support for gitlab ee (#142)

* workaround to work with gitlab ee

* review pr

* work with gitlab enterprise

* review pr

* review pr

* Update e2e/promotion_pull_request_test.go

Co-authored-by: Balazs Nadasdi <[email protected]>

* review comments

* review comments

Co-authored-by: Balazs Nadasdi <[email protected]>

Author: enekofb

Makefile

@@ -212,15 +212,13 @@ $(HELM): $(LOCALBIN)
 e2e: e2e-setup e2e-test e2e-clean
 
 .PHONY: e2e-setup
-e2e-setup: docker-build kind flux deploy
+e2e-setup: e2e-kind deploy
 	kubectl wait -n pipeline-system deployment/pipeline-controller --for=condition=available
 	kubectl apply -f e2e/testdata --recursive
 
-kind:
+e2e-kind: docker-build
 	kind create cluster --name=pipeline-controller || kubectx kind-pipeline-controller
 	kind load docker-image --name=pipeline-controller $(IMG)
-
-flux:
 	flux install
 
 .PHONY: e2e-test

e2e/promotion_pull_request_test.go

@@ -9,6 +9,8 @@ import (
 	"fmt"
 	"github.com/fluxcd/go-git-providers/gitprovider"
 	"github.com/fluxcd/helm-controller/api/v2beta1"
+	"github.com/fluxcd/pkg/runtime/logger"
+	"github.com/go-logr/logr"
 	"github.com/google/go-github/v47/github"
 	"github.com/hashicorp/go-uuid"
 	. "github.com/onsi/gomega"
@@ -37,6 +39,7 @@ const (
 
 func TestPullRequestPromotions(t *testing.T) {
 	g := testingutils.NewGomegaWithT(t)
+	log := logger.NewLogger(logger.Options{})
 
 	tests := []struct {
 		name              string
@@ -56,16 +59,15 @@ func TestPullRequestPromotions(t *testing.T) {
 			"6.0.0",
 			"6.0.1",
 		},
-		//TODO enable me when https://github.com/weaveworks/pipeline-controller/issues/132 is closed
-		//{
-		//	"can promote gitlab",
-		//	"podinfo-gitlab",
-		//	"flux-system",
-		//	"promotion-flux-system-podinfo-gitlab-prod",
-		//	"prod",
-		//	"6.0.0",
-		//	"6.0.1",
-		//},
+		{
+			"can promote gitlab",
+			"podinfo-gitlab",
+			"flux-system",
+			"promotion-flux-system-podinfo-gitlab-prod",
+			"prod",
+			"6.0.0",
+			"6.0.1",
+		},
 	}
 
 	g.SetDefaultEventuallyTimeout(defaultTimeout)
@@ -82,15 +84,15 @@ func TestPullRequestPromotions(t *testing.T) {
 
 			//cleanup promotion
 			t.Cleanup(func() {
-				log.Println("cleaning test")
+				log.Info("cleaning test")
 				//restore helm release version
 				released := releaseNewVersion(g, k8sClient, helmRelease, promotion.currentVersion)
 				g.Expect(released).To(BeTrue())
 				helmRelease, err = ensureHelmRelease(g, pipeline, k8sClient, promotion.currentVersion)
 				//delete git branch
-				err := deleteGitBranchByName(context.Background(), g, k8sClient, pipeline, promotion.branchName)
+				err := deleteGitBranchByName(context.Background(), g, k8sClient, pipeline, promotion.branchName, log)
 				if err != nil {
-					log.Fatalf("could not delete branch %s", err)
+					log.Error(err, "could not delete branch")
 				}
 			})
 
@@ -110,7 +112,7 @@ func TestPullRequestPromotions(t *testing.T) {
 	deletePodsByNamespaceAndLabel(g, "flux-system", "app=notification-controller")
 }
 
-func deleteGitBranchByName(ctx context.Context, g *WithT, c client.Client, pipeline v1alpha1.Pipeline, branchName string) error {
+func deleteGitBranchByName(ctx context.Context, g *WithT, c client.Client, pipeline v1alpha1.Pipeline, branchName string, log logr.Logger) error {
 	var secret corev1.Secret
 
 	promotion := pipeline.Spec.Promotion
@@ -131,26 +133,27 @@ func deleteGitBranchByName(ctx context.Context, g *WithT, c client.Client, pipel
 	g.Eventually(func() bool {
 		//get secret
 		if err := c.Get(ctx, client.ObjectKey{Namespace: pipeline.Namespace, Name: secretName}, &secret); err != nil {
-			log.Printf("failed to fetch Secret: %s", err)
+			log.Error(err, "failed to fetch Secret")
 			return false
 		}
 		return true
 	}).Should(BeTrue())
 
-	hostname := userRepoRef.Domain
 	tokenString := string(secret.Data["token"])
 	provider := pullrequest.GitProviderConfig{
 		Token:            tokenString,
 		TokenType:        "oauth2",
 		Type:             pullRequestPromotion.Type,
-		Hostname:         hostname,
+		Domain:           userRepoRef.Domain,
 		DestructiveCalls: false,
 	}
 
-	gitProviderClient, err := pullrequest.NewGitProviderClientFactory()(provider)
+	gitProviderClient, err := pullrequest.NewGitProviderClientFactory(log)(provider)
 	if err != nil {
 		return fmt.Errorf("could not create git provider client: %w", err)
 	}
+	//TODO it should not be needed - gitlab ggp issue
+	userRepoRef.Domain = gitProviderClient.SupportedDomain()
 	userRepo, err := gitProviderClient.UserRepositories().Get(ctx, *userRepoRef)
 	if err != nil {
 		return fmt.Errorf("could not get repository: %w", err)
@@ -167,19 +170,17 @@ func deleteGitBranchByName(ctx context.Context, g *WithT, c client.Client, pipel
 		}
 		owner := userRepoRef.UserLogin
 		repo := userRepoRef.RepositoryName
-		_, r, err := gClient.Repositories.RenameBranch(ctx, owner, repo, branchName, fmt.Sprintf("%s-%s", branchName, generatedUuid))
+		_, _, err = gClient.Repositories.RenameBranch(ctx, owner, repo, branchName, fmt.Sprintf("%s-%s", branchName, generatedUuid))
 		if err != nil {
 			return fmt.Errorf("could not rename branch: %w", err)
 		}
-		log.Println("branch delete response", r)
 	case v1alpha1.Gitlab:
 		gitlabProject := userRepo.APIObject().(*gitlab2.Project)
 		gClient := clientRaw.(*gitlab2.Client)
-		deletedBranch, err := gClient.Branches.DeleteBranch(gitlabProject.ID, branchName, nil)
+		_, err := gClient.Branches.DeleteBranch(gitlabProject.ID, branchName, nil)
 		if err != nil {
 			return fmt.Errorf("could not delete gitlab branch: %w", err)
 		}
-		log.Println("branch delete response", deletedBranch)
 	}
 	return nil
 }

e2e/testdata/pipelines/gitlab/pipeline.yaml

@@ -20,4 +20,4 @@ spec:
       type: "gitlab"
       url: "https://gitlab.git.dev.weave.works/pipeline-controller/pipeline-controller-e2e"
       secretRef:
-        name: "gitlab-promotion-credentials"
+        name: "gitlab-ee-promotion-credentials"

server/strategy/pullrequest/gitprovider.go

@@ -5,15 +5,18 @@ import (
 	"github.com/fluxcd/go-git-providers/github"
 	"github.com/fluxcd/go-git-providers/gitlab"
 	"github.com/fluxcd/go-git-providers/gitprovider"
+	"github.com/go-logr/logr"
 	"github.com/weaveworks/pipeline-controller/api/v1alpha1"
+	"strings"
 )
 
 var (
-	ErrGitProviderTypeEmpty     = fmt.Errorf("git provider type is empty")
-	ErrGitProviderTypeInvalid   = fmt.Errorf("git provider type not supported")
-	ErrGitProviderDomainIsEmpty = fmt.Errorf("git provider host is empty")
-	ErrTokenTypeIsEmpty         = fmt.Errorf("git provider token type is empty")
-	ErrTokenIsEmpty             = fmt.Errorf("git provider token is empty")
+	ErrGitProviderTypeEmpty       = fmt.Errorf("git provider type is empty")
+	ErrGitProviderTypeInvalid     = fmt.Errorf("git provider type not supported")
+	ErrGitProviderDomainIsEmpty   = fmt.Errorf("git provider host is empty")
+	ErrGitProviderDomainIsInvalid = fmt.Errorf("git provider domain is invalid")
+	ErrTokenTypeIsEmpty           = fmt.Errorf("git provider token type is empty")
+	ErrTokenIsEmpty               = fmt.Errorf("git provider token is empty")
 )
 
 type GitProviderClientFactory func(provider GitProviderConfig) (gitprovider.Client, error)
@@ -22,12 +25,12 @@ type GitProviderConfig struct {
 	Token            string
 	TokenType        string
 	Type             v1alpha1.GitProviderType
-	Hostname         string
+	Domain           string
 	DestructiveCalls bool
 }
 
 // same as https://github.com/weaveworks/weave-gitops-enterprise/blob/7ef05e773d7650a83cfa86dbd642253353b584c0/cmd/clusters-service/pkg/git/git.go#L286
-func NewGitProviderClientFactory() GitProviderClientFactory {
+func NewGitProviderClientFactory(log logr.Logger) GitProviderClientFactory {
 	return func(provider GitProviderConfig) (gitprovider.Client, error) {
 		var client gitprovider.Client
 		var err error
@@ -53,12 +56,16 @@ func NewGitProviderClientFactory() GitProviderClientFactory {
 		clientOptions = append(clientOptions, gitprovider.WithOAuth2Token(provider.Token))
 
 		if provider.DestructiveCalls {
-			//TODO bring visibility to this action
+			log.Info("creating client with destructive calls enabled")
 			clientOptions = append(clientOptions, gitprovider.WithDestructiveAPICalls(provider.DestructiveCalls))
 		}
 
-		if provider.Hostname != "" {
-			clientOptions = append(clientOptions, gitprovider.WithDomain(provider.Hostname))
+		if provider.Domain != "" {
+			domain, err := decorateCustomDomainByType(provider.Type, provider.Domain)
+			if err != nil {
+				return nil, err
+			}
+			clientOptions = append(clientOptions, gitprovider.WithDomain(domain))
 		}
 
 		switch provider.Type {
@@ -80,6 +87,29 @@ func NewGitProviderClientFactory() GitProviderClientFactory {
 
 }
 
+// TODO review me when https://github.com/fluxcd/go-git-providers/issues/175 and
+// https://github.com/fluxcd/go-git-providers/issues/176 are fixed
+// we need to hack this to add the https scheme to the domain to
+// have a gitlab client with a correct baseurl otherwise would create an invalid url
+func decorateCustomDomainByType(gitProviderType v1alpha1.GitProviderType, domain string) (string, error) {
+	if gitProviderType == "" {
+		return "", ErrGitProviderTypeEmpty
+	}
+
+	if domain == "" {
+		return "", ErrGitProviderDomainIsEmpty
+	}
+
+	switch gitProviderType {
+	case v1alpha1.Gitlab:
+		//if not a url we create one with https by default
+		if !strings.HasPrefix(domain, "http://") && !strings.HasPrefix(domain, "https://") {
+			return fmt.Sprintf("https://%s", domain), nil
+		}
+	}
+	return domain, nil
+}
+
 func gitProviderIsValid(gitProviderType v1alpha1.GitProviderType) (bool, error) {
 
 	if gitProviderType == "" {

server/strategy/pullrequest/gitprovider_test.go

@@ -2,6 +2,7 @@ package pullrequest
 
 import (
 	"github.com/fluxcd/go-git-providers/gitprovider"
+	"github.com/fluxcd/pkg/runtime/logger"
 	"github.com/onsi/gomega"
 	"github.com/weaveworks/pipeline-controller/api/v1alpha1"
 	"github.com/weaveworks/pipeline-controller/internal/testingutils"
@@ -55,7 +56,7 @@ func Test_gitProviderIsEmpty(t *testing.T) {
 	}
 }
 
-func Test_newGitProviderClientFactory(t *testing.T) {
+func TestNewGitProviderClientFactory(t *testing.T) {
 	tests := []struct {
 		name             string
 		in               GitProviderConfig
@@ -128,7 +129,7 @@ func Test_newGitProviderClientFactory(t *testing.T) {
 				Type:      v1alpha1.Github,
 				TokenType: "oauth2",
 				Token:     "asdf",
-				Hostname:  "github.myenterprise.com",
+				Domain:    "github.myenterprise.com",
 			},
 			"github",
 			"github.myenterprise.com",
@@ -142,27 +143,27 @@ func Test_newGitProviderClientFactory(t *testing.T) {
 				Token:     "abc",
 			},
 			"gitlab",
-			"https://gitlab.com", //TODO: raise issue with ggp cause the domain returns an URL
+			"https://gitlab.com", //TODO: change me when fixed https://github.com/fluxcd/go-git-providers/issues/175
 			"",
 		},
 		{
-			"can create git provider for gitlab on prem",
+			"can create git provider for gitlab enterprise",
 			GitProviderConfig{
 				Type:      v1alpha1.Gitlab,
 				TokenType: "oauth2",
 				Token:     "abc",
-				Hostname:  "gitlab.myenterprise.com",
+				Domain:    "gitlab.myenterprise.com",
 			},
 			"gitlab",
-			"https://gitlab.myenterprise.com", //TODO: raise issue with ggp cause the domain returns an URL
+			"https://gitlab.myenterprise.com", //TODO: change me when fixed https://github.com/fluxcd/go-git-providers/issues/175
 			"",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			g := testingutils.NewGomegaWithT(t)
-			client, err := NewGitProviderClientFactory()(tt.in)
+			client, err := NewGitProviderClientFactory(logger.NewLogger(logger.Options{}))(tt.in)
 			if tt.errPattern != "" {
 				g.Expect(err).To(gomega.MatchError(gomega.MatchRegexp(tt.errPattern)))
 			} else {
@@ -173,3 +174,71 @@ func Test_newGitProviderClientFactory(t *testing.T) {
 		})
 	}
 }
+
+func Test_decorateCustomDomainByType(t *testing.T) {
+
+	tests := []struct {
+		name            string
+		gitProviderType v1alpha1.GitProviderType
+		domain          string
+		expectedDomain  string
+		errPattern      string
+	}{
+		{
+			"cannot decorate if empty git provider",
+			"",
+			"",
+			"",
+			ErrGitProviderTypeEmpty.Error(),
+		},
+		{
+			"cannot decorate if empty domain",
+			v1alpha1.Github,
+			"",
+			"",
+			ErrGitProviderDomainIsEmpty.Error(),
+		},
+		{
+			"decorate non-gitlab enterprise domain has no effect",
+			v1alpha1.Github,
+			"github.myenterprise.com",
+			"github.myenterprise.com",
+			"",
+		},
+		{
+			"decorate gitlab enterprise domain adds https scheme",
+			v1alpha1.Gitlab,
+			"gitlab.git.dev.weave.works",
+			"https://gitlab.git.dev.weave.works",
+			"",
+		},
+		{
+			"decorate gitlab enterprise with https scheme does not change",
+			v1alpha1.Gitlab,
+			"https://gitlab.git.dev.weave.works",
+			"https://gitlab.git.dev.weave.works",
+			"",
+		},
+		{
+			"decorate gitlab enterprise with http scheme does not change",
+			v1alpha1.Gitlab,
+			"http://gitlab.git.dev.weave.works",
+			"http://gitlab.git.dev.weave.works",
+			"",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := testingutils.NewGomegaWithT(t)
+			domain, err := decorateCustomDomainByType(tt.gitProviderType, tt.domain)
+			if tt.errPattern != "" {
+				g.Expect(err).To(gomega.MatchError(gomega.MatchRegexp(tt.errPattern)))
+			} else {
+				g.Expect(domain).To(gomega.Equal(tt.expectedDomain))
+				g.Expect(err).To(gomega.BeNil())
+			}
+		})
+	}
+
+}