Merge pull request #592 from element-hq/gaelg/matrix-tools-cmd-refactor

matrix-tools cmd refactor

Author: gaelgatelement

charts/matrix-stack/source/common/sub_schema_values.yaml.j2

@@ -13,7 +13,7 @@ SPDX-License-Identifier: AGPL-3.0-only
 
 ## The matrix-tools image, used in multiple components
 matrixTools:
-{{ image(registry="ghcr.io", repository="element-hq/ess-helm/matrix-tools", tag="0.5.3") | indent(2) }}
+{{ image(registry="ghcr.io", repository="element-hq/ess-helm/matrix-tools", tag="0.5.4") | indent(2) }}
 
 ## CertManager Issuer to configure by default automatically on all ingresses
 ## If configured, the chart will automatically generate the tlsSecret name for all ingresses

charts/matrix-stack/values.yaml

@@ -20,7 +20,7 @@ matrixTools:
 
     ## The tag of the container image to use.
     ## One of tag or digest must be provided.
-    tag: "0.5.3"
+    tag: "0.5.4"
 
     ## Container digest to use. Used to pull the image instead of the image tag if set
     ## The tag will still be set as the app.kubernetes.io/version label

matrix-tools/cmd/main.go

@@ -6,48 +6,16 @@ package main
 
 import (
 	"fmt"
-	"io"
 	"os"
 
-	"flag"
-
+	deploymentmarkers "github.com/element-hq/ess-helm/matrix-tools/internal/cmd/deployment-markers"
+	generatesecrets "github.com/element-hq/ess-helm/matrix-tools/internal/cmd/generate-secrets"
+	renderconfig "github.com/element-hq/ess-helm/matrix-tools/internal/cmd/render-config"
+	"github.com/element-hq/ess-helm/matrix-tools/internal/cmd/syn2mas"
+	"github.com/element-hq/ess-helm/matrix-tools/internal/cmd/tcpwait"
 	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/args"
-	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/marker"
-	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/renderer"
-	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/secret"
-	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/syn2mas"
-	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/tcpwait"
-	"github.com/pkg/errors"
-	"gopkg.in/yaml.v3"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
 )
 
