Add binary version info

Make it easier to keep track of the version of sf-operator that was
used to deploy a resource.

* CLI: The `version` subcommand returns the version of the executable.
* Standalone mode: the "sf-standalone-owner" configmap has two new
  annotations: "sf-operator-version" with the version of the binary
  used to deploy, and "last-reconcile" with the EPOCH timestamp
  of the the end time of the deployment.
  The configmap's data also holds the latest "CR" that was applied.

Assisted-By: Gemini-2.5-pro

Change-Id: Ibe363403d57f299dda69f9fa3ad1ade7a7fdf464

Author: mhuin

Makefile

@@ -18,6 +18,8 @@ CATALOG_IMG ?= $(CATALOG_REPO):latest
 ENVTEST_K8S_VERSION = 1.29.0
 CERT_MANAGER_VERSION = v1.14.6
 
+LDFLAGS = -ldflags="-X github.com/softwarefactory-project/sf-operator/controllers/libs/utils.version=$(VERSION)"
+
 # Get the currently used golang install path (in GOPATH/bin, unless GOBIN is set)
 ifeq (,$(shell go env GOBIN))
 GOBIN=$(shell go env GOPATH)/bin
@@ -93,15 +95,15 @@ setenv:
 
 .PHONY: build
 build: setenv generate fmt vet sc build-api-doc ## Build manager binary.
-	go build -o bin/sf-operator main.go
+	go build $(LDFLAGS) -o bin/sf-operator main.go
 
 .PHONY: build-api-doc
 build-api-doc: # Build the API documentation.
 	./hack/build-api-doc.sh
 
 .PHONY: run
 run: manifests generate fmt vet ## Run a controller from your host.
-	go run main.go
+	go run $(LDFLAGS) main.go
 
 .PHONY: operator-build
 operator-build: ## Build podman image with the manager.

cli/cmd/version.go

@@ -0,0 +1,23 @@
+// Copyright (C) 2025 Red Hat
+// SPDX-License-Identifier: Apache-2.0
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/softwarefactory-project/sf-operator/controllers/libs/utils"
+	"github.com/spf13/cobra"
+)
+
+func MkVersionCmd() *cobra.Command {
+	var versionCmd = &cobra.Command{
+		Use:   "version",
+		Short: "Print the version number of sf-operator",
+		Long:  `All software has versions. This is sf-operator's`,
+		Run: func(cmd *cobra.Command, args []string) {
+			fmt.Println(utils.GetVersion())
+		},
+	}
+	return versionCmd
+}

controllers/libs/utils/version.go

@@ -0,0 +1,34 @@
+// Copyright (C) 2025 Red Hat
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import (
+	"os/exec"
+	"strings"
+)
+
+// version is a variable that will be set at build time
+var version string
+
+// GetVersion returns the latest tag known to git.
+// If it doesn't work, try to get the current commit hash.
+// If it doesn't work, return "development".
+func GetVersion() string {
+	if version != "" {
+		return version
+	}
+	cmd := exec.Command("git", "describe", "--tags")
+	out, err := cmd.Output()
+	if err == nil {
+		return strings.TrimSpace(string(out))
+	}
+
+	cmd = exec.Command("git", "rev-parse", "--short", "HEAD")
+	out, err = cmd.Output()
+	if err == nil {
+		return strings.TrimSpace(string(out))
+	}
+
+	return "development"
+}

controllers/softwarefactory_controller.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/fatih/color"
 	monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
+	"gopkg.in/yaml.v3"
 
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
@@ -657,18 +658,24 @@ func (r *SoftwareFactoryReconciler) StandaloneReconcile(ctx context.Context, ns
 			Name:      controllerCMName,
 			Namespace: ns,
 		}}
