Automatically register user to the default git integration (#229)

danielm-codefresh · web-flow · commit 7556d968389e · 2022-01-31T17:37:58.000+02:00
* Started working on adding git PAT to cli * Call register * fix * Revert "fix" This reverts commit e5fbb3a. * fix * Eliminate events being sent conditionally
diff --git a/Makefile b/Makefile
@@ -1,4 +1,4 @@
-VERSION=v0.0.212
+VERSION=v0.0.213
 
 OUT_DIR=dist
 YEAR?=$(shell date +"%Y")
diff --git a/cmd/commands/common.go b/cmd/commands/common.go
@@ -254,6 +254,38 @@ func ensureGitToken(cmd *cobra.Command, cloneOpts *git.CloneOptions) error {
 	return nil
 }
 
+func ensureGitPAT(cmd *cobra.Command, opts *RuntimeInstallOptions) error {
+	var err error
+	if !store.Get().Silent {
+		return getGitPATFromUserInput(cmd, opts)
+	}
+
+	opts.GitIntegrationRegistrationOpts.Token, err = cmd.Flags().GetString("git-token")
+	return err
+}
+
+func getGitPATFromUserInput(cmd *cobra.Command, opts *RuntimeInstallOptions) error {
+	gitPATPrompt := promptui.Prompt{
+		Label: "Enter your Personal Git Access Token (leave blank to use system token. Can be changed later)",
+		Mask:  '*',
+	}
+
+	gitPAT, err := gitPATPrompt.Run()
+	if err != nil {
+		return fmt.Errorf("prompt error: %w", err)
+	}
+
+	if gitPAT == "" {
+		gitPAT, err = cmd.Flags().GetString("git-token")
+		if err != nil {
+			return fmt.Errorf("%w", err)
+		}
+	}
+	opts.GitIntegrationRegistrationOpts.Token = gitPAT
+
+	return nil
+}
+
 func getGitTokenFromUserInput(cmd *cobra.Command) error {
 	gitTokenPrompt := promptui.Prompt{
 		Label: "Git provider api token",
diff --git a/cmd/commands/runtime.go b/cmd/commands/runtime.go
@@ -69,22 +69,23 @@ import (
 
 type (
 	RuntimeInstallOptions struct {
-		RuntimeName          string
-		RuntimeToken         string
-		RuntimeStoreIV       string
-		IngressHost          string
-		IngressClass         string
-		IngressController    string
-		Insecure             bool
-		InstallDemoResources bool
-		Version              *semver.Version
-		GsCloneOpts          *git.CloneOptions
-		InsCloneOpts         *git.CloneOptions
-		GitIntegrationOpts   *apmodel.AddGitIntegrationArgs
-		KubeFactory          kube.Factory
-		CommonConfig         *runtime.CommonConfig
-		versionStr           string
-		kubeContext          string
+		RuntimeName                    string
+		RuntimeToken                   string
+		RuntimeStoreIV                 string
+		IngressHost                    string
+		IngressClass                   string
+		IngressController              string
+		Insecure                       bool
+		InstallDemoResources           bool
+		Version                        *semver.Version
+		GsCloneOpts                    *git.CloneOptions
+		InsCloneOpts                   *git.CloneOptions
+		GitIntegrationCreationOpts     *apmodel.AddGitIntegrationArgs
+		GitIntegrationRegistrationOpts *apmodel.RegisterToGitIntegrationArgs
+		KubeFactory                    kube.Factory
+		CommonConfig                   *runtime.CommonConfig
+		versionStr                     string
+		kubeContext                    string
 	}
 	RuntimeUninstallOptions struct {
 		RuntimeName string
@@ -149,11 +150,14 @@ func NewRuntimeCommand() *cobra.Command {
 
 func NewRuntimeInstallCommand() *cobra.Command {
 	var (
-		gitIntegrationOpts = apmodel.AddGitIntegrationArgs{
+		gitIntegrationCreationOpts = apmodel.AddGitIntegrationArgs{
 			SharingPolicy: apmodel.SharingPolicyAllUsersInAccount,
 		}
-		installationOpts = RuntimeInstallOptions{GitIntegrationOpts: &gitIntegrationOpts}
-		finalParameters  map[string]string
+		installationOpts = RuntimeInstallOptions{
+			GitIntegrationCreationOpts:     &gitIntegrationCreationOpts,
+			GitIntegrationRegistrationOpts: &apmodel.RegisterToGitIntegrationArgs{},
+		}
+		finalParameters map[string]string
 	)
 
 	cmd := &cobra.Command{
@@ -191,7 +195,7 @@ func NewRuntimeInstallCommand() *cobra.Command {
 				"Runtime name":              installationOpts.RuntimeName,
 				"Repository URL":            installationOpts.InsCloneOpts.Repo,
 				"Ingress host":              installationOpts.IngressHost,
-				"Ingress class":              installationOpts.IngressClass,
+				"Ingress class":             installationOpts.IngressClass,
 				"Installing demo resources": strconv.FormatBool(installationOpts.InstallDemoResources),
 			}
 
@@ -213,7 +217,7 @@ func NewRuntimeInstallCommand() *cobra.Command {
 	cmd.Flags().StringVar(&installationOpts.versionStr, "version", "", "The runtime version to install (default: latest)")
 	cmd.Flags().BoolVar(&installationOpts.InstallDemoResources, "demo-resources", true, "Installs demo resources (default: true)")
 	cmd.Flags().DurationVar(&store.Get().WaitTimeout, "wait-timeout", store.Get().WaitTimeout, "How long to wait for the runtime components to be ready")
-	cmd.Flags().StringVar(&gitIntegrationOpts.APIURL, "provider-api-url", "", "Git provider API url")
+	cmd.Flags().StringVar(&gitIntegrationCreationOpts.APIURL, "provider-api-url", "", "Git provider API url")
 	cmd.Flags().BoolVar(&store.Get().BypassIngressClassCheck, "bypass-ingress-class-check", false, "Disables the ingress class check during pre-installation")
 
 	installationOpts.InsCloneOpts = apu.AddCloneFlags(cmd, &apu.CloneFlagsOptions{
@@ -235,16 +239,12 @@ func NewRuntimeInstallCommand() *cobra.Command {
 func runtimeInstallCommandPreRunHandler(cmd *cobra.Command, opts *RuntimeInstallOptions) error {
 	handleCliStep(reporter.InstallPhasePreCheckStart, "Starting pre checks", nil, false)
 
-	if opts.versionStr != "" {
-		version, err := semver.NewVersion(opts.versionStr)
-		handleCliStep(reporter.InstallStepPreCheckValidateRuntimeVersion, "Validating runtime version", err, false)
-		if err != nil {
-			return err
-		}
-		opts.Version = version
+	err := getVersionIfExists(opts)
+	handleCliStep(reporter.InstallStepPreCheckValidateRuntimeVersion, "Validating runtime version", err, false)
+	if err != nil {
+		return err
 	}
 
-	var err error
 	if opts.RuntimeName == "" {
 		if !store.Get().Silent {
 			err = getRuntimeNameFromUserInput(&opts.RuntimeName)
@@ -257,19 +257,11 @@ func runtimeInstallCommandPreRunHandler(cmd *cobra.Command, opts *RuntimeInstall
 		return err
 	}
 
-	isValid, err := IsValidName(opts.RuntimeName)
-	var errMsg string
+	err = validateRuntimeName(opts.RuntimeName)
+	handleCliStep(reporter.InstallStepPreCheckRuntimeNameValidation, "Validating runtime name", err, false)
 	if err != nil {
-		errMsg = "failed to check the validity of the runtime name"
-	} else if !isValid {
-		errMsg = "runtime name cannot have any uppercase letters, must start with a character, end with character or number, and be shorter than 63 chars"
-	}
-
-	if errMsg != "" {
-		handleCliStep(reporter.InstallStepPreCheckRuntimeNameValidation, "Validating runtime name", fmt.Errorf(errMsg), false)
-		log.G(cmd.Context()).Fatal(errMsg)
+		log.G(cmd.Context()).Fatal(fmt.Errorf("%w", err))
 	}
-	handleCliStep(reporter.InstallStepPreCheckRuntimeNameValidation, "Validating runtime name", err, false)
 
 	err = getKubeContextNameFromUserSelect(cmd, &opts.kubeContext)
 	handleCliStep(reporter.InstallStepPreCheckGetKubeContext, "Getting kube context name", err, false)
@@ -301,6 +293,12 @@ func runtimeInstallCommandPreRunHandler(cmd *cobra.Command, opts *RuntimeInstall
 		return err
 	}
 
+	err = ensureGitPAT(cmd, opts)
+	handleCliStep(reporter.InstallStepPreCheckEnsureGitPAT, "Getting git personal access token", err, false)
+	if err != nil {
+		return err
+	}
+
 	err = askUserIfToInstallDemoResources(cmd, &opts.InstallDemoResources)
 	handleCliStep(reporter.InstallStepPreCheckShouldInstallDemoResources, "Asking user is demo resources should be installed", err, false)
 	if err != nil {
@@ -650,12 +648,18 @@ func RunRuntimeInstall(ctx context.Context, opts *RuntimeInstallOptions) error {
 		return util.DecorateErrorWithDocsLink(fmt.Errorf("failed to complete installation: %w", timeoutErr))
 	}
 
-	gitIntgErr := addDefaultGitIntegration(ctx, opts.RuntimeName, opts.GitIntegrationOpts)
+	gitIntgErr := addDefaultGitIntegration(ctx, opts.RuntimeName, opts.GitIntegrationCreationOpts)
 	handleCliStep(reporter.InstallStepCreateDefaultGitIntegration, "Creating a default git integration", gitIntgErr, true)
 	if gitIntgErr != nil {
 		return util.DecorateErrorWithDocsLink(fmt.Errorf("failed to create default git integration: %w", gitIntgErr))
 	}
 
+	gitIntgErr = registerUserToGitIntegration(ctx, opts.RuntimeName, opts.GitIntegrationRegistrationOpts)
+	handleCliStep(reporter.InstallStepRegisterToDefaultGitIntegration, "Registering user to the default git integration", gitIntgErr, true)
+	if gitIntgErr != nil {
+		return util.DecorateErrorWithDocsLink(fmt.Errorf("failed to register user to the default git integration: %w", gitIntgErr))
+	}
+
 	installationSuccessMsg := fmt.Sprintf("Runtime '%s' installed successfully", opts.RuntimeName)
 	summaryArr = append(summaryArr, summaryLog{installationSuccessMsg, Info})
 	log.G(ctx).Infof(installationSuccessMsg)
@@ -678,6 +682,18 @@ func addDefaultGitIntegration(ctx context.Context, runtime string, opts *apmodel
 	return nil
 }
 
+func registerUserToGitIntegration(ctx context.Context, runtime string, opts *apmodel.RegisterToGitIntegrationArgs) error {
+	appProxyClient, err := cfConfig.NewClient().AppProxy(ctx, runtime, store.Get().InsecureIngressHost)
+	if err != nil {
+		return fmt.Errorf("failed to build app-proxy client: %w", err)
+	}
+	if err := RunGitIntegrationRegisterCommand(ctx, appProxyClient, opts); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func installComponents(ctx context.Context, opts *RuntimeInstallOptions, rt *runtime.Runtime) error {
 	var err error
 	if opts.IngressHost != "" {
@@ -1016,18 +1032,19 @@ func RunRuntimeUninstall(ctx context.Context, opts *RuntimeUninstallOptions) err
 	handleCliStep(reporter.UninstallPhaseStart, "Uninstall phase started", nil, false)
 
 	// check whether the runtime exists
+	var err error
 	if !opts.SkipChecks {
-		_, err := cfConfig.NewClient().V2().Runtime().Get(ctx, opts.RuntimeName)
-		handleCliStep(reporter.UninstallStepCheckRuntimeExists, "Checking if runtime exists", err, true)
-		if err != nil {
-			summaryArr = append(summaryArr, summaryLog{"you can attempt to uninstall again with the \"--skip-checks\" flag", Info})
-			return err
-		}
+		_, err = cfConfig.NewClient().V2().Runtime().Get(ctx, opts.RuntimeName)
+	}
+	handleCliStep(reporter.UninstallStepCheckRuntimeExists, "Checking if runtime exists", err, true)
+	if err != nil {
+		summaryArr = append(summaryArr, summaryLog{"you can attempt to uninstall again with the \"--skip-checks\" flag", Info})
+		return err
 	}
 
 	log.G(ctx).Infof("Uninstalling runtime '%s'", opts.RuntimeName)
 
-	err := apcmd.RunRepoUninstall(ctx, &apcmd.RepoUninstallOptions{
+	err = apcmd.RunRepoUninstall(ctx, &apcmd.RepoUninstallOptions{
 		Namespace:    opts.RuntimeName,
 		Timeout:      opts.Timeout,
 		CloneOptions: opts.CloneOpts,
@@ -1202,12 +1219,14 @@ func RunRuntimeUpgrade(ctx context.Context, opts *RuntimeUpgradeOptions) error {
 		infoStr := fmt.Sprintf("Creating app '%s'", component.Name)
 		log.G(ctx).Infof(infoStr)
 		err = component.CreateApp(ctx, nil, opts.CloneOpts, opts.RuntimeName, store.Get().CFComponentType, "", "")
-		handleCliStep(reporter.UpgradeStepCreateApp, infoStr, err, false)
 		if err != nil {
-			return fmt.Errorf("failed to create '%s' application: %w", component.Name, err)
+			err = fmt.Errorf("failed to create '%s' application: %w", component.Name, err)
+			break
 		}
 	}
 
+	handleCliStep(reporter.UpgradeStepCreateApps, "Creating apps", err, false)
+
 	return nil
 }
 
@@ -1668,17 +1687,21 @@ func createCodefreshArgoDashboardAgent(ctx context.Context, path string, cloneOp
 func ensureGitIntegrationOpts(opts *RuntimeInstallOptions) error {
 	var err error
 	if opts.InsCloneOpts.Provider == "" {
-		if opts.GitIntegrationOpts.Provider, err = inferProviderFromCloneURL(opts.InsCloneOpts.URL()); err != nil {
+		if opts.GitIntegrationCreationOpts.Provider, err = inferProviderFromCloneURL(opts.InsCloneOpts.URL()); err != nil {
 			return err
 		}
 	}
 
-	if opts.GitIntegrationOpts.APIURL == "" {
-		if opts.GitIntegrationOpts.APIURL, err = inferAPIURLForGitProvider(opts.GitIntegrationOpts.Provider); err != nil {
+	if opts.GitIntegrationCreationOpts.APIURL == "" {
+		if opts.GitIntegrationCreationOpts.APIURL, err = inferAPIURLForGitProvider(opts.GitIntegrationCreationOpts.Provider); err != nil {
 			return err
 		}
 	}
 
+	if opts.GitIntegrationRegistrationOpts.Token == "" {
+		return fmt.Errorf("git personal access token is missing")
+	}
+
 	return nil
 }
 
@@ -1788,3 +1811,29 @@ func createAnalyticsReporter(ctx context.Context, flow reporter.FlowType) {
 
 	reporter.Init(user, flow)
 }
+
+func validateRuntimeName(runtime string) error {
+	var err error
+	isValid, err := IsValidName(runtime)
+	if err != nil {
+		err = fmt.Errorf("failed to check the validity of the runtime name: %w", err)
+	} else if !isValid {
+		err = fmt.Errorf("runtime name cannot have any uppercase letters, must start with a character, end with character or number, and be shorter than 63 chars")
+	}
+
+	return err
+}
+
+func getVersionIfExists(opts *RuntimeInstallOptions) error {
+	if opts.versionStr != "" {
+		log.G().Infof("vesionStr: %s", opts.versionStr)
+		version, err := semver.NewVersion(opts.versionStr)
+		handleCliStep(reporter.InstallStepPreCheckValidateRuntimeVersion, "Validating runtime version", err, false)
+		if err != nil {
+			return err
+		}
+		opts.Version = version
+		log.G().Infof("opts.Version: %s", opts.Version)
+	}
+	return nil
+}
diff --git a/docs/releases/release_notes.md b/docs/releases/release_notes.md
@@ -23,7 +23,7 @@ cf version
 
 ```bash
 # download and extract the binary
-curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.212/cf-linux-amd64.tar.gz | tar zx
+curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.213/cf-linux-amd64.tar.gz | tar zx
 
 # move the binary to your $PATH
 mv ./cf-linux-amd64 /usr/local/bin/cf
@@ -36,7 +36,7 @@ cf version
 
 ```bash
 # download and extract the binary
-curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.212/cf-darwin-amd64.tar.gz | tar zx
+curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.213/cf-darwin-amd64.tar.gz | tar zx
 
 # move the binary to your $PATH
 mv ./cf-darwin-amd64 /usr/local/bin/cf
diff --git a/manifests/runtime.yaml b/manifests/runtime.yaml
@@ -5,7 +5,7 @@ metadata:
     namespace: '{{ namespace }}'
 spec:
     defVersion: 1.0.0
-    version: 0.0.212
+    version: 0.0.213
     bootstrapSpecifier: github.com/codefresh-io/cli-v2/manifests/argo-cd
     components:
         - name: events
diff --git a/pkg/reporter/reporter.go b/pkg/reporter/reporter.go
@@ -66,6 +66,7 @@ const (
 	InstallStepPreCheckEnsureIngressClass             CliStep = "install.pre-check.step.ensure-ingress-class"
 	InstallStepPreCheckEnsureRuntimeRepo              CliStep = "install.pre-check.step.ensure-runtime-repo"
 	InstallStepPreCheckEnsureGitToken                 CliStep = "install.pre-check.step.ensure-git-token"
+	InstallStepPreCheckEnsureGitPAT                   CliStep = "install.pre-check.step.ensure-git-personal-access-token"
 	InstallStepPreCheckEnsureIngressHost              CliStep = "install.pre-check.step.ensure-ingress-host"
 	InstallStepPreCheckShouldInstallDemoResources     CliStep = "install.pre-check.step.should-install-demo-resources"
 	InstallPhasePreCheckFinish                        CliStep = "install.pre-check.phase.finish"
@@ -89,6 +90,7 @@ const (
 	InstallStepCreateMarketplaceGitsource             CliStep = "install.run.step.create-marketplace-gitsource"
 	InstallStepCompleteRuntimeInstallation            CliStep = "install.run.step.complete-runtime-installation"
 	InstallStepCreateDefaultGitIntegration            CliStep = "install.run.step.create-default-git-integration"
+	InstallStepRegisterToDefaultGitIntegration        CliStep = "install.run.step.register-to-default-git-integration"
 	InstallPhaseFinish                                CliStep = "install.run.phase.finish"
 
 	// Uninstall
@@ -118,7 +120,7 @@ const (
 	UpgradeStepLoadRuntimeDefinition       CliStep = "upgrade.run.step.load-runtime-definition"
 	UpgradeStepUpgradeRuntime              CliStep = "upgrade.run.step.upgrade-runtime"
 	UpgradeStepPushRuntimeDefinition       CliStep = "upgrade.run.step.push-runtime-definition"
-	UpgradeStepCreateApp                   CliStep = "upgrade.run.step.create-app"
+	UpgradeStepCreateApps                  CliStep = "upgrade.run.step.create-apps"
 	UpgradePhaseFinish                     CliStep = "upgrade.run.phase.finish"
 
 	// General

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-VERSION=v0.0.212`
	`1`	`+VERSION=v0.0.213`
`2`	`2`
`3`	`3`	`OUT_DIR=dist`
`4`	`4`	`YEAR?=$(shell date +"%Y")`