fix: Handle multiple meta mutators cleanly

This applies each of the mutators before generating patches.

Author: jimmidyson

.golangci.yml

@@ -85,3 +85,7 @@ issues:
     - path: "api/*"
       linters:
         - gochecknoinits
+    # Idiomatic to use init functions to register APIs with scheme
+    - text: "hugeParam: holderRef is heavy"
+      linters:
+        - gocritic

cmd/main.go

@@ -136,7 +136,7 @@ func main() {
 	}
 	// This metaPatchHandlers combines all other patch and variable handlers under a single handler.
 	// It allows to specify configuration under a single variable.
-	metaPatchHandlers := []mutation.GeneratePatches{
+	metaPatchHandlers := []mutation.MetaMutater{
 		httpproxy.NewMetaPatch(mgr.GetClient()),
 		extraapiservercertsans.NewMetaPatch(),
 		auditpolicy.NewPatch(),

common/pkg/capi/clustertopology/handlers/cluster_context.go

@@ -0,0 +1,48 @@
+// Copyright 2023 D2iQ, Inc. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package handlers
+
+import (
+	"context"
+	"errors"
+
+	capiv1 "sigs.k8s.io/cluster-api/api/v1beta1"
+	runtimehooksv1 "sigs.k8s.io/cluster-api/exp/runtime/hooks/api/v1alpha1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+// clusterKeyContextKey is how we find a cluster key from a context.Context.
+type clusterKeyContextKey struct{}
+
+func ClusterKeyFrom(ctx context.Context) (client.ObjectKey, error) {
+	clusterKey, ok := ctx.Value(clusterKeyContextKey{}).(client.ObjectKey)
+	if !ok || clusterKey.Name == "" {
+		return client.ObjectKey{}, errors.New(
+			"failed to detect cluster name from GeneratePatch request",
+		)
+	}
+
+	return clusterKey, nil
+}
+
+func ClusterKeyInto(
+	ctx context.Context, req *runtimehooksv1.GeneratePatchesRequest,
+) context.Context {
+	clusterKey := client.ObjectKey{}
+
+	for i := range req.Items {
+		item := req.Items[i]
+		if item.HolderReference.Kind == "Cluster" &&
+			item.HolderReference.APIVersion == capiv1.GroupVersion.String() {
+			clusterKey.Name = item.HolderReference.Name
+			clusterKey.Namespace = item.HolderReference.Namespace
+		}
+	}
+
+	if clusterKey.Name != "" {
+		return context.WithValue(ctx, clusterKeyContextKey{}, clusterKey)
+	}
+
+	return ctx
+}

common/pkg/capi/clustertopology/handlers/mutation/meta.go

@@ -5,22 +5,44 @@ package mutation
 
 import (
 	"context"
-	"strings"
 
+	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+	bootstrapv1 "sigs.k8s.io/cluster-api/bootstrap/kubeadm/api/v1beta1"
+	controlplanev1 "sigs.k8s.io/cluster-api/controlplane/kubeadm/api/v1beta1"
 	runtimehooksv1 "sigs.k8s.io/cluster-api/exp/runtime/hooks/api/v1alpha1"
+	"sigs.k8s.io/cluster-api/exp/runtime/topologymutation"
 
 	"github.com/d2iq-labs/capi-runtime-extensions/common/pkg/capi/clustertopology/handlers"
 )
 
+type MetaMutater interface {
+	Mutate(
+		ctx context.Context,
+		obj runtime.Object,
+		vars map[string]apiextensionsv1.JSON,
+		holderRef runtimehooksv1.HolderReference,
+	) error
+}
+
 type metaGeneratePatches struct {
-	name            string
-	wrappedHandlers []GeneratePatches
+	name     string
+	decoder  runtime.Decoder
+	mutaters []MetaMutater
 }
 
-func NewMetaGeneratePatchesHandler(name string, gp ...GeneratePatches) handlers.Named {
+func NewMetaGeneratePatchesHandler(name string, m ...MetaMutater) handlers.Named {
+	scheme := runtime.NewScheme()
+	_ = bootstrapv1.AddToScheme(scheme)
+	_ = controlplanev1.AddToScheme(scheme)
 	return metaGeneratePatches{
-		name:            name,
-		wrappedHandlers: gp,
+		name: name,
+		decoder: serializer.NewCodecFactory(scheme).UniversalDecoder(
+			controlplanev1.GroupVersion,
+			bootstrapv1.GroupVersion,
+		),
+		mutaters: m,
 	}
 }
 
@@ -33,20 +55,26 @@ func (mgp metaGeneratePatches) GeneratePatches(
 	req *runtimehooksv1.GeneratePatchesRequest,
 	resp *runtimehooksv1.GeneratePatchesResponse,
 ) {
-	for _, h := range mgp.wrappedHandlers {
-		wrappedResp := &runtimehooksv1.GeneratePatchesResponse{}
-		h.GeneratePatches(ctx, req, wrappedResp)
-		resp.Items = append(resp.Items, wrappedResp.Items...)
-		if wrappedResp.Message != "" {
-			resp.Message = strings.TrimPrefix(resp.Message+"\n"+wrappedResp.Message, "\n")
-		}
-		resp.Status = wrappedResp.Status
-		if resp.Status == runtimehooksv1.ResponseStatusFailure {
-			return
-		}
-	}
+	ctx = handlers.ClusterKeyInto(ctx, req)
 
-	if resp.Status == "" {
-		resp.Status = runtimehooksv1.ResponseStatusSuccess
-	}
+	topologymutation.WalkTemplates(
+		ctx,
+		mgp.decoder,
+		req,
+		resp,
+		func(
+			ctx context.Context,
+			obj runtime.Object,
+			vars map[string]apiextensionsv1.JSON,
+			holderRef runtimehooksv1.HolderReference,
+		) error {
+			for _, h := range mgp.mutaters {
+				if err := h.Mutate(ctx, obj, vars, holderRef); err != nil {
+					return err
+				}
+			}
+
+			return nil
+		},
+	)
 }