+	controllerAnnotations := map[string]string{
+		"sf-operator-version": utils.GetVersion(),
+		"last-reconcile":      strconv.FormatInt(time.Now().Unix(), 10),
+	}
 	err := r.Client.Get(
 		ctx, client.ObjectKey{Name: controllerCMName, Namespace: ns}, &controllerCM)
 	if err != nil && k8s_errors.IsNotFound(err) {
-		controllerCM.Data = nil
+		marshaledSpec, _ := yaml.Marshal(sf.Spec)
+		controllerCM.Data = map[string]string{
+			"spec": string(marshaledSpec),
+		}
 		logging.LogI("Creating ConfigMap, name: " + controllerCMName)
 		// Create the fake controller configMap
 		if err := r.Create(ctx, &controllerCM); err != nil {
 			log.Error(err, "Unable to create configMap", "name", controllerCMName)
 			return err
 		}
 	}
-
 	sfCtrl := r.mkSFController(ctx, ns, &controllerCM, sf, true)
 	attempt := 0
 
@@ -680,6 +687,19 @@ func (r *SoftwareFactoryReconciler) StandaloneReconcile(ctx context.Context, ns
 		}
 		if status.Ready {
 			log.Info("Standalone reconcile done.")
+			log.Info("Updating controller configmap ...")
+			if err := r.Client.Get(
+				ctx, client.ObjectKey{Name: controllerCMName, Namespace: ns}, &controllerCM); err == nil {
+				controllerCM.ObjectMeta.Annotations = controllerAnnotations
+				if err := r.Update(ctx, &controllerCM); err != nil {
+					log.Error(err, "Unable to update configMap", "name", controllerCMName)
+					return err
+				} else {
+					log.Info("Controller configmap is up to date.")
+				}
+			} else {
+				log.Error(err, "Controller configmap not found")
+			}
 			return nil
 		}
 		log.Info("[attempt #" + strconv.Itoa(attempt) + "] Waiting 5s for the next reconcile call ...")

doc/reference/CHANGELOG.md

@@ -7,6 +7,10 @@ All notable changes to this project will be documented in this file.
 ### Added
 
 - Enable storage (PVC) configuration and resizing for the `logjuicer` component.
+- CLI: add the `version` subcommand, displaying the current version of the executable.
+- standalone mode: the sf-standalone-owner configMap is annotated with the CLI's version that
+  deployed the resource, and the end time of the deployment. The configMap's data
+  is also set to hold the last applied SoftwareFactory spec.
 
 ### Changed
 

doc/reference/cli/index.md

@@ -31,6 +31,7 @@ deployments, beyond what can be defined in a custom resource manifest.
     - [create auth-token](#create-auth-token)
     - [create client-config](#create-client-config)
   1. [Deploy](#deploy-sf)
+  1. [Version](#version)
 
 ## Installing the CLI
 
@@ -508,3 +509,8 @@ a Software Factory manifest as input and deploy all the required services as a o
 ```sh
 sf-operator [GLOBAL FLAGS] deploy /path/to/manifest
 ```
+
+### Version
+
+Return the version of the executable. If run directly without building the executable first (i.e. with `go run ./main.go`),
+this command requires `git` to be installed in the environment. It must also be running from the project's source directory.

main.go

@@ -138,6 +138,7 @@ func main() {
 		cmd.MkInitCmd(),
 		cmd.MkSFCmd(),
 		cmd.MkNodepoolCmd(),
+		cmd.MkVersionCmd(),
 		operatorCmd,
 		dev.MkDevCmd(),
 		zuul.MkZuulCmd(),

playbooks/run-tests.yaml

@@ -40,3 +40,21 @@
     # - health-check/config-update-nodepool-builder
     # - health-check/test-nodepool-launcher-pod
     # - health-check/test-volumestats-sidecar
+
+  tasks:
+    # test versioning
+    - name: Register CLI version
+      register: cli_version
+      ansible.builtin.shell: |
+        set -o pipefail
+        go run main.go version
+      args:
+        chdir: "{{ zuul.project.src_dir }}"
+
+    - name: ensure annotations are present on sf-standalone-owner
+      ansible.builtin.shell: "kubectl -n sf get configmap sf-standalone-owner -o jsonpath='{.metadata.annotations}'"
+      register: cm_annotations
+      failed_when:
+        - "'last_reconciled' not in cm_annotations.stdout"
+        - "'version' not in cm_annotations.stdout"
+        - "cli_version.stdout not in cm_annotations.stdout"