Add debug log output for execGit. (#25)

Author: bigkevmcd

cmd/services/main.go

@@ -7,10 +7,11 @@ import (
 	"os"
 
 	"github.com/mitchellh/go-homedir"
-	"github.com/rhd-gitops-example/services/pkg/avancement"
-	"github.com/rhd-gitops-example/services/pkg/git"
 	"github.com/tcnksm/go-gitconfig"
 	"github.com/urfave/cli/v2"
+
+	"github.com/rhd-gitops-example/services/pkg/avancement"
+	"github.com/rhd-gitops-example/services/pkg/git"
 )
 
 const (
@@ -22,6 +23,7 @@ const (
 	cacheDirFlag    = "cache-dir"
 	nameFlag        = "commit-name"
 	emailFlag       = "commit-email"
+	debugFlag       = "debug"
 )
 
 var (
@@ -32,6 +34,13 @@ var (
 			EnvVars:  []string{"GITHUB_TOKEN"},
 			Required: true,
 		},
+		&cli.BoolFlag{
+			Name:     debugFlag,
+			Usage:    "additional debug logging output",
+			EnvVars:  []string{"DEBUG_SERVICES"},
+			Value:    false,
+			Required: false,
+		},
 	}
 
 	promoteFlags = []cli.Flag{
@@ -103,6 +112,7 @@ func promoteAction(c *cli.Context) error {
 	toRepo := c.String(toFlag)
 	service := c.String(serviceFlag)
 	newBranchName := c.String(branchNameFlag)
+	debug := c.Bool(debugFlag)
 
 	cacheDir, err := homedir.Expand(c.String(cacheDirFlag))
 	if err != nil {
@@ -113,7 +123,7 @@ func promoteAction(c *cli.Context) error {
 	if err != nil {
 		return fmt.Errorf("unable to establish credentials: %w", err)
 	}
-	return avancement.New(cacheDir, author).Promote(service, fromRepo, toRepo, newBranchName)
+	return avancement.New(cacheDir, author, avancement.WithDebug(debug)).Promote(service, fromRepo, toRepo, newBranchName)
 }
 
 func newAuthor(c *cli.Context) (*git.Author, error) {

pkg/avancement/service_manager.go

@@ -18,29 +18,43 @@ type ServiceManager struct {
 	author        *git.Author
 	clientFactory scmClientFactory
 	repoFactory   repoFactory
+	debug         bool
 }
 
 const (
 	defaultCommitMsg = "this is a commit"
 )
 
 type scmClientFactory func(token string) *scm.Client
-type repoFactory func(url, localPath string) (git.Repo, error)
+type repoFactory func(url, localPath string, debug bool) (git.Repo, error)
+type serviceOpt func(*ServiceManager)
 
 // New creates and returns a new ServiceManager.
 //
 // The cacheDir used to checkout the source and destination repos.
 // The token is used to create a Git token
-func New(cacheDir string, author *git.Author) *ServiceManager {
-	return &ServiceManager{
+func New(cacheDir string, author *git.Author, opts ...serviceOpt) *ServiceManager {
+	sm := &ServiceManager{
 		cacheDir:      cacheDir,
 		author:        author,
 		clientFactory: git.CreateGitHubClient,
-		repoFactory: func(url, localPath string) (git.Repo, error) {
-			r, err := git.NewRepository(url, localPath)
+		repoFactory: func(url, localPath string, debug bool) (git.Repo, error) {
+			r, err := git.NewRepository(url, localPath, debug)
 			return git.Repo(r), err
 		},
 	}
+	for _, o := range opts {
+		o(sm)
+	}
+	return sm
+}
+
+// WithDebug is a service option that configures the ServiceManager for
+// additional debugging.
+func WithDebug(f bool) serviceOpt {
+	return func(sm *ServiceManager) {
+		sm.debug = f
+	}
 }
 
 // TODO: make this a command-line parameter defaulting to "master"
@@ -115,13 +129,13 @@ func (s *ServiceManager) cloneRepo(repoURL, branch string) (git.Repo, error) {
 	if err != nil {
 		return nil, err
 	}
-	repo, err := s.repoFactory(repoURL, path.Join(s.cacheDir, encode(repoURL, branch)))
+	repo, err := s.repoFactory(repoURL, path.Join(s.cacheDir, encode(repoURL, branch)), s.debug)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create repo for URL %s: %w", repoURL, err)
 	}
 	err = repo.Clone()
 	if err != nil {
-		return nil, fmt.Errorf("failed to clone repo %s: %w", repoURL, err)
+		return nil, err
 	}
 	return repo, nil
 }

pkg/avancement/service_manager_test.go

@@ -28,7 +28,7 @@ func TestPromoteWithSuccess(t *testing.T) {
 	}
 	sm := New("tmp", author)
 	sm.clientFactory = fakeClientFactory
-	sm.repoFactory = func(url, _ string) (git.Repo, error) {
+	sm.repoFactory = func(url, _ string, _ bool) (git.Repo, error) {
 		return git.Repo(repos[url]), nil
 	}
 	devRepo.AddFiles("/services/my-service/base/config/myfile.yaml")

pkg/git/repository.go

@@ -1,8 +1,10 @@
 package git
 
 import (
+	"bytes"
 	"fmt"
 	"io"
+	"log"
 	"net/url"
 	"os"
 	"os/exec"
@@ -17,18 +19,20 @@ type Repository struct {
 	LocalPath string
 	RepoURL   string
 	repoName  string
+	debug     bool
+	logger    func(fmt string, v ...interface{})
 }
 
 // NewRepository creates and returns a local cache of an upstream repository.
 //
 // The repoURL should be of the form https://github.com/myorg/myrepo.
 // The path should be a local directory where the contents are cloned to.
-func NewRepository(repoURL, localPath string) (*Repository, error) {
+func NewRepository(repoURL, localPath string, debug bool) (*Repository, error) {
 	name, err := repoName(repoURL)
 	if err != nil {
 		return nil, err
 	}
-	return &Repository{LocalPath: localPath, RepoURL: repoURL, repoName: name}, nil
+	return &Repository{LocalPath: localPath, RepoURL: repoURL, repoName: name, logger: log.Printf}, nil
 }
 
 func (g *Repository) repoPath(extras ...string) string {
@@ -41,17 +45,18 @@ func (r *Repository) Clone() error {
 	if err != nil {
 		return fmt.Errorf("error creating the cache dir %s: %w", r.LocalPath, err)
 	}
-	_, err = execGit(r.LocalPath, nil, "clone", r.RepoURL)
+	out, err := r.execGit(r.LocalPath, nil, "clone", r.RepoURL)
+	log.Printf("%s\n", out)
 	return err
 }
 
 func (r *Repository) Checkout(branch string) error {
-	_, err := execGit(r.repoPath(), nil, "checkout", branch)
+	_, err := r.execGit(r.repoPath(), nil, "checkout", branch)
 	return err
 }
 
 func (r *Repository) CheckoutAndCreate(branch string) error {
-	_, err := execGit(r.repoPath(), nil, "checkout", "-b", branch)
+	_, err := r.execGit(r.repoPath(), nil, "checkout", "-b", branch)
 	return err
 }
 
@@ -91,29 +96,38 @@ func (r *Repository) CopyFile(src, dst string) error {
 }
 
 func (r *Repository) StageFiles(filenames ...string) error {
-	_, err := execGit(r.repoPath(), nil, append([]string{"add"}, filenames...)...)
+	_, err := r.execGit(r.repoPath(), nil, append([]string{"add"}, filenames...)...)
 	return err
 }
 
 func (r *Repository) Commit(msg string, author *Author) error {
 	args := []string{"commit", "-m", msg}
-	_, err := execGit(r.repoPath(), envFromAuthor(author), args...)
+	_, err := r.execGit(r.repoPath(), envFromAuthor(author), args...)
 	return err
 }
 
 func (r *Repository) Push(branchName string) error {
 	args := []string{"push", "origin", branchName}
-	_, err := execGit(r.repoPath(), nil, args...)
+	_, err := r.execGit(r.repoPath(), nil, args...)
 	return err
 }
 
-func execGit(workingDir string, env []string, args ...string) ([]byte, error) {
+func (r *Repository) execGit(workingDir string, env []string, args ...string) ([]byte, error) {
 	cmd := exec.Command("git", args...)
 	if env != nil {
 		cmd.Env = append(os.Environ(), env...)
 	}
 	cmd.Dir = workingDir
-	return cmd.Output()
+	var b bytes.Buffer
+	cmd.Stdout = &b
+	cmd.Stderr = &b
+	err := cmd.Run()
+	out := b.Bytes()
+	// TODO: more sophisticated logging.
+	if err != nil && r.debug {
+		r.logger("DEBUG: %s\n", out)
+	}
+	return out, err
 }
 
 // TODO: this probably needs specialisation for GitLab URLs.

pkg/git/repository_test.go

@@ -1,6 +1,7 @@
 package git
 
 import (
+	"fmt"
 	"io/ioutil"
 	"net/url"
 	"os"
@@ -43,7 +44,7 @@ func TestRepoName(t *testing.T) {
 func TestCloneCreatesDirectory(t *testing.T) {
 	tempDir, cleanup := makeTempDir(t)
 	defer cleanup()
-	r, err := NewRepository(testRepository, path.Join(tempDir, "path"))
+	r, err := NewRepository(testRepository, path.Join(tempDir, "path"), false)
 	assertNoError(t, err)
 	err = r.Clone()
 	assertNoError(t, err)
@@ -69,24 +70,6 @@ func TestClone(t *testing.T) {
 	}
 }
 
-/* TestCheckout relates to earlier behaviour that dealt with branches within repos. We can revisit this.
-func TestCheckout(t *testing.T) {
-	r, cleanup := cloneTestRepository(t)
-	defer cleanup()
-
-	err := r.Checkout("updated-version")
-	assertNoError(t, err)
-
-	contents, err := ioutil.ReadFile(path.Join(r.LocalPath, "env-staging/service-a/deployment.txt"))
-	assertNoError(t, err)
-
-	want := "This is an updated version of this file.\n"
-	if diff := cmp.Diff(want, string(contents)); diff != "" {
-		t.Fatalf("failed to read file: %s", diff)
-	}
-}
-*/
-
 func TestWalk(t *testing.T) {
 	r, cleanup := cloneTestRepository(t)
 	defer cleanup()
@@ -201,7 +184,7 @@ func TestStageFiles(t *testing.T) {
 	err = r.StageFiles("services/service-a/new-file.txt")
 	assertNoError(t, err)
 
-	out := assertExecGit(t, r.repoPath("services/service-a"), "status", "--porcelain")
+	out := assertExecGit(t, r, r.repoPath("services/service-a"), "status", "--porcelain")
 	want := "A  services/service-a/new-file.txt\n"
 	if diff := cmp.Diff(want, string(out)); diff != "" {
 		t.Fatalf("file status not modified: %s", diff)
@@ -225,7 +208,7 @@ func TestCommit(t *testing.T) {
 	err = r.Commit("this is a test commit", &Author{Name: "Test User", Email: "[email protected]"})
 	assertNoError(t, err)
 
-	out := strings.Split(string(assertExecGit(t, r.repoPath("services/service-a"), "log", "-n", "1")), "\n")
+	out := strings.Split(string(assertExecGit(t, r, r.repoPath("services/service-a"), "log", "-n", "1")), "\n")
 	want := []string{"Author: Test User <[email protected]>", "    this is a test commit"}
 	if diff := cmp.Diff(want, out, cmpopts.IgnoreSliceElements(func(s string) bool {
 		return strings.HasPrefix(s, "commit") || strings.HasPrefix(s, "Date:") || s == ""
@@ -234,6 +217,23 @@ func TestCommit(t *testing.T) {
 	}
 }
 
+func TestExecGit(t *testing.T) {
+	r, cleanup := cloneTestRepository(t)
+	r.debug = true
+	captured := ""
+	r.logger = func(f string, v ...interface{}) {
+		captured = fmt.Sprintf(f, v...)
+	}
+	defer cleanup()
+	_, err := r.execGit(r.repoPath(), nil, "unknown")
+	test.AssertErrorMatch(t, "exit status 1", err)
+
+	want := "DEBUG: git: 'unknown' is not a git command. See 'git --help'."
+	if strings.TrimSpace(captured) != want {
+		t.Fatalf("execGit debug log failed: got %s, want %s", captured, want)
+	}
+}
+
 func TestPush(t *testing.T) {
 	if authToken() == "" {
 		t.Skip("no auth token to push the branch upstream")
@@ -255,7 +255,7 @@ func TestPush(t *testing.T) {
 
 func cloneTestRepository(t *testing.T) (*Repository, func()) {
 	tempDir, cleanup := makeTempDir(t)
-	r, err := NewRepository(authenticatedURL(t), tempDir)
+	r, err := NewRepository(authenticatedURL(t), tempDir, false)
 	assertNoError(t, err)
 	err = r.Clone()
 	assertNoError(t, err)
@@ -282,9 +282,9 @@ func makeTempDir(t *testing.T) (string, func()) {
 	}
 }
 
-func assertExecGit(t *testing.T, gitPath string, args ...string) []byte {
+func assertExecGit(t *testing.T, r *Repository, gitPath string, args ...string) []byte {
 	t.Helper()
-	out, err := execGit(gitPath, nil, args...)
+	out, err := r.execGit(gitPath, nil, args...)
 	if err != nil {
 		t.Fatalf("assertExecGit failed: %s (%s)", err, out)
 	}