Implement .spec.push.branch most simply

This adapts the controller so that it will honour the
`.spec.push.branch` field.

The behaviour _without_ that field is to check out the branch given in
`.spec.checkout.branch`, commit, and push to the origin.

With `.spec.push.branch` present, it will try to check out that
branch; if it doesn't exist, it'll create it, starting from
`.spec.checkout.branch`. Either way it'll commit to that branch and
push to the origin.

The effect is that all automation will happen on the "push" branch,
and (most likely) not be applied into the cluster until merged into
whichever branch is synced. When the push branch is deleted, it'll be
created anew; otherwise, commits will pile up there as more changes
are made.

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

Author: squaremo

controllers/imageupdateautomation_controller.go

@@ -176,6 +176,14 @@ func (r *ImageUpdateAutomationReconciler) Reconcile(ctx context.Context, req ctr
 		return failWithError(err)
 	}
 
+	// When there's a push spec, the pushed-to branch is where commits
+	// shall be made
+	if auto.Spec.Push != nil {
+		if err := switchBranch(repo, auto.Spec.Push.Branch); err != nil {
+			return failWithError(err)
+		}
+	}
+
 	log.V(debug).Info("cloned git repository", "gitrepository", originName, "branch", auto.Spec.Checkout.Branch, "working", tmp)
 
 	switch {
@@ -221,15 +229,19 @@ func (r *ImageUpdateAutomationReconciler) Reconcile(ctx context.Context, req ctr
 			return failWithError(err)
 		}
 	} else {
-		if err := push(ctx, tmp, repo, auto.Spec.Checkout.Branch, access, origin.Spec.GitImplementation); err != nil {
+		pushBranch := auto.Spec.Checkout.Branch
+		if auto.Spec.Push != nil {
+			pushBranch = auto.Spec.Push.Branch
+		}
+		if err := push(ctx, tmp, repo, pushBranch, access, origin.Spec.GitImplementation); err != nil {
 			return failWithError(err)
 		}
 
-		r.event(ctx, auto, events.EventSeverityInfo, "committed and pushed change "+rev)
-		log.Info("pushed commit to origin", "revision", rev)
+		r.event(ctx, auto, events.EventSeverityInfo, "committed and pushed change "+rev+" to "+pushBranch)
+		log.Info("pushed commit to origin", "revision", rev, "branch", pushBranch)
 		auto.Status.LastPushCommit = rev
 		auto.Status.LastPushTime = &metav1.Time{Time: now}
-		statusMessage = "committed and pushed " + rev
+		statusMessage = "committed and pushed " + rev + " to " + pushBranch
 	}
 
 	// Getting to here is a successful run.
@@ -358,6 +370,45 @@ func cloneInto(ctx context.Context, access repoAccess, branch, path, impl string
 	return gogit.PlainOpen(path)
 }
 
+// switchBranch switches the repo from the current branch to the
+// branch given. If the branch does not exist, it is created using the
+// head as the starting point.
+func switchBranch(repo *gogit.Repository, pushBranch string) error {
+	remoteBranch := plumbing.NewRemoteReferenceName(originRemote, pushBranch)
+	localBranch := plumbing.NewBranchReferenceName(pushBranch)
+
+	// is the remote branch already present?
+	branchHead, err := repo.Reference(remoteBranch, false)
+	switch {
+	case err == plumbing.ErrReferenceNotFound:
+		// make a new branch, starting at HEAD
+		head, err := repo.Head()
+		if err != nil {
+			return err
+		}
+		branchRef := plumbing.NewHashReference(localBranch, head.Hash())
+		if err = repo.Storer.SetReference(branchRef); err != nil {
+			return err
+		}
+	case err != nil:
+		return err
+	default:
+		// make a local branch that references the remote branch
+		branchRef := plumbing.NewHashReference(localBranch, branchHead.Hash())
+		if err = repo.Storer.SetReference(branchRef); err != nil {
+			return err
+		}
+	}
+
+	tree, err := repo.Worktree()
+	if err != nil {
+		return err
+	}
+	return tree.Checkout(&gogit.CheckoutOptions{
+		Branch: localBranch,
+	})
+}
+
 var errNoChanges error = errors.New("no changes made to working directory")
 
 func commitAll(ctx context.Context, repo *gogit.Repository, commit *imagev1.CommitSpec, values TemplateData) (string, error) {

controllers/update_test.go

@@ -390,6 +390,62 @@ Images:
 				Expect(gitServer.StopSSH()).To(Succeed())
 			})
 
