Merge pull request #121 from fluxcd/push-to-branch

Push to branch

Author: squaremo

api/v1alpha1/imageupdateautomation_types.go

@@ -39,10 +39,16 @@ type ImageUpdateAutomationSpec struct {
 	// value.
 	// +kubebuilder:default={"strategy":"Setters"}
 	Update *UpdateStrategy `json:"update,omitempty"`
-	// Commit specifies how to commit to the git repo
+	// Commit specifies how to commit to the git repository.
 	// +required
 	Commit CommitSpec `json:"commit"`
 
+	// Push specifies how and where to push commits made by the
+	// automation. If missing, commits are pushed (back) to
+	// `.spec.checkout.branch`.
+	// +optional
+	Push *PushSpec `json:"push,omitempty"`
+
 	// Suspend tells the controller to not run this automation, until
 	// it is unset (or set to false). Defaults to false.
 	// +optional
@@ -54,7 +60,9 @@ type GitCheckoutSpec struct {
 	// to a git repository to update files in.
 	// +required
 	GitRepositoryRef meta.LocalObjectReference `json:"gitRepositoryRef"`
-	// Branch gives the branch to clone from the git repository.
+	// Branch gives the branch to clone from the git repository. If
+	// `.spec.push` is not supplied, commits will also be pushed to
+	// this branch.
 	// +required
 	Branch string `json:"branch"`
 }
@@ -95,6 +103,15 @@ type CommitSpec struct {
 	MessageTemplate string `json:"messageTemplate,omitempty"`
 }
 
+// PushSpec specifies how and where to push commits.
+type PushSpec struct {
+	// Branch specifies that commits should be pushed to the branch
+	// named. The branch is created using `.spec.checkout.branch` as the
+	// starting point, if it doesn't already exist.
+	// +required
+	Branch string `json:"branch"`
+}
+
 // ImageUpdateAutomationStatus defines the observed state of ImageUpdateAutomation
 type ImageUpdateAutomationStatus struct {
 	// LastAutomationRunTime records the last time the controller ran

api/v1alpha1/zz_generated.deepcopy.go

@@ -47,6 +47,8 @@ spec:
                 properties:
                   branch:
                     description: Branch gives the branch to clone from the git repository.
+                      If `.spec.push` is not supplied, commits will also be pushed
+                      to this branch.
                     type: string
                   gitRepositoryRef:
                     description: GitRepositoryRef refers to the resource giving access
@@ -63,7 +65,7 @@ spec:
                 - gitRepositoryRef
                 type: object
               commit:
-                description: Commit specifies how to commit to the git repo
+                description: Commit specifies how to commit to the git repository.
                 properties:
                   authorEmail:
                     description: AuthorEmail gives the email to provide when making
@@ -86,6 +88,18 @@ spec:
                 description: Interval gives an lower bound for how often the automation
                   run should be attempted.
                 type: string
+              push:
+                description: Push specifies how and where to push commits made by
+                  the automation. If missing, commits are pushed (back) to `.spec.checkout.branch`.
+                properties:
+                  branch:
+                    description: Branch specifies that commits should be pushed to
+                      the branch named. The branch is created using `.spec.checkout.branch`
+                      as the starting point, if it doesn't already exist.
+                    type: string
+                required:
+                - branch
+                type: object
               suspend:
                 description: Suspend tells the controller to not run this automation,
                   until it is unset (or set to false). Defaults to false.

config/crd/bases/image.toolkit.fluxcd.io_imageupdateautomations.yaml

@@ -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/imageupdateautomation_controller.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)) {