Add gitlab and github enterprise support (#67)

New flags:
repository-type: github, gitlab, or ghe (default: githab)
tls-verify: true or false (default: true)

Author: akihikokuroda

pkg/avancement/pull_request.go

@@ -13,7 +13,7 @@ import (
 func makePullRequestInput(fromLocal bool, fromURL, toURL, branchName, prBody string) (*scm.PullRequestInput, error) {
 	var title string
 
-	fromUser, toRepo, err := util.ExtractUserAndRepo(toURL)
+	_, toRepo, err := util.ExtractUserAndRepo(toURL)
 	if err != nil {
 		return nil, err
 	}
@@ -30,7 +30,7 @@ func makePullRequestInput(fromLocal bool, fromURL, toURL, branchName, prBody str
 
 	return &scm.PullRequestInput{
 		Title: title,
-		Head:  fmt.Sprintf("%s:%s", fromUser, branchName),
+		Head:  branchName,
 		Base:  "master",
 		Body:  prBody,
 	}, nil

pkg/avancement/pull_request_test.go

@@ -16,7 +16,7 @@ func TestMakePullRequestInput(t *testing.T) {
 
 	want := &scm.PullRequestInput{
 		Title: "promotion from dev-env to prod-env",
-		Head:  "project:my-test-branch",
+		Head:  "my-test-branch",
 		Base:  "master",
 		Body:  "foo bar wibble",
 	}

pkg/avancement/service_manager.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/rhd-gitops-example/services/pkg/git"
 	"github.com/rhd-gitops-example/services/pkg/local"
-	"github.com/rhd-gitops-example/services/pkg/util"
 
 	"github.com/google/uuid"
 )
@@ -24,11 +23,13 @@ type ServiceManager struct {
 	clientFactory scmClientFactory
 	repoFactory   repoFactory
 	localFactory  localFactory
+	tlsVerify     bool
+	repoType      string
 	debug         bool
 }
 
-type scmClientFactory func(token string) *scm.Client
-type repoFactory func(url, localPath string, debug bool) (git.Repo, error)
+type scmClientFactory func(token, toURL, repoType string, tlsVerify bool) *scm.Client
+type repoFactory func(url, localPath string, tlsVerify, debug bool) (git.Repo, error)
 type localFactory func(localPath string, debug bool) git.Source
 type serviceOpt func(*ServiceManager)
 
@@ -40,9 +41,9 @@ func New(cacheDir string, author *git.Author, opts ...serviceOpt) *ServiceManage
 	sm := &ServiceManager{
 		cacheDir:      cacheDir,
 		author:        author,
-		clientFactory: git.CreateGitHubClient,
-		repoFactory: func(url, localPath string, debug bool) (git.Repo, error) {
-			r, err := git.NewRepository(url, localPath, debug)
+		clientFactory: git.CreateClient,
+		repoFactory: func(url, localPath string, tlsVerify, debug bool) (git.Repo, error) {
+			r, err := git.NewRepository(url, localPath, tlsVerify, debug)
 			return git.Repo(r), err
 		},
 		localFactory: func(localPath string, debug bool) git.Source {
@@ -64,6 +65,22 @@ func WithDebug(f bool) serviceOpt {
 	}
 }
 
+// WithTlsVerify is a service option that configures the ServiceManager for
+// TLS verify option.
+func WithInsecureSkipVerify(f bool) serviceOpt {
+	return func(sm *ServiceManager) {
+		sm.tlsVerify = !f
+	}
+}
+
+// WithRepType is a service option that configures the ServiceManager for
+// repository type option.  Supported values are "github", "gitlab, and "ghe"
+func WithRepoType(f string) serviceOpt {
+	return func(sm *ServiceManager) {
+		sm.repoType = strings.ToLower(f)
+	}
+}
+
 // TODO: make this a command-line parameter defaulting to "master"
 const fromBranch = "master"
 
@@ -150,7 +167,7 @@ func (s *ServiceManager) Promote(serviceName, fromURL, toURL, newBranchName, mes
 	}
 
 	ctx := context.Background()
-	pr, err := createPullRequest(ctx, fromURL, toURL, newBranchName, commitMsg, s.clientFactory(s.author.Token), isLocal)
+	pr, err := createPullRequest(ctx, fromURL, toURL, newBranchName, commitMsg, s.clientFactory(s.author.Token, toURL, s.repoType, s.tlsVerify), isLocal)
 	if err != nil {
 		message := fmt.Sprintf("failed to create a pull-request for branch %s, error: %s", newBranchName, err)
 		return git.GitError(message, toURL)
@@ -192,7 +209,7 @@ 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)), s.debug)
+	repo, err := s.repoFactory(repoURL, path.Join(s.cacheDir, encode(repoURL, branch)), s.tlsVerify, s.debug)
 	if err != nil {
 		message := fmt.Sprintf("failed to clone repository, error is: %s", err.Error())
 		return nil, git.GitError(message, repoURL)
@@ -210,14 +227,10 @@ func createPullRequest(ctx context.Context, fromURL, toURL, newBranchName, commi
 		// TODO: improve this error message
 		return nil, err
 	}
-	user, repo, err := util.ExtractUserAndRepo(toURL)
-	if err != nil {
-		// TODO: improve this error message
-		return nil, err
-	}
-	// TODO: come up with a better way of generating the repository URL (this
-	// only works for GitHub)
-	pr, _, err := client.PullRequests.Create(ctx, fmt.Sprintf("%s/%s", user, repo), prInput)
+
+	u, _ := url.Parse(toURL)
+	// take out ".git" at the end
+	pr, _, err := client.PullRequests.Create(ctx, u.Path[1:len(u.Path)-4], prInput)
 	return pr, err
 }
 

pkg/avancement/service_manager_test.go

@@ -22,19 +22,19 @@ const (
 	staging = "https://example.com/testing/staging-env"
 )
 
-func TestPromoteWithSuccessKeepCacheTrue(t *testing.T) {
-	promoteWithSuccess(t, true, "")
+func TestPromoteWithSuccessKeepCacheTrueWithGHE(t *testing.T) {
+	promoteWithSuccess(t, true, "ghe", true, "")
 }
 
-func TestPromoteWithSuccessKeepCacheFalse(t *testing.T) {
-	promoteWithSuccess(t, false, "")
+func TestPromoteWithSuccessKeepCacheFalseWithGitHub(t *testing.T) {
+	promoteWithSuccess(t, false, "github", false, "")
 }
 
 func TestPromoteWithSuccessCustomMsg(t *testing.T) {
 	promoteLocalWithSuccess(t, true, "custom commit message here")
 }
 
-func promoteWithSuccess(t *testing.T, keepCache bool, msg string) {
+func promoteWithSuccess(t *testing.T, keepCache bool, repoType string, tlsVerify bool, msg string) {
 	dstBranch := "test-branch"
 	author := &git.Author{Name: "Testing User", Email: "[email protected]", Token: "test-token"}
 	devRepo, stagingRepo := mock.New("/dev", "master"), mock.New("/staging", "master")
@@ -43,11 +43,22 @@ func promoteWithSuccess(t *testing.T, keepCache bool, msg string) {
 		mustAddCredentials(t, staging, author): stagingRepo,
 	}
 	sm := New("tmp", author)
-	sm.clientFactory = func(s string) *scm.Client {
+	sm.repoType = repoType
+	sm.tlsVerify = tlsVerify
+	sm.clientFactory = func(s, ty, r  string, v bool) *scm.Client {
 		client, _ := fakescm.NewDefault()
+		if r != repoType {
+			t.Fatalf("repoType doesn't match %s != %s\n", r, repoType)
+		}
+		if v != tlsVerify {
+			t.Fatalf("tlsVerify doesn't match in ClientFactory %v != %v\n", v, tlsVerify)
+		}
 		return client
 	}
-	sm.repoFactory = func(url, _ string, _ bool) (git.Repo, error) {
+	sm.repoFactory = func(url, _ string, v bool, _ bool) (git.Repo, error) {
+		if v != tlsVerify {
+			t.Fatalf("tlsVerify doesn't match in RepoFactory %v != %v\n", v, tlsVerify)
+		}
 		return git.Repo(repos[url]), nil
 	}
 	devRepo.AddFiles("/services/my-service/base/config/myfile.yaml")
@@ -96,11 +107,11 @@ func promoteLocalWithSuccess(t *testing.T, keepCache bool, msg string) {
 	devRepo := NewLocal("/dev")
 
 	sm := New("tmp", author)
-	sm.clientFactory = func(s string) *scm.Client {
+	sm.clientFactory = func(s, t, r  string, v bool) *scm.Client {
 		client, _ := fakescm.NewDefault()
 		return client
 	}
-	sm.repoFactory = func(url, _ string, _ bool) (git.Repo, error) {
+	sm.repoFactory = func(url, _ string, _ bool, _ bool) (git.Repo, error) {
 		return git.Repo(stagingRepo), nil
 	}
 	sm.localFactory = func(path string, _ bool) git.Source {
@@ -173,11 +184,11 @@ func TestPromoteWithCacheDeletionFailure(t *testing.T) {
 		mustAddCredentials(t, staging, author): stagingRepo,
 	}
 	sm := New("tmp", author)
-	sm.clientFactory = func(s string) *scm.Client {
+	sm.clientFactory = func(s, t, r  string, v bool) *scm.Client {
 		client, _ := fakescm.NewDefault()
 		return client
 	}
-	sm.repoFactory = func(url, _ string, _ bool) (git.Repo, error) {
+	sm.repoFactory = func(url, _ string, _ bool, _ bool) (git.Repo, error) {
 		return git.Repo(repos[url]), nil
 	}
 	devRepo.AddFiles("/services/my-service/base/config/myfile.yaml")
@@ -287,13 +298,13 @@ func TestRepositoryCloneErrorOmitsToken(t *testing.T) {
 	dstBranch := "test-branch"
 	author := &git.Author{Name: "Testing User", Email: "[email protected]", Token: "test-token"}
 	client, _ := fakescm.NewDefault()
-	fakeClientFactory := func(s string) *scm.Client {
+	fakeClientFactory := func(s, t, r  string, v bool)  *scm.Client {
 		return client
 	}
 	sm := New("tmp", author)
 	sm.clientFactory = fakeClientFactory
 
-	sm.repoFactory = func(url, _ string, _ bool) (git.Repo, error) {
+	sm.repoFactory = func(url, _ string, _ bool, _ bool) (git.Repo, error) {
 		// This actually causes the error and results in trying to create a repository
 		// which can surface the token
 		errorMessage := fmt.Errorf("failed to clone repository %s: exit status 128", dev)

pkg/cmd/promote.go

@@ -72,13 +72,27 @@ func makePromoteCmd() *cobra.Command {
 	)
 	logIfError(viper.BindPFlag(msgFlag, cmd.Flags().Lookup(msgFlag)))
 
+	cmd.Flags().String(
+		repoTypeFlag,
+		"github",
+		"the type of repository: github, gitlab or ghe",
+	)
+	logIfError(viper.BindPFlag(repoTypeFlag, cmd.Flags().Lookup(repoTypeFlag)))
+
 	cmd.Flags().Bool(
 		debugFlag,
 		false,
 		"additional debug logging output",
 	)
 	logIfError(viper.BindPFlag(debugFlag, cmd.Flags().Lookup(debugFlag)))
 
+	cmd.Flags().Bool(
+		insecureSkipVerifyFlag,
+		false,
+		"Insecure skip verify TLS certificate",
+	)
+	logIfError(viper.BindPFlag(insecureSkipVerifyFlag, cmd.Flags().Lookup(insecureSkipVerifyFlag)))
+
 	cmd.Flags().Bool(
 		keepCacheFlag,
 		false,
@@ -98,7 +112,9 @@ func promoteAction(c *cobra.Command, args []string) error {
 	fromRepo := viper.GetString(fromFlag)
 	toRepo := viper.GetString(toFlag)
 	service := viper.GetString(serviceFlag)
+	repoType := viper.GetString(repoTypeFlag)
 	newBranchName := viper.GetString(branchNameFlag)
+	insecureSkipVerify := viper.GetBool(insecureSkipVerifyFlag)
 	debug := viper.GetBool(debugFlag)
 	keepCache := viper.GetBool(keepCacheFlag)
 	msg := viper.GetString(msgFlag)
@@ -112,7 +128,7 @@ func promoteAction(c *cobra.Command, args []string) 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, msg, keepCache)
+	return avancement.New(cacheDir, author, avancement.WithDebug(debug), avancement.WithInsecureSkipVerify(insecureSkipVerify), avancement.WithRepoType(repoType)).Promote(service, fromRepo, toRepo, newBranchName, msg, keepCache)
 }
 
 func newAuthor() (*git.Author, error) {

pkg/cmd/root.go

@@ -10,17 +10,19 @@ import (
 )
 
 const (
-	githubTokenFlag = "github-token"
-	branchNameFlag  = "branch-name"
-	fromFlag        = "from"
-	toFlag          = "to"
-	serviceFlag     = "service"
-	cacheDirFlag    = "cache-dir"
-	msgFlag         = "commit-message"
-	nameFlag        = "commit-name"
-	emailFlag       = "commit-email"
-	debugFlag       = "debug"
-	keepCacheFlag   = "keep-cache"
+	githubTokenFlag        = "github-token"
+	branchNameFlag         = "branch-name"
+	fromFlag               = "from"
+	toFlag                 = "to"
+	serviceFlag            = "service"
+	repoTypeFlag           = "repository-type"
+	cacheDirFlag           = "cache-dir"
+	msgFlag                = "commit-message"
+	nameFlag               = "commit-name"
+	emailFlag              = "commit-email"
+	insecureSkipVerifyFlag = "insecure-skip-verify"
+	debugFlag              = "debug"
+	keepCacheFlag          = "keep-cache"
 )
 
 var rootCmd = &cobra.Command{

pkg/git/client.go

@@ -2,20 +2,46 @@ package git
 
 import (
 	"context"
-
+	"net/http"
+	"net/url"
+	"crypto/tls"
 	"github.com/jenkins-x/go-scm/scm"
 	"github.com/jenkins-x/go-scm/scm/driver/github"
+	"github.com/jenkins-x/go-scm/scm/driver/gitlab"
 	"golang.org/x/oauth2"
 )
 
-// CreateGitHubClient creates and returns a go-scm GitHub client, using the provided
+// CreateClient creates and returns a go-scm GitHub client, using the provided
 // oauth2 token.
-// TODO: This should probably use https://github.com/jenkins-x/go-scm/tree/master/scm/factory
-func CreateGitHubClient(token string) *scm.Client {
-	client := github.NewDefault()
+func CreateClient(token, toURL, repoType  string, tlsVerify bool) *scm.Client {
+	var client *scm.Client
+	u, _ := url.Parse(toURL)
+	if repoType == "gitlab" {
+		client = gitlab.NewDefault()
+	} else if repoType == "ghe" {
+		client, _ = github.New(u.Scheme + "://" + u.Host + "/api/v3")
+	} else {
+		client = github.NewDefault()
+	}
 	ts := oauth2.StaticTokenSource(
 		&oauth2.Token{AccessToken: token},
 	)
-	client.Client = oauth2.NewClient(context.Background(), ts)
+	if tlsVerify {
+		client.Client = oauth2.NewClient(context.Background(), ts)
+	} else {
+		client.Client = &http.Client{
+			Transport: &oauth2.Transport{
+				Source: ts,
+				Base: &http.Transport{
+					TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+				},
+			},
+		}
+	}
+	if repoType == "gitlab" {
+		u, _ := url.Parse(toURL)
+		client.BaseURL.Host = u.Host
+	}
 	return client
 }
+

pkg/git/client_test.go

@@ -0,0 +1,24 @@
+package git
+
+import (
+	"testing"
+)
+func TestCreateClient(t *testing.T) {
+	create := []struct {
+		toUrl       string
+		repoType  string
+		wantHost  string
+	}{
+		{"https://github.com/myorg/myrepo.git", "github", "api.github.com"},
+		{"https://gitlab.local.com/myorg/subdir/myrepo.git", "gitlab", "gitlab.local.com"},
+		{"https://github.local.com/myorg/myrepo.git", "ghe", "github.local.com"},
+	}
+
+	for _, tt := range create {
+		client := CreateClient("tokendata", tt.toUrl, tt.repoType, true)
+		if tt.wantHost != client.BaseURL.Host {
+			t.Errorf("CreateClient(%s) got host %s, want %s", tt.toUrl, client.BaseURL.Host, tt.wantHost)
+			continue
+		}
+	}
+}