Delete the cache after promotion unless --keep-cache is specified (#30)

Author: dibbles

cmd/services/main.go

@@ -24,6 +24,7 @@ const (
 	nameFlag        = "commit-name"
 	emailFlag       = "commit-email"
 	debugFlag       = "debug"
+	keepCacheFlag   = "keep-cache"
 )
 
 var (
@@ -83,6 +84,12 @@ var (
 			Value:    false,
 			Required: false,
 		},
+		&cli.BoolFlag{
+			Name:     keepCacheFlag,
+			Usage:    "whether to retain the locally cloned repositories in the cache directory",
+			Value:    false,
+			Required: false,
+		},
 	}
 )
 
@@ -113,6 +120,7 @@ func promoteAction(c *cli.Context) error {
 	service := c.String(serviceFlag)
 	newBranchName := c.String(branchNameFlag)
 	debug := c.Bool(debugFlag)
+	keepCache := c.Bool(keepCacheFlag)
 
 	cacheDir, err := homedir.Expand(c.String(cacheDirFlag))
 	if err != nil {
@@ -123,7 +131,7 @@ func promoteAction(c *cli.Context) error {
 	if err != nil {
 		return fmt.Errorf("unable to establish credentials: %w", err)
 	}
-	return avancement.New(cacheDir, author, avancement.WithDebug(debug)).Promote(service, fromRepo, toRepo, newBranchName)
+	return avancement.New(cacheDir, author, avancement.WithDebug(debug)).Promote(service, fromRepo, toRepo, newBranchName, keepCache)
 }
 
 func newAuthor(c *cli.Context) (*git.Author, error) {

pkg/avancement/service_manager.go

@@ -65,15 +65,32 @@ const fromBranch = "master"
 //
 // It uses a Git cache to checkout the code to, and will copy the environment
 // configuration for the `fromURL` to the `toURL` in a named branch.
-func (s *ServiceManager) Promote(serviceName, fromURL, toURL, newBranchName string) error {
+func (s *ServiceManager) Promote(serviceName, fromURL, toURL, newBranchName string, keepCache bool) error {
+	var source, destination git.Repo
+	var reposToDelete []git.Repo
+
+	defer func(keepRepos bool, repos *[]git.Repo) {
+		if !keepRepos {
+			for _, repo := range *repos {
+				err := repo.DeleteCachedRepo()
+				if err != nil {
+					fmt.Errorf("failed deleting files from cache: %w", err)
+				}
+			}
+		}
+	}(keepCache, &reposToDelete)
+
 	source, err := s.checkoutSourceRepo(fromURL, fromBranch)
 	if err != nil {
 		return err
 	}
-	destination, err := s.checkoutDestinationRepo(toURL, newBranchName)
+	reposToDelete = append(reposToDelete, source)
+
+	destination, err = s.checkoutDestinationRepo(toURL, newBranchName)
 	if err != nil {
 		return fmt.Errorf("failed to checkout repo: %w", err)
 	}
+	reposToDelete = append(reposToDelete, destination)
 
 	copied, err := git.CopyService(serviceName, source, destination)
 

pkg/avancement/service_manager_test.go

@@ -14,7 +14,15 @@ const (
 	staging = "https://example.com/testing/staging-env"
 )
 
-func TestPromoteWithSuccess(t *testing.T) {
+func TestPromoteWithSuccessKeepCacheTrue(t *testing.T) {
+	promoteWithSuccess(t, true)
+}
+
+func TestPromoteWithSuccessKeepCacheFalse(t *testing.T) {
+	promoteWithSuccess(t, false)
+}
+
+func promoteWithSuccess(t *testing.T, keepCache bool) {
 	dstBranch := "test-branch"
 	author := &git.Author{Name: "Testing User", Email: "[email protected]", Token: "test-token"}
 	client, _ := fakescm.NewDefault()
@@ -33,7 +41,7 @@ func TestPromoteWithSuccess(t *testing.T) {
 	}
 	devRepo.AddFiles("/services/my-service/base/config/myfile.yaml")
 
-	err := sm.Promote("my-service", dev, staging, dstBranch)
+	err := sm.Promote("my-service", dev, staging, dstBranch, keepCache)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -42,6 +50,14 @@ func TestPromoteWithSuccess(t *testing.T) {
 	stagingRepo.AssertFileCopiedInBranch(t, dstBranch, "/dev/services/my-service/base/config/myfile.yaml", "/staging/services/my-service/base/config/myfile.yaml")
 	stagingRepo.AssertCommit(t, dstBranch, defaultCommitMsg, author)
 	stagingRepo.AssertPush(t, dstBranch)
+
+	if keepCache {
+		stagingRepo.AssertNotDeletedFromCache(t)
+		devRepo.AssertNotDeletedFromCache(t)
+	} else {
+		stagingRepo.AssertDeletedFromCache(t)
+		devRepo.AssertDeletedFromCache(t)
+	}
 }
 
 func TestAddCredentials(t *testing.T) {
@@ -75,3 +91,36 @@ func mustAddCredentials(t *testing.T, repoURL string, a *git.Author) string {
 	}
 	return u
 }
+
+func TestPromoteWithCacheDeletionFailure(t *testing.T) {
+	dstBranch := mock.FAIL_DELETING_REPO_BRANCH
+	author := &git.Author{Name: "Testing User", Email: "[email protected]", Token: "test-token"}
+	client, _ := fakescm.NewDefault()
+	fakeClientFactory := func(s string) *scm.Client {
+		return client
+	}
+	devRepo, stagingRepo := mock.New("/dev", "master"), mock.New("/staging", "master")
+	repos := map[string]*mock.Repository{
+		mustAddCredentials(t, dev, author):     devRepo,
+		mustAddCredentials(t, staging, author): stagingRepo,
+	}
+	sm := New("tmp", author)
+	sm.clientFactory = fakeClientFactory
+	sm.repoFactory = func(url, _ string, _ bool) (git.Repo, error) {
+		return git.Repo(repos[url]), nil
+	}
+	devRepo.AddFiles("/services/my-service/base/config/myfile.yaml")
+
+	err := sm.Promote("my-service", dev, staging, dstBranch, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stagingRepo.AssertBranchCreated(t, "master", dstBranch)
+	stagingRepo.AssertFileCopiedInBranch(t, dstBranch, "/dev/services/my-service/base/config/myfile.yaml", "/staging/services/my-service/base/config/myfile.yaml")
+	stagingRepo.AssertCommit(t, dstBranch, defaultCommitMsg, author)
+	stagingRepo.AssertPush(t, dstBranch)
+
+	stagingRepo.AssertNotDeletedFromCache(t)
+	devRepo.AssertDeletedFromCache(t)
+}

pkg/git/interface.go

@@ -26,4 +26,5 @@ type Repo interface {
 	StageFiles(filenames ...string) error
 	Commit(msg string, author *Author) error
 	Push(branch string) error
+	DeleteCachedRepo() error
 }

pkg/git/mock/mock.go

@@ -1,6 +1,7 @@
 package mock
 
 import (
+	"errors"
 	"io"
 	"path"
 	"path/filepath"
@@ -10,6 +11,10 @@ import (
 	"github.com/rhd-gitops-example/services/pkg/git"
 )
 
+/* FAIL_DELETING_REPO_BRANCH is a branch name that when used as a target branch will
+   cause the the deletion from the cache to fail (in tests only) */
+const FAIL_DELETING_REPO_BRANCH = "fail_to_delete_repo"
+
 type Repository struct {
 	currentBranch string
 	knownBranches []string
@@ -31,6 +36,9 @@ type Repository struct {
 
 	pushedBranches []string
 	pushErr        error
+
+	deleted    bool
+	deletedErr error
 }
 
 // New creates and returns a new git.Cache implementation that operates entirely
@@ -140,6 +148,17 @@ func (m *Repository) AddFiles(names ...string) {
 	}
 }
 
+// DeleteCachedRepo deletes the repo from the local cache directory
+func (m *Repository) DeleteCachedRepo() error {
+	if m.currentBranch == FAIL_DELETING_REPO_BRANCH {
+		m.deleted = false
+		m.deletedErr = errors.New("MOCK FAILURE DELETING REPO MESSAGE")
+	} else {
+		m.deleted = true
+	}
+	return m.deletedErr
+}
+
 // AssertBranchCreated asserts that the named branch was created from the from
 // branch, using the `CheckoutAndCreate` implementation.
 func (m *Repository) AssertBranchCreated(t *testing.T, from, name string) {
@@ -171,6 +190,20 @@ func (m *Repository) AssertPush(t *testing.T, branch string) {
 	}
 }
 
+// AssertDeletedFromCache asserts that delete was called to remove the local repo
+func (m *Repository) AssertDeletedFromCache(t *testing.T) {
+	if !m.deleted {
+		t.Fatalf("repo was not deleted from the promotion cache directory")
+	}
+}
+
+// AssertNotDeletedFromCache asserts that delete was called to remove the local repo
+func (m *Repository) AssertNotDeletedFromCache(t *testing.T) {
+	if m.deleted {
+		t.Fatalf("repo was unexpectedly deleted from the promotion cache directory : %w", m.deletedErr)
+	}
+}
+
 func key(v ...string) string {
 	return strings.Join(v, ":")
 }

pkg/git/repository.go

@@ -155,3 +155,12 @@ func envFromAuthor(a *Author) []string {
 		sf("GIT_AUTHOR_NAME", a.Name),
 		sf("GIT_AUTHOR_EMAIL", a.Email)}
 }
+
+// DeleteCachedRepo removes the local clones from the promotion cache
+func (r *Repository) DeleteCachedRepo() error {
+	err := os.RemoveAll(r.LocalPath)
+	if err != nil {
+		return fmt.Errorf("failed deleting `%s` : %w", r.LocalPath, err)
+	}
+	return nil
+}