in internal/pkg/cli/init.go [104:373]
func newInitOpts(vars initVars) (*initOpts, error) {
fs := afero.NewOsFs()
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("init"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompt := prompt.New()
sel := selector.NewConfigSelector(prompt, configStore)
deployStore, err := deploy.NewStore(sessProvider, configStore)
if err != nil {
return nil, err
}
snsSel := selector.NewDeploySelect(prompt, configStore, deployStore)
spin := termprogress.NewSpinner(log.DiagnosticWriter)
id := identity.New(defaultSess)
deployer := cloudformation.New(defaultSess, cloudformation.WithProgressTracker(os.Stderr))
iamClient := iam.New(defaultSess)
initAppCmd := &initAppOpts{
initAppVars: initAppVars{
name: vars.appName,
},
store: configStore,
prompt: prompt,
identity: id,
cfn: deployer,
prog: spin,
isSessionFromEnvVars: func() (bool, error) {
return sessions.AreCredsFromEnvVars(defaultSess)
},
existingWorkspace: func() (wsAppManager, error) {
return workspace.Use(fs)
},
newWorkspace: func(appName string) (wsAppManager, error) {
return workspace.Create(appName, fs)
},
iam: iamClient,
iamRoleManager: iamClient,
}
initEnvCmd := &initEnvOpts{
store: configStore,
appDeployer: deployer,
prog: spin,
prompt: prompt,
identity: id,
newAppVersionGetter: func(appName string) (versionGetter, error) {
return describe.NewAppDescriber(appName)
},
appCFN: cloudformation.New(defaultSess, cloudformation.WithProgressTracker(os.Stderr)),
sess: defaultSess,
templateVersion: version.LatestTemplateVersion(),
}
deployEnvCmd := &deployEnvOpts{
store: configStore,
sessionProvider: sessProvider,
identity: id,
fs: fs,
newInterpolator: newManifestInterpolator,
newEnvVersionGetter: func(appName, envName string) (versionGetter, error) {
return describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: configStore,
})
},
templateVersion: version.LatestTemplateVersion(),
}
deploySvcCmd := &deploySvcOpts{
deployWkldVars: deployWkldVars{
imageTag: vars.imageTag,
},
store: configStore,
prompt: prompt,
newInterpolator: newManifestInterpolator,
unmarshal: manifest.UnmarshalWorkload,
spinner: spin,
cmd: exec.NewCmd(),
sessProvider: sessProvider,
templateVersion: version.LatestTemplateVersion(),
}
deploySvcCmd.newSvcDeployer = func() (workloadDeployer, error) {
return newSvcDeployer(deploySvcCmd)
}
deployJobCmd := &deployJobOpts{
deployWkldVars: deployWkldVars{
imageTag: vars.imageTag,
},
store: configStore,
newInterpolator: newManifestInterpolator,
unmarshal: manifest.UnmarshalWorkload,
cmd: exec.NewCmd(),
sessProvider: sessProvider,
templateVersion: version.LatestTemplateVersion(),
}
deployJobCmd.newJobDeployer = func() (workloadDeployer, error) {
return newJobDeployer(deployJobCmd)
}
cmd := exec.NewCmd()
useExistingWorkspaceClient := func(o *initOpts) error {
ws, err := workspace.Use(fs)
if err != nil {
return err
}
sel := selector.NewLocalWorkloadSelector(prompt, configStore, ws, selector.OnlyInitializedWorkloads)
initEnvCmd.manifestWriter = ws
initEnvCmd.envLister = ws
deployEnvCmd.ws = ws
deployEnvCmd.newEnvDeployer = func() (envDeployer, error) {
return newEnvDeployer(deployEnvCmd, ws)
}
deploySvcCmd.ws = ws
deploySvcCmd.sel = sel
deployJobCmd.ws = ws
deployJobCmd.sel = sel
if initSvcCmd, ok := o.initWlCmd.(*initSvcOpts); ok {
initSvcCmd.init = &initialize.WorkloadInitializer{Store: configStore, Ws: ws, Prog: spin, Deployer: deployer}
}
if initJobCmd, ok := o.initWlCmd.(*initJobOpts); ok {
initJobCmd.init = &initialize.WorkloadInitializer{Store: configStore, Ws: ws, Prog: spin, Deployer: deployer}
}
return nil
}
ws, err := workspace.Use(fs)
var errNoAppSummary *workspace.ErrNoAssociatedApplication
var errWorkspaceNotFound *workspace.ErrWorkspaceNotFound
if err != nil {
if !errors.As(err, &errWorkspaceNotFound) && !errors.As(err, &errNoAppSummary) {
return nil, err
}
}
return &initOpts{
initVars: vars,
initAppCmd: initAppCmd,
initEnvCmd: initEnvCmd,
deployEnvCmd: deployEnvCmd,
deploySvcCmd: deploySvcCmd,
deployJobCmd: deployJobCmd,
appName: &initAppCmd.name,
envName: &initEnvCmd.name,
prompt: prompt,
sel: sel,
store: configStore,
setupWorkloadInit: func(o *initOpts, wkldType string) error {
wkldVars := initWkldVars{
appName: *o.appName,
wkldType: wkldType,
name: vars.svcName,
dockerfilePath: vars.dockerfilePath,
image: vars.image,
}
dfSel, err := selector.NewDockerfileSelector(prompt, fs)
if err != nil {
return fmt.Errorf("initiate dockerfile selector: %w", err)
}
switch t := wkldType; {
case manifestinfo.IsTypeAJob(t):
jobVars := initJobVars{
initWkldVars: wkldVars,
schedule: vars.schedule,
retries: vars.retries,
timeout: vars.timeout,
}
opts := initJobOpts{
initJobVars: jobVars,
fs: fs,
store: configStore,
dockerfileSel: dfSel,
scheduleSelector: selector.NewStaticSelector(prompt),
prompt: prompt,
newAppVersionGetter: func(appName string) (versionGetter, error) {
return describe.NewAppDescriber(appName)
},
dockerEngine: dockerengine.New(cmd),
wsPendingCreation: true,
initParser: func(s string) dockerfileParser {
return dockerfile.New(fs, s)
},
templateVersion: version.LatestTemplateVersion(),
initEnvDescriber: func(appName string, envName string) (envDescriber, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: configStore,
})
if err != nil {
return nil, err
}
return envDescriber, nil
},
}
if ws != nil {
opts.mftReader = ws
opts.wsAppName = initAppCmd.name
opts.wsPendingCreation = false
}
o.initWlCmd = &opts
o.schedule = &opts.schedule // Surfaced via pointer for logging
o.initWkldVars = &opts.initWkldVars
case manifestinfo.IsTypeAService(t):
svcVars := initSvcVars{
initWkldVars: wkldVars,
port: vars.port,
ingressType: ingressTypeInternet,
}
opts := initSvcOpts{
initSvcVars: svcVars,
fs: fs,
sel: dfSel,
store: configStore,
topicSel: snsSel,
prompt: prompt,
newAppVersionGetter: func(appName string) (versionGetter, error) {
return describe.NewAppDescriber(appName)
},
dockerEngine: dockerengine.New(cmd),
wsPendingCreation: true,
templateVersion: version.LatestTemplateVersion(),
}
opts.dockerfile = func(path string) dockerfileParser {
if opts.df != nil {
return opts.df
}
opts.df = dockerfile.New(opts.fs, opts.dockerfilePath)
return opts.df
}
opts.initEnvDescriber = func(appName string, envName string) (envDescriber, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: opts.store,
})
if err != nil {
return nil, err
}
return envDescriber, nil
}
if ws != nil {
opts.svcLister = ws
opts.mftReader = ws
opts.wsAppName = initAppCmd.name
opts.wsRoot = ws.ProjectRoot()
sourceSel, err := selector.NewLocalFileSelector(prompt, fs, ws)
if err != nil {
return fmt.Errorf("init a new local file selector: %w", err)
}
opts.sourceSel = sourceSel
opts.wsPendingCreation = false
}
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
},
useExistingWorkspaceForCMDs: useExistingWorkspaceClient,
}, nil
}