Use Pod UID for install ID and always send deploy ctx

Author: Kate Osborn

charts/nginx-gateway-fabric/templates/deployment.yaml

@@ -58,6 +58,10 @@ spec:
             valueFrom:
               fieldRef:
                 fieldPath: metadata.name
+          - name: POD_UID
+            valueFrom:
+              fieldRef:
+                fieldPath: metadata.uid
         securityContext:
           seccompProfile:
             type: RuntimeDefault
@@ -142,6 +146,10 @@ spec:
           valueFrom:
             fieldRef:
               fieldPath: metadata.name
+        - name: POD_UID
+          valueFrom:
+            fieldRef:
+              fieldPath: metadata.uid
         image: {{ .Values.nginxGateway.image.repository }}:{{ default .Chart.AppVersion .Values.nginxGateway.image.tag }}
         imagePullPolicy: {{ .Values.nginxGateway.image.pullPolicy }}
         name: nginx-gateway

cmd/gateway/commands.go

@@ -23,6 +23,7 @@ import (
 	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static"
 	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/config"
 	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/licensing"
+	ngxConfig "github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/nginx/config"
 	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/nginx/file"
 )
 
@@ -161,16 +162,6 @@ func createStaticModeCommand() *cobra.Command {
 				return fmt.Errorf("error validating ports: %w", err)
 			}
 
