feat: reading cdc template from filesystem

internal/controllers/compositiondefinitions/compositiondefinitions.go

@@ -55,10 +55,7 @@ const (
 	reconcileGracePeriod           = 1 * time.Minute
 	reconcileTimeout               = 4 * time.Minute
 	compositionStillExistFinalizer = "composition.krateo.io/still-exist-compositions-finalizer"
-
-	cdcImageTagEnvVar            = "CDC_IMAGE_TAG"
-	urlPluralsEnvVar             = "URL_PLURALS"
-	helmRegistryConfigPathEnvVar = "HELM_REGISTRY_CONFIG_PATH"
+	helmRegistryConfigPathEnvVar   = "HELM_REGISTRY_CONFIG_PATH"
 )
 
 var (
@@ -90,12 +87,17 @@ var (
 	webhookServiceName           = env.GetEnvOrDefault("CORE_PROVIDER_WEBHOOK_SERVICE_NAME", "core-provider-webhook-service")
 	webhookServiceNamespace      = env.GetEnvOrDefault("CORE_PROVIDER_WEBHOOK_SERVICE_NAMESPACE", "default")
 	helmRegistryConfigPath       = env.GetEnvOrDefault(helmRegistryConfigPathEnvVar, chartfs.HelmRegistryConfigPathDefault)
+	CDCtemplateFilePath          = path.Join(os.TempDir(), "assets/deployment.yaml")
 )
 
 func GetCABundle() []byte {
 	// CertDir is the directory that contains the server key and certificate. Defaults to
 	// <temp-dir>/k8s-webhook-server/serving-certs.
-	fb, err := os.ReadFile(path.Join(os.TempDir(), "k8s-webhook-server/serving-certs/tls.crt"))
+	dir, err := os.UserHomeDir()
+	if err != nil {
+		dir = os.TempDir()
+	}
+	fb, err := os.ReadFile(path.Join(dir, "k8s-webhook-server/serving-certs/tls.crt"))
 	if err != nil {
 		return nil
 	}
@@ -224,16 +226,10 @@ func (e *external) Observe(ctx context.Context, mg resource.Managed) (reconciler
 
 	log.Printf("[DBG] Searching for Dynamic Controller (gvr: %q)\n", gvr.String())
 
-	cdcEnvs := map[string]string{}
-	urlplurals := os.Getenv(urlPluralsEnvVar)
-	if urlplurals != "" {
-		cdcEnvs[urlPluralsEnvVar] = urlplurals
-	}
-
 	obj, err := deployment.CreateDeployment(gvr, types.NamespacedName{
 		Namespace: cr.Namespace,
 		Name:      cr.Name,
-	}, os.Getenv(cdcImageTagEnvVar), cdcEnvs)
+	}, CDCtemplateFilePath)
 	if err != nil {
 		return reconciler.ExternalObservation{}, err
 	}
@@ -425,22 +421,15 @@ func (e *external) Create(ctx context.Context, mg resource.Managed) error {
 		)
 	}
 