+			Context("with PushSpec", func() {
+
+				var (
+					update     *imagev1.ImageUpdateAutomation
+					pushBranch string
+				)
+
+				BeforeEach(func() {
+					commitInRepo(cloneLocalRepoURL, branch, "Install setter marker", func(tmp string) {
+						replaceMarker(tmp, policyKey)
+					})
+					waitForNewHead(localRepo, branch)
+
+					pushBranch = "pr-" + randStringRunes(5)
+
+					update = &imagev1.ImageUpdateAutomation{
+						Spec: imagev1.ImageUpdateAutomationSpec{
+							Interval: metav1.Duration{Duration: 2 * time.Hour},
+							Checkout: imagev1.GitCheckoutSpec{
+								GitRepositoryRef: meta.LocalObjectReference{
+									Name: gitRepoKey.Name,
+								},
+								Branch: branch,
+							},
+							Update: &imagev1.UpdateStrategy{
+								Strategy: imagev1.UpdateStrategySetters,
+							},
+							Commit: imagev1.CommitSpec{
+								MessageTemplate: commitMessage,
+							},
+							Push: &imagev1.PushSpec{
+								Branch: pushBranch,
+							},
+						},
+					}
+					update.Name = "update-" + randStringRunes(5)
+					update.Namespace = namespace.Name
+
+					Expect(k8sClient.Create(context.Background(), update)).To(Succeed())
+				})
+
+				It("creates and pushes the push branch", func() {
+					waitForNewHead(localRepo, pushBranch)
+					head, err := localRepo.Reference(plumbing.NewRemoteReferenceName(originRemote, pushBranch), true)
+					Expect(err).NotTo(HaveOccurred())
+					commit, err := localRepo.CommitObject(head.Hash())
+					Expect(err).ToNot(HaveOccurred())
+					Expect(commit.Message).To(Equal(commitMessage))
+				})
+
+				AfterEach(func() {
+					Expect(k8sClient.Delete(context.Background(), update)).To(Succeed())
+				})
+
+			})
+
 			Context("with Setters", func() {
 
 				var (
@@ -586,20 +642,49 @@ func setterRef(name types.NamespacedName) string {
 	return fmt.Sprintf(`{"%s": "%s:%s"}`, update.SetterShortHand, name.Namespace, name.Name)
 }
 
+// waitForHead fetches the remote branch given until it differs from
+// the remote ref locally (or if there's no ref locally, until it has
+// fetched the remote branch). It resets the working tree head to the
+// remote branch ref.
 func waitForNewHead(repo *git.Repository, branch string) {
-	head, _ := repo.Head()
-	headHash := head.Hash().String()
 	working, err := repo.Worktree()
 	Expect(err).ToNot(HaveOccurred())
+
+	// Try to find the remote branch in the repo locally; this will
+	// fail if we're on a branch that didn't exist when we cloned the
+	// repo (e.g., if the automation is pushing to another branch).
+	remoteHeadHash := ""
+	remoteBranch := plumbing.NewRemoteReferenceName(originRemote, branch)
+	remoteHead, err := repo.Reference(remoteBranch, false)
+	if err != plumbing.ErrReferenceNotFound {
+		Expect(err).ToNot(HaveOccurred())
+	}
+	if err == nil {
+		remoteHeadHash = remoteHead.Hash().String()
+	} // otherwise, any reference fetched will do.
+
+	// Now try to fetch new commits from that remote branch
 	Eventually(func() bool {
-		if working.Pull(&git.PullOptions{
-			ReferenceName: plumbing.NewBranchReferenceName(branch),
+		if err := repo.Fetch(&git.FetchOptions{
+			RefSpecs: []config.RefSpec{
+				config.RefSpec("refs/heads/" + branch + ":refs/remotes/origin/" + branch),
+			},
 		}); err != nil {
 			return false
 		}
-		h, _ := repo.Head()
-		return headHash != h.Hash().String()
+		remoteHead, err = repo.Reference(remoteBranch, false)
+		if err != nil {
+			return false
+		}
+		return remoteHead.Hash().String() != remoteHeadHash
 	}, timeout, time.Second).Should(BeTrue())
+
+	// New commits in the remote branch -- reset the working tree head
+	// to that. Note this does not create a local branch tracking the
+	// remote, so it is a detached head.
+	Expect(working.Reset(&git.ResetOptions{
+		Commit: remoteHead.Hash(),
+	})).To(Succeed())
 }
 
 func compareRepoWithExpected(repoURL, branch, fixture string, changeFixture func(tmp string)) {