-func getKubernetesClient() (kubernetes.Interface, error) {
-	config, err := rest.InClusterConfig()
-	if err != nil {
-		return nil, err
-	}
-	clientset, err := kubernetes.NewForConfig(config)
-	if err != nil {
-		return nil, err
-	}
-	return clientset, nil
-}
-
-func readFiles(paths []string) ([]io.Reader, []func() error, error) {
-	files := make([]io.Reader, 0)
-	closeFiles := make([]func() error, 0)
-	for _, path := range paths {
-		fileReader, err := os.Open(path)
-		if err != nil {
-			return files, closeFiles, fmt.Errorf("failed to open file: %w", err)
-		}
-		files = append(files, fileReader)
-		closeFiles = append(closeFiles, fileReader.Close)
-	}
-	return files, closeFiles, nil
-}
 
 func main() {
 	options, err := args.ParseArgs(os.Args)
@@ -58,97 +26,15 @@ func main() {
 
 	switch options.Command {
 	case args.RenderConfig:
-		fileReaders, closeFiles, err := readFiles(options.Files)
-		defer func() {
-			for _, closeFn := range closeFiles {
-				err := closeFn()
-				if err != nil {
-					fmt.Println("Error closing file : ", err)
-				}
-			}
-		}()
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-		result, err := renderer.RenderConfig(fileReaders)
-		if err != nil {
-			if err == flag.ErrHelp {
-				flag.CommandLine.Usage()
-			} else {
-				fmt.Println("Error:", err)
-			}
-			os.Exit(1)
-		}
-		var outputYAML []byte
-		if outputYAML, err = yaml.Marshal(result); err != nil {
-			fmt.Println("Error marshalling merged config to YAML:", err)
-			os.Exit(1)
-		}
-
-		fmt.Printf("Rendering config to file: %v\n", options.Output)
-		if os.Getenv("DEBUG_RENDERING") == "1" {
-			fmt.Println(string(outputYAML))
-		}
-		err = os.WriteFile(options.Output, outputYAML, 0440)
-		if err != nil {
-			fmt.Println("Error writing to file:", err)
-			os.Exit(1)
-		}
+		renderconfig.Run(options.RenderConfig)
 	case args.TCPWait:
-		tcpwait.WaitForTCP(options.Address)
+		tcpwait.Run(options.TcpWait)
 	case args.Syn2Mas:
-		clientset, err := getKubernetesClient()
-		if err != nil {
-			fmt.Println("Error getting Kubernetes client: ", err)
-			os.Exit(1)
-		}
-		namespace := os.Getenv("NAMESPACE")
-		if namespace == "" {
-			fmt.Println("Error, $NAMESPACE is not defined")
-			os.Exit(1)
-		}
-		syn2mas.RunSyn2MAS(clientset, namespace, options.SynapseConfig, options.MASConfig)
+		syn2mas.Run(options.Syn2Mas)
 	case args.GenerateSecrets:
-		clientset, err := getKubernetesClient()
-		if err != nil {
-			fmt.Println("Error getting Kubernetes client: ", err)
-			os.Exit(1)
-		}
-		namespace := os.Getenv("NAMESPACE")
-		if namespace == "" {
-			fmt.Println("Error, $NAMESPACE is not defined")
-			os.Exit(1)
-		}
-
-		for _, generatedSecret := range options.GeneratedSecrets {
-			err := secret.GenerateSecret(clientset, options.Labels, namespace, generatedSecret.Name, generatedSecret.Key, generatedSecret.Type)
-			if err != nil {
-				wrappedErr := errors.Wrapf(err, "error generating secret: %s", generatedSecret.ArgValue)
-				fmt.Println("Error:", wrappedErr)
-				os.Exit(1)
-			}
-		}
+		generatesecrets.Run(options.GenerateSecrets)
 	case args.DeploymentMarkers:
-		clientset, err := getKubernetesClient()
-		if err != nil {
-			fmt.Println("Error getting Kubernetes client: ", err)
-			os.Exit(1)
-		}
-		namespace := os.Getenv("NAMESPACE")
-		if namespace == "" {
-			fmt.Println("Error, $NAMESPACE is not defined")
-			os.Exit(1)
-		}
-
-		for _, depMarker := range options.DeploymentMarkers {
-			err := marker.GenerateConfigMap(clientset, options.Labels, namespace, depMarker.Name, depMarker.Key, depMarker.Step, depMarker.NewValue, depMarker.AllowedValues)
-			if err != nil {
-				wrappedErr := errors.Wrapf(err, "error generating configmap: %v", depMarker)
-				fmt.Println("Error:", wrappedErr)
-				os.Exit(1)
-			}
-		}
+		deploymentmarkers.Run(options.DeploymentMarkers)
 	default:
 		fmt.Printf("Unknown command")
 		os.Exit(1)

matrix-tools/go.mod

@@ -10,6 +10,7 @@ require gopkg.in/yaml.v3 v3.0.1
 
 require (
 	github.com/pkg/errors v0.9.1
+	github.com/stretchr/testify v1.10.0
 	k8s.io/api v0.33.2
 	k8s.io/apimachinery v0.33.2
 	k8s.io/client-go v0.33.2
@@ -33,6 +34,7 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	golang.org/x/net v0.38.0 // indirect
 	golang.org/x/oauth2 v0.27.0 // indirect

matrix-tools/internal/cmd/deployment-markers/args.go

@@ -0,0 +1,61 @@
+// Copyright 2025 New Vector Ltd
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+package deploymentmarkers
+
+import (
+	"flag"
+	"fmt"
+	"strings"
+)
+
+const (
+		FlagSetName = "deployment-markers"
+)
+
+type DeploymentMarkersOptions struct {
+	Labels     map[string]string
+	DeploymentMarkers []DeploymentMarker
+}
+
+
+type DeploymentMarker struct {
+	Name          string
+	Key           string
+	Step          string
+	NewValue      string
+	AllowedValues []string
+}
+
+func ParseArgs(args []string) (*DeploymentMarkersOptions, error) {
+	options := &DeploymentMarkersOptions{}
+
+	deploymentMarkersSet := flag.NewFlagSet(FlagSetName, flag.ExitOnError)
+	deploymentMarkers := deploymentMarkersSet.String("markers", "", "Comma-separated list of deployment markers, with Semi-colon separated list of previous allowed values in the format of `name:step:newValue:[allowedValues;..]`")
+	labels := deploymentMarkersSet.String("labels", "", "Comma-separated list of labels for generated secrets, in the format of `key=value`")
+	step := deploymentMarkersSet.String("step", "", "One of `pre` or `post`")
+
+	err := deploymentMarkersSet.Parse(args)
+	if err != nil {
+		return nil, err
+	}
+	for _, deploymentMarkerArg := range strings.Split(*deploymentMarkers, ",") {
+		parsedValue := strings.Split(deploymentMarkerArg, ":")
+		if len(parsedValue) < 3 {
+			return nil, fmt.Errorf("invalid deployment marker format, expect <name:key:newValue:[allowedValues;..]>: %s", deploymentMarkerArg)
+		}
+		parsedAllowedValues := strings.Split(parsedValue[3], ";")
+		deploymentMarker := DeploymentMarker{Name: parsedValue[0], Key: parsedValue[1], Step: *step, NewValue: parsedValue[2], AllowedValues: parsedAllowedValues}
+		options.DeploymentMarkers = append(options.DeploymentMarkers, deploymentMarker)
+	}
+	options.Labels = make(map[string]string)
+	if *labels != "" {
+		for _, label := range strings.Split(*labels, ",") {
+			parsedLabelValue := strings.Split(label, "=")
+			options.Labels[parsedLabelValue[0]] = parsedLabelValue[1]
+		}
+	}
+	options.Labels["app.kubernetes.io/managed-by"] = "matrix-tools-deployment-markers"
+	return options, nil
+}

matrix-tools/internal/cmd/deployment-markers/cmd.go

@@ -0,0 +1,36 @@
+// Copyright 2025 New Vector Ltd
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+package deploymentmarkers
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/marker"
+	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/util"
+	"github.com/pkg/errors"
+)
+
+func Run(options *DeploymentMarkersOptions) {
+	clientset, err := util.GetKubernetesClient()
+	if err != nil {
+		fmt.Println("Error getting Kubernetes client: ", err)
+		os.Exit(1)
+	}
+	namespace := os.Getenv("NAMESPACE")
+	if namespace == "" {
+		fmt.Println("Error, $NAMESPACE is not defined")
+		os.Exit(1)
+	}
+
+	for _, depMarker := range options.DeploymentMarkers {
+		err := marker.GenerateConfigMap(clientset, options.Labels, namespace, depMarker.Name, depMarker.Key, depMarker.Step, depMarker.NewValue, depMarker.AllowedValues)
+		if err != nil {
+			wrappedErr := errors.Wrapf(err, "error generating configmap: %v", depMarker)
+			fmt.Println("Error:", wrappedErr)
+			os.Exit(1)
+		}
+	}
+}

matrix-tools/internal/cmd/generate-secrets/args.go

@@ -0,0 +1,84 @@
+// Copyright 2025 New Vector Ltd
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+package generatesecrets
+
+import (
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/element-hq/ess-helm/matrix-tools/internal/pkg/secret"
+)
+
+const (
+	FlagSetName = "generate-secrets"
+)
+
+type GenerateSecretsOptions struct {
+	GeneratedSecrets []GeneratedSecret
+	Labels     map[string]string
+}
+
+type GeneratedSecret struct {
+	ArgValue      string
+	Name          string
+	Key           string
+	Type          secret.SecretType
+}
+
+func parseSecretType(value string) (secret.SecretType, error) {
+	switch value {
+	case "rand32":
+		return secret.Rand32, nil
+	case "signingkey":
+		return secret.SigningKey, nil
+	case "hex32":
+		return secret.Hex32, nil
+	case "rsa":
+		return secret.RSA, nil
+	case "ecdsaprime256v1":
+		return secret.EcdsaPrime256v1, nil
+	case "ecdsasecp256k1":
+		return secret.EcdsaSecp256k1, nil
+	default:
+		return secret.UnknownSecretType, fmt.Errorf("unknown secret type: %s", value)
+	}
+}
+
+
+func ParseArgs(args []string) (*GenerateSecretsOptions, error) {
+	var options GenerateSecretsOptions
+
+	generateSecretsSet := flag.NewFlagSet("generate-secrets", flag.ExitOnError)
+	secrets := generateSecretsSet.String("secrets", "", "Comma-separated list of secrets to generate, in the format of `name:key:type`, where `type` is one of: rand32")
+	secretsLabels := generateSecretsSet.String("labels", "", "Comma-separated list of labels for generated secrets, in the format of `key=value`")
+
+	err := generateSecretsSet.Parse(args)
+	if err != nil {
+		return nil, err
+	}
+	for _, generatedSecretArg := range strings.Split(*secrets, ",") {
+		parsedValue := strings.Split(generatedSecretArg, ":")
+		if len(parsedValue) < 3 {
+			return nil, fmt.Errorf("invalid generated secret format, expect <name:key:type:...>: %s", generatedSecretArg)
+		}
+		var parsedSecretType secret.SecretType
+		if parsedSecretType, err = parseSecretType(parsedValue[2]); err != nil {
+			return nil, fmt.Errorf("invalid secret type in %s : %v", generatedSecretArg, err)
+		}
+
+		generatedSecret := GeneratedSecret{ArgValue: generatedSecretArg, Name: parsedValue[0], Key: parsedValue[1], Type: parsedSecretType}
+		options.GeneratedSecrets = append(options.GeneratedSecrets, generatedSecret)
+	}
+	options.Labels = make(map[string]string)
+	if *secretsLabels != "" {
+		for _, label := range strings.Split(*secretsLabels, ",") {
+			parsedLabelValue := strings.Split(label, "=")
+			options.Labels[parsedLabelValue[0]] = parsedLabelValue[1]
+		}
+	}
+	options.Labels["app.kubernetes.io/managed-by"] = "matrix-tools-init-secrets"
+	return &options, nil
+}