Refactored some of the template value names

Fixed router config template values

ziti/cmd/ziti/cmd/config_templates/controller.yml

@@ -1,7 +1,7 @@
 v: 3
 
 #trace:
-#  path: "{{ .Controller.Rawname }}.trace"
+#  path: "{{ .Controller.Name }}.trace"
 
 #profile:
 #  memory:
@@ -71,11 +71,11 @@ edge:
     # sessionTimeout - optional, default 10m
     # The number of minutes before an Edge API session will time out. Timeouts are reset by
     # API requests and connections that are maintained to Edge Routers
-    sessionTimeout: {{ .Controller.EdgeAPISessionTimeoutMinutes }}m
+    sessionTimeout: {{ .Controller.Edge.APISessionTimeoutMinutes }}m
     # address - required
     # The default address (host:port) to use for enrollment for the Client API. This value must match one of the addresses
     # defined in this Controller.WebListener.'s bindPoints.
-    address: {{ .Controller.EdgeCtrlAdvertised }}
+    address: {{ .Controller.Edge.AdvertisedHostPort }}
   # This section is used to define option that are used during enrollment of Edge Routers, Ziti Edge Identities.
   enrollment:
     # signingCert - required
@@ -115,18 +115,18 @@ web:
     bindPoints:
       #interface - required
       # A host:port string on which network interface to listen on. 0.0.0.0 will listen on all interfaces
-      - interface: {{ .Controller.EdgeCtrlListenerHostPort }}
+      - interface: {{ .Controller.Edge.ListenerHostPort }}
         # address - required
         # The public address that external incoming requests will be able to resolve. Used in request processing and
         # response content that requires full host:port/path addresses.
-        address: {{ .Controller.EdgeCtrlAdvertised }}
+        address: {{ .Controller.Edge.AdvertisedHostPort }}
     # identity - optional
     # Allows the webListener to have a specific identity instead of defaulting to the root 'identity' section.
     identity:
-      ca:          "{{ .Controller.IdentityCA }}"
-      key:         "{{ .Controller.IdentityKey }}"
-      server_cert: "{{ .Controller.IdentityServerCert }}"
-      cert:        "{{ .Controller.IdentityCert }}"
+      ca:          "{{ .Controller.Edge.IdentityCA }}"
+      key:         "{{ .Controller.Edge.IdentityKey }}"
+      server_cert: "{{ .Controller.Edge.IdentityServerCert }}"
+      cert:        "{{ .Controller.Edge.IdentityCert }}"
     # options - optional
     # Allows the specification of webListener level options - mainly dealing with HTTP/TLS settings. These options are
     # used for all http servers started by the current webListener.

ziti/cmd/ziti/cmd/config_templates/router.yml

@@ -8,13 +8,13 @@
 v: 3
 
 identity:
-  cert:                 "{{ .ZitiPKI }}/certs/{{ .Router.Name }}-client.cert"
-  server_cert:          "{{ .ZitiPKI }}/certs/{{ .Router.Name }}-server.cert"
-  key:                  "{{ .ZitiPKI }}/keys/{{ .Router.Name }}-server.key"
-  ca:                   "{{ .ZitiPKI }}/certs/{{ .Router.Name }}-cas.cert"
+  cert:                 "{{ .Controller.IdentityCert }}"
+  server_cert:          "{{ .Controller.IdentityServerCert }}"
+  key:                  "{{ .Controller.IdentityKey }}"
+  ca:                   "{{ .Controller.IdentityCA }}"
 
 ctrl:
-  endpoint:             tls:{{ .Controller.Hostname }}:{{ .Controller.FabCtrlPort }}
+  endpoint:             tls:{{ .Controller.ListenerHostPort }}
 
 link:
 {{ if .Router.IsPrivate }}#{{ end }}  listeners:
@@ -79,8 +79,8 @@ edge:
 {{ if not .Router.IsWss }}#{{ end }}    readBufferSize: {{ .Router.Wss.ReadBufferSize }}
 {{ if not .Router.IsWss }}#{{ end }}    writeBufferSize: {{ .Router.Wss.WriteBufferSize }}
 {{ if not .Router.IsWss }}#{{ end }}    enableCompression: true
