copy from source repo (#31)

Support `--from path-to-local-repository`

Author: akihikokuroda

pkg/avancement/pull_request.go

@@ -11,11 +11,11 @@ import (
 // TODO: For the Head, should this try and determine whether or not this is a
 // fork ("user" of both repoURLs) and if so, simplify the Head?
 func makePullRequestInput(fromURL, toURL, branchName string) (*scm.PullRequestInput, error) {
-	fromUser, fromRepo, err := util.ExtractUserAndRepo(fromURL)
+	_, fromRepo, err := util.ExtractUserAndRepo(fromURL)
 	if err != nil {
 		return nil, err
 	}
-	_, toRepo, err := util.ExtractUserAndRepo(toURL)
+	fromUser, toRepo, err := util.ExtractUserAndRepo(toURL)
 	if err != nil {
 		return nil, err
 	}

pkg/avancement/service_manager.go

@@ -10,6 +10,7 @@ import (
 	"github.com/jenkins-x/go-scm/scm"
 
 	"github.com/rhd-gitops-example/services/pkg/git"
+	"github.com/rhd-gitops-example/services/pkg/local"
 	"github.com/rhd-gitops-example/services/pkg/util"
 )
 
@@ -18,6 +19,7 @@ type ServiceManager struct {
 	author        *git.Author
 	clientFactory scmClientFactory
 	repoFactory   repoFactory
+	localFactory  localFactory
 	debug         bool
 }
 
@@ -27,6 +29,7 @@ const (
 
 type scmClientFactory func(token string) *scm.Client
 type repoFactory func(url, localPath string, debug bool) (git.Repo, error)
+type localFactory func(localPath string, debug bool) (git.Source, error)
 type serviceOpt func(*ServiceManager)
 
 // New creates and returns a new ServiceManager.
@@ -42,6 +45,10 @@ func New(cacheDir string, author *git.Author, opts ...serviceOpt) *ServiceManage
 			r, err := git.NewRepository(url, localPath, debug)
 			return git.Repo(r), err
 		},
+		localFactory: func(localPath string, debug bool)(git.Source, error){
+			l := &local.Local{LocalPath: localPath, Debug: debug, Logger: log.Printf}
+			return git.Source(l), nil
+		},
 	}
 	for _, o := range opts {
 		o(sm)
@@ -80,22 +87,30 @@ func (s *ServiceManager) Promote(serviceName, fromURL, toURL, newBranchName stri
 		}
 	}(keepCache, &reposToDelete)
 
-	source, err := s.checkoutSourceRepo(fromURL, fromBranch)
-	if err != nil {
-		return err
-	}
-	reposToDelete = append(reposToDelete, source)
-
-	destination, err = s.checkoutDestinationRepo(toURL, newBranchName)
+	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)
+	copied := []string{}
+	if fromLocalRepo(fromURL) {
+		localSource, err := s.localFactory(fromURL, s.debug) 
+		copied, err = local.CopyConfig(serviceName, localSource, destination)
+		if err != nil {
+			return fmt.Errorf("failed to setup local repo: %w", err)
+		}
+	} else {
+		source, err = s.checkoutSourceRepo(fromURL, fromBranch)
+		if err != nil {
+			return fmt.Errorf("failed to checkout repo: %w", err)
+		}
+		reposToDelete = append(reposToDelete, source)
 
-	if err != nil {
-		return fmt.Errorf("failed to copy service: %w", err)
+		copied, err = git.CopyService(serviceName, source, destination)
+		if err != nil {
+			return fmt.Errorf("failed to copy service: %w", err)
+		}
 	}
 	if err := destination.StageFiles(copied...); err != nil {
 		return fmt.Errorf("failed to stage files: %w", err)
@@ -190,3 +205,10 @@ func addCredentialsIfNecessary(s string, a *git.Author) (string, error) {
 	parsed.User = url.UserPassword("promotion", a.Token)
 	return parsed.String(), nil
 }
+func fromLocalRepo(s string) bool {
+	parsed, err := url.Parse(s)
+	if err != nil || parsed.Scheme == "" {
+		return true
+	}
+	return false
+}

pkg/avancement/service_manager_test.go

@@ -2,6 +2,9 @@ package avancement
 
 import (
 	"testing"
+	"path/filepath"
+	"strings"
+	"path"
 
 	"github.com/jenkins-x/go-scm/scm"
 	fakescm "github.com/jenkins-x/go-scm/scm/driver/fake"
@@ -11,6 +14,7 @@ import (
 
 const (
 	dev     = "https://example.com/testing/dev-env"
+	ldev    = "/root/repo"
 	staging = "https://example.com/testing/staging-env"
 )
 
@@ -60,6 +64,52 @@ func promoteWithSuccess(t *testing.T, keepCache bool) {
 	}
 }
 
+func TestPromoteLocalWithSuccessKeepCacheFalse(t *testing.T) {
+	promoteLocalWithSuccess(t, false)
+}
+
+func TestPromoteLocalWithSuccessKeepCacheTrue(t *testing.T) {
+	promoteLocalWithSuccess(t, true)
+}
+
+func promoteLocalWithSuccess(t *testing.T, keepCache bool) {
+	dstBranch := "test-branch"
+	author := &git.Author{Name: "Testing User", Email: "[email protected]", Token: "test-token"}
+	client, _ := fakescm.NewDefault()
+	fakeClientFactory := func(s string) *scm.Client {
+		return client
+	}
+	stagingRepo := mock.New("/staging", "master")
+	devRepo := NewLocal("/dev")
+
+	sm := New("tmp", author)
+	sm.clientFactory = fakeClientFactory
+	sm.repoFactory = func(url, _ string, _ bool) (git.Repo, error) {
+		return git.Repo(stagingRepo), nil
+	}
+	sm.localFactory = func(path string, _ bool) (git.Source, error) {
+		return git.Source(devRepo), nil
+	}
+	sm.debug = true
+	devRepo.AddFiles("/config/myfile.yaml")
+
+	err := sm.Promote("my-service", ldev, staging, dstBranch, keepCache)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stagingRepo.AssertBranchCreated(t, "master", dstBranch)
+	stagingRepo.AssertFileCopiedInBranch(t, dstBranch, "/dev/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)
+	} else {
+		stagingRepo.AssertDeletedFromCache(t)
+	}
+}
+
 func TestAddCredentials(t *testing.T) {
 	testUser := &git.Author{Name: "Test User", Email: "[email protected]", Token: "test-token"}
 	tests := []struct {
@@ -124,3 +174,47 @@ func TestPromoteWithCacheDeletionFailure(t *testing.T) {
 	stagingRepo.AssertNotDeletedFromCache(t)
 	devRepo.AssertDeletedFromCache(t)
 }
+
+
+type mockSource struct {
+	files     []string
+	localPath string
+}
+
+func NewLocal(localPath string) *mockSource {
+	return &mockSource{localPath: localPath}
+}
+
+// Walk: a mock function to emulate what happens in Repository.Walk()
+// The Mock version is different: it iterates over mockSource.files[] and then drives
+// the visitor callback in CopyService() as usual.
+//
+// To preserve the same behaviour, we see that Repository Walk receives /full/path/to/repo/services/service-name
+// and then calls filePath.Walk() on /full/path/to/repo/services/ .
+// When CopyService() drives Walk(), 'base' is typically services/service-name
+// Thus we take each /full/path/to/file/in/mockSource.files[] and split it at 'services/' as happens in the Walk() method we're mocking.
+func (s *mockSource) Walk(base string, cb func(string, string) error) error {
+	if s.files == nil {
+		return nil
+	}
+	base = filepath.Join(s.localPath, "config")
+
+	for _, f := range s.files {
+		splitString := filepath.Dir(base) + "/"
+		splitPoint := strings.Index(f, splitString) + len(splitString)
+		prefix := f[:splitPoint]
+		name := f[splitPoint:]
+		err := cb(prefix, name)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *mockSource) AddFiles(name string) {
+	if s.files == nil {
+		s.files = []string{}
+	}
+	s.files = append(s.files, path.Join(s.localPath, name))
+}

pkg/local/local.go

@@ -0,0 +1,58 @@
+package local
+
+import (
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"github.com/rhd-gitops-example/services/pkg/git"
+)
+
+
+type Local struct {
+	LocalPath string
+	Debug     bool
+	Logger    func(fmt string, v ...interface{})
+}
+
+
+// CopyConfig takes the name of a service and a Source local service root path to be copied to a Destination.
+//
+// Only files under /path/to/local/repo/config/* are copied to the destination /services/[serviceName]/base/config/* 
+//
+// Returns the list of files that were copied, and possibly an error.
+func CopyConfig(serviceName string, source git.Source, dest git.Destination) ([]string, error) {
+
+	copied := []string{}
+	err := source.Walk("", func(prefix, name string) error {
+		sourcePath := path.Join(prefix, name)
+		destPath := pathForDestServiceConfig(serviceName, name)
+		err := dest.CopyFile(sourcePath, destPath)
+		if err == nil {
+			copied = append(copied, destPath)
+		}
+		return err
+	})
+	return copied, err
+}
+
+// pathForDestServiceConfig defines where in a 'gitops' repository the config
+// for a given service should live.
+func pathForDestServiceConfig(serviceName, name string) string {
+	return filepath.Join("services/", serviceName, "base", name)
+}
+
+func (l *Local) Walk(base string, cb func(prefix, name string) error) error {
+	base = filepath.Join(l.LocalPath, "config")
+	prefix := filepath.Dir(base) + "/"
+	return filepath.Walk(base, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() {
+			return nil
+		}
+		return cb(prefix, strings.TrimPrefix(path, prefix))
+	})
+}

pkg/local/local_test.go

@@ -0,0 +1,98 @@
+package local
+
+import (
+	"errors"
+	"io"
+	"path"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestCopyConfig(t *testing.T) {
+	s := &mockSource{localPath: "/tmp/testing"}
+	files := []string{"config/my-file.yaml", "config/this-file.yaml"}
+	copiedfiles := []string{"services/service-a/base/config/my-file.yaml", "services/service-a/base/config/this-file.yaml"}
+	for _, f := range files {
+		s.addFile(f)
+	}
+	d := &mockDestination{}
+
+	copied, err := CopyConfig("service-a", s, d)
+	if err != nil {
+		t.Fatal(err)
+	}
+	d.assertFilesWritten(t, copiedfiles)
+	if !reflect.DeepEqual(copiedfiles, copied) {
+		t.Fatalf("failed to copy the files, got %#v, want %#v", copied, files)
+	}
+}
+
+
+type mockSource struct {
+	files     []string
+	localPath string
+}
+
+// Walk: a mock function to emulate what happens in Repository.Walk()
+// The Mock version is different: it iterates over mockSource.files[] and then drives
+// the visitor callback in CopyService() as usual.
+//
+// To preserve the same behaviour, we see that Repository Walk receives /full/path/to/repo/services/service-name
+// and then calls filePath.Walk() on /full/path/to/repo/services/ .
+// When CopyService() drives Walk(), 'base' is typically services/service-name
+// Thus we take each /full/path/to/file/in/mockSource.files[] and split it at 'services/' as happens in the Walk() method we're mocking.
+func (s *mockSource) Walk(base string, cb func(string, string) error) error {
+	if s.files == nil {
+		return nil
+	}
+	base = filepath.Join(s.localPath, "config")
+
+	for _, f := range s.files {
+		splitString := filepath.Dir(base) + "/"
+		splitPoint := strings.Index(f, splitString) + len(splitString)
+		prefix := f[:splitPoint]
+		name := f[splitPoint:]
+		err := cb(prefix, name)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *mockSource) addFile(name string) {
+	if s.files == nil {
+		s.files = []string{}
+	}
+	s.files = append(s.files, path.Join(s.localPath, name))
+}
+
+type mockDestination struct {
+	written   []string
+	copyError error
+}
+
+func (d *mockDestination) CopyFile(src, dst string) error {
+	if d.written == nil {
+		d.written = []string{}
+	}
+	if d.copyError != nil {
+		return d.copyError
+	}
+	d.written = append(d.written, dst)
+	return nil
+}
+
+func (d *mockDestination) WriteFile(src io.Reader, dst string) error {
+	return errors.New("not implemented just now")
+}
+
+func (d *mockDestination) assertFilesWritten(t *testing.T, want []string) {
+	if diff := cmp.Diff(want, d.written); diff != "" {
+		t.Fatalf("written files do not match: %s", diff)
+	}
+}