Add promotions between environments in a repo

Users will have the ability to specify every facet of the source and
 destination environments: repo URL, branch name, and environment
 folder. New tests check for various combinations of those options.

Some minor changes were made to some repository implementation details,
so that it can checkout specific branches (rather than just the default)
and so that calling Clone() multiple times does not result in an error.

Implements #92

Author: Justin Kulikauskas

pkg/git/mock/file_info.go

@@ -0,0 +1,40 @@
+package mock
+
+import (
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// satisfies the os.FileInfo interface for mocking
+type mockFileInfo struct {
+	name string
+}
+
+func newFileInfo(name string) mockFileInfo {
+	return mockFileInfo{name}
+}
+
+func (f mockFileInfo) Name() string {
+	return filepath.Base(f.name)
+}
+
+func (f mockFileInfo) Size() int64 {
+	return 8
+}
+
+func (f mockFileInfo) Mode() os.FileMode {
+	return os.ModeDir
+}
+
+func (f mockFileInfo) ModTime() time.Time {
+	return time.Now()
+}
+
+func (f mockFileInfo) IsDir() bool {
+	return true
+}
+
+func (f mockFileInfo) Sys() interface{} {
+	return nil
+}

pkg/git/mock/mock.go

@@ -96,9 +96,13 @@ func (m *Repository) Commit(msg string, author *git.Author) error {
 	return m.CommitErr
 }
 
-// Not implemented
 func (m *Repository) DirectoriesUnderPath(path string) ([]os.FileInfo, error) {
-	return nil, nil
+	// For easy mocking, returns all files "added" to this repo.
+	dirs := make([]os.FileInfo, len(m.files))
+	for i, f := range m.files {
+		dirs[i] = newFileInfo(f)
+	}
+	return dirs, nil
 }
 
 func (m *Repository) GetUniqueEnvironmentFolder() (string, error) {

pkg/git/repository.go

@@ -24,6 +24,7 @@ type Repository struct {
 	tlsVerify bool
 	debug     bool
 	logger    func(fmt string, v ...interface{})
+	noPush    bool
 }
 
 // NewRepository creates and returns a local cache of an upstream repository.
@@ -48,6 +49,13 @@ func (r *Repository) Clone() error {
 	if err != nil {
 		return fmt.Errorf("error creating the cache dir %s: %w", r.LocalPath, err)
 	}
+
+	// Just pull if the repo is already cached
+	if _, err := os.Stat(r.repoPath()); !os.IsNotExist(err) {
+		_, err = r.execGit(r.repoPath(), nil, "pull")
+		return err
+	}
+
 	// Intentionally omit output as it can contain an access token
 	_, err = r.execGit(r.LocalPath, nil, "clone", r.RepoURL)
 	return err
@@ -102,15 +110,13 @@ func (r *Repository) WriteFile(src io.Reader, dst string) error {
 // Returns an error if there was a problem in doing so (including if more than one folder found)
 // string return type for ease of mocking, callers would use .Name() anyway
 func (r *Repository) GetUniqueEnvironmentFolder() (string, error) {
-	lookup := filepath.Join(r.repoPath(), "environments")
-
-	foundDirsUnderEnv, err := r.DirectoriesUnderPath(lookup)
+	foundDirsUnderEnv, err := r.DirectoriesUnderPath("environments")
 	if err != nil {
 		return "", err
 	}
 	numDirsUnderEnv := len(foundDirsUnderEnv)
 	if numDirsUnderEnv != 1 {
-		return "", fmt.Errorf("found %d directories under environments folder, wanted one. Looked under directory %s", numDirsUnderEnv, lookup)
+		return "", fmt.Errorf("found %d directories under environments folder, wanted one", numDirsUnderEnv)
 	}
 	foundEnvDir := foundDirsUnderEnv[0]
 	return foundEnvDir.Name(), nil
@@ -119,7 +125,8 @@ func (r *Repository) GetUniqueEnvironmentFolder() (string, error) {
 // Returns the directory names of those under a certain path (excluding sub-dirs)
 // Returns an error if a directory list attempt errored
 func (r *Repository) DirectoriesUnderPath(path string) ([]os.FileInfo, error) {
-	files, err := ioutil.ReadDir(path)
+	lookup := filepath.Join(r.repoPath(), path)
+	files, err := ioutil.ReadDir(lookup)
 	if err != nil {
 		return nil, err
 	}
@@ -187,6 +194,9 @@ func (r *Repository) Commit(msg string, author *Author) error {
 
 // Does a git push origin *branch name*
 func (r *Repository) Push(branchName string) error {
+	if r.noPush {
+		return nil
+	}
 	args := []string{"push", "origin", branchName}
 	_, err := r.execGit(r.repoPath(), nil, args...)
 	return err
@@ -253,3 +263,7 @@ func (r *Repository) DeleteCache() error {
 	}
 	return nil
 }
+
+func (r *Repository) DisablePush() {
+	r.noPush = true
+}

pkg/git/repository_test.go

@@ -70,6 +70,16 @@ func TestClone(t *testing.T) {
 	}
 }
 
+func TestCloneIsIdempotent(t *testing.T) {
+	r, cleanup := cloneTestRepository(t)
+	defer cleanup()
+
+	err := r.Clone()
+	if err != nil {
+		t.Fatalf("failed to clone repository after it had already been cloned: %v", err)
+	}
+}
+
 func TestWalk(t *testing.T) {
 	r, cleanup := cloneTestRepository(t)
 	defer cleanup()

pkg/promotion/env_location.go

@@ -0,0 +1,50 @@
+package promotion
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/rhd-gitops-example/services/pkg/util"
+)
+
+type EnvLocation struct {
+	RepoPath string // URL or local path
+	Branch   string
+	Folder   string
+}
+
+func (env EnvLocation) IsLocal() (bool, error) {
+	parsed, err := url.Parse(env.RepoPath)
+	if err != nil {
+		return false, fmt.Errorf("failed parsing URL for environment path: %w", err)
+	}
+	return parsed.Scheme == "", nil
+}
+
+// String implements Stringer so that messages (including logs, commits and PRs)
+// can reference EnvLocations consistently and in a more readable way.
+// When possible, it will shorten repository paths so that 'github.com/org/repo'
+// is just 'repo'. When not possible, it will use the entire URL.
+func (env EnvLocation) String() string {
+	var repoName string
+	local, err := env.IsLocal()
+	if err != nil {
+		repoName = env.RepoPath
+	} else {
+		_, repoName, err = util.ExtractUserAndRepo(env.RepoPath)
+		if err != nil {
+			repoName = env.RepoPath
+		}
+	}
+	if local {
+		return "local filesystem directory"
+	}
+
+	var b strings.Builder
+	fmt.Fprintf(&b, "branch %s in %s", env.Branch, repoName)
+	if env.Folder != "" {
+		fmt.Fprintf(&b, " (environment folder %s)", env.Folder)
+	}
+	return b.String()
+}

pkg/promotion/promote.go

@@ -14,20 +14,6 @@ import (
 	"github.com/jenkins-x/go-scm/scm"
 )
 
-type EnvLocation struct {
-	RepoPath string // URL or local path
-	Branch   string
-}
-
-func (env EnvLocation) IsLocal() bool {
-	parsed, err := url.Parse(env.RepoPath)
-	if err != nil {
-		log.Printf("Error while parsing URL for environment path: '%v', assuming it is local.\n", err)
-		return true
-	}
-	return parsed.Scheme == ""
-}
-
 // Promote is the main driver for promoting files between two
 // repositories.
 //
@@ -39,9 +25,13 @@ func (s *ServiceManager) Promote(serviceName string, from, to EnvLocation, newBr
 		defer clearCache(&reposToDelete)
 	}
 
+	fromIsLocal, err := from.IsLocal()
+	if err != nil {
+		return fmt.Errorf("failed to determine if repository is local: %w", err)
+	}
+
 	var source git.Source
-	var err error
-	if from.IsLocal() {
+	if fromIsLocal {
 		source = s.localFactory(from.RepoPath, s.debug)
 	} else {
 		source, err = s.checkoutSourceRepo(from.RepoPath, from.Branch)
@@ -54,18 +44,18 @@ func (s *ServiceManager) Promote(serviceName string, from, to EnvLocation, newBr
 		newBranchName = generateBranchName(source)
 	}
 
-	destination, err := s.checkoutDestinationRepo(to.RepoPath, newBranchName)
+	destination, err := s.checkoutDestinationRepo(to.RepoPath, to.Branch, newBranchName)
 	if err != nil {
 		return err
 	}
 	reposToDelete = append(reposToDelete, destination)
-	destinationEnvironment, err := destination.GetUniqueEnvironmentFolder()
+	destinationEnvironment, err := getEnvironmentFolder(destination, to.Folder)
 	if err != nil {
-		return fmt.Errorf("could not determine unique environment name for destination repository - check that only one directory exists under it and you can write to your cache folder")
+		return err
 	}
 
 	var copied []string
-	if from.IsLocal() {
+	if fromIsLocal {
 		copied, err = local.CopyConfig(serviceName, source, destination, destinationEnvironment)
 		if err != nil {
 			return fmt.Errorf("failed to set up local repository: %w", err)
@@ -76,9 +66,9 @@ func (s *ServiceManager) Promote(serviceName string, from, to EnvLocation, newBr
 			// should not happen, but just in case
 			return fmt.Errorf("failed to convert source '%v' to Git Repo", source)
 		}
-		sourceEnvironment, err := repo.GetUniqueEnvironmentFolder()
+		sourceEnvironment, err := getEnvironmentFolder(repo, from.Folder)
 		if err != nil {
-			return fmt.Errorf("could not determine unique environment name for source repository - check that only one directory exists under it and you can write to your cache folder")
+			return err
 		}
 
 		copied, err = git.CopyService(serviceName, source, destination, sourceEnvironment, destinationEnvironment)
@@ -141,9 +131,9 @@ func generateDefaultCommitMsg(source git.Source, serviceName string, from EnvLoc
 	repo, ok := source.(git.Repo)
 	if ok {
 		commit := repo.GetCommitID()
-		return fmt.Sprintf("Promoting service %s at commit %s from branch %s in %s.", serviceName, commit, from.Branch, from.RepoPath)
+		return fmt.Sprintf("Promote service %s at commit %s from %v", serviceName, commit, from)
 	} else {
-		return fmt.Sprintf("Promoting service %s from local filesystem directory %s.", serviceName, from.RepoPath)
+		return fmt.Sprintf("Promote service %s from local filesystem directory %s", serviceName, from.RepoPath)
 	}
 }
 
@@ -158,3 +148,27 @@ func createPullRequest(ctx context.Context, from, to EnvLocation, newBranchName,
 	pr, _, err := client.PullRequests.Create(ctx, pathToUse, prInput)
 	return pr, err
 }
+
+// getEnvironmentFolder returns the name of the folder to use, or an error.
+// Will return an error if the specified folder is not present in the repository,
+// or if there are multiple folders and one isn't specified in the args here.
+func getEnvironmentFolder(r git.Repo, folder string) (string, error) {
+	if folder == "" {
+		dir, err := r.GetUniqueEnvironmentFolder()
+		if err != nil {
+			return "", fmt.Errorf("could not determine unique environment name for source repository - check that only one directory exists under it and you can write to your cache folder")
+		}
+		return dir, nil
+	}
+
+	dirs, err := r.DirectoriesUnderPath("environments")
+	if err != nil {
+		return "", err
+	}
+	for _, dir := range dirs {
+		if dir.Name() == folder {
+			return dir.Name(), nil
+		}
+	}
+	return "", fmt.Errorf("did not find environment folder matching '%v', only found '%v'", folder, dirs)
+}