func Install()

in operator/cmd/mesh/install.go [158:259]
86 lines of code
25 McCabe index (conditional complexity)

func Install(rootArgs *RootArgs, iArgs *InstallArgs, logOpts *log.Options, stdOut io.Writer, l clog.Logger, p Printer) error {
	kubeClient, client, err := KubernetesClients(iArgs.KubeConfigPath, iArgs.Context, l)
	if err != nil {
		return err
	}

	tag, err := GetTagVersion(operatorVer.OperatorVersionString)
	if err != nil {
		return fmt.Errorf("fetch Istio version: %v", err)
	}
	setFlags := applyFlagAliases(iArgs.Set, iArgs.ManifestsPath, iArgs.Revision)

	_, iop, err := manifest.GenerateConfig(iArgs.InFilenames, setFlags, iArgs.Force, kubeClient, l)
	if err != nil {
		return fmt.Errorf("generate config: %v", err)
	}

	profile, ns, enabledComponents, err := getProfileNSAndEnabledComponents(iop)
	if err != nil {
		return fmt.Errorf("failed to get profile, namespace or enabled components: %v", err)
	}

	// Ignore the err because we don't want to show
	// "no running Istio pods in dubbo-system" for the first time
	_ = detectIstioVersionDiff(p, tag, ns, kubeClient, setFlags)

	// Warn users if they use `istioctl install` without any config args.
	if !rootArgs.DryRun && !iArgs.SkipConfirmation {
		prompt := fmt.Sprintf("This will install the Istio %s %s profile with %q components into the cluster. Proceed? (y/N)", tag, profile, enabledComponents)
		if profile == "empty" {
			prompt = fmt.Sprintf("This will install the Istio %s %s profile into the cluster. Proceed? (y/N)", tag, profile)
		}
		if !confirm(prompt, stdOut) {
			p.Println("Cancelled.")
			os.Exit(1)
		}
	}
	if err := configLogs(logOpts); err != nil {
		return fmt.Errorf("could not configure logs: %s", err)
	}

	// Detect whether previous installation exists prior to performing the installation.
	exists := revtag.PreviousInstallExists(context.Background(), kubeClient)
	pilotEnabled := iop.Spec.Components.Pilot != nil && iop.Spec.Components.Pilot.Enabled.Value
	rev := iop.Spec.Revision
	if rev == "" && pilotEnabled {
		_ = revtag.DeleteTagWebhooks(context.Background(), kubeClient, revtag.DefaultRevisionName)
	}
	iop, err = InstallManifests(iop, iArgs.Force, rootArgs.DryRun, kubeClient, client, iArgs.ReadinessTimeout, l)
	if err != nil {
		return fmt.Errorf("failed to install manifests: %v", err)
	}

	if !exists || rev == "" && pilotEnabled {
		p.Println("Making this installation the default for injection and validation.")
		if rev == "" {
			rev = revtag.DefaultRevisionName
		}
		autoInjectNamespaces := validateEnableNamespacesByDefault(iop)

		o := &revtag.GenerateOptions{
			Tag:                  revtag.DefaultRevisionName,
			Revision:             rev,
			Overwrite:            true,
			AutoInjectNamespaces: autoInjectNamespaces,
		}
		// If tag cannot be created could be remote cluster install, don't fail out.
		tagManifests, err := revtag.Generate(context.Background(), kubeClient, o, ns)
		if err == nil {
			err = revtag.Create(kubeClient, tagManifests)
			if err != nil {
				return err
			}
		}
	}

	if iArgs.Verify {
		if rootArgs.DryRun {
			l.LogAndPrint("Control plane health check is not applicable in dry-run mode")
			return nil
		}
		l.LogAndPrint("\n\nVerifying installation:")
		installationVerifier, err := verifier.NewStatusVerifier(iop.Namespace, iArgs.ManifestsPath, iArgs.KubeConfigPath,
			iArgs.Context, iArgs.InFilenames, clioptions.ControlPlaneOptions{Revision: iop.Spec.Revision},
			verifier.WithLogger(l),
			verifier.WithIOP(iop),
		)
		if err != nil {
			return fmt.Errorf("failed to setup verifier: %v", err)
		}
		if err := installationVerifier.Verify(); err != nil {
			return fmt.Errorf("verification failed with the following error: %v", err)
		}
	}

	if !rootArgs.DryRun {
		_, _ = fmt.Fprintln(stdOut, "\nThank you for installing Istio 1.14.  Please take a few minutes to "+
			"tell us about your install/upgrade experience!  https://forms.gle/yEtCbt45FZ3VoDT5A")
	}

	return nil
}