-	cdcEnvs := map[string]string{}
-	urlplurals := os.Getenv(urlPluralsEnvVar)
-	if urlplurals != "" {
-		cdcEnvs[urlPluralsEnvVar] = urlplurals
-	}
-
 	opts := deploy.DeployOptions{
 		DiscoveryClient: memory.NewMemCacheClient(e.discovery),
 		KubeClient:      e.kube,
 		NamespacedName: types.NamespacedName{
 			Namespace: cr.Namespace,
 			Name:      resourceNamer(gvr.Resource, gvr.Version),
 		},
-		CDCImageTag: os.Getenv(cdcImageTagEnvVar),
-		CDCEnvs:     cdcEnvs,
-		Spec:        cr.Spec.Chart.DeepCopy(),
+		Spec:         cr.Spec.Chart.DeepCopy(),
+		TemplatePath: CDCtemplateFilePath,
 	}
 	if meta.IsVerbose(cr) {
 		opts.Log = e.log.Debug

internal/templates/templates.go

@@ -2,24 +2,16 @@ package templates
 
 import (
 	"bytes"
-	_ "embed"
 	"fmt"
 	"text/template"
 )
 
-var (
-	//go:embed assets/deployment.yaml
-	deploymentTpl string
-)
-
 type Renderoptions struct {
 	Group     string
 	Version   string
 	Resource  string
 	Namespace string
 	Name      string
-	Tag       string
-	Env       map[string]string
 }
 
 func Values(opts Renderoptions) map[string]any {
@@ -37,21 +29,15 @@ func Values(opts Renderoptions) map[string]any {
 		"resource":   opts.Resource,
 		"name":       opts.Name,
 		"namespace":  opts.Namespace,
-		"tag":        opts.Tag,
-	}
-
-	if len(opts.Env) > 0 {
-		values["extraEnv"] = map[string]string{}
-		for k, v := range opts.Env {
-			values["extraEnv"].(map[string]string)[k] = v
-		}
 	}
 
 	return values
 }
 
-func RenderDeployment(values map[string]any) ([]byte, error) {
-	tpl, err := template.New("deployment").Funcs(TxtFuncMap()).Parse(deploymentTpl)
+type Template string
+
+func (t Template) RenderDeployment(values map[string]any) ([]byte, error) {
+	tpl, err := template.New("deployment").Funcs(TxtFuncMap()).Parse(string(t))
 	if err != nil {
 		return nil, err
 	}

internal/templates/templates_test.go

@@ -1,11 +1,67 @@
 package templates
 
 import (
-	_ "embed"
 	"fmt"
 	"testing"
 )
 
+const deploymentTemplate = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ .resource }}-{{ .apiVersion }}-controller
+  namespace: {{ .namespace }}
+  labels:
+	app.kubernetes.io/name: {{ .name }}
+	app.kubernetes.io/instance: {{ .resource }}-{{ .apiVersion }}
+	app.kubernetes.io/component: controller
+	app.kubernetes.io/part-of: krateoplatformops
+	app.kubernetes.io/managed-by: krateo
+spec:
+  replicas: 1
+  selector:
+	matchLabels:
+	  app.kubernetes.io/name: {{ .name }}
+  strategy:
+	rollingUpdate:
+	  maxSurge: 25%
+	  maxUnavailable: 25%
+	type: RollingUpdate
+  template:
+	metadata:
+	  name: {{ .name }}
+	  namespace: {{ .namespace }}
+	  labels:
+		app.kubernetes.io/name: {{ .name }}
+	spec:
+	  containers:
+	  - name: {{ .resource }}-{{ .apiVersion }}-controller
+		image: ghcr.io/krateoplatformops/composition-dynamic-controller:0.15.3
+		imagePullPolicy: IfNotPresent
+		env: 
+		- name: HOME
+		  value: /tmp
+		args:
+		  - -debug
+		  - -group={{ .apiGroup }}
+		  - -version={{ .apiVersion }}
+		  - -resource={{ .resource }}
+		  - -namespace={{ .namespace }}
+		ports:
+		- containerPort: 8080
+		  name: metrics
+		  protocol: TCP
+		resources: {}
+		terminationMessagePath: /dev/termination-log
+		terminationMessagePolicy: File
+	  dnsPolicy: ClusterFirst
+	  restartPolicy: Always
+	  schedulerName: default-scheduler
+	  serviceAccount: {{ .name }}
+	  serviceAccountName: {{ .name }}
+	  terminationGracePeriodSeconds: 30
+`
+
 func TestDeploymentManifest(t *testing.T) {
 	values := Values(Renderoptions{
 		Group:     "composition.krateo.io",
@@ -14,7 +70,8 @@ func TestDeploymentManifest(t *testing.T) {
 		Name:      "postgres-tgz",
 		Namespace: "default",
 	})
-	bin, err := RenderDeployment(values)
+
+	bin, err := Template(deploymentTemplate).RenderDeployment(values)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/tools/deploy/deploy.go

@@ -173,8 +173,7 @@ type DeployOptions struct {
 	KubeClient      client.Client
 	NamespacedName  types.NamespacedName
 	Spec            *definitionsv1alpha1.ChartInfo
-	CDCImageTag     string
-	CDCEnvs         map[string]string
+	TemplatePath    string
 	Log             func(msg string, keysAndValues ...any)
 }
 
@@ -266,7 +265,7 @@ func Deploy(ctx context.Context, kube client.Client, opts DeployOptions) (err er
 		}
 	}
 
-	dep, err := deployment.CreateDeployment(gvr, opts.NamespacedName, opts.CDCImageTag, opts.CDCEnvs)
+	dep, err := deployment.CreateDeployment(gvr, opts.NamespacedName, opts.TemplatePath)
 	if err != nil {
 		return err, rbacErr
 	}

internal/tools/deployment/deployment.go

@@ -2,6 +2,8 @@ package deployment
 
 import (
 	"context"
+	"fmt"
+	"os"
 
 	"github.com/avast/retry-go"
 	"github.com/krateoplatformops/core-provider/internal/templates"
@@ -71,18 +73,22 @@ func InstallDeployment(ctx context.Context, kube client.Client, obj *appsv1.Depl
 	)
 }
 
-func CreateDeployment(gvr schema.GroupVersionResource, nn types.NamespacedName, cdcImageTag string, cdcEnv map[string]string) (appsv1.Deployment, error) {
+func CreateDeployment(gvr schema.GroupVersionResource, nn types.NamespacedName, templatePath string) (appsv1.Deployment, error) {
 	values := templates.Values(templates.Renderoptions{
 		Group:     gvr.Group,
 		Version:   gvr.Version,
 		Resource:  gvr.Resource,
 		Namespace: nn.Namespace,
 		Name:      nn.Name,
-		Tag:       cdcImageTag,
-		Env:       cdcEnv,
 	})
 
-	dat, err := templates.RenderDeployment(values)
+	templateF, err := os.ReadFile(templatePath)
+	if err != nil {
+		return appsv1.Deployment{}, fmt.Errorf("failed to read template file: %w", err)
+	}
+
+	template := templates.Template(string(templateF))
+	dat, err := template.RenderDeployment(values)
 	if err != nil {
 		return appsv1.Deployment{}, err
 	}