func installAndVerifyAgent()

in agent/setupcli/setupcli.go [396:532]
116 lines of code
34 McCabe index (conditional complexity)

func installAndVerifyAgent(log log.T,
	packageManager packagemanagers.IPackageManager,
	verificationManager verificationmanagers.IVerificationManager,
	serviceManager servicemanagers.IServiceManager,
	downloadManager downloadmanager.IDownloadManager,
	setupCLIArtifactsPath string,
	isNano bool) error {

	var targetAgentVersion string

	// Check whether SSM-Setup-CLI is latest or not.
	latestVersion, err := downloadManager.GetLatestVersion()
	if err != nil {
		return fmt.Errorf("failed to get latest version: %v", err)
	}
	// assign latest version when latest version value is passed in -version flag
	if strings.EqualFold(version, utility.LatestVersionString) {
		targetAgentVersion = latestVersion
	}

	var isAgentInstalled bool // This bool says that an agent is already installed

	// Check whether the requested target version is installed
	if isAgentInstalled, err = packageManager.IsAgentInstalled(); err != nil {
		return fmt.Errorf("failed to get agent installation status: %v", err)
	}
	if !isAgentInstalled && strings.TrimSpace(version) == "" {
		version = utility.StableVersionString
	}

	// Get stable version
	var stableVersion string
	if version == utility.StableVersionString {
		stableVersion, err = downloadManager.GetStableVersion()
		if err != nil {
			return fmt.Errorf("failed to get stable version: %v", err)
		}
		targetAgentVersion = stableVersion
	}

	agentVersionInstalled, err := packageManager.GetInstalledAgentVersion()
	if isAgentInstalled && agentVersionInstalled == "" {
		return fmt.Errorf("error while getting installed agent version: %v", err)
	}
	log.Infof("Installed agent version - %v", agentVersionInstalled)

	if isAgentInstalled && targetAgentVersion == "" {
		targetAgentVersion = agentVersionInstalled
	}

	var isTargetAgentInstalled bool // This bool says that the target version is already installed
	sourceVersionFilePaths, targetVersionFilePaths := "", ""
	uninstallNeeded := false
	if isAgentInstalled {
		if strings.EqualFold(agentVersionInstalled, targetAgentVersion) {
			log.Infof("Version already installed %v: ", targetAgentVersion)
			isTargetAgentInstalled = true
		} else if versionutil.Compare(agentVersionInstalled, targetAgentVersion, true) > 0 {
			if downgrade == false {
				return fmt.Errorf("downgrade flag is not set")
			}
			sourceVersionFilePaths = filepath.Join(setupCLIArtifactsPath, agentVersionInstalled)
			if err = fileUtilMakeDirs(sourceVersionFilePaths); err != nil {
				return fmt.Errorf("could not create source version directory: %v", err)
			}
			err = downloadManager.DownloadArtifacts(agentVersionInstalled, manifestUrl, sourceVersionFilePaths)
			if err != nil {
				return fmt.Errorf("error while downloading source agent: %v", err)
			}
			uninstallNeeded = true
		}
	}

	if !isTargetAgentInstalled {
		// Download target agent version artifacts
		log.Infof("Started downloaded agent artifacts for version: %v", targetAgentVersion)
		targetVersionFilePaths = filepath.Join(setupCLIArtifactsPath, targetAgentVersion)
		if err = fileUtilMakeDirs(targetVersionFilePaths); err != nil {
			return fmt.Errorf("could not update folder permissions: %v", err)
		}
		err = downloadManager.DownloadArtifacts(targetAgentVersion, manifestUrl, targetVersionFilePaths)
		if err != nil {
			return fmt.Errorf("error while downloading agent %v", err)
		}
		log.Infof("Successfully downloaded agent artifacts for version: %v", version)

		if !skipSignatureValidation && verificationManager != nil {
			fileExtension := packageManager.GetFileExtension()

			// Download will happen only for Linux
			signaturePath, err := downloadManager.DownloadSignatureFile(targetAgentVersion, targetVersionFilePaths, fileExtension)
			if err != nil {
				return fmt.Errorf("failed to download signature file %v", err)
			}
			log.Infof("Signature path: %v", signaturePath)

			log.Infof("Start agent signature verification")
			err = verificationManager.VerifySignature(log, signaturePath, targetVersionFilePaths, fileExtension)
			if err != nil {
				return fmt.Errorf("failed to verify signature file: %v", err)
			}
			log.Infof("Agent signature verification ended successfully")
		}
	}

	if uninstallNeeded {
		err = helperUnInstallAgent(log, packageManager, serviceManager, sourceVersionFilePaths)
		if err != nil {
			return fmt.Errorf("uninstallation failed for source version: %v", err)
		}
		timeSleep(2 * time.Second)
		if isAgentInstalled, err = packageManager.IsAgentInstalled(); err != nil || isAgentInstalled {
			return fmt.Errorf("failed to get agent installation status: %v", err)
		}
	}

	log.Infof("Attempting to configure agent")
	configManager := getConfigurationManager()
	if err = configManager.CreateUpdateAgentConfigWithOnPremIdentity(); err != nil {
		return fmt.Errorf("return failed to update agent config %v", err)
	}
	log.Infof("Agent is configured successfully")

	if !isTargetAgentInstalled {
		log.Infof("Starting agent installation")
		if err := helperInstallAgent(log, packageManager, serviceManager, targetVersionFilePaths); err != nil {
			return fmt.Errorf("installation failed %v", err)
		}
		if isNano {
			if err = startAgent(serviceManager, log); err != nil {
				return fmt.Errorf("failed while starting agent: %v", err)
			}
		}
		log.Infof("Agent installed successfully")
	}
	return nil
}