feat: refactor implementation to be able to create and modify GH deployment through a k8s object

Author: Kaitou786

config/samples/git_v1_gitdeployment.yaml

@@ -2,6 +2,8 @@ apiVersion: git.flanksource.com/v1
 kind: GitDeployment
 metadata:
   name: gitdeployment-sample
+  labels:
+    git.flanksource.com/repository: gitrepository-sample
 spec:
   # Add fields here
-  ref: add-git-ssh-connector
+  ref: git-deployment-branch-1

connectors/github.go

@@ -202,36 +202,79 @@ func (g *Github) ReconcileDeployments(ctx context.Context, repository *gitv1.Git
 	if err := g.k8sCrd.List(ctx, &k8sCrds, listOptions); err != nil {
 		return err
 	}
-	inK8sByName := map[string]*gitv1.GitDeployment{}
+	inK8sByRef := map[string]*gitv1.GitDeployment{}
+	inGhByRef := map[string]*gitv1.GitDeployment{}
+	for _, ghCrd := range ghCrds {
+		inGhByRef[ghCrd.Spec.Ref] = ghCrd.DeepCopy()
+	}
 	for _, k8sCrd := range k8sCrds.Items {
-		inK8sByName[k8sCrd.Spec.Name] = k8sCrd.DeepCopy()
+		inK8sByRef[k8sCrd.Spec.Ref] = k8sCrd.DeepCopy()
+		if k8sCrd.Status.Ref != "" {
+			// Presence of Status.Ref will show that the GH Deployment is present.
+			// Help us to make sure we don't create it again as in case of update request
+			// we won't find this Ref in the Spec.Ref because of that we might create a new CRD will be created since there is GH deployment present
+			// if Spec.Ref != Status.Ref => the Deployment needs to be updated
+			inK8sByRef[k8sCrd.Status.Ref] = k8sCrd.DeepCopy()
+		}
 	}
-	for _, ghCrd := range ghCrds {
-		k8sCrd, found := inK8sByName[ghCrd.Spec.Name]
-		if !found {
-			if err := g.k8sCrd.Create(ctx, &ghCrd); err != nil {
-				log.Error(err, "failed to create GitDeployment CRD", "Deployment", ghCrd.Spec.Name)
+	// Create Git Deployment from the CRD
+	for _, k8sCrd := range k8sCrds.Items {
+		// Make sure that the GH deployment not exist while comparing with both Status.Ref and Spec.Ref
+		ghCrd, found := inGhByRef[k8sCrd.Spec.Ref]
+		_, foundInStatus := inGhByRef[k8sCrd.Status.Ref]
+		if !found && !foundInStatus {
+			// Creates new GH deployment based on the Specs received in the k8s object
+			log.Info("Creating new deployment on GH")
+			deployment, _, err := g.scm.Deployments.Create(ctx, githubFetcher.repositoryName(), getDeploymentInputObject(k8sCrd))
+			if err != nil {
 				return err
 			}
-			log.Info("Deployment created", "deployment", ghCrd.Spec.Name)
-		} else if k8sCrd.Spec.Ref != ghCrd.Spec.Ref {
-			log.Info("Creating a new deployment")
+			k8sCrd.Spec = getGitDeploymentSpec(deployment)
+			k8sCrd.Status = getGitDeploymentStatus(deployment)
+			err = g.k8sCrd.Update(ctx, &k8sCrd)
+			if err != nil {
+				return err
+			}
+		} else if k8sCrd.Status.Ref != "" && (k8sCrd.Status.Ref != k8sCrd.Spec.Ref) {
+			// Process the Update request
+			log.Info("Updating deployment")
 			//Delete the existing deployment on github and create a new one
-			if _, _, err := g.scm.Deployments.Create(ctx, githubFetcher.repositoryName(), getDeploymentInputObject(*k8sCrd)); err != nil {
+			deployment, _, err := g.scm.Deployments.Create(ctx, githubFetcher.repositoryName(), getDeploymentInputObject(k8sCrd))
+			if err != nil {
 				return err
 			}
-
-			if _, err := g.scm.Deployments.Delete(ctx, githubFetcher.repositoryName(), ghCrd.Spec.ID); err != nil {
+			log.Info("Deleting Deployment", "ID", k8sCrd.Status.ID)
+			if _, err := g.scm.Deployments.Delete(ctx, githubFetcher.repositoryName(), k8sCrd.Status.ID); err != nil {
 				return err
 			}
-			if err := g.k8sCrd.Delete(ctx, &ghCrd); err != nil {
+			k8sCrd.Spec = getGitDeploymentSpec(deployment)
+			k8sCrd.Status = getGitDeploymentStatus(deployment)
+			err = g.k8sCrd.Update(ctx, &k8sCrd)
+			if err != nil {
 				return err
 			}
-			log.Info("Deployment updated", "deployment", ghCrd.Spec.Name)
 		} else {
-			log.Info("Deployment did not change", "deployment", ghCrd.Spec.Name)
+			// Status.Ref == "" after the spec is found on the GH deployment.
+			// Conclusion the k8sCRD is created with the same spec as present on the GH deployment prior to GH deployment start
+			// In this case we'll update the k8sCRD from the details from GH deployment
+			k8sCrd.Spec = ghCrd.Spec
+			k8sCrd.Status = ghCrd.Status
+			err = g.k8sCrd.Update(ctx, &k8sCrd)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	// Create the k8s CRD for all other deployments present on the GH repository
+	for _, ghCrd := range ghCrds {
+		_, found := inK8sByRef[ghCrd.Spec.Ref]
+		if !found {
+			if err := g.k8sCrd.Create(ctx, &ghCrd); err != nil {
+				return err
+			}
 		}
 	}
+	log.Info("GH deployments and k8s CRDs are in sync")
 
 	return nil
 }

connectors/github_util.go

@@ -3,6 +3,7 @@ package connectors
 import (
 	"context"
 	"fmt"
+	"math/rand"
 	"strconv"
 	"strings"
 	"time"
@@ -157,30 +158,15 @@ func (g *GithubFetcher) BuildDeploymentCRDsFromGithub(ctx context.Context, lastU
 func (g *GithubFetcher) BuildDeploymentCRDFromGithub(ctx context.Context, deployment *scm.Deployment) *gitv1.GitDeployment {
 	crd := &gitv1.GitDeployment{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:      g.deploymentName(g.repository.Name, deployment.Name, deployment.Ref),
+			Name:      g.deploymentName(g.repository.Name),
 			Namespace: g.repository.Namespace,
 			Labels: map[string]string{
 				"git.flanksource.com/repository": g.repository.Name,
 				"git.flanksource.com/deployment": deployment.Name,
 			},
 		},
-		Spec: gitv1.GitDeploymentSpec{
-			Ref:         deployment.Ref,
-			Sha:         deployment.Sha,
-			Name:        deployment.Name,
-			ID:          deployment.ID,
-			Environment: deployment.Environment,
-			Description: deployment.Description,
-		},
-		Status: gitv1.GitDeploymentStatus{
-			Ref:            deployment.Ref,
-			Sha:            deployment.Sha,
-			DeploymentLink: deployment.Link,
-			StatusLink:     deployment.StatusLink,
-			ID:             deployment.ID,
-			Name:           deployment.Name,
-			Environment:    deployment.Environment,
-		},
+		Spec:   getGitDeploymentSpec(deployment),
+		Status: getGitDeploymentStatus(deployment),
 	}
 	return crd
 }
@@ -193,10 +179,33 @@ func (g *GithubFetcher) branchName(repository string, name string) string {
 	return fmt.Sprintf("%s-%s", repository, name)
 }
 
-func (g *GithubFetcher) deploymentName(repository, name, ref string) string {
-	return fmt.Sprintf("%s-%s-%s", repository, name, ref)
+func (g *GithubFetcher) deploymentName(repository string) string {
+	return fmt.Sprintf("%s-%d", repository, rand.Int())
 }
 
 func (g *GithubFetcher) pullRequestName(repository string, number int) string {
 	return fmt.Sprintf("%s-%d", repository, number)
 }
+
+func getGitDeploymentStatus(deployment *scm.Deployment) gitv1.GitDeploymentStatus {
+	return gitv1.GitDeploymentStatus{
+		Ref:            deployment.Ref,
+		Sha:            deployment.Sha,
+		DeploymentLink: deployment.Link,
+		StatusLink:     deployment.StatusLink,
+		ID:             deployment.ID,
+		Name:           deployment.Name,
+		Environment:    deployment.Environment,
+	}
+}
+
+func getGitDeploymentSpec(deployment *scm.Deployment) gitv1.GitDeploymentSpec {
+	return gitv1.GitDeploymentSpec{
+		Ref:         deployment.Ref,
+		Sha:         deployment.Sha,
+		Name:        deployment.Name,
+		ID:          deployment.ID,
+		Environment: deployment.Environment,
+		Description: deployment.Description,
+	}
+}

controllers/suite_test.go

@@ -50,7 +50,8 @@ func TestAPIs(t *testing.T) {
 }
 
 var _ = BeforeSuite(func(done Done) {
-	logf.SetLogger(zap.LoggerTo(GinkgoWriter, true))
+	//TODO zap.LoggerTo is deprecated, need to move to Zap.New()
+	logf.SetLogger(zap.LoggerTo(GinkgoWriter, true)) //nolint: staticcheck
 
 	By("bootstrapping test environment")
 	testEnv = &envtest.Environment{