CR-14855-custom-runtime-manifest (#598)

* support --runtime-def flag

Author: ATGardner

Makefile

@@ -1,4 +1,4 @@
-VERSION=v0.0.539
+VERSION=v0.0.540
 
 OUT_DIR=dist
 YEAR?=$(shell date +"%Y")
@@ -99,15 +99,16 @@ $(OUT_DIR)/$(CLI_NAME)-%.sha256:
 
 $(OUT_DIR)/$(CLI_NAME)-%: $(CLI_SRCS)
 	@GO_FLAGS=$(GO_FLAGS) \
-	BUILD_DATE=$(BUILD_DATE) \
 	BINARY_NAME=$(CLI_NAME) \
 	VERSION=$(VERSION) \
+	BUILD_DATE=$(BUILD_DATE) \
 	GIT_COMMIT=$(GIT_COMMIT) \
-	OUT_FILE=$(OUT_DIR)/$(CLI_NAME)-$* \
 	RUNTIME_DEF_URL=$(RUNTIME_DEF_URL) \
 	ADD_CLUSTER_DEF_URL=$(ADD_CLUSTER_DEF_URL) \
 	FALLBACK_ADD_CLUSTER_DEF_URL=$(FALLBACK_ADD_CLUSTER_DEF_URL) \
 	SEGMENT_WRITE_KEY=$(SEGMENT_WRITE_KEY) \
+	DEV_MODE=$(DEV_MODE) \
+	OUT_FILE=$(OUT_DIR)/$(CLI_NAME)-$* \
 	MAIN=./cmd \
 	./hack/build.sh
 

cmd/commands/runtime.go

@@ -74,6 +74,7 @@ type (
 		CommonConfig              *runtime.CommonConfig
 		SuggestedSharedConfigRepo string
 		DisableTelemetry          bool
+		runtimeDef                string
 
 		featuresToInstall []runtime.InstallFeature
 	}
@@ -819,8 +820,12 @@ func NewRuntimeUpgradeCommand() *cobra.Command {
 	cmd.Flags().StringVar(&opts.SuggestedSharedConfigRepo, "shared-config-repo", "", "URL to the shared configurations repo. (default: <installation-repo> or the existing one for this account)")
 	cmd.Flags().BoolVar(&opts.DisableTelemetry, "disable-telemetry", false, "If true, will disable analytics reporting for the upgrade process")
 	cmd.Flags().BoolVar(&store.Get().SetDefaultResources, "set-default-resources", false, "If true, will set default requests and limits on all of the runtime components")
+	cmd.Flags().StringVar(&opts.runtimeDef, "runtime-def", store.RuntimeDefURL, "Install runtime from a specific manifest")
 	opts.CloneOpts = apu.AddCloneFlags(cmd, &apu.CloneFlagsOptions{CloneForWrite: true})
 
+	util.Die(cmd.Flags().MarkHidden("runtime-def"))
+	cmd.MarkFlagsMutuallyExclusive("version", "runtime-def")
+
 	return cmd
 }
 
@@ -829,7 +834,8 @@ func runRuntimeUpgrade(ctx context.Context, opts *RuntimeUpgradeOptions) error {
 
 	log.G(ctx).Info("Downloading runtime definition")
 
-	newRt, err := runtime.Download(opts.Version, opts.RuntimeName, opts.featuresToInstall)
+	runtimeDef := getRuntimeDef(opts.runtimeDef, opts.Version.String())
+	newRt, err := runtime.Download(runtimeDef, opts.RuntimeName, opts.featuresToInstall)
 	handleCliStep(reporter.UpgradeStepDownloadRuntimeDefinition, "Downloading runtime definition", err, true, false)
 	if err != nil {
 		return fmt.Errorf("failed to download runtime definition: %w", err)

cmd/commands/runtime_install.go

@@ -93,7 +93,6 @@ type (
 		DisableRollback                bool
 		DisableTelemetry               bool
 		FromRepo                       bool
-		Version                        *semver.Version
 		GsCloneOpts                    *apgit.CloneOptions
 		InsCloneOpts                   *apgit.CloneOptions
 		GitIntegrationCreationOpts     *apmodel.AddGitIntegrationArgs
@@ -119,6 +118,7 @@ type (
 		gitProvider       cfgit.Provider
 		useGatewayAPI     bool
 		featuresToInstall []runtime.InstallFeature
+		runtimeDef        string
 	}
 
 	tunnelServer struct {
@@ -254,6 +254,7 @@ func NewRuntimeInstallCommand() *cobra.Command {
 	cmd.Flags().StringToStringVar(&installationOpts.InternalIngressAnnotation, "internal-ingress-annotation", nil, "Add annotations to the internal ingress")
 	cmd.Flags().StringToStringVar(&installationOpts.ExternalIngressAnnotation, "external-ingress-annotation", nil, "Add annotations to the external ingress")
 	cmd.Flags().BoolVar(&installationOpts.EnableGitProviders, "enable-git-providers", false, "Enable git providers (bitbucket|bitbucket-server|gitlab)")
+	cmd.Flags().StringVar(&installationOpts.runtimeDef, "runtime-def", store.RuntimeDefURL, "Install runtime from a specific manifest")
 	cmd.Flags().StringVar(&accessMode, "access-mode", string(platmodel.AccessModeIngress), "The access mode to the cluster, one of: ingress|tunnel")
 	cmd.Flags().StringVar(&installationOpts.TunnelRegisterHost, "tunnel-register-host", "register-tunnels.cf-cd.com", "The host name for registering a new tunnel")
 	cmd.Flags().StringVar(&installationOpts.TunnelDomain, "tunnel-domain", "tunnels.cf-cd.com", "The base domain for the tunnels")
@@ -278,6 +279,9 @@ func NewRuntimeInstallCommand() *cobra.Command {
 	util.Die(cmd.Flags().MarkHidden("tunnel-register-host"))
 	util.Die(cmd.Flags().MarkHidden("tunnel-domain"))
 	util.Die(cmd.Flags().MarkHidden("ips-allow-list"))
+	util.Die(cmd.Flags().MarkHidden("runtime-def"))
+	cmd.MarkFlagsMutuallyExclusive("runtime-def", "version")
+	cmd.MarkFlagsMutuallyExclusive("runtime-def", "set-default-resources")
 
 	return cmd
 }
@@ -288,12 +292,8 @@ func runtimeInstallCommandPreRunHandler(cmd *cobra.Command, opts *RuntimeInstall
 
 	handleCliStep(reporter.InstallPhasePreCheckStart, "Starting pre checks", nil, true, false)
 
-	opts.Version, err = getVersionIfExists(opts.versionStr)
+	err = validateVersionIfExists(opts.versionStr)
 	handleCliStep(reporter.InstallStepPreCheckValidateRuntimeVersion, "Validating runtime version", err, true, false)
-	if err != nil {
-		return err
-	}
-
 	if opts.RuntimeName == "" {
 		if !store.Get().Silent {
 			opts.RuntimeName, err = getRuntimeNameFromUserInput()
@@ -597,19 +597,14 @@ func createRuntimeOnPlatform(ctx context.Context, opts *RuntimeInstallOptions, r
 }
 
 func runRuntimeInstall(ctx context.Context, opts *RuntimeInstallOptions) error {
-	err := preInstallationChecks(ctx, opts)
+	rt, err := preInstallationChecks(ctx, opts)
 	handleCliStep(reporter.InstallPhaseRunPreCheckFinish, "Pre run installation checks", err, true, true)
 	if err != nil {
 		return fmt.Errorf("pre installation checks failed: %w", err)
 	}
 
 	handleCliStep(reporter.InstallPhaseStart, "Runtime installation phase started", nil, false, true)
 
-	rt, err := runtimeInstallPreparations(opts)
-	if err != nil {
-		return err
-	}
-
 	if opts.FromRepo {
 		// in case of a runtime recovery, we don't want to clear the repo when failure occures
 		opts.DisableRollback = true
@@ -781,22 +776,6 @@ To complete the installation:
 	return nil
 }
 
-func runtimeInstallPreparations(opts *RuntimeInstallOptions) (*runtime.Runtime, error) {
-	rt, err := runtime.Download(opts.Version, opts.RuntimeName, opts.featuresToInstall)
-	handleCliStep(reporter.InstallStepDownloadRuntimeDefinition, "Downloading runtime definition", err, false, true)
-	if err != nil {
-		return nil, fmt.Errorf("failed to download runtime definition: %w", err)
-	}
-
-	rt.Spec.Cluster, err = util.KubeServerByContextName(opts.kubeContext, opts.kubeconfig)
-	handleCliStep(reporter.InstallStepGetServerAddress, "Getting kube server address", err, false, true)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current server address: %w", err)
-	}
-
-	return rt, nil
-}
-
 func createRuntimeComponents(ctx context.Context, opts *RuntimeInstallOptions, rt *runtime.Runtime) error {
 	var err error
 
@@ -1104,22 +1083,24 @@ func installComponents(ctx context.Context, opts *RuntimeInstallOptions, rt *run
 	return nil
 }
 
-func preInstallationChecks(ctx context.Context, opts *RuntimeInstallOptions) error {
+func preInstallationChecks(ctx context.Context, opts *RuntimeInstallOptions) (*runtime.Runtime, error) {
 	var err error
+
 	log.G(ctx).Debug("running pre-installation checks...")
 
 	handleCliStep(reporter.InstallPhaseRunPreCheckStart, "Running pre run installation checks", nil, true, false)
 
 	err = checkIscProvider(ctx, opts.InsCloneOpts)
 	handleCliStep(reporter.InstallStepRunPreCheckGitProvider, "Checking Account Git Provider", err, true, true)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	rt, err := runtime.Download(opts.Version, opts.RuntimeName, nil) // no need to send featuresToInstall, since we only use the runtime to get the DefVersion anyway
+	runtimeDef := getRuntimeDef(opts.runtimeDef, opts.versionStr)
+	rt, err := runtime.Download(runtimeDef, opts.RuntimeName, nil)
 	handleCliStep(reporter.InstallStepRunPreCheckDownloadRuntimeDefinition, "Downloading runtime definition", err, true, true)
 	if err != nil {
-		return fmt.Errorf("failed to download runtime definition: %w", err)
+		return nil, fmt.Errorf("failed to download runtime definition: %w", err)
 	}
 
 	if rt.Spec.DefVersion.GreaterThan(store.Get().MaxDefVersion) {
@@ -1128,38 +1109,47 @@ func preInstallationChecks(ctx context.Context, opts *RuntimeInstallOptions) err
 
 	handleCliStep(reporter.InstallStepRunPreCheckEnsureCliVersion, "Checking CLI version", err, true, false)
 	if err != nil {
-		return util.DecorateErrorWithDocsLink(err, store.Get().DownloadCliLink)
+		return nil, util.DecorateErrorWithDocsLink(err, store.Get().DownloadCliLink)
 	}
 
 	err = checkRuntimeCollisions(ctx, opts.KubeFactory, opts.RuntimeName)
 	handleCliStep(reporter.InstallStepRunPreCheckRuntimeCollision, "Checking for runtime collisions", err, true, false)
 	if err != nil {
-		return fmt.Errorf("runtime collision check failed: %w", err)
+		return nil, fmt.Errorf("runtime collision check failed: %w", err)
+	}
+
+	rt.Spec.Cluster, err = util.KubeServerByContextName(opts.kubeContext, opts.kubeconfig)
+	handleCliStep(reporter.InstallStepGetServerAddress, "Getting kube server address", err, false, true)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get current server address: %w", err)
 	}
 
 	if !opts.FromRepo {
 		err = checkExistingRuntimes(ctx, opts.RuntimeName)
 	}
+
 	handleCliStep(reporter.InstallStepRunPreCheckExisitingRuntimes, "Checking for exisiting runtimes", err, true, false)
 	if err != nil {
-		return fmt.Errorf("existing runtime check failed: %w", err)
+		return nil, fmt.Errorf("existing runtime check failed: %w", err)
 	}
 
 	if !opts.SkipClusterChecks {
-		err = kubeutil.EnsureClusterRequirements(ctx, kubeutil.RuntimeInstallOptions{
+		err = kubeutil.EnsureClusterRequirements(ctx, kubeutil.ClusterRequirementsOptions{
 			KubeFactory:        opts.KubeFactory,
 			Namespace:          opts.RuntimeName,
 			ContextUrl:         cfConfig.GetCurrentContext().URL,
 			AccessMode:         opts.AccessMode,
 			TunnelRegisterHost: opts.TunnelRegisterHost,
+			IsCustomInstall:    opts.IsCustomInstall(),
 		})
 	}
+
 	handleCliStep(reporter.InstallStepRunPreCheckValidateClusterRequirements, "Ensuring cluster requirements", err, true, false)
 	if err != nil {
-		return fmt.Errorf("validation of minimum cluster requirements failed: %w", err)
+		return nil, fmt.Errorf("validation of minimum cluster requirements failed: %w", err)
 	}
 
-	return nil
+	return rt, nil
 }
 
 func checkIscProvider(ctx context.Context, opts *apgit.CloneOptions) error {
@@ -2012,13 +2002,14 @@ func printPreviousVsNewConfigsToUser(previousConfigurations map[string]string, n
 	fmt.Printf("%vIngress host:%v       %s %v--> %s%v\n", BOLD, BOLD_RESET, previousConfigurations["IngressHost"], GREEN, newConfigurations["IngressHost"], COLOR_RESET)
 }
 
-func getVersionIfExists(versionStr string) (*semver.Version, error) {
+func validateVersionIfExists(versionStr string) error {
+	var err error
 	if versionStr != "" {
 		log.G().Infof("vesionStr: %s", versionStr)
-		return semver.NewVersion(versionStr)
+		_, err = semver.NewVersion(versionStr)
 	}
 
-	return nil, nil
+	return err
 }
 
 func initializeGitSourceCloneOpts(opts *RuntimeInstallOptions) {
@@ -2055,3 +2046,28 @@ func (opts *RuntimeInstallOptions) GetValues(name string) (string, error) {
 func (opts *RuntimeInstallOptions) shouldInstallIngress() bool {
 	return !opts.SkipIngress && opts.AccessMode == platmodel.AccessModeIngress
 }
+
+func (opts *RuntimeInstallOptions) IsCustomInstall() bool {
+	return opts.runtimeDef != store.RuntimeDefURL
+}
+
+func getRuntimeDef(runtimeDef, versionStr string) string {
+	if !strings.HasPrefix(runtimeDef, "http") {
+		// runtimeDef is some local file
+		return runtimeDef
+	}
+
+	if versionStr == "" {
+		// no specific version string
+		return runtimeDef
+	}
+
+	version, err := semver.NewVersion(versionStr)
+	if err != nil {
+		// should not arrive here, since we check for validateVersionIfExists earlier
+		return runtimeDef
+	}
+
+	// specific version means the runtimeDef is the default value in cli-v2 repo
+	return strings.Replace(runtimeDef, "/releases/latest/download", "/releases/download/v"+version.String(), 1)
+}

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.539/cf-linux-amd64.tar.gz | tar zx
+curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.540/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.539/cf-darwin-amd64.tar.gz | tar zx
+curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.540/cf-darwin-amd64.tar.gz | tar zx
 
 # move the binary to your $PATH
 mv ./cf-darwin-amd64 /usr/local/bin/cf

hack/build.sh

@@ -16,5 +16,6 @@ go build -ldflags=" \
     -X 'github.com/codefresh-io/cli-v2/pkg/store.RuntimeDefURL=${RUNTIME_DEF_URL}' \
     -X 'github.com/codefresh-io/cli-v2/pkg/store.AddClusterDefURL=${ADD_CLUSTER_DEF_URL}' \
     -X 'github.com/codefresh-io/cli-v2/pkg/store.FallbackAddClusterDefURL=${FALLBACK_ADD_CLUSTER_DEF_URL}' \
-    -X 'github.com/codefresh-io/cli-v2/pkg/store.segmentWriteKey=${SEGMENT_WRITE_KEY}'" \
+    -X 'github.com/codefresh-io/cli-v2/pkg/store.SegmentWriteKey=${SEGMENT_WRITE_KEY}' \
+    -X 'github.com/codefresh-io/cli-v2/pkg/store.devMode=${DEV_MODE}'" \
     -v -o ${OUT_FILE} ${MAIN}

manifests/runtime.yaml

@@ -5,7 +5,7 @@ metadata:
   namespace: "{{ namespace }}"
 spec:
   defVersion: 2.0.0
-  version: 0.0.539
+  version: 0.0.540
   bootstrapSpecifier: github.com/codefresh-io/cli-v2/manifests/argo-cd
   components:
     - name: events

pkg/reporter/reporter.go

@@ -151,7 +151,7 @@ func G() AnalyticsReporter {
 }
 
 func Init(user *codefresh.User, flow FlowType) {
-	writeKey := store.Get().SegmentWriteKey
+	writeKey := store.SegmentWriteKey
 	if writeKey == "" {
 		log.G().Debug("No segment write key was provided. Using the noop reporter.")
 		return