func execute()

in agent/pluginmanager/acspluginmanager/main/main.go [67:195]
115 lines of code
19 McCabe index (conditional complexity)

func execute(ctx *cli.Context, args []string) error {
	verbose := flag.VerboseFlag(ctx.Flags()).IsAssigned()
	pluginManager, err := pm.NewPluginManager(verbose)
	if err != nil {
		return err
	}

	version := flag.VersionFlag(ctx.Flags()).IsAssigned()
	list := flag.ListFlag(ctx.Flags()).IsAssigned()
	local := flag.LocalFlag(ctx.Flags()).IsAssigned()
	verify := flag.VerifyFlag(ctx.Flags()).IsAssigned()
	status := flag.StatusFlag(ctx.Flags()).IsAssigned()
	exec := flag.ExecFlag(ctx.Flags()).IsAssigned()
	remove := flag.RemoveFlag(ctx.Flags()).IsAssigned()

	plugin, _ := flag.PluginFlag(ctx.Flags()).GetValue()
	pluginId, _ := flag.PluginIdFlag(ctx.Flags()).GetValue()
	pluginVersion, _ := flag.PluginVersionFlag(ctx.Flags()).GetValue()
	params, _ := flag.ParamsFlag(ctx.Flags()).GetValue()
	paramsV2, _ := flag.ParamsV2Flag(ctx.Flags()).GetValue()
	url, _ := flag.UrlFlag(ctx.Flags()).GetValue()
	separator, _ := flag.SeparatorFlag(ctx.Flags()).GetValue()
	file, _ := flag.FileFlag(ctx.Flags()).GetValue()

	var fetchTimeoutInSeconds int = 20
	if fetchTimeout, assigned := flag.FetchTimeoutFlag(ctx.Flags()).GetValue(); assigned {
		fetchTimeoutValue, err := strconv.Atoi(fetchTimeout)
		if err != nil {
			return fmt.Errorf(`Invalid fetch timeout argument "%s": %w`, fetchTimeout, err)
		}
		fetchTimeoutInSeconds = fetchTimeoutValue
	}

	var optionalExecutionTimeoutInSeconds *int = nil
	if executionTimeout, assigned := flag.ExecutionTimeoutFlag(ctx.Flags()).GetValue(); assigned {
		executionTimeoutValue, err := strconv.Atoi(executionTimeout)
		if err != nil {
			return fmt.Errorf(`Invalid timeout argument for execution "%s": %w`, executionTimeout, err)
		}

		optionalExecutionTimeoutInSeconds = &executionTimeoutValue
	}

	if verbose {
		log.GetLogger().WithFields(log.Fields{
			"verbose":       verbose,
			"list":          list,
			"local":         local,
			"verify":        verify,
			"status":        status,
			"exec":          exec,
			"plugin":        plugin,
			"pluginId":      pluginId,
			"pluginversion": pluginVersion,
			"params":        params,
			"paramsV2":      paramsV2,
			"url":           url,
			"separator":     separator,
			"file":          file,
		}).Infof("Command-line options")
	}

	exitCode := 0
	if version {
		fmt.Println(versioning.AssistVersion)
	} else if list {
		log.GetLogger().Infof("Listing all plugins")
		exitCode, err = pluginManager.List(plugin, local)
	} else if verify {
		executeParams := &pm.ExecuteParams{
			CommonExecuteParams: pm.CommonExecuteParams{
				Params:    params,
				Separator: separator,
				ParamsV2:  paramsV2,

				OptionalExecutionTimeoutInSeconds: optionalExecutionTimeoutInSeconds,
			},
		}
		if err = parsePlatformSpecificFlags(ctx.Flags(), executeParams); err != nil {
			return err
		}

		exitCode, err = pluginManager.VerifyPlugin(&pm.VerifyFetchOptions{
			Url: url,

			FetchTimeoutInSeconds: fetchTimeoutInSeconds,
		}, executeParams)
	} else if status {
		exitCode, err = pluginManager.ShowPluginStatus()
	} else if exec {
		executeParams := &pm.ExecuteParams{
			CommonExecuteParams: pm.CommonExecuteParams{
				Params:    params,
				Separator: separator,
				ParamsV2:  paramsV2,

				OptionalExecutionTimeoutInSeconds: optionalExecutionTimeoutInSeconds,
			},
		}
		if err = parsePlatformSpecificFlags(ctx.Flags(), executeParams); err != nil {
			return err
		}

		exitCode, err = pluginManager.ExecutePlugin(&pm.ExecFetchOptions{
			File:       file,
			PluginName: plugin,
			PluginId:   pluginId,
			Version:    pluginVersion,
			Local:      local,

			FetchTimeoutInSeconds: fetchTimeoutInSeconds,
		}, executeParams)
	} else if remove {
		exitCode, err = pluginManager.RemovePlugin(plugin)
	} else {
		ctx.Command().PrintFlags(ctx)
	}
	if err != nil {
		log.GetLogger().Errorln(err)
	}
	if exitCode != 0 {
		os.Exit(exitCode)
	}
	if err != nil {
		fmt.Println(err)
	}

	return nil
}