-{{ if not .Router.IsWss }}#{{ end }}    server_cert: {{ .ZitiPKI }}/certs/{{ .Router.Name }}-router-server.cert
-{{ if not .Router.IsWss }}#{{ end }}    key: {{ .ZitiPKI }}/keys/{{ .Router.Name }}-router-server.key
+{{ if not .Router.IsWss }}#{{ end }}    server_cert: {{ .ZitiHome }}/certs/{{ .Router.Name }}-router-server.cert
+{{ if not .Router.IsWss }}#{{ end }}    key: {{ .ZitiHome }}/keys/{{ .Router.Name }}-router-server.key
 
 forwarder:
   latencyProbeInterval: {{ .Router.Forwarder.LatencyProbeInterval }}

ziti/cmd/ziti/cmd/create_config.go

@@ -54,19 +54,26 @@ type ConfigTemplateValues struct {
 }
 
 type ControllerTemplateValues struct {
-	Hostname                     string
-	EdgeCtrlListenerHostPort     string
-	EdgeCtrlAdvertised           string
-	ListenerHostPort             string
-	MgmtListenerHostPort         string
-	Rawname                      string
-	EdgeAPISessionTimeoutMinutes int
-	IdentityCert                 string
-	IdentityServerCert           string
-	IdentityKey                  string
-	IdentityCA                   string
-	WebListener                  ControllerWebListenerValues
-	HealthCheck                  ControllerHealthCheckValues
+	Name                 string
+	ListenerHostPort     string
+	MgmtListenerHostPort string
+	IdentityCert         string
+	IdentityServerCert   string
+	IdentityKey          string
+	IdentityCA           string
+	Edge                 EdgeControllerValues
+	WebListener          ControllerWebListenerValues
+	HealthCheck          ControllerHealthCheckValues
+}
+
+type EdgeControllerValues struct {
+	APISessionTimeoutMinutes int
+	ListenerHostPort         string
+	AdvertisedHostPort       string
+	IdentityCert             string
+	IdentityServerCert       string
+	IdentityKey              string
+	IdentityCA               string
 }
 
 type ControllerWebListenerValues struct {
@@ -157,20 +164,26 @@ func NewCmdCreateConfig() *cobra.Command {
 		"%-36s %s\n"+
 		"%-36s %s\n"+
 		"%-36s %s\n"+
+		"%-36s %s\n"+
+		"%-36s %s\n"+
+		"%-36s %s\n"+
 		"%-36s %s",
 		cmdhelper.ZitiHomeVarName, templateData.ZitiHome,
 		cmdhelper.ZitiCtrlListenerHostPortVarName, templateData.Controller.ListenerHostPort,
 		cmdhelper.ZitiCtrlMgmtListenerHostPortVarName, templateData.Controller.MgmtListenerHostPort,
-		cmdhelper.ZitiCtrlHostnameVarName, templateData.Controller.Hostname,
-		cmdhelper.ZitiCtrlRawnameVarName, templateData.Controller.Rawname,
-		cmdhelper.ZitiEdgeCtrlListenerHostPortVarName, templateData.Controller.EdgeCtrlListenerHostPort,
-		cmdhelper.ZitiEdgeCtrlAdvertisedVarName, templateData.Controller.EdgeCtrlAdvertised,
+		cmdhelper.ZitiCtrlNameVarName, templateData.Controller.Name,
+		cmdhelper.ZitiEdgeCtrlListenerHostPortVarName, templateData.Controller.Edge.ListenerHostPort,
+		cmdhelper.ZitiEdgeCtrlAdvertisedHostPortVarName, templateData.Controller.Edge.AdvertisedHostPort,
 		cmdhelper.ZitiEdgeRouterHostnameVarName, templateData.Router.Edge.Hostname,
 		cmdhelper.ZitiEdgeRouterPortVarName, templateData.Router.Edge.Port,
 		cmdhelper.ZitiCtrlIdentityCertVarName, templateData.Controller.IdentityCert,
 		cmdhelper.ZitiCtrlIdentityServerCertVarName, templateData.Controller.IdentityServerCert,
 		cmdhelper.ZitiCtrlIdentityKeyVarName, templateData.Controller.IdentityKey,
 		cmdhelper.ZitiCtrlIdentityCAVarName, templateData.Controller.IdentityCA,
+		cmdhelper.ZitiEdgeCtrlIdentityCertVarName, templateData.Controller.Edge.IdentityCert,
+		cmdhelper.ZitiEdgeCtrlIdentityServerCertVarName, templateData.Controller.Edge.IdentityServerCert,
+		cmdhelper.ZitiEdgeCtrlIdentityKeyVarName, templateData.Controller.Edge.IdentityKey,
+		cmdhelper.ZitiEdgeCtrlIdentityCAVarName, templateData.Controller.Edge.IdentityCA,
 		cmdhelper.ZitiSigningCertVarName, templateData.ZitiSigningCert,
 		cmdhelper.ZitiSigningKeyVarName, templateData.ZitiSigningKey)
 
@@ -198,13 +211,9 @@ func (data *ConfigTemplateValues) populateEnvVars() {
 	zitiHome, err := cmdhelper.GetZitiHome()
 	handleVariableError(err, cmdhelper.ZitiHomeVarName)
 
-	// Get Ziti Controller Rawname
-	zitiCtrlRawname, err := cmdhelper.GetZitiCtrlRawname()
-	handleVariableError(err, cmdhelper.ZitiCtrlRawnameVarName)
-
-	// Get Ziti Controller Hostname
-	zitiCtrlHostname, err := cmdhelper.GetZitiCtrlHostname()
-	handleVariableError(err, cmdhelper.ZitiCtrlHostnameVarName)
+	// Get Ziti Controller Name
+	zitiCtrlHostname, err := cmdhelper.GetZitiCtrlName()
+	handleVariableError(err, cmdhelper.ZitiCtrlNameVarName)
 
 	// Get Ziti Edge Router Hostname
 	zitiEdgeRouterHostName, err := cmdhelper.GetZitiEdgeRouterHostname()
@@ -218,18 +227,34 @@ func (data *ConfigTemplateValues) populateEnvVars() {
 	zitiCtrlIdentityCert, err := cmdhelper.GetZitiIdentityCert()
 	handleVariableError(err, cmdhelper.ZitiCtrlIdentityCertVarName)
 
-	// Get Ziti Controller Identity Cert
+	// Get Ziti Controller Identity Server Cert
 	zitiCtrlIdentityServerCert, err := cmdhelper.GetZitiIdentityServerCert()
 	handleVariableError(err, cmdhelper.ZitiCtrlIdentityServerCertVarName)
 
-	// Get Ziti Controller Identity Cert
+	// Get Ziti Controller Identity Key
 	zitiCtrlIdentityKey, err := cmdhelper.GetZitiIdentityKey()
 	handleVariableError(err, cmdhelper.ZitiCtrlIdentityKeyVarName)
 
-	// Get Ziti Controller Identity Cert
+	// Get Ziti Controller Identity CA
 	zitiCtrlIdentityCA, err := cmdhelper.GetZitiIdentityCA()
 	handleVariableError(err, cmdhelper.ZitiCtrlIdentityCAVarName)
 
+	// Get Ziti Edge Controller Identity Cert
+	zitiEdgeCtrlIdentityCert, err := cmdhelper.GetZitiEdgeIdentityCert()
+	handleVariableError(err, cmdhelper.ZitiCtrlIdentityCertVarName)
+
+	// Get Ziti Edge Controller Identity Server Cert
+	zitiEdgeCtrlIdentityServerCert, err := cmdhelper.GetZitiEdgeIdentityServerCert()
+	handleVariableError(err, cmdhelper.ZitiCtrlIdentityServerCertVarName)
+
+	// Get Ziti Edge Controller Identity Key
+	zitiEdgeCtrlIdentityKey, err := cmdhelper.GetZitiEdgeIdentityKey()
+	handleVariableError(err, cmdhelper.ZitiCtrlIdentityKeyVarName)
+
+	// Get Ziti Edge Controller Identity CA
+	zitiEdgeCtrlIdentityCA, err := cmdhelper.GetZitiEdgeIdentityCA()
+	handleVariableError(err, cmdhelper.ZitiCtrlIdentityCAVarName)
+
 	// Get Ziti Controller Listener Host and Port
 	zitiCtrlListenerHostPort, err := cmdhelper.GetZitiCtrlListenerHostPort()
 	handleVariableError(err, cmdhelper.ZitiCtrlListenerHostPortVarName)
@@ -251,24 +276,27 @@ func (data *ConfigTemplateValues) populateEnvVars() {
 	handleVariableError(err, cmdhelper.ZitiEdgeCtrlListenerHostPortVarName)
 
 	// Get Ziti Edge Controller Advertised Host and Port
-	zitiEdgeCtrlAdvertised, err := cmdhelper.GetZitiEdgeCtrlAdvertised()
-	handleVariableError(err, cmdhelper.ZitiEdgeCtrlAdvertisedVarName)
+	zitiEdgeCtrlAdvertisedHostPort, err := cmdhelper.GetZitiEdgeCtrlAdvertisedHostPort()
+	handleVariableError(err, cmdhelper.ZitiEdgeCtrlAdvertisedHostPortVarName)
 
 	// data.ZitiPKI = zitiPKI
 	data.ZitiHome = zitiHome
 	data.Hostname = hostname
 	data.ZitiSigningCert = zitiSigningCert
 	data.ZitiSigningKey = zitiSigningKey
-	data.Controller.Rawname = zitiCtrlRawname
-	data.Controller.Hostname = zitiCtrlHostname
+	data.Controller.Name = zitiCtrlHostname
 	data.Controller.ListenerHostPort = zitiCtrlListenerHostPort
 	data.Controller.MgmtListenerHostPort = zitiCtrlMgmtListenerHostPort
-	data.Controller.EdgeCtrlListenerHostPort = zitiEdgeCtrlListenerHostPort
-	data.Controller.EdgeCtrlAdvertised = zitiEdgeCtrlAdvertised
+	data.Controller.Edge.ListenerHostPort = zitiEdgeCtrlListenerHostPort
+	data.Controller.Edge.AdvertisedHostPort = zitiEdgeCtrlAdvertisedHostPort
 	data.Controller.IdentityCert = zitiCtrlIdentityCert
 	data.Controller.IdentityServerCert = zitiCtrlIdentityServerCert
 	data.Controller.IdentityKey = zitiCtrlIdentityKey
 	data.Controller.IdentityCA = zitiCtrlIdentityCA
+	data.Controller.Edge.IdentityCert = zitiEdgeCtrlIdentityCert
+	data.Controller.Edge.IdentityServerCert = zitiEdgeCtrlIdentityServerCert
+	data.Controller.Edge.IdentityKey = zitiEdgeCtrlIdentityKey
+	data.Controller.Edge.IdentityCA = zitiEdgeCtrlIdentityCA
 	data.Router.Edge.Hostname = zitiEdgeRouterHostName
 	data.Router.Edge.Port = zitiEdgeRouterPort
 }
@@ -278,7 +306,7 @@ func (data *ConfigTemplateValues) populateDefaults() {
 	data.Router.Listener.OutQueueSize = constants.DefaultOutQueueSize
 	data.Router.Listener.ConnectTimeoutMs = constants.DefaultConnectTimeoutMs
 	data.Router.Listener.GetSessionTimeoutS = constants.DefaultGetSessionTimeoutS
-	data.Controller.EdgeAPISessionTimeoutMinutes = constants.DefaultEdgeAPISessionTimeoutMinutes
+	data.Controller.Edge.APISessionTimeoutMinutes = constants.DefaultEdgeAPISessionTimeoutMinutes
 	data.Controller.WebListener.IdleTimeoutMS = constants.DefaultWebListenerIdleTimeoutMs
 	data.Controller.WebListener.ReadTimeoutMS = constants.DefaultWebListenerReadTimeoutMs
 	data.Controller.WebListener.WriteTimeoutMS = constants.DefaultWebListenerWriteTimeoutMs

ziti/cmd/ziti/cmd/helpers/env_helpers.go

@@ -29,21 +29,27 @@ const (
 
 	ZitiHomeVarName = "ZITI_HOME"
 
-	ZitiCtrlHostnameVarName = "ZITI_CONTROLLER_HOSTNAME"
-
-	ZitiCtrlRawnameVarName = "ZITI_CONTROLLER_RAWNAME"
+	ZitiCtrlNameVarName = "ZITI_CONTROLLER_NAME"
 
 	ZitiEdgeRouterHostnameVarName = "ZITI_EDGE_ROUTER_HOSTNAME"
 
 	ZitiEdgeRouterPortVarName = "ZITI_EDGE_ROUTER_PORT"
 
-	ZitiCtrlIdentityCertVarName = "ZITI_EDGE_CTRL_IDENTITY_CERT"
+	ZitiEdgeCtrlIdentityCertVarName = "ZITI_EDGE_CTRL_IDENTITY_CERT"
 
-	ZitiCtrlIdentityServerCertVarName = "ZITI_EDGE_CTRL_IDENTITY_SERVER_CERT"
+	ZitiEdgeCtrlIdentityServerCertVarName = "ZITI_EDGE_CTRL_IDENTITY_SERVER_CERT"
 
-	ZitiCtrlIdentityKeyVarName = "ZITI_EDGE_CTRL_IDENTITY_KEY"
+	ZitiEdgeCtrlIdentityKeyVarName = "ZITI_EDGE_CTRL_IDENTITY_KEY"
 
-	ZitiCtrlIdentityCAVarName = "ZITI_EDGE_CTRL_IDENTITY_CA"
+	ZitiEdgeCtrlIdentityCAVarName = "ZITI_EDGE_CTRL_IDENTITY_CA"
+
+	ZitiCtrlIdentityCertVarName = "ZITI_CTRL_IDENTITY_CERT"
+
+	ZitiCtrlIdentityServerCertVarName = "ZITI_CTRL_IDENTITY_SERVER_CERT"
+
+	ZitiCtrlIdentityKeyVarName = "ZITI_CTRL_IDENTITY_KEY"
+
+	ZitiCtrlIdentityCAVarName = "ZITI_CTRL_IDENTITY_CA"
 
 	ZitiSigningCertVarName = "ZITI_SIGNING_CERT"
 
@@ -55,7 +61,7 @@ const (
 
 	ZitiEdgeCtrlListenerHostPortVarName = "ZITI_CTRL_EDGE_LISTENER_HOST_PORT"
 
-	ZitiEdgeCtrlAdvertisedVarName = "ZITI_EDGE_CTRL_ADVERTISED"
+	ZitiEdgeCtrlAdvertisedHostPortVarName = "ZITI_EDGE_CTRL_ADVERTISED_HOST_PORT"
 )
 
 func HomeDir() string {
@@ -82,72 +88,159 @@ func GetZitiHome() (string, error) {
 
 	// Get path from env variable
 	retVal := os.Getenv(ZitiHomeVarName)
-	if retVal != "" {
-		return retVal, nil
+
+	if retVal == "" {
+		// If not set, create a default path of the current working directory
+		workingDir, err := WorkingDir()
+		if err != nil {
+			return "", err
+		}
+
+		err = os.Setenv(ZitiHomeVarName, workingDir)
+		if err != nil {
+			return "", err
+		}
+
+		retVal = os.Getenv(ZitiHomeVarName)
 	}
 
-	// If not set, create a default path of the current working directory
+	return strings.ReplaceAll(retVal, "\\", PathSeparator), nil
+}
+
+func GetZitiIdentityCert() (string, error) {
 	workingDir, err := WorkingDir()
 	if err != nil {
 		return "", err
 	}
 
-	err = os.Setenv(ZitiHomeVarName, workingDir)
+	controllerName, err := GetZitiCtrlName()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return getOrSetEnvVar(ZitiCtrlIdentityCertVarName, fmt.Sprintf("%s/%s-client.cert", workingDir, controllerName))
+}
+
+func GetZitiIdentityServerCert() (string, error) {
+	workingDir, err := WorkingDir()
 	if err != nil {
 		return "", err
 	}
 
-	retVal = os.Getenv(ZitiHomeVarName)
-
-	return retVal, nil
-}
-
-func GetZitiIdentityCert() (string, error) {
-	hostName, err := os.Hostname()
+	controllerName, err := GetZitiCtrlName()
 	if err != nil {
-		err := errors.Wrap(err, "Unable to get hostname")
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
 		if err != nil {
 			return "", err
 		}
 	}
 
-	return getOrSetEnvVar(ZitiCtrlIdentityCertVarName, fmt.Sprintf("./%s-client.cert", hostName))
-}
-
-func GetZitiIdentityServerCert() (string, error) {
-	hostName, err := os.Hostname()
-	if err != nil {
-		err := errors.Wrap(err, "Unable to get hostname")
-		if err != nil {
-			return "", err
-		}
-	}
-
-	return getOrSetEnvVar(ZitiCtrlIdentityServerCertVarName, fmt.Sprintf("./%s-server.pem", hostName))
+	return getOrSetEnvVar(ZitiCtrlIdentityServerCertVarName, fmt.Sprintf("%s/%s-server.pem", workingDir, controllerName))
 }
 
 func GetZitiIdentityKey() (string, error) {
-	hostName, err := os.Hostname()
+	workingDir, err := WorkingDir()
 	if err != nil {
-		err := errors.Wrap(err, "Unable to get hostname")
+		return "", err
+	}
+
+	controllerName, err := GetZitiCtrlName()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
 		if err != nil {
 			return "", err
 		}
 	}
 
-	return getOrSetEnvVar(ZitiCtrlIdentityKeyVarName, fmt.Sprintf("./%s-server.key", hostName))
+	return getOrSetEnvVar(ZitiCtrlIdentityKeyVarName, fmt.Sprintf("%s/%s-server.key", workingDir, controllerName))
 }
 
 func GetZitiIdentityCA() (string, error) {
-	hostName, err := os.Hostname()
+	workingDir, err := WorkingDir()
 	if err != nil {
-		err := errors.Wrap(err, "Unable to get hostname")
+		return "", err
+	}
+
+	controllerName, err := GetZitiCtrlName()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
 		if err != nil {
 			return "", err
 		}
 	}
 
-	return getOrSetEnvVar(ZitiCtrlIdentityCAVarName, fmt.Sprintf("./%s-cas.pem", hostName))
+	return getOrSetEnvVar(ZitiCtrlIdentityCAVarName, fmt.Sprintf("%s/%s-cas.pem", workingDir, controllerName))
+}
+
+func GetZitiEdgeIdentityCert() (string, error) {
+	workingDir, err := WorkingDir()
+	if err != nil {
+		return "", err
+	}
+
+	controllerName, err := GetZitiCtrlName()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return getOrSetEnvVar(ZitiEdgeCtrlIdentityCertVarName, fmt.Sprintf("%s/%s-client.cert", workingDir, controllerName))
+}
+
+func GetZitiEdgeIdentityServerCert() (string, error) {
+	workingDir, err := WorkingDir()
+	if err != nil {
+		return "", err
+	}
+
+	controllerName, err := GetZitiCtrlName()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return getOrSetEnvVar(ZitiEdgeCtrlIdentityServerCertVarName, fmt.Sprintf("%s/%s-server.pem", workingDir, controllerName))
+}
+
+func GetZitiEdgeIdentityKey() (string, error) {
+	workingDir, err := WorkingDir()
+	if err != nil {
+		return "", err
+	}
+
+	controllerName, err := GetZitiCtrlName()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return getOrSetEnvVar(ZitiEdgeCtrlIdentityKeyVarName, fmt.Sprintf("%s/%s-server.key", workingDir, controllerName))
+}
+
+func GetZitiEdgeIdentityCA() (string, error) {
+	workingDir, err := WorkingDir()
+	if err != nil {
+		return "", err
+	}
+
+	controllerName, err := GetZitiCtrlName()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiCtrlNameVarName)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return getOrSetEnvVar(ZitiEdgeCtrlIdentityCAVarName, fmt.Sprintf("%s/%s-cas.pem", workingDir, controllerName))
 }
 
 func GetZitiCtrlListenerHostPort() (string, error) {
@@ -158,29 +251,8 @@ func GetZitiCtrlMgmtListenerHostPort() (string, error) {
 	return getOrSetEnvVar(ZitiCtrlMgmtListenerHostPortVarName, constants.DefaultZitiMgmtControllerListenerHostPort)
 }
 
-func GetZitiCtrlHostname() (string, error) {
-	hostname, err := os.Hostname()
-	if err != nil {
-		err := errors.Wrap(err, "Unable to get hostname")
-		if err != nil {
-			return "", err
-		}
-	}
-
-	return getOrSetEnvVar(ZitiCtrlHostnameVarName, hostname)
-}
-
-func GetZitiCtrlRawname() (string, error) {
-	hostname, err := os.Hostname()
-	if err != nil {
-		err := errors.Wrap(err, "Unable to get hostname")
-		if err != nil {
-			return "", err
-		}
-	}
-
-	defaultZitiCtrlRawName := hostname + "-controller"
-	return getOrSetEnvVar(ZitiCtrlRawnameVarName, defaultZitiCtrlRawName)
+func GetZitiCtrlName() (string, error) {
+	return getOrSetEnvVar(ZitiCtrlNameVarName, constants.DefaultZitiControllerName)
 }
 
 func GetZitiEdgeRouterHostname() (string, error) {
@@ -199,19 +271,37 @@ func GetZitiEdgeRouterPort() (string, error) {
 }
 
 func GetZitiSigningCert() (string, error) {
-	return getOrSetEnvVar(ZitiSigningCertVarName, "./signingCert.cert")
+	workingDir, err := WorkingDir()
+	if err != nil {
+		return "", err
+	}
+
+	return getOrSetEnvVar(ZitiSigningCertVarName, fmt.Sprintf("%s/signingCert.cert", workingDir))
 }
 
 func GetZitiSigningKey() (string, error) {
-	return getOrSetEnvVar(ZitiSigningKeyVarName, "./signingKey.key")
+	workingDir, err := WorkingDir()
+	if err != nil {
+		return "", err
+	}
+
+	return getOrSetEnvVar(ZitiSigningKeyVarName, fmt.Sprintf("%s/signingKey.key", workingDir))
 }
 
 func GetZitiEdgeCtrlListenerHostPort() (string, error) {
 	return getOrSetEnvVar(ZitiEdgeCtrlListenerHostPortVarName, constants.DefaultZitiEdgeListenerHostPort)
 }
 
-func GetZitiEdgeCtrlAdvertised() (string, error) {
-	return getOrSetEnvVar(ZitiEdgeCtrlAdvertisedVarName, "")
+func GetZitiEdgeCtrlAdvertisedHostPort() (string, error) {
+	edgeCtrlListenerHostPort, err := GetZitiEdgeCtrlListenerHostPort()
+	if err != nil {
+		err := errors.Wrap(err, "Unable to get "+ZitiEdgeCtrlListenerHostPortVarName)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return getOrSetEnvVar(ZitiEdgeCtrlAdvertisedHostPortVarName, edgeCtrlListenerHostPort)
 }
 
 func getOrSetEnvVar(envVarName string, defaultValue string) (string, error) {

ziti/cmd/ziti/constants/constants.go

@@ -44,6 +44,7 @@ const (
 	DefaultZitiEdgeRouterPort = "3022"
 
 	// Controller defaults
+	DefaultZitiControllerName                 = "controller"
 	DefaultEdgeAPISessionTimeoutMinutes       = 30
 	DefaultWebListenerIdleTimeoutMs           = 5000
 	DefaultWebListenerReadTimeoutMs           = 5000