func newInitOpts()

in internal/pkg/cli/init.go [94:283]
179 lines of code
10 McCabe index (conditional complexity)

func newInitOpts(vars initVars) (*initOpts, error) {
	ws, err := workspace.New()
	if err != nil {
		return nil, err
	}
	ssm, err := config.NewStore()
	if err != nil {
		return nil, err
	}
	sessProvider := sessions.NewProvider()
	defaultSess, err := sessProvider.Default()
	if err != nil {
		return nil, err
	}
	prompt := prompt.New()
	sel := selector.NewWorkspaceSelect(prompt, ssm, ws)
	deployStore, err := deploy.NewStore(ssm)
	if err != nil {
		return nil, err
	}
	snsSel := selector.NewDeploySelect(prompt, ssm, deployStore)
	spin := termprogress.NewSpinner(log.DiagnosticWriter)
	id := identity.New(defaultSess)
	deployer := cloudformation.New(defaultSess)
	if err != nil {
		return nil, err
	}
	initAppCmd := &initAppOpts{
		initAppVars: initAppVars{
			name: vars.appName,
		},
		store:    ssm,
		ws:       ws,
		prompt:   prompt,
		identity: id,
		cfn:      deployer,
		prog:     spin,
		isSessionFromEnvVars: func() (bool, error) {
			return sessions.AreCredsFromEnvVars(defaultSess)
		},
	}
	initEnvCmd := &initEnvOpts{
		initEnvVars: initEnvVars{
			appName:      vars.appName,
			name:         defaultEnvironmentName,
			isProduction: false,
		},
		store:       ssm,
		appDeployer: deployer,
		prog:        spin,
		prompt:      prompt,
		identity:    id,
		appCFN:      cloudformation.New(defaultSess),
		uploader:    template.New(),
		newS3: func(region string) (uploader, error) {
			sess, err := sessProvider.DefaultWithRegion(region)
			if err != nil {
				return nil, err
			}
			return s3.New(sess), nil
		},

		sess: defaultSess,
	}

	deploySvcCmd := &deploySvcOpts{
		deployWkldVars: deployWkldVars{
			envName:  defaultEnvironmentName,
			imageTag: vars.imageTag,
			appName:  vars.appName,
		},

		store:           ssm,
		prompt:          prompt,
		ws:              ws,
		fs:              &afero.Afero{Fs: afero.NewOsFs()},
		newInterpolator: newManifestInterpolator,
		unmarshal:       manifest.UnmarshalWorkload,
		sel:             sel,
		spinner:         spin,
		now:             time.Now,
		cmd:             exec.NewCmd(),
		sessProvider:    sessProvider,
		snsTopicGetter:  deployStore,

		newAppVersionGetter: func(appName string) (versionGetter, error) {
			return describe.NewAppDescriber(appName)
		},
	}
	deployJobCmd := &deployJobOpts{
		deployWkldVars: deployWkldVars{
			envName:  defaultEnvironmentName,
			imageTag: vars.imageTag,
			appName:  vars.appName,
		},
		store:           ssm,
		prompt:          prompt,
		ws:              ws,
		fs:              &afero.Afero{Fs: afero.NewOsFs()},
		newInterpolator: newManifestInterpolator,
		unmarshal:       manifest.UnmarshalWorkload,
		sel:             sel,
		spinner:         spin,
		cmd:             exec.NewCmd(),
		sessProvider:    sessProvider,
	}
	fs := &afero.Afero{Fs: afero.NewOsFs()}
	cmd := exec.NewCmd()
	return &initOpts{
		initVars:     vars,
		ShouldDeploy: vars.shouldDeploy,

		initAppCmd:   initAppCmd,
		initEnvCmd:   initEnvCmd,
		deploySvcCmd: deploySvcCmd,
		deployJobCmd: deployJobCmd,

		appName: &initAppCmd.name,

		prompt: prompt,

		setupWorkloadInit: func(o *initOpts, wkldType string) error {
			wlInitializer := &initialize.WorkloadInitializer{Store: ssm, Ws: ws, Prog: spin, Deployer: deployer}
			wkldVars := initWkldVars{
				appName:        *o.appName,
				wkldType:       wkldType,
				name:           vars.svcName,
				dockerfilePath: vars.dockerfilePath,
				image:          vars.image,
			}
			switch t := wkldType; {
			case t == manifest.ScheduledJobType:
				jobVars := initJobVars{
					initWkldVars: wkldVars,
					schedule:     vars.schedule,
					retries:      vars.retries,
					timeout:      vars.timeout,
				}

				opts := initJobOpts{
					initJobVars: jobVars,

					fs:           fs,
					store:        ssm,
					init:         wlInitializer,
					sel:          sel,
					prompt:       prompt,
					mftReader:    ws,
					dockerEngine: dockerengine.New(cmd),
					initParser: func(s string) dockerfileParser {
						return dockerfile.New(fs, s)
					},
				}
				o.initWlCmd = &opts
				o.schedule = &opts.schedule // Surfaced via pointer for logging
				o.initWkldVars = &opts.initWkldVars
			case manifest.IsTypeAService(t):
				svcVars := initSvcVars{
					initWkldVars: wkldVars,
					port:         vars.port,
				}
				opts := initSvcOpts{
					initSvcVars: svcVars,

					fs:           fs,
					init:         wlInitializer,
					sel:          sel,
					store:        ssm,
					topicSel:     snsSel,
					mftReader:    ws,
					prompt:       prompt,
					dockerEngine: dockerengine.New(cmd),
				}
				opts.dockerfile = func(path string) dockerfileParser {
					if opts.df != nil {
						return opts.df
					}
					opts.df = dockerfile.New(opts.fs, opts.dockerfilePath)
					return opts.df
				}
				o.initWlCmd = &opts
				o.port = &opts.port // Surfaced via pointer for logging.
				o.initWkldVars = &opts.initWkldVars
			default:
				return fmt.Errorf("unrecognized workload type")
			}
			return nil
		},
	}, nil
}