-			podIP := os.Getenv("POD_IP")
-			if err := validateIP(podIP); err != nil {
-				return fmt.Errorf("error validating POD_IP environment variable: %w", err)
-			}
-
-			podNsName, err := getPodNsName()
-			if err != nil {
-				return fmt.Errorf("could not get pod namespaced name: %w", err)
-			}
-
 			imageSource := os.Getenv("BUILD_AGENT")
 			if imageSource != "gha" && imageSource != "local" {
 				imageSource = "unknown"
@@ -215,6 +206,11 @@ func createStaticModeCommand() *cobra.Command {
 
 			flagKeys, flagValues := parseFlags(cmd.Flags())
 
+			podConfig, err := createGatewayPodConfig(serviceName.value)
+			if err != nil {
+				return fmt.Errorf("error creating gateway pod config: %w", err)
+			}
+
 			conf := config.Config{
 				GatewayCtlrName:          gatewayCtlrName.value,
 				ConfigName:               configName.String(),
@@ -223,12 +219,7 @@ func createStaticModeCommand() *cobra.Command {
 				GatewayClassName:         gatewayClassName.value,
 				GatewayNsName:            gwNsName,
 				UpdateGatewayClassStatus: updateGCStatus,
-				GatewayPodConfig: config.GatewayPodConfig{
-					PodIP:       podIP,
-					ServiceName: serviceName.value,
-					Namespace:   podNsName.Namespace,
-					Name:        podNsName.Name,
-				},
+				GatewayPodConfig:         podConfig,
 				HealthConfig: config.HealthConfig{
 					Enabled: !disableHealth,
 					Port:    healthListenPort.value,
@@ -241,7 +232,7 @@ func createStaticModeCommand() *cobra.Command {
 				LeaderElection: config.LeaderElectionConfig{
 					Enabled:  !disableLeaderElection,
 					LockName: leaderElectionLockName.String(),
-					Identity: podNsName.Name,
+					Identity: podConfig.Name,
 				},
 				UsageReportConfig: usageReportConfig,
 				ProductTelemetryConfig: config.ProductTelemetryConfig{
@@ -539,9 +530,9 @@ func createInitializeCommand() *cobra.Command {
 				return err
 			}
 
-			podNsName, err := getPodNsName()
+			podUID, err := getValueFromEnv("POD_UID")
 			if err != nil {
-				return fmt.Errorf("could not get pod namespaced name: %w", err)
+				return fmt.Errorf("could not get pod UID: %w", err)
 			}
 
 			clusterCfg := ctlr.GetConfigOrDie()
@@ -563,15 +554,16 @@ func createInitializeCommand() *cobra.Command {
 
 			dcc := licensing.NewDeploymentContextCollector(licensing.DeploymentContextCollectorConfig{
 				K8sClientReader: k8sReader,
-				PodNSName:       podNsName,
+				PodUID:          podUID,
 				Logger:          logger.WithName("deployCtxCollector"),
 			})
 
 			return initialize(initializeConfig{
-				fileManager: file.NewStdLibOSFileManager(),
-				logger:      logger,
-				plus:        plus,
-				collector:   dcc,
+				fileManager:   file.NewStdLibOSFileManager(),
+				fileGenerator: ngxConfig.NewGeneratorImpl(plus, nil, logger.WithName("generator")),
+				logger:        logger,
+				plus:          plus,
+				collector:     dcc,
 				copy: copyFiles{
 					srcFileNames: srcFiles,
 					destDirName:  dest,
@@ -652,16 +644,43 @@ func getBuildInfo() (commitHash string, commitTime string, dirtyBuild string) {
 	return
 }
 
-func getPodNsName() (types.NamespacedName, error) {
-	namespace := os.Getenv("POD_NAMESPACE")
-	if namespace == "" {
-		return types.NamespacedName{}, errors.New("POD_NAMESPACE environment variable must be set")
+func createGatewayPodConfig(svcName string) (config.GatewayPodConfig, error) {
+	podIP, err := getValueFromEnv("POD_IP")
+	if err != nil {
+		return config.GatewayPodConfig{}, err
 	}
 
-	podName := os.Getenv("POD_NAME")
-	if podName == "" {
-		return types.NamespacedName{}, errors.New("POD_NAME environment variable must be set")
+	podUID, err := getValueFromEnv("POD_UID")
+	if err != nil {
+		return config.GatewayPodConfig{}, err
+	}
+
+	ns, err := getValueFromEnv("POD_NAMESPACE")
+	if err != nil {
+		return config.GatewayPodConfig{}, err
+	}
+
+	name, err := getValueFromEnv("POD_NAME")
+	if err != nil {
+		return config.GatewayPodConfig{}, err
+	}
+
+	c := config.GatewayPodConfig{
+		PodIP:       podIP,
+		ServiceName: svcName,
+		Namespace:   ns,
+		Name:        name,
+		UID:         podUID,
+	}
+
+	return c, nil
+}
+
+func getValueFromEnv(key string) (string, error) {
+	val := os.Getenv(key)
+	if val == "" {
+		return "", fmt.Errorf("environment variable %s not set", key)
 	}
 
-	return types.NamespacedName{Namespace: namespace, Name: podName}, nil
+	return val, nil
 }

cmd/gateway/commands_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"io"
 	"os"
 	"testing"
@@ -9,6 +10,8 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"k8s.io/apimachinery/pkg/types"
+
+	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/config"
 )
 
 type flagTestCase struct {
@@ -660,24 +663,49 @@ func TestGetBuildInfo(t *testing.T) {
 	g.Expect(dirtyBuild).To(Not(Equal("unknown")))
 }
 
-func TestGetPodNsName(t *testing.T) {
+func TestCreateGatewayPodConfig(t *testing.T) {
 	t.Parallel()
 	g := NewWithT(t)
 
+	// Order matters here
+	// We start with all env vars set
+	g.Expect(os.Setenv("POD_IP", "10.0.0.0")).To(Succeed())
+	g.Expect(os.Setenv("POD_UID", "1234")).To(Succeed())
 	g.Expect(os.Setenv("POD_NAMESPACE", "default")).To(Succeed())
 	g.Expect(os.Setenv("POD_NAME", "my-pod")).To(Succeed())
 
-	nsname, err := getPodNsName()
+	expCfg := config.GatewayPodConfig{
+		PodIP:       "10.0.0.0",
+		ServiceName: "svc",
+		Namespace:   "default",
+		Name:        "my-pod",
+		UID:         "1234",
+	}
+	cfg, err := createGatewayPodConfig("svc")
 	g.Expect(err).To(Not(HaveOccurred()))
-	g.Expect(nsname).To(Equal(types.NamespacedName{Name: "my-pod", Namespace: "default"}))
-
-	g.Expect(os.Unsetenv("POD_NAMESPACE")).To(Succeed())
-	nsname, err = getPodNsName()
-	g.Expect(err).To(HaveOccurred())
-	g.Expect(nsname).To(Equal(types.NamespacedName{}))
+	g.Expect(cfg).To(Equal(expCfg))
 
+	// unset name
 	g.Expect(os.Unsetenv("POD_NAME")).To(Succeed())
-	nsname, err = getPodNsName()
-	g.Expect(err).To(HaveOccurred())
-	g.Expect(nsname).To(Equal(types.NamespacedName{}))
+	cfg, err = createGatewayPodConfig("svc")
+	g.Expect(err).To(MatchError(errors.New("environment variable POD_NAME not set")))
+	g.Expect(cfg).To(Equal(config.GatewayPodConfig{}))
+
+	// unset namespace
+	g.Expect(os.Unsetenv("POD_NAMESPACE")).To(Succeed())
+	cfg, err = createGatewayPodConfig("svc")
+	g.Expect(err).To(MatchError(errors.New("environment variable POD_NAMESPACE not set")))
+	g.Expect(cfg).To(Equal(config.GatewayPodConfig{}))
+
+	// unset UUID
+	g.Expect(os.Unsetenv("POD_UID")).To(Succeed())
+	cfg, err = createGatewayPodConfig("svc")
+	g.Expect(err).To(MatchError(errors.New("environment variable POD_UID not set")))
+	g.Expect(cfg).To(Equal(config.GatewayPodConfig{}))
+
+	// unset IP
+	g.Expect(os.Unsetenv("POD_IP")).To(Succeed())
+	cfg, err = createGatewayPodConfig("svc")
+	g.Expect(err).To(MatchError(errors.New("environment variable POD_IP not set")))
+	g.Expect(cfg).To(Equal(config.GatewayPodConfig{}))
 }

cmd/gateway/initialize.go

@@ -11,7 +11,6 @@ import (
 	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/licensing"
 	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/nginx/config"
 	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/nginx/file"
-	"github.com/nginxinc/nginx-gateway-fabric/internal/mode/static/state/dataplane"
 )
 
 type copyFiles struct {
@@ -20,11 +19,12 @@ type copyFiles struct {
 }
 
 type initializeConfig struct {
-	collector   licensing.Collector
-	fileManager file.OSFileManager
-	logger      logr.Logger
-	copy        copyFiles
-	plus        bool
+	collector     licensing.Collector
+	fileManager   file.OSFileManager
+	fileGenerator config.Generator
+	logger        logr.Logger
+	copy          copyFiles
+	plus          bool
 }
 
 func initialize(cfg initializeConfig) error {
@@ -44,30 +44,22 @@ func initialize(cfg initializeConfig) error {
 
 	depCtx, err := cfg.collector.Collect(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to collect deployment context: %w", err)
+		cfg.logger.Error(err, "error collecting deployment context")
 	}
 
 	cfg.logger.Info("Deployment context collected", "deployment context", depCtx)
 
-	if err := writeDeploymentContextFile(cfg.fileManager, depCtx); err != nil {
-		return fmt.Errorf("failed to write deployment context file: %w", err)
-	}
-
-	cfg.logger.Info("Finished initializing configuration")
-
-	return nil
-}
-
-func writeDeploymentContextFile(osFileManager file.OSFileManager, depCtx dataplane.DeploymentContext) error {
-	depCtxFile, err := config.GenerateDeploymentContextFile(depCtx)
+	depCtxFile, err := cfg.fileGenerator.GenerateDeploymentContext(depCtx)
 	if err != nil {
 		return fmt.Errorf("failed to generate deployment context file: %w", err)
 	}
 
-	if err := file.WriteFile(osFileManager, depCtxFile); err != nil {
+	if err := file.WriteFile(cfg.fileManager, depCtxFile); err != nil {
 		return fmt.Errorf("failed to write deployment context file: %w", err)
 	}
 
+	cfg.logger.Info("Finished initializing configuration")
+
 	return nil
 }