refactor: encapsulate metadata in a struct

Makefile

@@ -28,11 +28,11 @@ LDFLAGS_COMMON ?= -extldflags=-Wl,-ld_classic
 endif
 
 LDFLAGS_METADATA ?= \
-	-X $(REPO)/modules/manager/metadata.ProjectName=$(REPO_NAME) \
-	-X $(REPO)/modules/manager/metadata.Release=$(TAG) \
-	-X $(REPO)/modules/manager/metadata.Commit=$(COMMIT) \
-	-X $(REPO)/modules/manager/metadata.Repo=$(REPO_INFO) \
-	-X $(REPO)/modules/manager/metadata.RepoURL=$(REPO_URL)
+	-X $(REPO)/modules/manager/metadata.projectName=$(REPO_NAME) \
+	-X $(REPO)/modules/manager/metadata.release=$(TAG) \
+	-X $(REPO)/modules/manager/metadata.commit=$(COMMIT) \
+	-X $(REPO)/modules/manager/metadata.repo=$(REPO_INFO) \
+	-X $(REPO)/modules/manager/metadata.repoURL=$(REPO_URL)
 
 # ------------------------------------------------------------------------------
 # Configuration - Tooling

cmd/main.go

@@ -25,16 +25,19 @@ import (
 	"github.com/kong/gateway-operator/modules/admission"
 	"github.com/kong/gateway-operator/modules/cli"
 	"github.com/kong/gateway-operator/modules/manager"
+	"github.com/kong/gateway-operator/modules/manager/metadata"
 	"github.com/kong/gateway-operator/modules/manager/scheme"
 )
 
 func main() {
-	cli := cli.New()
+	m := metadata.Metadata()
+
+	cli := cli.New(m)
 	cfg := cli.Parse(os.Args[1:])
 
 	ctrl.SetLogger(zap.New(zap.UseFlagOptions(cfg.LoggerOpts)))
 
-	if err := manager.Run(cfg, scheme.Get(), manager.SetupControllersShim, admission.NewRequestHandler, nil); err != nil {
+	if err := manager.Run(cfg, scheme.Get(), manager.SetupControllersShim, admission.NewRequestHandler, nil, m); err != nil {
 		ctrl.Log.Error(err, "failed to run manager")
 		os.Exit(1)
 	}

modules/cli/cli.go

@@ -16,7 +16,7 @@ import (
 )
 
 // New returns a new CLI.
-func New() *CLI {
+func New(m metadata.Info) *CLI {
 	flagSet := flag.NewFlagSet("", flag.ExitOnError)
 
 	var cfg manager.Config
@@ -64,6 +64,7 @@ func New() *CLI {
 		cfg:             &cfg,
 		loggerOpts:      loggerOpts,
 		deferFlagValues: &deferCfg,
+		metadata:        m,
 	}
 }
 
@@ -76,6 +77,8 @@ type CLI struct {
 	// logic after parsing flagSet to determine desired configuration.
 	deferFlagValues *flagsForFurtherEvaluation
 	cfg             *manager.Config
+
+	metadata metadata.Info
 }
 
 type flagsForFurtherEvaluation struct {
@@ -113,6 +116,10 @@ func (c *CLI) bindEnvVarsToFlags() (err error) {
 	return err
 }
 
+func (c *CLI) Metadata() metadata.Info {
+	return c.metadata
+}
+
 // Parse parses flag definitions from the argument list, which should not include the command name.
 // Must be called after all additional flags in the FlagSet() are defined and before flags are accessed
 // by the program. It returns config for controller manager.
@@ -160,9 +167,9 @@ func (c *CLI) Parse(arguments []string) manager.Config {
 			Commit  string `json:"commit"`
 		}
 		out, err := json.Marshal(Version{
-			Release: metadata.Release,
-			Repo:    metadata.Repo,
-			Commit:  metadata.Commit,
+			Release: c.metadata.Release,
+			Repo:    c.metadata.Repo,
+			Commit:  c.metadata.Commit,
 		})
 		if err != nil {
 			fmt.Printf("ERROR: failed to print version information: %v\n", err)

modules/manager/metadata/metadata.go

@@ -8,22 +8,60 @@ package metadata
 // WARNING: moving any of these variables requires changes to both the Makefile
 //          and the Dockerfile which modify them during the link step with -X
 
+type Info struct {
+	// Release returns the release version, generally a semver like v1.0.0.
+	Release string
+
+	// Repo returns the git repository URL.
+	Repo string
+
+	// RepoURL returns the repository URL.
+	RepoURL string
+
+	// Commit returns the SHA from the current branch HEAD.
+	Commit string
+
+	// ProjectName is the name of the project.
+	ProjectName string
+
+	// Organization is the Kong organization
+	Organization string
+
+	// Flavor is the flavor of the build.
+	Flavor string
+}
+
 var (
 	// Release returns the release version, generally a semver like v1.0.0.
-	Release = "NOT_SET"
+	release = "NOT_SET"
 
 	// Repo returns the git repository URL.
-	Repo = "NOT_SET"
+	repo = "NOT_SET"
 
 	// RepoURL returns the repository URL.
-	RepoURL = "NOT_SET"
+	repoURL = "NOT_SET"
 
 	// Commit returns the SHA from the current branch HEAD.
-	Commit = "NOT_SET"
+	commit = "NOT_SET"
 
 	// ProjectName is the name of the project.
-	ProjectName = "NOT_SET"
+	projectName = "NOT_SET"
 
 	// Organization is the Kong organization
-	Organization = "Kong"
+	organization = "Kong"
+
+	// Flavor is the flavor of the build.
+	flavor = "oss"
 )
+
+func Metadata() Info {
+	return Info{
+		Release:      release,
+		Repo:         repo,
+		RepoURL:      repoURL,
+		Commit:       commit,
+		ProjectName:  projectName,
+		Organization: organization,
+		Flavor:       flavor,
+	}
+}

modules/manager/run.go

@@ -132,6 +132,7 @@ func Run(
 	setupControllers SetupControllersFunc,
 	admissionRequestHandler AdmissionRequestHandlerFunc,
 	startedChan chan<- struct{},
+	metadata metadata.Info,
 ) error {
 	setupLog := ctrl.Log.WithName("setup")
 	setupLog.Info("starting controller manager",
@@ -243,7 +244,7 @@ func Run(
 	// Enable anonnymous reporting when configured but not for development builds
 	// to reduce the noise.
 	if cfg.AnonymousReports && !cfg.DevelopmentMode {
-		stopAnonymousReports, err := setupAnonymousReports(context.Background(), cfg, setupLog)
+		stopAnonymousReports, err := setupAnonymousReports(context.Background(), cfg, setupLog, metadata)
 		if err != nil {
 			setupLog.Error(err, "failed setting up anonymous reports")
 		} else {
@@ -368,18 +369,19 @@ func getKubeconfig(apiServerPath string, kubeconfig string) (*rest.Config, error
 // a cleanup function and an error.
 // The caller is responsible to call the returned function - when the returned
 // error is not nil - to stop the reports sending.
-func setupAnonymousReports(ctx context.Context, cfg Config, logger logr.Logger) (func(), error) {
+func setupAnonymousReports(ctx context.Context, cfg Config, logger logr.Logger, metadata metadata.Info) (func(), error) {
 	logger.Info("starting anonymous reports")
 	restConfig, err := getKubeconfig(cfg.APIServerPath, cfg.KubeconfigPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get kubeconfig: %w", err)
 	}
 
-	telemetryPayload := telemetry.Payload{
-		"v": metadata.Release,
+	payload := telemetry.Payload{
+		"v":      metadata.Release,
+		"flavor": metadata.Flavor,
 	}
 
-	tMgr, err := telemetry.CreateManager(telemetry.SignalPing, restConfig, logger, telemetryPayload)
+	tMgr, err := telemetry.CreateManager(telemetry.SignalPing, restConfig, logger, payload)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create anonymous reports manager: %w", err)
 	}

test/conformance/conformance_test.go

@@ -109,6 +109,7 @@ func TestGatewayConformance(t *testing.T) {
 	// Currently mode only relies on the KongRouterFlavor, but in the future
 	// we may want to add more modes.
 	mode := string(config.KongRouterFlavor)
+	metadata := metadata.Metadata()
 	reportFileName := fmt.Sprintf("standard-%s-%s-report.yaml", metadata.Release, mode)
 
 	opts := conformance.DefaultOptions(t)

test/conformance/suite_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/kong/gateway-operator/config"
 	"github.com/kong/gateway-operator/modules/admission"
 	"github.com/kong/gateway-operator/modules/manager"
+	"github.com/kong/gateway-operator/modules/manager/metadata"
 	"github.com/kong/gateway-operator/modules/manager/scheme"
 	testutils "github.com/kong/gateway-operator/pkg/utils/test"
 	"github.com/kong/gateway-operator/test"
@@ -113,7 +114,8 @@ func TestMain(m *testing.M) {
 	fmt.Println("INFO: starting the operator's controller manager")
 	// startControllerManager will spawn the controller manager in a separate
 	// goroutine and will report whether that succeeded.
-	started := startControllerManager()
+	metadata := metadata.Metadata()
+	started := startControllerManager(metadata)
 	<-started
 
 	exitOnErr(testutils.BuildMTLSCredentials(ctx, clients.K8sClient, &httpc))
@@ -160,7 +162,7 @@ func exitOnErr(err error) {
 
 // startControllerManager will configure the manager and start it in a separate goroutine.
 // It returns a channel which will get closed when manager.Start() gets called.
-func startControllerManager() <-chan struct{} {
+func startControllerManager(metadata metadata.Info) <-chan struct{} {
 	cfg := manager.DefaultConfig()
 	cfg.LeaderElection = false
 	cfg.DevelopmentMode = true
@@ -182,7 +184,7 @@ func startControllerManager() <-chan struct{} {
 
 	startedChan := make(chan struct{})
 	go func() {
-		exitOnErr(manager.Run(cfg, scheme.Get(), manager.SetupControllersShim, admission.NewRequestHandler, startedChan))
+		exitOnErr(manager.Run(cfg, scheme.Get(), manager.SetupControllersShim, admission.NewRequestHandler, startedChan, metadata))
 	}()
 
 	return startedChan

test/integration/run_integration_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/kong/gateway-operator/modules/admission"
 	"github.com/kong/gateway-operator/modules/manager"
+	"github.com/kong/gateway-operator/modules/manager/metadata"
 	"github.com/kong/gateway-operator/modules/manager/scheme"
 	"github.com/kong/gateway-operator/pkg/consts"
 	"github.com/kong/gateway-operator/test/helpers"
@@ -22,8 +23,10 @@ func TestMain(m *testing.M) {
 
 	testSuiteToRun = helpers.ParseGoTestFlags(TestIntegration, testSuiteToRun)
 	cfg := integration.DefaultControllerConfigForTests()
+
+	metadata := metadata.Metadata()
 	managerToTest := func(startedChan chan struct{}) error {
-		return manager.Run(cfg, scheme.Get(), manager.SetupControllersShim, admission.NewRequestHandler, startedChan)
+		return manager.Run(cfg, scheme.Get(), manager.SetupControllersShim, admission.NewRequestHandler, startedChan, metadata)
 	}
 	integration.TestMain(
 		m,