Supply values to the commit message template

This commit:

 - passes a value including the update result to the commit message
   template
 - gives the template result a method for enumerating the
   objects regardless of file

This means you can access the images updated either by file
(`.Files`), by object (`.Objects()`), or just as a list
(`.Images()`). The additional test case shows how to use these.

Signed-off-by: Michael Bridgen <[email protected]>

Author: squaremo

controllers/imageupdateautomation_controller.go

@@ -69,6 +69,11 @@ const defaultMessageTemplate = `Update from image update automation`
 const repoRefKey = ".spec.gitRepository"
 const imagePolicyKey = ".spec.update.imagePolicy"
 
+type TemplateValues struct {
+	AutomationObject types.NamespacedName
+	Updated          update.Result
+}
+
 // ImageUpdateAutomationReconciler reconciles a ImageUpdateAutomation object
 type ImageUpdateAutomationReconciler struct {
 	client.Client
@@ -85,6 +90,7 @@ type ImageUpdateAutomationReconciler struct {
 func (r *ImageUpdateAutomationReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	log := logr.FromContext(ctx)
 	now := time.Now()
+	var templateValues TemplateValues
 
 	var auto imagev1.ImageUpdateAutomation
 	if err := r.Get(ctx, req.NamespacedName, &auto); err != nil {
@@ -96,6 +102,8 @@ func (r *ImageUpdateAutomationReconciler) Reconcile(ctx context.Context, req ctr
 		return ctrl.Result{}, nil
 	}
 
+	templateValues.AutomationObject = req.NamespacedName
+
 	// Record readiness metric when exiting; if there's any points at
 	// which the readiness is updated _without also exiting_, they
 	// should also record the readiness.
@@ -178,8 +186,10 @@ func (r *ImageUpdateAutomationReconciler) Reconcile(ctx context.Context, req ctr
 			return failWithError(err)
 		}
 
-		if _, err := updateAccordingToSetters(ctx, tmp, policies.Items); err != nil {
+		if result, err := updateAccordingToSetters(ctx, tmp, policies.Items); err != nil {
 			return failWithError(err)
+		} else {
+			templateValues.Updated = result
 		}
 	default:
 		log.Info("no update strategy given in the spec")
@@ -197,7 +207,7 @@ func (r *ImageUpdateAutomationReconciler) Reconcile(ctx context.Context, req ctr
 	// The status message depends on what happens next. Since there's
 	// more than one way to succeed, there's some if..else below, and
 	// early returns only on failure.
-	if rev, err := commitAll(ctx, repo, &auto.Spec.Commit); err != nil {
+	if rev, err := commitAll(ctx, repo, &auto.Spec.Commit, templateValues); err != nil {
 		if err == errNoChanges {
 			r.event(ctx, auto, events.EventSeverityInfo, "no updates made")
 			log.V(debug).Info("no changes made in working directory; no commit")
@@ -348,7 +358,7 @@ func cloneInto(ctx context.Context, access repoAccess, branch, path, impl string
 
 var errNoChanges error = errors.New("no changes made to working directory")
 
-func commitAll(ctx context.Context, repo *gogit.Repository, commit *imagev1.CommitSpec) (string, error) {
+func commitAll(ctx context.Context, repo *gogit.Repository, commit *imagev1.CommitSpec, values TemplateValues) (string, error) {
 	working, err := repo.Worktree()
 	if err != nil {
 		return "", err
@@ -370,7 +380,7 @@ func commitAll(ctx context.Context, repo *gogit.Repository, commit *imagev1.Comm
 		return "", err
 	}
 	buf := &strings.Builder{}
-	if err := tmpl.Execute(buf, "no data! yet"); err != nil {
+	if err := tmpl.Execute(buf, values); err != nil {
 		return "", err
 	}
 

controllers/update_test.go

@@ -111,6 +111,157 @@ var _ = Describe("ImageUpdateAutomation", func() {
 		Expect(initGitRepo(gitServer, "testdata/appconfig", branch, repositoryPath)).To(Succeed())
 	})
 
+	Context("commit message template", func() {
+
+		var (
+			localRepo     *git.Repository
+			commitMessage string
+		)
+
+		const (
+			commitTemplate = `Commit summary
+
+Automation: {{ .AutomationObject }}
+
+Files:
+{{ range $filename, $_ := .Updated.Files -}}
+- {{ $filename }}
+{{ end -}}
+
+Objects:
+{{ range $resource, $_ := .Updated.Objects -}}
+- {{ $resource.Kind }} {{ $resource.Name }}
+{{ end -}}
+
+Images:
+{{ range .Updated.Images -}}
+- {{.}}
+{{ end -}}
+`
+			commitMessageFmt = `Commit summary
+
+Automation: %s/update-test
+
+Files:
+- deploy.yaml
+Objects:
+- Deployment test
+Images:
+- helloworld:v1.0.0
+`
+		)
+
+		BeforeEach(func() {
+			commitMessage = fmt.Sprintf(commitMessageFmt, namespace.Name)
+
+			Expect(initGitRepo(gitServer, "testdata/appconfig", branch, repositoryPath)).To(Succeed())
+			repoURL := gitServer.HTTPAddressWithCredentials() + repositoryPath
+			var err error
+			localRepo, err = git.Clone(memory.NewStorage(), memfs.New(), &git.CloneOptions{
+				URL:           repoURL,
+				RemoteName:    "origin",
+				ReferenceName: plumbing.NewBranchReferenceName(branch),
+			})
+			Expect(err).ToNot(HaveOccurred())
+
+			gitRepoKey := types.NamespacedName{
+				Name:      "image-auto-" + randStringRunes(5),
+				Namespace: namespace.Name,
+			}
+			gitRepo := &sourcev1.GitRepository{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      gitRepoKey.Name,
+					Namespace: namespace.Name,
+				},
+				Spec: sourcev1.GitRepositorySpec{
+					URL:      repoURL,
+					Interval: metav1.Duration{Duration: time.Minute},
+				},
+			}
+			Expect(k8sClient.Create(context.Background(), gitRepo)).To(Succeed())
+			policyKey := types.NamespacedName{
+				Name:      "policy-" + randStringRunes(5),
+				Namespace: namespace.Name,
+			}
+			// NB not testing the image reflector controller; this
+			// will make a "fully formed" ImagePolicy object.
+			policy := &imagev1_reflect.ImagePolicy{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      policyKey.Name,
+					Namespace: policyKey.Namespace,
+				},
+				Spec: imagev1_reflect.ImagePolicySpec{
+					ImageRepositoryRef: meta.LocalObjectReference{
+						Name: "not-expected-to-exist",
+					},
+					Policy: imagev1_reflect.ImagePolicyChoice{
+						SemVer: &imagev1_reflect.SemVerPolicy{
+							Range: "1.x",
+						},
+					},
+				},
+				Status: imagev1_reflect.ImagePolicyStatus{
+					LatestImage: "helloworld:v1.0.0",
+				},
+			}
+			Expect(k8sClient.Create(context.Background(), policy)).To(Succeed())
+			Expect(k8sClient.Status().Update(context.Background(), policy)).To(Succeed())
+
+			// Insert a setter reference into the deployment file,
+			// before creating the automation object itself.
+			commitInRepo(repoURL, branch, "Install setter marker", func(tmp string) {
+				replaceMarker(tmp, policyKey)
+			})
+
+			// pull the head commit we just pushed, so it's not
+			// considered a new commit when checking for a commit
+			// made by automation.
+			waitForNewHead(localRepo, branch)
+
+			// now create the automation object, and let it (one
+			// hopes!) make a commit itself.
+			updateKey := types.NamespacedName{
+				Namespace: namespace.Name,
+				Name:      "update-test",
+			}
+			updateBySetters := &imagev1.ImageUpdateAutomation{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      updateKey.Name,
+					Namespace: updateKey.Namespace,
+				},
+				Spec: imagev1.ImageUpdateAutomationSpec{
+					Interval: metav1.Duration{Duration: 2 * time.Hour}, // this is to ensure any subsequent run should be outside the scope of the testing
+					Checkout: imagev1.GitCheckoutSpec{
+						GitRepositoryRef: meta.LocalObjectReference{
+							Name: gitRepoKey.Name,
+						},
+						Branch: branch,
+					},
+					Update: &imagev1.UpdateStrategy{
+						Strategy: imagev1.UpdateStrategySetters,
+					},
+					Commit: imagev1.CommitSpec{
+						MessageTemplate: commitTemplate,
+					},
+				},
+			}
+			Expect(k8sClient.Create(context.Background(), updateBySetters)).To(Succeed())
+			// wait for a new commit to be made by the controller
+			waitForNewHead(localRepo, branch)
+		})
+
+		AfterEach(func() {
+			Expect(k8sClient.Delete(context.Background(), namespace)).To(Succeed())
+		})
+
+		It("formats the commit message as in the template", func() {
+			head, _ := localRepo.Head()
+			commit, err := localRepo.CommitObject(head.Hash())
+			Expect(err).ToNot(HaveOccurred())
+			Expect(commit.Message).To(Equal(commitMessage))
+		})
+	})
+
 	endToEnd := func(impl, proto string) func() {
 		return func() {
 			var (

pkg/update/result.go

@@ -16,3 +16,33 @@ type Result struct {
 type FileResult struct {
 	Objects map[yaml.ResourceIdentifier][]name.Reference
 }
+
+// Images returns all the images that were involved in at least one
+// update.
+func (r Result) Images() []name.Reference {
+	seen := make(map[name.Reference]struct{})
+	var result []name.Reference
+	for _, file := range r.Files {
+		for _, images := range file.Objects {
+			for _, ref := range images {
+				if _, ok := seen[ref]; !ok {
+					seen[ref] = struct{}{}
+					result = append(result, ref)
+				}
+			}
+		}
+	}
+	return result
+}
+
+// Objects returns a map of all the objects against the images updated
+// within, regardless of which file they appear in.
+func (r Result) Objects() map[yaml.ResourceIdentifier][]name.Reference {
+	result := make(map[yaml.ResourceIdentifier][]name.Reference)
+	for _, file := range r.Files {
+		for res, refs := range file.Objects {
+			result[res] = append(result[res], refs...)
+		}
+	}
+	return result
+}

pkg/update/result_test.go

@@ -0,0 +1,72 @@
+package update
+
+import (
+	"github.com/google/go-containerregistry/pkg/name"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"sigs.k8s.io/kustomize/kyaml/yaml"
+)
+
+func mustRef(ref string) name.Reference {
+	r, err := name.ParseReference(ref)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+var _ = Describe("update results", func() {
+
+	var result Result
+	objectNames := []yaml.ResourceIdentifier{
+		yaml.ResourceIdentifier{
+			NameMeta: yaml.NameMeta{Namespace: "ns", Name: "foo"},
+		},
+		yaml.ResourceIdentifier{
+			NameMeta: yaml.NameMeta{Namespace: "ns", Name: "bar"},
+		},
+	}
+
+	BeforeEach(func() {
+		result = Result{
+			Files: map[string]FileResult{
+				"foo.yaml": {
+					Objects: map[yaml.ResourceIdentifier][]name.Reference{
+						objectNames[0]: {
+							mustRef("image:v1.0"),
+							mustRef("other:v2.0"),
+						},
+					},
+				},
+				"bar.yaml": {
+					Objects: map[yaml.ResourceIdentifier][]name.Reference{
+						objectNames[1]: {
+							mustRef("image:v1.0"),
+							mustRef("other:v2.0"),
+						},
+					},
+				},
+			},
+		}
+	})
+
+	It("deduplicates images", func() {
+		Expect(result.Images()).To(Equal([]name.Reference{
+			mustRef("image:v1.0"),
+			mustRef("other:v2.0"),
+		}))
+	})
+
+	It("collects images by object", func() {
+		Expect(result.Objects()).To(Equal(map[yaml.ResourceIdentifier][]name.Reference{
+			objectNames[0]: {
+				mustRef("image:v1.0"),
+				mustRef("other:v2.0"),
+			},
+			objectNames[1]: {
+				mustRef("image:v1.0"),
+				mustRef("other:v2.0"),
+			},
+		}))
+	})
+})