kustomize generator: fix handling of templateSuffix, and add missing auto-generation of kustomization.yaml

Author: cbarbian-sap

pkg/manifests/kustomize.go

@@ -12,16 +12,19 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"strings"
 	"text/template"
 
 	"github.com/Masterminds/sprig/v3"
 
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	utilyaml "k8s.io/apimachinery/pkg/util/yaml"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/kustomize/api/konfig"
 	"sigs.k8s.io/kustomize/api/krusty"
 	kustypes "sigs.k8s.io/kustomize/api/types"
 	kustfsys "sigs.k8s.io/kustomize/kyaml/filesys"
+	kyaml "sigs.k8s.io/yaml"
 
 	"github.com/sap/component-operator-runtime/internal/templatex"
 	"github.com/sap/component-operator-runtime/pkg/cluster"
@@ -31,7 +34,8 @@ import (
 // KustomizeGenerator is a Generator implementation that basically renders a given Kustomization.
 type KustomizeGenerator struct {
 	kustomizer *krusty.Kustomizer
-	templates  []*template.Template
+	files      map[string][]byte
+	templates  map[string]*template.Template
 }
 
 var _ Generator = &KustomizeGenerator{}
@@ -40,7 +44,10 @@ var _ Generator = &KustomizeGenerator{}
 // Deprecation warning: the parameter client is ignored (can be passed as nil) and will be removed in a future release;
 // the according value will be retrieved from the context passed to Generate().
 func NewKustomizeGenerator(fsys fs.FS, kustomizationPath string, templateSuffix string, client client.Client) (*KustomizeGenerator, error) {
-	g := KustomizeGenerator{}
+	g := KustomizeGenerator{
+		files:     make(map[string][]byte),
+		templates: make(map[string]*template.Template),
+	}
 
 	if fsys == nil {
 		fsys = os.DirFS("/")
@@ -58,7 +65,7 @@ func NewKustomizeGenerator(fsys fs.FS, kustomizationPath string, templateSuffix
 	g.kustomizer = krusty.MakeKustomizer(options)
 
 	var t *template.Template
-	files, err := find(fsys, kustomizationPath, "*"+templateSuffix, fileTypeRegular, 0)
+	files, err := find(fsys, kustomizationPath, "*", fileTypeRegular, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -74,23 +81,29 @@ func NewKustomizeGenerator(fsys fs.FS, kustomizationPath string, templateSuffix
 			// TODO: is it ok to panic here in case of error ?
 			panic("this cannot happen")
 		}
-		if t == nil {
-			t = template.New(name)
-			t.Option("missingkey=zero").
-				Funcs(sprig.TxtFuncMap()).
-				Funcs(templatex.FuncMap()).
-				Funcs(templatex.FuncMapForTemplate(t)).
-				Funcs(templatex.FuncMapForClient(nil)).
-				Funcs(funcMapForGenerateContext(nil, "", ""))
+		if strings.HasSuffix(name, templateSuffix) {
+			if t == nil {
+				t = template.New(name)
+				t.Option("missingkey=zero").
+					Funcs(sprig.TxtFuncMap()).
+					Funcs(templatex.FuncMap()).
+					Funcs(templatex.FuncMapForTemplate(t)).
+					Funcs(templatex.FuncMapForClient(nil)).
+					Funcs(funcMapForGenerateContext(nil, "", ""))
+			} else {
+				t = t.New(name)
+			}
+			if _, err := t.Parse(string(raw)); err != nil {
+				return nil, err
+			}
+			g.templates[strings.TrimSuffix(name, templateSuffix)] = t
 		} else {
-			t = t.New(name)
-		}
-		if _, err := t.Parse(string(raw)); err != nil {
-			return nil, err
+			g.files[name] = raw
 		}
-		g.templates = append(g.templates, t)
 	}
 
+	// TODO: check that g.files and g.templates are disjoint
+
 	return &g, nil
 }
 
@@ -136,22 +149,45 @@ func (g *KustomizeGenerator) Generate(ctx context.Context, namespace string, nam
 	data := parameters.ToUnstructured()
 	fsys := kustfsys.MakeFsInMemory()
 
-	var t0 *template.Template
-	if len(g.templates) > 0 {
-		t0, err = g.templates[0].Clone()
-		if err != nil {
+	for n, f := range g.files {
+		if err := fsys.WriteFile(n, f); err != nil {
 			return nil, err
 		}
-		t0.Option("missingkey=zero").
-			Funcs(templatex.FuncMapForClient(client)).
-			Funcs(funcMapForGenerateContext(client, namespace, name))
 	}
-	for _, t := range g.templates {
+
+	var t0 *template.Template
+	for n, t := range g.templates {
+		if t0 == nil {
+			t0, err = t.Clone()
+			if err != nil {
+				return nil, err
+			}
+			t0.Option("missingkey=zero").
+				Funcs(templatex.FuncMapForClient(client)).
+				Funcs(funcMapForGenerateContext(client, namespace, name))
+		}
 		var buf bytes.Buffer
 		if err := t0.ExecuteTemplate(&buf, t.Name(), data); err != nil {
 			return nil, err
 		}
-		if err := fsys.WriteFile(t.Name(), buf.Bytes()); err != nil {
+		if err := fsys.WriteFile(n, buf.Bytes()); err != nil {
+			return nil, err
+		}
+	}
+
+	haveKustomization := false
+	for _, kustomizationName := range konfig.RecognizedKustomizationFileNames() {
+		if fsys.Exists(kustomizationName) {
+			haveKustomization = true
+			break
+		}
+	}
+	if !haveKustomization {
+		kustomization, err := generateKustomization(fsys)
+		if err != nil {
+			return nil, err
+		}
+		if err := fsys.WriteFile(konfig.DefaultKustomizationFileName(), kustomization); err != nil {
 			return nil, err
 		}
 	}
@@ -191,3 +227,36 @@ func funcMapForGenerateContext(client cluster.Client, namespace string, name str
 		"name":      func() string { return name },
 	}
 }
+
+func generateKustomization(fsys kustfsys.FileSystem) ([]byte, error) {
+	var resources []string
+
+	f := func(path string, info fs.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() && (strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml")) {
+			resources = append(resources, path)
+		}
+		return nil
+	}
+
+	if err := fsys.Walk(".", f); err != nil {
+		return nil, err
+	}
+
+	kustomization := kustypes.Kustomization{
+		TypeMeta: kustypes.TypeMeta{
+			APIVersion: kustypes.KustomizationVersion,
+			Kind:       kustypes.KustomizationKind,
+		},
+		Resources: resources,
+	}
+
+	rawKustomization, err := kyaml.Marshal(kustomization)
+	if err != nil {
+		return nil, err
+	}
+
+	return rawKustomization, nil
+}

website/content/en/docs/generators/kustomize.md

@@ -11,7 +11,7 @@ This generator allows to generate the manifests of the component's resources fro
 As a special case, one or more simple Kubernetes manifests (without a `kustomization.yaml`) are supported as well.
 In addition, all (or selected; see below) files in the kustomization directory can be templatized in a helm'ish way.
 That means, they will be considered as a common template group (where all templates are associated with each other),
-and the same template function set that is available on helm can be used; so, all the [sprig](http://masterminds.github.io/sprig) functions, and custom functions such as `include`, `tpl`, `lookup` can be used.
+and the same template function set that is available on helm can be used; so, all the [sprig](http://masterminds.github.io/sprig) functions, and custom functions such as `include`, `tpl`, `lookup` can be used. In addition, parameterless functions `namespace` and `name` are defined, which return the corresponding arguments passed to `Generate()`.
 
 In the generation step, first, all the go templates will be rendered, and the result of this pre-step will be passed to kustomize.