repo_name
stringlengths 1
52
| repo_creator
stringclasses 6
values | programming_language
stringclasses 4
values | code
stringlengths 0
9.68M
| num_lines
int64 1
234k
|
|---|---|---|---|---|
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
const (
jobPackageJobNamePrompt = "Which job would you like to generate a CloudFormation template for?"
jobPackageEnvNamePrompt = "Which environment would you like to package this stack for?"
)
type packageJobVars struct {
name string
envName string
appName string
tag string
outputDir string
uploadAssets bool
showDiff bool
}
type packageJobOpts struct {
packageJobVars
// Interfaces to interact with dependencies.
ws wsJobDirReader
store store
runner execRunner
sel wsSelector
prompt prompter
// Subcommand implementing svc_package's Execute()
packageCmd actionCommand
newPackageCmd func(*packageJobOpts)
}
func newPackageJobOpts(vars packageJobVars) (*packageJobOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("job package"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
prompter := prompt.New()
opts := &packageJobOpts{
packageJobVars: vars,
ws: ws,
store: store,
runner: exec.NewCmd(),
sel: selector.NewLocalWorkloadSelector(prompter, store, ws),
prompt: prompter,
}
opts.newPackageCmd = func(o *packageJobOpts) {
opts.packageCmd = &packageSvcOpts{
packageSvcVars: packageSvcVars{
name: o.name,
envName: o.envName,
appName: o.appName,
tag: o.tag,
outputDir: o.outputDir,
uploadAssets: o.uploadAssets,
},
runner: o.runner,
ws: ws,
store: o.store,
templateWriter: os.Stdout,
unmarshal: manifest.UnmarshalWorkload,
newInterpolator: newManifestInterpolator,
paramsWriter: discardFile{},
addonsWriter: discardFile{},
fs: fs,
sessProvider: sessProvider,
newStackGenerator: newWorkloadStackGenerator,
gitShortCommit: imageTagFromGit(o.runner),
}
}
return opts, nil
}
// Validate returns an error if the values provided by the user are invalid.
func (o *packageJobOpts) Validate() error {
if o.appName == "" {
return errNoAppInWorkspace
}
if o.name != "" {
names, err := o.ws.ListJobs()
if err != nil {
return fmt.Errorf("list jobs in the workspace: %w", err)
}
if !contains(o.name, names) {
return fmt.Errorf("job '%s' does not exist in the workspace", o.name)
}
}
if o.envName != "" {
if _, err := o.store.GetEnvironment(o.appName, o.envName); err != nil {
return err
}
}
return nil
}
// Ask prompts the user for any missing required fields.
func (o *packageJobOpts) Ask() error {
if err := o.askJobName(); err != nil {
return err
}
if err := o.askEnvName(); err != nil {
return err
}
return nil
}
// Execute prints the CloudFormation template of the application for the environment.
func (o *packageJobOpts) Execute() error {
o.newPackageCmd(o)
return o.packageCmd.Execute()
}
// RecommendActions suggests recommended actions before the packaged template is used for deployment.
func (o *packageJobOpts) RecommendActions() error {
return o.packageCmd.RecommendActions()
}
func (o *packageJobOpts) askJobName() error {
if o.name != "" {
return nil
}
name, err := o.sel.Job(jobPackageJobNamePrompt, "")
if err != nil {
return fmt.Errorf("select job: %w", err)
}
o.name = name
return nil
}
func (o *packageJobOpts) askEnvName() error {
if o.envName != "" {
return nil
}
name, err := o.sel.Environment(jobPackageEnvNamePrompt, "", o.appName)
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
o.envName = name
return nil
}
// buildJobPackageCmd builds the command for printing a job's CloudFormation template.
func buildJobPackageCmd() *cobra.Command {
vars := packageJobVars{}
cmd := &cobra.Command{
Use: "package",
Short: "Print the AWS CloudFormation template of a job.",
Long: `Print the CloudFormation template used to deploy a job to an environment.`,
Example: `
Print the CloudFormation template for the "report-generator" job parametrized for the "test" environment.
/code $ copilot job package -n report-generator -e test
Write the CloudFormation stack and configuration to a "infrastructure/" sub-directory instead of printing.
/startcodeblock
$ copilot job package -n report-generator -e test --output-dir ./infrastructure
$ ls ./infrastructure
report-generator-test.stack.yml report-generator-test.params.yml
/endcodeblock`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newPackageJobOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", jobFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.tag, imageTagFlag, "", imageTagFlagDescription)
cmd.Flags().StringVar(&vars.outputDir, stackOutputDirFlag, "", stackOutputDirFlagDescription)
cmd.Flags().BoolVar(&vars.uploadAssets, uploadAssetsFlag, false, uploadAssetsFlagDescription)
cmd.Flags().BoolVar(&vars.showDiff, diffFlag, false, diffFlagDescription)
cmd.MarkFlagsMutuallyExclusive(diffFlag, stackOutputDirFlag)
cmd.MarkFlagsMutuallyExclusive(diffFlag, uploadAssetsFlag)
return cmd
}
| 211 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestPackageJobOpts_Validate(t *testing.T) {
var (
mockWorkspace *mocks.MockwsJobDirReader
mockStore *mocks.Mockstore
)
testCases := map[string]struct {
inAppName string
inEnvName string
inJobName string
inShowDiff bool
inOutputDir string
inUploadAssets bool
setupMocks func()
wantedErrorS string
}{
"invalid workspace": {
setupMocks: func() {
mockWorkspace.EXPECT().ListJobs().Times(0)
mockStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
},
wantedErrorS: "could not find an application attached to this workspace, please run `app init` first",
},
"error while fetching job": {
inAppName: "phonetool",
inJobName: "resizer",
setupMocks: func() {
mockWorkspace.EXPECT().ListJobs().Return(nil, errors.New("some error"))
mockStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
},
wantedErrorS: "list jobs in the workspace: some error",
},
"error when job not in workspace": {
inAppName: "phonetool",
inJobName: "resizer",
setupMocks: func() {
mockWorkspace.EXPECT().ListJobs().Return([]string{"other-job"}, nil)
mockStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
},
wantedErrorS: "job 'resizer' does not exist in the workspace",
},
"error while fetching environment": {
inAppName: "phonetool",
inEnvName: "test",
setupMocks: func() {
mockWorkspace.EXPECT().ListJobs().Times(0)
mockStore.EXPECT().GetEnvironment("phonetool", "test").Return(nil, &config.ErrNoSuchEnvironment{
ApplicationName: "phonetool",
EnvironmentName: "test",
})
},
wantedErrorS: (&config.ErrNoSuchEnvironment{
ApplicationName: "phonetool",
EnvironmentName: "test",
}).Error(),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockWorkspace = mocks.NewMockwsJobDirReader(ctrl)
mockStore = mocks.NewMockstore(ctrl)
tc.setupMocks()
opts := &packageJobOpts{
packageJobVars: packageJobVars{
name: tc.inJobName,
envName: tc.inEnvName,
appName: tc.inAppName,
showDiff: tc.inShowDiff,
outputDir: tc.inOutputDir,
uploadAssets: tc.inUploadAssets,
},
ws: mockWorkspace,
store: mockStore,
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedErrorS != "" {
require.EqualError(t, err, tc.wantedErrorS, "error %v does not match '%s'", err, tc.wantedErrorS)
} else {
require.NoError(t, err)
}
})
}
}
func TestPackageJobOpts_Ask(t *testing.T) {
const testAppName = "phonetool"
testCases := map[string]struct {
inJobName string
inEnvName string
expectSelector func(m *mocks.MockwsSelector)
expectPrompt func(m *mocks.Mockprompter)
wantedJobName string
wantedEnvName string
wantedErrorS string
}{
"prompt for all options": {
expectSelector: func(m *mocks.MockwsSelector) {
m.EXPECT().Job(jobPackageJobNamePrompt, "").Return("resizer", nil)
m.EXPECT().Environment(jobPackageEnvNamePrompt, "", testAppName).Return("test", nil)
},
expectPrompt: func(m *mocks.Mockprompter) {},
wantedJobName: "resizer",
wantedEnvName: "test",
},
"prompt only for the job name": {
inEnvName: "test",
expectSelector: func(m *mocks.MockwsSelector) {
m.EXPECT().Job(jobPackageJobNamePrompt, "").Return("resizer", nil)
m.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
expectPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedJobName: "resizer",
wantedEnvName: "test",
},
"prompt only for the env name": {
inJobName: "resizer",
expectSelector: func(m *mocks.MockwsSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any()).Times(0)
m.EXPECT().Environment(jobPackageEnvNamePrompt, "", testAppName).Return("test", nil)
},
expectPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedJobName: "resizer",
wantedEnvName: "test",
},
"don't prompt": {
inJobName: "resizer",
inEnvName: "test",
expectSelector: func(m *mocks.MockwsSelector) {
m.EXPECT().Job(gomock.Any(), gomock.Any()).Times(0)
m.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
expectPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedJobName: "resizer",
wantedEnvName: "test",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSelector := mocks.NewMockwsSelector(ctrl)
mockPrompt := mocks.NewMockprompter(ctrl)
mockRunner := mocks.NewMockexecRunner(ctrl)
tc.expectSelector(mockSelector)
tc.expectPrompt(mockPrompt)
opts := &packageJobOpts{
packageJobVars: packageJobVars{
name: tc.inJobName,
envName: tc.inEnvName,
appName: testAppName,
},
sel: mockSelector,
prompt: mockPrompt,
runner: mockRunner,
}
// WHEN
err := opts.Ask()
// THEN
require.Equal(t, tc.wantedJobName, opts.name)
require.Equal(t, tc.wantedEnvName, opts.envName)
if tc.wantedErrorS != "" {
require.EqualError(t, err, tc.wantedErrorS)
} else {
require.NoError(t, err)
}
})
}
}
func TestPackageJobOpts_Execute(t *testing.T) {
testCases := map[string]struct {
inVars packageJobVars
mockDependencies func(*gomock.Controller, *packageJobOpts)
wantedErr error
}{
"writes job template without addons": {
inVars: packageJobVars{
appName: "ecs-kudos",
name: "resizer",
envName: "test",
tag: "1234",
},
mockDependencies: func(ctrl *gomock.Controller, opts *packageJobOpts) {
opts.newPackageCmd = func(opts *packageJobOpts) {
mockCmd := mocks.NewMockactionCommand(ctrl)
mockCmd.EXPECT().Execute().Return(nil)
opts.packageCmd = mockCmd
}
},
wantedErr: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
opts := &packageJobOpts{
packageJobVars: tc.inVars,
packageCmd: mocks.NewMockactionCommand(ctrl),
}
tc.mockDependencies(ctrl, opts)
// WHEN
err := opts.Execute()
// THEN
require.Equal(t, tc.wantedErr, err)
})
}
}
func TestPackageJobOpts_RecommendActions(t *testing.T) {
testCases := map[string]struct {
mockDependencies func(*gomock.Controller, *packageJobOpts)
wantedErr error
}{
"reuse svc package RecommandActions": {
mockDependencies: func(ctrl *gomock.Controller, opts *packageJobOpts) {
mockCmd := mocks.NewMockactionCommand(ctrl)
mockCmd.EXPECT().RecommendActions().Return(nil)
opts.packageCmd = mockCmd
},
wantedErr: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
opts := &packageJobOpts{
packageCmd: mocks.NewMockactionCommand(ctrl),
}
tc.mockDependencies(ctrl, opts)
// WHEN
err := opts.RecommendActions()
// THEN
require.Equal(t, tc.wantedErr, err)
})
}
}
| 309 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/aws/stepfunctions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/runner/jobrunner"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
type jobRunVars struct {
appName string
envName string
jobName string
}
type jobRunOpts struct {
jobRunVars
configStore store
sel configSelector
ws wsEnvironmentsLister
// cached variables.
targetEnv *config.Environment
sessProvider *sessions.Provider
newRunner func() (runner, error)
newEnvCompatibilityChecker func() (versionCompatibilityChecker, error)
}
func newJobRunOpts(vars jobRunVars) (*jobRunOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("job deploy"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, err
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
prompter := prompt.New()
opts := &jobRunOpts{
jobRunVars: vars,
configStore: configStore,
sel: selector.NewConfigSelector(prompter, configStore),
ws: ws,
sessProvider: sessProvider,
}
opts.newRunner = func() (runner, error) {
sess, err := opts.envSession()
if err != nil {
return nil, err
}
return jobrunner.New(&jobrunner.Config{
App: opts.appName,
Env: opts.envName,
Job: opts.jobName,
CFN: cloudformation.New(sess),
StateMachine: stepfunctions.New(sess),
}), nil
}
opts.newEnvCompatibilityChecker = func() (versionCompatibilityChecker, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: opts.appName,
Env: opts.envName,
ConfigStore: opts.configStore,
})
if err != nil {
return nil, fmt.Errorf("new environment compatibility checker: %v", err)
}
return envDescriber, nil
}
return opts, nil
}
// Validate is a no-op for this command.
// it's a no-op because all 3 flags are required, and `Validate` only validate optional flags.
func (o *jobRunOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *jobRunOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
if err := o.askJobName(); err != nil {
return err
}
if err := o.askEnvName(); err != nil {
return err
}
return nil
}
// Execute runs the "job run" command.
func (o *jobRunOpts) Execute() error {
if err := o.validateEnvCompatible(); err != nil {
return err
}
runner, err := o.newRunner()
if err != nil {
return err
}
if err := runner.Run(); err != nil {
return fmt.Errorf("execute job %q: %w", o.jobName, err)
}
log.Successf("Invoked job %q successfully\n", o.jobName)
return nil
}
func (o *jobRunOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.configStore.GetApplication(o.appName)
return err
}
app, err := o.sel.Application(jobAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *jobRunOpts) askJobName() error {
if o.jobName != "" {
if _, err := o.configStore.GetJob(o.appName, o.jobName); err != nil {
return err
}
return nil
}
name, err := o.sel.Job("Which job would you like to invoke?", "", o.appName)
if err != nil {
return fmt.Errorf("select job: %w", err)
}
o.jobName = name
return nil
}
func (o *jobRunOpts) askEnvName() error {
if o.envName != "" {
if _, err := o.getTargetEnv(); err != nil {
return err
}
return nil
}
name, err := o.sel.Environment("Which environment?", "", o.appName)
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
o.envName = name
return nil
}
func (o *jobRunOpts) getTargetEnv() (*config.Environment, error) {
if o.targetEnv != nil {
return o.targetEnv, nil
}
env, err := o.configStore.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, err
}
o.targetEnv = env
return o.targetEnv, nil
}
func (o *jobRunOpts) envSession() (*session.Session, error) {
env, err := o.getTargetEnv()
if err != nil {
return nil, err
}
return o.sessProvider.FromRole(env.ManagerRoleARN, env.Region)
}
func (o *jobRunOpts) validateEnvCompatible() error {
envStack, err := o.newEnvCompatibilityChecker()
if err != nil {
return err
}
return validateMinEnvVersion(o.ws, envStack, o.appName, o.envName, "v1.12.0", "job run")
}
func buildJobRunCmd() *cobra.Command {
vars := jobRunVars{}
cmd := &cobra.Command{
Use: "run",
Short: "Invoke a job in an environment.",
Long: "Invoke a job in an environment.",
Example: `
Run a job named "report-gen" in an application named "report" within a "test" environment
/code $ copilot job run -a report -n report-gen -e test`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newJobRunOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.jobName, nameFlag, nameFlagShort, "", jobFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
return cmd
}
| 233 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type jobRunMock struct {
configStore *mocks.Mockstore
sel *mocks.MockconfigSelector
}
func TestJobRun_Ask(t *testing.T) {
const (
inputApp = "my-app"
inputEnv = "my-env"
inputJob = "my-job"
)
testCases := map[string]struct {
inputApp string
inputJob string
inputEnvName string
setupMocks func(mocks jobRunMock)
wantedApp string
wantedEnv string
wantedJob string
wantedError error
}{
"validate app env and job with all flags passed in": {
inputApp: inputApp,
inputJob: inputJob,
inputEnvName: inputEnv,
setupMocks: func(m jobRunMock) {
gomock.InOrder(
m.configStore.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil),
m.configStore.EXPECT().GetJob("my-app", "my-job").Return(&config.Workload{}, nil),
m.configStore.EXPECT().GetEnvironment("my-app", "my-env").Return(&config.Environment{Name: "my-env"}, nil),
)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedJob: inputJob,
},
"prompt for app name": {
inputJob: inputJob,
inputEnvName: inputEnv,
setupMocks: func(m jobRunMock) {
gomock.InOrder(
m.sel.EXPECT().Application(jobAppNamePrompt, wkldAppNameHelpPrompt).Return("my-app", nil),
m.configStore.EXPECT().GetApplication(gomock.Any()).Times(0),
m.configStore.EXPECT().GetJob(gomock.Any(), gomock.Any()).AnyTimes(),
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes(),
m.sel.EXPECT().Job(gomock.Any(), gomock.Any(), gomock.Any()).Return("my-job", nil).AnyTimes(),
m.sel.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any()).Return("my-env", nil).AnyTimes(),
)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedJob: inputJob,
},
"returns error if fail to select app": {
setupMocks: func(m jobRunMock) {
gomock.InOrder(
m.sel.EXPECT().Application(jobAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error")),
)
},
wantedError: fmt.Errorf("select application: some error"),
},
"prompt for job and env": {
inputApp: inputApp,
setupMocks: func(m jobRunMock) {
gomock.InOrder(
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes(),
m.configStore.EXPECT().GetJob(gomock.Any(), gomock.Any()).Times(0),
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0),
m.sel.EXPECT().Job("Which job would you like to invoke?", "", "my-app").Return("my-job", nil),
m.sel.EXPECT().Environment("Which environment?", "", "my-app").Return("my-env", nil),
)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedJob: inputJob,
},
"return error if fail to select environment": {
inputApp: inputApp,
inputJob: inputJob,
setupMocks: func(m jobRunMock) {
gomock.InOrder(
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes(),
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0),
m.configStore.EXPECT().GetJob(gomock.Any(), gomock.Any()).AnyTimes(),
m.sel.EXPECT().Environment("Which environment?", "", "my-app").Return("", errors.New("some error")),
)
},
wantedError: fmt.Errorf("select environment: some error"),
},
"return error if fail to select job": {
inputApp: inputApp,
inputEnvName: inputEnv,
setupMocks: func(m jobRunMock) {
gomock.InOrder(
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes(),
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes(),
m.configStore.EXPECT().GetJob(gomock.Any(), gomock.Any()).Times(0),
m.sel.EXPECT().Job("Which job would you like to invoke?", "", "my-app").Return("", errors.New("some error")),
)
},
wantedError: fmt.Errorf("select job: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
mockSel := mocks.NewMockconfigSelector(ctrl)
tc.setupMocks(jobRunMock{
configStore: mockStore,
sel: mockSel,
})
jobRun := &jobRunOpts{
jobRunVars: jobRunVars{
envName: tc.inputEnvName,
appName: tc.inputApp,
jobName: tc.inputJob,
},
configStore: mockStore,
sel: mockSel,
}
err := jobRun.Ask()
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, jobRun.appName, "expected app name to match")
require.Equal(t, tc.wantedJob, jobRun.jobName, "expected job name to match")
require.Equal(t, tc.wantedEnv, jobRun.envName, "expected environment name to match")
}
})
}
}
func TestJobRun_Execute(t *testing.T) {
testCases := map[string]struct {
appName string
envName string
jobName string
mockjobRunner func(ctrl *gomock.Controller) runner
mockEnvChecker func(ctrl *gomock.Controller) versionCompatibilityChecker
wantedError error
}{
"successfully invoke job": {
jobName: "mockJob",
mockjobRunner: func(ctrl *gomock.Controller) runner {
m := mocks.NewMockrunner(ctrl)
m.EXPECT().Run().Return(nil)
return m
},
mockEnvChecker: func(ctrl *gomock.Controller) versionCompatibilityChecker {
m := mocks.NewMockversionCompatibilityChecker(ctrl)
m.EXPECT().Version().Return("v1.12.1", nil)
return m
},
},
"should return a wrapped error when state machine cannot be run": {
jobName: "mockJob",
mockjobRunner: func(ctrl *gomock.Controller) runner {
m := mocks.NewMockrunner(ctrl)
m.EXPECT().Run().Return(errors.New("some error"))
return m
},
mockEnvChecker: func(ctrl *gomock.Controller) versionCompatibilityChecker {
m := mocks.NewMockversionCompatibilityChecker(ctrl)
m.EXPECT().Version().Return("v1.12.0", nil)
return m
},
wantedError: fmt.Errorf(`execute job "mockJob": some error`),
},
"should return a wrapped error when environment version cannot be retrieved": {
appName: "finance",
envName: "test",
jobName: "report",
mockjobRunner: func(ctrl *gomock.Controller) runner {
return nil
},
mockEnvChecker: func(ctrl *gomock.Controller) versionCompatibilityChecker {
m := mocks.NewMockversionCompatibilityChecker(ctrl)
m.EXPECT().Version().Return("", errors.New("some error"))
return m
},
wantedError: errors.New(`retrieve version of environment stack "test" in application "finance": some error`),
},
"should return an error when environment template version is below v1.12.0": {
appName: "finance",
envName: "test",
jobName: "report",
mockjobRunner: func(ctrl *gomock.Controller) runner {
return nil
},
mockEnvChecker: func(ctrl *gomock.Controller) versionCompatibilityChecker {
m := mocks.NewMockversionCompatibilityChecker(ctrl)
m.EXPECT().Version().Return("v1.11.0", nil)
return m
},
wantedError: errors.New(`environment "test" is on version "v1.11.0" which does not support the "job run" feature`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
jobRunOpts := &jobRunOpts{
jobRunVars: jobRunVars{
appName: tc.appName,
envName: tc.envName,
jobName: tc.jobName,
},
newRunner: func() (runner, error) {
return tc.mockjobRunner(ctrl), nil
},
newEnvCompatibilityChecker: func() (versionCompatibilityChecker, error) {
return tc.mockEnvChecker(ctrl), nil
},
}
err := jobRunOpts.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 257 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"io"
"path/filepath"
"strconv"
"strings"
"github.com/aws/copilot-cli/internal/pkg/override"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/spf13/afero"
)
const (
// IaC options for overrides.
cdkIaCTool = "cdk"
yamlPatch = "yamlpatch"
// IaC toolkit configuration.
typescriptCDKLang = "typescript"
)
var validIaCTools = []string{
cdkIaCTool,
yamlPatch,
}
var validCDKLangs = []string{
typescriptCDKLang,
}
type stringWriteCloser interface {
fmt.Stringer
io.WriteCloser
}
type closableStringBuilder struct {
*strings.Builder
}
// Close implements the io.Closer interface for a strings.Builder and is a no-op.
func (sb *closableStringBuilder) Close() error {
return nil
}
// overrideVars represent common flags for all "[noun] override" commands.
type overrideVars struct {
name string
appName string
iacTool string
// CDK override engine flags.
cdkLang string
// We prompt for resources if the user does not opt-in to skipping.
skipResources bool
resources []template.CFNResource
}
// overrideOpts represents the command for all "[noun] override" commands.
type overrideOpts struct {
overrideVars
// Interfaces to interact with dependencies.
fs afero.Fs
cfgStore store
prompt prompter
cfnPrompt cfnSelector
spinner progress
dir func() string
packageCmd func(w stringWriteCloser) (executor, error)
}
// Validate returns an error for any invalid optional flags.
func (o *overrideOpts) Validate() error {
if err := o.validateAppName(); err != nil {
return err
}
return o.validateCDKLang()
}
// Ask prompts for and validates any required flags.
func (o *overrideOpts) Ask() error {
if err := o.validateOrAskIaCTool(); err != nil {
return err
}
return o.askResourcesToOverride()
}
// Execute writes IaC override files to the local workspace.
// This method assumes that the IaC tool chosen by the user is valid.
func (o *overrideOpts) Execute() error {
dir := o.dir()
switch o.iacTool {
case cdkIaCTool:
if err := override.ScaffoldWithCDK(o.fs, dir, o.resources); err != nil {
return fmt.Errorf("scaffold CDK application under %q: %v", dir, err)
}
log.Successf("Created a new CDK application at %q to override resources\n", displayPath(dir))
case yamlPatch:
if err := override.ScaffoldWithPatch(o.fs, dir); err != nil {
return fmt.Errorf("scaffold CFN YAML patches under %q: %v", dir, err)
}
log.Successf("Created a YAML patch file under %q to override resources\n", displayPath(dir))
}
return nil
}
// RecommendActions prints optional follow-up actions.
func (o *overrideOpts) RecommendActions() error {
readmePath := filepath.Join(o.dir(), "README.md")
logRecommendedActions([]string{
fmt.Sprintf("Please follow the instructions in %q", displayPath(readmePath)),
})
return nil
}
func (o *overrideOpts) validateAppName() error {
if o.appName == "" {
return errNoAppInWorkspace
}
_, err := o.cfgStore.GetApplication(o.appName)
if err != nil {
return fmt.Errorf("get application %q configuration: %v", o.appName, err)
}
return nil
}
func (o *overrideOpts) validateCDKLang() error {
for _, valid := range validCDKLangs {
if o.cdkLang == valid {
return nil
}
}
return fmt.Errorf("%q is not a valid CDK language: must be one of: %s",
o.cdkLang,
strings.Join(applyAll(validCDKLangs, strconv.Quote), ", "))
}
func (o *overrideOpts) validateOrAskIaCTool() error {
if o.iacTool == "" {
return o.askIaCTool()
}
return o.validateIaCTool()
}
func (o *overrideOpts) askIaCTool() error {
msg := fmt.Sprintf("Which Infrastructure as Code tool would you like to use to override %q?", o.name)
help := `The AWS Cloud Development Kit (CDK) lets you override templates using
the expressive power of programming languages.
This option is recommended for users that need to override several resources.
To learn more about the CDK: https://aws.github.io/copilot-cli/docs/developing/overrides/cdk/
CloudFormation YAML patches is recommended for users that need to override
a handful resources or do not want to depend on any other tool.
To learn more about CFN yaml patches: https://aws.github.io/copilot-cli/docs/developing/overrides/yamlpatch/`
tool, err := o.prompt.SelectOne(msg, help, validIaCTools, prompt.WithFinalMessage("IaC tool:"))
if err != nil {
return fmt.Errorf("select IaC tool: %v", err)
}
o.iacTool = tool
return nil
}
func (o *overrideOpts) validateIaCTool() error {
for _, valid := range validIaCTools {
if o.iacTool == valid {
return nil
}
}
return fmt.Errorf("%q is not a valid IaC tool: must be one of: %s",
o.iacTool,
strings.Join(applyAll(validIaCTools, strconv.Quote), ", "))
}
func (o *overrideOpts) askResourcesToOverride() error {
if o.skipResources || o.iacTool == yamlPatch {
return nil
}
o.spinner.Start("Generating CloudFormation template for resource selection")
buf := &closableStringBuilder{
Builder: new(strings.Builder),
}
pkgCmd, err := o.packageCmd(buf)
if err != nil {
o.spinner.Stop("")
return err
}
if err := pkgCmd.Execute(); err != nil {
o.spinner.Stop("")
return fmt.Errorf("generate CloudFormation template for %q: %v", o.name, err)
}
o.spinner.Stop("")
msg := fmt.Sprintf("Which resources in %q would you like to override?", o.name)
resources, err := o.cfnPrompt.Resources(msg, "Resources:", "", buf.String())
if err != nil {
return err
}
o.resources = resources
return nil
}
| 209 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
)
// BuildPipelineCmd is the top level command for pipelines
func BuildPipelineCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "pipeline",
Short: `Commands for pipelines.
Continuous delivery pipelines to release services.`,
Long: `Commands for pipelines.
Continuous delivery pipelines to release services.`,
}
cmd.AddCommand(buildPipelineInitCmd())
cmd.AddCommand(buildPipelineDeployCmd())
cmd.AddCommand(buildPipelineDeleteCmd())
cmd.AddCommand(buildPipelineShowCmd())
cmd.AddCommand(buildPipelineStatusCmd())
cmd.AddCommand(buildPipelineListCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Release,
}
return cmd
}
| 36 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"strings"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/codepipeline"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"github.com/aws/copilot-cli/internal/pkg/aws/secretsmanager"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
const (
pipelineDeleteAppNamePrompt = "Which application's pipeline would you like to delete?"
pipelineDeleteAppNameHelpPrompt = "An application is a collection of related services."
pipelineDeleteConfirmPrompt = "Are you sure you want to delete pipeline %s from application %s?"
pipelineDeleteConfirmHelp = "This will delete the deployment pipeline for the services in the workspace."
pipelineSecretDeleteConfirmPrompt = "Are you sure you want to delete the source secret %s associated with pipeline %s?"
pipelineDeleteSecretConfirmHelp = "This will delete the token associated with the source of your pipeline."
fmtPipelineDeletePrompt = "Which deployed pipeline of application %s would you like to delete?"
fmtDeletePipelineStart = "Deleting pipeline %s from application %s."
fmtDeletePipelineFailed = "Failed to delete pipeline %s from application %s: %v.\n"
fmtDeletePipelineComplete = "Deleted pipeline %s from application %s.\n"
)
var (
errPipelineDeleteCancelled = errors.New("pipeline delete cancelled - no changes made")
)
type deletePipelineVars struct {
appName string
name string
skipConfirmation bool
shouldDeleteSecret bool
}
type deletePipelineOpts struct {
deletePipelineVars
ghAccessTokenSecretName string
// Interfaces to dependencies.
pipelineDeployer pipelineDeployer
codepipeline pipelineGetter
prog progress
sel codePipelineSelector
prompt prompter
secretsmanager secretsManager
ws wsPipelineGetter
deployedPipelineLister deployedPipelineLister
store store
// Cached variables.
targetPipeline *deploy.Pipeline
}
func newDeletePipelineOpts(vars deletePipelineVars) (*deletePipelineOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
defaultSess, err := sessions.ImmutableProvider(sessions.UserAgentExtras("pipeline delete")).Default()
if err != nil {
return nil, fmt.Errorf("default session: %w", err)
}
ssmStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompter := prompt.New()
codepipeline := codepipeline.New(defaultSess)
pipelineLister := deploy.NewPipelineStore(rg.New(defaultSess))
opts := &deletePipelineOpts{
deletePipelineVars: vars,
codepipeline: codepipeline,
prog: termprogress.NewSpinner(log.DiagnosticWriter),
prompt: prompter,
secretsmanager: secretsmanager.New(defaultSess),
pipelineDeployer: cloudformation.New(defaultSess, cloudformation.WithProgressTracker(os.Stderr)),
deployedPipelineLister: pipelineLister,
ws: ws,
store: ssmStore,
sel: selector.NewAppPipelineSelector(prompter, ssmStore, pipelineLister),
}
return opts, nil
}
// Validate returns an error if the flag values for optional fields are invalid.
func (o *deletePipelineOpts) Validate() error {
return nil
}
// Ask prompts for and validates required fields.
func (o *deletePipelineOpts) Ask() error {
if o.appName != "" {
if _, err := o.store.GetApplication(o.appName); err != nil {
return err
}
} else {
if err := o.askAppName(); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.getTargetPipeline(); err != nil {
return fmt.Errorf("validate pipeline name %s: %w", o.name, err)
}
} else {
pipeline, err := askDeployedPipelineName(o.sel, fmt.Sprintf(fmtPipelineDeletePrompt, color.HighlightUserInput(o.appName)), o.appName)
if err != nil {
return err
}
o.name = pipeline.Name
o.targetPipeline = &pipeline
}
if o.skipConfirmation {
return nil
}
deleteConfirmed, err := o.prompt.Confirm(
fmt.Sprintf(pipelineDeleteConfirmPrompt, o.name, o.appName),
pipelineDeleteConfirmHelp,
prompt.WithConfirmFinalMessage())
if err != nil {
return fmt.Errorf("pipeline delete confirmation prompt: %w", err)
}
if !deleteConfirmed {
return errPipelineDeleteCancelled
}
return nil
}
// Execute deletes the secret and pipeline stack.
func (o *deletePipelineOpts) Execute() error {
if err := o.getSecret(); err != nil {
return err
}
if err := o.deleteSecret(); err != nil {
return err
}
if err := o.deleteStack(); err != nil {
return err
}
return nil
}
func (o *deletePipelineOpts) getTargetPipeline() (deploy.Pipeline, error) {
if o.targetPipeline != nil {
return *o.targetPipeline, nil
}
pipeline, err := getDeployedPipelineInfo(o.deployedPipelineLister, o.appName, o.name)
if err != nil {
return deploy.Pipeline{}, err
}
o.targetPipeline = &pipeline
return pipeline, nil
}
func askDeployedPipelineName(sel codePipelineSelector, msg, appName string) (deploy.Pipeline, error) {
pipeline, err := sel.DeployedPipeline(msg, "", appName)
if err != nil {
return deploy.Pipeline{}, fmt.Errorf("select deployed pipelines: %w", err)
}
return pipeline, nil
}
func getDeployedPipelineInfo(lister deployedPipelineLister, app, name string) (deploy.Pipeline, error) {
pipelines, err := lister.ListDeployedPipelines(app)
if err != nil {
return deploy.Pipeline{}, fmt.Errorf("list deployed pipelines: %w", err)
}
for _, pipeline := range pipelines {
if pipeline.Name == name {
return pipeline, nil
}
}
return deploy.Pipeline{}, fmt.Errorf("cannot find pipeline named %s", name)
}
func (o *deletePipelineOpts) askAppName() error {
app, err := o.sel.Application(pipelineDeleteAppNamePrompt, pipelineDeleteAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *deletePipelineOpts) getSecret() error {
// Look for default secret name for GHv1 access token based on default pipeline name.
o.ghAccessTokenSecretName = o.pipelineSecretName()
output, err := o.secretsmanager.DescribeSecret(o.ghAccessTokenSecretName)
if err != nil {
var notFoundErr *secretsmanager.ErrSecretNotFound
if errors.As(err, ¬FoundErr) {
o.ghAccessTokenSecretName = ""
return nil
}
return fmt.Errorf("describe secret %s: %w", o.ghAccessTokenSecretName, err)
}
for _, tag := range output.Tags {
if aws.StringValue(tag.Key) == deploy.AppTagKey && aws.StringValue(tag.Value) == output.CreatedDate.UTC().Format(time.UnixDate) {
return nil
}
}
// The secret was found but tags didn't match.
o.ghAccessTokenSecretName = ""
return nil
}
// With GHv1 sources, we stored access tokens in SecretsManager. Pipelines generated
// prior to Copilot v1.4 have secrets named 'github-token-[appName]-[repoName]'.
// Pipelines prior to 1745fee were given default names of `pipeline-[appName]-[repoName]`.
// Users may have changed pipeline names, so this is our best-guess approach to
// deleting legacy pipeline secrets.
func (o *deletePipelineOpts) pipelineSecretName() string {
appAndRepo := strings.TrimPrefix(o.name, "pipeline-")
return fmt.Sprintf("github-token-%s", appAndRepo)
}
func (o *deletePipelineOpts) deleteSecret() error {
if o.ghAccessTokenSecretName == "" {
return nil
}
// Only pipelines created with GitHubV1 have personal access tokens saved as secrets.
if !o.shouldDeleteSecret {
confirmDeletion, err := o.prompt.Confirm(
fmt.Sprintf(pipelineSecretDeleteConfirmPrompt, o.ghAccessTokenSecretName, o.name),
pipelineDeleteSecretConfirmHelp,
)
if err != nil {
return fmt.Errorf("pipeline delete secret confirmation prompt: %w", err)
}
if !confirmDeletion {
log.Infof("Skipping deletion of secret %s.\n", o.ghAccessTokenSecretName)
return nil
}
}
if err := o.secretsmanager.DeleteSecret(o.ghAccessTokenSecretName); err != nil {
return err
}
log.Successf("Deleted secret %s.\n", o.ghAccessTokenSecretName)
return nil
}
func (o *deletePipelineOpts) deleteStack() error {
pipeline, err := o.getTargetPipeline()
if err != nil {
return err
}
o.prog.Start(fmt.Sprintf(fmtDeletePipelineStart, pipeline.Name, o.appName))
if err := o.pipelineDeployer.DeletePipeline(pipeline); err != nil {
o.prog.Stop(log.Serrorf(fmtDeletePipelineFailed, pipeline.Name, o.appName, err))
return err
}
o.prog.Stop(log.Ssuccessf(fmtDeletePipelineComplete, pipeline.Name, o.appName))
return nil
}
// RecommendActions is a no-op for this command.
func (o *deletePipelineOpts) RecommendActions() error {
return nil
}
// buildPipelineDeleteCmd build the command for deleting an existing pipeline.
func buildPipelineDeleteCmd() *cobra.Command {
vars := deletePipelineVars{}
cmd := &cobra.Command{
Use: "delete",
Short: "Deletes the pipeline associated with your workspace.",
Example: `
Delete the pipeline associated with your workspace.
/code $ copilot pipeline delete
`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeletePipelineOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", pipelineFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
cmd.Flags().BoolVar(&vars.shouldDeleteSecret, deleteSecretFlag, false, deleteSecretFlagDescription)
return cmd
}
| 321 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"time"
"github.com/aws/aws-sdk-go/aws"
sdkSecretsmanager "github.com/aws/aws-sdk-go/service/secretsmanager"
"github.com/aws/copilot-cli/internal/pkg/aws/secretsmanager"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type deletePipelineMocks struct {
prompt *mocks.Mockprompter
prog *mocks.Mockprogress
secretsmanager *mocks.MocksecretsManager
deployer *mocks.MockpipelineDeployer
ws *mocks.MockwsPipelineGetter
store *mocks.Mockstore
codepipeline *mocks.MockpipelineGetter
sel *mocks.MockcodePipelineSelector
deployedPipelineLister *mocks.MockdeployedPipelineLister
}
func TestDeletePipelineOpts_Ask(t *testing.T) {
const (
testAppName = "badgoose"
testPipelineName = "pipeline-badgoose-honkpipes"
)
testCases := map[string]struct {
skipConfirmation bool
inAppName string
inPipelineName string
callMocks func(m deletePipelineMocks)
wantedAppName string
wantedPipelineName string
wantedError error
}{
"prompts for app name if empty": {
inPipelineName: testPipelineName,
skipConfirmation: true,
callMocks: func(m deletePipelineMocks) {
m.sel.EXPECT().Application(pipelineDeleteAppNamePrompt, pipelineDeleteAppNameHelpPrompt).Return(testAppName, nil)
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(testAppName).Return([]deploy.Pipeline{
{
Name: testPipelineName,
},
}, nil)
},
wantedAppName: testAppName,
wantedPipelineName: testPipelineName,
wantedError: nil,
},
"errors if passed-in app name invalid": {
skipConfirmation: true,
inAppName: "badAppName",
callMocks: func(m deletePipelineMocks) {
m.store.EXPECT().GetApplication("badAppName").Return(nil, errors.New("some error"))
},
wantedError: errors.New("some error"),
},
"errors if passed-in pipeline name is invalid": {
skipConfirmation: true,
inAppName: testAppName,
inPipelineName: "badPipelineName",
callMocks: func(m deletePipelineMocks) {
m.store.EXPECT().GetApplication(testAppName).Return(nil, nil)
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(testAppName).Return([]deploy.Pipeline{}, nil)
},
wantedAppName: testAppName,
wantedError: errors.New("validate pipeline name badPipelineName: cannot find pipeline named badPipelineName"),
},
"gets name of legacy pipeline": {
skipConfirmation: true,
inAppName: testAppName,
callMocks: func(m deletePipelineMocks) {
m.store.EXPECT().GetApplication(testAppName).Return(nil, nil)
m.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), testAppName).Return(deploy.Pipeline{
Name: testPipelineName,
IsLegacy: true,
}, nil)
},
wantedAppName: testAppName,
wantedPipelineName: testPipelineName,
wantedError: nil,
},
"error getting pipeline": {
skipConfirmation: true,
inAppName: testAppName,
callMocks: func(m deletePipelineMocks) {
m.store.EXPECT().GetApplication(testAppName).Return(nil, nil)
m.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), testAppName).Return(deploy.Pipeline{}, errors.New("some error"))
},
wantedAppName: testAppName,
wantedError: errors.New("select deployed pipelines: some error"),
},
"skip confirmation works": {
skipConfirmation: true,
inAppName: testAppName,
inPipelineName: testPipelineName,
callMocks: func(m deletePipelineMocks) {
m.store.EXPECT().GetApplication(testAppName).Return(nil, nil)
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(testAppName).Return([]deploy.Pipeline{
{
Name: testPipelineName,
},
}, nil)
},
wantedAppName: testAppName,
wantedPipelineName: testPipelineName,
wantedError: nil,
},
"delete confirmation works": {
skipConfirmation: false,
inAppName: testAppName,
inPipelineName: testPipelineName,
callMocks: func(m deletePipelineMocks) {
m.store.EXPECT().GetApplication(testAppName).Return(nil, nil)
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(testAppName).Return([]deploy.Pipeline{
{
Name: testPipelineName,
},
}, nil)
m.prompt.EXPECT().Confirm(
fmt.Sprintf(pipelineDeleteConfirmPrompt, testPipelineName, testAppName),
pipelineDeleteConfirmHelp,
gomock.Any(),
).Times(1).Return(true, nil)
},
wantedAppName: testAppName,
wantedPipelineName: testPipelineName,
wantedError: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockPipelineGetter := mocks.NewMockpipelineGetter(ctrl)
mockPrompt := mocks.NewMockprompter(ctrl)
mockWorkspace := mocks.NewMockwsPipelineGetter(ctrl)
mockStore := mocks.NewMockstore(ctrl)
mockSel := mocks.NewMockcodePipelineSelector(ctrl)
mocks := deletePipelineMocks{
codepipeline: mockPipelineGetter,
prompt: mockPrompt,
ws: mockWorkspace,
store: mockStore,
sel: mockSel,
deployedPipelineLister: mocks.NewMockdeployedPipelineLister(ctrl),
}
tc.callMocks(mocks)
opts := &deletePipelineOpts{
deletePipelineVars: deletePipelineVars{
skipConfirmation: tc.skipConfirmation,
appName: tc.inAppName,
name: tc.inPipelineName,
},
codepipeline: mockPipelineGetter,
prompt: mockPrompt,
ws: mockWorkspace,
store: mockStore,
sel: mockSel,
deployedPipelineLister: mocks.deployedPipelineLister,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedAppName, opts.appName, "expected app names to match")
require.Equal(t, tc.wantedPipelineName, opts.name, "expected pipeline names to match")
}
})
}
}
func TestDeletePipelineOpts_Execute(t *testing.T) {
const (
testAppName = "badgoose"
testPipelineName = "pipeline-badgoose-honkpipes"
testPipelineSecret = "github-token-badgoose-honkpipes"
)
targetPipeline := deploy.Pipeline{
Name: testPipelineName,
AppName: testAppName,
IsLegacy: true,
}
mockTime := time.Now()
mockResp := &secretsmanager.DescribeSecretOutput{
CreatedDate: aws.Time(mockTime),
Name: aws.String(testPipelineSecret),
Tags: []*sdkSecretsmanager.Tag{
{
Key: aws.String(deploy.AppTagKey),
Value: aws.String(mockTime.UTC().Format(time.UnixDate)),
},
},
}
mockBadResp := &secretsmanager.DescribeSecretOutput{
CreatedDate: aws.Time(mockTime),
Name: aws.String(testPipelineSecret),
Tags: []*sdkSecretsmanager.Tag{
{
Key: aws.String("someOtherKey"),
Value: aws.String(mockTime.UTC().Format(time.UnixDate)),
},
},
}
testError := errors.New("some error")
testCases := map[string]struct {
deleteSecret bool
inAppName string
inPipelineName string
setupMocks func(mocks deletePipelineMocks)
wantedError error
}{
"skips delete secret confirmation (and deletion attempt) if there is no secret": {
inAppName: testAppName,
inPipelineName: testPipelineName,
setupMocks: func(mocks deletePipelineMocks) {
gomock.InOrder(
mocks.secretsmanager.EXPECT().DescribeSecret(testPipelineSecret).Return(nil, &secretsmanager.ErrSecretNotFound{}),
mocks.secretsmanager.EXPECT().DeleteSecret(gomock.Any()).Times(0),
mocks.prog.EXPECT().Start(fmt.Sprintf(fmtDeletePipelineStart, testPipelineName, testAppName)),
mocks.deployer.EXPECT().DeletePipeline(targetPipeline).Return(nil),
mocks.prog.EXPECT().Stop(log.Ssuccessf(fmtDeletePipelineComplete, testPipelineName, testAppName)),
)
},
wantedError: nil,
},
"skips secret deletion if secret found but tags don't match": {
inAppName: testAppName,
inPipelineName: testPipelineName,
setupMocks: func(mocks deletePipelineMocks) {
gomock.InOrder(
mocks.secretsmanager.EXPECT().DescribeSecret(testPipelineSecret).Return(mockBadResp, nil),
mocks.prog.EXPECT().Start(fmt.Sprintf(fmtDeletePipelineStart, testPipelineName, testAppName)),
mocks.deployer.EXPECT().DeletePipeline(targetPipeline).Return(nil),
mocks.prog.EXPECT().Stop(log.Ssuccessf(fmtDeletePipelineComplete, testPipelineName, testAppName)),
)
},
wantedError: nil,
},
"wraps error from DescribeSecret": {
inAppName: testAppName,
inPipelineName: testPipelineName,
setupMocks: func(mocks deletePipelineMocks) {
gomock.InOrder(
mocks.secretsmanager.EXPECT().DescribeSecret(testPipelineSecret).Return(nil, errors.New("some error")),
)
},
wantedError: fmt.Errorf("describe secret %s: some error", testPipelineSecret),
},
"skips delete secret confirmation when flag is specified": {
deleteSecret: true,
inAppName: testAppName,
inPipelineName: testPipelineName,
setupMocks: func(mocks deletePipelineMocks) {
gomock.InOrder(
mocks.secretsmanager.EXPECT().DescribeSecret(testPipelineSecret).Return(mockResp, nil),
// no confirmation prompt for deleting secret
mocks.secretsmanager.EXPECT().DeleteSecret(testPipelineSecret).Return(nil),
mocks.prog.EXPECT().Start(fmt.Sprintf(fmtDeletePipelineStart, testPipelineName, testAppName)),
mocks.deployer.EXPECT().DeletePipeline(targetPipeline).Return(nil),
mocks.prog.EXPECT().Stop(log.Ssuccessf(fmtDeletePipelineComplete, testPipelineName, testAppName)),
)
},
wantedError: nil,
},
"asks for confirmation when delete secret flag is not specified": {
deleteSecret: false,
inAppName: testAppName,
inPipelineName: testPipelineName,
setupMocks: func(mocks deletePipelineMocks) {
gomock.InOrder(
mocks.secretsmanager.EXPECT().DescribeSecret(testPipelineSecret).Return(mockResp, nil),
mocks.prompt.EXPECT().Confirm(
fmt.Sprintf(pipelineSecretDeleteConfirmPrompt, testPipelineSecret, testPipelineName),
pipelineDeleteSecretConfirmHelp,
).Times(1).Return(true, nil),
mocks.secretsmanager.EXPECT().DeleteSecret(testPipelineSecret).Return(nil),
mocks.prog.EXPECT().Start(fmt.Sprintf(fmtDeletePipelineStart, testPipelineName, testAppName)),
mocks.deployer.EXPECT().DeletePipeline(targetPipeline).Return(nil),
mocks.prog.EXPECT().Stop(log.Ssuccessf(fmtDeletePipelineComplete, testPipelineName, testAppName)),
)
},
wantedError: nil,
},
"does not delete secret if user does not confirm": {
deleteSecret: false,
inAppName: testAppName,
inPipelineName: testPipelineName,
setupMocks: func(mocks deletePipelineMocks) {
gomock.InOrder(
mocks.secretsmanager.EXPECT().DescribeSecret(testPipelineSecret).Return(mockResp, nil),
mocks.prompt.EXPECT().Confirm(
fmt.Sprintf(pipelineSecretDeleteConfirmPrompt, testPipelineSecret, testPipelineName),
pipelineDeleteSecretConfirmHelp,
).Times(1).Return(false, nil),
// does not delete secret
mocks.secretsmanager.EXPECT().DeleteSecret(testPipelineSecret).Times(0),
mocks.prog.EXPECT().Start(fmt.Sprintf(fmtDeletePipelineStart, testPipelineName, testAppName)),
mocks.deployer.EXPECT().DeletePipeline(targetPipeline).Times(1).Return(nil),
mocks.prog.EXPECT().Stop(log.Ssuccessf(fmtDeletePipelineComplete, testPipelineName, testAppName)),
)
},
wantedError: nil,
},
"error when deleting stack": {
deleteSecret: true,
inAppName: testAppName,
inPipelineName: testPipelineName,
setupMocks: func(mocks deletePipelineMocks) {
gomock.InOrder(
mocks.secretsmanager.EXPECT().DescribeSecret(testPipelineSecret).Return(mockResp, nil),
mocks.secretsmanager.EXPECT().DeleteSecret(testPipelineSecret).Return(nil),
mocks.prog.EXPECT().Start(fmt.Sprintf(fmtDeletePipelineStart, testPipelineName, testAppName)),
mocks.deployer.EXPECT().DeletePipeline(targetPipeline).Times(1).Return(testError),
mocks.prog.EXPECT().Stop(log.Serrorf(fmtDeletePipelineFailed, testPipelineName, testAppName, testError)),
)
},
wantedError: testError,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSecretsManager := mocks.NewMocksecretsManager(ctrl)
mockProg := mocks.NewMockprogress(ctrl)
mockDeployer := mocks.NewMockpipelineDeployer(ctrl)
mockPrompter := mocks.NewMockprompter(ctrl)
mockWorkspace := mocks.NewMockwsPipelineGetter(ctrl)
mocks := deletePipelineMocks{
prompt: mockPrompter,
prog: mockProg,
secretsmanager: mockSecretsManager,
deployer: mockDeployer,
ws: mockWorkspace,
}
tc.setupMocks(mocks)
opts := &deletePipelineOpts{
deletePipelineVars: deletePipelineVars{
shouldDeleteSecret: tc.deleteSecret,
appName: tc.inAppName,
name: tc.inPipelineName,
},
secretsmanager: mockSecretsManager,
pipelineDeployer: mockDeployer,
ws: mockWorkspace,
prog: mockProg,
prompt: mockPrompter,
targetPipeline: &targetPipeline,
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
| 416 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
cs "github.com/aws/copilot-cli/internal/pkg/aws/codestar"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/cli/list"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
deploycfn "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest"
templatediff "github.com/aws/copilot-cli/internal/pkg/template/diff"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/aws/aws-sdk-go/aws"
"github.com/spf13/cobra"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
)
const (
pipelineSelectPrompt = "Select a pipeline from your workspace to deploy"
fmtPipelineDeployResourcesStart = "Adding pipeline resources to your application: %s"
fmtPipelineDeployResourcesFailed = "Failed to add pipeline resources to your application: %s\n"
fmtPipelineDeployResourcesComplete = "Successfully added pipeline resources to your application: %s\n"
fmtPipelineDeployStart = "Creating a new pipeline: %s"
fmtPipelineDeployFailed = "Failed to create a new pipeline: %s.\n"
fmtPipelineDeployComplete = "Successfully created a new pipeline: %s\n"
fmtPipelineDeployProposalStart = "Proposing infrastructure changes for the pipeline: %s"
fmtPipelineDeployProposalFailed = "Failed to accept changes for pipeline: %s.\n"
fmtPipelineDeployProposalComplete = "Successfully deployed pipeline: %s\n"
fmtPipelineDeployExistPrompt = "Are you sure you want to redeploy an existing pipeline: %s?"
)
const connectionsURL = "https://console.aws.amazon.com/codesuite/settings/connections"
type deployPipelineVars struct {
appName string
name string
skipConfirmation bool
showDiff bool
}
type deployPipelineOpts struct {
deployPipelineVars
pipelineDeployer pipelineDeployer
sel wsPipelineSelector
prog progress
prompt prompter
region string
store store
ws wsPipelineReader
codestar codestar
diffWriter io.Writer
newSvcListCmd func(io.Writer, string) cmd
newJobListCmd func(io.Writer, string) cmd
pipelineStackConfig func(in *deploy.CreatePipelineInput) pipelineStackConfig
configureDeployedPipelineLister func() deployedPipelineLister
// cached variables
wsAppName string
app *config.Application
pipeline *workspace.PipelineManifest
shouldPromptUpdateConnection bool
pipelineMft *manifest.Pipeline
svcBuffer *bytes.Buffer
jobBuffer *bytes.Buffer
}
func newDeployPipelineOpts(vars deployPipelineVars) (*deployPipelineOpts, error) {
defaultSession, err := sessions.ImmutableProvider(sessions.UserAgentExtras("pipeline deploy")).Default()
if err != nil {
return nil, fmt.Errorf("default session: %w", err)
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
wsAppName := tryReadingAppName()
if vars.appName == "" {
vars.appName = wsAppName
}
opts := &deployPipelineOpts{
ws: ws,
pipelineDeployer: deploycfn.New(defaultSession, deploycfn.WithProgressTracker(os.Stderr)),
region: aws.StringValue(defaultSession.Config.Region),
deployPipelineVars: vars,
store: store,
prog: termprogress.NewSpinner(log.DiagnosticWriter),
prompt: prompter,
diffWriter: os.Stdout,
sel: selector.NewWsPipelineSelector(prompter, ws),
codestar: cs.New(defaultSession),
pipelineStackConfig: func(in *deploy.CreatePipelineInput) pipelineStackConfig {
return stack.NewPipelineStackConfig(in)
},
newSvcListCmd: func(w io.Writer, appName string) cmd {
return &listSvcOpts{
listWkldVars: listWkldVars{
appName: appName,
},
sel: selector.NewAppEnvSelector(prompt.New(), store),
list: &list.SvcListWriter{
Ws: ws,
Store: store,
Out: w,
ShowLocalSvcs: true,
OutputJSON: true,
},
}
},
newJobListCmd: func(w io.Writer, appName string) cmd {
return &listJobOpts{
listWkldVars: listWkldVars{
appName: appName,
},
sel: selector.NewAppEnvSelector(prompt.New(), store),
list: &list.JobListWriter{
Ws: ws,
Store: store,
Out: w,
ShowLocalJobs: true,
OutputJSON: true,
},
}
},
wsAppName: wsAppName,
svcBuffer: &bytes.Buffer{},
jobBuffer: &bytes.Buffer{},
}
opts.configureDeployedPipelineLister = func() deployedPipelineLister {
// Initialize the client only after the appName is asked.
return deploy.NewPipelineStore(rg.New(defaultSession))
}
return opts, nil
}
// Validate returns an error if the optional flag values passed by the user are invalid.
func (o *deployPipelineOpts) Validate() error {
return nil
}
// Ask prompts the user for any unprovided required fields and validates them.
func (o *deployPipelineOpts) Ask() error {
if o.wsAppName == "" {
return errNoAppInWorkspace
}
// This command must be run within the app's workspace.
if o.appName != "" && o.appName != o.wsAppName {
return fmt.Errorf("cannot specify app %s because the workspace is already registered with app %s", o.appName, o.wsAppName)
}
appConfig, err := o.store.GetApplication(o.wsAppName)
if err != nil {
return fmt.Errorf("get application %s configuration: %w", o.wsAppName, err)
}
o.app = appConfig
if o.name != "" {
return o.validatePipelineName()
}
return o.askWsPipelineName()
}
// Execute creates a new pipeline or updates the current pipeline if it already exists.
func (o *deployPipelineOpts) Execute() error {
// bootstrap pipeline resources
o.prog.Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, color.HighlightUserInput(o.appName)))
err := o.pipelineDeployer.AddPipelineResourcesToApp(o.app, o.region)
if err != nil {
o.prog.Stop(log.Serrorf(fmtPipelineDeployResourcesFailed, color.HighlightUserInput(o.appName)))
return fmt.Errorf("add pipeline resources to application %s in %s: %w", o.appName, o.region, err)
}
o.prog.Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, color.HighlightUserInput(o.appName)))
// Read pipeline manifest.
pipeline, err := o.getPipelineMft()
if err != nil {
return err
}
// If the source has an existing connection, get the correlating ConnectionARN.
connection, ok := pipeline.Source.Properties["connection_name"]
if ok {
arn, err := o.codestar.GetConnectionARN((connection).(string))
if err != nil {
return fmt.Errorf("get connection ARN: %w", err)
}
pipeline.Source.Properties["connection_arn"] = arn
}
source, shouldPrompt, err := deploy.PipelineSourceFromManifest(pipeline.Source)
if err != nil {
return fmt.Errorf("read source from manifest: %w", err)
}
o.shouldPromptUpdateConnection = shouldPrompt
// Convert full manifest path to relative path from workspace root.
relPath, err := o.ws.Rel(o.pipeline.Path)
if err != nil {
return err
}
// Convert environments to deployment stages.
stages, err := o.convertStages(pipeline.Stages)
if err != nil {
return fmt.Errorf("convert environments to deployment stage: %w", err)
}
// Get cross-regional resources.
artifactBuckets, err := o.getArtifactBuckets()
if err != nil {
return fmt.Errorf("get cross-regional resources: %w", err)
}
isLegacy, err := o.isLegacy(pipeline.Name)
if err != nil {
return err
}
var build deploy.Build
if err = build.Init(pipeline.Build, filepath.Dir(relPath)); err != nil {
return err
}
deployPipelineInput := &deploy.CreatePipelineInput{
AppName: o.appName,
Name: pipeline.Name,
IsLegacy: isLegacy,
Source: source,
Build: &build,
Stages: stages,
ArtifactBuckets: artifactBuckets,
AdditionalTags: o.app.Tags,
PermissionsBoundary: o.app.PermissionsBoundary,
}
if o.showDiff {
tpl, err := o.pipelineStackConfig(deployPipelineInput).Template()
if err != nil {
return fmt.Errorf("generate the new template for diff: %w", err)
}
if err = diff(o, tpl, o.diffWriter); err != nil {
var errHasDiff *errHasDiff
if !errors.As(err, &errHasDiff) {
return err
}
}
if !o.skipConfirmation {
contd, err := o.prompt.Confirm(continueDeploymentPrompt, "")
if err != nil {
return fmt.Errorf("ask whether to continue with the deployment: %w", err)
}
if !contd {
return nil
}
}
}
if err := o.deployPipeline(deployPipelineInput); err != nil {
return err
}
return nil
}
// DeployDiff returns the stringified diff of the template against the deployed template of the pipeline.
func (o *deployPipelineOpts) DeployDiff(template string) (string, error) {
isLegacy, err := o.isLegacy(o.pipeline.Name)
if err != nil {
return "", err
}
tmpl, err := o.pipelineDeployer.Template(stack.NameForPipeline(o.app.Name, o.pipeline.Name, isLegacy))
if err != nil {
var errNotFound *awscloudformation.ErrStackNotFound
if !errors.As(err, &errNotFound) {
return "", fmt.Errorf("retrieve the deployed template for %q: %w", o.pipeline.Name, err)
}
tmpl = ""
}
diffTree, err := templatediff.From(tmpl).ParseWithCFNOverriders([]byte(template))
if err != nil {
return "", fmt.Errorf("parse the diff against the deployed pipeline stack %q: %w", o.pipeline.Name, err)
}
buf := strings.Builder{}
if err := diffTree.Write(&buf); err != nil {
return "", err
}
return buf.String(), nil
}
func (o *deployPipelineOpts) isLegacy(inputName string) (bool, error) {
lister := o.configureDeployedPipelineLister()
pipelines, err := lister.ListDeployedPipelines(o.appName)
if err != nil {
return false, fmt.Errorf("list deployed pipelines for app %s: %w", o.appName, err)
}
for _, pipeline := range pipelines {
if pipeline.ResourceName == inputName {
// NOTE: this is double insurance. A namespaced pipeline's `ResourceName` wouldn't be equal to
// `inputName` in the first place, because it would have been namespaced and have random string
// appended by CFN.
return pipeline.IsLegacy, nil
}
}
return false, nil
}
func (o *deployPipelineOpts) validatePipelineName() error {
pipelines, err := o.ws.ListPipelines()
if err != nil {
return fmt.Errorf("list pipelines: %w", err)
}
for _, pipeline := range pipelines {
if pipeline.Name == o.name {
o.pipeline = &pipeline
return nil
}
}
return fmt.Errorf(`pipeline %s not found in the workspace`, color.HighlightUserInput(o.name))
}
func (o *deployPipelineOpts) askWsPipelineName() error {
pipeline, err := o.sel.WsPipeline(pipelineSelectPrompt, "")
if err != nil {
return fmt.Errorf("select pipeline: %w", err)
}
o.pipeline = pipeline
return nil
}
func (o *deployPipelineOpts) getPipelineMft() (*manifest.Pipeline, error) {
if o.pipelineMft != nil {
return o.pipelineMft, nil
}
pipelineMft, err := o.ws.ReadPipelineManifest(o.pipeline.Path)
if err != nil {
return nil, fmt.Errorf("read pipeline manifest: %w", err)
}
if err := pipelineMft.Validate(); err != nil {
return nil, fmt.Errorf("validate pipeline manifest: %w", err)
}
o.pipelineMft = pipelineMft
return pipelineMft, nil
}
func (o *deployPipelineOpts) convertStages(manifestStages []manifest.PipelineStage) ([]deploy.PipelineStage, error) {
var stages []deploy.PipelineStage
workloads, err := o.getLocalWorkloads()
if err != nil {
return nil, err
}
for _, stage := range manifestStages {
env, err := o.store.GetEnvironment(o.appName, stage.Name)
if err != nil {
return nil, fmt.Errorf("get environment %s in application %s: %w", stage.Name, o.appName, err)
}
var stg deploy.PipelineStage
stg.Init(env, &stage, workloads)
stages = append(stages, stg)
}
return stages, nil
}
func (o deployPipelineOpts) getLocalWorkloads() ([]string, error) {
var localWklds []string
if err := o.newSvcListCmd(o.svcBuffer, o.appName).Execute(); err != nil {
return nil, fmt.Errorf("get local services: %w", err)
}
if err := o.newJobListCmd(o.jobBuffer, o.appName).Execute(); err != nil {
return nil, fmt.Errorf("get local jobs: %w", err)
}
svcOutput, jobOutput := &list.ServiceJSONOutput{}, &list.JobJSONOutput{}
if err := json.Unmarshal(o.svcBuffer.Bytes(), svcOutput); err != nil {
return nil, fmt.Errorf("unmarshal service list output; %w", err)
}
for _, svc := range svcOutput.Services {
localWklds = append(localWklds, svc.Name)
}
if err := json.Unmarshal(o.jobBuffer.Bytes(), jobOutput); err != nil {
return nil, fmt.Errorf("unmarshal job list output; %w", err)
}
for _, job := range jobOutput.Jobs {
localWklds = append(localWklds, job.Name)
}
return localWklds, nil
}
func (o *deployPipelineOpts) getArtifactBuckets() ([]deploy.ArtifactBucket, error) {
regionalResources, err := o.pipelineDeployer.GetRegionalAppResources(o.app)
if err != nil {
return nil, err
}
var buckets []deploy.ArtifactBucket
for _, resource := range regionalResources {
bucket := deploy.ArtifactBucket{
BucketName: resource.S3Bucket,
KeyArn: resource.KMSKeyARN,
}
buckets = append(buckets, bucket)
}
return buckets, nil
}
func (o *deployPipelineOpts) getBucketName() (string, error) {
resources, err := o.pipelineDeployer.GetAppResourcesByRegion(o.app, o.region)
if err != nil {
return "", fmt.Errorf("get app resources: %w", err)
}
return resources.S3Bucket, nil
}
func (o *deployPipelineOpts) shouldUpdate() (bool, error) {
if o.skipConfirmation {
return true, nil
}
shouldUpdate, err := o.prompt.Confirm(fmt.Sprintf(fmtPipelineDeployExistPrompt, o.pipeline.Name), "")
if err != nil {
return false, fmt.Errorf("prompt for pipeline deploy: %w", err)
}
return shouldUpdate, nil
}
func (o *deployPipelineOpts) deployPipeline(in *deploy.CreatePipelineInput) error {
exist, err := o.pipelineDeployer.PipelineExists(in)
if err != nil {
return fmt.Errorf("check if pipeline exists: %w", err)
}
// Find the bucket to push the pipeline template to.
bucketName, err := o.getBucketName()
if err != nil {
return fmt.Errorf("get bucket name: %w", err)
}
if !exist {
o.prog.Start(fmt.Sprintf(fmtPipelineDeployStart, color.HighlightUserInput(o.pipeline.Name)))
// If the source requires CodeStar Connections, the user is prompted to update the connection status.
if o.shouldPromptUpdateConnection {
source, ok := in.Source.(interface {
ConnectionName() (string, error)
})
if !ok {
return fmt.Errorf("source %v does not have a connection name", in.Source)
}
connectionName, err := source.ConnectionName()
if err != nil {
return fmt.Errorf("parse connection name: %w", err)
}
log.Infoln()
log.Infof("%s Go to %s to update the status of connection %s from PENDING to AVAILABLE.", color.Emphasize("ACTION REQUIRED!"), color.HighlightResource(connectionsURL), color.HighlightUserInput(connectionName))
log.Infoln()
}
if err := o.pipelineDeployer.CreatePipeline(in, bucketName); err != nil {
var alreadyExists *cloudformation.ErrStackAlreadyExists
if !errors.As(err, &alreadyExists) {
o.prog.Stop(log.Serrorf(fmtPipelineDeployFailed, color.HighlightUserInput(o.pipeline.Name)))
return fmt.Errorf("create pipeline: %w", err)
}
}
o.prog.Stop(log.Ssuccessf(fmtPipelineDeployComplete, color.HighlightUserInput(o.pipeline.Name)))
return nil
}
// If the stack already exists - we update it
if !o.showDiff {
shouldUpdate, err := o.shouldUpdate()
if err != nil {
return err
}
if !shouldUpdate {
return nil
}
}
o.prog.Start(fmt.Sprintf(fmtPipelineDeployProposalStart, color.HighlightUserInput(o.pipeline.Name)))
if err := o.pipelineDeployer.UpdatePipeline(in, bucketName); err != nil {
o.prog.Stop(log.Serrorf(fmtPipelineDeployProposalFailed, color.HighlightUserInput(o.pipeline.Name)))
return fmt.Errorf("update pipeline: %w", err)
}
o.prog.Stop(log.Ssuccessf(fmtPipelineDeployProposalComplete, color.HighlightUserInput(o.pipeline.Name)))
return nil
}
// RecommendedActions returns follow-up actions the user can take after successfully executing the command.
func (o *deployPipelineOpts) RecommendedActions() []string {
return []string{
fmt.Sprintf("Run %s to see the state of your pipeline.", color.HighlightCode("copilot pipeline status")),
fmt.Sprintf("Run %s for info about your pipeline.", color.HighlightCode("copilot pipeline show")),
}
}
// BuildPipelineDeployCmd build the command for deploying a new pipeline or updating an existing pipeline.
func buildPipelineDeployCmd() *cobra.Command {
vars := deployPipelineVars{}
cmd := &cobra.Command{
Use: "deploy",
Aliases: []string{"update"},
Short: "Deploys a pipeline for the services in your workspace.",
Long: `Deploys a pipeline for the services in your workspace, using the environments associated with the application.`,
Example: `
Deploys a pipeline for the services and jobs in your workspace.
/code $ copilot pipeline deploy
`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeployPipelineOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, "", appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", pipelineFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
cmd.Flags().BoolVar(&vars.showDiff, diffFlag, false, diffFlagDescription)
return cmd
}
| 560 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"io"
"strings"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type deployPipelineMocks struct {
store *mocks.Mockstore
prompt *mocks.Mockprompter
prog *mocks.Mockprogress
deployer *mocks.MockpipelineDeployer
pipelineStackConfig *mocks.MockpipelineStackConfig
mockDiffWriter *strings.Builder
ws *mocks.MockwsPipelineReader
actionCmd *mocks.MockactionCommand
deployedPipelineLister *mocks.MockdeployedPipelineLister
}
func TestDeployPipelineOpts_Ask(t *testing.T) {
const (
testAppName = "badgoose"
testPipelineName = "pipeline-badgoose-honkpipes"
testPipelineSecret = "github-token-badgoose-honkpipes"
)
pipeline := workspace.PipelineManifest{
Name: testPipelineName,
Path: "copilot/pipeline.yml",
}
testCases := map[string]struct {
inAppName string
inWsAppName string
inPipelineName string
mockWs func(m *mocks.MockwsPipelineReader)
mockSel func(m *mocks.MockwsPipelineSelector)
mockStore func(m *mocks.Mockstore)
wantedApp string
wantedAppConfig *config.Application
wantedPipeline *workspace.PipelineManifest
wantedError error
}{
"return error if can't read app name from workspace file": {
inWsAppName: "",
mockStore: func(m *mocks.Mockstore) {},
mockWs: func(m *mocks.MockwsPipelineReader) {},
mockSel: func(m *mocks.MockwsPipelineSelector) {},
wantedError: errNoAppInWorkspace,
},
"return error if passed-in app name doesn't match workspace app": {
inAppName: "badAppName",
inWsAppName: testAppName,
mockStore: func(m *mocks.Mockstore) {},
mockWs: func(m *mocks.MockwsPipelineReader) {},
mockSel: func(m *mocks.MockwsPipelineSelector) {},
wantedError: errors.New("cannot specify app badAppName because the workspace is already registered with app badgoose"),
},
"return error if passed-in app name can't be validated": {
inWsAppName: testAppName,
inAppName: testAppName,
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication(testAppName).Return(nil, errors.New("some error"))
},
mockWs: func(m *mocks.MockwsPipelineReader) {},
mockSel: func(m *mocks.MockwsPipelineSelector) {},
wantedError: errors.New("get application badgoose configuration: some error"),
},
"return error if passed-in pipeline name not found": {
inAppName: testAppName,
inWsAppName: testAppName,
inPipelineName: "someOtherPipelineName",
mockSel: func(m *mocks.MockwsPipelineSelector) {},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication(testAppName).Return(nil, nil)
},
mockWs: func(m *mocks.MockwsPipelineReader) {
m.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil)
},
wantedError: errors.New("pipeline someOtherPipelineName not found in the workspace"),
},
"return error if fail to select pipeline": {
inAppName: testAppName,
inWsAppName: testAppName,
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication(testAppName).Return(nil, nil)
},
mockSel: func(m *mocks.MockwsPipelineSelector) {
m.EXPECT().WsPipeline(gomock.Any(), gomock.Any()).Return(nil, errors.New("some error"))
},
mockWs: func(m *mocks.MockwsPipelineReader) {},
wantedError: fmt.Errorf("select pipeline: some error"),
},
"success with app flag and pipeline flag": {
inWsAppName: testAppName,
inAppName: testAppName,
inPipelineName: testPipelineName,
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication(testAppName).Return(&config.Application{
Name: testAppName,
}, nil)
},
mockSel: func(m *mocks.MockwsPipelineSelector) {},
mockWs: func(m *mocks.MockwsPipelineReader) {
m.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil)
},
wantedApp: testAppName,
wantedAppConfig: &config.Application{Name: testAppName},
wantedPipeline: &pipeline,
wantedError: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSel := mocks.NewMockwsPipelineSelector(ctrl)
mockWs := mocks.NewMockwsPipelineReader(ctrl)
mockStore := mocks.NewMockstore(ctrl)
tc.mockSel(mockSel)
tc.mockWs(mockWs)
tc.mockStore(mockStore)
opts := deployPipelineOpts{
deployPipelineVars: deployPipelineVars{
appName: tc.inAppName,
name: tc.inPipelineName,
},
wsAppName: tc.inWsAppName,
sel: mockSel,
ws: mockWs,
store: mockStore,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedPipeline, opts.pipeline)
require.Equal(t, tc.wantedApp, opts.appName)
require.Equal(t, tc.wantedAppConfig, opts.app)
}
})
}
}
func TestDeployPipelineOpts_Execute(t *testing.T) {
const (
appName = "badgoose"
region = "us-west-2"
accountID = "123456789012"
pipelineName = "pipepiper"
badPipelineName = "pipeline-badgoose-honkpipes"
pipelineManifestPath = "someStuff/someMoreStuff/aws-copilot-sample-service/copilot/pipelines/pipepiper/manifest.yml"
relativePath = "/copilot/pipelines/pipepiper/manifest.yml"
)
mockPipelineManifest := &manifest.Pipeline{
Name: "pipepiper",
Version: 1,
Source: &manifest.Source{
ProviderName: "GitHub",
Properties: map[string]interface{}{
"repository": "aws/somethingCool",
"branch": "main",
},
},
Stages: []manifest.PipelineStage{
{
Name: "chicken",
TestCommands: []string{"make test", "echo 'made test'"},
},
{
Name: "wings",
TestCommands: []string{"echo 'bok bok bok'"},
},
},
}
app := config.Application{
AccountID: accountID,
Name: appName,
Domain: "amazon.com",
}
mockResources := []*stack.AppRegionalResources{
{
S3Bucket: "someBucket",
KMSKeyARN: "someKey",
},
}
mockResource := &stack.AppRegionalResources{
S3Bucket: "someOtherBucket",
}
mockEnv := &config.Environment{
Name: "test",
App: appName,
Region: region,
AccountID: accountID,
}
testCases := map[string]struct {
inApp *config.Application
inAppName string
inPipelineName string
inRegion string
inPipelineFile string
callMocks func(m deployPipelineMocks)
expectedError error
inShowDiff bool
}{
"create and deploy pipeline": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput) (bool, error) {
if in.IsLegacy {
return false, errors.New("should not be a legacy pipeline")
}
return false, nil
}),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployStart, pipelineName)).Times(1),
m.deployer.EXPECT().CreatePipeline(gomock.Any(), gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput, _ string) error {
if in.IsLegacy {
return errors.New("should not be a legacy pipeline")
}
return nil
}),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployComplete, pipelineName)).Times(1),
)
},
expectedError: nil,
},
"update and deploy pipeline with new naming": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput) (bool, error) {
if in.IsLegacy {
return false, errors.New("should not be a legacy pipeline")
}
return true, nil
}),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtPipelineDeployExistPrompt, pipelineName), "").Return(true, nil),
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployProposalStart, pipelineName)).Times(1),
m.deployer.EXPECT().UpdatePipeline(gomock.Any(), gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput, _ string) error {
if in.IsLegacy {
return errors.New("should not be a legacy pipeline")
}
return nil
}),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployProposalComplete, pipelineName)).Times(1),
)
},
expectedError: nil,
},
"update and deploy pipeline with legacy naming": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{
{
ResourceName: pipelineName,
IsLegacy: true,
},
}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput) (bool, error) {
if !in.IsLegacy {
return false, errors.New("should be a legacy pipeline")
}
return true, nil
}),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtPipelineDeployExistPrompt, pipelineName), "").Return(true, nil),
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployProposalStart, pipelineName)).Times(1),
m.deployer.EXPECT().UpdatePipeline(gomock.Any(), gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput, _ string) error {
if !in.IsLegacy {
return errors.New("should be a legacy pipeline")
}
return nil
}),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployProposalComplete, pipelineName)).Times(1),
)
},
expectedError: nil,
},
"do not deploy pipeline if decline to redeploy an existing pipeline": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).Return(true, nil),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtPipelineDeployExistPrompt, pipelineName), "").Return(false, nil),
)
},
expectedError: nil,
},
"returns an error if fails to prompt for pipeline deploy": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).Return(true, nil),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtPipelineDeployExistPrompt, pipelineName), "").Return(false, errors.New("some error")),
)
},
expectedError: fmt.Errorf("prompt for pipeline deploy: some error"),
},
"returns an error if fail to add pipeline resources to app": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(errors.New("some error")),
m.prog.EXPECT().Stop(log.Serrorf(fmtPipelineDeployResourcesFailed, appName)).Times(1),
)
},
expectedError: fmt.Errorf("add pipeline resources to application %s in %s: some error", appName, region),
},
"returns an error if fail to read pipeline file": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, errors.New("some error")),
)
},
expectedError: fmt.Errorf("read pipeline manifest: some error"),
},
"returns an error if unable to unmarshal pipeline file": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(nil, errors.New("some error")),
)
},
expectedError: fmt.Errorf("read pipeline manifest: some error"),
},
"returns an error if pipeline name fails validation": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
mockBadPipelineManifest := &manifest.Pipeline{
Name: "12345678101234567820123456783012345678401234567850123456786012345678701234567880123456789012345671001",
Version: 1,
Source: &manifest.Source{
ProviderName: "GitHub",
Properties: map[string]interface{}{
"repository": "aws/somethingCool",
"branch": "main",
},
},
}
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockBadPipelineManifest, nil),
)
},
expectedError: fmt.Errorf("validate pipeline manifest: pipeline name '12345678101234567820123456783012345678401234567850123456786012345678701234567880123456789012345671001' must be shorter than 100 characters"),
},
"returns an error if provider is not a supported type": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
mockBadPipelineManifest := &manifest.Pipeline{
Name: badPipelineName,
Version: 1,
Source: &manifest.Source{
ProviderName: "NotGitHub",
Properties: map[string]interface{}{
"access_token_secret": "github-token-badgoose-backend",
"repository": "aws/somethingCool",
"branch": "main",
},
},
}
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockBadPipelineManifest, nil),
)
},
expectedError: fmt.Errorf("read source from manifest: invalid repo source provider: NotGitHub"),
},
"returns an error if unable to convert environments to deployment stage": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Return(errors.New("some error")),
)
},
expectedError: fmt.Errorf("convert environments to deployment stage: get local services: some error"),
},
"returns an error if fails to get cross-regional resources": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, errors.New("some error")),
)
},
expectedError: fmt.Errorf("get cross-regional resources: some error"),
},
"returns an error if fails to check if pipeline exists": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).Return(false, errors.New("some error")),
)
},
expectedError: fmt.Errorf("check if pipeline exists: some error"),
},
"returns an error if fails to create pipeline": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).Return(false, nil),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployStart, pipelineName)).Times(1),
m.deployer.EXPECT().CreatePipeline(gomock.Any(), gomock.Any()).Return(errors.New("some error")),
m.prog.EXPECT().Stop(log.Serrorf(fmtPipelineDeployFailed, pipelineName)).Times(1),
)
},
expectedError: fmt.Errorf("create pipeline: some error"),
},
"returns an error if fails to update pipeline": {
inApp: &app,
inRegion: region,
inAppName: appName,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).Return(true, nil),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtPipelineDeployExistPrompt, pipelineName), "").Return(true, nil),
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployProposalStart, pipelineName)).Times(1),
m.deployer.EXPECT().UpdatePipeline(gomock.Any(), gomock.Any()).Return(errors.New("some error")),
m.prog.EXPECT().Stop(log.Serrorf(fmtPipelineDeployProposalFailed, pipelineName)).Times(1),
)
},
expectedError: fmt.Errorf("update pipeline: some error"),
},
"update and deploy pipeline with specifying build property": {
inApp: &app,
inAppName: appName,
inRegion: region,
callMocks: func(m deployPipelineMocks) {
mockPipelineManifest := &manifest.Pipeline{
Name: "pipepiper",
Version: 1,
Source: &manifest.Source{
ProviderName: "GitHub",
Properties: map[string]interface{}{
"repository": "aws/somethingCool",
"branch": "main",
},
},
Build: &manifest.Build{Image: "aws/codebuild/standard:3.0"},
Stages: []manifest.PipelineStage{
{
Name: "chicken",
RequiresApproval: false,
TestCommands: []string{"make test", "echo 'made test'"},
},
{
Name: "wings",
RequiresApproval: false,
TestCommands: []string{"echo 'bok bok bok'"},
},
},
}
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).Return(true, nil),
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil),
m.prompt.EXPECT().Confirm(fmt.Sprintf(fmtPipelineDeployExistPrompt, pipelineName), "").Return(true, nil),
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployProposalStart, pipelineName)).Times(1),
m.deployer.EXPECT().UpdatePipeline(gomock.Any(), gomock.Any()).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployProposalComplete, pipelineName)).Times(1),
)
},
expectedError: nil,
},
"error if failed to generate the template to show diff": {
inApp: &app,
inAppName: appName,
inRegion: region,
inShowDiff: true,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
m.pipelineStackConfig.EXPECT().Template().Return("", errors.New("some error")),
)
},
expectedError: fmt.Errorf("generate the new template for diff: some error"),
},
"failed to fetch the template of deployed stack": {
inApp: &app,
inAppName: appName,
inRegion: region,
inShowDiff: true,
callMocks: func(m deployPipelineMocks) {
gomock.InOrder(
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1),
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil),
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
m.pipelineStackConfig.EXPECT().Template().Return("template one", nil),
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
m.deployer.EXPECT().Template(gomock.Any()).Return("", fmt.Errorf("some error")))
},
expectedError: fmt.Errorf("retrieve the deployed template for %q: some error", pipelineName),
},
"failed prompt to accept diff": {
inApp: &app,
inAppName: appName,
inRegion: region,
inShowDiff: true,
callMocks: func(m deployPipelineMocks) {
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1)
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil)
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1)
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil)
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil)
m.actionCmd.EXPECT().Execute().Times(2)
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1)
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1)
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil)
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil)
m.pipelineStackConfig.EXPECT().Template().Return("name: mockEnv\ntype: Environment", nil)
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil)
m.deployer.EXPECT().Template(gomock.Any()).Return("name: mockEnv\ntype: Environment", nil)
m.prompt.EXPECT().Confirm(continueDeploymentPrompt, "").Return(false, errors.New("some error"))
},
expectedError: fmt.Errorf("ask whether to continue with the deployment: some error"),
},
"successfully show diff and create a new pipeline": {
inApp: &app,
inAppName: appName,
inRegion: region,
inShowDiff: true,
callMocks: func(m deployPipelineMocks) {
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1)
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil)
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1)
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil)
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil)
m.actionCmd.EXPECT().Execute().Times(2)
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1)
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1)
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil)
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil)
m.deployer.EXPECT().PipelineExists(gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput) (bool, error) {
if in.IsLegacy {
return false, errors.New("should not be a legacy pipeline")
}
return false, nil
})
m.pipelineStackConfig.EXPECT().Template().Return("name: mockEnv\ntype: Environment", nil)
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil)
m.deployer.EXPECT().Template(gomock.Any()).Return("name: mockEnv\ntype: Environment", nil)
m.prompt.EXPECT().Confirm(continueDeploymentPrompt, "").Return(true, nil)
// deployPipeline
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil)
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployStart, pipelineName)).Times(1)
m.deployer.EXPECT().CreatePipeline(gomock.Any(), gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput, _ string) error {
if in.IsLegacy {
return errors.New("should not be a legacy pipeline")
}
return nil
})
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployComplete, pipelineName)).Times(1)
},
},
"Successfully show diff and redeploy an existing pipeline": {
inApp: &app,
inAppName: appName,
inRegion: region,
inShowDiff: true,
callMocks: func(m deployPipelineMocks) {
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployResourcesStart, appName)).Times(1)
m.deployer.EXPECT().AddPipelineResourcesToApp(&app, region).Return(nil)
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployResourcesComplete, appName)).Times(1)
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil)
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil)
m.actionCmd.EXPECT().Execute().Times(2)
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1)
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1)
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil)
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil)
m.pipelineStackConfig.EXPECT().Template().Return("name: mockEnv\ntype: Environment", nil)
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil)
m.deployer.EXPECT().Template(gomock.Any()).Return("name: mockEnv\ntype: Environment", nil)
m.prompt.EXPECT().Confirm(continueDeploymentPrompt, "").Return(true, nil)
// deployPipeline
m.deployer.EXPECT().PipelineExists(gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput) (bool, error) {
if in.IsLegacy {
return false, errors.New("should not be a legacy pipeline")
}
return true, nil
})
m.deployer.EXPECT().GetAppResourcesByRegion(&app, region).Return(mockResource, nil)
m.prog.EXPECT().Start(fmt.Sprintf(fmtPipelineDeployProposalStart, pipelineName)).Times(1)
m.deployer.EXPECT().UpdatePipeline(gomock.Any(), gomock.Any()).DoAndReturn(func(in *deploy.CreatePipelineInput, _ string) error {
if in.IsLegacy {
return errors.New("should not be a legacy pipeline")
}
return nil
})
m.prog.EXPECT().Stop(log.Ssuccessf(fmtPipelineDeployProposalComplete, pipelineName)).Times(1)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockPipelineDeployer := mocks.NewMockpipelineDeployer(ctrl)
mockStore := mocks.NewMockstore(ctrl)
mockWorkspace := mocks.NewMockwsPipelineReader(ctrl)
mockProgress := mocks.NewMockprogress(ctrl)
mockPrompt := mocks.NewMockprompter(ctrl)
mockActionCmd := mocks.NewMockactionCommand(ctrl)
mockPipelineStackConfig := mocks.NewMockpipelineStackConfig(ctrl)
mocks := deployPipelineMocks{
store: mockStore,
prompt: mockPrompt,
prog: mockProgress,
deployer: mockPipelineDeployer,
ws: mockWorkspace,
actionCmd: mockActionCmd,
pipelineStackConfig: mockPipelineStackConfig,
deployedPipelineLister: mocks.NewMockdeployedPipelineLister(ctrl),
mockDiffWriter: &strings.Builder{},
}
tc.callMocks(mocks)
opts := &deployPipelineOpts{
deployPipelineVars: deployPipelineVars{
appName: tc.inAppName,
name: tc.inPipelineName,
showDiff: tc.inShowDiff,
},
pipelineDeployer: mockPipelineDeployer,
pipelineStackConfig: func(in *deploy.CreatePipelineInput) pipelineStackConfig {
return mockPipelineStackConfig
},
ws: mockWorkspace,
app: tc.inApp,
region: tc.inRegion,
store: mockStore,
prog: mockProgress,
prompt: mockPrompt,
diffWriter: &strings.Builder{},
newSvcListCmd: func(w io.Writer, app string) cmd {
return mockActionCmd
},
newJobListCmd: func(w io.Writer, app string) cmd {
return mockActionCmd
},
configureDeployedPipelineLister: func() deployedPipelineLister {
return mocks.deployedPipelineLister
},
pipeline: &workspace.PipelineManifest{
Name: "pipepiper",
Path: pipelineManifestPath,
},
svcBuffer: bytes.NewBufferString(`{"services":[{"app":"badgoose","name":"frontend","type":""}]}`),
jobBuffer: bytes.NewBufferString(`{"jobs":[{"app":"badgoose","name":"backend","type":""}]}`),
}
// WHEN
err := opts.Execute()
// THEN
if tc.expectedError != nil {
require.Error(t, err)
require.Equal(t, tc.expectedError.Error(), err.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestDeployPipelineOpts_getArtifactBuckets(t *testing.T) {
testCases := map[string]struct {
mockDeployer func(m *mocks.MockpipelineDeployer)
expectedOut []deploy.ArtifactBucket
expectedError error
}{
"getsBucketInfo": {
mockDeployer: func(m *mocks.MockpipelineDeployer) {
mockResources := []*stack.AppRegionalResources{
{
S3Bucket: "someBucket",
KMSKeyARN: "someKey",
},
}
m.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil)
},
expectedOut: []deploy.ArtifactBucket{
{
BucketName: "someBucket",
KeyArn: "someKey",
},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockPipelineDeployer := mocks.NewMockpipelineDeployer(ctrl)
tc.mockDeployer(mockPipelineDeployer)
opts := &deployPipelineOpts{
pipelineDeployer: mockPipelineDeployer,
}
// WHEN
actual, err := opts.getArtifactBuckets()
// THEN
if tc.expectedError != nil {
require.Equal(t, tc.expectedError, err)
} else {
require.NoError(t, err)
require.ElementsMatch(t, tc.expectedOut, actual)
}
})
}
}
| 1,048 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"os"
"path"
"path/filepath"
"regexp"
"strconv"
"strings"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"github.com/dustin/go-humanize/english"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/spf13/cobra"
"github.com/dustin/go-humanize"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/aws/secretsmanager"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
)
const (
fmtPipelineInitNamePrompt = "What would you like to %s this pipeline?"
pipelineInitNameHelpPrompt = `A unique identifier for your pipeline (e.g., "myRepo-myBranch").`
pipelineSelectEnvPrompt = "Which environment would you like to add to your pipeline?"
pipelineSelectEnvHelpPrompt = "Adds an environment that corresponds to a deployment stage in your pipeline. Environments are added sequentially."
pipelineSelectURLPrompt = "Which repository would you like to use for your pipeline?"
pipelineSelectURLHelpPrompt = `The repository linked to your pipeline.
Pushing to this repository will trigger your pipeline build stage.
Please enter full repository URL, e.g., "https://github.com/myCompany/myRepo", or the owner/rep, e.g., "myCompany/myRepo"`
)
const (
workloadsPipelineBuildspecTemplatePath = "cicd/buildspec.yml"
environmentsPipelineBuildspecTemplatePath = "cicd/env/buildspec.yml"
fmtPipelineStackName = "pipeline-%s-%s" // Ex: "pipeline-appName-repoName"
defaultBranch = deploy.DefaultPipelineBranch
// For a GitHub repository.
githubURL = "github.com"
fmtGHRepoURL = "https://%s/%s/%s" // Ex: "https://github.com/repoOwner/repoName"
fmtSecretName = "github-token-%s-%s" // Ex: "github-token-appName-repoName"
// For a CodeCommit repository.
awsURL = "aws.amazon.com"
ccIdentifier = "codecommit"
fmtCCRepoURL = "https://%s.console.%s/codesuite/codecommit/repositories/%s/browse" // Ex: "https://region.console.aws.amazon.com/codesuite/codecommit/repositories/repoName/browse"
// For a Bitbucket repository.
bbURL = "bitbucket.org"
fmtBBRepoURL = "https://%s/%s/%s" // Ex: "https://bitbucket.org/repoOwner/repoName"
)
const (
pipelineTypeWorkloads = "Workloads"
pipelineTypeEnvironments = "Environments"
)
var pipelineTypes = []string{pipelineTypeWorkloads, pipelineTypeEnvironments}
var (
// Filled in via the -ldflags flag at compile time to support pipeline buildspec CLI pulling.
binaryS3BucketPath string
)
// Pipeline init errors.
var (
fmtErrInvalidPipelineProvider = "repository %s must be from a supported provider: %s"
)
type pipelineInitializer interface {
writeManifest() error
writeBuildspec() error
}
type workloadPipelineInitializer struct {
cmd *initPipelineOpts
}
type envPipelineInitializer struct {
cmd *initPipelineOpts
}
func (ini *workloadPipelineInitializer) writeManifest() error {
var stages []manifest.PipelineStage
for _, env := range ini.cmd.envConfigs {
stage := manifest.PipelineStage{
Name: env.Name,
}
stages = append(stages, stage)
}
return ini.cmd.createPipelineManifest(stages)
}
func (ini *workloadPipelineInitializer) writeBuildspec() error {
if err := ini.cmd.createBuildspec(workloadsPipelineBuildspecTemplatePath); err != nil {
return err
}
log.Debugln(`The buildspec contains the commands to push your container images, and generate CloudFormation templates.
Update the "build" phase to unit test your services before pushing the images.`)
return nil
}
func (ini *envPipelineInitializer) writeManifest() error {
var stages []manifest.PipelineStage
for _, env := range ini.cmd.envConfigs {
stage := manifest.PipelineStage{
Name: env.Name,
Deployments: manifest.Deployments{
"deploy-env": &manifest.Deployment{
TemplatePath: path.Join(deploy.DefaultPipelineArtifactsDir, fmt.Sprintf(envCFNTemplateNameFmt, env.Name)),
TemplateConfig: path.Join(deploy.DefaultPipelineArtifactsDir, fmt.Sprintf(envCFNTemplateConfigurationNameFmt, env.Name)),
StackName: stack.NameForEnv(ini.cmd.appName, env.Name),
},
},
}
stages = append(stages, stage)
}
return ini.cmd.createPipelineManifest(stages)
}
func (ini *envPipelineInitializer) writeBuildspec() error {
if err := ini.cmd.createBuildspec(environmentsPipelineBuildspecTemplatePath); err != nil {
return err
}
log.Debugln(`The buildspec contains the commands to generate CloudFormation templates for your environments.`)
return nil
}
func newPipelineInitializer(cmd *initPipelineOpts) pipelineInitializer {
switch cmd.pipelineType {
case pipelineTypeWorkloads:
return &workloadPipelineInitializer{
cmd: cmd,
}
case pipelineTypeEnvironments:
return &envPipelineInitializer{
cmd: cmd,
}
}
return nil
}
type initPipelineVars struct {
appName string
name string // Name of the pipeline
environments []string
repoURL string
repoBranch string
githubAccessToken string
pipelineType string
}
type initPipelineOpts struct {
initPipelineVars
// Interfaces to interact with dependencies.
workspace wsPipelineIniter
secretsmanager secretsManager
parser template.Parser
runner execRunner
sessProvider sessionProvider
cfnClient appResourcesGetter
store store
prompt prompter
sel pipelineEnvSelector
pipelineLister deployedPipelineLister
// Outputs stored on successful actions.
secret string
provider string
repoName string
repoOwner string
ccRegion string
// Cached variables
wsAppName string
buffer bytes.Buffer
envConfigs []*config.Environment
manifestPath string // relative path to pipeline's manifest.yml file
}
type artifactBucket struct {
BucketName string
Region string
Environments []string
}
func newInitPipelineOpts(vars initPipelineVars) (*initPipelineOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
p := sessions.ImmutableProvider(sessions.UserAgentExtras("pipeline init"))
defaultSession, err := p.Default()
if err != nil {
return nil, err
}
ssmStore := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
wsAppName := tryReadingAppName()
if vars.appName == "" {
vars.appName = wsAppName
}
return &initPipelineOpts{
initPipelineVars: vars,
workspace: ws,
secretsmanager: secretsmanager.New(defaultSession),
parser: template.New(),
sessProvider: p,
cfnClient: cloudformation.New(defaultSession, cloudformation.WithProgressTracker(os.Stderr)),
store: ssmStore,
prompt: prompter,
sel: selector.NewAppEnvSelector(prompter, ssmStore),
runner: exec.NewCmd(),
wsAppName: wsAppName,
pipelineLister: deploy.NewPipelineStore(rg.New(defaultSession)),
}, nil
}
// Validate returns an error if the optional flag values passed by the user are invalid.
func (o *initPipelineOpts) Validate() error {
return nil
}
// Ask prompts for required fields that are not passed in and validates them.
func (o *initPipelineOpts) Ask() error {
// This command must be executed in the app's workspace because the pipeline manifest and buildspec will be created and stored.
if err := validateWorkspaceApp(o.wsAppName, o.appName, o.store); err != nil {
return err
}
o.appName = o.wsAppName
if err := o.askOrValidateURL(); err != nil {
return err
}
if err := o.parseRepoDetails(); err != nil {
return err
}
if o.repoBranch == "" {
o.getBranch()
}
if err := o.askOrValidatePipelineName(); err != nil {
return err
}
if err := o.askOrValidatePipelineType(); err != nil {
return err
}
if err := o.validateDuplicatePipeline(); err != nil {
return err
}
if len(o.environments) == 0 {
if err := o.askEnvs(); err != nil {
return err
}
}
if err := o.validateEnvs(); err != nil {
return err
}
return nil
}
// Execute writes the pipeline manifest file.
func (o *initPipelineOpts) Execute() error {
if o.provider == manifest.GithubV1ProviderName {
if err := o.storeGitHubAccessToken(); err != nil {
return err
}
}
log.Infoln()
ini := newPipelineInitializer(o)
if err := ini.writeManifest(); err != nil {
return err
}
if err := ini.writeBuildspec(); err != nil {
return err
}
return nil
}
// RequiredActions returns follow-up actions the user must take after successfully executing the command.
func (o *initPipelineOpts) RequiredActions() []string {
return []string{
fmt.Sprintf("Commit and push the %s directory to your repository.", color.HighlightResource("copilot/")),
fmt.Sprintf("Run %s to create your pipeline.", color.HighlightCode("copilot pipeline deploy")),
}
}
// validateDuplicatePipeline checks that the pipeline name isn't already used
// by another pipeline to reduce potential confusion with a legacy pipeline.
func (o *initPipelineOpts) validateDuplicatePipeline() error {
var allPipelines []string
localPipelines, err := o.workspace.ListPipelines()
if err != nil {
return fmt.Errorf("get local pipelines: %w", err)
}
for _, pipeline := range localPipelines {
allPipelines = append(allPipelines, pipeline.Name)
}
deployedPipelines, err := o.pipelineLister.ListDeployedPipelines(o.appName)
if err != nil {
return fmt.Errorf("list deployed pipelines for app %s: %w", o.appName, err)
}
for _, pipeline := range deployedPipelines {
allPipelines = append(allPipelines, pipeline.Name)
}
fullName := fmt.Sprintf(fmtPipelineStackName, o.appName, o.name)
for _, pipeline := range allPipelines {
if strings.EqualFold(pipeline, o.name) || strings.EqualFold(pipeline, fullName) {
log.Warningf(`You already have a pipeline named '%s'.
To deploy the existing pipeline, run %s.
To recreate the pipeline, run %s,
optionally delete your pipeline.yml/manifest.yml and/or buildspec.yml file(s),
then run %s.
If you have manually deleted your pipeline.yml/manifest.yml and/or buildspec.yml file(s)
for the existing pipeline, Copilot will now generate new default file(s).
To create an additional pipeline, run "copilot pipeline init" again, but with a new pipeline name.
`, o.name, fmt.Sprintf(`"copilot pipeline deploy --name %s"`, o.name), fmt.Sprintf(`"copilot pipeline delete --name %s"`, o.name), fmt.Sprintf(`"copilot pipeline init --name %s"`, o.name))
return nil
}
}
return nil
}
func (o *initPipelineOpts) askOrValidatePipelineName() error {
if o.name == "" {
return o.askPipelineName()
}
return validatePipelineName(o.name, o.appName)
}
func (o *initPipelineOpts) askOrValidateURL() error {
if o.repoURL == "" {
return o.selectURL()
}
return o.validateURL(o.repoURL)
}
func (o *initPipelineOpts) askPipelineName() error {
promptOpts := []prompt.PromptConfig{
prompt.WithFinalMessage("Pipeline name:"),
}
// Only show suggestion if [repo]-[branch] is a valid pipeline name.
suggestion := strings.ToLower(fmt.Sprintf("%s-%s", o.repoName, o.repoBranch))
if err := validatePipelineName(suggestion, o.appName); err == nil {
promptOpts = append(promptOpts, prompt.WithDefaultInput(suggestion))
}
name, err := o.prompt.Get(fmt.Sprintf(fmtPipelineInitNamePrompt, color.Emphasize("name")),
pipelineInitNameHelpPrompt,
func(val interface{}) error {
return validatePipelineName(val, o.appName)
}, promptOpts...)
if err != nil {
return fmt.Errorf("get pipeline name: %w", err)
}
o.name = name
return nil
}
func (o *initPipelineOpts) askOrValidatePipelineType() error {
if o.pipelineType != "" {
for _, typ := range pipelineTypes {
if o.pipelineType == typ {
return nil
}
}
return fmt.Errorf("invalid pipeline type %q; must be one of %s", o.pipelineType, english.WordSeries(applyAll(pipelineTypes, strconv.Quote), "or"))
}
typ, err := o.prompt.SelectOption("What type of continuous delivery pipeline is this?",
"A pipeline can be set up to deploy either your workloads or your environments",
[]prompt.Option{
{
Value: pipelineTypeWorkloads,
Hint: "Deploy the services or jobs in your workspace",
},
{
Value: pipelineTypeEnvironments,
Hint: "Deploy the environments in your workspace",
},
})
if err != nil {
return fmt.Errorf("prompt for pipeline type: %w", err)
}
o.pipelineType = typ
return nil
}
func (o *initPipelineOpts) validateURL(url string) error {
// Note: no longer calling `validateDomainName` because if users use git-remote-codecommit
// (the HTTPS (GRC) protocol) to connect to CodeCommit, the url does not have any periods.
if !strings.Contains(url, githubURL) && !strings.Contains(url, ccIdentifier) && !strings.Contains(url, bbURL) {
return fmt.Errorf(fmtErrInvalidPipelineProvider, url, english.WordSeries(manifest.PipelineProviders, "or"))
}
return nil
}
// To avoid duplicating calls to GetEnvironment, validate and get config in the same step.
func (o *initPipelineOpts) validateEnvs() error {
var envConfigs []*config.Environment
for _, env := range o.environments {
config, err := o.store.GetEnvironment(o.appName, env)
if err != nil {
return fmt.Errorf("validate environment %s: %w", env, err)
}
envConfigs = append(envConfigs, config)
}
o.envConfigs = envConfigs
return nil
}
func (o *initPipelineOpts) askEnvs() error {
envs, err := o.sel.Environments(pipelineSelectEnvPrompt, pipelineSelectEnvHelpPrompt, o.appName, func(order int) prompt.PromptConfig {
return prompt.WithFinalMessage(fmt.Sprintf("%s stage:", humanize.Ordinal(order)))
})
if err != nil {
return fmt.Errorf("select environments: %w", err)
}
o.environments = envs
return nil
}
func (o *initPipelineOpts) parseRepoDetails() error {
switch {
case strings.Contains(o.repoURL, githubURL):
return o.parseGitHubRepoDetails()
case strings.Contains(o.repoURL, ccIdentifier):
return o.parseCodeCommitRepoDetails()
case strings.Contains(o.repoURL, bbURL):
return o.parseBitbucketRepoDetails()
default:
return fmt.Errorf(fmtErrInvalidPipelineProvider, o.repoURL, english.WordSeries(manifest.PipelineProviders, "or"))
}
}
// getBranch fetches the user's current branch as a best-guess of which branch they want their pipeline to follow. If err, insert default branch name.
func (o *initPipelineOpts) getBranch() {
// Fetches local git branch.
err := o.runner.Run("git", []string{"rev-parse", "--abbrev-ref", "HEAD"}, exec.Stdout(&o.buffer))
o.repoBranch = strings.TrimSpace(o.buffer.String())
if err != nil {
o.repoBranch = defaultBranch
}
if strings.TrimSpace(o.buffer.String()) == "" {
o.repoBranch = defaultBranch
}
o.buffer.Reset()
log.Infof(`Your pipeline will follow branch '%s'.
`, color.HighlightUserInput(o.repoBranch))
}
func (o *initPipelineOpts) parseGitHubRepoDetails() error {
// If the user uses a flag to specify a GitHub access token,
// GitHub version 1 (not CSC) is the provider.
o.provider = manifest.GithubProviderName
if o.githubAccessToken != "" {
o.provider = manifest.GithubV1ProviderName
}
repoDetails, err := ghRepoURL(o.repoURL).parse()
if err != nil {
return err
}
o.repoName = repoDetails.name
o.repoOwner = repoDetails.owner
return nil
}
func (o *initPipelineOpts) parseCodeCommitRepoDetails() error {
o.provider = manifest.CodeCommitProviderName
repoDetails, err := ccRepoURL(o.repoURL).parse()
if err != nil {
return err
}
o.repoName = repoDetails.name
o.ccRegion = repoDetails.region
// If the CodeCommit region is different than that of the app, pipeline init errors out.
sess, err := o.sessProvider.Default()
if err != nil {
return fmt.Errorf("retrieve default session: %w", err)
}
region := aws.StringValue(sess.Config.Region)
if o.ccRegion == "" {
o.ccRegion = region
}
if o.ccRegion != region {
return fmt.Errorf("repository %s is in %s, but app %s is in %s; they must be in the same region", o.repoName, o.ccRegion, o.appName, region)
}
return nil
}
func (o *initPipelineOpts) parseBitbucketRepoDetails() error {
o.provider = manifest.BitbucketProviderName
repoDetails, err := bbRepoURL(o.repoURL).parse()
if err != nil {
return err
}
o.repoName = repoDetails.name
o.repoOwner = repoDetails.owner
return nil
}
func (o *initPipelineOpts) selectURL() error {
// Fetches and parses all remote repositories.
err := o.runner.Run("git", []string{"remote", "-v"}, exec.Stdout(&o.buffer))
if err != nil {
return fmt.Errorf("get remote repository info: %w; make sure you have installed Git and are in a Git repository", err)
}
urls, err := o.parseGitRemoteResult(strings.TrimSpace(o.buffer.String()))
if err != nil {
return err
}
o.buffer.Reset()
// If there is only one returned URL, set it rather than prompt to select.
if len(urls) == 1 {
log.Infof(`Only one git remote detected. Your pipeline will follow '%s'.
`, color.HighlightUserInput(urls[0]))
o.repoURL = urls[0]
return nil
}
// Prompts user to select a repo URL.
url, err := o.prompt.SelectOne(
pipelineSelectURLPrompt,
pipelineSelectURLHelpPrompt,
urls,
prompt.WithFinalMessage("Repository URL:"),
)
if err != nil {
return fmt.Errorf("select URL: %w", err)
}
o.repoURL = url
return nil
}
// examples:
// efekarakus [email protected]:efekarakus/grit.git (fetch)
// efekarakus https://github.com/karakuse/grit.git (fetch)
// origin https://github.com/koke/grit (fetch)
// koke git://github.com/koke/grit.git (push)
// https https://git-codecommit.us-west-2.amazonaws.com/v1/repos/aws-sample (fetch)
// fed codecommit::us-west-2://aws-sample (fetch)
// ssh ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/aws-sample (push)
// bbhttps https://[email protected]/huanjani/aws-copilot-sample-service.git (fetch)
// bbssh ssh://[email protected]:teamsinspace/documentation-tests.git (fetch)
// parseGitRemoteResults returns just the trimmed middle column (url) of the `git remote -v` results,
// and skips urls from unsupported sources.
func (o *initPipelineOpts) parseGitRemoteResult(s string) ([]string, error) {
var urls []string
urlSet := make(map[string]bool)
items := strings.Split(s, "\n")
for _, item := range items {
if !strings.Contains(item, githubURL) && !strings.Contains(item, ccIdentifier) && !strings.Contains(item, bbURL) {
continue
}
cols := strings.Split(item, "\t")
url := strings.TrimSpace(strings.TrimSuffix(strings.Split(cols[1], " ")[0], ".git"))
urlSet[url] = true
}
for url := range urlSet {
urls = append(urls, url)
}
return urls, nil
}
type ghRepoURL string
type ghRepoDetails struct {
name string
owner string
}
type ccRepoURL string
type ccRepoDetails struct {
name string
region string
}
type bbRepoURL string
type bbRepoDetails struct {
name string
owner string
}
func (url ghRepoURL) parse() (ghRepoDetails, error) {
urlString := string(url)
regexPattern := regexp.MustCompile(`.*(github.com)(:|\/)`)
parsedURL := strings.TrimPrefix(urlString, regexPattern.FindString(urlString))
parsedURL = strings.TrimSuffix(parsedURL, ".git")
ownerRepo := strings.Split(parsedURL, "/")
if len(ownerRepo) != 2 {
return ghRepoDetails{}, fmt.Errorf("unable to parse the GitHub repository owner and name from %s: please pass the repository URL with the format `--url https://github.com/{owner}/{repositoryName}`", url)
}
return ghRepoDetails{
name: ownerRepo[1],
owner: ownerRepo[0],
}, nil
}
func (url ccRepoURL) parse() (ccRepoDetails, error) {
urlString := string(url)
var region string
// Parse region.
switch {
case strings.HasPrefix(urlString, "https://") || strings.HasPrefix(urlString, "ssh://"):
parsedURL := strings.Split(urlString, ".")
region = parsedURL[1]
case strings.HasPrefix(urlString, "codecommit::"):
parsedURL := strings.Split(urlString, ":")
region = parsedURL[2]
case strings.HasPrefix(urlString, "codecommit://"):
// Use default profile region.
default:
return ccRepoDetails{}, fmt.Errorf("unknown CodeCommit URL format: %s", url)
}
if region != "" {
// Double-check that parsed results is a valid region. Source: https://www.regextester.com/109163
match, _ := regexp.MatchString(`(us(-gov)?|ap|ca|cn|eu|sa)-(central|(north|south)?(east|west)?)-\d`, region)
if !match {
return ccRepoDetails{}, fmt.Errorf("unable to parse the AWS region from %s", url)
}
}
// Parse repo name.
parsedForRepo := strings.Split(urlString, "/")
if len(parsedForRepo) < 2 {
return ccRepoDetails{}, fmt.Errorf("unable to parse the CodeCommit repository name from %s", url)
}
repoName := parsedForRepo[len(parsedForRepo)-1]
return ccRepoDetails{
name: repoName,
region: region,
}, nil
}
// Bitbucket URLs, post-parseGitRemoteResults(), may look like:
// https://[email protected]/teamsinspace/documentation-tests
// ssh://[email protected]:teamsinspace/documentation-tests
func (url bbRepoURL) parse() (bbRepoDetails, error) {
urlString := string(url)
splitURL := strings.Split(urlString, "/")
if len(splitURL) < 2 {
return bbRepoDetails{}, fmt.Errorf("unable to parse the Bitbucket repository name from %s", url)
}
repoName := splitURL[len(splitURL)-1]
// rather than check for the SSH prefix, split on colon here; HTTPS version will be unaffected.
splitRepoOwner := strings.Split(splitURL[len(splitURL)-2], ":")
repoOwner := splitRepoOwner[len(splitRepoOwner)-1]
return bbRepoDetails{
name: repoName,
owner: repoOwner,
}, nil
}
func (o *initPipelineOpts) storeGitHubAccessToken() error {
secretName := o.secretName()
_, err := o.secretsmanager.CreateSecret(secretName, o.githubAccessToken)
if err != nil {
var existsErr *secretsmanager.ErrSecretAlreadyExists
if !errors.As(err, &existsErr) {
return err
}
log.Successf("Secret already exists for %s! Do nothing.\n", color.HighlightUserInput(o.repoName))
} else {
log.Successf("Created the secret %s for pipeline source stage!\n", color.HighlightUserInput(secretName))
}
o.secret = secretName
return nil
}
func (o *initPipelineOpts) createPipelineManifest(stages []manifest.PipelineStage) error {
provider, err := o.pipelineProvider()
if err != nil {
return err
}
manifest, err := manifest.NewPipeline(o.name, provider, stages)
if err != nil {
return fmt.Errorf("generate a pipeline manifest: %w", err)
}
var manifestExists bool
o.manifestPath, err = o.workspace.WritePipelineManifest(manifest, o.name)
if err != nil {
e, ok := err.(*workspace.ErrFileExists)
if !ok {
return fmt.Errorf("write pipeline manifest to workspace: %w", err)
}
manifestExists = true
o.manifestPath = e.FileName
}
mftPath := displayPath(o.manifestPath)
o.manifestPath, err = o.workspace.Rel(o.manifestPath)
if err != nil {
return err
}
if manifestExists {
log.Infof(`Pipeline manifest file for %s already exists at %s, skipping writing it.
Previously set repository URL, branch, and environment stages will remain.
`, color.HighlightUserInput(o.repoName), color.HighlightResource(mftPath))
} else {
log.Successf("Wrote the pipeline manifest for %s at '%s'\n", color.HighlightUserInput(o.repoName), color.HighlightResource(mftPath))
}
log.Debug(`The manifest contains configurations for your pipeline.
Update the file to add stages, change the tracked branch, add test commands or manual approval actions.
`)
return nil
}
func (o *initPipelineOpts) createBuildspec(buildSpecTemplatePath string) error {
artifactBuckets, err := o.artifactBuckets()
if err != nil {
return err
}
content, err := o.parser.Parse(buildSpecTemplatePath, struct {
BinaryS3BucketPath string
Version string
ManifestPath string
ArtifactBuckets []artifactBucket
}{
BinaryS3BucketPath: binaryS3BucketPath,
Version: version.Version,
ManifestPath: filepath.ToSlash(o.manifestPath), // The manifest path must be rendered in the buildspec with '/' instead of os-specific separator.
ArtifactBuckets: artifactBuckets,
})
if err != nil {
return err
}
buildspecPath, err := o.workspace.WritePipelineBuildspec(content, o.name)
var buildspecExists bool
if err != nil {
e, ok := err.(*workspace.ErrFileExists)
if !ok {
return fmt.Errorf("write buildspec to workspace: %w", err)
}
buildspecExists = true
buildspecPath = e.FileName
}
buildspecPath = displayPath(buildspecPath)
if buildspecExists {
log.Infof(`Buildspec file for pipeline already exists at %s, skipping writing it.
Previously set config will remain.
`, color.HighlightResource(buildspecPath))
return nil
}
log.Successf("Wrote the buildspec for the pipeline's build stage at '%s'\n", color.HighlightResource(buildspecPath))
return nil
}
func (o *initPipelineOpts) secretName() string {
return fmt.Sprintf(fmtSecretName, o.appName, o.repoName)
}
func (o *initPipelineOpts) pipelineProvider() (manifest.Provider, error) {
var config interface{}
switch o.provider {
case manifest.GithubV1ProviderName:
config = &manifest.GitHubV1Properties{
RepositoryURL: fmt.Sprintf(fmtGHRepoURL, githubURL, o.repoOwner, o.repoName),
Branch: o.repoBranch,
GithubSecretIdKeyName: o.secret,
}
case manifest.GithubProviderName:
config = &manifest.GitHubProperties{
RepositoryURL: fmt.Sprintf(fmtGHRepoURL, githubURL, o.repoOwner, o.repoName),
Branch: o.repoBranch,
}
case manifest.CodeCommitProviderName:
config = &manifest.CodeCommitProperties{
RepositoryURL: fmt.Sprintf(fmtCCRepoURL, o.ccRegion, awsURL, o.repoName),
Branch: o.repoBranch,
}
case manifest.BitbucketProviderName:
config = &manifest.BitbucketProperties{
RepositoryURL: fmt.Sprintf(fmtBBRepoURL, bbURL, o.repoOwner, o.repoName),
Branch: o.repoBranch,
}
default:
return nil, fmt.Errorf("unable to create pipeline source provider for %s", o.repoName)
}
return manifest.NewProvider(config)
}
func (o *initPipelineOpts) artifactBuckets() ([]artifactBucket, error) {
app, err := o.store.GetApplication(o.appName)
if err != nil {
return nil, fmt.Errorf("get application %s: %w", o.appName, err)
}
regionalResources, err := o.cfnClient.GetRegionalAppResources(app)
if err != nil {
return nil, fmt.Errorf("get regional application resources: %w", err)
}
var buckets []artifactBucket
for _, resource := range regionalResources {
var envNames []string
for _, env := range o.envConfigs {
if env.Region == resource.Region {
envNames = append(envNames, env.Name)
}
}
bucket := artifactBucket{
BucketName: resource.S3Bucket,
Region: resource.Region,
Environments: envNames,
}
buckets = append(buckets, bucket)
}
return buckets, nil
}
// buildPipelineInitCmd build the command for creating a new pipeline.
func buildPipelineInitCmd() *cobra.Command {
vars := initPipelineVars{}
cmd := &cobra.Command{
Use: "init",
Short: "Creates a pipeline for the services in your workspace.",
Long: `Creates a pipeline for the services in your workspace, using the environments associated with the application.`,
Example: `
Create a pipeline for the services in your workspace.
/code $ copilot pipeline init \
/code --name frontend-main \
/code --url https://github.com/gitHubUserName/frontend.git \
/code --git-branch main \
/code --environments "stage,prod"`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newInitPipelineOpts(vars)
if err != nil {
return err
}
if err := opts.Validate(); err != nil {
return err
}
if err := opts.Ask(); err != nil {
return err
}
if err := opts.Execute(); err != nil {
return err
}
log.Infoln()
log.Infoln("Required follow-up actions:")
for _, followup := range opts.RequiredActions() {
log.Infof("- %s\n", followup)
}
return nil
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, "", appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", pipelineFlagDescription)
cmd.Flags().StringVar(&vars.repoURL, githubURLFlag, "", githubURLFlagDescription)
_ = cmd.Flags().MarkHidden(githubURLFlag)
cmd.Flags().StringVarP(&vars.repoURL, repoURLFlag, repoURLFlagShort, "", repoURLFlagDescription)
cmd.Flags().StringVarP(&vars.githubAccessToken, githubAccessTokenFlag, githubAccessTokenFlagShort, "", githubAccessTokenFlagDescription)
_ = cmd.Flags().MarkHidden(githubAccessTokenFlag)
cmd.Flags().StringVarP(&vars.repoBranch, gitBranchFlag, gitBranchFlagShort, "", gitBranchFlagDescription)
cmd.Flags().StringSliceVarP(&vars.environments, envsFlag, envsFlagShort, []string{}, pipelineEnvsFlagDescription)
cmd.Flags().StringVarP(&vars.pipelineType, pipelineTypeFlag, pipelineTypeShort, "", pipelineTypeFlagDescription)
return cmd
}
| 918 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/secretsmanager"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/template"
templatemocks "github.com/aws/copilot-cli/internal/pkg/template/mocks"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type pipelineInitMocks struct {
workspace *mocks.MockwsPipelineIniter
secretsmanager *mocks.MocksecretsManager
parser *templatemocks.MockParser
runner *mocks.MockexecRunner
sessProvider *mocks.MocksessionProvider
cfnClient *mocks.MockappResourcesGetter
store *mocks.Mockstore
prompt *mocks.Mockprompter
sel *mocks.MockpipelineEnvSelector
pipelineLister *mocks.MockdeployedPipelineLister
}
func TestInitPipelineOpts_Ask(t *testing.T) {
const (
mockAppName = "my-app"
wantedName = "mypipe"
)
mockError := errors.New("some error")
mockApp := &config.Application{
Name: mockAppName,
}
githubAnotherURL := "[email protected]:goodGoose/bhaOS.git"
githubToken := "hunter2"
testCases := map[string]struct {
inName string
inAppName string
inWsAppName string
inEnvironments []string
inRepoURL string
inGitHubAccessToken string
inGitBranch string
inType string
setupMocks func(m pipelineInitMocks)
buffer bytes.Buffer
expectedBranch string
expectedError error
}{
"empty workspace app name": {
inWsAppName: "",
expectedError: errNoAppInWorkspace,
},
"invalid app name (not in workspace)": {
inWsAppName: "diff-app",
inAppName: "ghost-app",
expectedError: errors.New("cannot specify app ghost-app because the workspace is already registered with app diff-app"),
},
"invalid app name": {
inWsAppName: "ghost-app",
inAppName: "ghost-app",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication("ghost-app").Return(nil, mockError)
},
expectedError: fmt.Errorf("get application ghost-app configuration: some error"),
},
"returns error when repository URL is not from a supported git provider": {
inWsAppName: mockAppName,
inRepoURL: "https://gitlab.company.com/group/project.git",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
},
expectedError: errors.New("repository https://gitlab.company.com/group/project.git must be from a supported provider: GitHub, CodeCommit or Bitbucket"),
},
"returns error when GitHub repository URL is of unknown format": {
inWsAppName: mockAppName,
inRepoURL: "thisisnotevenagithub.comrepository",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
},
expectedError: errors.New("unable to parse the GitHub repository owner and name from thisisnotevenagithub.comrepository: please pass the repository URL with the format `--url https://github.com/{owner}/{repositoryName}`"),
},
"returns error when CodeCommit repository URL is of unknown format": {
inWsAppName: mockAppName,
inRepoURL: "git-codecommitus-west-2amazonaws.com",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
},
expectedError: errors.New("unknown CodeCommit URL format: git-codecommitus-west-2amazonaws.com"),
},
"returns error when CodeCommit repository contains unknown region": {
inWsAppName: mockAppName,
inRepoURL: "codecommit::us-mess-2://repo-man",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
},
expectedError: errors.New("unable to parse the AWS region from codecommit::us-mess-2://repo-man"),
},
"returns error when CodeCommit repository region does not match pipeline's region": {
inWsAppName: mockAppName,
inRepoURL: "codecommit::us-west-2://repo-man",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.sessProvider.EXPECT().Default().Return(&session.Session{
Config: &aws.Config{
Region: aws.String("us-east-1"),
},
}, nil)
},
expectedError: errors.New("repository repo-man is in us-west-2, but app my-app is in us-east-1; they must be in the same region"),
},
"returns error when Bitbucket repository URL is of unknown format": {
inWsAppName: mockAppName,
inRepoURL: "bitbucket.org",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
},
expectedError: errors.New("unable to parse the Bitbucket repository name from bitbucket.org"),
},
"successfully detects local branch and sets it": {
inWsAppName: mockAppName,
inRepoURL: "[email protected]:badgoose/goose.git",
inEnvironments: []string{"test"},
inName: wantedName,
buffer: *bytes.NewBufferString("devBranch"),
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.runner.EXPECT().Run(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
m.store.EXPECT().GetEnvironment("my-app", "test").Return(
&config.Environment{
Name: "test",
}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{}, nil)
},
expectedBranch: "devBranch",
expectedError: nil,
},
"sets 'main' as branch name if error fetching it": {
inWsAppName: mockAppName,
inRepoURL: "[email protected]:badgoose/goose.git",
inEnvironments: []string{"test"},
inName: wantedName,
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.runner.EXPECT().Run(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
m.store.EXPECT().GetEnvironment("my-app", "test").Return(
&config.Environment{
Name: "test",
}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{}, nil)
},
expectedBranch: "main",
expectedError: nil,
},
"invalid pipeline name": {
inWsAppName: mockAppName,
inName: "1234",
inRepoURL: githubAnotherURL,
inGitBranch: "main",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication("my-app").Return(mockApp, nil)
},
expectedError: fmt.Errorf("pipeline name 1234 is invalid: %w", errBasicNameRegexNotMatched),
},
"returns an error if fail to get pipeline name": {
inWsAppName: mockAppName,
inRepoURL: githubAnotherURL,
inGitBranch: "main",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return("", errors.New("mock error"))
},
expectedError: fmt.Errorf("get pipeline name: mock error"),
},
"invalid pipeline type": {
inWsAppName: mockAppName,
inRepoURL: githubAnotherURL,
inGitBranch: "main",
inName: "mock-pipeline",
inType: "RandomType",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
},
expectedError: errors.New(`invalid pipeline type "RandomType"; must be one of "Workloads" or "Environments"`),
},
"returns an error if fail to get pipeline type": {
inWsAppName: mockAppName,
inRepoURL: githubAnotherURL,
inGitBranch: "main",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().Get(gomock.Eq("What would you like to name this pipeline?"), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedName, nil)
m.prompt.EXPECT().SelectOption(gomock.Eq("What type of continuous delivery pipeline is this?"), gomock.Any(), gomock.Any()).
Return("", errors.New("mock error"))
},
expectedError: fmt.Errorf("prompt for pipeline type: mock error"),
},
"prompt for pipeline name": {
inWsAppName: mockAppName,
inRepoURL: githubAnotherURL,
inGitBranch: "main",
inEnvironments: []string{"prod"},
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.store.EXPECT().GetEnvironment(mockAppName, "prod").
Return(&config.Environment{Name: "prod"}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{}, nil)
m.prompt.EXPECT().Get(gomock.Eq("What would you like to name this pipeline?"), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedName, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
},
"passed-in URL to unsupported repo provider": {
inWsAppName: mockAppName,
inName: wantedName,
inRepoURL: "unsupported.org/repositories/repoName",
inEnvironments: []string{"test"},
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
expectedError: errors.New("repository unsupported.org/repositories/repoName must be from a supported provider: GitHub, CodeCommit or Bitbucket"),
},
"passed-in invalid environments": {
inWsAppName: mockAppName,
inName: wantedName,
inRepoURL: "https://github.com/badGoose/chaOS",
inEnvironments: []string{"test", "prod"},
inGitBranch: "main",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment("my-app", "test").Return(nil, mockError)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{}, nil)
},
expectedError: errors.New("validate environment test: some error"),
},
"success with GH repo with env and repoURL flags": {
inWsAppName: mockAppName,
inName: wantedName,
inEnvironments: []string{"test", "prod"},
inRepoURL: "https://github.com/badGoose/chaOS",
inGitBranch: "main",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment("my-app", "test").Return(
&config.Environment{
Name: "test",
}, nil)
m.store.EXPECT().GetEnvironment("my-app", "prod").Return(
&config.Environment{
Name: "prod",
}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{}, nil)
},
},
"success with CC repo with env and repoURL flags": {
inWsAppName: mockAppName,
inName: wantedName,
inEnvironments: []string{"test", "prod"},
inRepoURL: "https://git-codecommit.us-west-2.amazonaws.com/v1/repos/repo-man",
inGitBranch: "main",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.sessProvider.EXPECT().Default().Return(&session.Session{
Config: &aws.Config{
Region: aws.String("us-west-2"),
},
}, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment("my-app", "test").Return(
&config.Environment{
Name: "test",
}, nil)
m.store.EXPECT().GetEnvironment("my-app", "prod").Return(
&config.Environment{
Name: "prod",
}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{}, nil)
},
},
"no flags, prompts for all input, success case for selecting URL": {
inWsAppName: mockAppName,
inGitHubAccessToken: githubToken,
buffer: *bytes.NewBufferString("archer\[email protected]:goodGoose/bhaOS (fetch)\narcher\thttps://github.com/badGoose/chaOS (push)\narcher\tcodecommit::us-west-2://repo-man (fetch)\n"),
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.runner.EXPECT().Run(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
m.runner.EXPECT().Run(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
m.store.EXPECT().GetEnvironment("my-app", "test").Return(&config.Environment{
Name: "test",
Region: "us-west-2",
}, nil)
m.store.EXPECT().GetEnvironment("my-app", "prod").Return(&config.Environment{
Name: "prod",
Region: "us-west-2",
}, nil)
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(wantedName, nil)
m.prompt.EXPECT().SelectOption("What type of continuous delivery pipeline is this?", gomock.Any(), gomock.Any()).Return(pipelineTypeEnvironments, nil)
m.prompt.EXPECT().SelectOne(pipelineSelectURLPrompt, gomock.Any(), gomock.Any(), gomock.Any()).Return(githubAnotherURL, nil).Times(1)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{}, nil)
m.sel.EXPECT().Environments(pipelineSelectEnvPrompt, gomock.Any(), "my-app", gomock.Any()).Return([]string{"test", "prod"}, nil)
},
},
"returns error if fail to list environments": {
inWsAppName: mockAppName,
inName: wantedName,
inRepoURL: githubAnotherURL,
inGitBranch: "main",
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return(nil, nil)
m.sel.EXPECT().Environments(pipelineSelectEnvPrompt, gomock.Any(), "my-app", gomock.Any()).Return(nil, errors.New("some error"))
},
expectedError: fmt.Errorf("select environments: some error"),
},
"returns error if fail to select URL": {
inWsAppName: mockAppName,
inName: wantedName,
inRepoURL: "",
inEnvironments: []string{},
buffer: *bytes.NewBufferString("archer\[email protected]:goodGoose/bhaOS (fetch)\narcher\thttps://github.com/badGoose/chaOS (push)\n"),
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.runner.EXPECT().Run(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
m.prompt.EXPECT().SelectOne(pipelineSelectURLPrompt, gomock.Any(), gomock.Any(), gomock.Any()).Return("", mockError).Times(1)
},
expectedError: fmt.Errorf("select URL: some error"),
},
"returns error if fail to get env config": {
inWsAppName: mockAppName,
inName: wantedName,
inRepoURL: githubAnotherURL,
inGitBranch: "main",
inEnvironments: []string{},
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return(nil, nil)
m.sel.EXPECT().Environments(pipelineSelectEnvPrompt, gomock.Any(), "my-app", gomock.Any()).Return([]string{"test", "prod"}, nil)
m.store.EXPECT().GetEnvironment("my-app", "test").Return(&config.Environment{
Name: "test",
Region: "us-west-2",
}, nil)
m.store.EXPECT().GetEnvironment("my-app", "prod").Return(nil, errors.New("some error"))
},
expectedError: fmt.Errorf("validate environment prod: some error"),
},
"skip selector prompt if only one repo URL": {
inWsAppName: mockAppName,
inName: wantedName,
inGitBranch: "main",
buffer: *bytes.NewBufferString("archer\[email protected]:goodGoose/bhaOS (fetch)\n"),
setupMocks: func(m pipelineInitMocks) {
m.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil)
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
m.runner.EXPECT().Run(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
m.workspace.EXPECT().ListPipelines().Return(nil, nil)
m.sel.EXPECT().Environments(pipelineSelectEnvPrompt, gomock.Any(), "my-app", gomock.Any()).Return([]string{"test", "prod"}, nil)
m.store.EXPECT().GetEnvironment("my-app", "test").Return(&config.Environment{
Name: "test",
Region: "us-west-2",
}, nil)
m.store.EXPECT().GetEnvironment("my-app", "prod").Return(&config.Environment{
Name: "prod",
Region: "us-west-2",
}, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := pipelineInitMocks{
prompt: mocks.NewMockprompter(ctrl),
runner: mocks.NewMockexecRunner(ctrl),
sessProvider: mocks.NewMocksessionProvider(ctrl),
sel: mocks.NewMockpipelineEnvSelector(ctrl),
store: mocks.NewMockstore(ctrl),
pipelineLister: mocks.NewMockdeployedPipelineLister(ctrl),
workspace: mocks.NewMockwsPipelineIniter(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(mocks)
}
opts := &initPipelineOpts{
initPipelineVars: initPipelineVars{
appName: tc.inAppName,
name: tc.inName,
environments: tc.inEnvironments,
repoURL: tc.inRepoURL,
githubAccessToken: tc.inGitHubAccessToken,
repoBranch: tc.inGitBranch,
pipelineType: tc.inType,
},
wsAppName: tc.inWsAppName,
prompt: mocks.prompt,
runner: mocks.runner,
sessProvider: mocks.sessProvider,
buffer: tc.buffer,
sel: mocks.sel,
store: mocks.store,
pipelineLister: mocks.pipelineLister,
workspace: mocks.workspace,
}
// WHEN
err := opts.Ask()
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.NoError(t, err)
if tc.expectedBranch != "" {
require.Equal(t, tc.expectedBranch, opts.repoBranch)
}
}
})
}
}
func TestInitPipelineOpts_Execute(t *testing.T) {
const (
wantedName = "mypipe"
wantedManifestFile = "/pipelines/mypipe/manifest.yml"
wantedManifestRelPath = "/copilot/pipelines/mypipe/manifest.yml"
wantedBuildspecFile = "/pipelines/mypipe/buildspec.yml"
wantedBuildspecRelPath = "/copilot/pipelines/mypipe/buildspec.yml"
)
buildspecExistsErr := &workspace.ErrFileExists{FileName: wantedBuildspecFile}
manifestExistsErr := &workspace.ErrFileExists{FileName: wantedManifestFile}
testCases := map[string]struct {
inName string
inEnvironments []string
inEnvConfigs []*config.Environment
inGitHubToken string
inRepoURL string
inBranch string
inAppName string
inType string
setupMocks func(m pipelineInitMocks)
buffer bytes.Buffer
expectedError error
}{
"creates secret and writes manifest and buildspec for GHV1 provider": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("some-arn", nil)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return(wantedBuildspecFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: nil,
},
"writes workloads pipeline manifest and buildspec for GH(v2) provider": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return(wantedBuildspecFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: nil,
},
"writes workloads pipeline manifest and buildspec for CC provider": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inRepoURL: "https://git-codecommit.us-west-2.amazonaws.com/v1/repos/goose",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return(wantedBuildspecFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
m.sessProvider.EXPECT().Default().Return(&session.Session{
Config: &aws.Config{
Region: aws.String("us-west-2"),
},
}, nil)
},
expectedError: nil,
},
"writes workloads pipeline manifest and buildspec for BB provider": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inRepoURL: "https://[email protected]/badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return(wantedBuildspecFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: nil,
},
"writes environments pipeline manifest for GH(v2) provider": {
inName: wantedName,
inType: pipelineTypeEnvironments,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return(wantedBuildspecFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(environmentsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: nil,
},
"does not return an error if secret already exists": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
existsErr := &secretsmanager.ErrSecretAlreadyExists{}
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("", existsErr)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return(wantedBuildspecFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: nil,
},
"returns an error if can't write manifest": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("some-arn", nil)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return("", errors.New("some error"))
},
expectedError: errors.New("write pipeline manifest to workspace: some error"),
},
"returns an error if application cannot be retrieved": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("some-arn", nil)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.store.EXPECT().GetApplication("badgoose").Return(nil, errors.New("some error"))
},
expectedError: errors.New("get application badgoose: some error"),
},
"returns an error if can't get regional application resources": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("some-arn", nil)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return(nil, errors.New("some error"))
},
expectedError: fmt.Errorf("get regional application resources: some error"),
},
"returns an error if buildspec cannot be parsed": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("some-arn", nil)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Times(0)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(nil, errors.New("some error"))
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: errors.New("some error"),
},
"does not return an error if buildspec and manifest already exists": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("some-arn", nil)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return("", manifestExistsErr)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return("", buildspecExistsErr)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: nil,
},
"returns an error if can't write buildspec": {
inName: wantedName,
inType: pipelineTypeWorkloads,
inEnvConfigs: []*config.Environment{
{
Name: "test",
},
},
inGitHubToken: "hunter2",
inRepoURL: "[email protected]:badgoose/goose.git",
inAppName: "badgoose",
setupMocks: func(m pipelineInitMocks) {
m.secretsmanager.EXPECT().CreateSecret("github-token-badgoose-goose", "hunter2").Return("some-arn", nil)
m.workspace.EXPECT().WritePipelineManifest(gomock.Any(), wantedName).Return(wantedManifestFile, nil)
m.workspace.EXPECT().Rel(wantedManifestFile).Return(wantedManifestRelPath, nil)
m.workspace.EXPECT().WritePipelineBuildspec(gomock.Any(), wantedName).Return("", errors.New("some error"))
m.parser.EXPECT().Parse(workloadsPipelineBuildspecTemplatePath, gomock.Any()).Return(&template.Content{
Buffer: bytes.NewBufferString("hello"),
}, nil)
m.store.EXPECT().GetApplication("badgoose").Return(&config.Application{
Name: "badgoose",
}, nil)
m.cfnClient.EXPECT().GetRegionalAppResources(&config.Application{
Name: "badgoose",
}).Return([]*stack.AppRegionalResources{
{
Region: "us-west-2",
S3Bucket: "gooseBucket",
},
}, nil)
},
expectedError: fmt.Errorf("write buildspec to workspace: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := pipelineInitMocks{
workspace: mocks.NewMockwsPipelineIniter(ctrl),
secretsmanager: mocks.NewMocksecretsManager(ctrl),
parser: templatemocks.NewMockParser(ctrl),
sessProvider: mocks.NewMocksessionProvider(ctrl),
cfnClient: mocks.NewMockappResourcesGetter(ctrl),
store: mocks.NewMockstore(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(mocks)
}
opts := &initPipelineOpts{
initPipelineVars: initPipelineVars{
name: tc.inName,
githubAccessToken: tc.inGitHubToken,
appName: tc.inAppName,
repoBranch: tc.inBranch,
repoURL: tc.inRepoURL,
pipelineType: tc.inType,
},
workspace: mocks.workspace,
secretsmanager: mocks.secretsmanager,
parser: mocks.parser,
sessProvider: mocks.sessProvider,
store: mocks.store,
cfnClient: mocks.cfnClient,
buffer: tc.buffer,
envConfigs: tc.inEnvConfigs,
}
// WHEN
require.NoError(t, opts.parseRepoDetails())
err := opts.Execute()
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestInitPipelineOpts_parseGitRemoteResult(t *testing.T) {
testCases := map[string]struct {
inRemoteResult string
expectedURLs []string
expectedError error
}{
"matched format": {
inRemoteResult: `badgoose [email protected]:badgoose/grit.git (fetch)
badgoose https://github.com/badgoose/cli.git (fetch)
origin https://github.com/koke/grit (fetch)
koke git://github.com/koke/grit.git (push)
https https://git-codecommit.us-west-2.amazonaws.com/v1/repos/aws-sample (fetch)
fed codecommit::us-west-2://aws-sample (fetch)
ssh ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/aws-sample (push)
bb https://[email protected]/huanjani/aws-copilot-sample-service.git (push)`,
expectedURLs: []string{"[email protected]:badgoose/grit", "https://github.com/badgoose/cli", "https://github.com/koke/grit", "git://github.com/koke/grit", "https://git-codecommit.us-west-2.amazonaws.com/v1/repos/aws-sample", "codecommit::us-west-2://aws-sample", "ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/aws-sample", "https://[email protected]/huanjani/aws-copilot-sample-service"},
},
"don't add to URL list if it is not a GitHub or CodeCommit or Bitbucket URL": {
inRemoteResult: `badgoose [email protected]/whatever (fetch)`,
expectedURLs: []string{},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
opts := &initPipelineOpts{}
// WHEN
urls, err := opts.parseGitRemoteResult(tc.inRemoteResult)
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.ElementsMatch(t, tc.expectedURLs, urls)
}
})
}
}
func TestInitPipelineGHRepoURL_parse(t *testing.T) {
testCases := map[string]struct {
inRepoURL ghRepoURL
expectedDetails ghRepoDetails
expectedError error
}{
"successfully parses name without .git suffix": {
inRepoURL: "https://github.com/badgoose/cli",
expectedDetails: ghRepoDetails{
name: "cli",
owner: "badgoose",
},
},
"successfully parses repo name with .git suffix": {
inRepoURL: "https://github.com/koke/grit.git",
expectedDetails: ghRepoDetails{
name: "grit",
owner: "koke",
},
},
"returns an error if it is not a github URL": {
inRepoURL: "https://git-codecommit.us-east-1.amazonaws.com/v1/repos/whatever",
expectedError: fmt.Errorf("unable to parse the GitHub repository owner and name from https://git-codecommit.us-east-1.amazonaws.com/v1/repos/whatever: please pass the repository URL with the format `--url https://github.com/{owner}/{repositoryName}`"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// WHEN
details, err := ghRepoURL.parse(tc.inRepoURL)
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.Equal(t, tc.expectedDetails, details)
}
})
}
}
func TestInitPipelineCCRepoURL_parse(t *testing.T) {
testCases := map[string]struct {
inRepoURL ccRepoURL
expectedDetails ccRepoDetails
expectedError error
}{
"successfully parses https url": {
inRepoURL: "https://git-codecommit.sa-east-1.amazonaws.com/v1/repos/aws-sample",
expectedDetails: ccRepoDetails{
name: "aws-sample",
region: "sa-east-1",
},
},
"successfully parses ssh url": {
inRepoURL: "ssh://git-codecommit.us-east-2.amazonaws.com/v1/repos/aws-sample",
expectedDetails: ccRepoDetails{
name: "aws-sample",
region: "us-east-2",
},
},
"successfully parses federated (GRC) url": {
inRepoURL: "codecommit::us-gov-west-1://aws-sample",
expectedDetails: ccRepoDetails{
name: "aws-sample",
region: "us-gov-west-1",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// WHEN
details, err := ccRepoURL.parse(tc.inRepoURL)
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.Equal(t, tc.expectedDetails, details)
}
})
}
}
func TestInitPipelineBBRepoURL_parse(t *testing.T) {
testCases := map[string]struct {
inRepoURL bbRepoURL
expectedDetails bbRepoDetails
expectedError error
}{
"successfully parses https url": {
inRepoURL: "https://[email protected]/huanjani/aws-copilot-sample-service",
expectedDetails: bbRepoDetails{
name: "aws-copilot-sample-service",
owner: "huanjani",
},
},
"successfully parses ssh url": {
inRepoURL: "ssh://[email protected]:huanjani/aws-copilot-sample-service",
expectedDetails: bbRepoDetails{
name: "aws-copilot-sample-service",
owner: "huanjani",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// WHEN
details, err := bbRepoURL.parse(tc.inRepoURL)
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.Equal(t, tc.expectedDetails, details)
}
})
}
}
| 1,077 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"context"
"encoding/json"
"fmt"
"io"
"os"
"sort"
"sync"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"golang.org/x/sync/errgroup"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
pipelineListAppNamePrompt = "Which application are the pipelines in?"
pipelineListAppNameHelper = "An application is a collection of related services."
pipelineListTimeout = 10 * time.Second
)
type listPipelineVars struct {
appName string
shouldOutputJSON bool
shouldShowLocalPipelines bool
}
type listPipelineOpts struct {
listPipelineVars
prompt prompter
sel configSelector
store store
w io.Writer
workspace wsPipelineGetter
pipelineLister deployedPipelineLister
newDescriber newPipelineDescriberFunc
wsAppName string
}
type newPipelineDescriberFunc func(pipeline deploy.Pipeline) (describer, error)
func newListPipelinesOpts(vars listPipelineVars) (*listPipelineOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
defaultSession, err := sessions.ImmutableProvider(sessions.UserAgentExtras("pipeline ls")).Default()
if err != nil {
return nil, fmt.Errorf("default session: %w", err)
}
var wsAppName string
if vars.shouldShowLocalPipelines {
wsAppName = tryReadingAppName()
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
return &listPipelineOpts{
listPipelineVars: vars,
pipelineLister: deploy.NewPipelineStore(rg.New(defaultSession)),
prompt: prompter,
sel: selector.NewConfigSelector(prompter, store),
store: store,
w: os.Stdout,
workspace: ws,
newDescriber: func(pipeline deploy.Pipeline) (describer, error) {
return describe.NewPipelineDescriber(pipeline, false)
},
wsAppName: wsAppName,
}, nil
}
// Ask asks for and validates fields that are required but not passed in.
func (o *listPipelineOpts) Ask() error {
if o.shouldShowLocalPipelines {
return validateWorkspaceApp(o.wsAppName, o.appName, o.store)
}
if o.appName != "" {
if _, err := o.store.GetApplication(o.appName); err != nil {
return fmt.Errorf("validate application: %w", err)
}
} else {
app, err := o.sel.Application(pipelineListAppNamePrompt, pipelineListAppNameHelper)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
}
return nil
}
// Execute writes the pipelines.
func (o *listPipelineOpts) Execute() error {
ctx, cancel := context.WithTimeout(context.Background(), pipelineListTimeout)
defer cancel()
switch {
case o.shouldShowLocalPipelines && o.shouldOutputJSON:
return o.jsonOutputLocal(ctx)
case o.shouldShowLocalPipelines:
return o.humanOutputLocal()
case o.shouldOutputJSON:
return o.jsonOutputDeployed(ctx)
}
return o.humanOutputDeployed()
}
// jsonOutputLocal prints data about all pipelines in the current workspace.
// If a local pipeline has been deployed, data from codepipeline is included.
func (o *listPipelineOpts) jsonOutputLocal(ctx context.Context) error {
local, err := o.workspace.ListPipelines()
if err != nil {
return err
}
deployed, err := getDeployedPipelines(ctx, o.appName, o.pipelineLister, o.newDescriber)
if err != nil {
return err
}
cp := make(map[string]*describe.Pipeline)
for _, pipeline := range deployed {
cp[pipeline.Name] = pipeline
}
type info struct {
Name string `json:"name"`
ManifestPath string `json:"manifestPath"`
PipelineName string `json:"pipelineName,omitempty"`
}
var out struct {
Pipelines []info `json:"pipelines"`
}
for _, pipeline := range local {
i := info{
Name: pipeline.Name,
ManifestPath: pipeline.Path,
}
if v, ok := cp[pipeline.Name]; ok {
i.PipelineName = v.Pipeline.Name
}
out.Pipelines = append(out.Pipelines, i)
}
b, err := json.Marshal(out)
if err != nil {
return fmt.Errorf("marshal pipelines: %w", err)
}
fmt.Fprintf(o.w, "%s\n", b)
return nil
}
// humanOutputLocal prints the name of all pipelines in the current workspace.
func (o *listPipelineOpts) humanOutputLocal() error {
local, err := o.workspace.ListPipelines()
if err != nil {
return err
}
for _, pipeline := range local {
fmt.Fprintln(o.w, pipeline.Name)
}
return nil
}
// jsonOutputDeployed prints data about all pipelines in the given app that have been deployed.
func (o *listPipelineOpts) jsonOutputDeployed(ctx context.Context) error {
pipelines, err := getDeployedPipelines(ctx, o.appName, o.pipelineLister, o.newDescriber)
if err != nil {
return err
}
type serializedPipelines struct {
Pipelines []*describe.Pipeline `json:"pipelines"`
}
b, err := json.Marshal(serializedPipelines{Pipelines: pipelines})
if err != nil {
return fmt.Errorf("marshal pipelines: %w", err)
}
fmt.Fprintf(o.w, "%s\n", b)
return nil
}
// humanOutputDeployed prints the name of all pipelines in the given app that have been deployed.
func (o *listPipelineOpts) humanOutputDeployed() error {
pipelines, err := o.pipelineLister.ListDeployedPipelines(o.appName)
if err != nil {
return fmt.Errorf("list deployed pipelines: %w", err)
}
sort.Slice(pipelines, func(i, j int) bool {
return pipelines[i].Name < pipelines[j].Name
})
for _, p := range pipelines {
fmt.Fprintln(o.w, p.Name)
}
return nil
}
func getDeployedPipelines(ctx context.Context, app string, lister deployedPipelineLister, newDescriber newPipelineDescriberFunc) ([]*describe.Pipeline, error) {
pipelines, err := lister.ListDeployedPipelines(app)
if err != nil {
return nil, fmt.Errorf("list deployed pipelines: %w", err)
}
var mux sync.Mutex
var res []*describe.Pipeline
g, _ := errgroup.WithContext(ctx)
for i := range pipelines {
pipeline := pipelines[i]
g.Go(func() error {
d, err := newDescriber(pipeline)
if err != nil {
return fmt.Errorf("create pipeline describer for %q: %w", pipeline.ResourceName, err)
}
info, err := d.Describe()
if err != nil {
return fmt.Errorf("describe pipeline %q: %w", pipeline.ResourceName, err)
}
p, ok := info.(*describe.Pipeline)
if !ok {
return fmt.Errorf("unexpected describer for %q: %T", pipeline.ResourceName, info)
}
mux.Lock()
defer mux.Unlock()
res = append(res, p)
return nil
})
}
if err := g.Wait(); err != nil {
return nil, err
}
sort.Slice(res, func(i, j int) bool {
return res[i].Name < res[j].Name
})
return res, nil
}
// buildPipelineListCmd builds the command for showing a list of all deployed pipelines.
func buildPipelineListCmd() *cobra.Command {
vars := listPipelineVars{}
cmd := &cobra.Command{
Use: "ls",
Short: "Lists all the deployed pipelines in an application.",
Example: `
Lists all the pipelines for the frontend application.
/code $ copilot pipeline ls -a frontend`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newListPipelinesOpts(vars)
if err != nil {
return err
}
if err := opts.Ask(); err != nil {
return err
}
return opts.Execute()
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.shouldShowLocalPipelines, localFlag, false, localPipelineFlagDescription)
return cmd
}
| 306 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/aws/codepipeline"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type pipelineListMocks struct {
prompt *mocks.Mockprompter
sel *mocks.MockconfigSelector
store *mocks.Mockstore
workspace *mocks.MockwsPipelineGetter
pipelineLister *mocks.MockdeployedPipelineLister
describer *mocks.Mockdescriber
}
func TestPipelineList_Ask(t *testing.T) {
testCases := map[string]struct {
inputApp string
inWsAppName string
shouldShowLocalPipelines bool
setupMocks func(mocks pipelineListMocks)
wantedApp string
wantedErr error
}{
"success with no flags set": {
setupMocks: func(m pipelineListMocks) {
m.sel.EXPECT().Application(pipelineListAppNamePrompt, pipelineListAppNameHelper).Return("my-app", nil)
},
wantedApp: "my-app",
wantedErr: nil,
},
"success with app flag set": {
inputApp: "my-app",
setupMocks: func(m pipelineListMocks) {
m.store.EXPECT().GetApplication("my-app").Return(nil, nil)
},
wantedApp: "my-app",
wantedErr: nil,
},
"error if fail to select app": {
setupMocks: func(m pipelineListMocks) {
m.sel.EXPECT().Application(pipelineListAppNamePrompt, pipelineListAppNameHelper).Return("", errors.New("some error"))
},
wantedApp: "my-app",
wantedErr: fmt.Errorf("select application: some error"),
},
"error if passed-in app doesn't exist": {
inputApp: "my-app",
setupMocks: func(m pipelineListMocks) {
m.store.EXPECT().GetApplication("my-app").Return(nil, errors.New("some error"))
},
wantedApp: "",
wantedErr: errors.New("validate application: some error"),
},
"using workspace successful": {
inWsAppName: "my-app",
setupMocks: func(m pipelineListMocks) {
m.store.EXPECT().GetApplication("my-app").Return(nil, nil)
},
shouldShowLocalPipelines: true,
},
"--local not in workspace": {
inWsAppName: "",
shouldShowLocalPipelines: true,
wantedErr: errNoAppInWorkspace,
},
"--local workspace and app name mismatch": {
inWsAppName: "my-app",
inputApp: "not-my-app",
shouldShowLocalPipelines: true,
wantedErr: errors.New("cannot specify app not-my-app because the workspace is already registered with app my-app"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := pipelineListMocks{
prompt: mocks.NewMockprompter(ctrl),
sel: mocks.NewMockconfigSelector(ctrl),
store: mocks.NewMockstore(ctrl),
workspace: mocks.NewMockwsPipelineGetter(ctrl),
pipelineLister: mocks.NewMockdeployedPipelineLister(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(mocks)
}
opts := &listPipelineOpts{
listPipelineVars: listPipelineVars{
appName: tc.inputApp,
shouldShowLocalPipelines: tc.shouldShowLocalPipelines,
},
prompt: mocks.prompt,
sel: mocks.sel,
store: mocks.store,
workspace: mocks.workspace,
pipelineLister: mocks.pipelineLister,
wsAppName: tc.inWsAppName,
}
err := opts.Ask()
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, opts.appName, "expected app names to match")
}
})
}
}
func TestPipelineList_Execute(t *testing.T) {
const (
mockAppName = "coolapp"
mockPipelineResourceName = "pipeline-coolapp-my-pipeline-repo-ABCDERANDOMRANDOM"
mockPipelineName = "my-pipeline-repo"
mockLegacyPipelineResourceName = "bad-goose"
mockLegacyPipelineName = "bad-goose"
)
mockPipeline := deploy.Pipeline{
AppName: mockAppName,
ResourceName: mockPipelineResourceName,
Name: mockPipelineName,
IsLegacy: false,
}
mockLegacyPipeline := deploy.Pipeline{
AppName: mockAppName,
ResourceName: mockLegacyPipelineResourceName,
Name: mockLegacyPipelineName,
IsLegacy: true,
}
mockError := errors.New("mock error")
testCases := map[string]struct {
shouldOutputJSON bool
shouldShowLocalPipelines bool
setupMocks func(m pipelineListMocks)
expectedContent string
expectedErr error
}{
"with JSON output": {
shouldOutputJSON: true,
setupMocks: func(m pipelineListMocks) {
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline, mockLegacyPipeline}, nil)
m.describer.EXPECT().Describe().Return(&describe.Pipeline{
Name: mockLegacyPipelineName,
Pipeline: codepipeline.Pipeline{
Name: mockLegacyPipelineResourceName,
},
}, nil)
m.describer.EXPECT().Describe().Return(&describe.Pipeline{
Name: mockPipelineName,
Pipeline: codepipeline.Pipeline{
Name: mockPipelineResourceName,
},
}, nil)
},
expectedContent: `{"pipelines":[{"name":"bad-goose","pipelineName":"bad-goose","region":"","accountId":"","stages":null,"createdAt":"0001-01-01T00:00:00Z","updatedAt":"0001-01-01T00:00:00Z"},{"name":"my-pipeline-repo","pipelineName":"pipeline-coolapp-my-pipeline-repo-ABCDERANDOMRANDOM","region":"","accountId":"","stages":null,"createdAt":"0001-01-01T00:00:00Z","updatedAt":"0001-01-01T00:00:00Z"}]}` + "\n",
},
"with human output": {
setupMocks: func(m pipelineListMocks) {
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline, mockLegacyPipeline}, nil)
},
expectedContent: `bad-goose
my-pipeline-repo
`,
},
"with failed call to list pipelines": {
shouldOutputJSON: true,
setupMocks: func(m pipelineListMocks) {
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return(nil, mockError)
},
expectedErr: fmt.Errorf("list deployed pipelines: mock error"),
},
"with failed call to get pipeline info": {
shouldOutputJSON: true,
setupMocks: func(m pipelineListMocks) {
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline}, nil)
m.describer.EXPECT().Describe().Return(nil, mockError)
},
expectedErr: fmt.Errorf(`describe pipeline %q: mock error`, mockPipelineResourceName),
},
"ls --local": {
shouldShowLocalPipelines: true,
setupMocks: func(m pipelineListMocks) {
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{{Name: mockLegacyPipeline.Name}, {Name: mockPipeline.Name}}, nil)
},
expectedContent: `bad-goose
my-pipeline-repo
`,
},
"ls --local --json with one deployed, one local": {
shouldShowLocalPipelines: true,
shouldOutputJSON: true,
setupMocks: func(m pipelineListMocks) {
m.workspace.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{
{Name: mockLegacyPipeline.Name, Path: "/copilot/pipeline.yml"},
{Name: mockPipeline.Name, Path: "/copilot/pipelines/my-pipeline-repo/manifest.yml"}}, nil)
m.pipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{mockPipeline}, nil)
m.describer.EXPECT().Describe().Return(&describe.Pipeline{
Name: mockPipelineName,
Pipeline: codepipeline.Pipeline{
Name: mockPipelineResourceName,
},
}, nil)
},
expectedContent: `{"pipelines":[{"name":"bad-goose","manifestPath":"/copilot/pipeline.yml"},{"name":"my-pipeline-repo","manifestPath":"/copilot/pipelines/my-pipeline-repo/manifest.yml","pipelineName":"pipeline-coolapp-my-pipeline-repo-ABCDERANDOMRANDOM"}]}` + "\n",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := pipelineListMocks{
prompt: mocks.NewMockprompter(ctrl),
sel: mocks.NewMockconfigSelector(ctrl),
store: mocks.NewMockstore(ctrl),
workspace: mocks.NewMockwsPipelineGetter(ctrl),
pipelineLister: mocks.NewMockdeployedPipelineLister(ctrl),
describer: mocks.NewMockdescriber(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(mocks)
}
b := &bytes.Buffer{}
opts := &listPipelineOpts{
listPipelineVars: listPipelineVars{
appName: mockAppName,
shouldOutputJSON: tc.shouldOutputJSON,
shouldShowLocalPipelines: tc.shouldShowLocalPipelines,
},
prompt: mocks.prompt,
sel: mocks.sel,
store: mocks.store,
w: b,
workspace: mocks.workspace,
pipelineLister: mocks.pipelineLister,
newDescriber: func(pipeline deploy.Pipeline) (describer, error) {
return mocks.describer, nil
},
}
// WHEN
err := opts.Execute()
// THEN
if tc.expectedErr != nil {
require.EqualError(t, err, tc.expectedErr.Error())
} else {
require.Equal(t, tc.expectedContent, b.String())
}
})
}
}
| 278 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"encoding/json"
"fmt"
"io"
"path/filepath"
"github.com/aws/copilot-cli/internal/pkg/cli/list"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/manifest"
)
type packagePipelineVars struct {
name string
appName string
}
type packagePipelineOpts struct {
packagePipelineVars
pipelineDeployer pipelineDeployer
tmplWriter io.WriteCloser
ws wsPipelineReader
codestar codestar
store store
pipelineStackConfig func(in *deploy.CreatePipelineInput) pipelineStackConfig
configureDeployedPipelineLister func() deployedPipelineLister
newSvcListCmd func(io.Writer, string) cmd
newJobListCmd func(io.Writer, string) cmd
//catched variables
pipelineMft *manifest.Pipeline
app *config.Application
svcBuffer *bytes.Buffer
jobBuffer *bytes.Buffer
}
func (o *packagePipelineOpts) Execute() error {
pipelines, err := o.ws.ListPipelines()
if err != nil {
return fmt.Errorf("list all pipelines in the workspace: %w", err)
}
var pipelinePath string
for _, pipeline := range pipelines {
if pipeline.Name == o.name {
pipelinePath = pipeline.Path
break
}
}
if pipelinePath == "" {
return fmt.Errorf("pipeline %q not found", o.name)
}
pipelineMft, err := o.getPipelineMft(pipelinePath)
if err != nil {
return err
}
connection, ok := pipelineMft.Source.Properties["connection_name"]
if ok {
arn, err := o.codestar.GetConnectionARN((connection).(string))
if err != nil {
return fmt.Errorf("get connection ARN: %w", err)
}
pipelineMft.Source.Properties["connection_arn"] = arn
}
source, _, err := deploy.PipelineSourceFromManifest(pipelineMft.Source)
if err != nil {
return fmt.Errorf("read source from manifest: %w", err)
}
relPath, err := o.ws.Rel(pipelinePath)
if err != nil {
return fmt.Errorf("convert manifest path to relative path: %w", err)
}
stages, err := o.convertStages(pipelineMft.Stages)
if err != nil {
return fmt.Errorf("convert environments to deployment stage: %w", err)
}
appConfig, err := o.store.GetApplication(o.appName)
if err != nil {
return fmt.Errorf("get application %s configuration: %w", o.appName, err)
}
o.app = appConfig
artifactBuckets, err := o.getArtifactBuckets()
if err != nil {
return fmt.Errorf("get cross-regional resources: %w", err)
}
isLegacy, err := o.isLegacy(pipelineMft.Name)
if err != nil {
return err
}
var build deploy.Build
if err = build.Init(pipelineMft.Build, filepath.Dir(relPath)); err != nil {
return err
}
deployPipelineInput := &deploy.CreatePipelineInput{
AppName: o.appName,
Name: o.name,
IsLegacy: isLegacy,
Source: source,
Build: &build,
Stages: stages,
ArtifactBuckets: artifactBuckets,
AdditionalTags: o.app.Tags,
PermissionsBoundary: o.app.PermissionsBoundary,
}
tpl, err := o.pipelineStackConfig(deployPipelineInput).Template()
if err != nil {
return fmt.Errorf("generate stack template: %w", err)
}
if _, err := o.tmplWriter.Write([]byte(tpl)); err != nil {
return err
}
o.tmplWriter.Close()
return nil
}
func (o *packagePipelineOpts) getPipelineMft(pipelinePath string) (*manifest.Pipeline, error) {
if o.pipelineMft != nil {
return o.pipelineMft, nil
}
pipelineMft, err := o.ws.ReadPipelineManifest(pipelinePath)
if err != nil {
return nil, fmt.Errorf("read pipeline manifest: %w", err)
}
if err := pipelineMft.Validate(); err != nil {
return nil, fmt.Errorf("validate pipeline manifest: %w", err)
}
o.pipelineMft = pipelineMft
return pipelineMft, nil
}
func (o *packagePipelineOpts) isLegacy(inputName string) (bool, error) {
lister := o.configureDeployedPipelineLister()
pipelines, err := lister.ListDeployedPipelines(o.appName)
if err != nil {
return false, fmt.Errorf("list deployed pipelines for app %s: %w", o.appName, err)
}
for _, pipeline := range pipelines {
if pipeline.ResourceName == inputName {
return pipeline.IsLegacy, nil
}
}
return false, nil
}
func (o *packagePipelineOpts) convertStages(manifestStages []manifest.PipelineStage) ([]deploy.PipelineStage, error) {
var stages []deploy.PipelineStage
workloads, err := o.getLocalWorkloads()
if err != nil {
return nil, err
}
for _, stage := range manifestStages {
env, err := o.store.GetEnvironment(o.appName, stage.Name)
if err != nil {
return nil, fmt.Errorf("get environment %s in application %s: %w", stage.Name, o.appName, err)
}
var stg deploy.PipelineStage
stg.Init(env, &stage, workloads)
stages = append(stages, stg)
}
return stages, nil
}
func (o packagePipelineOpts) getLocalWorkloads() ([]string, error) {
var localWklds []string
if err := o.newSvcListCmd(o.svcBuffer, o.appName).Execute(); err != nil {
return nil, fmt.Errorf("get local services: %w", err)
}
if err := o.newJobListCmd(o.jobBuffer, o.appName).Execute(); err != nil {
return nil, fmt.Errorf("get local jobs: %w", err)
}
svcOutput, jobOutput := &list.ServiceJSONOutput{}, &list.JobJSONOutput{}
if err := json.Unmarshal(o.svcBuffer.Bytes(), svcOutput); err != nil {
return nil, fmt.Errorf("unmarshal service list output; %w", err)
}
for _, svc := range svcOutput.Services {
localWklds = append(localWklds, svc.Name)
}
if err := json.Unmarshal(o.jobBuffer.Bytes(), jobOutput); err != nil {
return nil, fmt.Errorf("unmarshal job list output; %w", err)
}
for _, job := range jobOutput.Jobs {
localWklds = append(localWklds, job.Name)
}
return localWklds, nil
}
func (o *packagePipelineOpts) getArtifactBuckets() ([]deploy.ArtifactBucket, error) {
regionalResources, err := o.pipelineDeployer.GetRegionalAppResources(o.app)
if err != nil {
return nil, err
}
var buckets []deploy.ArtifactBucket
for _, resource := range regionalResources {
bucket := deploy.ArtifactBucket{
BucketName: resource.S3Bucket,
KeyArn: resource.KMSKeyARN,
}
buckets = append(buckets, bucket)
}
return buckets, nil
}
| 225 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"io"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type packagePipelineMocks struct {
store *mocks.Mockstore
prompt *mocks.Mockprompter
prog *mocks.Mockprogress
deployer *mocks.MockpipelineDeployer
pipelineStackConfig *mocks.MockpipelineStackConfig
ws *mocks.MockwsPipelineReader
actionCmd *mocks.MockactionCommand
deployedPipelineLister *mocks.MockdeployedPipelineLister
}
func TestPipelinePackageOpts_Execute(t *testing.T) {
const (
appName = "badgoose"
region = "us-west-2"
accountID = "123456789012"
pipelineName = "pipepiper"
badPipelineName = "pipeline-badgoose-honkpipes"
pipelineManifestPath = "someStuff/someMoreStuff/aws-copilot-sample-service/copilot/pipelines/pipepiper/manifest.yml"
relativePath = "/copilot/pipelines/pipepiper/manifest.yml"
)
pipeline := workspace.PipelineManifest{
Name: pipelineName,
Path: pipelineManifestPath,
}
mockPipelineManifest := &manifest.Pipeline{
Name: "pipepiper",
Version: 1,
Source: &manifest.Source{
ProviderName: "GitHub",
Properties: map[string]interface{}{
"repository": "aws/somethingCool",
"branch": "main",
},
},
Stages: []manifest.PipelineStage{
{
Name: "chicken",
TestCommands: []string{"make test", "echo 'made test'"},
},
{
Name: "wings",
TestCommands: []string{"echo 'bok bok bok'"},
},
},
}
mockResources := []*stack.AppRegionalResources{
{
S3Bucket: "someBucket",
KMSKeyARN: "someKey",
},
}
mockEnv := &config.Environment{
Name: "test",
App: appName,
Region: region,
AccountID: accountID,
}
var someError = errors.New("some error")
testCases := map[string]struct {
callMocks func(m packagePipelineMocks)
expectedError error
}{
"returns an error if fail to get the list of pipelines": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return(nil, someError),
)
},
expectedError: fmt.Errorf("list all pipelines in the workspace: some error"),
},
"returns an error if fail to read pipeline file": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, someError),
)
},
expectedError: fmt.Errorf("read pipeline manifest: some error"),
},
"returns an error if unable to unmarshal pipeline file": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(nil, someError),
)
},
expectedError: fmt.Errorf("read pipeline manifest: some error"),
},
"returns an error if pipeline name fails validation": {
callMocks: func(m packagePipelineMocks) {
mockBadPipelineManifest := &manifest.Pipeline{
Name: "12345678101234567820123456783012345678401234567850123456786012345678701234567880123456789012345671001",
Version: 1,
Source: &manifest.Source{
ProviderName: "GitHub",
Properties: map[string]interface{}{
"repository": "aws/somethingCool",
"branch": "main",
},
},
}
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockBadPipelineManifest, nil),
)
},
expectedError: fmt.Errorf("validate pipeline manifest: pipeline name '12345678101234567820123456783012345678401234567850123456786012345678701234567880123456789012345671001' must be shorter than 100 characters"),
},
"returns an error if provider is not a supported type": {
callMocks: func(m packagePipelineMocks) {
mockBadPipelineManifest := &manifest.Pipeline{
Name: badPipelineName,
Version: 1,
Source: &manifest.Source{
ProviderName: "NotGitHub",
Properties: map[string]interface{}{
"access_token_secret": "github-token-badgoose-backend",
"repository": "aws/somethingCool",
"branch": "main",
},
},
}
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockBadPipelineManifest, nil),
)
},
expectedError: fmt.Errorf("read source from manifest: invalid repo source provider: NotGitHub"),
},
"returns an error while converting manifest path to relative path from workspace root": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return("", someError),
)
},
expectedError: fmt.Errorf("convert manifest path to relative path: some error"),
},
"returns an error if unable to convert environments to deployment stage": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Return(someError),
)
},
expectedError: fmt.Errorf("convert environments to deployment stage: get local services: some error"),
},
"returns an error if fails to fetch an application": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetApplication(appName).Return(nil, someError),
)
},
expectedError: fmt.Errorf("get application %v configuration: some error", appName),
},
"returns an error if fails to get cross-regional resources": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetApplication(appName).Return(&config.Application{
Name: appName,
}, nil),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, someError),
)
},
expectedError: fmt.Errorf("get cross-regional resources: some error"),
},
"error if failed to generate the template": {
callMocks: func(m packagePipelineMocks) {
gomock.InOrder(
m.ws.EXPECT().ListPipelines().Return([]workspace.PipelineManifest{pipeline}, nil),
m.ws.EXPECT().ReadPipelineManifest(pipelineManifestPath).Return(mockPipelineManifest, nil),
m.ws.EXPECT().Rel(pipelineManifestPath).Return(relativePath, nil),
m.actionCmd.EXPECT().Execute().Times(2),
// convertStages
m.store.EXPECT().GetEnvironment(appName, "chicken").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetEnvironment(appName, "wings").Return(mockEnv, nil).Times(1),
m.store.EXPECT().GetApplication(appName).Return(&config.Application{
Name: appName,
}, nil),
// getArtifactBuckets
m.deployer.EXPECT().GetRegionalAppResources(gomock.Any()).Return(mockResources, nil),
// check if the pipeline has been deployed using a legacy naming.
m.deployedPipelineLister.EXPECT().ListDeployedPipelines(appName).Return([]deploy.Pipeline{}, nil),
m.pipelineStackConfig.EXPECT().Template().Return("", someError),
)
},
expectedError: fmt.Errorf("generate stack template: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockPipelineDeployer := mocks.NewMockpipelineDeployer(ctrl)
mockStore := mocks.NewMockstore(ctrl)
mockWorkspace := mocks.NewMockwsPipelineReader(ctrl)
mockProgress := mocks.NewMockprogress(ctrl)
mockPrompt := mocks.NewMockprompter(ctrl)
mockActionCmd := mocks.NewMockactionCommand(ctrl)
mockPipelineStackConfig := mocks.NewMockpipelineStackConfig(ctrl)
mocks := packagePipelineMocks{
store: mockStore,
prompt: mockPrompt,
prog: mockProgress,
deployer: mockPipelineDeployer,
ws: mockWorkspace,
actionCmd: mockActionCmd,
pipelineStackConfig: mockPipelineStackConfig,
deployedPipelineLister: mocks.NewMockdeployedPipelineLister(ctrl),
}
tc.callMocks(mocks)
opts := &packagePipelineOpts{
packagePipelineVars: packagePipelineVars{
appName: appName,
name: pipelineName,
},
pipelineDeployer: mockPipelineDeployer,
pipelineStackConfig: func(in *deploy.CreatePipelineInput) pipelineStackConfig {
return mockPipelineStackConfig
},
ws: mockWorkspace,
store: mockStore,
newSvcListCmd: func(w io.Writer, app string) cmd {
return mockActionCmd
},
newJobListCmd: func(w io.Writer, app string) cmd {
return mockActionCmd
},
configureDeployedPipelineLister: func() deployedPipelineLister {
return mocks.deployedPipelineLister
},
svcBuffer: bytes.NewBufferString(`{"services":[{"app":"badgoose","name":"frontend","type":""}]}`),
jobBuffer: bytes.NewBufferString(`{"jobs":[{"app":"badgoose","name":"backend","type":""}]}`),
}
// WHEN
err := opts.Execute()
// THEN
if tc.expectedError != nil {
require.Error(t, err)
require.Equal(t, tc.expectedError.Error(), err.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 309 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"io"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/spf13/afero"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/codepipeline"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/cobra"
)
const (
pipelineShowAppNamePrompt = "Which application's pipelines would you like to show?"
pipelineShowAppNameHelpPrompt = "An application is a collection of related services."
fmtPipelineShowPrompt = "Which deployed pipeline of application %s would you like to show the details of?"
)
type showPipelineVars struct {
appName string
name string
shouldOutputJSON bool
shouldOutputResources bool
}
type showPipelineOpts struct {
showPipelineVars
// Interfaces to dependencies
w io.Writer
ws wsPipelineReader
store applicationStore
codepipeline pipelineGetter
describer describer
initDescriber func(bool) error
sel codePipelineSelector
deployedPipelineLister deployedPipelineLister
prompt prompter
// Cached variables.
targetPipeline *deploy.Pipeline
}
func newShowPipelineOpts(vars showPipelineVars) (*showPipelineOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
defaultSession, err := sessions.ImmutableProvider(sessions.UserAgentExtras("pipeline show")).Default()
if err != nil {
return nil, fmt.Errorf("default session: %w", err)
}
codepipeline := codepipeline.New(defaultSession)
pipelineLister := deploy.NewPipelineStore(rg.New(defaultSession))
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
opts := &showPipelineOpts{
showPipelineVars: vars,
ws: ws,
store: store,
codepipeline: codepipeline,
deployedPipelineLister: pipelineLister,
sel: selector.NewAppPipelineSelector(prompter, store, pipelineLister),
prompt: prompter,
w: log.OutputWriter,
}
opts.initDescriber = func(enableResources bool) error {
pipeline, err := opts.getTargetPipeline()
if err != nil {
return err
}
describer, err := describe.NewPipelineDescriber(pipeline, enableResources)
if err != nil {
return fmt.Errorf("new pipeline describer: %w", err)
}
opts.describer = describer
return nil
}
return opts, nil
}
// Validate returns an error if the optional flag values passed by the user are invalid.
func (o *showPipelineOpts) Validate() error {
return nil
}
// Ask prompts for fields that are required but not passed in, and validates those that are.
func (o *showPipelineOpts) Ask() error {
if o.appName != "" {
if _, err := o.store.GetApplication(o.appName); err != nil {
return fmt.Errorf("validate application name: %w", err)
}
} else {
if err := o.askAppName(); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.getTargetPipeline(); err != nil {
return fmt.Errorf("validate pipeline name %s: %w", o.name, err)
}
return nil
}
pipeline, err := askDeployedPipelineName(o.sel, fmt.Sprintf(fmtPipelineShowPrompt, color.HighlightUserInput(o.appName)), o.appName)
if err != nil {
return err
}
o.name = pipeline.Name
o.targetPipeline = &pipeline
return nil
}
// Execute shows details about the pipeline.
func (o *showPipelineOpts) Execute() error {
err := o.initDescriber(o.shouldOutputResources)
if err != nil {
return err
}
pipeline, err := o.describer.Describe()
if err != nil {
return fmt.Errorf("describe pipeline %s: %w", o.name, err)
}
if o.shouldOutputJSON {
data, err := pipeline.JSONString()
if err != nil {
return err
}
fmt.Fprint(o.w, data)
} else {
fmt.Fprint(o.w, pipeline.HumanString())
}
return nil
}
func (o *showPipelineOpts) getTargetPipeline() (deploy.Pipeline, error) {
if o.targetPipeline != nil {
return *o.targetPipeline, nil
}
pipeline, err := getDeployedPipelineInfo(o.deployedPipelineLister, o.appName, o.name)
if err != nil {
return deploy.Pipeline{}, err
}
o.targetPipeline = &pipeline
return pipeline, nil
}
func (o *showPipelineOpts) askAppName() error {
name, err := o.sel.Application(pipelineShowAppNamePrompt, pipelineShowAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = name
return nil
}
// buildPipelineShowCmd build the command for deploying a new pipeline or updating an existing pipeline.
func buildPipelineShowCmd() *cobra.Command {
vars := showPipelineVars{}
cmd := &cobra.Command{
Use: "show",
Short: "Shows info about a deployed pipeline for an application.",
Long: "Shows info about a deployed pipeline for an application, including information about each stage.",
Example: `
Shows info, including resources, about the pipeline "myrepo-mybranch."
/code $ copilot pipeline show --name myrepo-mybranch --resources`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newShowPipelineOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", pipelineFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputResources, resourcesFlag, false, pipelineResourcesFlagDescription)
return cmd
}
| 204 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type showPipelineMocks struct {
store *mocks.Mockstore
ws *mocks.MockwsPipelineReader
prompt *mocks.Mockprompter
codepipeline *mocks.MockpipelineGetter
sel *mocks.MockcodePipelineSelector
deployedPipelineLister *mocks.MockdeployedPipelineLister
}
func TestPipelineShow_Ask(t *testing.T) {
const (
mockAppName = "dinder"
mockPipelineName = "pipeline-dinder-badgoose-repo"
)
mockError := errors.New("mock error")
testCases := map[string]struct {
inAppName string
inPipelineName string
setupMocks func(mocks showPipelineMocks)
expectedApp string
expectedPipeline string
expectedErr error
}{
"with valid application name via flag, no pipeline name flag": {
inAppName: mockAppName,
setupMocks: func(mocks showPipelineMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil),
mocks.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), mockAppName).Return(deploy.Pipeline{
Name: mockPipelineName,
AppName: mockAppName,
}, nil),
)
},
expectedApp: mockAppName,
expectedPipeline: mockPipelineName,
expectedErr: nil,
},
"error if problem selecting app": {
setupMocks: func(mocks showPipelineMocks) {
gomock.InOrder(
mocks.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Return("", mockError))
},
expectedErr: fmt.Errorf("select application: %w", mockError),
},
"with pipeline flag": {
inPipelineName: mockPipelineName,
inAppName: mockAppName,
setupMocks: func(mocks showPipelineMocks) {
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil)
mocks.deployedPipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{
{
Name: mockPipelineName,
},
}, nil)
},
expectedApp: mockAppName,
expectedPipeline: mockPipelineName,
expectedErr: nil,
},
"prompt if no app name AND no pipeline name": {
setupMocks: func(mocks showPipelineMocks) {
gomock.InOrder(
mocks.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Return(mockAppName, nil))
mocks.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), mockAppName).Return(deploy.Pipeline{
Name: mockPipelineName,
}, nil)
},
expectedApp: mockAppName,
expectedPipeline: mockPipelineName,
expectedErr: nil,
},
"error if invalid name passed in": {
inPipelineName: "dander",
inAppName: mockAppName,
setupMocks: func(mocks showPipelineMocks) {
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil)
mocks.deployedPipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, nil)
},
expectedApp: mockAppName,
expectedErr: errors.New("validate pipeline name dander: cannot find pipeline named dander"),
},
"error occurs when listing deployed pipelines for validation": {
inPipelineName: "dander",
inAppName: mockAppName,
setupMocks: func(mocks showPipelineMocks) {
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil)
mocks.deployedPipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{}, errors.New("some error"))
},
expectedApp: mockAppName,
expectedErr: errors.New("validate pipeline name dander: list deployed pipelines: some error"),
},
"wraps error when fails to retrieve deployed pipelines to select": {
inAppName: mockAppName,
inPipelineName: "",
setupMocks: func(mocks showPipelineMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil),
mocks.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), mockAppName).Return(deploy.Pipeline{}, mockError),
)
},
expectedErr: fmt.Errorf("select deployed pipelines: %w", mockError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
mockWorkspace := mocks.NewMockwsPipelineReader(ctrl)
mockPrompt := mocks.NewMockprompter(ctrl)
mockPipelineSvc := mocks.NewMockpipelineGetter(ctrl)
mockSel := mocks.NewMockcodePipelineSelector(ctrl)
mockDeployedPipelineLister := mocks.NewMockdeployedPipelineLister(ctrl)
mocks := showPipelineMocks{
store: mockStore,
ws: mockWorkspace,
prompt: mockPrompt,
codepipeline: mockPipelineSvc,
sel: mockSel,
deployedPipelineLister: mockDeployedPipelineLister,
}
tc.setupMocks(mocks)
opts := &showPipelineOpts{
showPipelineVars: showPipelineVars{
appName: tc.inAppName,
name: tc.inPipelineName,
},
store: mockStore,
ws: mockWorkspace,
codepipeline: mockPipelineSvc,
prompt: mockPrompt,
sel: mockSel,
deployedPipelineLister: mockDeployedPipelineLister,
}
// WHEN
err := opts.Ask()
// THEN
if tc.expectedErr != nil {
require.EqualError(t, err, tc.expectedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.expectedPipeline, opts.name, "expected pipeline name to match")
}
})
}
}
func TestPipelineShow_Execute(t *testing.T) {
const (
mockPipelineName = "pipeline-dinder-badgoose-repo"
)
mockError := errors.New("mock error")
mockPipeline := mockDescribeData{
data: "mockData",
err: mockError,
}
testCases := map[string]struct {
inPipelineName string
setupMocks func(m *mocks.Mockdescriber)
shouldOutputJSON bool
expectedContent string
expectedErr error
}{
"happy path": {
inPipelineName: mockPipelineName,
setupMocks: func(m *mocks.Mockdescriber) {
m.EXPECT().Describe().Return(&mockPipeline, nil)
},
shouldOutputJSON: false,
expectedContent: "mockData",
expectedErr: nil,
},
"return error if fail to generate JSON output": {
inPipelineName: mockPipelineName,
setupMocks: func(m *mocks.Mockdescriber) {
m.EXPECT().Describe().Return(&mockPipeline, nil)
},
shouldOutputJSON: true,
expectedErr: mockError,
},
"return error if fail to describe pipeline": {
inPipelineName: mockPipelineName,
setupMocks: func(m *mocks.Mockdescriber) {
m.EXPECT().Describe().Return(nil, mockError)
},
shouldOutputJSON: false,
expectedErr: fmt.Errorf("describe pipeline %s: %w", mockPipelineName, mockError),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
b := &bytes.Buffer{}
mockDescriber := mocks.NewMockdescriber(ctrl)
tc.setupMocks(mockDescriber)
opts := &showPipelineOpts{
showPipelineVars: showPipelineVars{
shouldOutputJSON: tc.shouldOutputJSON,
name: tc.inPipelineName,
},
describer: mockDescriber,
initDescriber: func(bool) error { return nil },
w: b,
}
// WHEN
err := opts.Execute()
// THEN
if tc.expectedErr != nil {
require.EqualError(t, err, tc.expectedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.expectedContent, b.String(), "expected output content match")
}
})
}
}
| 270 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"io"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/spf13/afero"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/codepipeline"
rg "github.com/aws/copilot-cli/internal/pkg/aws/resourcegroups"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/cobra"
)
const (
pipelineStatusAppNamePrompt = "Which application's pipeline status would you like to show?"
pipelineStatusAppNameHelpPrompt = "An application is a collection of related services."
fmtpipelineStatusPrompt = "Which pipeline of %s would you like to show the status of?"
)
type pipelineStatusVars struct {
appName string
shouldOutputJSON bool
name string
}
type pipelineStatusOpts struct {
pipelineStatusVars
w io.Writer
ws wsPipelineReader
store store
codepipeline pipelineGetter
describer describer
sel codePipelineSelector
prompt prompter
initDescriber func(opts *pipelineStatusOpts) error
deployedPipelineLister deployedPipelineLister
// Cached variables.
targetPipeline *deploy.Pipeline
}
func newPipelineStatusOpts(vars pipelineStatusVars) (*pipelineStatusOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
session, err := sessions.ImmutableProvider(sessions.UserAgentExtras("pipeline status")).Default()
if err != nil {
return nil, fmt.Errorf("session: %w", err)
}
codepipeline := codepipeline.New(session)
pipelineLister := deploy.NewPipelineStore(rg.New(session))
store := config.NewSSMStore(identity.New(session), ssm.New(session), aws.StringValue(session.Config.Region))
prompter := prompt.New()
return &pipelineStatusOpts{
w: log.OutputWriter,
pipelineStatusVars: vars,
ws: ws,
store: store,
codepipeline: codepipeline,
deployedPipelineLister: pipelineLister,
sel: selector.NewAppPipelineSelector(prompter, store, pipelineLister),
prompt: prompter,
initDescriber: func(o *pipelineStatusOpts) error {
pipeline, err := o.getTargetPipeline()
if err != nil {
return err
}
d, err := describe.NewPipelineStatusDescriber(pipeline)
if err != nil {
return fmt.Errorf("new pipeline status describer: %w", err)
}
o.describer = d
return nil
},
}, nil
}
// Validate returns an error if the optional flag values provided by the user are invalid.
func (o *pipelineStatusOpts) Validate() error {
return nil
}
// Ask prompts for fields that are required but not passed in, and validates those that are.
func (o *pipelineStatusOpts) Ask() error {
if o.appName != "" {
if _, err := o.store.GetApplication(o.appName); err != nil {
return fmt.Errorf("validate application name: %w", err)
}
} else {
if err := o.askAppName(); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.getTargetPipeline(); err != nil {
return fmt.Errorf("validate pipeline name %s: %w", o.name, err)
}
return nil
}
pipeline, err := askDeployedPipelineName(o.sel, fmt.Sprintf(fmtpipelineStatusPrompt, color.HighlightUserInput(o.appName)), o.appName)
if err != nil {
return err
}
o.name = pipeline.Name
o.targetPipeline = &pipeline
return nil
}
// Execute displays the status of the pipeline.
func (o *pipelineStatusOpts) Execute() error {
err := o.initDescriber(o)
if err != nil {
return fmt.Errorf("describe status of pipeline: %w", err)
}
pipelineStatus, err := o.describer.Describe()
if err != nil {
return fmt.Errorf("describe status of pipeline: %w", err)
}
if o.shouldOutputJSON {
data, err := pipelineStatus.JSONString()
if err != nil {
return err
}
fmt.Fprint(o.w, data)
} else {
fmt.Fprint(o.w, pipelineStatus.HumanString())
}
return nil
}
func (o *pipelineStatusOpts) getTargetPipeline() (deploy.Pipeline, error) {
if o.targetPipeline != nil {
return *o.targetPipeline, nil
}
pipeline, err := getDeployedPipelineInfo(o.deployedPipelineLister, o.appName, o.name)
if err != nil {
return deploy.Pipeline{}, err
}
o.targetPipeline = &pipeline
return pipeline, nil
}
func (o *pipelineStatusOpts) askAppName() error {
name, err := o.sel.Application(pipelineStatusAppNamePrompt, pipelineStatusAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = name
return nil
}
// buildPipelineStatusCmd builds the command for showing the status of a deployed pipeline.
func buildPipelineStatusCmd() *cobra.Command {
vars := pipelineStatusVars{}
cmd := &cobra.Command{
Use: "status",
Short: "Shows the status of a pipeline.",
Long: "Shows the status of each stage of your pipeline.",
Example: `
Shows status of the pipeline "my-repo-my-branch".
/code $ copilot pipeline status -n my-repo-my-branch`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newPipelineStatusOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", pipelineFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
return cmd
}
| 200 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type pipelineStatusMocks struct {
store *mocks.Mockstore
ws *mocks.MockwsPipelineReader
prompt *mocks.Mockprompter
codepipeline *mocks.MockpipelineGetter
describer *mocks.Mockdescriber
sel *mocks.MockcodePipelineSelector
deployedPipelineLister *mocks.MockdeployedPipelineLister
}
func TestPipelineStatus_Ask(t *testing.T) {
const (
mockAppName = "dinder"
mockPipelineName = "pipeline-dinder-badgoose-repo"
)
mockError := errors.New("mock error")
mockTestCommands := []string{"make test", "echo 'honk'"}
testCases := map[string]struct {
testAppName string
testPipelineName string
setupMocks func(mocks pipelineStatusMocks)
expectedApp string
expectedPipeline string
expectedTestCommands []string
expectedErr error
}{
"with invalid app name": {
testAppName: mockAppName,
setupMocks: func(mocks pipelineStatusMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetApplication(mockAppName).Return(nil, mockError),
)
},
expectedApp: "",
expectedErr: fmt.Errorf("validate application name: %w", mockError),
},
"prompts for app name if not passed in with flag and name not passed in": {
setupMocks: func(mocks pipelineStatusMocks) {
gomock.InOrder(
mocks.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Return(mockAppName, nil),
mocks.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), mockAppName).Return(deploy.Pipeline{
Name: mockPipelineName,
}, nil),
)
},
expectedApp: mockAppName,
expectedPipeline: mockPipelineName,
expectedErr: nil,
},
"errors if fail to select app name": {
setupMocks: func(mocks pipelineStatusMocks) {
gomock.InOrder(
mocks.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Return("", errors.New("some error")))
},
expectedApp: "",
expectedErr: errors.New("select application: some error"),
},
"retrieves pipeline name from remote": {
testAppName: mockAppName,
setupMocks: func(mocks pipelineStatusMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil),
mocks.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), mockAppName).Return(deploy.Pipeline{
Name: mockPipelineName,
}, nil),
)
},
expectedApp: mockAppName,
expectedPipeline: mockPipelineName,
expectedErr: nil,
},
"wraps error when fails to retrieve pipelines": {
testAppName: mockAppName,
testPipelineName: "",
setupMocks: func(mocks pipelineStatusMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil),
mocks.sel.EXPECT().DeployedPipeline(gomock.Any(), gomock.Any(), mockAppName).Return(deploy.Pipeline{}, mockError),
)
},
expectedApp: mockAppName,
expectedErr: fmt.Errorf("select deployed pipelines: %w", mockError),
},
"success with flags": {
testAppName: mockAppName,
testPipelineName: mockPipelineName,
setupMocks: func(mocks pipelineStatusMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetApplication(mockAppName).Return(&config.Application{
Name: "dinder",
}, nil),
mocks.deployedPipelineLister.EXPECT().ListDeployedPipelines(mockAppName).Return([]deploy.Pipeline{
{
Name: mockPipelineName,
},
}, nil),
)
},
expectedApp: mockAppName,
expectedPipeline: mockPipelineName,
expectedTestCommands: mockTestCommands,
expectedErr: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
mockWS := mocks.NewMockwsPipelineReader(ctrl)
mockPrompt := mocks.NewMockprompter(ctrl)
mockPLSvc := mocks.NewMockpipelineGetter(ctrl)
mockSel := mocks.NewMockcodePipelineSelector(ctrl)
mocks := pipelineStatusMocks{
store: mockStore,
ws: mockWS,
prompt: mockPrompt,
codepipeline: mockPLSvc,
sel: mockSel,
deployedPipelineLister: mocks.NewMockdeployedPipelineLister(ctrl),
}
tc.setupMocks(mocks)
opts := &pipelineStatusOpts{
pipelineStatusVars: pipelineStatusVars{
appName: tc.testAppName,
name: tc.testPipelineName,
},
store: mockStore,
ws: mockWS,
codepipeline: mockPLSvc,
sel: mockSel,
prompt: mockPrompt,
deployedPipelineLister: mocks.deployedPipelineLister,
}
// WHEN
err := opts.Ask()
// THEN
if tc.expectedErr != nil {
require.EqualError(t, err, tc.expectedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.expectedApp, opts.appName, "expected app name to match")
require.Equal(t, tc.expectedPipeline, opts.name, "expected pipeline name to match")
}
})
}
}
func TestPipelineStatus_Execute(t *testing.T) {
const (
mockPipelineName = "pipeline-dinder-badgoose-repo"
)
mockError := errors.New("mock error")
mockPipelineStatus := mockDescribeData{
data: "mockData",
err: mockError,
}
testCases := map[string]struct {
shouldOutputJSON bool
pipelineName string
setupMocks func(m pipelineStatusMocks)
expectedContent string
expectedError error
}{
"errors if fail to return JSON output": {
pipelineName: mockPipelineName,
shouldOutputJSON: true,
setupMocks: func(m pipelineStatusMocks) {
m.describer.EXPECT().Describe().Return(&mockPipelineStatus, nil)
},
expectedError: mockError,
},
"success with HumanString": {
pipelineName: mockPipelineName,
setupMocks: func(m pipelineStatusMocks) {
m.describer.EXPECT().Describe().Return(&mockPipelineStatus, nil)
},
expectedContent: "mockData",
expectedError: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
b := &bytes.Buffer{}
mockDescriber := mocks.NewMockdescriber(ctrl)
mocks := pipelineStatusMocks{
describer: mockDescriber,
}
tc.setupMocks(mocks)
opts := &pipelineStatusOpts{
pipelineStatusVars: pipelineStatusVars{
shouldOutputJSON: tc.shouldOutputJSON,
name: tc.pipelineName,
},
describer: mockDescriber,
initDescriber: func(o *pipelineStatusOpts) error { return nil },
w: b,
}
// WHEN
err := opts.Execute()
// THEN
if tc.expectedError != nil {
require.EqualError(t, err, tc.expectedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.expectedContent, b.String(), "expected output content to match")
}
})
}
}
| 257 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
// progress is the interface to inform the user that a long operation is taking place.
type progress interface {
// Start starts displaying progress with a label.
Start(label string)
// Stop ends displaying progress with a label.
Stop(label string)
}
| 13 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import "github.com/aws/copilot-cli/internal/pkg/term/prompt"
type prompter interface {
Get(message, help string, validator prompt.ValidatorFunc, promptOpts ...prompt.PromptConfig) (string, error)
GetSecret(message, help string, promptOpts ...prompt.PromptConfig) (string, error)
SelectOne(message, help string, options []string, promptOpts ...prompt.PromptConfig) (string, error)
MultiSelect(message, help string, options []string, validator prompt.ValidatorFunc, promptOpts ...prompt.PromptConfig) ([]string, error)
Confirm(message, help string, promptOpts ...prompt.PromptConfig) (bool, error)
SelectOption(message, help string, opts []prompt.Option, promptCfgs ...prompt.PromptConfig) (value string, err error)
MultiSelectOptions(message, help string, opts []prompt.Option, promptCfgs ...prompt.PromptConfig) ([]string, error)
}
| 17 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
)
// BuildSecretCmd is the top level command for secret.
func BuildSecretCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "secret",
Short: `Commands for secrets.
Secrets are sensitive information that you need in your application.`,
}
cmd.AddCommand(buildSecretInitCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Extend,
}
return cmd
}
| 28 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"sort"
"strings"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/aws/copilot-cli/internal/pkg/describe"
"golang.org/x/text/cases"
"golang.org/x/text/language"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/dustin/go-humanize/english"
"gopkg.in/yaml.v3"
"github.com/aws/aws-sdk-go/aws"
awsssm "github.com/aws/aws-sdk-go/service/ssm"
"github.com/spf13/afero"
"github.com/spf13/cobra"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/aws/ssm"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
)
const (
fmtSecretParameterName = "/copilot/%s/%s/secrets/%s"
fmtSecretParameterNameMftExample = "/copilot/${COPILOT_APPLICATION_NAME}/${COPILOT_ENVIRONMENT_NAME}/secrets/%s"
)
const (
secretInitAppPrompt = "Which application do you want to add the secret to?"
secretInitAppPromptHelp = "The secret can then be versioned by your existing environments inside the application."
secretInitSecretNamePrompt = "What would you like to name this secret?"
secretInitSecretNamePromptHelp = "The name of the secret, such as 'db_password'."
fmtSecretInitSecretValuePrompt = "What is the value of secret %s in environment %s?"
fmtSecretInitSecretValuePromptHelp = "If you do not wish to add the secret %s to environment %s, you can leave this blank by pressing 'Enter' without entering any value."
)
type secretInitVars struct {
appName string
name string
values map[string]string
inputFilePath string
overwrite bool
}
type secretInitOpts struct {
secretInitVars
shouldShowOverwriteHint bool
secretValues map[string]map[string]string
store store
fs afero.Fs
prompter prompter
selector appSelector
ws wsEnvironmentsLister
envCompatibilityChecker map[string]versionCompatibilityChecker
secretPutters map[string]secretPutter
configureClientsForEnv func(envName string) error
readFile func() ([]byte, error)
}
func newSecretInitOpts(vars secretInitVars) (*secretInitOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("secret init"))
defaultSession, err := sessProvider.Default()
if err != nil {
return nil, err
}
fs := afero.NewOsFs()
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSession), awsssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
opts := secretInitOpts{
secretInitVars: vars,
store: store,
fs: fs,
ws: ws,
envCompatibilityChecker: make(map[string]versionCompatibilityChecker),
secretPutters: make(map[string]secretPutter),
prompter: prompter,
selector: selector.NewAppEnvSelector(prompter, store),
}
opts.configureClientsForEnv = func(envName string) error {
checker, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: opts.appName,
Env: envName,
ConfigStore: opts.store,
})
if err != nil {
return fmt.Errorf("new environment compatibility checker: %v", err)
}
opts.envCompatibilityChecker[envName] = checker
env, err := opts.targetEnv(envName)
if err != nil {
return err
}
sess, err := sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return fmt.Errorf("create session from environment manager role %s in region %s: %w", env.ManagerRoleARN, env.Region, err)
}
opts.secretPutters[envName] = ssm.New(sess)
return nil
}
opts.readFile = func() ([]byte, error) {
file, err := opts.fs.Open(opts.inputFilePath)
if err != nil {
return nil, fmt.Errorf("open input file %s: %w", opts.inputFilePath, err)
}
defer file.Close()
f, err := afero.ReadFile(opts.fs, file.Name())
if err != nil {
return nil, fmt.Errorf("read input file %s: %w", opts.inputFilePath, err)
}
return f, nil
}
return &opts, nil
}
// Validate returns an error if the flag values passed by the user are invalid.
func (o *secretInitOpts) Validate() error {
if o.inputFilePath != "" && o.name != "" {
return errors.New("cannot specify `--cli-input-yaml` with `--name`")
}
if o.inputFilePath != "" && o.values != nil {
return errors.New("cannot specify `--cli-input-yaml` with `--values`")
}
if o.appName != "" {
_, err := o.store.GetApplication(o.appName)
if err != nil {
return fmt.Errorf("get application %s: %w", o.appName, err)
}
if o.values != nil {
for env := range o.values {
if _, err := o.targetEnv(env); err != nil {
return err
}
}
}
}
if o.name != "" {
if err := validateSecretName(o.name); err != nil {
return err
}
}
if o.inputFilePath != "" {
if _, err := o.fs.Stat(o.inputFilePath); err != nil {
return err
}
}
return nil
}
// Ask prompts the user for any required or important fields that are not provided.
func (o *secretInitOpts) Ask() error {
if o.overwrite {
log.Warningf("You have specified %s flag. Please note that overwriting an existing secret may break your deployed service.\n", color.HighlightCode(fmt.Sprintf("--%s", overwriteFlag)))
}
if o.inputFilePath != "" {
return nil
}
if err := o.askForAppName(); err != nil {
return err
}
if err := o.askForSecretName(); err != nil {
return err
}
if err := o.askForSecretValues(); err != nil {
return err
}
return nil
}
// Execute creates or updates the secrets.
func (o *secretInitOpts) Execute() error {
if o.inputFilePath != "" {
secrets, err := o.parseSecretsInputFile()
if err != nil {
return err
}
o.secretValues = secrets
if err := o.configureClientsAndUpgradeForEnvironments(secrets); err != nil {
return err
}
var errs []*errSecretFailedInSomeEnvironments
for secretName, secretValues := range secrets {
if err := o.putSecret(secretName, secretValues); err != nil {
errs = append(errs, err.(*errSecretFailedInSomeEnvironments))
}
log.Infoln("")
}
if len(errs) != 0 {
return &errBatchPutSecretsFailed{
errors: errs,
}
}
return nil
}
o.secretValues = map[string]map[string]string{
o.name: o.values,
}
if err := o.configureClientsAndUpgradeForEnvironments(o.secretValues); err != nil {
return err
}
return o.putSecret(o.name, o.values)
}
func (o *secretInitOpts) configureClientsAndUpgradeForEnvironments(secrets map[string]map[string]string) error {
envNames := make(map[string]struct{})
for _, values := range secrets {
for envName := range values {
envNames[envName] = struct{}{}
}
}
const minEnvVersionForSecretInit = "v1.4.0"
for envName := range envNames {
if err := o.configureClientsForEnv(envName); err != nil {
return err
}
if err := validateMinEnvVersion(o.ws, o.envCompatibilityChecker[envName], o.appName, envName, minEnvVersionForSecretInit, "secret init"); err != nil {
return err
}
}
return nil
}
func (o *secretInitOpts) putSecret(secretName string, values map[string]string) error {
envs := make([]string, 0)
for env := range values {
envs = append(envs, env)
}
if len(envs) == 0 {
return nil
}
log.Infof("...Put secret %s to environment %s\n", color.HighlightUserInput(secretName), english.WordSeries(envs, "and"))
errorsForEnvironments := make(map[string]error)
for envName, value := range values {
err := o.putSecretInEnv(secretName, envName, value)
if err != nil {
errorsForEnvironments[envName] = err
continue
}
}
for envName := range errorsForEnvironments {
log.Errorf("Failed to put secret %s in environment %s. See error message below.\n", color.HighlightUserInput(secretName), color.HighlightUserInput(envName))
}
if len(errorsForEnvironments) != 0 {
return &errSecretFailedInSomeEnvironments{
secretName: secretName,
errorsForEnvironments: errorsForEnvironments,
}
}
return nil
}
func (o *secretInitOpts) putSecretInEnv(secretName, envName, value string) error {
name := fmt.Sprintf(fmtSecretParameterName, o.appName, envName, secretName)
in := ssm.PutSecretInput{
Name: name,
Value: value,
Overwrite: o.overwrite,
Tags: map[string]string{
deploy.AppTagKey: o.appName,
deploy.EnvTagKey: envName,
},
}
out, err := o.secretPutters[envName].PutSecret(in)
if err != nil {
var targetErr *ssm.ErrParameterAlreadyExists
if errors.As(err, &targetErr) {
o.shouldShowOverwriteHint = true
log.Successf("Secret %s already exists in environment %s as %s. Did not overwrite. \n", color.HighlightUserInput(secretName), color.HighlightUserInput(envName), color.HighlightResource(name))
return nil
}
return err
}
version := aws.Int64Value(out.Version)
if version != 1 {
log.Successln(fmt.Sprintf("Secret %s already exists in environment %s. Overwritten.", name, color.HighlightUserInput(envName)))
return nil
}
log.Successln(fmt.Sprintf("Successfully put secret %s in environment %s as %s.", color.HighlightUserInput(secretName), color.HighlightUserInput(envName), color.HighlightResource(name)))
return nil
}
func (o *secretInitOpts) parseSecretsInputFile() (map[string]map[string]string, error) {
raw, err := o.readFile()
if err != nil {
return nil, err
}
type inputFile struct {
Secrets map[string]map[string]string `yaml:",inline"`
}
var f inputFile
if err := yaml.Unmarshal(raw, &f); err != nil {
return nil, fmt.Errorf("unmarshal input file: %w", err)
}
return f.Secrets, nil
}
func (o *secretInitOpts) askForAppName() error {
if o.appName != "" {
return nil
}
app, err := o.selector.Application(secretInitAppPrompt, secretInitAppPromptHelp)
if err != nil {
return fmt.Errorf("ask for an application to add the secret to: %w", err)
}
o.appName = app
return nil
}
func (o *secretInitOpts) askForSecretName() error {
if o.name != "" {
return nil
}
name, err := o.prompter.Get(secretInitSecretNamePrompt,
secretInitSecretNamePromptHelp,
validateSecretName,
prompt.WithFinalMessage("Secret name: "))
if err != nil {
return fmt.Errorf("ask for the secret name: %w", err)
}
o.name = name
return nil
}
func (o *secretInitOpts) askForSecretValues() error {
if o.values != nil {
return nil
}
envs, err := o.store.ListEnvironments(o.appName)
if err != nil {
return fmt.Errorf("list environments in app %s: %w", o.appName, err)
}
if len(envs) == 0 {
log.Errorf("Secrets are environment-level resources. Please run %s before running %s.\n",
color.HighlightCode("copilot env init"),
color.HighlightCode("copilot secret init"))
return fmt.Errorf("no environment is found in app %s", o.appName)
}
values := make(map[string]string)
for _, env := range envs {
value, err := o.prompter.GetSecret(
fmt.Sprintf(fmtSecretInitSecretValuePrompt, color.HighlightUserInput(o.name), env.Name),
fmt.Sprintf(fmtSecretInitSecretValuePromptHelp, color.HighlightUserInput(o.name), env.Name),
prompt.WithFinalMessage(fmt.Sprintf("%s secret value:", cases.Title(language.English).String(env.Name))),
)
if err != nil {
return fmt.Errorf("get secret value for %s in environment %s: %w", color.HighlightUserInput(o.name), env.Name, err)
}
if value != "" {
values[env.Name] = value
}
}
o.values = values
return nil
}
// RecommendActions shows recommended actions to do after running `secret init`.
func (o *secretInitOpts) RecommendActions() error {
secretsManifestExample := "secrets:"
for secretName := range o.secretValues {
currSecret := fmt.Sprintf("%s: %s", secretName, fmt.Sprintf(fmtSecretParameterNameMftExample, secretName))
secretsManifestExample = fmt.Sprintf("%s\n%s", secretsManifestExample, fmt.Sprintf(" %s", currSecret))
}
log.Infoln("You can refer to these secrets from your manifest file by editing the `secrets` section.")
log.Infoln(color.HighlightCodeBlock(secretsManifestExample))
return nil
}
type errSecretFailedInSomeEnvironments struct {
secretName string
errorsForEnvironments map[string]error
}
type errBatchPutSecretsFailed struct {
errors []*errSecretFailedInSomeEnvironments
}
func (e *errSecretFailedInSomeEnvironments) Error() string {
// Sort failure messages by environment names.
var envs []string
for env := range e.errorsForEnvironments {
envs = append(envs, env)
}
sort.Strings(envs)
out := make([]string, 0)
for _, env := range envs {
out = append(out, fmt.Sprintf("put secret %s in environment %s: %s", e.secretName, env, e.errorsForEnvironments[env].Error()))
}
return strings.Join(out, "\n")
}
func (e *errSecretFailedInSomeEnvironments) name() string {
return e.secretName
}
func (e *errBatchPutSecretsFailed) Error() string {
out := []string{
"batch put secrets:",
}
sort.SliceStable(e.errors, func(i, j int) bool {
return e.errors[i].name() < e.errors[j].name()
})
for _, err := range e.errors {
out = append(out, err.Error())
}
return strings.Join(out, "\n")
}
func (o *secretInitOpts) targetEnv(envName string) (*config.Environment, error) {
env, err := o.store.GetEnvironment(o.appName, envName)
if err != nil {
return nil, fmt.Errorf("get environment %s in application %s: %w", envName, o.appName, err)
}
return env, nil
}
// buildSecretInitCmd build the command for creating a new secret or updating an existing one.
func buildSecretInitCmd() *cobra.Command {
vars := secretInitVars{}
cmd := &cobra.Command{
Use: "init",
Short: "Create or update secrets in SSM Parameter Store.",
Example: `
Create a secret with prompts.
/code $ copilot secret init
Create a secret named db-password in multiple environments.
/code $ copilot secret init --name db-password
Create secrets from input.yml. For the format of the YAML file, please see https://aws.github.io/copilot-cli/docs/commands/secret-init/.
/code $ copilot secret init --cli-input-yaml input.yml`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newSecretInitOpts(vars)
if err != nil {
return err
}
if err := opts.Validate(); err != nil {
return err
}
if err := opts.Ask(); err != nil {
return err
}
err = opts.Execute()
if opts.shouldShowOverwriteHint {
log.Warningf("If you want to overwrite an existing secret, use the %s flag.\n", color.HighlightCode(fmt.Sprintf("--%s", overwriteFlag)))
}
if err != nil {
return err
}
if err := opts.RecommendActions(); err != nil {
return err
}
return nil
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", secretNameFlagDescription)
cmd.Flags().StringToStringVar(&vars.values, valuesFlag, nil, secretValuesFlagDescription)
cmd.Flags().BoolVar(&vars.overwrite, overwriteFlag, false, secretOverwriteFlagDescription)
cmd.Flags().StringVar(&vars.inputFilePath, inputFilePathFlag, "", secretInputFilePathFlagDescription)
return cmd
}
| 528 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"path/filepath"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/aws/ssm"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
)
type secretInitMocks struct {
mockFS afero.Fs
mockStore *mocks.Mockstore
}
func TestSecretInitOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inApp string
inName string
inValues map[string]string
inOverwrite bool
inInputFilePath string
setupMocks func(m secretInitMocks)
wantedError error
}{
"skip validation if app flag is not set": {
setupMocks: func(m secretInitMocks) {},
},
"valid with input file": {
inInputFilePath: "./deep/secrets.yml",
inOverwrite: true,
setupMocks: func(m secretInitMocks) {
m.mockFS.MkdirAll("deep", 0755)
afero.WriteFile(m.mockFS, "deep/secrets.yml", []byte("FROM nginx"), 0644)
},
},
"valid with name and value": {
inName: "where_is_the_dragon",
inValues: map[string]string{
"good_village": "on_top_of_the_mountain",
"bad_village": "by_the_volcano",
},
inApp: "dragon_slaying",
inOverwrite: true,
setupMocks: func(m secretInitMocks) {
m.mockStore.EXPECT().GetApplication("dragon_slaying").Return(&config.Application{}, nil)
m.mockStore.EXPECT().GetEnvironment("dragon_slaying", "good_village").Return(&config.Environment{}, nil)
m.mockStore.EXPECT().GetEnvironment("dragon_slaying", "bad_village").Return(&config.Environment{}, nil)
},
},
"error getting app": {
inApp: "dragon_befriending",
setupMocks: func(m secretInitMocks) {
m.mockStore.EXPECT().GetApplication("dragon_befriending").Return(&config.Application{}, errors.New("some error"))
},
wantedError: errors.New("get application dragon_befriending: some error"),
},
"error getting env from the app": {
inName: "where_is_the_dragon",
inValues: map[string]string{
"good_village": "on_top_of_the_mountain",
"bad_village": "by_the_volcano",
"neutral_village": "there_is_no_such_village",
},
inApp: "dragon_slaying",
setupMocks: func(m secretInitMocks) {
m.mockStore.EXPECT().GetApplication("dragon_slaying").Return(&config.Application{}, nil)
m.mockStore.EXPECT().GetEnvironment("dragon_slaying", "good_village").Return(&config.Environment{}, nil).MinTimes(0).MaxTimes(1)
m.mockStore.EXPECT().GetEnvironment("dragon_slaying", "bad_village").Return(&config.Environment{}, nil).MinTimes(0).MaxTimes(1)
m.mockStore.EXPECT().GetEnvironment("dragon_slaying", "neutral_village").Return(nil, errors.New("some error"))
},
wantedError: errors.New("get environment neutral_village in application dragon_slaying: some error"),
},
"invalid input file name": {
inInputFilePath: "weird/path/to/secrets",
setupMocks: func(m secretInitMocks) {},
wantedError: fmt.Errorf("open %s: file does not exist", filepath.FromSlash("weird/path/to/secrets")),
},
"error if input file name is specified with name": {
inName: "db-password",
inInputFilePath: "path/to/file",
setupMocks: func(m secretInitMocks) {},
wantedError: errors.New("cannot specify `--cli-input-yaml` with `--name`"),
},
"error if input file name is specified with values": {
inValues: map[string]string{
"test": "test-db",
"prod": "prod-db",
},
inInputFilePath: "path/to/file",
setupMocks: func(m secretInitMocks) {},
wantedError: errors.New("cannot specify `--cli-input-yaml` with `--values`"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
opts := secretInitOpts{
secretInitVars: secretInitVars{
appName: tc.inApp,
name: tc.inName,
values: tc.inValues,
inputFilePath: tc.inInputFilePath,
overwrite: tc.inOverwrite,
},
fs: &afero.Afero{Fs: afero.NewMemMapFs()},
store: mockStore,
}
m := secretInitMocks{
mockFS: opts.fs,
mockStore: mockStore,
}
tc.setupMocks(m)
// WHEN
err := opts.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
type secretInitAskMocks struct {
mockStore *mocks.Mockstore
mockPrompter *mocks.Mockprompter
mockSelector *mocks.MockappSelector
}
func TestSecretInitOpts_Ask(t *testing.T) {
var (
wantedName = "db-password"
wantedApp = "my-app"
wantedValues = map[string]string{
"test": "test-password",
"dev": "dev-password",
"prod": "prod-password",
}
wantedVars = secretInitVars{
appName: wantedApp,
name: wantedName,
values: wantedValues,
}
)
testCases := map[string]struct {
inAppName string
inName string
inValues map[string]string
setupMocks func(m secretInitAskMocks)
wantedVars secretInitVars
wantedError error
}{
"prompt to select an app if not specified": {
inName: wantedName,
inValues: wantedValues,
setupMocks: func(m secretInitAskMocks) {
m.mockSelector.EXPECT().Application(secretInitAppPrompt, gomock.Any()).Return(wantedApp, nil)
},
wantedVars: wantedVars,
},
"error prompting to select an app": {
setupMocks: func(m secretInitAskMocks) {
m.mockSelector.EXPECT().Application(secretInitAppPrompt, gomock.Any()).Return("", errors.New("some error"))
},
wantedError: errors.New("ask for an application to add the secret to: some error"),
},
"do not prompt for app if specified": {
inAppName: wantedApp,
inName: wantedName,
inValues: wantedValues,
setupMocks: func(m secretInitAskMocks) {
m.mockSelector.EXPECT().Application(gomock.Any(), gomock.Any()).Times(0)
},
wantedVars: secretInitVars{
appName: wantedApp,
name: wantedName,
values: wantedValues,
},
},
"ask for a secret name if not specified": {
inAppName: wantedApp,
inValues: wantedValues,
setupMocks: func(m secretInitAskMocks) {
m.mockPrompter.EXPECT().Get(secretInitSecretNamePrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return("db-password", nil)
},
wantedVars: wantedVars,
},
"error prompting for a secret name": {
inAppName: wantedApp,
inValues: wantedValues,
setupMocks: func(m secretInitAskMocks) {
m.mockPrompter.EXPECT().Get(secretInitSecretNamePrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return("", errors.New("some error"))
},
wantedError: errors.New("ask for the secret name: some error"),
},
"do not ask for a secret name if specified": {
inName: "db-password",
inAppName: wantedApp,
inValues: wantedValues,
setupMocks: func(m secretInitAskMocks) {
m.mockPrompter.EXPECT().Get(secretInitSecretNamePrompt, gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedVars: wantedVars,
},
"ask for values for each existing environment if not specified": {
inAppName: wantedApp,
inName: wantedName,
setupMocks: func(m secretInitAskMocks) {
m.mockStore.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
},
{
Name: "dev",
},
{
Name: "prod",
},
}, nil)
m.mockPrompter.EXPECT().GetSecret(fmt.Sprintf(fmtSecretInitSecretValuePrompt, "db-password", "test"), gomock.Any(), gomock.Any()).
Return("test-password", nil)
m.mockPrompter.EXPECT().GetSecret(fmt.Sprintf(fmtSecretInitSecretValuePrompt, "db-password", "dev"), gomock.Any(), gomock.Any()).
Return("dev-password", nil)
m.mockPrompter.EXPECT().GetSecret(fmt.Sprintf(fmtSecretInitSecretValuePrompt, "db-password", "prod"), gomock.Any(), gomock.Any()).
Return("prod-password", nil)
},
wantedVars: wantedVars,
},
"error listing environments": {
inAppName: wantedApp,
inName: wantedName,
setupMocks: func(m secretInitAskMocks) {
m.mockStore.EXPECT().ListEnvironments("my-app").Return(nil, errors.New("some error"))
},
wantedError: errors.New("list environments in app my-app: some error"),
},
"error prompting for values": {
inAppName: wantedApp,
inName: wantedName,
setupMocks: func(m secretInitAskMocks) {
m.mockStore.EXPECT().ListEnvironments("my-app").Return([]*config.Environment{
{
Name: "test",
},
{
Name: "dev",
},
{
Name: "prod",
},
}, nil)
m.mockPrompter.EXPECT().GetSecret(fmt.Sprintf(fmtSecretInitSecretValuePrompt, "db-password", "test"), gomock.Any(), gomock.Any()).
Return("", errors.New("some error"))
m.mockPrompter.EXPECT().GetSecret(fmt.Sprintf(fmtSecretInitSecretValuePrompt, "db-password", "dev"), gomock.Any(), gomock.Any()).MinTimes(0).MaxTimes(1)
m.mockPrompter.EXPECT().GetSecret(fmt.Sprintf(fmtSecretInitSecretValuePrompt, "db-password", "prod"), gomock.Any(), gomock.Any()).MinTimes(0).MaxTimes(1)
},
wantedError: errors.New("get secret value for db-password in environment test: some error"),
},
"error if no env is found": {
inAppName: wantedApp,
inName: wantedName,
setupMocks: func(m secretInitAskMocks) {
m.mockStore.EXPECT().ListEnvironments(wantedApp).Return([]*config.Environment{}, nil)
},
wantedError: errors.New("no environment is found in app my-app"),
},
"do not ask for values if specified": {
inAppName: wantedApp,
inName: wantedName,
inValues: wantedValues,
setupMocks: func(m secretInitAskMocks) {},
wantedVars: wantedVars,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := secretInitAskMocks{
mockPrompter: mocks.NewMockprompter(ctrl),
mockSelector: mocks.NewMockappSelector(ctrl),
mockStore: mocks.NewMockstore(ctrl),
}
opts := secretInitOpts{
secretInitVars: secretInitVars{
appName: tc.inAppName,
name: tc.inName,
values: tc.inValues,
},
prompter: m.mockPrompter,
store: m.mockStore,
selector: m.mockSelector,
}
tc.setupMocks(m)
err := opts.Ask()
if tc.wantedError == nil {
require.NoError(t, err)
require.Equal(t, tc.wantedVars, opts.secretInitVars)
} else {
require.EqualError(t, tc.wantedError, err.Error())
}
})
}
}
type secretInitExecuteMocks struct {
mockStore *mocks.Mockstore
mockSecretPutter *mocks.MocksecretPutter
mockEnvCompatibilityChecker *mocks.MockversionCompatibilityChecker
}
func TestSecretInitOpts_Execute(t *testing.T) {
var (
testApp = "test-app"
testName = "db-password"
testValues = map[string]string{
"test": "test-password",
"prod": "prod-password",
}
)
testCases := map[string]struct {
inAppName string
inName string
inValues map[string]string
inInputFilePath string
inOverwrite bool
mockInputFileContent []byte
setupMocks func(m secretInitExecuteMocks)
wantedError error
}{
"successfully create secrets in two environments": {
inAppName: testApp,
inName: testName,
inValues: testValues,
setupMocks: func(m secretInitExecuteMocks) {
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/test/secrets/db-password",
Value: "test-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "test",
},
}).Return(&ssm.PutSecretOutput{
Version: aws.Int64(1),
}, nil)
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/prod/secrets/db-password",
Value: "prod-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "prod",
},
}).Return(&ssm.PutSecretOutput{
Version: aws.Int64(1),
}, nil)
m.mockEnvCompatibilityChecker.EXPECT().Version().Return("v1.10.0", nil).Times(2)
},
},
"should make calls to overwrite if overwrite is specified": {
inAppName: testApp,
inName: testName,
inValues: testValues,
inOverwrite: true,
setupMocks: func(m secretInitExecuteMocks) {
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/test/secrets/db-password",
Value: "test-password",
Overwrite: true,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "test",
},
}).Return(&ssm.PutSecretOutput{
Version: aws.Int64(1),
}, nil)
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/prod/secrets/db-password",
Value: "prod-password",
Overwrite: true,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "prod",
},
}).Return(&ssm.PutSecretOutput{
Version: aws.Int64(1),
}, nil)
m.mockEnvCompatibilityChecker.EXPECT().Version().Return("v1.10.0", nil).Times(2)
},
},
"do not throw error if parameter already exists": {
inAppName: testApp,
inName: testName,
inValues: testValues,
setupMocks: func(m secretInitExecuteMocks) {
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/test/secrets/db-password",
Value: "test-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "test",
},
}).Return(nil, &ssm.ErrParameterAlreadyExists{})
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/prod/secrets/db-password",
Value: "prod-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "prod",
},
}).Return(&ssm.PutSecretOutput{
Version: aws.Int64(1),
}, nil)
m.mockEnvCompatibilityChecker.EXPECT().Version().Return("v1.10.0", nil).Times(2)
},
},
"a secret fails to create in some environments": {
inAppName: testApp,
inName: testName,
inValues: testValues,
setupMocks: func(m secretInitExecuteMocks) {
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/test/secrets/db-password",
Value: "test-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "test",
},
}).Return(nil, errors.New("some error"))
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/prod/secrets/db-password",
Value: "prod-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "prod",
},
}).Return(&ssm.PutSecretOutput{
Version: aws.Int64(1),
}, nil)
m.mockEnvCompatibilityChecker.EXPECT().Version().Return("v1.10.0", nil).Times(2)
},
wantedError: &errSecretFailedInSomeEnvironments{
secretName: testName,
errorsForEnvironments: map[string]error{
"test": errors.New("some error"),
},
},
},
"some secrets fail to create during a batch operation": {
inAppName: testApp,
inInputFilePath: "some/file",
mockInputFileContent: []byte(`db-password:
test: test-password
prod: prod-password
db-host:
test: test-host`),
setupMocks: func(m secretInitExecuteMocks) {
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/test/secrets/db-password",
Value: "test-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "test",
},
}).Return(nil, errors.New("some error for db-password in test"))
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/prod/secrets/db-password",
Value: "prod-password",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "prod",
},
}).Return(&ssm.PutSecretOutput{
Version: aws.Int64(1),
}, nil)
m.mockSecretPutter.EXPECT().PutSecret(ssm.PutSecretInput{
Name: "/copilot/test-app/test/secrets/db-host",
Value: "test-host",
Overwrite: false,
Tags: map[string]string{
deploy.AppTagKey: "test-app",
deploy.EnvTagKey: "test",
},
}).Return(nil, errors.New("some error for db-host in test"))
m.mockEnvCompatibilityChecker.EXPECT().Version().Return("v1.10.0", nil).Times(2)
},
wantedError: &errBatchPutSecretsFailed{
errors: []*errSecretFailedInSomeEnvironments{
{
secretName: "db-password",
errorsForEnvironments: map[string]error{
"test": errors.New("some error for db-password in test"),
},
},
{
secretName: "db-host",
errorsForEnvironments: map[string]error{
"test": errors.New("some error for db-host in test"),
},
},
},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := secretInitExecuteMocks{
mockStore: mocks.NewMockstore(ctrl),
mockSecretPutter: mocks.NewMocksecretPutter(ctrl),
mockEnvCompatibilityChecker: mocks.NewMockversionCompatibilityChecker(ctrl),
}
tc.setupMocks(m)
opts := secretInitOpts{
secretInitVars: secretInitVars{
appName: tc.inAppName,
name: tc.inName,
values: tc.inValues,
overwrite: tc.inOverwrite,
inputFilePath: tc.inInputFilePath,
},
store: m.mockStore,
secretPutters: make(map[string]secretPutter),
envCompatibilityChecker: make(map[string]versionCompatibilityChecker),
readFile: func() ([]byte, error) {
return tc.mockInputFileContent, nil
},
}
opts.configureClientsForEnv = func(envName string) error {
opts.secretPutters[envName] = m.mockSecretPutter
opts.envCompatibilityChecker[envName] = m.mockEnvCompatibilityChecker
return nil
}
err := opts.Execute()
if tc.wantedError == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
func Test_SecretInitParseSecretsInputFile(t *testing.T) {
t.Run("success", func(t *testing.T) {
opts := secretInitOpts{
readFile: func() ([]byte, error) {
raw := `db-password:
test: test-password
prod: prod-password
db-host:
test: test-host
prod: prod-host
test-only-secret:
test: test-only`
return []byte(raw), nil
},
}
expected := map[string]map[string]string{
"db-password": {
"test": "test-password",
"prod": "prod-password",
},
"db-host": {
"test": "test-host",
"prod": "prod-host",
},
"test-only-secret": {
"test": "test-only",
},
}
secrets, err := opts.parseSecretsInputFile()
require.NoError(t, err)
require.Equal(t, expected, secrets)
})
}
| 643 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
)
// BuildStorageCmd is the top level command for storage
func BuildStorageCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "storage",
Short: "Commands for working with storage and databases.",
Long: `Commands for working with storage and databases.
Augment your services with S3 buckets, NoSQL and SQL databases.`,
}
cmd.AddCommand(buildStorageInitCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Extend,
}
return cmd
}
| 30 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"encoding"
"errors"
"fmt"
"strconv"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/dustin/go-humanize/english"
"github.com/aws/copilot-cli/internal/pkg/addon"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
)
const (
dynamoDBStorageType = "DynamoDB"
s3StorageType = "S3"
rdsStorageType = "Aurora"
)
var storageTypes = []string{
dynamoDBStorageType,
s3StorageType,
rdsStorageType,
}
// Displayed options for storage types
const (
dynamoDBStorageTypeOption = "DynamoDB"
s3StorageTypeOption = "S3"
rdsStorageTypeOption = "Aurora Serverless"
)
const (
s3BucketFriendlyText = "S3 Bucket"
dynamoDBTableFriendlyText = "DynamoDB Table"
rdsFriendlyText = "Database Cluster"
)
const (
lifecycleEnvironmentLevel = "environment"
lifecycleWorkloadLevel = "workload"
lifecycleEnvironmentFriendlyText = "No, the storage should be created and deleted at the environment level"
fmtLifecycleWorkloadFriendlyText = "Yes, the storage should be created and deleted at the same time as %s"
)
var validLifecycleOptions = []string{lifecycleWorkloadLevel, lifecycleEnvironmentLevel}
// General-purpose prompts, collected for all storage resources.
var (
storageInitTypeHelp = `The type of storage you'd like to add to your workload.
DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale.
S3 is a web object store built to store and retrieve any amount of data from anywhere on the Internet.
Aurora Serverless is an on-demand autoscaling configuration for Amazon Aurora, a MySQL and PostgreSQL-compatible relational database.
`
fmtStorageInitNamePrompt = "What would you like to " + color.Emphasize("name") + " this %s?"
storageInitNameHelp = "The name of this storage resource. You can use the following characters: a-zA-Z0-9-_"
storageInitSvcPrompt = "Which " + color.Emphasize("workload") + " needs access to the storage?"
fmtStorageInitLifecyclePrompt = "Do you want the storage to be created and deleted with the %s service?"
)
// DDB-specific questions and help prompts.
var (
fmtStorageInitDDBKeyPrompt = "What would you like to name the %s of this %s?"
storageInitDDBPartitionKeyHelp = "The partition key of this table. This key, along with the sort key, will make up the primary key."
storageInitDDBSortKeyConfirm = "Would you like to add a sort key to this table?"
storageInitDDBSortKeyHelp = "The sort key of this table. Without a sort key, the partition key " + color.Emphasize("must") + ` be unique on the table.
You must specify a sort key if you wish to add alternate sort keys later.`
fmtStorageInitDDBKeyTypePrompt = "What datatype is this %s?"
fmtStorageInitDDBKeyTypeHelp = "The datatype to store in the %s. N is number, S is string, B is binary."
storageInitDDBLSIPrompt = "Would you like to add any alternate sort keys to this table?"
storageInitDDBLSIHelp = `Alternate sort keys create Local Secondary Indexes, which allow you to sort the table using the same
partition key but a different sort key. You may specify up to 5 alternate sort keys.`
storageInitDDBMoreLSIPrompt = "Would you like to add more alternate sort keys to this table?"
storageInitDDBLSINamePrompt = "What would you like to name this " + color.Emphasize("alternate sort key") + "?"
storageInitDDBLSINameHelp = "You can use the characters [a-zA-Z0-9.-_]"
)
// DynamoDB specific constants and variables.
const (
ddbKeyString = "key"
ddbStringType = "String"
ddbIntType = "Number"
ddbBinaryType = "Binary"
)
var attributeTypes = []string{
ddbStringType,
ddbIntType,
ddbBinaryType,
}
// RDS Aurora Serverless specific questions and help prompts.
var (
storageInitRDSInitialDBNamePrompt = "What would you like to name the initial database in your cluster?"
storageInitRDSDBEnginePrompt = "Which database engine would you like to use?"
)
// RDS Aurora Serverless specific constants and variables.
const (
auroraServerlessVersionV1 = "v1"
auroraServerlessVersionV2 = "v2"
defaultAuroraServerlessVersion = auroraServerlessVersionV2
fmtRDSStorageNameDefault = "%s-cluster"
engineTypeMySQL = addon.RDSEngineTypeMySQL
engineTypePostgreSQL = addon.RDSEngineTypePostgreSQL
)
var auroraServerlessVersions = []string{
auroraServerlessVersionV1,
auroraServerlessVersionV2,
}
var engineTypes = []string{
engineTypeMySQL,
engineTypePostgreSQL,
}
const workloadTypeNonLocal = "Non Local"
const (
blobDescriptionParameters = "parameters"
blobDescriptionTemplate = "template"
)
type initStorageVars struct {
storageType string
storageName string
workloadName string
lifecycle string
addIngressFrom string
// Dynamo DB specific values collected via flags or prompts
partitionKey string
sortKey string
lsiSorts []string // lsi sort keys collected as "name:T" where T is one of [SNB]
noLSI bool
noSort bool
// RDS Aurora Serverless specific values collected via flags or prompts
auroraServerlessVersion string
rdsEngine string
rdsParameterGroup string
rdsInitialDBName string
}
type initStorageOpts struct {
initStorageVars
appName string
fs afero.Fs
ws wsReadWriter
store store
sel wsSelector
configSel configSelector
prompt prompter
// Cached data.
workloadType string
workloadExists bool
}
func newStorageInitOpts(vars initStorageVars) (*initStorageOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("storage init"))
defaultSession, err := sessProvider.Default()
if err != nil {
return nil, err
}
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
return &initStorageOpts{
initStorageVars: vars,
appName: tryReadingAppName(),
fs: fs,
store: store,
ws: ws,
sel: selector.NewLocalWorkloadSelector(prompter, store, ws),
configSel: selector.NewConfigSelector(prompter, store),
prompt: prompter,
}, nil
}
// Validate returns an error for any invalid optional flags.
func (o *initStorageOpts) Validate() error {
if o.appName == "" {
return errNoAppInWorkspace
}
if o.addIngressFrom != "" {
if err := o.validateAddIngressFrom(); err != nil {
return err
}
}
// --no-lsi and --lsi are mutually exclusive.
if o.noLSI && len(o.lsiSorts) != 0 {
return fmt.Errorf("validate LSI configuration: cannot specify --no-lsi and --lsi options at once")
}
// --no-sort and --lsi are mutually exclusive.
if o.noSort && len(o.lsiSorts) != 0 {
return fmt.Errorf("validate LSI configuration: cannot specify --no-sort and --lsi options at once")
}
if o.auroraServerlessVersion != "" {
if err := o.validateServerlessVersion(); err != nil {
return err
}
}
return nil
}
func (o *initStorageOpts) validateAddIngressFrom() error {
if o.workloadName != "" {
return fmt.Errorf("--%s cannot be specified with --%s", workloadFlag, storageAddIngressFromFlag)
}
if o.lifecycle == lifecycleWorkloadLevel {
return fmt.Errorf("--%s cannot be %s when --%s is used", storageLifecycleFlag, lifecycleWorkloadLevel, storageAddIngressFromFlag)
}
if o.storageName == "" {
return fmt.Errorf("--%s is required when --%s is used", nameFlag, storageAddIngressFromFlag)
}
if o.storageType == "" {
return fmt.Errorf("--%s is required when --%s is used", storageTypeFlag, storageAddIngressFromFlag)
}
exist, err := o.ws.WorkloadExists(o.addIngressFrom)
if err != nil {
return fmt.Errorf("check if %s exists in the workspace: %w", o.addIngressFrom, err)
}
if !exist {
return fmt.Errorf("workload %s not found in the workspace", o.addIngressFrom)
}
return nil
}
func (o *initStorageOpts) validateServerlessVersion() error {
for _, valid := range auroraServerlessVersions {
if o.auroraServerlessVersion == valid {
return nil
}
}
fmtErrInvalidServerlessVersion := "invalid Aurora Serverless version %s: must be one of %s"
return fmt.Errorf(fmtErrInvalidServerlessVersion, o.auroraServerlessVersion, prettify(auroraServerlessVersions))
}
// Ask asks for fields that are required but not passed in.
func (o *initStorageOpts) Ask() error {
if o.addIngressFrom != "" {
return nil
}
if err := o.validateOrAskStorageType(); err != nil {
return err
}
if err := o.askWorkload(); err != nil {
return err
}
// Storage name needs to be asked after workload because for Aurora the default storage name uses the workload name.
if err := o.validateOrAskStorageName(); err != nil {
return err
}
if err := o.validateOrAskLifecycle(); err != nil {
return err
}
if err := o.validateWorkloadNameWithLifecycle(); err != nil {
return err
}
switch o.storageType {
case dynamoDBStorageType:
if err := o.validateOrAskDynamoPartitionKey(); err != nil {
return err
}
if err := o.validateOrAskDynamoSortKey(); err != nil {
return err
}
if err := o.validateOrAskDynamoLSIConfig(); err != nil {
return err
}
case rdsStorageType:
if err := o.validateOrAskAuroraEngineType(); err != nil {
return err
}
// Ask for initial db name after engine type since the name needs to be validated accordingly.
if err := o.validateOrAskAuroraInitialDBName(); err != nil {
return err
}
}
return nil
}
func (o *initStorageOpts) validateOrAskStorageType() error {
if o.storageType != "" {
return o.validateStorageType()
}
options := []prompt.Option{
{
Value: dynamoDBStorageType,
FriendlyText: dynamoDBStorageTypeOption,
Hint: "NoSQL",
},
{
Value: s3StorageType,
FriendlyText: s3StorageTypeOption,
Hint: "Objects",
},
{
Value: rdsStorageType,
FriendlyText: rdsStorageTypeOption,
Hint: "SQL",
},
}
result, err := o.prompt.SelectOption(o.storageTypePrompt(),
storageInitTypeHelp,
options,
prompt.WithFinalMessage("Storage type:"))
if err != nil {
return fmt.Errorf("select storage type: %w", err)
}
o.storageType = result
return o.validateStorageType()
}
func (o *initStorageOpts) storageTypePrompt() string {
if o.workloadName == "" {
return "What " + color.Emphasize("type") + " of storage would you like to create?"
}
return fmt.Sprintf("What "+color.Emphasize("type")+" of storage would you like to associate with %s?", color.HighlightUserInput(o.workloadName))
}
func (o *initStorageOpts) validateStorageType() error {
if err := validateStorageType(o.storageType, validateStorageTypeOpts{
ws: o.ws,
workloadName: o.workloadName,
}); err != nil {
if errors.Is(err, errRDWSNotConnectedToVPC) {
log.Errorf(`Your %s needs to be connected to a VPC in order to use a %s resource.
You can enable VPC connectivity by updating your manifest with:
%s
`, manifestinfo.RequestDrivenWebServiceType, o.storageType, color.HighlightCodeBlock(`network:
vpc:
placement: private`))
}
return err
}
return nil
}
func (o *initStorageOpts) validateOrAskStorageName() error {
if o.storageName != "" {
if err := o.validateStorageName(); err != nil {
return fmt.Errorf("validate storage name: %w", err)
}
return nil
}
var validator func(interface{}) error
var friendlyText string
switch o.storageType {
case s3StorageType:
validator = s3BucketNameValidation
friendlyText = s3BucketFriendlyText
case dynamoDBStorageType:
validator = dynamoTableNameValidation
friendlyText = dynamoDBTableFriendlyText
case rdsStorageType:
return o.askStorageNameWithDefault(rdsFriendlyText, fmt.Sprintf(fmtRDSStorageNameDefault, o.workloadName), rdsNameValidation)
}
name, err := o.prompt.Get(fmt.Sprintf(fmtStorageInitNamePrompt,
color.HighlightUserInput(friendlyText)),
storageInitNameHelp,
validator,
prompt.WithFinalMessage("Storage resource name:"))
if err != nil {
return fmt.Errorf("input storage name: %w", err)
}
o.storageName = name
return nil
}
func (o *initStorageOpts) validateStorageName() error {
switch o.storageType {
case dynamoDBStorageType:
return dynamoTableNameValidation(o.storageName)
case s3StorageType:
return s3BucketNameValidation(o.storageName)
case rdsStorageType:
return rdsNameValidation(o.storageName)
default:
// use dynamo since it's a superset of s3
return dynamoTableNameValidation(o.storageName)
}
}
func (o *initStorageOpts) askStorageNameWithDefault(friendlyText, defaultName string, validator func(interface{}) error) error {
name, err := o.prompt.Get(fmt.Sprintf(fmtStorageInitNamePrompt,
color.HighlightUserInput(friendlyText)),
storageInitNameHelp,
validator,
prompt.WithFinalMessage("Storage resource name:"),
prompt.WithDefaultInput(defaultName))
if err != nil {
return fmt.Errorf("input storage name: %w", err)
}
o.storageName = name
return nil
}
func (o *initStorageOpts) askWorkload() error {
if o.workloadName != "" {
return nil
}
if o.lifecycle == lifecycleWorkloadLevel {
return o.askLocalWorkload()
}
workload, err := o.configSel.Workload(storageInitSvcPrompt, "", o.appName)
if err != nil {
return fmt.Errorf("select a workload from app %s: %w", o.appName, err)
}
o.workloadName = workload
return nil
}
func (o *initStorageOpts) askLocalWorkload() error {
workload, err := o.sel.Workload(storageInitSvcPrompt, "")
if err != nil {
return fmt.Errorf("retrieve local workload names: %w", err)
}
o.workloadName = workload
return nil
}
func (o *initStorageOpts) validateOrAskLifecycle() error {
if o.lifecycle != "" {
return o.validateStorageLifecycle()
}
_, err := o.ws.ReadFile(o.ws.WorkloadAddonFileAbsPath(o.workloadName, fmt.Sprintf("%s.yml", o.storageName)))
if err == nil {
o.lifecycle = lifecycleWorkloadLevel
log.Infof("%s %s %s\n",
color.Emphasize("Lifecycle:"),
"workload-level",
color.Faint.Sprintf("(found %s)", o.ws.WorkloadAddonFilePath(o.workloadName, fmt.Sprintf("%s.yml", o.storageName))),
)
return nil
}
if _, ok := err.(*workspace.ErrFileNotExists); !ok {
return fmt.Errorf("check if %s addon exists for %s in workspace: %w", o.storageName, o.workloadName, err)
}
_, err = o.ws.ReadFile(o.ws.EnvAddonFileAbsPath(fmt.Sprintf("%s.yml", o.storageName)))
if err == nil {
o.lifecycle = lifecycleEnvironmentLevel
log.Infof("%s %s %s\n",
color.Emphasize("Lifecycle:"),
"environment-level",
color.Faint.Sprintf("(found %s)", o.ws.EnvAddonFilePath(fmt.Sprintf("%s.yml", o.storageName))),
)
return nil
}
if _, ok := err.(*workspace.ErrFileNotExists); !ok {
return fmt.Errorf("check if %s exists as an environment addon in workspace: %w", o.storageName, err)
}
options := []prompt.Option{
{
Value: lifecycleWorkloadLevel,
FriendlyText: fmt.Sprintf(fmtLifecycleWorkloadFriendlyText, color.HighlightUserInput(o.workloadName)),
},
{
Value: lifecycleEnvironmentLevel,
FriendlyText: lifecycleEnvironmentFriendlyText,
},
}
lifecycle, err := o.prompt.SelectOption(
fmt.Sprintf(fmtStorageInitLifecyclePrompt, o.workloadName),
"",
options,
prompt.WithFinalMessage("Lifecycle: "))
if err != nil {
return fmt.Errorf("ask for lifecycle: %w", err)
}
o.lifecycle = lifecycle
return nil
}
func (o *initStorageOpts) validateStorageLifecycle() error {
for _, valid := range validLifecycleOptions {
if o.lifecycle == valid {
return nil
}
}
return fmt.Errorf("invalid lifecycle; must be one of %s", english.OxfordWordSeries(applyAll(validLifecycleOptions, strconv.Quote), "or"))
}
// validateWorkloadNameWithLifecycle requires the workload to be in the workspace if the storage lifecycle is on workload-level.
// Otherwise, it only caches whether the workload is present.
func (o *initStorageOpts) validateWorkloadNameWithLifecycle() error {
if o.lifecycle == lifecycleEnvironmentLevel {
hasEnv, err := o.ws.HasEnvironments()
if err != nil {
return fmt.Errorf("check if environments directory exists in the workspace: %w", err)
}
if !hasEnv {
return &errNoEnvironmentInWorkspace{}
}
return nil
}
if o.lifecycle == lifecycleWorkloadLevel {
exists, err := o.ws.WorkloadExists(o.workloadName)
if err != nil {
return fmt.Errorf("check if %s exists in the workspace: %w", o.workloadName, err)
}
if !exists {
return &errWorkloadNotInWorkspace{
workloadName: o.workloadName,
}
}
}
return nil
}
func (o *initStorageOpts) validateOrAskDynamoPartitionKey() error {
if o.partitionKey != "" {
if err := validateKey(o.partitionKey); err != nil {
return fmt.Errorf("validate partition key: %w", err)
}
return nil
}
keyPrompt := fmt.Sprintf(fmtStorageInitDDBKeyPrompt,
color.HighlightUserInput("partition key"),
color.HighlightUserInput(dynamoDBStorageType),
)
key, err := o.prompt.Get(keyPrompt,
storageInitDDBPartitionKeyHelp,
dynamoAttributeNameValidation,
prompt.WithFinalMessage("Partition key:"),
)
if err != nil {
return fmt.Errorf("get DDB partition key: %w", err)
}
keyTypePrompt := fmt.Sprintf(fmtStorageInitDDBKeyTypePrompt, ddbKeyString)
keyTypeHelp := fmt.Sprintf(fmtStorageInitDDBKeyTypeHelp, ddbKeyString)
keyType, err := o.prompt.SelectOne(keyTypePrompt,
keyTypeHelp,
attributeTypes,
prompt.WithFinalMessage("Partition key datatype:"),
)
if err != nil {
return fmt.Errorf("get DDB partition key datatype: %w", err)
}
o.partitionKey = key + ":" + keyType
return nil
}
func (o *initStorageOpts) validateOrAskDynamoSortKey() error {
if o.sortKey != "" {
if err := validateKey(o.sortKey); err != nil {
return fmt.Errorf("validate sort key: %w", err)
}
return nil
}
// If the user has not specified a sort key and has specified the --no-sort flag we don't have to demand it of them.
if o.noSort {
return nil
}
response, err := o.prompt.Confirm(storageInitDDBSortKeyConfirm, storageInitDDBSortKeyHelp, prompt.WithFinalMessage("Sort key?"))
if err != nil {
return fmt.Errorf("confirm DDB sort key: %w", err)
}
if !response {
o.noSort = true
return nil
}
keyPrompt := fmt.Sprintf(fmtStorageInitDDBKeyPrompt,
color.HighlightUserInput("sort key"),
color.HighlightUserInput(dynamoDBStorageType),
)
key, err := o.prompt.Get(keyPrompt,
storageInitDDBSortKeyHelp,
dynamoAttributeNameValidation,
prompt.WithFinalMessage("Sort key:"),
)
if err != nil {
return fmt.Errorf("get DDB sort key: %w", err)
}
keyTypePrompt := fmt.Sprintf(fmtStorageInitDDBKeyTypePrompt, ddbKeyString)
keyTypeHelp := fmt.Sprintf(fmtStorageInitDDBKeyTypeHelp, ddbKeyString)
keyType, err := o.prompt.SelectOne(keyTypePrompt,
keyTypeHelp,
attributeTypes,
prompt.WithFinalMessage("Sort key datatype:"),
)
if err != nil {
return fmt.Errorf("get DDB sort key datatype: %w", err)
}
o.sortKey = key + ":" + keyType
return nil
}
func (o *initStorageOpts) validateOrAskDynamoLSIConfig() error {
// LSI has already been specified by flags.
if len(o.lsiSorts) > 0 {
return validateLSIs(o.lsiSorts)
}
// If --no-lsi has been specified, there is no need to ask for local secondary indices.
if o.noLSI {
return nil
}
// If --no-sort has been specified, there is no need to ask for local secondary indices.
if o.noSort {
o.noLSI = true
return nil
}
lsiTypePrompt := fmt.Sprintf(fmtStorageInitDDBKeyTypePrompt, color.Emphasize("alternate sort key"))
lsiTypeHelp := fmt.Sprintf(fmtStorageInitDDBKeyTypeHelp, "alternate sort key")
moreLSI, err := o.prompt.Confirm(storageInitDDBLSIPrompt, storageInitDDBLSIHelp, prompt.WithFinalMessage("Additional sort keys?"))
if err != nil {
return fmt.Errorf("confirm add alternate sort key: %w", err)
}
for {
if len(o.lsiSorts) > 5 {
log.Infoln("You may not specify more than 5 alternate sort keys. Continuing...")
moreLSI = false
}
// This will execute last in the loop if moreLSI is set to false by any confirm prompts.
if !moreLSI {
o.noLSI = len(o.lsiSorts) == 0
return nil
}
lsiName, err := o.prompt.Get(storageInitDDBLSINamePrompt,
storageInitDDBLSINameHelp,
dynamoTableNameValidation,
prompt.WithFinalMessage("Alternate Sort Key:"),
)
if err != nil {
return fmt.Errorf("get DDB alternate sort key name: %w", err)
}
lsiType, err := o.prompt.SelectOne(lsiTypePrompt,
lsiTypeHelp,
attributeTypes,
prompt.WithFinalMessage("Attribute type:"),
)
if err != nil {
return fmt.Errorf("get DDB alternate sort key type: %w", err)
}
o.lsiSorts = append(o.lsiSorts, lsiName+":"+lsiType)
moreLSI, err = o.prompt.Confirm(
storageInitDDBMoreLSIPrompt,
storageInitDDBLSIHelp,
prompt.WithFinalMessage("Additional sort keys?"),
)
if err != nil {
return fmt.Errorf("confirm add alternate sort key: %w", err)
}
}
}
func (o *initStorageOpts) validateOrAskAuroraEngineType() error {
if o.rdsEngine != "" {
return validateEngine(o.rdsEngine)
}
engine, err := o.prompt.SelectOne(storageInitRDSDBEnginePrompt,
"",
engineTypes,
prompt.WithFinalMessage("Database engine:"))
if err != nil {
return fmt.Errorf("select database engine: %w", err)
}
o.rdsEngine = engine
return nil
}
func (o *initStorageOpts) validateOrAskAuroraInitialDBName() error {
var validator func(interface{}) error
switch o.rdsEngine {
case engineTypeMySQL:
validator = validateMySQLDBName
case engineTypePostgreSQL:
validator = validatePostgreSQLDBName
default:
return errors.New("unknown engine type")
}
if o.rdsInitialDBName != "" {
// The flag input is validated here because it needs engine type to determine which validator to use.
return validator(o.rdsInitialDBName)
}
dbName, err := o.prompt.Get(storageInitRDSInitialDBNamePrompt,
"",
validator,
prompt.WithFinalMessage("Initial database name:"))
if err != nil {
return fmt.Errorf("input initial database name: %w", err)
}
o.rdsInitialDBName = dbName
return nil
}
// Execute deploys a new environment with CloudFormation and adds it to SSM.
func (o *initStorageOpts) Execute() error {
o.consumeFlags()
if err := o.checkWorkloadExists(); err != nil {
return err
}
if err := o.readWorkloadType(); err != nil {
return err
}
addonBlobs, err := o.addonBlobs()
if err != nil {
return err
}
for _, addon := range addonBlobs {
path, err := o.ws.Write(addon.blob, addon.path)
if err == nil {
log.Successf("Wrote CloudFormation %s at %s\n",
addon.description,
color.HighlightResource(displayPath(path)),
)
continue
}
var errFileExists *workspace.ErrFileExists
if !errors.As(err, &errFileExists) {
return err
}
log.Successf("CloudFormation %s already exists at %s, skipping writing it.\n",
addon.description,
color.HighlightResource(displayPath(addon.path)))
if addon.description == blobDescriptionParameters {
log.Infoln(indentBy(color.Faint.Sprintf(addon.recommendedAction()), 2))
}
}
log.Infoln()
return nil
}
func (o *initStorageOpts) consumeFlags() {
if o.addIngressFrom == "" {
return
}
o.workloadName = o.addIngressFrom
o.lifecycle = lifecycleEnvironmentLevel
if o.storageType == rdsStorageType && o.rdsEngine == "" {
o.rdsEngine = addon.RDSEngineTypeMySQL
}
}
func (o *initStorageOpts) checkWorkloadExists() error {
exist, err := o.ws.WorkloadExists(o.workloadName)
if err != nil {
return fmt.Errorf("check if %s exists in the workspace: %w", o.workloadName, err)
}
o.workloadExists = exist
return nil
}
func (o *initStorageOpts) readWorkloadType() error {
if !o.workloadExists {
o.workloadType = workloadTypeNonLocal
return nil
}
mft, err := o.ws.ReadWorkloadManifest(o.workloadName)
if err != nil {
return fmt.Errorf("read manifest for %s: %w", o.workloadName, err)
}
t, err := mft.WorkloadType()
if err != nil {
return fmt.Errorf("read 'type' from manifest for %s: %w", o.workloadName, err)
}
o.workloadType = t
return nil
}
type addonBlob struct {
path string
description string
blob encoding.BinaryMarshaler
}
func (b *addonBlob) recommendedAction() string {
data, err := b.blob.MarshalBinary()
if err != nil {
return "" // Best effort to read the content in order to make suggestions.
}
return fmt.Sprintf("Check that %s has the following snippet:\n%s", displayPath(b.path), color.HighlightCodeBlock(string(data)))
}
func (o *initStorageOpts) addonBlobs() ([]addonBlob, error) {
type option struct {
lifecycle string
storageType string
}
selection := option{o.lifecycle, o.storageType}
switch selection {
case option{lifecycleWorkloadLevel, s3StorageType}:
return o.wkldS3AddonBlobs()
case option{lifecycleWorkloadLevel, dynamoDBStorageType}:
return o.wkldDDBAddonBlobs()
case option{lifecycleWorkloadLevel, rdsStorageType}:
return o.wkldRDSAddonBlobs()
case option{lifecycleEnvironmentLevel, s3StorageType}:
return o.envS3AddonBlobs()
case option{lifecycleEnvironmentLevel, dynamoDBStorageType}:
return o.envDDBAddonBlobs()
case option{lifecycleEnvironmentLevel, rdsStorageType}:
return o.envRDSAddonBlobs()
}
return nil, fmt.Errorf("storage type %s is not supported yet", o.storageType)
}
func (o *initStorageOpts) wkldDDBAddonBlobs() ([]addonBlob, error) {
props, err := o.ddbProps()
if err != nil {
return nil, err
}
return []addonBlob{
{
path: o.ws.WorkloadAddonFilePath(o.workloadName, fmt.Sprintf("%s.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.WorkloadDDBTemplate(props),
},
}, nil
}
func (o *initStorageOpts) envDDBAddonBlobs() ([]addonBlob, error) {
ingressBlob := addonBlob{
path: o.ws.WorkloadAddonFilePath(o.workloadName, fmt.Sprintf("%s-access-policy.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.EnvDDBAccessPolicyTemplate(&addon.AccessPolicyProps{
Name: o.storageName,
}),
}
if o.addIngressFrom != "" {
return []addonBlob{ingressBlob}, nil
}
props, err := o.ddbProps()
if err != nil {
return nil, err
}
tmplBlob := addonBlob{
path: o.ws.EnvAddonFilePath(fmt.Sprintf("%s.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.EnvDDBTemplate(props),
}
if !o.workloadExists {
return []addonBlob{tmplBlob}, nil
}
return []addonBlob{tmplBlob, ingressBlob}, nil
}
func (o *initStorageOpts) ddbProps() (*addon.DynamoDBProps, error) {
props := addon.DynamoDBProps{
StorageProps: &addon.StorageProps{
Name: o.storageName,
},
}
if err := props.BuildPartitionKey(o.partitionKey); err != nil {
return nil, err
}
hasSortKey, err := props.BuildSortKey(o.noSort, o.sortKey)
if err != nil {
return nil, err
}
if hasSortKey {
_, err := props.BuildLocalSecondaryIndex(o.noLSI, o.lsiSorts)
if err != nil {
return nil, err
}
}
return &props, nil
}
func (o *initStorageOpts) wkldS3AddonBlobs() ([]addonBlob, error) {
return []addonBlob{
{
path: o.ws.WorkloadAddonFilePath(o.workloadName, fmt.Sprintf("%s.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.WorkloadS3Template(o.s3Props()),
},
}, nil
}
func (o *initStorageOpts) envS3AddonBlobs() ([]addonBlob, error) {
ingressBlob := addonBlob{
path: o.ws.WorkloadAddonFilePath(o.workloadName, fmt.Sprintf("%s-access-policy.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.EnvS3AccessPolicyTemplate(&addon.AccessPolicyProps{
Name: o.storageName,
}),
}
if o.addIngressFrom != "" {
return []addonBlob{ingressBlob}, nil
}
tmplBlob := addonBlob{
path: o.ws.EnvAddonFilePath(fmt.Sprintf("%s.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.EnvS3Template(o.s3Props()),
}
if !o.workloadExists {
return []addonBlob{tmplBlob}, nil
}
return []addonBlob{tmplBlob, ingressBlob}, nil
}
func (o *initStorageOpts) s3Props() *addon.S3Props {
return &addon.S3Props{
StorageProps: &addon.StorageProps{
Name: o.storageName,
},
}
}
func (o *initStorageOpts) wkldRDSAddonBlobs() ([]addonBlob, error) {
props, err := o.rdsProps()
if err != nil {
return nil, err
}
var tmplBlob encoding.BinaryMarshaler
switch {
case o.auroraServerlessVersion == auroraServerlessVersionV1 && o.workloadType == manifestinfo.RequestDrivenWebServiceType:
tmplBlob = addon.RDWSServerlessV1Template(props)
case o.auroraServerlessVersion == auroraServerlessVersionV1 && o.workloadType != manifestinfo.RequestDrivenWebServiceType:
tmplBlob = addon.WorkloadServerlessV1Template(props)
case o.auroraServerlessVersion == auroraServerlessVersionV2 && o.workloadType == manifestinfo.RequestDrivenWebServiceType:
tmplBlob = addon.RDWSServerlessV2Template(props)
case o.auroraServerlessVersion == auroraServerlessVersionV2 && o.workloadType != manifestinfo.RequestDrivenWebServiceType:
tmplBlob = addon.WorkloadServerlessV2Template(props)
default:
return nil, fmt.Errorf("unknown combination of serverless version %q and workload type %q", o.auroraServerlessVersion, o.workloadType)
}
blobs := []addonBlob{{
path: o.ws.WorkloadAddonFilePath(o.workloadName, fmt.Sprintf("%s.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: tmplBlob,
}}
if o.workloadType != manifestinfo.RequestDrivenWebServiceType {
return blobs, nil
}
return append(blobs, addonBlob{
path: o.ws.WorkloadAddonFilePath(o.workloadName, workspace.AddonsParametersFileName),
description: blobDescriptionParameters,
blob: addon.RDWSParamsForRDS(),
}), nil
}
func (o *initStorageOpts) envRDSAddonBlobs() ([]addonBlob, error) {
if o.workloadType == manifestinfo.RequestDrivenWebServiceType {
return o.envRDSForRDWSAddonBlobs()
}
if o.addIngressFrom != "" {
return nil, nil
}
props, err := o.rdsProps()
if err != nil {
return nil, err
}
tmplBlob := addonBlob{
path: o.ws.EnvAddonFilePath(fmt.Sprintf("%s.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.EnvServerlessTemplate(props),
}
paramBlob := addonBlob{
path: o.ws.EnvAddonFilePath(workspace.AddonsParametersFileName),
description: blobDescriptionParameters,
blob: addon.EnvParamsForRDS(),
}
return []addonBlob{tmplBlob, paramBlob}, nil
}
func (o *initStorageOpts) envRDSForRDWSAddonBlobs() ([]addonBlob, error) {
rdwsIngressTmplBlob := addonBlob{
path: o.ws.WorkloadAddonFilePath(o.workloadName, fmt.Sprintf("%s-ingress.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.EnvServerlessRDWSIngressTemplate(addon.RDSIngressProps{
ClusterName: o.storageName,
Engine: o.rdsEngine,
}),
}
rdwsIngressParamBlob := addonBlob{
path: o.ws.WorkloadAddonFilePath(o.workloadName, workspace.AddonsParametersFileName),
description: blobDescriptionParameters,
blob: addon.RDWSParamsForEnvRDS(),
}
if o.addIngressFrom != "" {
return []addonBlob{rdwsIngressTmplBlob, rdwsIngressParamBlob}, nil
}
props, err := o.rdsProps()
if err != nil {
return nil, err
}
tmplBlob := addonBlob{
path: o.ws.EnvAddonFilePath(fmt.Sprintf("%s.yml", o.storageName)),
description: blobDescriptionTemplate,
blob: addon.EnvServerlessForRDWSTemplate(props),
}
paramBlob := addonBlob{
path: o.ws.EnvAddonFilePath(workspace.AddonsParametersFileName),
description: blobDescriptionParameters,
blob: addon.EnvParamsForRDS(),
}
if o.workloadExists {
return []addonBlob{tmplBlob, paramBlob, rdwsIngressTmplBlob, rdwsIngressParamBlob}, nil
}
return []addonBlob{tmplBlob, paramBlob}, nil
}
func (o *initStorageOpts) rdsProps() (addon.RDSProps, error) {
envs, err := o.environmentNames()
if err != nil {
return addon.RDSProps{}, err
}
return addon.RDSProps{
ClusterName: o.storageName,
Engine: o.rdsEngine,
InitialDBName: o.rdsInitialDBName,
ParameterGroup: o.rdsParameterGroup,
Envs: envs,
}, nil
}
func (o *initStorageOpts) environmentNames() ([]string, error) {
var envNames []string
envs, err := o.store.ListEnvironments(o.appName)
if err != nil {
return nil, fmt.Errorf("list environments: %w", err)
}
for _, env := range envs {
envNames = append(envNames, env.Name)
}
return envNames, nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *initStorageOpts) RecommendActions() error {
switch o.lifecycle {
case lifecycleWorkloadLevel:
logRecommendedActions(o.actionsForWorkloadStorage())
case lifecycleEnvironmentLevel:
logRecommendedActions(o.actionsForEnvStorage())
}
return nil
}
func (o *initStorageOpts) actionsForWorkloadStorage() []string {
var (
retrieveEnvVarCode string
newVar string
)
switch o.storageType {
case dynamoDBStorageType, s3StorageType:
newVar = template.ToSnakeCaseFunc(template.EnvVarNameFunc(o.storageName))
retrieveEnvVarCode = fmt.Sprintf("const storageName = process.env.%s", newVar)
case rdsStorageType:
newVar = template.ToSnakeCaseFunc(template.EnvVarSecretFunc(o.storageName))
retrieveEnvVarCode = fmt.Sprintf("const {username, host, dbname, password, port} = JSON.parse(process.env.%s)", newVar)
if o.workloadType == manifestinfo.RequestDrivenWebServiceType {
newVar = fmt.Sprintf("%s_ARN", newVar)
retrieveEnvVarCode = fmt.Sprintf(`const AWS = require('aws-sdk');
const client = new AWS.SecretsManager({
region: process.env.AWS_DEFAULT_REGION,
});
const dbSecret = await client.getSecretValue({SecretId: process.env.%s}).promise();
const {username, host, dbname, password, port} = JSON.parse(dbSecret.SecretString);`, newVar)
}
}
actionRetrieveEnvVar := fmt.Sprintf(
`Update %s's code to leverage the injected environment variable %s.
For example, in JavaScript you can write:
%s`,
o.workloadName,
newVar,
color.HighlightCodeBlock(retrieveEnvVarCode))
deployCmd := fmt.Sprintf("copilot deploy --name %s", o.workloadName)
actionDeploy := fmt.Sprintf("Run %s to deploy your storage resources.", color.HighlightCode(deployCmd))
return []string{
actionRetrieveEnvVar,
actionDeploy,
}
}
func (o *initStorageOpts) actionsForEnvStorage() []string {
envDeployAction := fmt.Sprintf("Run %s to deploy your environment storage resources.", color.HighlightCode("copilot env deploy"))
svcMftAction := fmt.Sprintf("Update the manifest for your %q workload:\n%s", o.workloadName, color.HighlightCodeBlock(o.manifestSuggestion()))
svcDeployAction := fmt.Sprintf("Run %s to deploy the workload so that %s has access to %s storage.",
color.HighlightCode(fmt.Sprintf("copilot svc deploy --name %s", o.workloadName)),
color.HighlightUserInput(o.workloadName),
color.HighlightUserInput(o.storageName))
addIngressAction := fmt.Sprintf("From the workspace where %s is, run:\n%s",
color.HighlightUserInput(o.workloadName),
color.HighlightCodeBlock(o.addIngressSuggestion()))
if envAndWkldWritten := o.addIngressFrom == "" && o.workloadExists; envAndWkldWritten {
return []string{envDeployAction, svcMftAction, svcDeployAction}
}
if onlyEnv := !o.workloadExists; onlyEnv {
return []string{envDeployAction, addIngressAction}
}
if onlyWkld := o.addIngressFrom != ""; onlyWkld {
return []string{svcMftAction, svcDeployAction}
}
return nil
}
func (o *initStorageOpts) manifestSuggestion() string {
logicalIDSafeStorageName := template.StripNonAlphaNumFunc(o.storageName)
switch {
case o.storageType == s3StorageType:
return fmt.Sprintf(`variables:
DB_NAME:
from_cfn: ${COPILOT_APPLICATION_NAME}-${COPILOT_ENVIRONMENT_NAME}-%sBucketName`, logicalIDSafeStorageName)
case o.storageType == dynamoDBStorageType:
return fmt.Sprintf(`variables:
DB_NAME:
from_cfn: ${COPILOT_APPLICATION_NAME}-${COPILOT_ENVIRONMENT_NAME}-%sTableName`, logicalIDSafeStorageName)
case o.storageType == rdsStorageType && o.workloadType == manifestinfo.RequestDrivenWebServiceType:
return fmt.Sprintf(`secrets:
DB_SECRET:
from_cfn: ${COPILOT_APPLICATION_NAME}-${COPILOT_ENVIRONMENT_NAME}-%sAuroraSecret`, logicalIDSafeStorageName)
case o.storageType == rdsStorageType && o.workloadType != manifestinfo.RequestDrivenWebServiceType:
return fmt.Sprintf(`network:
vpc:
security_groups:
- from_cfn: ${COPILOT_APPLICATION_NAME}-${COPILOT_ENVIRONMENT_NAME}-%sSecurityGroup
secrets:
DB_SECRET:
from_cfn: ${COPILOT_APPLICATION_NAME}-${COPILOT_ENVIRONMENT_NAME}-%sAuroraSecret`,
logicalIDSafeStorageName, logicalIDSafeStorageName)
}
return ""
}
func (o *initStorageOpts) addIngressSuggestion() string {
return fmt.Sprintf(`copilot storage init -n %s \
--storage-type %s \
--add-ingress-from %s`, o.storageName, o.storageType, o.workloadName)
}
type errWorkloadNotInWorkspace struct {
workloadName string
}
func (e *errWorkloadNotInWorkspace) Error() string {
return fmt.Sprintf("workload %s not found in the workspace", e.workloadName)
}
// RecommendActions suggests actions to fix the error.
func (e *errWorkloadNotInWorkspace) RecommendActions() string {
return fmt.Sprintf("Run %s in the workspace where %s is instead.", color.HighlightCode("copilot storage init"), color.HighlightUserInput(e.workloadName))
}
type errNoEnvironmentInWorkspace struct{}
func (e *errNoEnvironmentInWorkspace) Error() string {
return "environments are not managed in the workspace"
}
// RecommendActions suggests actions to fix the error.
func (e *errNoEnvironmentInWorkspace) RecommendActions() string {
return fmt.Sprintf("Run %s in the workspace where environments are managed instaed.", color.HighlightCode("copilot storage init"))
}
// buildStorageInitCmd builds the command and adds it to the CLI.
func buildStorageInitCmd() *cobra.Command {
vars := initStorageVars{}
cmd := &cobra.Command{
Use: "init",
Short: "Creates a new AWS CloudFormation template for a storage resource.",
Long: `Creates a new AWS CloudFormation template for a storage resource.
Storage resources are addons, either for a workload or the environments.`,
Example: `
Create an S3 bucket named "my-bucket" attached to the "frontend" service.
/code $ copilot storage init -n my-bucket -t S3 -w frontend -l workload
Create an environment S3 bucket fronted by the "api" service.
/code $ copilot storage init -n my-bucket -t S3 -w api -l environment
Create a DynamoDB table with a sort key.
/code $ copilot storage init -n my-table -t DynamoDB -w frontend --partition-key Email:S --sort-key UserId:N --no-lsi
Create an RDS Aurora Serverless v2 cluster using PostgreSQL.
/code $ copilot storage init -n my-cluster -t Aurora -w frontend --engine PostgreSQL --initial-db testdb`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newStorageInitOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.storageName, nameFlag, nameFlagShort, "", storageFlagDescription)
cmd.Flags().StringVarP(&vars.storageType, storageTypeFlag, typeFlagShort, "", storageTypeFlagDescription)
cmd.Flags().StringVarP(&vars.workloadName, workloadFlag, workloadFlagShort, "", storageWorkloadFlagDescription)
cmd.Flags().StringVarP(&vars.lifecycle, storageLifecycleFlag, storageLifecycleShort, "", storageLifecycleFlagDescription)
cmd.Flags().StringVarP(&vars.addIngressFrom, storageAddIngressFromFlag, "", "", storageAddIngressFromFlagDescription)
cmd.Flags().StringVar(&vars.partitionKey, storagePartitionKeyFlag, "", storagePartitionKeyFlagDescription)
cmd.Flags().StringVar(&vars.sortKey, storageSortKeyFlag, "", storageSortKeyFlagDescription)
cmd.Flags().StringArrayVar(&vars.lsiSorts, storageLSIConfigFlag, []string{}, storageLSIConfigFlagDescription)
cmd.Flags().BoolVar(&vars.noLSI, storageNoLSIFlag, false, storageNoLSIFlagDescription)
cmd.Flags().BoolVar(&vars.noSort, storageNoSortFlag, false, storageNoSortFlagDescription)
cmd.Flags().StringVar(&vars.auroraServerlessVersion, storageAuroraServerlessVersionFlag, defaultAuroraServerlessVersion, storageAuroraServerlessVersionFlagDescription)
cmd.Flags().StringVar(&vars.rdsEngine, storageRDSEngineFlag, "", storageRDSEngineFlagDescription)
cmd.Flags().StringVar(&vars.rdsInitialDBName, storageRDSInitialDBFlag, "", storageRDSInitialDBFlagDescription)
cmd.Flags().StringVar(&vars.rdsParameterGroup, storageRDSParameterGroupFlag, "", storageRDSParameterGroupFlagDescription)
ddbFlags := []string{storagePartitionKeyFlag, storageSortKeyFlag, storageNoSortFlag, storageLSIConfigFlag, storageNoLSIFlag}
rdsFlags := []string{storageAuroraServerlessVersionFlag, storageRDSEngineFlag, storageRDSInitialDBFlag, storageRDSParameterGroupFlag}
for _, f := range append(ddbFlags, storageAuroraServerlessVersionFlag, storageRDSInitialDBFlag, storageRDSParameterGroupFlag) {
cmd.MarkFlagsMutuallyExclusive(storageAddIngressFromFlag, f)
}
requiredFlags := pflag.NewFlagSet("Required", pflag.ContinueOnError)
requiredFlags.AddFlag(cmd.Flags().Lookup(nameFlag))
requiredFlags.AddFlag(cmd.Flags().Lookup(storageTypeFlag))
requiredFlags.AddFlag(cmd.Flags().Lookup(workloadFlag))
requiredFlags.AddFlag(cmd.Flags().Lookup(storageLifecycleFlag))
ddbFlagSet := pflag.NewFlagSet("DynamoDB", pflag.ContinueOnError)
for _, f := range ddbFlags {
ddbFlagSet.AddFlag(cmd.Flags().Lookup(f))
}
auroraFlagSet := pflag.NewFlagSet("Aurora Serverless", pflag.ContinueOnError)
for _, f := range rdsFlags {
auroraFlagSet.AddFlag(cmd.Flags().Lookup(f))
}
optionalFlagSet := pflag.NewFlagSet("Optional", pflag.ContinueOnError)
optionalFlagSet.AddFlag(cmd.Flags().Lookup(storageAddIngressFromFlag))
cmd.Annotations = map[string]string{
// The order of the sections we want to display.
"sections": `Required,DynamoDB,Aurora Serverless,Optional`,
"Required": requiredFlags.FlagUsages(),
"DynamoDB": ddbFlagSet.FlagUsages(),
"Aurora Serverless": auroraFlagSet.FlagUsages(),
"Optional": optionalFlagSet.FlagUsages(),
}
cmd.SetUsageTemplate(`{{h1 "Usage"}}{{if .Runnable}}
{{.UseLine}}{{end}}{{$annotations := .Annotations}}{{$sections := split .Annotations.sections ","}}{{if gt (len $sections) 0}}
{{range $i, $sectionName := $sections}}{{h1 (print $sectionName " Flags")}}
{{(index $annotations $sectionName) | trimTrailingWhitespaces}}{{if ne (inc $i) (len $sections)}}
{{end}}{{end}}{{end}}{{if .HasAvailableInheritedFlags}}
{{h1 "Global Flags"}}
{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasExample}}
{{h1 "Examples"}}{{code .Example}}{{end}}
`)
return cmd
}
| 1,297 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type mockStorageInitValidate struct {
ws *mocks.MockwsReadWriter
store *mocks.Mockstore
}
func TestStorageInitOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inAppName string
inStorageType string
inSvcName string
inStorageName string
inLifecycle string
inAddIngressFrom string
inPartition string
inSort string
inLSISorts []string
inNoSort bool
inNoLSI bool
inServerlessVersion string
inEngine string
mock func(m *mockStorageInitValidate)
wantedErr error
}{
"no app in workspace": {
mock: func(m *mockStorageInitValidate) {},
wantedErr: errNoAppInWorkspace,
},
"fails when --add-ingress-from is accompanied by workload name": {
inAppName: "bowie",
inAddIngressFrom: "api",
inSvcName: "nonamemonster",
mock: func(m *mockStorageInitValidate) {},
wantedErr: errors.New("--workload cannot be specified with --add-ingress-from"),
},
"fails when --add-ingress-from is accompanied by workload-level lifecycle": {
inAppName: "bowie",
inAddIngressFrom: "api",
inLifecycle: lifecycleWorkloadLevel,
mock: func(m *mockStorageInitValidate) {},
wantedErr: errors.New("--lifecycle cannot be workload when --add-ingress-from is used"),
},
"fails when --add-ingress-from is not accompanied by storage name": {
inAppName: "bowie",
inAddIngressFrom: "api",
mock: func(m *mockStorageInitValidate) {},
wantedErr: errors.New("--name is required when --add-ingress-from is used"),
},
"fails when --add-ingress-from is not accompanied by storage type": {
inAppName: "bowie",
inAddIngressFrom: "api",
inStorageName: "coolbucket",
mock: func(m *mockStorageInitValidate) {},
wantedErr: errors.New("--storage-type is required when --add-ingress-from is used"),
},
"fails to check if --add-ingress-from workload is in the workspace": {
inAppName: "bowie",
inAddIngressFrom: "api",
inStorageName: "coolbucket",
inStorageType: s3StorageType,
mock: func(m *mockStorageInitValidate) {
m.ws.EXPECT().WorkloadExists("api").Return(false, errors.New("some error"))
},
wantedErr: errors.New("check if api exists in the workspace: some error"),
},
"fails when --add-ingress-from workload is not in the workspace": {
inAppName: "bowie",
inAddIngressFrom: "api",
inStorageName: "coolbucket",
inStorageType: s3StorageType,
mock: func(m *mockStorageInitValidate) {
m.ws.EXPECT().WorkloadExists("api").Return(false, nil)
},
wantedErr: errors.New("workload api not found in the workspace"),
},
"fails when --no-lsi and --lsi are both provided": {
inAppName: "bowie",
inStorageType: dynamoDBStorageType,
inLSISorts: []string{"userID:Number"},
inNoLSI: true,
mock: func(m *mockStorageInitValidate) {},
wantedErr: fmt.Errorf("validate LSI configuration: cannot specify --no-lsi and --lsi options at once"),
},
"fails when --no-sort and --lsi are both provided": {
inAppName: "bowie",
inStorageType: dynamoDBStorageType,
inLSISorts: []string{"userID:Number"},
inNoSort: true,
mock: func(m *mockStorageInitValidate) {},
wantedErr: fmt.Errorf("validate LSI configuration: cannot specify --no-sort and --lsi options at once"),
},
"successfully validates aurora serverless version v1": {
inAppName: "bowie",
inStorageType: rdsStorageType,
inServerlessVersion: auroraServerlessVersionV1,
mock: func(m *mockStorageInitValidate) {},
},
"successfully validates aurora serverless version v2": {
inAppName: "bowie",
inStorageType: rdsStorageType,
inServerlessVersion: auroraServerlessVersionV2,
mock: func(m *mockStorageInitValidate) {},
},
"invalid aurora serverless version": {
inAppName: "bowie",
inStorageType: rdsStorageType,
inServerlessVersion: "weird-serverless-version",
mock: func(m *mockStorageInitValidate) {},
wantedErr: errors.New("invalid Aurora Serverless version weird-serverless-version: must be one of \"v1\", \"v2\""),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := mockStorageInitValidate{
ws: mocks.NewMockwsReadWriter(ctrl),
store: mocks.NewMockstore(ctrl),
}
tc.mock(&m)
opts := initStorageOpts{
initStorageVars: initStorageVars{
storageType: tc.inStorageType,
storageName: tc.inStorageName,
workloadName: tc.inSvcName,
lifecycle: tc.inLifecycle,
addIngressFrom: tc.inAddIngressFrom,
partitionKey: tc.inPartition,
sortKey: tc.inSort,
lsiSorts: tc.inLSISorts,
noLSI: tc.inNoLSI,
noSort: tc.inNoSort,
auroraServerlessVersion: tc.inServerlessVersion,
rdsEngine: tc.inEngine,
},
appName: tc.inAppName,
ws: m.ws,
store: m.store,
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
type mockStorageInitAsk struct {
prompt *mocks.Mockprompter
sel *mocks.MockwsSelector
configSel *mocks.MockconfigSelector
ws *mocks.MockwsReadWriter
}
func TestStorageInitOpts_Ask(t *testing.T) {
const (
wantedAppName = "bowie"
wantedSvcName = "frontend"
wantedBucketName = "cool-bucket"
)
testCases := map[string]struct {
inStorageType string
inSvcName string
inStorageName string
inLifecycle string
inAddIngressFrom string
mock func(m *mockStorageInitAsk)
wantedErr error
wantedVars *initStorageVars
}{
"prompt for nothing if --add-ingress-from is used": {
inAddIngressFrom: "api",
mock: func(m *mockStorageInitAsk) {},
},
"invalid storage type": {
inStorageType: "box",
inSvcName: "frontend",
mock: func(m *mockStorageInitAsk) {},
wantedErr: errors.New(`invalid storage type box: must be one of "DynamoDB", "S3", "Aurora"`),
},
"asks for storage type": {
inSvcName: wantedSvcName,
inStorageName: wantedBucketName,
inLifecycle: lifecycleWorkloadLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(s3StorageType, nil)
},
wantedVars: &initStorageVars{
storageType: s3StorageType,
storageName: wantedBucketName,
workloadName: wantedSvcName,
lifecycle: lifecycleWorkloadLevel,
},
},
"error if storage type not gotten": {
inSvcName: wantedSvcName,
inStorageName: wantedBucketName,
mock: func(m *mockStorageInitAsk) {
m.prompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("select storage type: some error"),
},
"asks for local workload when lifecycle is workload-level": {
inStorageName: wantedBucketName,
inStorageType: s3StorageType,
inLifecycle: lifecycleWorkloadLevel,
mock: func(m *mockStorageInitAsk) {
m.sel.EXPECT().Workload(gomock.Eq(storageInitSvcPrompt), gomock.Any()).Return(wantedSvcName, nil)
m.ws.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
},
wantedVars: &initStorageVars{
storageType: s3StorageType,
storageName: wantedBucketName,
workloadName: wantedSvcName,
lifecycle: lifecycleWorkloadLevel,
},
},
"asks for any workload if lifecycle is otherwise": {
inStorageName: wantedBucketName,
inStorageType: s3StorageType,
inLifecycle: lifecycleEnvironmentLevel,
mock: func(m *mockStorageInitAsk) {
m.configSel.EXPECT().Workload(gomock.Eq(storageInitSvcPrompt), gomock.Any(), wantedAppName).Return(wantedSvcName, nil)
m.ws.EXPECT().HasEnvironments().Return(true, nil)
},
wantedVars: &initStorageVars{
storageType: s3StorageType,
storageName: wantedBucketName,
workloadName: wantedSvcName,
lifecycle: lifecycleEnvironmentLevel,
},
},
"error if local workload not returned": {
inStorageName: wantedBucketName,
inStorageType: s3StorageType,
inLifecycle: lifecycleWorkloadLevel,
mock: func(m *mockStorageInitAsk) {
m.sel.EXPECT().Workload(gomock.Eq(storageInitSvcPrompt), gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("retrieve local workload names: some error"),
},
"error if any workload not returned": {
inStorageName: wantedBucketName,
inStorageType: s3StorageType,
mock: func(m *mockStorageInitAsk) {
m.configSel.EXPECT().Workload(gomock.Eq(storageInitSvcPrompt), gomock.Any(), wantedAppName).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("select a workload from app %s: some error", wantedAppName),
},
"successfully validates valid s3 bucket name": {
inSvcName: "frontend",
inStorageType: s3StorageType,
inStorageName: "my-bucket.4",
inLifecycle: lifecycleEnvironmentLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(true, nil)
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
},
},
"invalid s3 bucket name": {
inSvcName: "frontend",
inStorageType: s3StorageType,
inStorageName: "mybadbucket???",
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
},
wantedErr: fmt.Errorf("validate storage name: %w", errValueBadFormatWithPeriod),
},
"asks for storage name": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inLifecycle: lifecycleWorkloadLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Get(gomock.Eq(fmt.Sprintf(fmtStorageInitNamePrompt, color.HighlightUserInput(s3BucketFriendlyText))),
gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedBucketName, nil)
},
wantedVars: &initStorageVars{
storageType: s3StorageType,
storageName: wantedBucketName,
workloadName: wantedSvcName,
lifecycle: lifecycleWorkloadLevel,
},
},
"error if storage name not returned": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
mock: func(m *mockStorageInitAsk) {
m.prompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("input storage name: some error"),
},
"invalid lifecycle": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
inLifecycle: "immortal",
mock: func(m *mockStorageInitAsk) {},
wantedErr: fmt.Errorf(`invalid lifecycle; must be one of "workload" or "environment"`),
},
"infer lifecycle to be workload level if the addon is found as a workload addon": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadAddonFileAbsPath(wantedSvcName, fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockWorkloadAddonPath")
m.ws.EXPECT().ReadFile("mockWorkloadAddonPath").Return([]byte(""), nil)
m.ws.EXPECT().WorkloadAddonFilePath(wantedSvcName, fmt.Sprintf("%s.yml", wantedBucketName)).
Return("mockWorkloadAddonPath") // Called in log.Info.
m.ws.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
},
wantedVars: &initStorageVars{
storageType: s3StorageType,
storageName: wantedBucketName,
workloadName: wantedSvcName,
lifecycle: lifecycleWorkloadLevel,
},
},
"error reading workload addon": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadAddonFileAbsPath(wantedSvcName, fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockWorkloadAddonPath")
m.ws.EXPECT().ReadFile("mockWorkloadAddonPath").Return([]byte(""), errors.New("some error"))
},
wantedErr: fmt.Errorf("check if %s addon exists for %s in workspace: some error", wantedBucketName, wantedSvcName),
},
"infer lifecycle to be env level if the addon is found as an env addon": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadAddonFileAbsPath(wantedSvcName, fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockWorkloadAddonPath")
m.ws.EXPECT().ReadFile("mockWorkloadAddonPath").Return([]byte(""), &workspace.ErrFileNotExists{})
m.ws.EXPECT().EnvAddonFileAbsPath(fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockEnvAddonPath")
m.ws.EXPECT().ReadFile("mockEnvAddonPath").Return([]byte(""), nil)
m.ws.EXPECT().EnvAddonFilePath(fmt.Sprintf("%s.yml", wantedBucketName)).
Return("mockEnvAddonPath") // Called in log.Info.
m.ws.EXPECT().HasEnvironments().Return(true, nil)
},
wantedVars: &initStorageVars{
storageType: s3StorageType,
storageName: wantedBucketName,
workloadName: wantedSvcName,
lifecycle: lifecycleEnvironmentLevel,
},
},
"error reading environment addon": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadAddonFileAbsPath(wantedSvcName, fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockWorkloadAddonPath")
m.ws.EXPECT().ReadFile("mockWorkloadAddonPath").Return([]byte(""), &workspace.ErrFileNotExists{})
m.ws.EXPECT().EnvAddonFileAbsPath(fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockEnvAddonPath")
m.ws.EXPECT().ReadFile("mockEnvAddonPath").Return([]byte(""), errors.New("some error"))
},
wantedErr: fmt.Errorf("check if %s exists as an environment addon in workspace: some error", wantedBucketName),
},
"asks for lifecycle": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadAddonFileAbsPath(wantedSvcName, fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockWorkloadAddonPath")
m.ws.EXPECT().ReadFile("mockWorkloadAddonPath").Return([]byte(""), &workspace.ErrFileNotExists{})
m.ws.EXPECT().EnvAddonFileAbsPath(fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockEnvAddonPath")
m.ws.EXPECT().ReadFile("mockEnvAddonPath").Return([]byte(""), &workspace.ErrFileNotExists{})
m.prompt.EXPECT().SelectOption(fmt.Sprintf(fmtStorageInitLifecyclePrompt, wantedSvcName), gomock.Any(), gomock.Any(), gomock.Any()).Return(lifecycleWorkloadLevel, nil)
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
},
wantedVars: &initStorageVars{
storageType: s3StorageType,
storageName: wantedBucketName,
workloadName: wantedSvcName,
lifecycle: lifecycleWorkloadLevel,
},
},
"error if lifecycle not gotten": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadAddonFileAbsPath(wantedSvcName, fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockWorkloadAddonPath")
m.ws.EXPECT().ReadFile("mockWorkloadAddonPath").Return([]byte(""), &workspace.ErrFileNotExists{})
m.ws.EXPECT().EnvAddonFileAbsPath(fmt.Sprintf("%s.yml", wantedBucketName)).Return("mockEnvAddonPath")
m.ws.EXPECT().ReadFile("mockEnvAddonPath").Return([]byte(""), &workspace.ErrFileNotExists{})
m.prompt.EXPECT().SelectOption(fmt.Sprintf(fmtStorageInitLifecyclePrompt, wantedSvcName), gomock.Any(), gomock.Any(), gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: errors.New("ask for lifecycle: some error"),
},
"error checking if any environment is in workspace": {
inStorageType: s3StorageType,
inSvcName: "frontend",
inStorageName: "my-bucket",
inLifecycle: lifecycleEnvironmentLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(false, errors.New("wanted err"))
},
wantedErr: errors.New("check if environments directory exists in the workspace: wanted err"),
},
"error if environments are not managed in workspace for a env-level storage": {
inStorageType: s3StorageType,
inSvcName: "frontend",
inStorageName: "my-bucket",
inLifecycle: lifecycleEnvironmentLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(false, nil)
},
wantedErr: errors.New("environments are not managed in the workspace"),
},
"error checking if workload is in workspace": {
inStorageType: s3StorageType,
inSvcName: "frontend",
inStorageName: "my-bucket",
inLifecycle: lifecycleWorkloadLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Eq("frontend")).Return(false, errors.New("wanted err"))
},
wantedErr: errors.New("check if frontend exists in the workspace: wanted err"),
},
"error if workload is not in workspace for a workload-level storage": {
inStorageType: s3StorageType,
inSvcName: "frontend",
inStorageName: "my-bucket",
inLifecycle: lifecycleWorkloadLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Eq("frontend")).Return(false, nil)
},
wantedErr: errors.New("workload frontend not found in the workspace"),
},
"ok if workload is not in workspace for an env-level storage": {
inStorageType: s3StorageType,
inSvcName: "frontend",
inStorageName: "my-bucket",
inLifecycle: lifecycleEnvironmentLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(true, nil)
m.ws.EXPECT().WorkloadExists(gomock.Eq("frontend")).Times(0)
},
},
"no error or asks when fully specified": {
inSvcName: wantedSvcName,
inStorageType: s3StorageType,
inStorageName: wantedBucketName,
inLifecycle: lifecycleEnvironmentLevel,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(true, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := mockStorageInitAsk{
prompt: mocks.NewMockprompter(ctrl),
sel: mocks.NewMockwsSelector(ctrl),
configSel: mocks.NewMockconfigSelector(ctrl),
ws: mocks.NewMockwsReadWriter(ctrl),
}
opts := initStorageOpts{
initStorageVars: initStorageVars{
storageType: tc.inStorageType,
storageName: tc.inStorageName,
workloadName: tc.inSvcName,
lifecycle: tc.inLifecycle,
addIngressFrom: tc.inAddIngressFrom,
},
appName: wantedAppName,
sel: m.sel,
configSel: m.configSel,
prompt: m.prompt,
ws: m.ws,
}
tc.mock(&m)
// WHEN
err := opts.Ask()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
if tc.wantedVars != nil {
require.Equal(t, *tc.wantedVars, opts.initStorageVars)
}
})
}
}
func TestStorageInitOpts_AskDDB(t *testing.T) {
const (
wantedSvcName = "frontend"
wantedTableName = "my-cool_table.3"
wantedPartitionKey = "DogName:String"
wantedSortKey = "PhotoId:Number"
)
testCases := map[string]struct {
inStorageName string
inPartition string
inSort string
inLSISorts []string
inNoLSI bool
inNoSort bool
mock func(m *mockStorageInitAsk)
wantedErr error
wantedVars *initStorageVars
}{
"invalid ddb name": {
inStorageName: "badTable!!!",
mock: func(m *mockStorageInitAsk) {},
wantedErr: fmt.Errorf("validate storage name: %w", errValueBadFormatWithPeriodUnderscore),
},
"invalid partition key": {
inStorageName: wantedTableName,
inPartition: "bipartite",
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
},
wantedErr: errors.New("validate partition key: value must be of the form <name>:<T> where T is one of S, N, or B"),
},
"asks for partition key if not specified": {
inStorageName: wantedTableName,
inSort: wantedSortKey,
inNoLSI: true,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
keyPrompt := fmt.Sprintf(fmtStorageInitDDBKeyPrompt,
color.HighlightUserInput("partition key"),
color.HighlightUserInput(dynamoDBStorageType),
)
keyTypePrompt := fmt.Sprintf(fmtStorageInitDDBKeyTypePrompt, ddbKeyString)
m.prompt.EXPECT().Get(gomock.Eq(keyPrompt),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(wantedPartitionKey, nil)
m.prompt.EXPECT().SelectOne(gomock.Eq(keyTypePrompt),
gomock.Any(),
attributeTypes,
gomock.Any(),
).Return(ddbStringType, nil)
},
},
"error if fail to return partition key": {
inStorageName: wantedTableName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Get(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("get DDB partition key: some error"),
},
"error if fail to return partition key type": {
inStorageName: wantedTableName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Get(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(wantedPartitionKey, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("get DDB partition key datatype: some error"),
},
"invalid sort key": {
inStorageName: wantedTableName,
inPartition: wantedSortKey,
inSort: "allsortofstuff",
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
},
wantedErr: errors.New("validate sort key: value must be of the form <name>:<T> where T is one of S, N, or B"),
},
"ask for sort key if not specified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inNoLSI: true,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBSortKeyConfirm),
gomock.Any(),
gomock.Any(),
).Return(true, nil)
keyPrompt := fmt.Sprintf(fmtStorageInitDDBKeyPrompt,
color.HighlightUserInput("sort key"),
color.HighlightUserInput(dynamoDBStorageType),
)
keyTypePrompt := fmt.Sprintf(fmtStorageInitDDBKeyTypePrompt, ddbKeyString)
m.prompt.EXPECT().Get(gomock.Eq(keyPrompt),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(wantedPartitionKey, nil)
m.prompt.EXPECT().SelectOne(gomock.Eq(keyTypePrompt),
gomock.Any(),
attributeTypes,
gomock.Any(),
).Return(ddbStringType, nil)
},
},
"error if fail to confirm add sort key": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBSortKeyConfirm),
gomock.Any(),
gomock.Any(),
).Return(false, errors.New("some error"))
},
wantedErr: fmt.Errorf("confirm DDB sort key: some error"),
},
"error if fail to return sort key": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBSortKeyConfirm),
gomock.Any(),
gomock.Any(),
).Return(true, nil)
m.prompt.EXPECT().Get(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("get DDB sort key: some error"),
},
"error if fail to return sort key type": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBSortKeyConfirm),
gomock.Any(),
gomock.Any(),
).Return(true, nil)
m.prompt.EXPECT().Get(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(wantedPartitionKey, nil)
m.prompt.EXPECT().SelectOne(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("get DDB sort key datatype: some error"),
},
"don't ask for sort key if no-sort specified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inNoSort: true,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBSortKeyConfirm),
gomock.Any(),
gomock.Any(),
).Times(0)
},
},
"ok if --no-lsi and --sort-key are both specified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
inNoLSI: true,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
},
},
"don't ask about LSI if no-sort is specified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inNoSort: true,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBLSIPrompt),
gomock.Eq(storageInitDDBLSIHelp),
gomock.Any(),
).Times(0)
},
},
"ask for LSI if not specified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
lsiTypePrompt := fmt.Sprintf(fmtStorageInitDDBKeyTypePrompt, color.Emphasize("alternate sort key"))
lsiTypeHelp := fmt.Sprintf(fmtStorageInitDDBKeyTypeHelp, "alternate sort key")
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBLSIPrompt),
gomock.Eq(storageInitDDBLSIHelp),
gomock.Any(),
).Return(true, nil)
m.prompt.EXPECT().Get(
gomock.Eq(storageInitDDBLSINamePrompt),
gomock.Eq(storageInitDDBLSINameHelp),
gomock.Any(),
gomock.Any(),
).Return("Email", nil)
m.prompt.EXPECT().SelectOne(
gomock.Eq(lsiTypePrompt),
gomock.Eq(lsiTypeHelp),
gomock.Eq(attributeTypes),
gomock.Any(),
).Return(ddbStringType, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBMoreLSIPrompt),
gomock.Eq(storageInitDDBLSIHelp),
gomock.Any(),
).Return(false, nil)
},
wantedVars: &initStorageVars{
storageName: wantedTableName,
workloadName: wantedSvcName,
storageType: dynamoDBStorageType,
lifecycle: lifecycleWorkloadLevel,
partitionKey: wantedPartitionKey,
sortKey: wantedSortKey,
noLSI: false,
lsiSorts: []string{"Email:String"},
},
},
"noLSI is set correctly if no lsis specified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBLSIPrompt),
gomock.Eq(storageInitDDBLSIHelp),
gomock.Any(),
).Return(false, nil)
},
wantedVars: &initStorageVars{
storageName: wantedTableName,
workloadName: wantedSvcName,
storageType: dynamoDBStorageType,
lifecycle: lifecycleWorkloadLevel,
partitionKey: wantedPartitionKey,
sortKey: wantedSortKey,
noLSI: true,
},
},
"noLSI is set correctly if no sort key": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBSortKeyConfirm),
gomock.Eq(storageInitDDBSortKeyHelp),
gomock.Any(),
).Return(false, nil)
},
wantedVars: &initStorageVars{
storageName: wantedTableName,
workloadName: wantedSvcName,
storageType: dynamoDBStorageType,
lifecycle: lifecycleWorkloadLevel,
partitionKey: wantedPartitionKey,
noLSI: true,
noSort: true,
},
},
"error if lsi name misspecified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Eq(storageInitDDBLSIPrompt),
gomock.Any(),
gomock.Any(),
).Return(true, nil)
m.prompt.EXPECT().Get(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("get DDB alternate sort key name: some error"),
},
"errors if fail to confirm lsi": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(false, errors.New("some error"))
},
wantedErr: fmt.Errorf("confirm add alternate sort key: some error"),
},
"error if lsi type misspecified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
m.prompt.EXPECT().Confirm(
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(true, nil)
m.prompt.EXPECT().Get(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("cool", nil)
m.prompt.EXPECT().SelectOne(gomock.Any(),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("get DDB alternate sort key type: some error"),
},
"do not ask for ddb config when fully specified": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
inLSISorts: []string{"userID:Number", "data:Binary"},
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
},
},
"successfully validate flags with non-config": {
inStorageName: wantedTableName,
inPartition: wantedPartitionKey,
inNoSort: true,
inNoLSI: true,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := mockStorageInitAsk{
ws: mocks.NewMockwsReadWriter(ctrl),
prompt: mocks.NewMockprompter(ctrl),
}
tc.mock(&m)
opts := initStorageOpts{
initStorageVars: initStorageVars{
storageType: dynamoDBStorageType,
storageName: tc.inStorageName,
workloadName: wantedSvcName,
partitionKey: tc.inPartition,
sortKey: tc.inSort,
lsiSorts: tc.inLSISorts,
noLSI: tc.inNoLSI,
noSort: tc.inNoSort,
lifecycle: lifecycleWorkloadLevel,
},
appName: "ddos",
prompt: m.prompt,
ws: m.ws,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
if tc.wantedVars != nil {
require.Equal(t, *tc.wantedVars, opts.initStorageVars)
}
})
}
}
func TestStorageInitOpts_AskRDS(t *testing.T) {
const (
wantedSvcName = "frontend"
wantedClusterName = "cookie"
wantedServerlessVersion = auroraServerlessVersionV2
wantedInitialDBName = "mydb"
wantedDBEngine = engineTypePostgreSQL
)
testCases := map[string]struct {
inStorageName string
inPartition string
inSort string
inLSISorts []string
inNoLSI bool
inNoSort bool
inServerlessVersion string
inDBEngine string
inInitialDBName string
mock func(m *mockStorageInitAsk)
wantedErr error
wantedVars *initStorageVars
}{
"invalid cluster name": {
inStorageName: "wow!such name..:doge",
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
},
wantedErr: errors.New("validate storage name: value must start with a letter and followed by alphanumeric letters only"),
},
"asks for cluster name for RDS storage": {
inDBEngine: wantedDBEngine,
inInitialDBName: wantedInitialDBName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
m.prompt.EXPECT().Get(
gomock.Eq("What would you like to name this Database Cluster?"),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return(wantedClusterName, nil)
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
},
wantedVars: &initStorageVars{
storageType: rdsStorageType,
storageName: wantedClusterName,
workloadName: wantedSvcName,
lifecycle: lifecycleEnvironmentLevel,
auroraServerlessVersion: wantedServerlessVersion,
rdsEngine: wantedDBEngine,
rdsInitialDBName: wantedInitialDBName,
},
},
"error if cluster name not gotten": {
mock: func(m *mockStorageInitAsk) {
m.prompt.EXPECT().Get(
gomock.Eq("What would you like to name this Database Cluster?"),
gomock.Any(),
gomock.Any(),
gomock.Any(),
).Return("", errors.New("some error"))
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
},
wantedErr: errors.New("input storage name: some error"),
},
"invalid database engine type": {
inStorageName: wantedClusterName,
inDBEngine: "mysql",
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
},
wantedErr: errors.New("invalid engine type mysql: must be one of \"MySQL\", \"PostgreSQL\""),
},
"asks for engine if not specified": {
inStorageName: wantedClusterName,
inInitialDBName: wantedInitialDBName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
m.prompt.EXPECT().SelectOne(gomock.Eq(storageInitRDSDBEnginePrompt), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedDBEngine, nil)
},
wantedVars: &initStorageVars{
storageType: rdsStorageType,
storageName: wantedClusterName,
workloadName: wantedSvcName,
lifecycle: lifecycleEnvironmentLevel,
auroraServerlessVersion: wantedServerlessVersion,
rdsInitialDBName: wantedInitialDBName,
rdsEngine: wantedDBEngine,
},
},
"error if engine not gotten": {
inStorageName: wantedClusterName,
inInitialDBName: wantedInitialDBName,
mock: func(m *mockStorageInitAsk) {
m.prompt.EXPECT().SelectOne(storageInitRDSDBEnginePrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return("", errors.New("some error"))
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
},
wantedErr: errors.New("select database engine: some error"),
},
"invalid initial database name": {
inStorageName: wantedClusterName,
inDBEngine: wantedDBEngine,
inInitialDBName: "wow!suchweird??name!",
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
},
wantedErr: errors.New("invalid database name wow!suchweird??name!: must contain only alphanumeric characters and underscore; should start with a letter"),
},
"asks for initial database name": {
inStorageName: wantedClusterName,
inDBEngine: wantedDBEngine,
mock: func(m *mockStorageInitAsk) {
m.prompt.EXPECT().Get(gomock.Eq(storageInitRDSInitialDBNamePrompt), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedInitialDBName, nil)
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
},
wantedVars: &initStorageVars{
storageType: rdsStorageType,
storageName: wantedClusterName,
workloadName: wantedSvcName,
lifecycle: lifecycleEnvironmentLevel,
auroraServerlessVersion: wantedServerlessVersion,
rdsEngine: wantedDBEngine,
rdsInitialDBName: wantedInitialDBName,
},
},
"error if initial database name not gotten": {
inStorageName: wantedClusterName,
inDBEngine: wantedDBEngine,
mock: func(m *mockStorageInitAsk) {
m.prompt.EXPECT().Get(storageInitRDSInitialDBNamePrompt, gomock.Any(), gomock.Any(), gomock.Any()).
Return("", errors.New("some error"))
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
},
wantedErr: fmt.Errorf("input initial database name: some error"),
},
"successfully validate rds with full config": {
inStorageName: wantedClusterName,
inDBEngine: wantedDBEngine,
inInitialDBName: wantedInitialDBName,
mock: func(m *mockStorageInitAsk) {
m.ws.EXPECT().HasEnvironments().Return(true, nil).AnyTimes()
m.ws.EXPECT().WorkloadExists(gomock.Any()).Return(true, nil).AnyTimes()
m.ws.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(workspace.WorkloadManifest("type: Load Balanced Web Service"), nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := mockStorageInitAsk{
prompt: mocks.NewMockprompter(ctrl),
ws: mocks.NewMockwsReadWriter(ctrl),
}
opts := initStorageOpts{
initStorageVars: initStorageVars{
storageType: rdsStorageType,
workloadName: wantedSvcName,
storageName: tc.inStorageName,
lifecycle: lifecycleEnvironmentLevel,
auroraServerlessVersion: wantedServerlessVersion,
rdsEngine: tc.inDBEngine,
rdsInitialDBName: tc.inInitialDBName,
},
appName: "ddos",
prompt: m.prompt,
ws: m.ws,
}
tc.mock(&m)
// WHEN
err := opts.Ask()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
if tc.wantedVars != nil {
require.Equal(t, *tc.wantedVars, opts.initStorageVars)
}
})
}
}
func TestStorageInitOpts_Execute(t *testing.T) {
const (
wantedAppName = "ddos"
wantedSvcName = "frontend"
wantedPartitionKey = "DogName:String"
wantedSortKey = "PhotoId:Number"
)
fileExistsError := &workspace.ErrFileExists{FileName: "my-file"}
testCases := map[string]struct {
inStorageType string
inSvcName string
inStorageName string
inAddIngressFrom string
inPartition string
inSort string
inLSISorts []string
inNoLSI bool
inNoSort bool
inServerlessVersion string
inEngine string
inInitialDBName string
inParameterGroup string
inLifecycle string
mockWS func(m *mocks.MockwsReadWriter)
mockStore func(m *mocks.Mockstore)
mockWkldAbsent bool
wantedErr error
}{
"happy calls for wkld S3": {
inStorageType: s3StorageType,
inSvcName: wantedSvcName,
inStorageName: "my-bucket",
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-bucket.yml")).Return("mockPath")
m.EXPECT().Write(gomock.Any(), "mockPath").Return("/frontend/addons/my-bucket.yml", nil)
},
},
"happy calls for wkld DDB": {
inStorageType: dynamoDBStorageType,
inSvcName: wantedSvcName,
inStorageName: "my-table",
inNoLSI: true,
inNoSort: true,
inPartition: wantedPartitionKey,
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-table.yml")).Return("mockPath")
m.EXPECT().Write(gomock.Any(), "mockPath").Return("/frontend/addons/my-table.yml", nil)
},
},
"happy calls for wkld DDB with LSI": {
inStorageType: dynamoDBStorageType,
inSvcName: wantedSvcName,
inStorageName: "my-table",
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
inLSISorts: []string{"goodness:Number"},
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-table.yml")).Return("mockPath")
m.EXPECT().Write(gomock.Any(), "mockPath").Return("/frontend/addons/my-table.yml", nil)
},
},
"happy calls for wkld RDS with LBWS": {
inSvcName: wantedSvcName,
inStorageType: rdsStorageType,
inStorageName: "mycluster",
inServerlessVersion: auroraServerlessVersionV1,
inEngine: engineTypeMySQL,
inParameterGroup: "mygroup",
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("mycluster.yml")).Return("mockPath")
m.EXPECT().Write(gomock.Any(), "mockPath").Return("/frontend/addons/mycluster.yml", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments(gomock.Any()).Times(1)
},
},
"happy calls for wkld RDS with a RDWS": {
inSvcName: wantedSvcName,
inStorageType: rdsStorageType,
inStorageName: "mycluster",
inServerlessVersion: auroraServerlessVersionV1,
inEngine: engineTypeMySQL,
inParameterGroup: "mygroup",
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Request-Driven Web Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("mycluster.yml")).Return("mockTmplPath")
m.EXPECT().Write(gomock.Any(), "mockTmplPath").Return("/frontend/addons/mycluster.yml", nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("addons.parameters.yml")).Return("mockParamsPath")
m.EXPECT().Write(gomock.Any(), "mockParamsPath").Return("/frontend/addons/addons.parameters.yml", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments(gomock.Any()).Times(1)
},
},
"happy calls for env S3": {
inStorageType: s3StorageType,
inSvcName: wantedSvcName,
inStorageName: "my-bucket",
inLifecycle: lifecycleEnvironmentLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().EnvAddonFilePath(gomock.Eq("my-bucket.yml")).Return("mockEnvTemplatePath")
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-bucket-access-policy.yml")).Return("mockWkldTemplatePath")
m.EXPECT().Write(gomock.Any(), "mockEnvTemplatePath").Return("mockEnvTemplatePath", nil)
m.EXPECT().Write(gomock.Any(), "mockWkldTemplatePath").Return("mockWkldTemplatePath", nil)
},
},
"happy calls for env DDB": {
inStorageType: dynamoDBStorageType,
inSvcName: wantedSvcName,
inStorageName: "my-table",
inNoLSI: true,
inNoSort: true,
inPartition: wantedPartitionKey,
inLifecycle: lifecycleEnvironmentLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().EnvAddonFilePath(gomock.Eq("my-table.yml")).Return("mockEnvTemplatePath")
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-table-access-policy.yml")).Return("mockWkldTemplatePath")
m.EXPECT().Write(gomock.Any(), "mockEnvTemplatePath").Return("mockEnvTemplatePath", nil)
m.EXPECT().Write(gomock.Any(), "mockWkldTemplatePath").Return("mockWkldTemplatePath", nil)
},
},
"happy calls for env DDB with LSI": {
inStorageType: dynamoDBStorageType,
inSvcName: wantedSvcName,
inStorageName: "my-table",
inPartition: wantedPartitionKey,
inSort: wantedSortKey,
inLSISorts: []string{"goodness:Number"},
inLifecycle: lifecycleEnvironmentLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().EnvAddonFilePath(gomock.Eq("my-table.yml")).Return("mockEnvTemplatePath")
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-table-access-policy.yml")).Return("mockWkldTemplatePath")
m.EXPECT().Write(gomock.Any(), "mockEnvTemplatePath").Return("mockEnvTemplatePath", nil)
m.EXPECT().Write(gomock.Any(), "mockWkldTemplatePath").Return("mockWkldTemplatePath", nil)
},
},
"happy calls for env RDS with LBWS": {
inSvcName: wantedSvcName,
inStorageType: rdsStorageType,
inStorageName: "mycluster",
inServerlessVersion: auroraServerlessVersionV1,
inEngine: engineTypeMySQL,
inParameterGroup: "mygroup",
inLifecycle: lifecycleEnvironmentLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Load-Balanced Web Service"), nil)
m.EXPECT().EnvAddonFilePath(gomock.Eq("mycluster.yml")).Return("mockEnvTemplatePath")
m.EXPECT().EnvAddonFilePath(gomock.Eq("addons.parameters.yml")).Return("mockEnvParametersPath")
m.EXPECT().Write(gomock.Any(), "mockEnvTemplatePath").Return("mockEnvTemplatePath", nil)
m.EXPECT().Write(gomock.Any(), "mockEnvParametersPath").Return("mockEnvParametersPath", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments(gomock.Any()).Times(1)
},
},
"happy calls for env RDS with RDWS": {
inSvcName: wantedSvcName,
inStorageType: rdsStorageType,
inStorageName: "mycluster",
inServerlessVersion: auroraServerlessVersionV1,
inEngine: engineTypeMySQL,
inParameterGroup: "mygroup",
inLifecycle: lifecycleEnvironmentLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Request-Driven Web Service"), nil)
m.EXPECT().EnvAddonFilePath(gomock.Eq("mycluster.yml")).Return("mockEnvTemplatePath")
m.EXPECT().EnvAddonFilePath(gomock.Eq("addons.parameters.yml")).Return("mockEnvParametersPath")
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("mycluster-ingress.yml")).Return("mockWkldTmplPath")
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("addons.parameters.yml")).Return("mockWkldParamsPath")
m.EXPECT().Write(gomock.Any(), "mockEnvTemplatePath").Return("mockEnvTemplatePath", nil)
m.EXPECT().Write(gomock.Any(), "mockEnvParametersPath").Return("mockEnvParametersPath", nil)
m.EXPECT().Write(gomock.Any(), "mockWkldTmplPath").Return("mockWkldTmplPath", nil)
m.EXPECT().Write(gomock.Any(), "mockWkldParamsPath").Return("mockWkldParamsPath", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments(gomock.Any()).Times(1)
},
},
"add ingress for env DDB": {
inStorageType: dynamoDBStorageType,
inStorageName: "my-table",
inNoLSI: true,
inNoSort: true,
inPartition: wantedPartitionKey,
inAddIngressFrom: wantedSvcName,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-table-access-policy.yml")).Return("mockWkldTemplatePath")
m.EXPECT().Write(gomock.Any(), "mockWkldTemplatePath").Return("mockWkldTemplatePath", nil)
},
},
"add ingress for env S3": {
inStorageType: s3StorageType,
inStorageName: "my-bucket",
inAddIngressFrom: wantedSvcName,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-bucket-access-policy.yml")).Return("mockWkldTemplatePath")
m.EXPECT().Write(gomock.Any(), "mockWkldTemplatePath").Return("mockWkldTemplatePath", nil)
},
},
"add ingress for env RDS with LBWS": {
inStorageType: rdsStorageType,
inStorageName: "mycluster",
inAddIngressFrom: wantedSvcName,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Load-Balanced Web Service"), nil)
},
},
"add ingress for env RDS with RDWS": {
inStorageType: rdsStorageType,
inStorageName: "mycluster",
inAddIngressFrom: wantedSvcName,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Request-Driven Web Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("mycluster-ingress.yml")).Return("mockWkldTmplPath")
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("addons.parameters.yml")).Return("mockWkldParamsPath")
m.EXPECT().Write(gomock.Any(), "mockWkldTmplPath").Return("mockWkldTmplPath", nil)
m.EXPECT().Write(gomock.Any(), "mockWkldParamsPath").Return("mockWkldParamsPath", nil)
},
},
"do not attempt to read manifest or write workload ingress for an env RDS if workload is not in the workspace": {
inSvcName: wantedSvcName,
inStorageType: rdsStorageType,
inStorageName: "mycluster",
inServerlessVersion: auroraServerlessVersionV1,
inEngine: engineTypeMySQL,
inParameterGroup: "mygroup",
inLifecycle: lifecycleEnvironmentLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(false, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Times(0)
m.EXPECT().EnvAddonFilePath(gomock.Eq("mycluster.yml")).Return("mockEnvPath")
m.EXPECT().EnvAddonFilePath(gomock.Eq("addons.parameters.yml")).Return("mockEnvPath")
m.EXPECT().Write(gomock.Any(), gomock.Not(gomock.Eq("mockWkldPath"))).Return("mockEnvTemplatePath", nil).Times(2)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments(gomock.Any()).Times(1)
},
},
"do not error out if addon exists": {
inStorageType: s3StorageType,
inSvcName: wantedSvcName,
inStorageName: "my-bucket",
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-bucket.yml")).Return("mockPath")
m.EXPECT().Write(gomock.Any(), "mockPath").Return("/frontend/addons/my-bucket.yml", nil).Return("", fileExistsError)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments(gomock.Any()).AnyTimes()
},
},
"unexpected read workload manifest error handled": {
inStorageType: s3StorageType,
inSvcName: wantedSvcName,
inStorageName: "my-bucket",
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, errors.New("some error"))
},
wantedErr: errors.New("read manifest for frontend: some error"),
},
"unexpected write addon error handled": {
inStorageType: s3StorageType,
inSvcName: wantedSvcName,
inStorageName: "my-bucket",
inLifecycle: lifecycleWorkloadLevel,
mockWS: func(m *mocks.MockwsReadWriter) {
m.EXPECT().WorkloadExists(wantedSvcName).Return(true, nil)
m.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte("type: Worker Service"), nil)
m.EXPECT().WorkloadAddonFilePath(gomock.Eq(wantedSvcName), gomock.Eq("my-bucket.yml")).Return("mockPath")
m.EXPECT().Write(gomock.Any(), "mockPath").Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
mockWS := mocks.NewMockwsReadWriter(ctrl)
opts := initStorageOpts{
initStorageVars: initStorageVars{
storageType: tc.inStorageType,
storageName: tc.inStorageName,
workloadName: tc.inSvcName,
lifecycle: tc.inLifecycle,
addIngressFrom: tc.inAddIngressFrom,
partitionKey: tc.inPartition,
sortKey: tc.inSort,
lsiSorts: tc.inLSISorts,
noLSI: tc.inNoLSI,
noSort: tc.inNoSort,
auroraServerlessVersion: tc.inServerlessVersion,
rdsEngine: tc.inEngine,
rdsParameterGroup: tc.inParameterGroup,
},
appName: wantedAppName,
ws: mockWS,
store: mockStore,
workloadExists: !tc.mockWkldAbsent,
}
tc.mockWS(mockWS)
if tc.mockStore != nil {
tc.mockStore(mockStore)
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 1,527 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
)
var errNoAppInWorkspace = errors.New("could not find an application attached to this workspace, please run `app init` first")
// BuildSvcCmd is the top level command for service.
func BuildSvcCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "svc",
Short: `Commands for services.
Services are long-running ECS or App Runner services.`,
Long: `Commands for services.
Services are long-running ECS or App Runner services.`,
}
cmd.AddCommand(buildSvcInitCmd())
cmd.AddCommand(buildSvcListCmd())
cmd.AddCommand(buildSvcPackageCmd())
cmd.AddCommand(buildSvcOverrideCmd())
cmd.AddCommand(buildSvcDeployCmd())
cmd.AddCommand(buildSvcDeleteCmd())
cmd.AddCommand(buildSvcShowCmd())
cmd.AddCommand(buildSvcStatusCmd())
cmd.AddCommand(buildSvcLogsCmd())
cmd.AddCommand(buildSvcExecCmd())
cmd.AddCommand(buildSvcPauseCmd())
cmd.AddCommand(buildSvcResumeCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Develop,
}
return cmd
}
| 46 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
awss3 "github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/cli/clean"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/s3"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
awssession "github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/ecr"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/spf13/cobra"
)
const (
svcDeleteNamePrompt = "Which service would you like to delete?"
fmtSvcDeleteConfirmPrompt = "Are you sure you want to delete %s from application %s?"
fmtSvcDeleteFromEnvConfirmPrompt = "Are you sure you want to delete %s from environment %s?"
svcDeleteConfirmHelp = "This will remove the service from all environments and delete it from your app."
svcDeleteFromEnvConfirmHelp = "This will remove the service from just the %s environment."
)
var (
errSvcDeleteCancelled = errors.New("svc delete cancelled - no changes made")
)
type cleaner interface {
Clean() error
}
type deleteSvcVars struct {
appName string
skipConfirmation bool
name string
envName string
}
type deleteSvcOpts struct {
deleteSvcVars
// Interfaces to dependencies.
store store
sess sessionProvider
spinner progress
prompt prompter
sel configSelector
appCFN svcRemoverFromApp
getSvcCFN func(sess *awssession.Session) wlDeleter
getECR func(sess *awssession.Session) imageRemover
newSvcCleaner func(sess *awssession.Session, manifestType string) cleaner
}
func newDeleteSvcOpts(vars deleteSvcVars) (*deleteSvcOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc delete"))
defaultSession, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
opts := &deleteSvcOpts{
deleteSvcVars: vars,
store: store,
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
prompt: prompter,
sess: sessProvider,
sel: selector.NewConfigSelector(prompter, store),
appCFN: cloudformation.New(defaultSession, cloudformation.WithProgressTracker(os.Stderr)),
getSvcCFN: func(sess *awssession.Session) wlDeleter {
return cloudformation.New(sess, cloudformation.WithProgressTracker(os.Stderr))
},
getECR: func(sess *awssession.Session) imageRemover {
return ecr.New(sess)
},
}
opts.newSvcCleaner = func(sess *awssession.Session, manifestType string) cleaner {
if manifestType == manifestinfo.StaticSiteType {
return clean.StaticSite(opts.appName, opts.envName, opts.name, s3.New(sess), awss3.New(sess))
}
return &clean.NoOp{}
}
return opts, nil
}
// Validate returns an error for any invalid optional flags.
func (o *deleteSvcOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *deleteSvcOpts) Ask() error {
if o.appName != "" {
if _, err := o.store.GetApplication(o.appName); err != nil {
return err
}
} else {
if err := o.askAppName(); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.store.GetService(o.appName, o.name); err != nil {
return err
}
} else {
if err := o.askSvcName(); err != nil {
return err
}
}
if o.envName != "" {
if err := o.validateEnvName(); err != nil {
return err
}
}
if o.skipConfirmation {
return nil
}
// When there's no env name passed in, we'll completely
// remove the service from the application.
deletePrompt := fmt.Sprintf(fmtSvcDeleteConfirmPrompt, o.name, o.appName)
deleteConfirmHelp := svcDeleteConfirmHelp
if o.envName != "" {
// When a customer provides a particular environment,
// we'll just delete the service from that environment -
// but keep it in the app.
deletePrompt = fmt.Sprintf(fmtSvcDeleteFromEnvConfirmPrompt, o.name, o.envName)
deleteConfirmHelp = fmt.Sprintf(svcDeleteFromEnvConfirmHelp, o.envName)
}
deleteConfirmed, err := o.prompt.Confirm(
deletePrompt,
deleteConfirmHelp,
prompt.WithConfirmFinalMessage())
if err != nil {
return fmt.Errorf("svc delete confirmation prompt: %w", err)
}
if !deleteConfirmed {
return errSvcDeleteCancelled
}
return nil
}
// Execute deletes the service's CloudFormation stack.
// If the service is being removed from the application, Execute will
// also delete the ECR repository and the SSM parameter.
func (o *deleteSvcOpts) Execute() error {
wkld, err := o.store.GetWorkload(o.appName, o.name)
if err != nil {
return fmt.Errorf("get workload: %w", err)
}
envs, err := o.appEnvironments()
if err != nil {
return err
}
if err := o.deleteStacks(wkld.Type, envs); err != nil {
return err
}
// Skip removing the service from the application if
// we are only removing the stack from a particular environment.
if !o.needsAppCleanup() {
return nil
}
if err := o.emptyECRRepos(envs); err != nil {
return err
}
if err := o.removeSvcFromApp(); err != nil {
return err
}
if err := o.deleteSSMParam(); err != nil {
return err
}
log.Infoln()
log.Successf("Deleted service %s from application %s.\n", o.name, o.appName)
return nil
}
func (o *deleteSvcOpts) validateEnvName() error {
if _, err := o.targetEnv(); err != nil {
return err
}
return nil
}
func (o *deleteSvcOpts) needsAppCleanup() bool {
// Only remove from a service from the app if
// we're removing it from every environment.
// If we're just removing the service from one
// env, we keep the app configuration.
return o.envName == ""
}
func (o *deleteSvcOpts) targetEnv() (*config.Environment, error) {
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, fmt.Errorf("get environment %s from config store: %w", o.envName, err)
}
return env, nil
}
func (o *deleteSvcOpts) askAppName() error {
name, err := o.sel.Application(svcAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application name: %w", err)
}
o.appName = name
return nil
}
func (o *deleteSvcOpts) askSvcName() error {
name, err := o.sel.Service(svcDeleteNamePrompt, "", o.appName)
if err != nil {
return fmt.Errorf("select service: %w", err)
}
o.name = name
return nil
}
func (o *deleteSvcOpts) appEnvironments() ([]*config.Environment, error) {
var envs []*config.Environment
var err error
if o.envName != "" {
env, err := o.targetEnv()
if err != nil {
return nil, err
}
envs = append(envs, env)
} else {
envs, err = o.store.ListEnvironments(o.appName)
if err != nil {
return nil, fmt.Errorf("list environments: %w", err)
}
}
return envs, nil
}
func (o *deleteSvcOpts) deleteStacks(wkldType string, envs []*config.Environment) error {
for _, env := range envs {
sess, err := o.sess.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
if err := o.newSvcCleaner(sess, wkldType).Clean(); err != nil {
return fmt.Errorf("clean resources: %w", err)
}
cfClient := o.getSvcCFN(sess)
if err := cfClient.DeleteWorkload(deploy.DeleteWorkloadInput{
Name: o.name,
EnvName: env.Name,
AppName: o.appName,
ExecutionRoleARN: env.ExecutionRoleARN,
}); err != nil {
return fmt.Errorf("delete service: %w", err)
}
}
return nil
}
// This is to make mocking easier in unit tests
func (o *deleteSvcOpts) emptyECRRepos(envs []*config.Environment) error {
var uniqueRegions []string
for _, env := range envs {
if !contains(env.Region, uniqueRegions) {
uniqueRegions = append(uniqueRegions, env.Region)
}
}
// TODO: centralized ECR repo name
repoName := fmt.Sprintf("%s/%s", o.appName, o.name)
for _, region := range uniqueRegions {
sess, err := o.sess.DefaultWithRegion(region)
if err != nil {
return err
}
client := o.getECR(sess)
if err := client.ClearRepository(repoName); err != nil {
return err
}
}
return nil
}
func (o *deleteSvcOpts) removeSvcFromApp() error {
proj, err := o.store.GetApplication(o.appName)
if err != nil {
return err
}
if err := o.appCFN.RemoveServiceFromApp(proj, o.name); err != nil {
if !isStackSetNotExistsErr(err) {
return err
}
}
return nil
}
func (o *deleteSvcOpts) deleteSSMParam() error {
if err := o.store.DeleteService(o.appName, o.name); err != nil {
return fmt.Errorf("delete service %s in application %s from config store: %w", o.name, o.appName, err)
}
return nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *deleteSvcOpts) RecommendActions() error {
logRecommendedActions([]string{
fmt.Sprintf("Run %s to update the corresponding pipeline if it exists.",
color.HighlightCode("copilot pipeline deploy")),
})
return nil
}
// buildSvcDeleteCmd builds the command to delete application(s).
func buildSvcDeleteCmd() *cobra.Command {
vars := deleteSvcVars{}
cmd := &cobra.Command{
Use: "delete",
Short: "Deletes a service from an application.",
Example: `
Delete the "test" service from the application.
/code $ copilot svc delete --name test
Delete the "test" service from just the prod environment.
/code $ copilot svc delete --name test --env prod
Delete the "test" service from the "my-app" application from outside of the workspace.
/code $ copilot svc delete --name test --app my-app
Delete the "test" service without confirmation prompt.
/code $ copilot svc delete --name test --yes`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeleteSvcOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
return cmd
}
| 381 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/cli/clean/cleantest"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestDeleteSvcOpts_Validate(t *testing.T) {
tests := map[string]struct {
inAppName string
inEnvName string
inName string
setupMocks func(m *mocks.Mockstore)
want error
}{
"with no flag set": {
inAppName: "phonetool",
setupMocks: func(m *mocks.Mockstore) {},
want: nil,
},
"with all flags set": {
inAppName: "phonetool",
inEnvName: "test",
inName: "api",
setupMocks: func(m *mocks.Mockstore) {},
want: nil,
},
"with env flag set": {
inAppName: "phonetool",
inEnvName: "test",
setupMocks: func(m *mocks.Mockstore) {},
want: nil,
},
"with svc flag set": {
inAppName: "phonetool",
inName: "api",
setupMocks: func(m *mocks.Mockstore) {},
want: nil,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
test.setupMocks(mockstore)
opts := deleteSvcOpts{
deleteSvcVars: deleteSvcVars{
appName: test.inAppName,
name: test.inName,
envName: test.inEnvName,
},
store: mockstore,
}
err := opts.Validate()
if test.want != nil {
require.EqualError(t, err, test.want.Error())
} else {
require.NoError(t, err)
}
})
}
}
type svcDeleteAskMocks struct {
store *mocks.Mockstore
prompt *mocks.Mockprompter
sel *mocks.MockconfigSelector
}
func TestDeleteSvcOpts_Ask(t *testing.T) {
const (
testAppName = "phonetool"
testSvcName = "api"
)
mockError := errors.New("mockError")
tests := map[string]struct {
skipConfirmation bool
inName string
envName string
appName string
mockSel func(m *mocks.MockconfigSelector)
mockPrompt func(m *mocks.Mockprompter)
setUpMocks func(m *svcDeleteAskMocks)
wantedName string
wantedError error
}{
"validate app name if passed as a flag": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.store.EXPECT().GetApplication(gomock.Any()).Return(&config.Application{}, nil)
m.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
},
wantedName: testSvcName,
},
"error validating app name": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.store.EXPECT().GetApplication(gomock.Any()).Return(nil, &config.ErrNoSuchApplication{})
m.sel.EXPECT().Application(gomock.Any(), gomock.Any()).Times(0)
},
wantedError: &config.ErrNoSuchApplication{},
},
"should ask for app name": {
appName: "",
inName: testSvcName,
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return(testAppName, nil)
m.store.EXPECT().GetApplication(gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
},
wantedName: testSvcName,
},
"validate service name if passed as a flag": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Return(&config.Workload{}, nil)
m.sel.EXPECT().Service(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedName: testSvcName,
},
"error validating service name": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.store.EXPECT().GetApplication(gomock.Any()).Return(&config.Application{}, nil)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Return(nil, errors.New("some error"))
},
wantedError: errors.New("some error"),
},
"should ask for service name": {
appName: testAppName,
inName: "",
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.sel.EXPECT().Service("Which service would you like to delete?", "", testAppName).Return(testSvcName, nil)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedName: testSvcName,
},
"returns error if no services found": {
appName: testAppName,
inName: "",
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.sel.EXPECT().Service("Which service would you like to delete?", "", testAppName).Return("", mockError)
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedError: fmt.Errorf("select service: %w", mockError),
},
"returns error if fail to select service": {
appName: testAppName,
inName: "",
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.sel.EXPECT().Service("Which service would you like to delete?", "", testAppName).Return("", mockError)
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedError: fmt.Errorf("select service: %w", mockError),
},
"should skip confirmation": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: true,
setUpMocks: func(m *svcDeleteAskMocks) {
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedName: testSvcName,
},
"should wrap error returned from prompter confirmation": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: false,
setUpMocks: func(m *svcDeleteAskMocks) {
m.prompt.EXPECT().Confirm(
fmt.Sprintf(fmtSvcDeleteConfirmPrompt, testSvcName, testAppName),
svcDeleteConfirmHelp,
gomock.Any(),
).Times(1).Return(true, mockError)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedError: fmt.Errorf("svc delete confirmation prompt: %w", mockError),
},
"should return error if user does not confirm svc delete": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: false,
setUpMocks: func(m *svcDeleteAskMocks) {
m.prompt.EXPECT().Confirm(
fmt.Sprintf(fmtSvcDeleteConfirmPrompt, testSvcName, testAppName),
svcDeleteConfirmHelp,
gomock.Any(),
).Times(1).Return(false, nil)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedError: errSvcDeleteCancelled,
},
"should return error nil if user confirms svc delete": {
appName: testAppName,
inName: testSvcName,
skipConfirmation: false,
setUpMocks: func(m *svcDeleteAskMocks) {
m.prompt.EXPECT().Confirm(
fmt.Sprintf(fmtSvcDeleteConfirmPrompt, testSvcName, testAppName),
svcDeleteConfirmHelp,
gomock.Any(),
).Times(1).Return(true, nil)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedName: testSvcName,
},
"should return error nil if user confirms svc delete --env": {
appName: testAppName,
inName: testSvcName,
envName: "test",
skipConfirmation: false,
setUpMocks: func(m *svcDeleteAskMocks) {
m.store.EXPECT().GetEnvironment(testAppName, "test").Return(&config.Environment{}, nil)
m.prompt.EXPECT().Confirm(
fmt.Sprintf(fmtSvcDeleteFromEnvConfirmPrompt, testSvcName, "test"),
fmt.Sprintf(svcDeleteFromEnvConfirmHelp, "test"),
gomock.Any(),
).Times(1).Return(true, nil)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedName: testSvcName,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockPrompter := mocks.NewMockprompter(ctrl)
mockSel := mocks.NewMockconfigSelector(ctrl)
mockStore := mocks.NewMockstore(ctrl)
m := &svcDeleteAskMocks{
sel: mockSel,
prompt: mockPrompter,
store: mockStore,
}
test.setUpMocks(m)
opts := deleteSvcOpts{
deleteSvcVars: deleteSvcVars{
skipConfirmation: test.skipConfirmation,
appName: test.appName,
name: test.inName,
envName: test.envName,
},
prompt: m.prompt,
sel: m.sel,
store: m.store,
}
got := opts.Ask()
if got != nil {
require.Equal(t, test.wantedError, got)
} else {
require.Equal(t, test.wantedName, opts.name)
}
})
}
}
type deleteSvcMocks struct {
store *mocks.Mockstore
secretsmanager *mocks.MocksecretsManager
sessProvider *mocks.MocksessionProvider
appCFN *mocks.MocksvcRemoverFromApp
spinner *mocks.Mockprogress
svcCFN *mocks.MockwlDeleter
ecr *mocks.MockimageRemover
}
func TestDeleteSvcOpts_Execute(t *testing.T) {
mockSvcName := "backend"
mockEnvName := "test"
mockAppName := "badgoose"
mockEnv := &config.Environment{
App: mockAppName,
Name: mockEnvName,
ManagerRoleARN: "some-arn",
Region: "us-west-2",
}
mockEnvs := []*config.Environment{mockEnv}
mockApp := &config.Application{
Name: mockAppName,
}
mockRepo := fmt.Sprintf("%s/%s", mockAppName, mockSvcName)
testError := errors.New("some error")
tests := map[string]struct {
inAppName string
inEnvName string
inSvcName string
opts *deleteSvcOpts
wkldCleaner cleaner
setupMocks func(mocks deleteSvcMocks)
wantedError error
}{
"happy path with no environment passed in as flag": {
opts: &deleteSvcOpts{
deleteSvcVars: deleteSvcVars{
appName: mockAppName,
name: mockSvcName,
},
newSvcCleaner: func(*session.Session, string) cleaner {
return &cleantest.Succeeds{}
},
},
setupMocks: func(mocks deleteSvcMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetWorkload(mockAppName, mockSvcName).Return(&config.Workload{
Type: manifestinfo.LoadBalancedWebServiceType,
}, nil),
// appEnvironments
mocks.store.EXPECT().ListEnvironments(gomock.Eq(mockAppName)).Times(1).Return(mockEnvs, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil),
// deleteStacks
mocks.svcCFN.EXPECT().DeleteWorkload(gomock.Any()).Return(nil),
mocks.sessProvider.EXPECT().DefaultWithRegion(gomock.Any()).Return(&session.Session{}, nil),
// emptyECRRepos
mocks.ecr.EXPECT().ClearRepository(mockRepo).Return(nil),
// removeSvcFromApp
mocks.store.EXPECT().GetApplication(mockAppName).Return(mockApp, nil),
mocks.appCFN.EXPECT().RemoveServiceFromApp(mockApp, mockSvcName).Return(nil),
// deleteSSMParam
mocks.store.EXPECT().DeleteService(mockAppName, mockSvcName).Return(nil),
)
},
wantedError: nil,
},
// A service can be deployed to multiple
// environments - and deleting it in one
// should not delete it from the entire app.
"happy path with environment passed in as flag": {
opts: &deleteSvcOpts{
deleteSvcVars: deleteSvcVars{
appName: mockAppName,
envName: mockEnvName,
name: mockSvcName,
},
newSvcCleaner: func(*session.Session, string) cleaner {
return &cleantest.Succeeds{}
},
},
setupMocks: func(mocks deleteSvcMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetWorkload(mockAppName, mockSvcName).Return(&config.Workload{
Type: manifestinfo.LoadBalancedWebServiceType,
}, nil),
// appEnvironments
mocks.store.EXPECT().GetEnvironment(mockAppName, mockEnvName).Times(1).Return(mockEnv, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil),
// deleteStacks
mocks.svcCFN.EXPECT().DeleteWorkload(gomock.Any()).Return(nil),
// It should **not** emptyECRRepos
mocks.ecr.EXPECT().ClearRepository(gomock.Any()).Return(nil).Times(0),
// It should **not** removeSvcFromApp
mocks.appCFN.EXPECT().RemoveServiceFromApp(gomock.Any(), gomock.Any()).Return(nil).Times(0),
// It should **not** deleteSSMParam
mocks.store.EXPECT().DeleteService(gomock.Any(), gomock.Any()).Return(nil).Times(0),
)
},
wantedError: nil,
},
"error getting workload": {
opts: &deleteSvcOpts{
deleteSvcVars: deleteSvcVars{
appName: mockAppName,
name: mockSvcName,
},
},
setupMocks: func(mocks deleteSvcMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetWorkload(mockAppName, mockSvcName).Return(nil, errors.New("some error")),
)
},
wantedError: errors.New("get workload: some error"),
},
"error cleaning workload": {
opts: &deleteSvcOpts{
deleteSvcVars: deleteSvcVars{
appName: mockAppName,
envName: mockEnvName,
name: mockSvcName,
},
newSvcCleaner: func(*session.Session, string) cleaner {
return &cleantest.Fails{}
},
},
setupMocks: func(mocks deleteSvcMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetWorkload(mockAppName, mockSvcName).Return(&config.Workload{
Type: manifestinfo.LoadBalancedWebServiceType,
}, nil),
mocks.store.EXPECT().GetEnvironment(mockAppName, mockEnvName).Times(1).Return(mockEnv, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil),
)
},
wantedError: errors.New("clean resources: an error"),
},
"errors when deleting stack": {
opts: &deleteSvcOpts{
deleteSvcVars: deleteSvcVars{
appName: mockAppName,
envName: mockEnvName,
name: mockSvcName,
},
newSvcCleaner: func(*session.Session, string) cleaner {
return &cleantest.Succeeds{}
},
},
setupMocks: func(mocks deleteSvcMocks) {
gomock.InOrder(
mocks.store.EXPECT().GetWorkload(mockAppName, mockSvcName).Return(&config.Workload{
Type: manifestinfo.LoadBalancedWebServiceType,
}, nil),
// appEnvironments
mocks.store.EXPECT().GetEnvironment(mockAppName, mockEnvName).Times(1).Return(mockEnv, nil),
mocks.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil),
// deleteStacks
mocks.svcCFN.EXPECT().DeleteWorkload(gomock.Any()).Return(testError),
)
},
wantedError: fmt.Errorf("delete service: %w", testError),
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mocks := deleteSvcMocks{
store: mocks.NewMockstore(ctrl),
secretsmanager: mocks.NewMocksecretsManager(ctrl),
sessProvider: mocks.NewMocksessionProvider(ctrl),
appCFN: mocks.NewMocksvcRemoverFromApp(ctrl),
spinner: mocks.NewMockprogress(ctrl),
svcCFN: mocks.NewMockwlDeleter(ctrl),
ecr: mocks.NewMockimageRemover(ctrl),
}
tc.setupMocks(mocks)
tc.opts.store = mocks.store
tc.opts.sess = mocks.sessProvider
tc.opts.spinner = mocks.spinner
tc.opts.appCFN = mocks.appCFN
tc.opts.getSvcCFN = func(_ *session.Session) wlDeleter {
return mocks.svcCFN
}
tc.opts.getECR = func(_ *session.Session) imageRemover {
return mocks.ecr
}
// WHEN
err := tc.opts.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 528 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/tags"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/spf13/afero"
"github.com/spf13/cobra"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
clideploy "github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
)
type deployWkldVars struct {
appName string
name string
envName string
imageTag string
resourceTags map[string]string
forceNewUpdate bool // NOTE: this variable is not applicable for a job workload currently.
disableRollback bool
showDiff bool
skipDiffPrompt bool
// To facilitate unit tests.
clientConfigured bool
}
type deploySvcOpts struct {
deployWkldVars
store store
ws wsWlDirReader
unmarshal func([]byte) (manifest.DynamicWorkload, error)
newInterpolator func(app, env string) interpolator
cmd execRunner
sessProvider *sessions.Provider
newSvcDeployer func() (workloadDeployer, error)
envFeaturesDescriber versionCompatibilityChecker
diffWriter io.Writer
spinner progress
sel wsSelector
prompt prompter
gitShortCommit string
// cached variables
targetApp *config.Application
targetEnv *config.Environment
envSess *session.Session
svcType string
appliedDynamicMft manifest.DynamicWorkload
rootUserARN string
deployRecs clideploy.ActionRecommender
noDeploy bool
}
func newSvcDeployOpts(vars deployWkldVars) (*deploySvcOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc deploy"))
defaultSession, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
prompter := prompt.New()
opts := &deploySvcOpts{
deployWkldVars: vars,
store: store,
ws: ws,
unmarshal: manifest.UnmarshalWorkload,
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
sel: selector.NewLocalWorkloadSelector(prompter, store, ws),
prompt: prompter,
newInterpolator: newManifestInterpolator,
cmd: exec.NewCmd(),
sessProvider: sessProvider,
diffWriter: os.Stdout,
}
opts.newSvcDeployer = func() (workloadDeployer, error) {
// NOTE: Defined as a struct member to facilitate unit testing.
return newSvcDeployer(opts)
}
return opts, err
}
func newSvcDeployer(o *deploySvcOpts) (workloadDeployer, error) {
targetApp, err := o.getTargetApp()
if err != nil {
return nil, err
}
raw, err := o.ws.ReadWorkloadManifest(o.name)
if err != nil {
return nil, fmt.Errorf("read manifest file for %s: %w", o.name, err)
}
ovrdr, err := clideploy.NewOverrider(o.ws.WorkloadOverridesPath(o.name), o.appName, o.envName, afero.NewOsFs(), o.sessProvider)
if err != nil {
return nil, err
}
content := o.appliedDynamicMft.Manifest()
var deployer workloadDeployer
in := clideploy.WorkloadDeployerInput{
SessionProvider: o.sessProvider,
Name: o.name,
App: targetApp,
Env: o.targetEnv,
Image: clideploy.ContainerImageIdentifier{
CustomTag: o.imageTag,
GitShortCommitTag: o.gitShortCommit,
},
Mft: content,
RawMft: raw,
EnvVersionGetter: o.envFeaturesDescriber,
Overrider: ovrdr,
}
switch t := content.(type) {
case *manifest.LoadBalancedWebService:
deployer, err = clideploy.NewLBWSDeployer(&in)
case *manifest.BackendService:
deployer, err = clideploy.NewBackendDeployer(&in)
case *manifest.RequestDrivenWebService:
deployer, err = clideploy.NewRDWSDeployer(&in)
case *manifest.WorkerService:
deployer, err = clideploy.NewWorkerSvcDeployer(&in)
case *manifest.StaticSite:
deployer, err = clideploy.NewStaticSiteDeployer(&in)
default:
return nil, fmt.Errorf("unknown manifest type %T while creating the CloudFormation stack", t)
}
if err != nil {
return nil, fmt.Errorf("initiate workload deployer: %w", err)
}
return deployer, nil
}
func newManifestInterpolator(app, env string) interpolator {
return manifest.NewInterpolator(app, env)
}
// Validate returns an error for any invalid optional flags.
func (o *deploySvcOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *deploySvcOpts) Ask() error {
if o.appName != "" {
if _, err := o.getTargetApp(); err != nil {
return err
}
} else {
// NOTE: This command is required to be executed under a workspace. We don't prompt for it.
return errNoAppInWorkspace
}
if err := o.validateOrAskSvcName(); err != nil {
return err
}
if err := o.validateOrAskEnvName(); err != nil {
return err
}
return nil
}
// Execute builds and pushes the container image for the service,
func (o *deploySvcOpts) Execute() error {
if !o.clientConfigured {
if err := o.configureClients(); err != nil {
return err
}
}
mft, err := workloadManifest(&workloadManifestInput{
name: o.name,
appName: o.appName,
envName: o.envName,
interpolator: o.newInterpolator(o.appName, o.envName),
ws: o.ws,
unmarshal: o.unmarshal,
sess: o.envSess,
})
if err != nil {
return err
}
if o.forceNewUpdate && o.svcType == manifestinfo.StaticSiteType {
return fmt.Errorf("--%s is not supported for service type %q", forceFlag, manifestinfo.StaticSiteType)
}
o.appliedDynamicMft = mft
if err := validateWorkloadManifestCompatibilityWithEnv(o.ws, o.envFeaturesDescriber, mft, o.envName); err != nil {
return err
}
deployer, err := o.newSvcDeployer()
if err != nil {
return err
}
serviceInRegion, err := deployer.IsServiceAvailableInRegion(o.targetEnv.Region)
if err != nil {
return fmt.Errorf("check if %s is available in region %s: %w", o.svcType, o.targetEnv.Region, err)
}
if !serviceInRegion {
log.Warningf(`%s might not be available in region %s; proceed with caution.
`, o.svcType, o.targetEnv.Region)
}
uploadOut, err := deployer.UploadArtifacts()
if err != nil {
return fmt.Errorf("upload deploy resources for service %s: %w", o.name, err)
}
targetApp, err := o.getTargetApp()
if err != nil {
return err
}
if o.showDiff {
output, err := deployer.GenerateCloudFormationTemplate(&clideploy.GenerateCloudFormationTemplateInput{
StackRuntimeConfiguration: clideploy.StackRuntimeConfiguration{
RootUserARN: o.rootUserARN,
Tags: targetApp.Tags,
EnvFileARNs: uploadOut.EnvFileARNs,
ImageDigests: uploadOut.ImageDigests,
AddonsURL: uploadOut.AddonsURL,
CustomResourceURLs: uploadOut.CustomResourceURLs,
StaticSiteAssetMappingURL: uploadOut.StaticSiteAssetMappingLocation,
},
})
if err != nil {
return fmt.Errorf("generate the template for workload %q against environment %q: %w", o.name, o.envName, err)
}
if err := diff(deployer, output.Template, o.diffWriter); err != nil {
var errHasDiff *errHasDiff
if !errors.As(err, &errHasDiff) {
return err
}
}
contd, err := o.skipDiffPrompt, nil
if !o.skipDiffPrompt {
contd, err = o.prompt.Confirm(continueDeploymentPrompt, "")
}
if err != nil {
return fmt.Errorf("ask whether to continue with the deployment: %w", err)
}
if !contd {
o.noDeploy = true
return nil
}
}
deployRecs, err := deployer.DeployWorkload(&clideploy.DeployWorkloadInput{
StackRuntimeConfiguration: clideploy.StackRuntimeConfiguration{
ImageDigests: uploadOut.ImageDigests,
EnvFileARNs: uploadOut.EnvFileARNs,
AddonsURL: uploadOut.AddonsURL,
RootUserARN: o.rootUserARN,
Tags: tags.Merge(targetApp.Tags, o.resourceTags),
CustomResourceURLs: uploadOut.CustomResourceURLs,
StaticSiteAssetMappingURL: uploadOut.StaticSiteAssetMappingLocation,
},
Options: clideploy.Options{
ForceNewUpdate: o.forceNewUpdate,
DisableRollback: o.disableRollback,
},
})
if err != nil {
if o.disableRollback {
stackName := stack.NameForWorkload(o.targetApp.Name, o.targetEnv.Name, o.name)
rollbackCmd := fmt.Sprintf("aws cloudformation rollback-stack --stack-name %s --role-arn %s", stackName, o.targetEnv.ExecutionRoleARN)
log.Infof(`It seems like you have disabled automatic stack rollback for this deployment. To debug, you can:
* Run %s to inspect the service log.
* Visit the AWS console to inspect the errors.
After fixing the deployment, you can:
1. Run %s to rollback the deployment.
2. Run %s to make a new deployment.
`, color.HighlightCode("copilot svc logs"), color.HighlightCode(rollbackCmd), color.HighlightCode("copilot svc deploy"))
}
return fmt.Errorf("deploy service %s to environment %s: %w", o.name, o.envName, err)
}
o.deployRecs = deployRecs
log.Successf("Deployed service %s.\n", color.HighlightUserInput(o.name))
return nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *deploySvcOpts) RecommendActions() error {
if o.noDeploy {
return nil
}
var recommendations []string
uriRecs, err := o.uriRecommendedActions()
if err != nil {
return err
}
recommendations = append(recommendations, uriRecs...)
recommendations = append(recommendations, o.deployRecs.RecommendedActions()...)
recommendations = append(recommendations, o.publishRecommendedActions()...)
logRecommendedActions(recommendations)
return nil
}
func (o *deploySvcOpts) validateSvcName() error {
names, err := o.ws.ListServices()
if err != nil {
return fmt.Errorf("list services in the workspace: %w", err)
}
for _, name := range names {
if o.name == name {
return nil
}
}
return fmt.Errorf("service %s not found in the workspace", color.HighlightUserInput(o.name))
}
func (o *deploySvcOpts) validateEnvName() error {
if _, err := o.store.GetEnvironment(o.appName, o.envName); err != nil {
return fmt.Errorf("get environment %s configuration: %w", o.envName, err)
}
return nil
}
func (o *deploySvcOpts) validateOrAskSvcName() error {
if o.name != "" {
if err := o.validateSvcName(); err != nil {
return err
}
} else {
name, err := o.sel.Service("Select a service in your workspace", "")
if err != nil {
return fmt.Errorf("select service: %w", err)
}
o.name = name
}
svc, err := o.store.GetService(o.appName, o.name)
if err != nil {
return fmt.Errorf("get service %s configuration: %w", o.name, err)
}
o.svcType = svc.Type
return nil
}
func (o *deploySvcOpts) validateOrAskEnvName() error {
if o.envName != "" {
return o.validateEnvName()
}
name, err := o.sel.Environment("Select an environment", "", o.appName)
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
o.envName = name
return nil
}
func (o *deploySvcOpts) configureClients() error {
o.gitShortCommit = imageTagFromGit(o.cmd) // Best effort assign git tag.
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return fmt.Errorf("get environment %s configuration: %w", o.envName, err)
}
o.targetEnv = env
// client to retrieve an application's resources created with CloudFormation.
defaultSess, err := o.sessProvider.Default()
if err != nil {
return fmt.Errorf("create default session: %w", err)
}
envSess, err := o.sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
o.envSess = envSess
// client to retrieve caller identity.
caller, err := identity.New(defaultSess).Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
o.rootUserARN = caller.RootUserARN
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: o.appName,
Env: o.envName,
ConfigStore: o.store,
})
if err != nil {
return err
}
o.envFeaturesDescriber = envDescriber
return nil
}
type workloadManifestInput struct {
name string
appName string
envName string
ws wsWlDirReader
interpolator interpolator
sess *session.Session
unmarshal func([]byte) (manifest.DynamicWorkload, error)
}
func workloadManifest(in *workloadManifestInput) (manifest.DynamicWorkload, error) {
raw, err := in.ws.ReadWorkloadManifest(in.name)
if err != nil {
return nil, fmt.Errorf("read manifest file for %s: %w", in.name, err)
}
interpolated, err := in.interpolator.Interpolate(string(raw))
if err != nil {
return nil, fmt.Errorf("interpolate environment variables for %s manifest: %w", in.name, err)
}
mft, err := in.unmarshal([]byte(interpolated))
if err != nil {
return nil, fmt.Errorf("unmarshal service %s manifest: %w", in.name, err)
}
envMft, err := mft.ApplyEnv(in.envName)
if err != nil {
return nil, fmt.Errorf("apply environment %s override: %w", in.envName, err)
}
if err := envMft.Validate(); err != nil {
return nil, fmt.Errorf("validate manifest against environment %q: %w", in.envName, err)
}
if err := envMft.Load(in.sess); err != nil {
return nil, fmt.Errorf("load dynamic content: %w", err)
}
return envMft, nil
}
func validateWorkloadManifestCompatibilityWithEnv(ws wsEnvironmentsLister, env versionCompatibilityChecker, mft manifest.DynamicWorkload, envName string) error {
currVersion, err := env.Version()
if err != nil {
return fmt.Errorf("get environment %q version: %w", envName, err)
}
if currVersion == version.EnvTemplateBootstrap {
return fmt.Errorf(`cannot deploy a service to an undeployed environment. Please run "copilot env deploy --name %s" to deploy the environment first`, envName)
}
availableFeatures, err := env.AvailableFeatures()
if err != nil {
return fmt.Errorf("get available features of the %s environment stack: %w", envName, err)
}
exists := struct{}{}
available := make(map[string]struct{})
for _, f := range availableFeatures {
available[f] = exists
}
features := mft.RequiredEnvironmentFeatures()
for _, f := range features {
if _, ok := available[f]; !ok {
logMsg := fmt.Sprintf(`Your manifest configuration requires your environment %q to have the feature %q available.`, envName, template.FriendlyEnvFeatureName(f))
if v := template.LeastVersionForFeature(f); v != "" {
logMsg += fmt.Sprintf(` The least environment version that supports the feature is %s.`, v)
}
logMsg += fmt.Sprintf(" Your environment is on %s.", currVersion)
log.Errorln(logMsg)
return &errFeatureIncompatibleWithEnvironment{
ws: ws,
missingFeature: f,
envName: envName,
curVersion: currVersion,
}
}
}
return nil
}
func (o *deploySvcOpts) uriRecommendedActions() ([]string, error) {
describer, err := describe.NewReachableService(o.appName, o.name, o.store)
if err != nil {
var errNotAccessible *describe.ErrNonAccessibleServiceType
if errors.As(err, &errNotAccessible) {
return nil, nil
}
return nil, err
}
uri, err := describer.URI(o.envName)
if err != nil {
return nil, fmt.Errorf("get uri for environment %s: %w", o.envName, err)
}
network := "over the internet."
switch uri.AccessType {
case describe.URIAccessTypeInternal:
network = "from your internal network."
case describe.URIAccessTypeServiceDiscovery:
network = "with service discovery."
case describe.URIAccessTypeServiceConnect:
network = "with service connect."
}
return []string{
fmt.Sprintf("You can access your service at %s %s", uri.URI, network),
}, nil
}
func (o *deploySvcOpts) publishRecommendedActions() []string {
type publisher interface {
Publish() []manifest.Topic
}
mft, ok := o.appliedDynamicMft.Manifest().(publisher)
if !ok {
return nil
}
if topics := mft.Publish(); len(topics) == 0 {
return nil
}
return []string{
fmt.Sprintf(`Update %s's code to leverage the injected environment variable "COPILOT_SNS_TOPIC_ARNS".
In JavaScript you can write %s.`,
o.name,
color.HighlightCode("const {<topicName>} = JSON.parse(process.env.COPILOT_SNS_TOPIC_ARNS)")),
}
}
func (o *deploySvcOpts) getTargetApp() (*config.Application, error) {
if o.targetApp != nil {
return o.targetApp, nil
}
app, err := o.store.GetApplication(o.appName)
if err != nil {
return nil, fmt.Errorf("get application %s configuration: %w", o.appName, err)
}
o.targetApp = app
return o.targetApp, nil
}
type errFeatureIncompatibleWithEnvironment struct {
ws wsEnvironmentsLister
missingFeature string
envName string
curVersion string
}
func (e *errFeatureIncompatibleWithEnvironment) Error() string {
if e.curVersion == "" {
return fmt.Sprintf("environment %q is not on a version that supports the %q feature", e.envName, template.FriendlyEnvFeatureName(e.missingFeature))
}
return fmt.Sprintf("environment %q is on version %q which does not support the %q feature", e.envName, e.curVersion, template.FriendlyEnvFeatureName(e.missingFeature))
}
// RecommendActions returns recommended actions to be taken after the error.
// Implements main.actionRecommender interface.
func (e *errFeatureIncompatibleWithEnvironment) RecommendActions() string {
envs, _ := e.ws.ListEnvironments() // Best effort try to detect if env manifest exists.
for _, env := range envs {
if e.envName == env {
return fmt.Sprintf("You can upgrade the %q environment template by running %s.", e.envName, color.HighlightCode(fmt.Sprintf("copilot env deploy --name %s", e.envName)))
}
}
msgs := []string{
"You can upgrade your environment template by running:",
fmt.Sprintf("1. Create the directory to store your environment manifest %s.",
color.HighlightCode(fmt.Sprintf("mkdir -p %s", filepath.Join("copilot", "environments", e.envName)))),
fmt.Sprintf("2. Generate the manifest %s.",
color.HighlightCode(fmt.Sprintf("copilot env show -n %s --manifest > %s", e.envName, filepath.Join("copilot", "environments", e.envName, "manifest.yml")))),
fmt.Sprintf("3. Deploy the environment stack %s.",
color.HighlightCode(fmt.Sprintf("copilot env deploy --name %s", e.envName))),
}
return strings.Join(msgs, "\n")
}
type errHasDiff struct{}
func (e *errHasDiff) Error() string {
return ""
}
// ExitCode returns 1 for a non-empty diff.
func (e *errHasDiff) ExitCode() int {
return 1
}
func diff(differ templateDiffer, tmpl string, writer io.Writer) error {
if out, err := differ.DeployDiff(tmpl); err != nil {
return err
} else if out != "" {
if _, err := writer.Write([]byte(out)); err != nil {
return err
}
return &errHasDiff{}
}
if _, err := writer.Write([]byte("No changes.\n")); err != nil {
return err
}
return nil
}
// buildSvcDeployCmd builds the `svc deploy` subcommand.
func buildSvcDeployCmd() *cobra.Command {
vars := deployWkldVars{}
cmd := &cobra.Command{
Use: "deploy",
Short: "Deploys a service to an environment.",
Long: `Deploys a service to an environment.`,
Example: `
Deploys a service named "frontend" to a "test" environment.
/code $ copilot svc deploy --name frontend --env test
Deploys a service with additional resource tags.
/code $ copilot svc deploy --resource-tags source/revision=bb133e7,deployment/initiator=manual`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newSvcDeployOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVar(&vars.imageTag, imageTagFlag, "", imageTagFlagDescription)
cmd.Flags().StringToStringVar(&vars.resourceTags, resourceTagsFlag, nil, resourceTagsFlagDescription)
cmd.Flags().BoolVar(&vars.forceNewUpdate, forceFlag, false, forceFlagDescription)
cmd.Flags().BoolVar(&vars.disableRollback, noRollbackFlag, false, noRollbackFlagDescription)
cmd.Flags().BoolVar(&vars.showDiff, diffFlag, false, diffFlagDescription)
cmd.Flags().BoolVar(&vars.skipDiffPrompt, diffAutoApproveFlag, false, diffAutoApproveFlagDescription)
return cmd
}
| 650 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"strings"
"testing"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
clideploy "github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
)
func TestSvcDeployOpts_Validate(t *testing.T) {
// There is no validation for svc deploy.
}
type svcDeployAskMocks struct {
store *mocks.Mockstore
sel *mocks.MockwsSelector
ws *mocks.MockwsWlDirReader
}
func TestSvcDeployOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inAppName string
inEnvName string
inSvcName string
setupMocks func(m *svcDeployAskMocks)
wantedSvcName string
wantedEnvName string
wantedError error
}{
"validate instead of prompting application name, svc name and environment name": {
inAppName: "phonetool",
inEnvName: "prod-iad",
inSvcName: "frontend",
setupMocks: func(m *svcDeployAskMocks) {
m.store.EXPECT().GetApplication("phonetool")
m.store.EXPECT().GetEnvironment("phonetool", "prod-iad").Return(&config.Environment{Name: "prod-iad"}, nil)
m.ws.EXPECT().ListServices().Return([]string{"frontend"}, nil)
m.store.EXPECT().GetService("phonetool", "frontend").Return(&config.Workload{}, nil)
m.sel.EXPECT().Service(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedSvcName: "frontend",
wantedEnvName: "prod-iad",
},
"error instead of prompting for application name if not provided": {
setupMocks: func(m *svcDeployAskMocks) {
m.store.EXPECT().GetApplication(gomock.Any()).Times(0)
},
wantedError: errNoAppInWorkspace,
},
"prompt for service name": {
inAppName: "phonetool",
inEnvName: "prod-iad",
setupMocks: func(m *svcDeployAskMocks) {
m.sel.EXPECT().Service("Select a service in your workspace", "").Return("frontend", nil)
m.store.EXPECT().GetApplication(gomock.Any()).Times(1)
m.store.EXPECT().GetEnvironment("phonetool", "prod-iad").Return(&config.Environment{Name: "prod-iad"}, nil)
m.store.EXPECT().GetService("phonetool", "frontend").Return(&config.Workload{}, nil)
},
wantedSvcName: "frontend",
wantedEnvName: "prod-iad",
},
"prompt for environment name": {
inAppName: "phonetool",
inSvcName: "frontend",
setupMocks: func(m *svcDeployAskMocks) {
m.sel.EXPECT().Environment(gomock.Any(), gomock.Any(), "phonetool").Return("prod-iad", nil)
m.store.EXPECT().GetApplication("phonetool")
m.ws.EXPECT().ListServices().Return([]string{"frontend"}, nil)
m.store.EXPECT().GetService("phonetool", "frontend").Return(&config.Workload{}, nil)
},
wantedSvcName: "frontend",
wantedEnvName: "prod-iad",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &svcDeployAskMocks{
store: mocks.NewMockstore(ctrl),
sel: mocks.NewMockwsSelector(ctrl),
ws: mocks.NewMockwsWlDirReader(ctrl),
}
tc.setupMocks(m)
opts := deploySvcOpts{
deployWkldVars: deployWkldVars{
appName: tc.inAppName,
name: tc.inSvcName,
envName: tc.inEnvName,
},
sel: m.sel,
store: m.store,
ws: m.ws,
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError == nil {
require.NoError(t, err)
require.Equal(t, tc.wantedSvcName, opts.name)
require.Equal(t, tc.wantedEnvName, opts.envName)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
type deployMocks struct {
mockDeployer *mocks.MockworkloadDeployer
mockInterpolator *mocks.Mockinterpolator
mockWsReader *mocks.MockwsWlDirReader
mockEnvFeaturesDescriber *mocks.MockversionCompatibilityChecker
mockMft *mockWorkloadMft
mockDiffWriter *strings.Builder
mockPrompter *mocks.Mockprompter
}
func TestSvcDeployOpts_Execute(t *testing.T) {
const (
mockAppName = "phonetool"
mockSvcName = "frontend"
mockEnvName = "prod-iad"
)
mockError := errors.New("some error")
testCases := map[string]struct {
inShowDiff bool
inSkipDiffPrompt bool
inForceFlag bool
inSvcType string
mock func(m *deployMocks)
wantedDiff string
wantedError error
}{
"error out if fail to read workload manifest": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return(nil, mockError)
},
wantedError: fmt.Errorf("read manifest file for frontend: some error"),
},
"error out if fail to interpolate workload manifest": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", mockError)
},
wantedError: fmt.Errorf("interpolate environment variables for frontend manifest: some error"),
},
"error if fail to get a list of available features from the environment": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return(nil, mockError)
},
wantedError: fmt.Errorf("get available features of the prod-iad environment stack: some error"),
},
"error out if force deploy for static site service": {
inForceFlag: true,
inSvcType: manifestinfo.StaticSiteType,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
},
wantedError: fmt.Errorf(`--force is not supported for service type "Static Site"`),
},
"error if some required features are not available in the environment": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1", "mockFeature3"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
},
wantedError: fmt.Errorf(`environment "prod-iad" is on version "v1.mock" which does not support the "mockFeature3" feature`),
},
"error if failed to upload artifacts": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(nil, mockError)
},
wantedError: fmt.Errorf("upload deploy resources for service frontend: some error"),
},
"error if failed to generate the template to show diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("generate the template for workload %q against environment %q: some error", mockSvcName, mockEnvName),
},
"error if failed to generate the diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&clideploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("", errors.New("some error"))
},
wantedError: errors.New("some error"),
},
"write 'no changes' if there is no diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&clideploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, nil)
},
wantedDiff: "No changes.\n",
},
"write the correct diff": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&clideploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, nil)
},
wantedDiff: "mock diff",
},
"error if fail to ask whether to continue the deployment": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&clideploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, errors.New("some error"))
},
wantedError: errors.New("ask whether to continue with the deployment: some error"),
},
"do not deploy if asked to": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&clideploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(false, nil)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Times(0)
},
},
"deploy if asked to": {
inShowDiff: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&clideploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Return(true, nil)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Times(1)
},
},
"skip prompt and deploy immediately after diff": {
inShowDiff: true,
inSkipDiffPrompt: true,
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&clideploy.GenerateCloudFormationTemplateOutput{}, nil)
m.mockDeployer.EXPECT().DeployDiff(gomock.Any()).Return("mock diff", nil)
m.mockDiffWriter = &strings.Builder{}
m.mockPrompter.EXPECT().Confirm(gomock.Eq("Continue with the deployment?"), gomock.Any(), gomock.Any()).Times(0)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Times(1)
},
},
"error if failed to deploy service": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Return(nil, mockError)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
},
wantedError: fmt.Errorf("deploy service frontend to environment prod-iad: some error"),
},
"success with no recommendations": {
mock: func(m *deployMocks) {
m.mockWsReader.EXPECT().ReadWorkloadManifest(mockSvcName).Return([]byte(""), nil)
m.mockInterpolator.EXPECT().Interpolate("").Return("", nil)
m.mockMft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{"mockFeature1"}
},
}
m.mockEnvFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mockEnvFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{"mockFeature1", "mockFeature2"}, nil)
m.mockDeployer.EXPECT().UploadArtifacts().Return(&clideploy.UploadArtifactsOutput{}, nil)
m.mockDeployer.EXPECT().DeployWorkload(gomock.Any()).Return(nil, nil)
m.mockDeployer.EXPECT().IsServiceAvailableInRegion("").Return(false, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployMocks{
mockDeployer: mocks.NewMockworkloadDeployer(ctrl),
mockInterpolator: mocks.NewMockinterpolator(ctrl),
mockWsReader: mocks.NewMockwsWlDirReader(ctrl),
mockEnvFeaturesDescriber: mocks.NewMockversionCompatibilityChecker(ctrl),
mockPrompter: mocks.NewMockprompter(ctrl),
}
tc.mock(m)
opts := deploySvcOpts{
deployWkldVars: deployWkldVars{
appName: mockAppName,
name: mockSvcName,
envName: mockEnvName,
showDiff: tc.inShowDiff,
skipDiffPrompt: tc.inSkipDiffPrompt,
forceNewUpdate: tc.inForceFlag,
clientConfigured: true,
},
svcType: tc.inSvcType,
newSvcDeployer: func() (workloadDeployer, error) {
return m.mockDeployer, nil
},
newInterpolator: func(app, env string) interpolator {
return m.mockInterpolator
},
ws: m.mockWsReader,
unmarshal: func(b []byte) (manifest.DynamicWorkload, error) {
return m.mockMft, nil
},
envFeaturesDescriber: m.mockEnvFeaturesDescriber,
prompt: m.mockPrompter,
diffWriter: m.mockDiffWriter,
targetApp: &config.Application{},
targetEnv: &config.Environment{},
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedError == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
if tc.wantedDiff != "" {
require.Equal(t, tc.wantedDiff, m.mockDiffWriter.String())
}
})
}
}
type checkEnvironmentCompatibilityMocks struct {
ws *mocks.MockwsEnvironmentsLister
versionFeatureGetter *mocks.MockversionCompatibilityChecker
requiredEnvironmentFeaturesFunc func() []string
}
func Test_isManifestCompatibleWithEnvironment(t *testing.T) {
mockError := errors.New("some error")
testCases := map[string]struct {
setupMock func(m *checkEnvironmentCompatibilityMocks)
mockManifest *mockWorkloadMft
wantedError error
}{
"error getting environment version": {
setupMock: func(m *checkEnvironmentCompatibilityMocks) {
m.versionFeatureGetter.EXPECT().Version().Return("", mockError)
},
wantedError: errors.New("get environment \"mockEnv\" version: some error"),
},
"error if env is not deployed": {
setupMock: func(m *checkEnvironmentCompatibilityMocks) {
m.versionFeatureGetter.EXPECT().Version().Return(version.EnvTemplateBootstrap, nil)
},
wantedError: errors.New("cannot deploy a service to an undeployed environment. Please run \"copilot env deploy --name mockEnv\" to deploy the environment first"),
},
"error getting environment available features": {
setupMock: func(m *checkEnvironmentCompatibilityMocks) {
m.versionFeatureGetter.EXPECT().Version().Return("mockVersion", nil)
m.versionFeatureGetter.EXPECT().AvailableFeatures().Return(nil, mockError)
m.requiredEnvironmentFeaturesFunc = func() []string {
return nil
}
},
wantedError: errors.New("get available features of the mockEnv environment stack: some error"),
},
"not compatible": {
setupMock: func(m *checkEnvironmentCompatibilityMocks) {
m.versionFeatureGetter.EXPECT().Version().Return("mockVersion", nil)
m.versionFeatureGetter.EXPECT().AvailableFeatures().Return([]string{template.ALBFeatureName}, nil)
m.requiredEnvironmentFeaturesFunc = func() []string {
return []string{template.InternalALBFeatureName}
}
},
wantedError: errors.New(`environment "mockEnv" is on version "mockVersion" which does not support the "Internal ALB" feature`),
},
"compatible": {
setupMock: func(m *checkEnvironmentCompatibilityMocks) {
m.versionFeatureGetter.EXPECT().Version().Return("mockVersion", nil)
m.versionFeatureGetter.EXPECT().AvailableFeatures().Return([]string{template.ALBFeatureName, template.InternalALBFeatureName}, nil)
m.requiredEnvironmentFeaturesFunc = func() []string {
return []string{template.InternalALBFeatureName}
}
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &checkEnvironmentCompatibilityMocks{
versionFeatureGetter: mocks.NewMockversionCompatibilityChecker(ctrl),
ws: mocks.NewMockwsEnvironmentsLister(ctrl),
}
tc.setupMock(m)
mockManifest := &mockWorkloadMft{
mockRequiredEnvironmentFeatures: m.requiredEnvironmentFeaturesFunc,
}
// WHEN
err := validateWorkloadManifestCompatibilityWithEnv(m.ws, m.versionFeatureGetter, mockManifest, "mockEnv")
// THEN
if tc.wantedError == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantedError.Error())
}
})
}
}
type mockWorkloadMft struct {
mockRequiredEnvironmentFeatures func() []string
}
func (m *mockWorkloadMft) ApplyEnv(envName string) (manifest.DynamicWorkload, error) {
return m, nil
}
func (m *mockWorkloadMft) Validate() error {
return nil
}
func (m *mockWorkloadMft) Load(sess *session.Session) error {
return nil
}
func (m *mockWorkloadMft) Manifest() interface{} {
return nil
}
func (m *mockWorkloadMft) RequiredEnvironmentFeatures() []string {
return m.mockRequiredEnvironmentFeatures()
}
| 592 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"math/rand"
"strings"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/cmd/copilot/template"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
svcExecNamePrompt = "Into which service would you like to execute?"
svcExecNameHelpPrompt = `Copilot runs your command in one of your chosen service's tasks.
The task is chosen at random, and the first essential container is used.`
ssmPluginInstallPrompt = `Looks like the Session Manager plugin is not installed yet.
Would you like to install the plugin to execute into the container?`
ssmPluginInstallPromptHelp = `You must install the Session Manager plugin on your local machine to be able to execute into the container
See https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html`
ssmPluginUpdatePrompt = `Looks like the Session Manager plugin is using version %s.
Would you like to update it to the latest version %s?`
)
var (
errSSMPluginCommandInstallCancelled = errors.New("ssm plugin install cancelled")
)
type svcExecOpts struct {
execVars
store store
sel deploySelector
newSvcDescriber func(*session.Session) serviceDescriber
newCommandExecutor func(*session.Session) ecsCommandExecutor
ssmPluginManager ssmPluginManager
prompter prompter
sessProvider sessionProvider
// Override in unit test
randInt func(int) int
}
func newSvcExecOpts(vars execVars) (*svcExecOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc exec"))
defaultSession, err := sessProvider.Default()
if err != nil {
return nil, err
}
ssmStore := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, ssmStore)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
return &svcExecOpts{
execVars: vars,
store: ssmStore,
sel: selector.NewDeploySelect(prompt.New(), ssmStore, deployStore),
newSvcDescriber: func(s *session.Session) serviceDescriber {
return ecs.New(s)
},
newCommandExecutor: func(s *session.Session) ecsCommandExecutor {
return awsecs.New(s)
},
randInt: func(x int) int {
return rand.Intn(x)
},
ssmPluginManager: exec.NewSSMPluginCommand(nil),
prompter: prompt.New(),
sessProvider: sessProvider,
}, nil
}
// Validate returns an error for any invalid optional flags.
func (o *svcExecOpts) Validate() error {
return validateSSMBinary(o.prompter, o.ssmPluginManager, o.skipConfirmation)
}
// Ask prompts for and validates any required flags.
func (o *svcExecOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
if err := o.validateAndAskSvcEnvName(); err != nil {
return err
}
return nil
}
// Execute executes a command in a running container.
func (o *svcExecOpts) Execute() error {
wkld, err := o.store.GetWorkload(o.appName, o.name)
if err != nil {
return fmt.Errorf("get workload: %w", err)
}
if wkld.Type == manifestinfo.RequestDrivenWebServiceType {
return fmt.Errorf("executing a command in a running container part of a service is not supported for services with type: '%s'", manifestinfo.RequestDrivenWebServiceType)
}
sess, err := o.envSession()
if err != nil {
return err
}
svcDesc, err := o.newSvcDescriber(sess).DescribeService(o.appName, o.envName, o.name)
if err != nil {
return fmt.Errorf("describe ECS service for %s in environment %s: %w", o.name, o.envName, err)
}
taskID, err := o.selectTask(awsecs.FilterRunningTasks(svcDesc.Tasks))
if err != nil {
return err
}
container := o.selectContainer()
log.Infof("Execute %s in container %s in task %s.\n", color.HighlightCode(o.command),
color.HighlightUserInput(container), color.HighlightResource(taskID))
if err = o.newCommandExecutor(sess).ExecuteCommand(awsecs.ExecuteCommandInput{
Cluster: svcDesc.ClusterName,
Command: o.command,
Container: container,
Task: taskID,
}); err != nil {
var errExecCmd *awsecs.ErrExecuteCommand
if errors.As(err, &errExecCmd) {
log.Errorf("Failed to execute command %s. Is %s set in your manifest?\n", o.command, color.HighlightCode("exec: true"))
}
return fmt.Errorf("execute command %s in container %s: %w", o.command, container, err)
}
return nil
}
func (o *svcExecOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.store.GetApplication(o.appName)
return err
}
app, err := o.sel.Application(svcAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *svcExecOpts) validateAndAskSvcEnvName() error {
if o.envName != "" {
if _, err := o.store.GetEnvironment(o.appName, o.envName); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.store.GetService(o.appName, o.name); err != nil {
return err
}
}
// Note: we let prompter handle the case when there is only option for user to choose from.
// This is naturally the case when `o.envName != "" && o.name != ""`.
deployedService, err := o.sel.DeployedService(svcExecNamePrompt, svcExecNameHelpPrompt, o.appName, selector.WithEnv(o.envName), selector.WithName(o.name))
if err != nil {
return fmt.Errorf("select deployed service for application %s: %w", o.appName, err)
}
o.name = deployedService.Name
o.envName = deployedService.Env
return nil
}
func (o *svcExecOpts) envSession() (*session.Session, error) {
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, fmt.Errorf("get environment %s: %w", o.envName, err)
}
return o.sessProvider.FromRole(env.ManagerRoleARN, env.Region)
}
func (o *svcExecOpts) selectTask(tasks []*awsecs.Task) (string, error) {
if len(tasks) == 0 {
return "", fmt.Errorf("found no running task for service %s in environment %s", o.name, o.envName)
}
if o.taskID != "" {
for _, task := range tasks {
taskID, err := awsecs.TaskID(aws.StringValue(task.TaskArn))
if err != nil {
return "", err
}
if strings.HasPrefix(taskID, o.taskID) {
return taskID, nil
}
}
return "", fmt.Errorf("found no running task whose ID is prefixed with %s", o.taskID)
}
taskID, err := awsecs.TaskID(aws.StringValue(tasks[o.randInt(len(tasks))].TaskArn))
if err != nil {
return "", err
}
return taskID, nil
}
func (o *svcExecOpts) selectContainer() string {
if o.containerName != "" {
return o.containerName
}
// The first essential container is named with the workload name.
return o.name
}
func validateSSMBinary(prompt prompter, manager ssmPluginManager, skipConfirmation *bool) error {
if skipConfirmation != nil && !aws.BoolValue(skipConfirmation) {
return nil
}
err := manager.ValidateBinary()
if err == nil {
return nil
}
switch v := err.(type) {
case *exec.ErrSSMPluginNotExist:
// If ssm plugin is not install, prompt users to install the plugin.
if skipConfirmation == nil {
confirmInstall, err := prompt.Confirm(ssmPluginInstallPrompt, ssmPluginInstallPromptHelp)
if err != nil {
return fmt.Errorf("prompt to confirm installing the plugin: %w", err)
}
if !confirmInstall {
return errSSMPluginCommandInstallCancelled
}
}
if err := manager.InstallLatestBinary(); err != nil {
return fmt.Errorf("install ssm plugin: %w", err)
}
return nil
case *exec.ErrOutdatedSSMPlugin:
// If ssm plugin is not up to date, prompt users to update the plugin.
if skipConfirmation == nil {
confirmUpdate, err := prompt.Confirm(
fmt.Sprintf(ssmPluginUpdatePrompt, v.CurrentVersion, v.LatestVersion), "")
if err != nil {
return fmt.Errorf("prompt to confirm updating the plugin: %w", err)
}
if !confirmUpdate {
log.Infof(`Alright, we won't update the Session Manager plugin.
It might fail to execute if it is not using the latest plugin.
`)
return nil
}
}
if err := manager.InstallLatestBinary(); err != nil {
return fmt.Errorf("update ssm plugin: %w", err)
}
return nil
default:
log.Errorf(`Failed to validate the Session Manager plugin. Please install or make sure your SSM plugin is up-to-date:
https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html
`)
return fmt.Errorf("validate ssm plugin: %w", err)
}
}
// buildSvcExecCmd builds the command for execute a running container in a service.
func buildSvcExecCmd() *cobra.Command {
vars := execVars{}
var skipPrompt bool
cmd := &cobra.Command{
Use: "exec",
Short: "Execute a command in a running container part of a service.",
Example: `
Start an interactive bash session with a task part of the "frontend" service.
/code $ copilot svc exec -a my-app -e test -n frontend
Runs the 'ls' command in the task prefixed with ID "8c38184" within the "backend" service.
/code $ copilot svc exec -a my-app -e test --name backend --task-id 8c38184 --command "ls"`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newSvcExecOpts(vars)
if err != nil {
return err
}
if cmd.Flags().Changed(yesFlag) {
opts.skipConfirmation = aws.Bool(false)
if skipPrompt {
opts.skipConfirmation = aws.Bool(true)
}
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", nameFlagDescription)
cmd.Flags().StringVarP(&vars.command, commandFlag, commandFlagShort, defaultCommand, execCommandFlagDescription)
cmd.Flags().StringVar(&vars.taskID, taskIDFlag, "", taskIDFlagDescription)
cmd.Flags().StringVar(&vars.containerName, containerFlag, "", containerFlagDescription)
cmd.Flags().BoolVar(&skipPrompt, yesFlag, false, execYesFlagDescription)
cmd.SetUsageTemplate(template.Usage)
return cmd
}
| 311 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type execSvcMocks struct {
storeSvc *mocks.Mockstore
sessProvider *mocks.MocksessionProvider
sel *mocks.MockdeploySelector
ecsSvcDescriber *mocks.MockserviceDescriber
ecsCommandExecutor *mocks.MockecsCommandExecutor
ssmPluginManager *mocks.MockssmPluginManager
prompter *mocks.Mockprompter
}
func TestSvcExec_Validate(t *testing.T) {
const (
mockApp = "my-app"
mockEnv = "my-env"
mockSvc = "my-svc"
)
mockErr := errors.New("some error")
testCases := map[string]struct {
inputApp string
inputEnv string
inputSvc string
skipConfirmation *bool
setupMocks func(mocks execSvcMocks)
wantedError error
}{
"skip without installing/updating if yes flag is set to be false": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
skipConfirmation: aws.Bool(false),
setupMocks: func(m execSvcMocks) {},
},
"should bubble error if cannot validate ssm plugin": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
m.ssmPluginManager.EXPECT().ValidateBinary().Return(mockErr)
},
wantedError: fmt.Errorf("validate ssm plugin: some error"),
},
"should bubble error if cannot prompt to confirm install": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrSSMPluginNotExist{}),
m.prompter.EXPECT().Confirm(ssmPluginInstallPrompt, ssmPluginInstallPromptHelp).Return(false, mockErr),
)
},
wantedError: fmt.Errorf("prompt to confirm installing the plugin: some error"),
},
"should bubble error if cannot confirm install": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrSSMPluginNotExist{}),
m.prompter.EXPECT().Confirm(ssmPluginInstallPrompt, ssmPluginInstallPromptHelp).
Return(false, nil),
)
},
wantedError: errSSMPluginCommandInstallCancelled,
},
"should bubble error if cannot install binary": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrSSMPluginNotExist{}),
m.prompter.EXPECT().Confirm(ssmPluginInstallPrompt, ssmPluginInstallPromptHelp).
Return(true, nil),
m.ssmPluginManager.EXPECT().InstallLatestBinary().Return(mockErr),
)
},
wantedError: fmt.Errorf("install ssm plugin: some error"),
},
"should bubble error if cannot prompt to confirm update": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrOutdatedSSMPlugin{
CurrentVersion: "mockCurrentVersion",
LatestVersion: "mockLatestVersion",
}),
m.prompter.EXPECT().Confirm(fmt.Sprintf(ssmPluginUpdatePrompt, "mockCurrentVersion", "mockLatestVersion"), "").
Return(false, mockErr),
)
},
wantedError: fmt.Errorf("prompt to confirm updating the plugin: some error"),
},
"should proceed if cannot confirm update": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrOutdatedSSMPlugin{
CurrentVersion: "mockCurrentVersion",
LatestVersion: "mockLatestVersion",
}),
m.prompter.EXPECT().Confirm(fmt.Sprintf(ssmPluginUpdatePrompt, "mockCurrentVersion", "mockLatestVersion"), "").
Return(false, nil),
)
},
},
"should bubble error if cannot update the binary": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrOutdatedSSMPlugin{
CurrentVersion: "mockCurrentVersion",
LatestVersion: "mockLatestVersion",
}),
m.prompter.EXPECT().Confirm(fmt.Sprintf(ssmPluginUpdatePrompt, "mockCurrentVersion", "mockLatestVersion"), "").
Return(true, nil),
m.ssmPluginManager.EXPECT().InstallLatestBinary().Return(mockErr),
)
},
wantedError: fmt.Errorf("update ssm plugin: some error"),
},
"skip validation if app flag is not set": {
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(nil),
)
},
},
"valid case": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(nil),
)
},
wantedError: nil,
},
"valid case with ssm plugin installing": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrSSMPluginNotExist{}),
m.prompter.EXPECT().Confirm(ssmPluginInstallPrompt, ssmPluginInstallPromptHelp).Return(true, nil),
m.ssmPluginManager.EXPECT().InstallLatestBinary().Return(nil),
)
},
wantedError: nil,
},
"valid case with ssm plugin updating and skip confirming to install": {
inputApp: mockApp,
inputEnv: mockEnv,
inputSvc: mockSvc,
skipConfirmation: aws.Bool(true),
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.ssmPluginManager.EXPECT().ValidateBinary().Return(&exec.ErrOutdatedSSMPlugin{
CurrentVersion: "mockCurrentVersion",
LatestVersion: "mockLatestVersion",
}),
m.ssmPluginManager.EXPECT().InstallLatestBinary().Return(nil),
)
},
wantedError: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mockSSMPluginManager := mocks.NewMockssmPluginManager(ctrl)
mockPrompter := mocks.NewMockprompter(ctrl)
mocks := execSvcMocks{
storeSvc: mockStoreReader,
ssmPluginManager: mockSSMPluginManager,
prompter: mockPrompter,
}
tc.setupMocks(mocks)
execSvcs := &svcExecOpts{
execVars: execVars{
name: tc.inputSvc,
appName: tc.inputApp,
envName: tc.inputEnv,
skipConfirmation: tc.skipConfirmation,
},
store: mockStoreReader,
ssmPluginManager: mockSSMPluginManager,
prompter: mockPrompter,
}
// WHEN
err := execSvcs.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestSvcExec_Ask(t *testing.T) {
const (
inputApp = "my-app"
inputEnv = "my-env"
inputSvc = "my-svc"
)
testCases := map[string]struct {
inputApp string
inputEnv string
inputSvc string
setupMocks func(mocks execSvcMocks)
wantedApp string
wantedEnv string
wantedSvc string
wantedError error
}{
"validate app env and svc with all flags passed in": {
inputApp: inputApp,
inputEnv: inputEnv,
inputSvc: inputSvc,
setupMocks: func(m execSvcMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil)
m.storeSvc.EXPECT().GetEnvironment("my-app", "my-env").Return(&config.Environment{Name: "my-env"}, nil)
m.storeSvc.EXPECT().GetService("my-app", "my-svc").Return(&config.Workload{}, nil)
m.sel.EXPECT().DeployedService(svcExecNamePrompt, svcExecNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil) // Let prompter handles the case when svc(env) is definite.
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"prompt for app name": {
inputEnv: inputEnv,
inputSvc: inputSvc,
setupMocks: func(m execSvcMocks) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("my-app", nil)
m.storeSvc.EXPECT().GetApplication(gomock.Any()).Times(0)
// Don't care about the other calls.
m.storeSvc.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.storeSvc.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil).AnyTimes()
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"returns error when fail to select apps": {
setupMocks: func(m execSvcMocks) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error"))
},
wantedError: fmt.Errorf("select application: some error"),
},
"prompt for svc and env": {
inputApp: inputApp,
setupMocks: func(m execSvcMocks) {
m.storeSvc.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.storeSvc.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(svcExecNamePrompt, svcExecNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil)
// Don't care about the other calls.
m.storeSvc.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"returns error when fail to select services": {
inputApp: inputApp,
setupMocks: func(m execSvcMocks) {
m.sel.EXPECT().DeployedService(svcExecNamePrompt, svcExecNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(nil, fmt.Errorf("some error"))
// Don't care about the other calls.
m.storeSvc.EXPECT().GetApplication(gomock.Any()).AnyTimes()
},
wantedError: fmt.Errorf("select deployed service for application my-app: some error"),
},
"success": {
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("my-app", nil),
m.sel.EXPECT().DeployedService(svcExecNamePrompt, svcExecNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil),
)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mockSelector := mocks.NewMockdeploySelector(ctrl)
mocks := execSvcMocks{
storeSvc: mockStoreReader,
sel: mockSelector,
}
tc.setupMocks(mocks)
execSvcs := &svcExecOpts{
execVars: execVars{
name: tc.inputSvc,
envName: tc.inputEnv,
appName: tc.inputApp,
},
store: mockStoreReader,
sel: mockSelector,
}
// WHEN
err := execSvcs.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, execSvcs.appName, "expected app name to match")
require.Equal(t, tc.wantedSvc, execSvcs.name, "expected service name to match")
require.Equal(t, tc.wantedEnv, execSvcs.envName, "expected service name to match")
}
})
}
}
func TestSvcExec_Execute(t *testing.T) {
const (
mockTaskARN = "arn:aws:ecs:us-west-2:123456789:task/mockCluster/mockTaskID"
mockOtherTaskARN = "arn:aws:ecs:us-west-2:123456789:task/mockCluster/mockTaskID1"
)
mockWl := config.Workload{
App: "mockApp",
Name: "mockSvc",
Type: "Load Balanced Web Service",
}
mockRDWSWl := config.Workload{
App: "mockApp",
Name: "mockSvc",
Type: "Request-Driven Web Service",
}
mockError := errors.New("some error")
testCases := map[string]struct {
containerName string
taskID string
setupMocks func(mocks execSvcMocks)
wantedError error
}{
"return error if fail to get workload": {
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(nil, mockError),
)
},
wantedError: fmt.Errorf("get workload: some error"),
},
"return error if service type is Request-Driven Web Service": {
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(&mockRDWSWl, nil),
)
},
wantedError: fmt.Errorf("executing a command in a running container part of a service is not supported for services with type: 'Request-Driven Web Service'"),
},
"return error if fail to get environment": {
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(&mockWl, nil),
m.storeSvc.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(nil, mockError),
)
},
wantedError: fmt.Errorf("get environment mockEnv: some error"),
},
"return error if fail to describe service": {
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(&mockWl, nil),
m.storeSvc.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(&config.Environment{
Name: "my-env",
}, nil),
m.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil),
m.ecsSvcDescriber.EXPECT().DescribeService("mockApp", "mockEnv", "mockSvc").Return(nil, mockError),
)
},
wantedError: fmt.Errorf("describe ECS service for mockSvc in environment mockEnv: some error"),
},
"return error if no running task found": {
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(&mockWl, nil),
m.storeSvc.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(&config.Environment{
Name: "my-env",
}, nil),
m.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil),
m.ecsSvcDescriber.EXPECT().DescribeService("mockApp", "mockEnv", "mockSvc").Return(&ecs.ServiceDesc{
Tasks: []*awsecs.Task{},
}, nil),
)
},
wantedError: fmt.Errorf("found no running task for service mockSvc in environment mockEnv"),
},
"return error if fail to find prefixed task": {
taskID: "mockTaskID1",
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(&mockWl, nil),
m.storeSvc.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(&config.Environment{
Name: "my-env",
}, nil),
m.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil),
m.ecsSvcDescriber.EXPECT().DescribeService("mockApp", "mockEnv", "mockSvc").Return(&ecs.ServiceDesc{
Tasks: []*awsecs.Task{
{
TaskArn: aws.String(mockTaskARN),
LastStatus: aws.String("RUNNING"),
},
},
}, nil),
)
},
wantedError: fmt.Errorf("found no running task whose ID is prefixed with mockTaskID1"),
},
"return error if fail to execute command": {
containerName: "hello",
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(&mockWl, nil),
m.storeSvc.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(&config.Environment{
Name: "my-env",
}, nil),
m.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil),
m.ecsSvcDescriber.EXPECT().DescribeService("mockApp", "mockEnv", "mockSvc").Return(&ecs.ServiceDesc{
ClusterName: "mockCluster",
Tasks: []*awsecs.Task{
{
TaskArn: aws.String(mockTaskARN),
LastStatus: aws.String("RUNNING"),
},
},
}, nil),
m.ecsCommandExecutor.EXPECT().ExecuteCommand(awsecs.ExecuteCommandInput{
Cluster: "mockCluster",
Container: "hello",
Task: "mockTaskID",
Command: "mockCommand",
}).Return(mockError),
)
},
wantedError: fmt.Errorf("execute command mockCommand in container hello: some error"),
},
"success": {
setupMocks: func(m execSvcMocks) {
gomock.InOrder(
m.storeSvc.EXPECT().GetWorkload("mockApp", "mockSvc").Return(&mockWl, nil),
m.storeSvc.EXPECT().GetEnvironment("mockApp", "mockEnv").Return(&config.Environment{
Name: "my-env",
}, nil),
m.sessProvider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil),
m.ecsSvcDescriber.EXPECT().DescribeService("mockApp", "mockEnv", "mockSvc").Return(&ecs.ServiceDesc{
ClusterName: "mockCluster",
Tasks: []*awsecs.Task{
{
TaskArn: aws.String(mockTaskARN),
LastStatus: aws.String("RUNNING"),
},
{
TaskArn: aws.String(mockOtherTaskARN),
LastStatus: aws.String("RUNNING"),
},
},
}, nil),
m.ecsCommandExecutor.EXPECT().ExecuteCommand(awsecs.ExecuteCommandInput{
Cluster: "mockCluster",
Container: "mockSvc",
Task: "mockTaskID",
Command: "mockCommand",
}).Return(nil),
)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mockSvcDescriber := mocks.NewMockserviceDescriber(ctrl)
mockCommandExecutor := mocks.NewMockecsCommandExecutor(ctrl)
mockSessionProvider := mocks.NewMocksessionProvider(ctrl)
mockNewSvcDescriber := func(_ *session.Session) serviceDescriber {
return mockSvcDescriber
}
mockNewCommandExecutor := func(_ *session.Session) ecsCommandExecutor {
return mockCommandExecutor
}
mocks := execSvcMocks{
storeSvc: mockStoreReader,
ecsCommandExecutor: mockCommandExecutor,
ecsSvcDescriber: mockSvcDescriber,
sessProvider: mockSessionProvider,
}
tc.setupMocks(mocks)
execSvcs := &svcExecOpts{
execVars: execVars{
name: "mockSvc",
envName: "mockEnv",
appName: "mockApp",
command: "mockCommand",
containerName: tc.containerName,
taskID: tc.taskID,
},
store: mockStoreReader,
newSvcDescriber: mockNewSvcDescriber,
newCommandExecutor: mockNewCommandExecutor,
randInt: func(i int) int { return 0 },
sessProvider: mockSessionProvider,
}
// WHEN
err := execSvcs.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 629 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/dustin/go-humanize/english"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerfile"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/initialize"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
const (
wkldInitImagePromptHelp = `The name of an existing Docker image. Images in the Docker Hub registry are available by default.
Other repositories are specified with either repository-url/image:tag or repository-url/image@digest`
wkldInitAppRunnerImagePromptHelp = `The name of an existing Docker image. App Runner supports images hosted in ECR or ECR Public registries.`
)
const (
defaultSvcPortString = "80"
service = "service"
job = "job"
)
var (
fmtSvcInitSvcTypePrompt = "Which %s best represents your service's architecture?"
svcInitSvcTypeHelpPrompt = fmt.Sprintf(`A %s is an internet-facing or private HTTP server managed by AWS App Runner that scales based on incoming requests.
To learn more see: https://git.io/JEEfb
A %s is an internet-facing HTTP server managed by Amazon ECS on AWS Fargate behind a load balancer.
To learn more see: https://git.io/JEEJe
A %s is a private, non internet-facing service accessible from other services in your VPC.
To learn more see: https://git.io/JEEJt
A %s is a private service that can consume messages published to topics in your application.
To learn more see: https://git.io/JEEJY`,
manifestinfo.RequestDrivenWebServiceType,
manifestinfo.LoadBalancedWebServiceType,
manifestinfo.BackendServiceType,
manifestinfo.WorkerServiceType,
)
fmtWkldInitNamePrompt = "What do you want to %s this %s?"
fmtWkldInitNameHelpPrompt = `The name will uniquely identify this %s within your app %s.
Deployed resources (such as your ECR repository, logs) will contain this %[1]s's name and be tagged with it.`
fmtWkldInitDockerfilePrompt = "Which " + color.Emphasize("Dockerfile") + " would you like to use for %s?"
wkldInitDockerfileHelpPrompt = "Dockerfile to use for building your container image."
fmtWkldInitDockerfilePathPrompt = "What is the path to the " + color.Emphasize("Dockerfile") + " for %s?"
wkldInitDockerfilePathHelpPrompt = "Path to Dockerfile to use for building your container image."
svcInitSvcPortPrompt = "Which %s do you want customer traffic sent to?"
svcInitSvcPortHelpPrompt = `The port will be used by the load balancer to route incoming traffic to this service.
You should set this to the port which your Dockerfile uses to communicate with the internet.`
svcInitPublisherPrompt = "Which topics do you want to subscribe to?"
svcInitPublisherHelpPrompt = `A publisher is an existing SNS Topic to which a service publishes messages.
These messages can be consumed by the Worker Service.`
svcInitIngressTypePrompt = "Would you like to accept traffic from your environment or the internet?"
svcInitIngressTypeHelpPrompt = `"Environment" will configure your service as private.
"Internet" will configure your service as public.`
wkldInitImagePrompt = fmt.Sprintf("What's the %s ([registry/]repository[:tag|@digest]) of the image to use?", color.Emphasize("location"))
fmtStaticSiteInitDirFilePrompt = "Which " + color.Emphasize("directories or files") + " would you like to upload for %s?"
staticSiteInitDirFileHelpPrompt = "Directories or files to use for building your static site."
fmtStaticSiteInitDirFilePathPrompt = "What is the path to the " + color.Emphasize("directory or file") + " for %s?"
staticSiteInitDirFilePathHelpPrompt = "Path to directory or file to use for building your static site."
)
const (
ingressTypeEnvironment = "Environment"
ingressTypeInternet = "Internet"
)
var rdwsIngressOptions = []string{
ingressTypeEnvironment,
ingressTypeInternet,
}
var serviceTypeHints = map[string]string{
manifestinfo.RequestDrivenWebServiceType: "App Runner",
manifestinfo.LoadBalancedWebServiceType: "Internet to ECS on Fargate",
manifestinfo.BackendServiceType: "ECS on Fargate",
manifestinfo.WorkerServiceType: "Events to SQS to ECS on Fargate",
manifestinfo.StaticSiteType: "Internet to CDN to S3 bucket",
}
type initWkldVars struct {
appName string
wkldType string
name string
dockerfilePath string
image string
subscriptions []string
noSubscribe bool
sourcePaths []string
allowAppDowngrade bool
}
type initSvcVars struct {
initWkldVars
port uint16
ingressType string
}
type initSvcOpts struct {
initSvcVars
// Interfaces to interact with dependencies.
fs afero.Fs
init svcInitializer
prompt prompter
store store
dockerEngine dockerEngine
sel dockerfileSelector
sourceSel staticSourceSelector
topicSel topicSelector
mftReader manifestReader
// Outputs stored on successful actions.
manifestPath string
platform *manifest.PlatformString
topics []manifest.TopicSubscription
staticAssets []manifest.FileUpload
// For workspace validation.
wsAppName string
wsPendingCreation bool
// Cache variables
df dockerfileParser
manifestExists bool
additionalFoundPort uint16 // For logging a personalized recommended action with multiple ports.
wsRoot string
dockerfile func(path string) dockerfileParser
initEnvDescriber func(appName, envName string) (envDescriber, error)
newAppVersionGetter func(appName string) (versionGetter, error)
// Overridden in tests.
templateVersion string
}
func newInitSvcOpts(vars initSvcVars) (*initSvcOpts, error) {
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc init"))
sess, err := sessProvider.Default()
if err != nil {
return nil, err
}
store := config.NewSSMStore(identity.New(sess), ssm.New(sess), aws.StringValue(sess.Config.Region))
prompter := prompt.New()
deployStore, err := deploy.NewStore(sessProvider, store)
if err != nil {
return nil, err
}
snsSel := selector.NewDeploySelect(prompter, store, deployStore)
initSvc := &initialize.WorkloadInitializer{
Store: store,
Ws: ws,
Prog: termprogress.NewSpinner(log.DiagnosticWriter),
Deployer: cloudformation.New(sess, cloudformation.WithProgressTracker(os.Stderr)),
}
dfSel, err := selector.NewDockerfileSelector(prompter, fs)
if err != nil {
return nil, err
}
sourceSel, err := selector.NewLocalFileSelector(prompter, fs, ws)
if err != nil {
return nil, fmt.Errorf("init a new local file selector: %w", err)
}
opts := &initSvcOpts{
initSvcVars: vars,
store: store,
fs: fs,
init: initSvc,
prompt: prompter,
sel: dfSel,
topicSel: snsSel,
sourceSel: sourceSel,
mftReader: ws,
newAppVersionGetter: func(appName string) (versionGetter, error) {
return describe.NewAppDescriber(appName)
},
initEnvDescriber: func(appName string, envName string) (envDescriber, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: appName,
Env: envName,
ConfigStore: store,
})
if err != nil {
return nil, err
}
return envDescriber, nil
},
dockerEngine: dockerengine.New(exec.NewCmd()),
wsAppName: tryReadingAppName(),
wsRoot: ws.ProjectRoot(),
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
}
return opts, nil
}
// Validate returns an error for any invalid optional flags.
func (o *initSvcOpts) Validate() error {
// If this app is pending creation, we'll skip validation.
if !o.wsPendingCreation {
if err := validateWorkspaceApp(o.wsAppName, o.appName, o.store); err != nil {
return err
}
o.appName = o.wsAppName
}
if o.dockerfilePath != "" && o.image != "" {
return fmt.Errorf("--%s and --%s cannot be specified together", dockerFileFlag, imageFlag)
}
if o.dockerfilePath != "" {
if _, err := o.fs.Stat(o.dockerfilePath); err != nil {
return err
}
}
if o.port != 0 {
if err := validateSvcPort(o.port); err != nil {
return err
}
}
if o.image != "" && o.wkldType == manifestinfo.RequestDrivenWebServiceType {
if err := validateAppRunnerImage(o.image); err != nil {
return err
}
}
if len(o.sourcePaths) != 0 {
if o.wkldType != manifestinfo.StaticSiteType {
return fmt.Errorf("'--%s' must be specified with '--%s %q'", sourcesFlag, typeFlag, manifestinfo.StaticSiteType)
}
if err := o.validateSourcePaths(o.sourcePaths); err != nil {
return err
}
assets, err := o.convertStringsToAssets(o.sourcePaths)
if err != nil {
return fmt.Errorf("convert source strings to objects: %w", err)
}
o.staticAssets = assets
}
if err := validateSubscribe(o.noSubscribe, o.subscriptions); err != nil {
return err
}
if err := o.validateIngressType(); err != nil {
return err
}
return nil
}
func (o *initSvcOpts) validateSourcePaths(sources []string) error {
if o.wsPendingCreation {
// This can happen during `copilot init`, that we have to `Validate` before there is a workspace.
// In this case, we skip the validation for path, and let `svc deploy` handle the validation.
return nil
}
for _, source := range sources {
_, err := o.fs.Stat(filepath.Join(o.wsRoot, source))
if err != nil {
return fmt.Errorf("source %q must be a valid path relative to the workspace %q: %w", source, o.wsRoot, err)
}
}
return nil
}
// Ask prompts for and validates any required flags.
func (o *initSvcOpts) Ask() error {
// NOTE: we optimize the case where `name` is given as a flag while `wkldType` is not.
// In this case, we can try reading the manifest, and set `wkldType` to the value found in the manifest
// without having to validate it. We can then short circuit the rest of the prompts for an optimal UX.
if o.name != "" && o.wkldType == "" {
// Best effort to validate the service name without type.
if err := o.validateSvc(); err != nil {
return err
}
shouldSkipAsking, err := o.manifestAlreadyExists()
if err != nil {
return err
}
if shouldSkipAsking {
return nil
}
}
if o.wkldType != "" {
if err := validateSvcType(o.wkldType); err != nil {
return err
}
} else {
if err := o.askSvcType(); err != nil {
return err
}
}
if o.name == "" {
if err := o.askSvcName(); err != nil {
return err
}
}
if err := o.validateSvc(); err != nil {
return err
}
if err := o.askIngressType(); err != nil {
return err
}
shouldSkipAsking, err := o.manifestAlreadyExists()
if err != nil {
return err
}
if shouldSkipAsking {
return nil
}
return o.askSvcDetails()
}
// Execute writes the service's manifest file and stores the service in SSM.
func (o *initSvcOpts) Execute() error {
if !o.allowAppDowngrade {
appVersionGetter, err := o.newAppVersionGetter(o.appName)
if err != nil {
return err
}
if err := validateAppVersion(appVersionGetter, o.appName, o.templateVersion); err != nil {
return err
}
}
// Check for a valid healthcheck and add it to the opts.
var hc manifest.ContainerHealthCheck
var err error
if o.dockerfilePath != "" {
hc, err = parseHealthCheck(o.dockerfile(o.dockerfilePath))
if err != nil {
log.Warningf("Cannot parse the HEALTHCHECK instruction from the Dockerfile: %v\n", err)
}
}
// If the user passes in an image, their docker engine isn't necessarily running, and we can't do anything with the platform because we're not building the Docker image.
if o.image == "" && !o.manifestExists {
platform, err := legitimizePlatform(o.dockerEngine, o.wkldType)
if err != nil {
return err
}
if platform != "" {
o.platform = &platform
}
}
// Environments that are deployed and have​ only private subnets.
envs, err := envsWithPrivateSubnetsOnly(o.store, o.initEnvDescriber, o.appName)
if err != nil {
return err
}
o.manifestPath, err = o.init.Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: o.appName,
Name: o.name,
Type: o.wkldType,
DockerfilePath: o.dockerfilePath,
Image: o.image,
Platform: manifest.PlatformArgsOrString{
PlatformString: o.platform,
},
Topics: o.topics,
PrivateOnlyEnvironments: envs,
},
Port: o.port,
HealthCheck: hc,
Private: strings.EqualFold(o.ingressType, ingressTypeEnvironment),
FileUploads: o.staticAssets,
})
if err != nil {
return err
}
return nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *initSvcOpts) RecommendActions() error {
actions := []string{fmt.Sprintf("Update your manifest %s to change the defaults.", color.HighlightResource(o.manifestPath))}
// If the Dockerfile exposes multiple ports, log a code block suggesting adding additional rules.
if o.additionalFoundPort != 0 {
multiplePortsAdditionalPathsAction := fmt.Sprintf(`It looks like your Dockerfile exposes multiple ports.
You can specify multiple paths where your service will receive traffic by setting http.additional_rules:
%s`, color.HighlightCodeBlock(fmt.Sprintf(`http:
path: /
additional_rules:
- path: /admin
target_port: %d`, o.additionalFoundPort)))
actions = append(actions, multiplePortsAdditionalPathsAction)
}
actions = append(actions, fmt.Sprintf("Run %s to deploy your service to a %s environment.",
color.HighlightCode(fmt.Sprintf("copilot svc deploy --name %s --env %s", o.name, defaultEnvironmentName)),
defaultEnvironmentName))
logRecommendedActions(actions)
return nil
}
func (o *initSvcOpts) askSvcDetails() error {
if o.wkldType == manifestinfo.StaticSiteType {
return o.askStaticSite()
}
err := o.askDockerfile()
if err != nil {
return err
}
if o.dockerfilePath == "" {
if err := o.askImage(); err != nil {
return err
}
}
if err := o.askSvcPort(); err != nil {
return err
}
return o.askSvcPublishers()
}
func (o *initSvcOpts) askSvcType() error {
if o.wkldType != "" {
return nil
}
msg := fmt.Sprintf(fmtSvcInitSvcTypePrompt, color.Emphasize("service type"))
t, err := o.prompt.SelectOption(msg, svcInitSvcTypeHelpPrompt, svcTypePromptOpts(), prompt.WithFinalMessage("Service type:"))
if err != nil {
return fmt.Errorf("select service type: %w", err)
}
o.wkldType = t
return nil
}
func (o *initSvcOpts) validateSvc() error {
if err := validateSvcName(o.name, o.wkldType); err != nil {
return err
}
return o.validateDuplicateSvc()
}
func (o *initSvcOpts) validateDuplicateSvc() error {
_, err := o.store.GetService(o.appName, o.name)
if err == nil {
log.Errorf(`It seems like you are trying to init a service that already exists.
To recreate the service, please run:
1. %s. Note: The manifest file will not be deleted and will be used in Step 2.
If you'd prefer a new default manifest, please manually delete the existing one.
2. And then %s
`,
color.HighlightCode(fmt.Sprintf("copilot svc delete --name %s", o.name)),
color.HighlightCode(fmt.Sprintf("copilot svc init --name %s", o.name)))
return fmt.Errorf("service %s already exists", color.HighlightUserInput(o.name))
}
var errNoSuchSvc *config.ErrNoSuchService
if !errors.As(err, &errNoSuchSvc) {
return fmt.Errorf("validate if service exists: %w", err)
}
return nil
}
func (o *initSvcOpts) askStaticSite() error {
if len(o.staticAssets) != 0 {
return nil
}
var sources []string
var err error
if o.wsPendingCreation {
sources, err = selector.AskCustomPaths(
o.prompt,
fmt.Sprintf(fmtStaticSiteInitDirFilePathPrompt, color.HighlightUserInput(o.name)),
staticSiteInitDirFilePathHelpPrompt,
validateNonEmptyString, // When the workspace is absent, we skip the validation and leave it to `svc deploy`.
)
} else {
sources, err = o.sourceSel.StaticSources(
fmt.Sprintf(fmtStaticSiteInitDirFilePrompt, color.HighlightUserInput(o.name)),
staticSiteInitDirFileHelpPrompt,
fmt.Sprintf(fmtStaticSiteInitDirFilePathPrompt, color.HighlightUserInput(o.name)),
staticSiteInitDirFilePathHelpPrompt,
func(val interface{}) error {
path, ok := val.(string)
if !ok {
return errValueNotAString
}
_, err := o.fs.Stat(filepath.Join(o.wsRoot, path))
if err != nil {
return fmt.Errorf("source %q must be a valid path relative to the workspace %q: %w", path, o.wsRoot, err)
}
return nil
},
)
}
if err != nil {
return err
}
if o.staticAssets, err = o.convertStringsToAssets(sources); err != nil {
return fmt.Errorf("convert source paths to asset objects: %w", err)
}
return nil
}
func (o *initSvcOpts) askSvcName() error {
name, err := o.prompt.Get(
fmt.Sprintf(fmtWkldInitNamePrompt, color.Emphasize("name"), "service"),
fmt.Sprintf(fmtWkldInitNameHelpPrompt, service, o.appName),
func(val interface{}) error {
return validateSvcName(val, o.wkldType)
},
prompt.WithFinalMessage("Service name:"))
if err != nil {
return fmt.Errorf("get service name: %w", err)
}
o.name = name
return nil
}
func (o *initSvcOpts) askIngressType() error {
if o.wkldType != manifestinfo.RequestDrivenWebServiceType || o.ingressType != "" {
return nil
}
var opts []prompt.Option
for _, typ := range rdwsIngressOptions {
opts = append(opts, prompt.Option{Value: typ})
}
t, err := o.prompt.SelectOption(svcInitIngressTypePrompt, svcInitIngressTypeHelpPrompt, opts, prompt.WithFinalMessage("Reachable from:"))
if err != nil {
return fmt.Errorf("select ingress type: %w", err)
}
o.ingressType = t
return nil
}
func (o *initSvcOpts) validateIngressType() error {
if o.wkldType != manifestinfo.RequestDrivenWebServiceType {
return nil
}
if strings.EqualFold(o.ingressType, "internet") || strings.EqualFold(o.ingressType, "environment") {
return nil
}
return fmt.Errorf("invalid ingress type %q: must be one of %s", o.ingressType, english.OxfordWordSeries(rdwsIngressOptions, "or"))
}
func (o *initSvcOpts) askImage() error {
if o.image != "" {
return nil
}
validator := prompt.RequireNonEmpty
promptHelp := wkldInitImagePromptHelp
if o.wkldType == manifestinfo.RequestDrivenWebServiceType {
promptHelp = wkldInitAppRunnerImagePromptHelp
validator = validateAppRunnerImage
}
image, err := o.prompt.Get(
wkldInitImagePrompt,
promptHelp,
validator,
prompt.WithFinalMessage("Image:"),
)
if err != nil {
return fmt.Errorf("get image location: %w", err)
}
o.image = image
return nil
}
func (o *initSvcOpts) manifestAlreadyExists() (bool, error) {
if o.wsPendingCreation {
return false, nil
}
localMft, err := o.mftReader.ReadWorkloadManifest(o.name)
if err != nil {
var (
errNotFound *workspace.ErrFileNotExists
errWorkspaceNotFound *workspace.ErrWorkspaceNotFound
)
if !errors.As(err, &errNotFound) && !errors.As(err, &errWorkspaceNotFound) {
return false, fmt.Errorf("read manifest file for service %s: %w", o.name, err)
}
return false, nil
}
o.manifestExists = true
svcType, err := localMft.WorkloadType()
if err != nil {
return false, fmt.Errorf(`read "type" field for service %s from local manifest: %w`, o.name, err)
}
if o.wkldType != "" {
if o.wkldType != svcType {
return false, fmt.Errorf("manifest file for service %s exists with a different type %s", o.name, svcType)
}
} else {
o.wkldType = svcType
}
log.Infof("Manifest file for service %s already exists. Skipping configuration.\n", o.name)
return true, nil
}
// isDfSelected indicates if any Dockerfile is in use.
func (o *initSvcOpts) askDockerfile() error {
if o.dockerfilePath != "" || o.image != "" {
return nil
}
if err := o.dockerEngine.CheckDockerEngineRunning(); err != nil {
var errDaemon *dockerengine.ErrDockerDaemonNotResponsive
switch {
case errors.Is(err, dockerengine.ErrDockerCommandNotFound):
log.Info("Docker command is not found; Copilot won't build from a Dockerfile.\n")
return nil
case errors.As(err, &errDaemon):
log.Info("Docker daemon is not responsive; Copilot won't build from a Dockerfile.\n")
return nil
default:
return fmt.Errorf("check if docker engine is running: %w", err)
}
}
df, err := o.sel.Dockerfile(
fmt.Sprintf(fmtWkldInitDockerfilePrompt, color.HighlightUserInput(o.name)),
fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, color.HighlightUserInput(o.name)),
wkldInitDockerfileHelpPrompt,
wkldInitDockerfilePathHelpPrompt,
func(v interface{}) error {
return validatePath(afero.NewOsFs(), v)
},
)
if err != nil {
return fmt.Errorf("select Dockerfile: %w", err)
}
if df == selector.DockerfilePromptUseImage {
return nil
}
o.dockerfilePath = df
return nil
}
func (o *initSvcOpts) askSvcPort() (err error) {
// If the port flag was set, use that and don't ask.
if o.port != 0 {
return nil
}
var ports []dockerfile.Port
if o.dockerfilePath != "" && o.image == "" {
// Check for exposed ports.
ports, err = o.dockerfile(o.dockerfilePath).GetExposedPorts()
// Ignore any errors in dockerfile parsing--we'll use the default port instead.
if err != nil {
log.Debugln(err.Error())
}
}
defaultPort := defaultSvcPortString
if o.dockerfilePath != "" {
switch len(ports) {
case 0:
// There were no ports detected, keep the default port prompt.
case 1:
o.port = ports[0].Port
return nil
default:
defaultPort = strconv.Itoa(int(ports[0].Port))
}
}
if o.wkldType == manifestinfo.BackendServiceType || o.wkldType == manifestinfo.WorkerServiceType {
return nil
}
port, err := o.prompt.Get(
fmt.Sprintf(svcInitSvcPortPrompt, color.Emphasize("port(s)")),
svcInitSvcPortHelpPrompt,
validateSvcPort,
prompt.WithDefaultInput(defaultPort),
prompt.WithFinalMessage("Port:"),
)
if err != nil {
return fmt.Errorf("get port: %w", err)
}
portUint, err := strconv.ParseUint(port, 10, 16)
if err != nil {
return fmt.Errorf("parse port string: %w", err)
}
o.port = uint16(portUint)
// Log a recommended action to update additional rules if multiple ports exposed.
for _, foundPort := range ports {
// Use the first exposed port in the Dockerfile that wasn't selected for traffic.
if foundPort.Port != o.port {
o.additionalFoundPort = foundPort.Port
break
}
}
return nil
}
func legitimizePlatform(engine dockerEngine, wkldType string) (manifest.PlatformString, error) {
if err := engine.CheckDockerEngineRunning(); err != nil {
// This is a best-effort attempt to detect the platform for users.
// If docker is not available, we skip this information.
var errDaemon *dockerengine.ErrDockerDaemonNotResponsive
switch {
case errors.Is(err, dockerengine.ErrDockerCommandNotFound):
log.Info("Docker command is not found; Copilot won't detect and populate the \"platform\" field in the manifest.\n")
return "", nil
case errors.As(err, &errDaemon):
log.Info("Docker daemon is not responsive; Copilot won't detect and populate the \"platform\" field in the manifest.\n")
return "", nil
default:
return "", fmt.Errorf("check if docker engine is running: %w", err)
}
}
detectedOs, detectedArch, err := engine.GetPlatform()
if err != nil {
return "", fmt.Errorf("get docker engine platform: %w", err)
}
redirectedPlatform, err := manifest.RedirectPlatform(detectedOs, detectedArch, wkldType)
if err != nil {
return "", fmt.Errorf("redirect docker engine platform: %w", err)
}
if redirectedPlatform == "" {
return "", nil
}
// Return an error if a platform cannot be redirected.
if wkldType == manifestinfo.RequestDrivenWebServiceType && detectedOs == manifest.OSWindows {
return "", manifest.ErrAppRunnerInvalidPlatformWindows
}
// Messages are logged only if the platform was redirected.
msg := fmt.Sprintf("Architecture type %s has been detected. We will set platform '%s' instead. If you'd rather build and run as architecture type %s, please change the 'platform' field in your workload manifest to '%s'.\n", detectedArch, redirectedPlatform, manifest.ArchARM64, dockerengine.PlatformString(detectedOs, manifest.ArchARM64))
if manifest.IsArmArch(detectedArch) && wkldType == manifestinfo.RequestDrivenWebServiceType {
msg = fmt.Sprintf("Architecture type %s has been detected. At this time, %s architectures are not supported for App Runner workloads. We will set platform '%s' instead.\n", detectedArch, detectedArch, redirectedPlatform)
}
log.Warningf(msg)
return manifest.PlatformString(redirectedPlatform), nil
}
func (o *initSvcOpts) askSvcPublishers() (err error) {
if o.wkldType != manifestinfo.WorkerServiceType {
return nil
}
// publishers already specified by flags
if len(o.subscriptions) > 0 {
var topicSubscriptions []manifest.TopicSubscription
for _, sub := range o.subscriptions {
sub, err := parseSerializedSubscription(sub)
if err != nil {
return err
}
topicSubscriptions = append(topicSubscriptions, sub)
}
o.topics = topicSubscriptions
return nil
}
// if --no-subscriptions flag specified, no need to ask for publishers
if o.noSubscribe {
return nil
}
topics, err := o.topicSel.Topics(svcInitPublisherPrompt, svcInitPublisherHelpPrompt, o.appName)
if err != nil {
return fmt.Errorf("select publisher: %w", err)
}
subscriptions := make([]manifest.TopicSubscription, 0, len(topics))
for _, t := range topics {
subscriptions = append(subscriptions, manifest.TopicSubscription{
Name: aws.String(t.Name()),
Service: aws.String(t.Workload()),
})
}
o.topics = subscriptions
return nil
}
func validateWorkspaceApp(wsApp, inputApp string, store store) error {
if wsApp == "" {
// NOTE: This command is required to be executed under a workspace. We don't prompt for it.
return errNoAppInWorkspace
}
// This command must be run within the app's workspace.
if inputApp != "" && inputApp != wsApp {
return fmt.Errorf("cannot specify app %s because the workspace is already registered with app %s", inputApp, wsApp)
}
if _, err := store.GetApplication(wsApp); err != nil {
return fmt.Errorf("get application %s configuration: %w", wsApp, err)
}
return nil
}
func (o initSvcOpts) convertStringsToAssets(sources []string) ([]manifest.FileUpload, error) {
assets := make([]manifest.FileUpload, len(sources))
var root string
if !o.wsPendingCreation {
root = o.wsRoot
}
for i, source := range sources {
info, err := o.fs.Stat(filepath.Join(root, source))
var recursive bool
if err == nil && info.IsDir() {
// Swallow the error at this point, because the path would have been validated during Validate or Ask, or will
// be validated during deploy.
recursive = true
}
assets[i] = manifest.FileUpload{
Source: source,
Recursive: recursive,
}
}
return assets, nil
}
// parseSerializedSubscription parses the service and topic name out of keys specified in the form "service:topicName"
func parseSerializedSubscription(input string) (manifest.TopicSubscription, error) {
attrs := regexpMatchSubscription.FindStringSubmatch(input)
if len(attrs) == 0 {
return manifest.TopicSubscription{}, fmt.Errorf("parse subscription from key: %s", input)
}
return manifest.TopicSubscription{
Name: aws.String(attrs[2]),
Service: aws.String(attrs[1]),
}, nil
}
func parseHealthCheck(df dockerfileParser) (manifest.ContainerHealthCheck, error) {
hc, err := df.GetHealthCheck()
if err != nil {
return manifest.ContainerHealthCheck{}, fmt.Errorf("get healthcheck: %w", err)
}
if hc == nil {
return manifest.ContainerHealthCheck{}, nil
}
return manifest.ContainerHealthCheck{
Interval: &hc.Interval,
Timeout: &hc.Timeout,
StartPeriod: &hc.StartPeriod,
Retries: &hc.Retries,
Command: hc.Cmd,
}, nil
}
func svcTypePromptOpts() []prompt.Option {
var options []prompt.Option
for _, svcType := range manifestinfo.ServiceTypes() {
options = append(options, prompt.Option{
Value: svcType,
Hint: serviceTypeHints[svcType],
})
}
return options
}
// buildSvcInitCmd build the command for creating a new service.
func buildSvcInitCmd() *cobra.Command {
vars := initSvcVars{}
cmd := &cobra.Command{
Use: "init",
Short: "Creates a new service in an application.",
Long: `Creates a new service in an application.
This command is also run as part of "copilot init".`,
Example: `
Create a "frontend" load balanced web service.
/code $ copilot svc init --name frontend --svc-type "Load Balanced Web Service" --dockerfile ./frontend/Dockerfile
Create a "subscribers" backend service.
/code $ copilot svc init --name subscribers --svc-type "Backend Service"`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newInitSvcOpts(vars)
if err != nil {
return err
}
if err := opts.Validate(); err != nil { // validate flags
return err
}
log.Warningln("It's best to run this command in the root of your workspace.")
if err := opts.Ask(); err != nil {
return err
}
if err := opts.Execute(); err != nil {
return err
}
if err := opts.RecommendActions(); err != nil {
return err
}
return nil
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, "", appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.wkldType, svcTypeFlag, typeFlagShort, "", svcTypeFlagDescription)
cmd.Flags().StringVarP(&vars.dockerfilePath, dockerFileFlag, dockerFileFlagShort, "", dockerFileFlagDescription)
cmd.Flags().StringVarP(&vars.image, imageFlag, imageFlagShort, "", imageFlagDescription)
cmd.Flags().Uint16Var(&vars.port, svcPortFlag, 0, svcPortFlagDescription)
cmd.Flags().StringArrayVar(&vars.subscriptions, subscribeTopicsFlag, []string{}, subscribeTopicsFlagDescription)
cmd.Flags().BoolVar(&vars.noSubscribe, noSubscriptionFlag, false, noSubscriptionFlagDescription)
cmd.Flags().StringVar(&vars.ingressType, ingressTypeFlag, "", ingressTypeFlagDescription)
cmd.Flags().StringArrayVar(&vars.sourcePaths, sourcesFlag, nil, sourcesFlagDescription)
cmd.Flags().BoolVar(&vars.allowAppDowngrade, allowDowngradeFlag, false, allowDowngradeFlagDescription)
return cmd
}
| 951 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"path/filepath"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerfile"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/initialize"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/golang/mock/gomock"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
)
type initSvcMocks struct {
mockPrompt *mocks.Mockprompter
mockSel *mocks.MockdockerfileSelector
mocktopicSel *mocks.MocktopicSelector
mockSourceSel *mocks.MockstaticSourceSelector
mockDockerfile *mocks.MockdockerfileParser
mockDockerEngine *mocks.MockdockerEngine
mockMftReader *mocks.MockmanifestReader
mockStore *mocks.Mockstore
mockCachedWSRoot string
}
func TestSvcInitOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inSvcType string
inSvcName string
inDockerfilePath string
inImage string
inAppName string
inSvcPort uint16
inSubscribeTags []string
inNoSubscribe bool
inIngressType string
inSources []string
setupMocks func(mocks *initSvcMocks)
mockFileSystem func(mockFS afero.Fs)
wantedErr error
wantedAssets []manifest.FileUpload
}{
"fail if using different app name with the workspace": {
inAppName: "demo",
wantedErr: fmt.Errorf("cannot specify app demo because the workspace is already registered with app phonetool"),
},
"fail if cannot validate application": {
inAppName: "phonetool",
inDockerfilePath: "mockDockerfile",
inImage: "mockImage",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(nil, errors.New("some error"))
},
wantedErr: fmt.Errorf("get application phonetool configuration: some error"),
},
"fail if both image and dockerfile are set": {
inAppName: "phonetool",
inDockerfilePath: "mockDockerfile",
inImage: "mockImage",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("--dockerfile and --image cannot be specified together"),
},
"fail if image not supported by App Runner": {
inAppName: "phonetool",
inImage: "amazon/amazon-ecs-sample",
inSvcType: manifestinfo.RequestDrivenWebServiceType,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("image amazon/amazon-ecs-sample is not supported by App Runner: value must be an ECR or ECR Public image URI"),
},
"invalid dockerfile directory path": {
inAppName: "phonetool",
inDockerfilePath: "./hello/Dockerfile",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: fmt.Errorf("open %s: file does not exist", filepath.FromSlash("hello/Dockerfile")),
},
"fail if both no-subscribe and subscribe are set": {
inAppName: "phonetool",
inSvcName: "service",
inSubscribeTags: []string{"name:svc"},
inNoSubscribe: true,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: errors.New("validate subscribe configuration: cannot specify both --no-subscribe and --subscribe-topics"),
},
"rdws invalid ingress type error": {
inSvcName: "frontend",
inSvcType: "Request-Driven Web Service",
inDockerfilePath: "./hello/Dockerfile",
inIngressType: "invalid",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
mockFileSystem: func(mockFS afero.Fs) {
mockFS.MkdirAll("hello", 0755)
afero.WriteFile(mockFS, "hello/Dockerfile", []byte("FROM nginx"), 0644)
},
wantedErr: errors.New(`invalid ingress type "invalid": must be one of Environment or Internet`),
},
"error if sources flag used without Static Site type": {
inSvcName: "frontend",
inSvcType: "Load Balanced Web Service",
inSources: []string{"goodbye", "hello/there"},
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: errors.New(`'--sources' must be specified with '--type "Static Site"'`),
},
"error if sources flag used with invalid sources": {
inSvcName: "frontend",
inSvcType: "Static Site",
inSources: []string{"non-existent path"},
mockFileSystem: func(mockFS afero.Fs) {
mockFS.MkdirAll("copilot", 0755)
mockFS.MkdirAll("hello", 0755)
mockFS.MkdirAll("goodbye", 0755)
afero.WriteFile(mockFS, "hello/there", []byte("howdy"), 0644)
},
setupMocks: func(m *initSvcMocks) {
m.mockCachedWSRoot = "mockRoot"
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedErr: errors.New(`source "non-existent path" must be a valid path relative to the workspace "mockRoot": open mockRoot/non-existent path: file does not exist`),
},
"valid flags": {
inSvcName: "frontend",
inSvcType: "Load Balanced Web Service",
inDockerfilePath: "./hello/Dockerfile",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
mockFileSystem: func(mockFS afero.Fs) {
mockFS.MkdirAll("hello", 0755)
afero.WriteFile(mockFS, "hello/Dockerfile", []byte("FROM nginx"), 0644)
},
},
"valid rdws flags": {
inSvcName: "frontend",
inSvcType: "Request-Driven Web Service",
inDockerfilePath: "./hello/Dockerfile",
inIngressType: "Internet",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
mockFileSystem: func(mockFS afero.Fs) {
mockFS.MkdirAll("hello", 0755)
afero.WriteFile(mockFS, "hello/Dockerfile", []byte("FROM nginx"), 0644)
},
},
"valid lbws port flag": {
inSvcName: "frontend",
inSvcType: "Load Balanced Web Service",
inDockerfilePath: "./hello/Dockerfile",
inSvcPort: 3000,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
mockFileSystem: func(mockFS afero.Fs) {
mockFS.MkdirAll("hello", 0755)
afero.WriteFile(mockFS, "hello/Dockerfile", []byte("FROM nginx"), 0644)
},
},
"valid static site flag": {
inSvcName: "frontend",
inSvcType: "Static Site",
inSources: []string{"goodbye", "hello/there"},
mockFileSystem: func(mockFS afero.Fs) {
mockFS.MkdirAll("copilot", 0755)
mockFS.MkdirAll("groot/hello", 0755)
mockFS.MkdirAll("groot/goodbye", 0755)
afero.WriteFile(mockFS, "groot/hello/there", []byte("howdy"), 0644)
},
setupMocks: func(m *initSvcMocks) {
m.mockCachedWSRoot = "groot"
m.mockStore.EXPECT().GetApplication("phonetool").Return(&config.Application{}, nil)
},
wantedAssets: []manifest.FileUpload{
{
Source: "goodbye",
Recursive: true,
},
{
Source: "hello/there",
Recursive: false,
},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := initSvcMocks{
mockStore: mocks.NewMockstore(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(&m)
}
opts := initSvcOpts{
initSvcVars: initSvcVars{
initWkldVars: initWkldVars{
wkldType: tc.inSvcType,
name: tc.inSvcName,
dockerfilePath: tc.inDockerfilePath,
image: tc.inImage,
appName: tc.inAppName,
subscriptions: tc.inSubscribeTags,
noSubscribe: tc.inNoSubscribe,
sourcePaths: tc.inSources,
},
port: tc.inSvcPort,
ingressType: tc.inIngressType,
},
store: m.mockStore,
fs: &afero.Afero{Fs: afero.NewMemMapFs()},
wsAppName: "phonetool",
wsRoot: m.mockCachedWSRoot,
}
if tc.mockFileSystem != nil {
tc.mockFileSystem(opts.fs)
}
// WHEN
err := opts.Validate()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedAssets, opts.staticAssets)
}
})
}
}
func TestSvcInitOpts_Ask(t *testing.T) {
const (
mockAppName = "phonetool"
wantedSvcType = manifestinfo.LoadBalancedWebServiceType
appRunnerSvcType = manifestinfo.RequestDrivenWebServiceType
wantedSvcName = "frontend"
badAppRunnerSvcName = "iamoverfortycharacterlongandaninvalidrdwsname"
wantedDockerfilePath = "frontend/Dockerfile"
wantedSvcPort = 80
wantedImage = "mockImage"
mockProjectRoot = "groot"
mockFile = "my/mock/file.css"
mockDir = "my/mock/dir"
)
mockTopic, _ := deploy.NewTopic("arn:aws:sns:us-west-2:123456789012:mockApp-mockEnv-mockWkld-orders", "mockApp", "mockEnv", "mockWkld")
mockError := errors.New("mock error")
testCases := map[string]struct {
inSvcType string
inSvcName string
inDockerfilePath string
inImage string
inSvcPort uint16
inSubscribeTags []string
inNoSubscribe bool
inIngressType string
inWsPendingCreation bool
mockFileSystem func(mockFS afero.Fs)
setupMocks func(mocks *initSvcMocks)
wantedErr error
wantedAssets []manifest.FileUpload
}{
"invalid service type": {
inSvcType: "TestSvcType",
wantedErr: errors.New(`invalid service type TestSvcType: must be one of "Request-Driven Web Service", "Load Balanced Web Service", "Backend Service", "Worker Service", "Static Site"`),
},
"invalid service name": {
inSvcType: wantedSvcType,
inSvcName: "1234",
wantedErr: fmt.Errorf("service name 1234 is invalid: %s", errBasicNameRegexNotMatched),
},
"prompt for service name": {
inSvcType: wantedSvcType,
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockPrompt.EXPECT().Get(gomock.Eq("What do you want to name this service?"), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedSvcName, nil)
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
},
wantedErr: nil,
},
"returns an error if fail to get service name": {
inSvcType: wantedSvcType,
inSvcName: "",
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockPrompt.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("get service name: some error"),
},
"returns an error if service already exists": {
inSvcType: wantedSvcType,
inSvcName: "",
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockPrompt.EXPECT().Get(gomock.Eq("What do you want to name this service?"), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedSvcName, nil)
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(&config.Workload{}, nil)
},
wantedErr: fmt.Errorf("service frontend already exists"),
},
"returns an error if fail to validate service existence": {
inSvcType: wantedSvcType,
inSvcName: "",
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockPrompt.EXPECT().Get(gomock.Eq("What do you want to name this service?"), gomock.Any(), gomock.Any(), gomock.Any()).
Return(wantedSvcName, nil)
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, mockError)
},
wantedErr: fmt.Errorf("validate if service exists: mock error"),
},
"error if manifest type doesn't match": {
inSvcType: "Worker Service",
inSvcName: wantedSvcName,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte(`
type: Backend Service`), nil)
},
wantedErr: fmt.Errorf("manifest file for service frontend exists with a different type Backend Service"),
},
"skip asking questions if local manifest file exists by flags": {
inSvcType: "Worker Service",
inSvcName: wantedSvcName,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return([]byte(`
type: Worker Service`), nil)
},
},
"error if invalid app runner service name": {
inSvcType: "Request-Driven Web Service",
inSvcName: badAppRunnerSvcName,
setupMocks: func(m *initSvcMocks) {},
wantedErr: fmt.Errorf("service name iamoverfortycharacterlongandaninvalidrdwsname is invalid: value must not exceed 40 characters"),
},
"skip asking questions if local manifest file exists by only name flag with minimal check": {
inSvcName: badAppRunnerSvcName,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, badAppRunnerSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(badAppRunnerSvcName).Return([]byte(`
type: Request-Driven Web Service`), nil)
},
},
"return an error if fail to read local manifest": {
inSvcType: "Worker Service",
inSvcName: wantedSvcName,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, mockError)
},
wantedErr: fmt.Errorf("read manifest file for service frontend: mock error"),
},
"return an error if fail to get service type": {
inSvcType: "",
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockPrompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return("", errors.New("some error"))
},
wantedErr: fmt.Errorf("select service type: some error"),
},
"prompt for service type": {
inSvcType: "",
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockPrompt.EXPECT().SelectOption(gomock.Eq(fmt.Sprintf(fmtSvcInitSvcTypePrompt, "service type")), gomock.Any(), gomock.Eq([]prompt.Option{
{
Value: manifestinfo.RequestDrivenWebServiceType,
Hint: "App Runner",
},
{
Value: manifestinfo.LoadBalancedWebServiceType,
Hint: "Internet to ECS on Fargate",
},
{
Value: manifestinfo.BackendServiceType,
Hint: "ECS on Fargate",
},
{
Value: manifestinfo.WorkerServiceType,
Hint: "Events to SQS to ECS on Fargate",
},
{
Value: manifestinfo.StaticSiteType,
Hint: "Internet to CDN to S3 bucket",
},
}), gomock.Any()).
Return(wantedSvcType, nil)
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{}).Times(2)
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName}).Times(2)
},
wantedErr: nil,
},
"prompt for service type and error if the name is invalid": {
inSvcType: "",
inSvcName: badAppRunnerSvcName,
setupMocks: func(m *initSvcMocks) {
m.mockPrompt.EXPECT().SelectOption(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return(appRunnerSvcType, nil)
m.mockStore.EXPECT().GetService(mockAppName, badAppRunnerSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(badAppRunnerSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: badAppRunnerSvcName})
},
wantedErr: fmt.Errorf("service name iamoverfortycharacterlongandaninvalidrdwsname is invalid: value must not exceed 40 characters"),
},
"rdws prompt for ingress type": {
inSvcType: appRunnerSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().SelectOption(gomock.Eq(svcInitIngressTypePrompt), gomock.Any(), gomock.Eq([]prompt.Option{
{
Value: "Environment",
},
{
Value: "Internet",
},
}), gomock.Any()).Return("Environment", nil)
},
},
"rdws prompt for ingress type error": {
inSvcType: appRunnerSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockPrompt.EXPECT().SelectOption(gomock.Eq(svcInitIngressTypePrompt), gomock.Any(), gomock.Eq([]prompt.Option{
{
Value: "Environment",
},
{
Value: "Internet",
},
}), gomock.Any()).Return("", errors.New("some error"))
},
wantedErr: errors.New("select ingress type: some error"),
},
"rdws skip ingress type prompt with flag": {
inSvcType: appRunnerSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inDockerfilePath: wantedDockerfilePath,
inIngressType: ingressTypeInternet,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
},
},
"skip selecting Dockerfile if image flag is set": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inImage: "mockImage",
inDockerfilePath: "",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
},
},
"return error if failed to check if docker engine is running": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(errors.New("some error"))
},
wantedErr: fmt.Errorf("check if docker engine is running: some error"),
},
"skip selecting Dockerfile if docker command is not found": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("mockImage", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(dockerengine.ErrDockerCommandNotFound)
},
wantedErr: nil,
},
"skip selecting Dockerfile if docker engine is not responsive": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("mockImage", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(&dockerengine.ErrDockerDaemonNotResponsive{})
},
wantedErr: nil,
},
"returns an error if fail to get image location": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inDockerfilePath: "",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("", mockError)
m.mockSel.EXPECT().Dockerfile(
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePrompt, wantedSvcName)),
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, wantedSvcName)),
gomock.Eq(wkldInitDockerfileHelpPrompt),
gomock.Eq(wkldInitDockerfilePathHelpPrompt),
gomock.Any(),
).Return("Use an existing image instead", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
wantedErr: fmt.Errorf("get image location: mock error"),
},
"using existing image": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inDockerfilePath: "",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().Get(wkldInitImagePrompt, wkldInitImagePromptHelp, gomock.Any(), gomock.Any()).
Return("mockImage", nil)
m.mockPrompt.EXPECT().Get(gomock.Eq(fmt.Sprintf(svcInitSvcPortPrompt, "port(s)")), gomock.Any(), gomock.Any(), gomock.Any()).
Return(defaultSvcPortString, nil)
m.mockSel.EXPECT().Dockerfile(
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePrompt, wantedSvcName)),
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, wantedSvcName)),
gomock.Eq(wkldInitDockerfileHelpPrompt),
gomock.Eq(wkldInitDockerfilePathHelpPrompt),
gomock.Any(),
).Return("Use an existing image instead", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
},
"select Dockerfile": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inDockerfilePath: "",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockSel.EXPECT().Dockerfile(
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePrompt, wantedSvcName)),
gomock.Eq(fmt.Sprintf(fmtWkldInitDockerfilePathPrompt, wantedSvcName)),
gomock.Eq(wkldInitDockerfileHelpPrompt),
gomock.Eq(wkldInitDockerfilePathHelpPrompt),
gomock.Any(),
).Return("frontend/Dockerfile", nil)
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
wantedErr: nil,
},
"returns an error if fail to get Dockerfile": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inDockerfilePath: "",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockSel.EXPECT().Dockerfile(
gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
).Return("", errors.New("some error"))
m.mockDockerEngine.EXPECT().CheckDockerEngineRunning().Return(nil)
},
wantedErr: fmt.Errorf("select Dockerfile: some error"),
},
"skip asking for port for backend service": {
inSvcType: "Backend Service",
inSvcName: wantedSvcName,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockDockerfile.EXPECT().GetExposedPorts().Return(nil, errors.New("no expose"))
},
wantedErr: nil,
},
"asks for port if not specified": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().Get(gomock.Eq(fmt.Sprintf(svcInitSvcPortPrompt, "port(s)")), gomock.Any(), gomock.Any(), gomock.Any()).
Return(defaultSvcPortString, nil)
m.mockDockerfile.EXPECT().GetExposedPorts().Return(nil, errors.New("no expose"))
},
wantedErr: nil,
},
"errors if port not specified": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().Get(gomock.Eq(fmt.Sprintf(svcInitSvcPortPrompt, "port(s)")), gomock.Any(), gomock.Any(), gomock.Any()).
Return("", errors.New("some error"))
m.mockDockerfile.EXPECT().GetExposedPorts().Return(nil, errors.New("expose error"))
},
wantedErr: fmt.Errorf("get port: some error"),
},
"errors if port out of range": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockPrompt.EXPECT().Get(gomock.Eq(fmt.Sprintf(svcInitSvcPortPrompt, "port(s)")), gomock.Any(), gomock.Any(), gomock.Any()).
Return("100000", errors.New("some error"))
m.mockDockerfile.EXPECT().GetExposedPorts().Return(nil, errors.New("no expose"))
},
wantedErr: fmt.Errorf("get port: some error"),
},
"don't ask if dockerfile has port": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inDockerfilePath: wantedDockerfilePath,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockDockerfile.EXPECT().GetExposedPorts().Return([]dockerfile.Port{{Port: 80, Protocol: "", RawString: "80"}}, nil)
},
},
"don't use dockerfile port if flag specified": {
inSvcType: wantedSvcType,
inSvcName: wantedSvcName,
inDockerfilePath: wantedDockerfilePath,
inSvcPort: wantedSvcPort,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
},
},
"skip selecting subscriptions if no-subscriptions flag is set": {
inSvcType: "Worker Service",
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inImage: "mockImage",
inNoSubscribe: true,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
},
},
"skip selecting subscriptions if subscribe flag is set": {
inSvcType: "Worker Service",
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inImage: "mockImage",
inNoSubscribe: false,
inSubscribeTags: []string{"svc:name"},
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
},
},
"select subscriptions": {
inSvcType: "Worker Service",
inSvcName: wantedSvcName,
inSvcPort: wantedSvcPort,
inImage: "mockImage",
inDockerfilePath: "",
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mocktopicSel.EXPECT().Topics(
gomock.Eq(svcInitPublisherPrompt),
gomock.Eq(svcInitPublisherHelpPrompt),
gomock.Any(),
).Return([]deploy.Topic{*mockTopic}, nil)
},
},
"error if source for static site source not selected successfully": {
inSvcType: manifestinfo.StaticSiteType,
inSvcName: wantedSvcName,
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockSourceSel.EXPECT().StaticSources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, mockError)
},
wantedErr: fmt.Errorf("mock error"),
},
"successfully ask for static site sources and convert to asset objects with dirs marked recursive": {
inSvcType: manifestinfo.StaticSiteType,
inSvcName: wantedSvcName,
mockFileSystem: func(mockFS afero.Fs) {
_ = mockFS.MkdirAll(filepath.Join(mockProjectRoot, mockDir), 0755)
_ = afero.WriteFile(mockFS, filepath.Join(mockProjectRoot, mockFile), []byte("file guts"), 0644)
},
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockMftReader.EXPECT().ReadWorkloadManifest(wantedSvcName).Return(nil, &workspace.ErrFileNotExists{FileName: wantedSvcName})
m.mockSourceSel.EXPECT().StaticSources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return([]string{mockFile, mockDir}, nil)
m.mockCachedWSRoot = mockProjectRoot
},
wantedAssets: []manifest.FileUpload{
{
Source: mockFile,
Recursive: false,
},
{
Source: mockDir,
Recursive: true,
},
},
},
"ask for static site source paths rather than providing selector if workspace hasn't been created (`copilot init` workflow)": {
inSvcType: manifestinfo.StaticSiteType,
inSvcName: wantedSvcName,
inWsPendingCreation: true,
mockFileSystem: func(mockFS afero.Fs) {
_ = mockFS.MkdirAll(mockDir, 0755)
_ = afero.WriteFile(mockFS, mockFile, []byte("file guts"), 0644)
},
setupMocks: func(m *initSvcMocks) {
m.mockStore.EXPECT().GetService(mockAppName, wantedSvcName).Return(nil, &config.ErrNoSuchService{})
m.mockPrompt.EXPECT().Get(gomock.Eq("What is the path to the directory or file for frontend?"), gomock.Eq("Path to directory or file to use for building your static site."), gomock.Any(), gomock.Any()).Return(mockFile, nil)
m.mockPrompt.EXPECT().Confirm(gomock.Eq("Would you like to enter another path?"), gomock.Eq("You may add multiple custom paths. Enter 'y' to type another."), gomock.Any()).Return(false, nil)
},
wantedAssets: []manifest.FileUpload{
{
Source: mockFile,
Recursive: false,
},
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := initSvcMocks{
mockPrompt: mocks.NewMockprompter(ctrl),
mockDockerfile: mocks.NewMockdockerfileParser(ctrl),
mockSel: mocks.NewMockdockerfileSelector(ctrl),
mocktopicSel: mocks.NewMocktopicSelector(ctrl),
mockSourceSel: mocks.NewMockstaticSourceSelector(ctrl),
mockDockerEngine: mocks.NewMockdockerEngine(ctrl),
mockMftReader: mocks.NewMockmanifestReader(ctrl),
mockStore: mocks.NewMockstore(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(&m)
}
opts := &initSvcOpts{
initSvcVars: initSvcVars{
initWkldVars: initWkldVars{
wkldType: tc.inSvcType,
name: tc.inSvcName,
image: tc.inImage,
dockerfilePath: tc.inDockerfilePath,
noSubscribe: tc.inNoSubscribe,
subscriptions: tc.inSubscribeTags,
appName: mockAppName,
},
port: tc.inSvcPort,
ingressType: tc.inIngressType,
},
store: m.mockStore,
fs: &afero.Afero{Fs: afero.NewMemMapFs()},
dockerfile: func(s string) dockerfileParser {
return m.mockDockerfile
},
df: m.mockDockerfile,
prompt: m.mockPrompt,
mftReader: m.mockMftReader,
sel: m.mockSel,
topicSel: m.mocktopicSel,
sourceSel: m.mockSourceSel,
dockerEngine: m.mockDockerEngine,
wsPendingCreation: tc.inWsPendingCreation,
wsRoot: m.mockCachedWSRoot,
}
if tc.mockFileSystem != nil {
tc.mockFileSystem(opts.fs)
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
if opts.dockerfilePath != "" {
require.Equal(t, wantedDockerfilePath, opts.dockerfilePath)
}
if opts.image != "" {
require.Equal(t, wantedImage, opts.image)
}
if opts.staticAssets != nil {
require.Equal(t, tc.wantedAssets, opts.staticAssets)
}
}
})
}
}
func TestSvcInitOpts_Execute(t *testing.T) {
mockEnvironmentManifest := []byte(`name: test
type: Environment
network:
vpc:
id: 'vpc-mockid'
subnets:
private:
- id: 'subnet-1'
- id: 'subnet-2'
- id: 'subnet-3'
- id: 'subnet-4'`)
testCases := map[string]struct {
mockSvcInit func(m *mocks.MocksvcInitializer)
mockDockerfile func(m *mocks.MockdockerfileParser)
mockDockerEngine func(m *mocks.MockdockerEngine)
mockTopicSel func(m *mocks.MocktopicSelector)
mockStore func(m *mocks.Mockstore)
mockEnvDescriber func(m *mocks.MockenvDescriber)
inSvcPort uint16
inSvcType string
inSvcName string
inDockerfilePath string
inImage string
inAppName string
inManifestExists bool
wantedErr error
wantedManifestPath string
}{
"success on typical svc props": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
inSvcPort: 80,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Load Balanced Web Service",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
},
Port: 80,
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"backend service": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.BackendServiceType,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Backend Service",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
},
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"doesn't attempt to detect and populate the platform if manifest already exists": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
inSvcPort: 80,
inManifestExists: true,
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Times(0)
m.EXPECT().GetPlatform().Times(0)
},
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Load Balanced Web Service",
DockerfilePath: "./Dockerfile",
},
Port: 80,
}).Return("manifest/path", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"doesn't complain if docker is unavailable": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
inSvcPort: 80,
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(&dockerengine.ErrDockerDaemonNotResponsive{})
m.EXPECT().GetPlatform().Times(0)
},
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Load Balanced Web Service",
DockerfilePath: "./Dockerfile",
},
Port: 80,
}).Return("manifest/path", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"windows platform": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
inSvcPort: 80,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Load Balanced Web Service",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{
PlatformString: (*manifest.PlatformString)(aws.String("windows/x86_64")),
},
},
Port: 80,
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("windows", "amd64", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"ARM architecture redirects to X86_64": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
inSvcPort: 80,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Load Balanced Web Service",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{
PlatformString: (*manifest.PlatformString)(aws.String("linux/x86_64")),
},
},
Port: 80,
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "arm", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"worker service": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.WorkerServiceType,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Worker Service",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
},
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockTopicSel: func(m *mocks.MocktopicSelector) {
m.EXPECT().Topics(
gomock.Eq(svcInitPublisherPrompt),
gomock.Eq(svcInitPublisherHelpPrompt),
gomock.Any(),
).Return([]manifest.TopicSubscription{
{
Name: aws.String("thetopic"),
Service: aws.String("theservice"),
},
}, nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"doesn't parse dockerfile if image specified (backend)": {
inAppName: "sample",
inSvcName: "backend",
inDockerfilePath: "",
inImage: "nginx:latest",
inSvcType: manifestinfo.BackendServiceType,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "backend",
Type: "Backend Service",
Image: "nginx:latest",
Platform: manifest.PlatformArgsOrString{},
},
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {}, // Be sure that no dockerfile parsing happens.
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"doesn't parse dockerfile if image specified (lb-web)": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "",
inImage: "nginx:latest",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Load Balanced Web Service",
Image: "nginx:latest",
Platform: manifest.PlatformArgsOrString{},
},
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {}, // Be sure that no dockerfile parsing happens.
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return(nil, nil)
},
wantedManifestPath: "manifest/path",
},
"return error if platform detection fails": {
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("", "", errors.New("some error"))
},
wantedErr: errors.New("get docker engine platform: some error"),
},
"return error if Windows platform attempted with RDWS": {
inAppName: "sample",
inSvcName: "appRunner",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.RequestDrivenWebServiceType,
inSvcPort: 80,
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("windows", "amd64", nil)
},
wantedErr: errors.New("redirect docker engine platform: Windows is not supported for App Runner services"),
},
"failure": {
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("").Return(nil, errors.New("some error"))
},
wantedErr: errors.New("list environments for application : some error"),
},
"initalize a service in environments with only private subnets": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
inSvcPort: 80,
mockSvcInit: func(m *mocks.MocksvcInitializer) {
m.EXPECT().Service(&initialize.ServiceProps{
WorkloadProps: initialize.WorkloadProps{
App: "sample",
Name: "frontend",
Type: "Load Balanced Web Service",
DockerfilePath: "./Dockerfile",
Platform: manifest.PlatformArgsOrString{},
PrivateOnlyEnvironments: []string{
"test",
},
},
Port: 80,
}).Return("manifest/path", nil)
},
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return([]*config.Environment{
{
App: "sample",
Name: "test",
},
}, nil)
},
mockEnvDescriber: func(m *mocks.MockenvDescriber) {
m.EXPECT().Manifest().Return(mockEnvironmentManifest, nil)
},
wantedManifestPath: "manifest/path",
},
"error if fail to read the manifest": {
inAppName: "sample",
inSvcName: "frontend",
inDockerfilePath: "./Dockerfile",
inSvcType: manifestinfo.LoadBalancedWebServiceType,
inSvcPort: 80,
mockDockerfile: func(m *mocks.MockdockerfileParser) {
m.EXPECT().GetHealthCheck().Return(nil, nil)
},
mockDockerEngine: func(m *mocks.MockdockerEngine) {
m.EXPECT().CheckDockerEngineRunning().Return(nil)
m.EXPECT().GetPlatform().Return("linux", "amd64", nil)
},
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().ListEnvironments("sample").Return([]*config.Environment{
{
App: "sample",
Name: "test",
},
}, nil)
},
mockEnvDescriber: func(m *mocks.MockenvDescriber) {
m.EXPECT().Manifest().Return(nil, errors.New("failed to read manifest"))
},
wantedErr: errors.New("read the manifest used to deploy environment test: failed to read manifest"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSvcInitializer := mocks.NewMocksvcInitializer(ctrl)
mockDockerfile := mocks.NewMockdockerfileParser(ctrl)
mockDockerEngine := mocks.NewMockdockerEngine(ctrl)
mockTopicSel := mocks.NewMocktopicSelector(ctrl)
mockStore := mocks.NewMockstore(ctrl)
mockEnvDescriber := mocks.NewMockenvDescriber(ctrl)
if tc.mockStore != nil {
tc.mockStore(mockStore)
}
if tc.mockSvcInit != nil {
tc.mockSvcInit(mockSvcInitializer)
}
if tc.mockDockerfile != nil {
tc.mockDockerfile(mockDockerfile)
}
if tc.mockDockerEngine != nil {
tc.mockDockerEngine(mockDockerEngine)
}
if tc.mockEnvDescriber != nil {
tc.mockEnvDescriber(mockEnvDescriber)
}
opts := initSvcOpts{
initSvcVars: initSvcVars{
initWkldVars: initWkldVars{
appName: tc.inAppName,
name: tc.inSvcName,
wkldType: tc.inSvcType,
dockerfilePath: tc.inDockerfilePath,
image: tc.inImage,
allowAppDowngrade: true,
},
port: tc.inSvcPort,
},
init: mockSvcInitializer,
dockerfile: func(s string) dockerfileParser {
return mockDockerfile
},
df: mockDockerfile,
dockerEngine: mockDockerEngine,
store: mockStore,
topicSel: mockTopicSel,
manifestExists: tc.inManifestExists,
initEnvDescriber: func(string, string) (envDescriber, error) {
return mockEnvDescriber, nil
},
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedErr == nil {
require.NoError(t, err)
require.Equal(t, tc.wantedManifestPath, opts.manifestPath)
} else {
require.EqualError(t, err, tc.wantedErr.Error())
}
})
}
}
| 1,396 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/spf13/afero"
"github.com/aws/copilot-cli/internal/pkg/cli/list"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/cobra"
)
type listWkldVars struct {
appName string
shouldOutputJSON bool
shouldShowLocalWorkloads bool
}
type listSvcOpts struct {
listWkldVars
// Interfaces to dependencies.
sel appSelector
list workloadListWriter
}
func newListSvcOpts(vars listWkldVars) (*listSvcOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
sess, err := sessions.ImmutableProvider(sessions.UserAgentExtras("svc ls")).Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
store := config.NewSSMStore(identity.New(sess), ssm.New(sess), aws.StringValue(sess.Config.Region))
svcLister := &list.SvcListWriter{
Ws: ws,
Store: store,
Out: os.Stdout,
ShowLocalSvcs: vars.shouldShowLocalWorkloads,
OutputJSON: vars.shouldOutputJSON,
}
return &listSvcOpts{
listWkldVars: vars,
list: svcLister,
sel: selector.NewAppEnvSelector(prompt.New(), store),
}, nil
}
// Validate is a no-op for this command.
func (o *listSvcOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *listSvcOpts) Ask() error {
if o.appName != "" {
// NOTE: Skip validating app name here because `Execute` will fail pretty soon with a clear error message.
// The validation (config.GetApplication) would only add additional operation time in this particular case.
return nil
}
name, err := o.sel.Application(svcAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application name: %w", err)
}
o.appName = name
return nil
}
// Execute lists the services through the prompt.
func (o *listSvcOpts) Execute() error {
if err := o.list.Write(o.appName); err != nil {
return err
}
return nil
}
// buildSvcListCmd builds the command for listing services in an appication.
func buildSvcListCmd() *cobra.Command {
vars := listWkldVars{}
cmd := &cobra.Command{
Use: "ls",
Short: "Lists all the services in an application.",
Example: `
Lists all the services for the "myapp" application.
/code $ copilot svc ls --app myapp`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newListSvcOpts(vars)
if err != nil {
return err
}
if err := opts.Ask(); err != nil {
return err
}
return opts.Execute()
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.shouldShowLocalWorkloads, localFlag, false, localSvcFlagDescription)
return cmd
}
| 122 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestListSvcOpts_Execute(t *testing.T) {
ctrl := gomock.NewController(t)
mockError := fmt.Errorf("error")
mockLister := mocks.NewMockworkloadListWriter(ctrl)
defer ctrl.Finish()
testCases := map[string]struct {
opts listSvcOpts
mocking func()
expectedErr error
}{
"with successful call to list.Services": {
opts: listSvcOpts{
listWkldVars: listWkldVars{
shouldOutputJSON: true,
appName: "coolapp",
},
list: mockLister,
},
mocking: func() {
mockLister.EXPECT().
Write("coolapp").
Return(nil)
},
},
"with failed call to list.Services": {
opts: listSvcOpts{
listWkldVars: listWkldVars{
appName: "coolapp",
},
list: mockLister,
},
mocking: func() {
mockLister.EXPECT().
Write(gomock.Eq("coolapp")).
Return(mockError)
},
expectedErr: fmt.Errorf("error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
tc.mocking()
err := tc.opts.Execute()
if tc.expectedErr != nil {
require.EqualError(t, tc.expectedErr, err.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestListSvcOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inApp string
mockSel func(m *mocks.MockappSelector)
wantedApp string
}{
"with no flags set": {
mockSel: func(m *mocks.MockappSelector) {
m.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("myapp", nil)
},
wantedApp: "myapp",
},
"with app flag set": {
mockSel: func(m *mocks.MockappSelector) {
m.EXPECT().Application(gomock.Any(), gomock.Any()).Times(0)
},
inApp: "myapp",
wantedApp: "myapp",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSel := mocks.NewMockappSelector(ctrl)
tc.mockSel(mockSel)
listApps := &listSvcOpts{
listWkldVars: listWkldVars{
appName: tc.inApp,
},
sel: mockSel,
}
err := listApps.Ask()
require.NoError(t, err)
require.Equal(t, tc.wantedApp, listApps.appName, "expected application names to match")
})
}
}
| 114 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"sort"
"time"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/logging"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
svcLogNamePrompt = "Which service's logs would you like to show?"
svcLogNameHelpPrompt = "The logs of the indicated deployed service will be shown."
cwGetLogEventsLimitMin = 1
cwGetLogEventsLimitMax = 10000
)
var (
noPreviousTasksErr = errors.New("no previously stopped tasks found")
)
type wkldLogsVars struct {
shouldOutputJSON bool
follow bool
limit int
name string
envName string
appName string
humanStartTime string
humanEndTime string
taskIDs []string
since time.Duration
}
type svcLogsVars struct {
wkldLogsVars
logGroup string
containerName string
previous bool
}
type svcLogsOpts struct {
svcLogsVars
wkldLogOpts
// Cached variables.
targetEnv *config.Environment
targetSvcType string
}
type wkldLogOpts struct {
// Internal states.
startTime *int64
endTime *int64
// Dependencies.
w io.Writer
configStore store
sessProvider sessionProvider
deployStore deployedEnvironmentLister
sel deploySelector
logsSvc logEventsWriter
ecs serviceDescriber
initRuntimeClients func() error // Overridden in tests.
}
func newSvcLogOpts(vars svcLogsVars) (*svcLogsOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc logs"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, configStore)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
opts := &svcLogsOpts{
svcLogsVars: vars,
wkldLogOpts: wkldLogOpts{
w: log.OutputWriter,
configStore: configStore,
deployStore: deployStore,
sel: selector.NewDeploySelect(prompt.New(), configStore, deployStore),
},
}
opts.initRuntimeClients = func() error {
env, err := opts.getTargetEnv()
if err != nil {
return fmt.Errorf("get environment: %w", err)
}
sess, err := sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
opts.ecs = ecs.New(sess)
newWorkloadLoggerOpts := &logging.NewWorkloadLoggerOpts{
App: opts.appName,
Env: opts.envName,
Name: opts.name,
Sess: sess,
}
if opts.targetSvcType != manifestinfo.RequestDrivenWebServiceType {
opts.logsSvc = logging.NewECSServiceClient(newWorkloadLoggerOpts)
return nil
}
opts.logsSvc, err = logging.NewAppRunnerServiceLogger(&logging.NewAppRunnerServiceLoggerOpts{
NewWorkloadLoggerOpts: newWorkloadLoggerOpts,
ConfigStore: opts.configStore,
})
if err != nil {
return err
}
return nil
}
return opts, nil
}
// Validate returns an error for any invalid optional flags.
func (o *svcLogsOpts) Validate() error {
if o.since != 0 && o.humanStartTime != "" {
return errors.New("only one of --since or --start-time may be used")
}
if o.humanEndTime != "" && o.follow {
return errors.New("only one of --follow or --end-time may be used")
}
if o.since != 0 {
if o.since < 0 {
return fmt.Errorf("--since must be greater than 0")
}
// round up to the nearest second
o.startTime = parseSince(o.since)
}
if o.humanStartTime != "" {
startTime, err := parseRFC3339(o.humanStartTime)
if err != nil {
return fmt.Errorf(`invalid argument %s for "--start-time" flag: %w`, o.humanStartTime, err)
}
o.startTime = aws.Int64(startTime)
}
if o.humanEndTime != "" {
endTime, err := parseRFC3339(o.humanEndTime)
if err != nil {
return fmt.Errorf(`invalid argument %s for "--end-time" flag: %w`, o.humanEndTime, err)
}
o.endTime = aws.Int64(endTime)
}
if o.limit != 0 && (o.limit < cwGetLogEventsLimitMin || o.limit > cwGetLogEventsLimitMax) {
return fmt.Errorf("--limit %d is out-of-bounds, value must be between %d and %d", o.limit, cwGetLogEventsLimitMin, cwGetLogEventsLimitMax)
}
if o.previous {
if err := o.validatePrevious(); err != nil {
return err
}
}
return nil
}
// Ask prompts for and validates any required flags.
func (o *svcLogsOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
return o.validateAndAskSvcEnvName()
}
// Execute outputs logs of the service.
func (o *svcLogsOpts) Execute() error {
if err := o.initRuntimeClients(); err != nil {
return err
}
eventsWriter := logging.WriteHumanLogs
if o.shouldOutputJSON {
eventsWriter = logging.WriteJSONLogs
}
var limit *int64
if o.limit != 0 {
limit = aws.Int64(int64(o.limit))
}
if o.previous {
taskID, err := o.latestStoppedTaskID()
if err != nil {
if errors.Is(err, noPreviousTasksErr) {
log.Warningln("no previously stopped tasks found")
return nil // return nil as we have no stopped tasks.
}
return err
}
o.taskIDs = []string{taskID}
log.Infoln("previously stopped task:", taskID)
}
err := o.logsSvc.WriteLogEvents(logging.WriteLogEventsOpts{
Follow: o.follow,
Limit: limit,
EndTime: o.endTime,
StartTime: o.startTime,
TaskIDs: o.taskIDs,
OnEvents: eventsWriter,
ContainerName: o.containerName,
LogGroup: o.logGroup,
})
if err != nil {
return fmt.Errorf("write log events for service %s: %w", o.name, err)
}
return nil
}
func (o *svcLogsOpts) latestStoppedTaskID() (string, error) {
svcDesc, err := o.ecs.DescribeService(o.appName, o.envName, o.name)
if err != nil {
return "", fmt.Errorf("describe service %s: %w", o.name, err)
}
if len(svcDesc.StoppedTasks) > 0 {
sort.Slice(svcDesc.StoppedTasks, func(i, j int) bool {
return svcDesc.StoppedTasks[i].StoppingAt.After(aws.TimeValue(svcDesc.StoppedTasks[j].StoppingAt))
})
taskID, err := awsecs.TaskID(aws.StringValue(svcDesc.StoppedTasks[0].TaskArn))
if err != nil {
return "", err
}
return taskID, nil
}
return "", noPreviousTasksErr
}
func (o *svcLogsOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.configStore.GetApplication(o.appName)
return err
}
app, err := o.sel.Application(svcAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *svcLogsOpts) validateAndAskSvcEnvName() error {
if o.envName != "" {
if _, err := o.getTargetEnv(); err != nil {
return err
}
}
if o.name != "" {
if _, err := o.configStore.GetService(o.appName, o.name); err != nil {
return err
}
}
// Note: we let prompter handle the case when there is only option for user to choose from.
// This is naturally the case when `o.envName != "" && o.name != ""`.
deployedService, err := o.sel.DeployedService(svcLogNamePrompt, svcLogNameHelpPrompt, o.appName, selector.WithEnv(o.envName), selector.WithName(o.name))
if err != nil {
return fmt.Errorf("select deployed services for application %s: %w", o.appName, err)
}
if deployedService.SvcType == manifestinfo.RequestDrivenWebServiceType && len(o.taskIDs) != 0 {
return fmt.Errorf("cannot use `--tasks` for App Runner service logs")
}
if deployedService.SvcType == manifestinfo.StaticSiteType {
return fmt.Errorf("`svc logs` unavailable for Static Site services")
}
o.name = deployedService.Name
o.envName = deployedService.Env
o.targetSvcType = deployedService.SvcType
return nil
}
func (o *svcLogsOpts) validatePrevious() error {
if o.previous && len(o.taskIDs) != 0 {
return fmt.Errorf("cannot specify both --%s and --%s", previousFlag, tasksFlag)
}
return nil
}
func (o *svcLogsOpts) getTargetEnv() (*config.Environment, error) {
if o.targetEnv != nil {
return o.targetEnv, nil
}
env, err := o.configStore.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, err
}
o.targetEnv = env
return o.targetEnv, nil
}
func parseSince(since time.Duration) *int64 {
sinceSec := int64(since.Round(time.Second).Seconds())
timeNow := time.Now().Add(time.Duration(-sinceSec) * time.Second)
return aws.Int64(timeNow.UnixMilli())
}
func parseRFC3339(timeStr string) (int64, error) {
startTimeTmp, err := time.Parse(time.RFC3339, timeStr)
if err != nil {
return 0, fmt.Errorf("reading time value %s: %w", timeStr, err)
}
return startTimeTmp.UnixMilli(), nil
}
// buildSvcLogsCmd builds the command for displaying service logs in an application.
func buildSvcLogsCmd() *cobra.Command {
vars := svcLogsVars{}
cmd := &cobra.Command{
Use: "logs",
Short: "Displays logs of a deployed service.",
Example: `
Displays logs of the service "my-svc" in environment "test".
/code $ copilot svc logs -n my-svc -e test
Displays logs in the last hour.
/code $ copilot svc logs --since 1h
Displays logs from 2006-01-02T15:04:05 to 2006-01-02T15:05:05.
/code $ copilot svc logs --start-time 2006-01-02T15:04:05+00:00 --end-time 2006-01-02T15:05:05+00:00
Displays logs from specific task IDs.
/code $ copilot svc logs --tasks 709c7eae05f947f6861b150372ddc443,1de57fd63c6a4920ac416d02add891b9
Displays logs in real time.
/code $ copilot svc logs --follow
Display logs from specific log group.
/code $ copilot svc logs --log-group system`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newSvcLogOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.humanStartTime, startTimeFlag, "", startTimeFlagDescription)
cmd.Flags().StringVar(&vars.humanEndTime, endTimeFlag, "", endTimeFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.follow, followFlag, false, followFlagDescription)
cmd.Flags().DurationVar(&vars.since, sinceFlag, 0, sinceFlagDescription)
cmd.Flags().IntVar(&vars.limit, limitFlag, 0, limitFlagDescription)
cmd.Flags().StringSliceVar(&vars.taskIDs, tasksFlag, nil, tasksLogsFlagDescription)
cmd.Flags().StringVar(&vars.logGroup, logGroupFlag, "", logGroupFlagDescription)
cmd.Flags().BoolVarP(&vars.previous, previousFlag, previousFlagShort, false, previousFlagDescription)
cmd.Flags().StringVar(&vars.containerName, containerLogFlag, "", containerLogFlagDescription)
return cmd
}
| 377 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"time"
"github.com/aws/aws-sdk-go/aws"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/logging"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type wkldLogsMock struct {
configStore *mocks.Mockstore
sel *mocks.MockdeploySelector
sessProvider *mocks.MocksessionProvider
ecs *mocks.MockserviceDescriber
logSvcWriter *mocks.MocklogEventsWriter
}
func TestSvcLogs_Validate(t *testing.T) {
const (
mockSince = 1 * time.Minute
mockStartTime = "1970-01-01T01:01:01+00:00"
mockBadStartTime = "badStartTime"
mockEndTime = "1971-01-01T01:01:01+00:00"
mockBadEndTime = "badEndTime"
)
testCases := map[string]struct {
inputApp string
inputSvc string
inputLimit int
inputFollow bool
inputEnvName string
inputStartTime string
inputEndTime string
inputSince time.Duration
inputPrevious bool
inputTaskIDs []string
mockstore func(m *mocks.Mockstore)
wantedError error
}{
"with no flag set": {
mockstore: func(m *mocks.Mockstore) {},
},
"returns error if since and startTime flags are set together": {
inputSince: mockSince,
inputStartTime: mockStartTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("only one of --since or --start-time may be used"),
},
"returns error if follow and endTime flags are set together": {
inputFollow: true,
inputEndTime: mockEndTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("only one of --follow or --end-time may be used"),
},
"returns error if invalid start time flag value": {
inputStartTime: mockBadStartTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("invalid argument badStartTime for \"--start-time\" flag: reading time value badStartTime: parsing time \"badStartTime\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"badStartTime\" as \"2006\""),
},
"returns error if invalid end time flag value": {
inputEndTime: mockBadEndTime,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("invalid argument badEndTime for \"--end-time\" flag: reading time value badEndTime: parsing time \"badEndTime\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"badEndTime\" as \"2006\""),
},
"returns error if invalid since flag value": {
inputSince: -mockSince,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("--since must be greater than 0"),
},
"returns error if limit value is below limit": {
inputLimit: -1,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("--limit -1 is out-of-bounds, value must be between 1 and 10000"),
},
"returns error if limit value is above limit": {
inputLimit: 10001,
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("--limit 10001 is out-of-bounds, value must be between 1 and 10000"),
},
"returns error if both previous and tasks flags are defined": {
inputPrevious: true,
inputTaskIDs: []string{"taskId"},
mockstore: func(m *mocks.Mockstore) {},
wantedError: fmt.Errorf("cannot specify both --previous and --tasks"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
tc.mockstore(mockstore)
svcLogs := &svcLogsOpts{
svcLogsVars: svcLogsVars{
wkldLogsVars: wkldLogsVars{
follow: tc.inputFollow,
limit: tc.inputLimit,
envName: tc.inputEnvName,
humanStartTime: tc.inputStartTime,
humanEndTime: tc.inputEndTime,
since: tc.inputSince,
name: tc.inputSvc,
appName: tc.inputApp,
taskIDs: tc.inputTaskIDs,
},
previous: tc.inputPrevious,
},
wkldLogOpts: wkldLogOpts{
configStore: mockstore,
},
}
// WHEN
err := svcLogs.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestSvcLogs_Ask(t *testing.T) {
const (
inputApp = "my-app"
inputEnv = "my-env"
inputSvc = "my-svc"
)
testCases := map[string]struct {
inputApp string
inputSvc string
inputEnvName string
inputTaskIDs []string
setupMocks func(mocks wkldLogsMock)
wantedApp string
wantedEnv string
wantedSvc string
wantedError error
}{
"validate app env and svc with all flags passed in": {
inputApp: inputApp,
inputSvc: inputSvc,
inputEnvName: inputEnv,
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.configStore.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil),
m.configStore.EXPECT().GetEnvironment("my-app", "my-env").Return(&config.Environment{Name: "my-env"}, nil),
m.configStore.EXPECT().GetService("my-app", "my-svc").Return(&config.Workload{}, nil),
m.sel.EXPECT().DeployedService(svcLogNamePrompt, svcLogNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil), // Let prompter handles the case when svc(env) is definite.
)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"return error if name of Static Site passed in": {
inputApp: inputApp,
inputSvc: inputSvc,
inputEnvName: inputEnv,
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.configStore.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil),
m.configStore.EXPECT().GetEnvironment("my-app", "my-env").Return(&config.Environment{Name: "my-env"}, nil),
m.configStore.EXPECT().GetService("my-app", "my-svc").Return(
&config.Workload{
Type: manifestinfo.StaticSiteType,
}, nil))
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
SvcType: manifestinfo.StaticSiteType,
}, nil)
},
wantedError: errors.New("`svc logs` unavailable for Static Site services"),
},
"prompt for app name": {
inputSvc: inputSvc,
inputEnvName: inputEnv,
setupMocks: func(m wkldLogsMock) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("my-app", nil)
m.configStore.EXPECT().GetApplication(gomock.Any()).Times(0)
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
SvcType: manifestinfo.BackendServiceType,
}, nil).AnyTimes()
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"returns error if fail to select app": {
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error")),
)
},
wantedError: fmt.Errorf("select application: some error"),
},
"prompt for svc and env": {
inputApp: "my-app",
setupMocks: func(m wkldLogsMock) {
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.configStore.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(svcLogNamePrompt, svcLogNameHelpPrompt, "my-app", gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"return error if fail to select deployed services": {
inputApp: inputApp,
setupMocks: func(m wkldLogsMock) {
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.configStore.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(svcLogNamePrompt, svcLogNameHelpPrompt, inputApp, gomock.Any(), gomock.Any()).
Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("select deployed services for application my-app: some error"),
},
"return error if task ID is used for an RDWS": {
inputApp: inputApp,
inputTaskIDs: []string{"mockTask1, mockTask2"},
setupMocks: func(m wkldLogsMock) {
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.configStore.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(svcLogNamePrompt, svcLogNameHelpPrompt, inputApp, gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
SvcType: manifestinfo.RequestDrivenWebServiceType,
}, nil)
},
wantedError: errors.New("cannot use `--tasks` for App Runner service logs"),
},
"return error if selected svc is of Static Site type": {
inputApp: inputApp,
setupMocks: func(m wkldLogsMock) {
m.configStore.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.configStore.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.configStore.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(svcLogNamePrompt, svcLogNameHelpPrompt, inputApp, gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
SvcType: manifestinfo.StaticSiteType,
}, nil)
},
wantedError: errors.New("`svc logs` unavailable for Static Site services"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
mockSel := mocks.NewMockdeploySelector(ctrl)
mocks := wkldLogsMock{
configStore: mockstore,
sel: mockSel,
}
tc.setupMocks(mocks)
svcLogs := &svcLogsOpts{
svcLogsVars: svcLogsVars{
wkldLogsVars: wkldLogsVars{
envName: tc.inputEnvName,
name: tc.inputSvc,
appName: tc.inputApp,
taskIDs: tc.inputTaskIDs,
},
},
wkldLogOpts: wkldLogOpts{
configStore: mockstore,
sel: mockSel,
},
}
// WHEN
err := svcLogs.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, svcLogs.appName, "expected app name to match")
require.Equal(t, tc.wantedSvc, svcLogs.name, "expected service name to match")
require.Equal(t, tc.wantedEnv, svcLogs.envName, "expected service name to match")
}
})
}
}
func TestSvcLogs_Execute(t *testing.T) {
mockTaskARN := "arn:aws:ecs:us-west-2:123456789:task/mockCluster/mockTaskID"
mockOtherTaskARN := "arn:aws:ecs:us-west-2:123456789:task/mockCluster/mockTaskID1"
mockStartTime := int64(123456789)
mockEndTime := int64(987654321)
mockLimit := int64(10)
var mockNilLimit *int64
testCases := map[string]struct {
inputSvc string
inputApp string
inputEnv string
follow bool
limit int
endTime int64
startTime int64
taskIDs []string
inputPreviousTask bool
container string
logGroup string
setupMocks func(mocks wkldLogsMock)
wantedError error
}{
"success": {
inputSvc: "mockSvc",
endTime: mockEndTime,
startTime: mockStartTime,
follow: true,
limit: 10,
taskIDs: []string{"mockTaskID"},
container: "datadog",
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.logSvcWriter.EXPECT().WriteLogEvents(gomock.Any()).Do(func(param logging.WriteLogEventsOpts) {
require.Equal(t, param.TaskIDs, []string{"mockTaskID"})
require.Equal(t, param.EndTime, &mockEndTime)
require.Equal(t, param.StartTime, &mockStartTime)
require.Equal(t, param.Follow, true)
require.Equal(t, param.Limit, &mockLimit)
require.Equal(t, param.ContainerName, "datadog")
}).Return(nil),
)
},
wantedError: nil,
},
"success with no limit set": {
inputSvc: "mockSvc",
endTime: mockEndTime,
startTime: mockStartTime,
follow: true,
taskIDs: []string{"mockTaskID"},
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.logSvcWriter.EXPECT().WriteLogEvents(gomock.Any()).Do(func(param logging.WriteLogEventsOpts) {
require.Equal(t, param.TaskIDs, []string{"mockTaskID"})
require.Equal(t, param.EndTime, &mockEndTime)
require.Equal(t, param.StartTime, &mockStartTime)
require.Equal(t, param.Follow, true)
require.Equal(t, param.Limit, mockNilLimit)
}).Return(nil),
)
},
wantedError: nil,
},
"success with system log group for RDWS": {
inputSvc: "mockSvc",
startTime: mockStartTime,
endTime: mockEndTime,
logGroup: "system",
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.logSvcWriter.EXPECT().WriteLogEvents(gomock.Any()).Do(func(param logging.WriteLogEventsOpts) {
require.Equal(t, param.TaskIDs, ([]string)(nil))
require.Equal(t, param.EndTime, &mockEndTime)
require.Equal(t, param.StartTime, &mockStartTime)
require.Equal(t, param.Follow, false)
require.Equal(t, param.Limit, (*int64)(nil))
require.Equal(t, param.ContainerName, "")
require.Equal(t, param.LogGroup, "system")
}).Return(nil),
)
},
wantedError: nil,
},
"returns error if fail to get event logs": {
inputSvc: "mockSvc",
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.logSvcWriter.EXPECT().WriteLogEvents(gomock.Any()).
Return(errors.New("some error")),
)
},
wantedError: fmt.Errorf("write log events for service mockSvc: some error"),
},
"retrieve previously stopped task's logs": {
inputSvc: "mockSvc",
inputPreviousTask: true,
inputApp: "my-app",
inputEnv: "my-env",
endTime: mockEndTime,
startTime: mockStartTime,
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.ecs.EXPECT().DescribeService("my-app", "my-env", "mockSvc").Return(&ecs.ServiceDesc{
ClusterName: "mockCluster",
StoppedTasks: []*awsecs.Task{
{
TaskArn: aws.String(mockTaskARN),
LastStatus: aws.String("STOPPED"),
StoppingAt: aws.Time(time.Now()),
},
{
TaskArn: aws.String(mockOtherTaskARN),
LastStatus: aws.String("STOPPED"),
StoppingAt: aws.Time(time.Now()),
},
},
Tasks: []*awsecs.Task{
{
TaskArn: aws.String(mockTaskARN),
LastStatus: aws.String("RUNNING"),
},
},
}, nil),
m.logSvcWriter.EXPECT().WriteLogEvents(gomock.Any()).Do(func(param logging.WriteLogEventsOpts) {
require.Equal(t, param.TaskIDs, []string{"mockTaskID1"})
require.Equal(t, param.EndTime, &mockEndTime)
require.Equal(t, param.StartTime, &mockStartTime)
require.Equal(t, param.Limit, mockNilLimit)
}).Return(nil),
)
},
wantedError: nil,
},
"retrieve warning no previously stopped tasks found, when no stopped task or logs available": {
inputSvc: "mockSvc",
inputPreviousTask: true,
inputApp: "my-app",
inputEnv: "my-env",
endTime: mockEndTime,
startTime: mockStartTime,
setupMocks: func(m wkldLogsMock) {
gomock.InOrder(
m.ecs.EXPECT().DescribeService("my-app", "my-env", "mockSvc").Return(&ecs.ServiceDesc{
ClusterName: "mockCluster",
StoppedTasks: []*awsecs.Task{},
Tasks: []*awsecs.Task{
{
TaskArn: aws.String(mockTaskARN),
LastStatus: aws.String("RUNNING"),
},
},
}, nil),
)
},
wantedError: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockConfigStoreReader := mocks.NewMockstore(ctrl)
mockSelector := mocks.NewMockdeploySelector(ctrl)
mockSvcDescriber := mocks.NewMockserviceDescriber(ctrl)
mockSessionProvider := mocks.NewMocksessionProvider(ctrl)
mockLogsSvc := mocks.NewMocklogEventsWriter(ctrl)
mocks := wkldLogsMock{
configStore: mockConfigStoreReader,
sessProvider: mockSessionProvider,
sel: mockSelector,
ecs: mockSvcDescriber,
logSvcWriter: mockLogsSvc,
}
tc.setupMocks(mocks)
svcLogs := &svcLogsOpts{
svcLogsVars: svcLogsVars{
wkldLogsVars: wkldLogsVars{
name: tc.inputSvc,
appName: tc.inputApp,
envName: tc.inputEnv,
follow: tc.follow,
limit: tc.limit,
taskIDs: tc.taskIDs,
},
previous: tc.inputPreviousTask,
containerName: tc.container,
logGroup: tc.logGroup,
},
wkldLogOpts: wkldLogOpts{
startTime: &tc.startTime,
endTime: &tc.endTime,
initRuntimeClients: func() error { return nil },
logsSvc: mockLogsSvc,
configStore: mockConfigStoreReader,
sel: mockSelector,
sessProvider: mockSessionProvider,
ecs: mockSvcDescriber,
},
}
// WHEN
err := svcLogs.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 577 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
type overrideWorkloadVars struct {
overrideVars
envName string // Optional.
}
type overrideWorkloadOpts struct {
envName string
*overrideOpts
// Interfaces to interact with dependencies.
ws wsWlDirReader
wsPrompt wsSelector
validateOrAskName func() error
}
func newOverrideWorkloadOpts(vars overrideWorkloadVars) (*overrideWorkloadOpts, error) {
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc override"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
cfgStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompt := prompt.New()
cmd := &overrideWorkloadOpts{
envName: vars.envName,
overrideOpts: &overrideOpts{
overrideVars: vars.overrideVars,
fs: fs,
cfgStore: cfgStore,
prompt: prompt,
cfnPrompt: selector.NewCFNSelector(prompt),
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
},
ws: ws,
wsPrompt: selector.NewLocalWorkloadSelector(prompt, cfgStore, ws),
}
return cmd, nil
}
func newOverrideSvcOpts(vars overrideWorkloadVars) (*overrideWorkloadOpts, error) {
cmd, err := newOverrideWorkloadOpts(vars)
if err != nil {
return nil, err
}
cmd.validateOrAskName = cmd.validateOrAskServiceName
cmd.overrideOpts.packageCmd = cmd.newSvcPackageCmd
return cmd, nil
}
// Validate returns an error for any invalid optional flags.
func (o *overrideWorkloadOpts) Validate() error {
if err := o.overrideOpts.Validate(); err != nil {
return err
}
return o.validateEnvName()
}
// Ask prompts for and validates any required flags.
func (o *overrideWorkloadOpts) Ask() error {
if err := o.validateOrAskName(); err != nil {
return err
}
return o.overrideOpts.Ask()
}
// Execute writes IaC override files to the local workspace.
// This method assumes that the IaC tool chosen by the user is valid.
func (o *overrideWorkloadOpts) Execute() error {
o.overrideOpts.dir = func() string {
return o.ws.WorkloadOverridesPath(o.name)
}
return o.overrideOpts.Execute()
}
func (o *overrideWorkloadOpts) validateEnvName() error {
if o.envName == "" {
return nil
}
_, err := o.cfgStore.GetEnvironment(o.appName, o.envName)
if err != nil {
return fmt.Errorf("get environment %q configuration: %v", o.envName, err)
}
return nil
}
func (o *overrideWorkloadOpts) validateOrAskServiceName() error {
if o.name == "" {
return o.askServiceName()
}
return o.validateServiceName()
}
func (o *overrideWorkloadOpts) validateServiceName() error {
names, err := o.ws.ListServices()
if err != nil {
return fmt.Errorf("list services in the workspace: %v", err)
}
if !contains(o.name, names) {
return fmt.Errorf("service %q does not exist in the workspace", o.name)
}
return nil
}
func (o *overrideWorkloadOpts) askServiceName() error {
name, err := o.wsPrompt.Service("Which service's resources would you like to override?", "")
if err != nil {
return fmt.Errorf("select service name from workspace: %v", err)
}
o.name = name
return nil
}
func (o *overrideWorkloadOpts) newSvcPackageCmd(tplBuf stringWriteCloser) (executor, error) {
envName, err := o.targetEnvName()
if err != nil {
return nil, err
}
cmd, err := newPackageSvcOpts(packageSvcVars{
name: o.name,
envName: envName,
appName: o.appName,
})
if err != nil {
return nil, err
}
cmd.templateWriter = tplBuf
return cmd, nil
}
// targetEnvName returns the name of the environment to use when running "svc package".
// If the user does not explicitly provide an environment, default to a random environment.
func (o *overrideWorkloadOpts) targetEnvName() (string, error) {
if o.envName != "" {
return o.envName, nil
}
envs, err := o.cfgStore.ListEnvironments(o.appName)
if err != nil {
return "", fmt.Errorf("list environments in application %q: %v", o.appName, err)
}
if len(envs) == 0 {
return "", fmt.Errorf("no environments found in application %q", o.appName)
}
return envs[0].Name, nil
}
func buildSvcOverrideCmd() *cobra.Command {
vars := overrideWorkloadVars{}
cmd := &cobra.Command{
Use: "override",
Short: "Override the AWS CloudFormation template of a service.",
Long: `Scaffold Infrastructure as Code (IaC) extension files for a service.
The generated files allow you to extend and override the Copilot-generated AWS CloudFormation template.
You can edit the files to change existing resource properties, delete
or add new resources to the service's template.`,
Example: `
Create a new Cloud Development Kit application to override the "frontend" service template.
/code $ copilot svc override -n frontend --tool cdk`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newOverrideSvcOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", overrideEnvFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.iacTool, iacToolFlag, "", iacToolFlagDescription)
cmd.Flags().StringVar(&vars.cdkLang, cdkLanguageFlag, typescriptCDKLang, cdkLanguageFlagDescription)
cmd.Flags().BoolVar(&vars.skipResources, skipResourcesFlag, false, skipResourcesFlagDescription)
return cmd
}
| 203 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"path/filepath"
"testing"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/golang/mock/gomock"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
)
func TestOverrideSvc_Validate(t *testing.T) {
t.Run("validate application", func(t *testing.T) {
testCases := map[string]struct {
appName string
initMocks func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts)
wanted error
}{
"return an error if the workspace has no application associated with": {
wanted: errNoAppInWorkspace,
},
"return a wrapped error if the workspace's application cannot be fetched from the Config Store": {
appName: "demo",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).Return(nil, errors.New("some error"))
cmd.cfgStore = mockSSM
},
wanted: errors.New(`get application "demo" configuration: some error`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
vars := overrideVars{appName: tc.appName}
cmd := &overrideWorkloadOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
},
}
if tc.initMocks != nil {
tc.initMocks(ctrl, cmd)
}
// WHEN
err := cmd.Validate()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
t.Run("validate environment name", func(t *testing.T) {
testCases := map[string]struct {
envName string
initMocks func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts)
wanted error
}{
"skip validating if environment name is empty": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).AnyTimes()
cmd.cfgStore = mockSSM
},
},
"return a wrapped error if the environment flag value does not exist": {
envName: "test",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).AnyTimes()
mockSSM.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Return(nil, &config.ErrNoSuchEnvironment{})
cmd.cfgStore = mockSSM
},
wanted: errors.New(`get environment "test" configuration`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
vars := overrideVars{appName: "demo", cdkLang: "typescript"}
cmd := &overrideWorkloadOpts{
envName: tc.envName,
overrideOpts: &overrideOpts{
overrideVars: vars,
},
}
if tc.initMocks != nil {
tc.initMocks(ctrl, cmd)
}
// WHEN
err := cmd.Validate()
// THEN
if tc.wanted != nil {
require.ErrorContains(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
t.Run("validate CDK language", func(t *testing.T) {
testCases := map[string]struct {
lang string
wanted error
}{
"return an error when an unknown language is selected": {
lang: "python",
wanted: errors.New(`"python" is not a valid CDK language: must be one of: "typescript"`),
},
"typescript is a valid CDK language": {
lang: "typescript",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSSM := mocks.NewMockstore(ctrl)
mockSSM.EXPECT().GetApplication(gomock.Any()).Return(nil, nil)
vars := overrideVars{appName: "demo", cdkLang: tc.lang}
cmd := &overrideWorkloadOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mockSSM,
},
}
// WHEN
err := cmd.Validate()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
}
func TestOverrideSvc_Ask(t *testing.T) {
t.Run("ask or validate service name", func(t *testing.T) {
testCases := map[string]struct {
name string
initMocks func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts)
wanted error
}{
"validation passes if service exists in local workspace": {
name: "frontend",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListServices().Return([]string{"backend", "frontend", "worker"}, nil)
cmd.ws = mockWS
},
},
"return a wrapped error if local services cannot be retrieved from workspace": {
name: "frontend",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListServices().Return(nil, errors.New("some error"))
cmd.ws = mockWS
},
wanted: errors.New("list services in the workspace: some error"),
},
"return an error if service does not exist in the workspace": {
name: "frontend",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListServices().Return([]string{"backend"}, nil)
cmd.ws = mockWS
},
wanted: errors.New(`service "frontend" does not exist in the workspace`),
},
"should ask for the local service name if flag is not provided": {
name: "",
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockPrompt := mocks.NewMockwsSelector(ctrl)
mockPrompt.EXPECT().Service(gomock.Any(), gomock.Any())
cmd.wsPrompt = mockPrompt
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockCfnPrompt := mocks.NewMockcfnSelector(ctrl)
mockCfnPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
vars := overrideVars{name: tc.name, appName: "demo", iacTool: "cdk"}
cmd := &overrideWorkloadOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mocks.NewMockstore(ctrl),
cfnPrompt: mockCfnPrompt,
packageCmd: func(_ stringWriteCloser) (executor, error) {
mockCmd := mocks.NewMockexecutor(ctrl)
mockCmd.EXPECT().Execute().AnyTimes()
return mockCmd, nil
},
spinner: &spinnerTestDouble{},
},
}
cmd.validateOrAskName = cmd.validateOrAskServiceName
tc.initMocks(ctrl, cmd)
// WHEN
err := cmd.Ask()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
t.Run("ask or validate IaC tool", func(t *testing.T) {
testCases := map[string]struct {
iacTool string
initMocks func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts)
wanted error
}{
"validation passes if IaC tool is a valid option": {
iacTool: "cdk",
wanted: nil,
},
"return an error if IaC tool flag value is invalid": {
iacTool: "terraform",
wanted: errors.New(`"terraform" is not a valid IaC tool: must be one of: "cdk", "yamlpatch"`),
},
"should ask for IaC tool name if flag is not provided": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockPrompt := mocks.NewMockprompter(ctrl)
mockPrompt.EXPECT().SelectOne(gomock.Any(), gomock.Any(), []string{"cdk", "yamlpatch"}, gomock.Any())
cmd.prompt = mockPrompt
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSSM := mocks.NewMockstore(ctrl)
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListServices().Return([]string{"frontend"}, nil).AnyTimes()
mockCfnPrompt := mocks.NewMockcfnSelector(ctrl)
mockCfnPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
vars := overrideVars{appName: "demo", name: "frontend", iacTool: tc.iacTool}
cmd := &overrideWorkloadOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mockSSM,
cfnPrompt: mockCfnPrompt,
packageCmd: func(_ stringWriteCloser) (executor, error) {
mockCmd := mocks.NewMockexecutor(ctrl)
mockCmd.EXPECT().Execute().AnyTimes()
return mockCmd, nil
},
spinner: &spinnerTestDouble{},
},
ws: mockWS,
}
cmd.validateOrAskName = cmd.validateOrAskServiceName
if tc.initMocks != nil {
tc.initMocks(ctrl, cmd)
}
// WHEN
err := cmd.Ask()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
t.Run("ask for which template resources to override", func(t *testing.T) {
testCases := map[string]struct {
skip bool
initMocks func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts)
wanted error
}{
"should skip prompting for resources if the user opts-in to generating empty files": {
skip: true,
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockPrompt := mocks.NewMockcfnSelector(ctrl)
mockPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
cmd.cfnPrompt = mockPrompt
},
},
"should return an error if package command cannot be initialized": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
cmd.packageCmd = func(_ stringWriteCloser) (executor, error) {
return nil, errors.New("init fail")
}
},
wanted: errors.New("init fail"),
},
"should return a wrapped error if package command fails to execute": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockPkgCmd := mocks.NewMockexecutor(ctrl)
mockPkgCmd.EXPECT().Execute().Return(errors.New("some error"))
cmd.packageCmd = func(_ stringWriteCloser) (executor, error) {
return mockPkgCmd, nil
}
},
wanted: errors.New(`generate CloudFormation template for "frontend": some error`),
},
"should prompt for CloudFormation resources in a template": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
mockPkgCmd := mocks.NewMockexecutor(ctrl)
mockPkgCmd.EXPECT().Execute().Return(nil)
mockPrompt := mocks.NewMockcfnSelector(ctrl)
template := `
Resources:
Queue:
Type: AWS::SQS::Queue
Service:
Type: AWS::ECS::Service
`
mockPrompt.EXPECT().Resources(gomock.Any(), gomock.Any(), gomock.Any(), template).Return(nil, nil)
cmd.packageCmd = func(w stringWriteCloser) (executor, error) {
_, _ = w.Write([]byte(template))
return mockPkgCmd, nil
}
cmd.cfnPrompt = mockPrompt
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSSM := mocks.NewMockstore(ctrl)
mockWS := mocks.NewMockwsWlDirReader(ctrl)
mockWS.EXPECT().ListServices().Return([]string{"frontend"}, nil).AnyTimes()
vars := overrideVars{appName: "demo", name: "frontend", iacTool: "cdk", skipResources: tc.skip}
cmd := &overrideWorkloadOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
cfgStore: mockSSM,
spinner: &spinnerTestDouble{},
},
ws: mockWS,
}
cmd.validateOrAskName = cmd.validateOrAskServiceName
tc.initMocks(ctrl, cmd)
// WHEN
err := cmd.Ask()
// THEN
if tc.wanted != nil {
require.EqualError(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
}
func TestOverrideSvc_Execute(t *testing.T) {
t.Run("with the CDK", func(t *testing.T) {
testCases := map[string]struct {
resources []template.CFNResource
initMocks func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts)
wanted error
}{
"should succeed creating IaC files without any resources": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
fs := afero.NewMemMapFs()
ws := mocks.NewMockwsWlDirReader(ctrl)
ws.EXPECT().WorkloadOverridesPath(gomock.Any()).Return(filepath.Join("copilot", "frontend", "overrides"))
cmd.ws = ws
cmd.fs = fs
},
},
"should succeed creating IaC files with resources": {
resources: []template.CFNResource{
{
Type: "AWS::ECS::Service",
LogicalID: "Service",
},
},
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
fs := afero.NewMemMapFs()
ws := mocks.NewMockwsWlDirReader(ctrl)
ws.EXPECT().WorkloadOverridesPath(gomock.Any()).Return(filepath.Join("copilot", "frontend", "overrides"))
cmd.ws = ws
cmd.fs = fs
},
},
"should return a wrapped error if override files already exists": {
initMocks: func(ctrl *gomock.Controller, cmd *overrideWorkloadOpts) {
dir := filepath.Join("copilot", "frontend", "overrides")
fs := afero.NewMemMapFs()
_ = fs.MkdirAll(dir, 0755)
_ = afero.WriteFile(fs, filepath.Join(dir, "cdk.json"), []byte("content"), 0755)
ws := mocks.NewMockwsWlDirReader(ctrl)
ws.EXPECT().WorkloadOverridesPath(gomock.Any()).Return(dir)
cmd.ws = ws
cmd.fs = fs
},
wanted: fmt.Errorf("scaffold CDK application under %q", filepath.Join("copilot", "frontend", "overrides")),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
vars := overrideVars{appName: "demo", name: "frontend", iacTool: "cdk", resources: tc.resources}
cmd := &overrideWorkloadOpts{
overrideOpts: &overrideOpts{
overrideVars: vars,
},
}
tc.initMocks(ctrl, cmd)
// WHEN
err := cmd.Execute()
// THEN
if tc.wanted != nil {
require.ErrorContains(t, err, tc.wanted.Error())
} else {
require.NoError(t, err)
}
})
}
})
}
| 475 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"os"
"path/filepath"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
clideploy "github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/spf13/afero"
"github.com/spf13/cobra"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
)
const (
svcPackageSvcNamePrompt = "Which service would you like to generate a CloudFormation template for?"
svcPackageEnvNamePrompt = "Which environment would you like to package this stack for?"
)
type packageSvcVars struct {
name string
envName string
appName string
tag string
outputDir string
uploadAssets bool
showDiff bool
// To facilitate unit tests.
clientConfigured bool
}
type packageSvcOpts struct {
packageSvcVars
// Interfaces to interact with dependencies.
ws wsWlDirReader
fs afero.Fs
store store
templateWriter io.WriteCloser
paramsWriter io.WriteCloser
addonsWriter io.WriteCloser
diffWriter io.Writer
runner execRunner
sessProvider *sessions.Provider
sel wsSelector
unmarshal func([]byte) (manifest.DynamicWorkload, error)
newInterpolator func(app, env string) interpolator
newStackGenerator func(*packageSvcOpts) (workloadStackGenerator, error)
envFeaturesDescriber versionCompatibilityChecker
gitShortCommit string
// cached variables
targetApp *config.Application
targetEnv *config.Environment
envSess *session.Session
appliedDynamicMft manifest.DynamicWorkload
rootUserARN string
}
func newPackageSvcOpts(vars packageSvcVars) (*packageSvcOpts, error) {
fs := afero.NewOsFs()
ws, err := workspace.Use(fs)
if err != nil {
return nil, err
}
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc package"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompter := prompt.New()
opts := &packageSvcOpts{
packageSvcVars: vars,
store: store,
ws: ws,
fs: fs,
unmarshal: manifest.UnmarshalWorkload,
runner: exec.NewCmd(),
sel: selector.NewLocalWorkloadSelector(prompter, store, ws),
templateWriter: os.Stdout,
paramsWriter: discardFile{},
addonsWriter: discardFile{},
diffWriter: os.Stdout,
newInterpolator: newManifestInterpolator,
sessProvider: sessProvider,
newStackGenerator: newWorkloadStackGenerator,
}
return opts, nil
}
func newWorkloadStackGenerator(o *packageSvcOpts) (workloadStackGenerator, error) {
targetApp, err := o.getTargetApp()
if err != nil {
return nil, err
}
targetEnv, err := o.getTargetEnv()
if err != nil {
return nil, err
}
raw, err := o.ws.ReadWorkloadManifest(o.name)
if err != nil {
return nil, fmt.Errorf("read manifest file for %s: %w", o.name, err)
}
ovrdr, err := clideploy.NewOverrider(o.ws.WorkloadOverridesPath(o.name), o.appName, o.envName, o.fs, o.sessProvider)
if err != nil {
return nil, err
}
content := o.appliedDynamicMft.Manifest()
var deployer workloadStackGenerator
in := clideploy.WorkloadDeployerInput{
SessionProvider: o.sessProvider,
Name: o.name,
App: targetApp,
Env: targetEnv,
Image: clideploy.ContainerImageIdentifier{
CustomTag: o.tag,
GitShortCommitTag: o.gitShortCommit,
},
Mft: content,
RawMft: raw,
EnvVersionGetter: o.envFeaturesDescriber,
Overrider: ovrdr,
}
switch t := content.(type) {
case *manifest.LoadBalancedWebService:
deployer, err = clideploy.NewLBWSDeployer(&in)
case *manifest.BackendService:
deployer, err = clideploy.NewBackendDeployer(&in)
case *manifest.RequestDrivenWebService:
deployer, err = clideploy.NewRDWSDeployer(&in)
case *manifest.WorkerService:
deployer, err = clideploy.NewWorkerSvcDeployer(&in)
case *manifest.ScheduledJob:
deployer, err = clideploy.NewJobDeployer(&in)
case *manifest.StaticSite:
deployer, err = clideploy.NewStaticSiteDeployer(&in)
default:
return nil, fmt.Errorf("unknown manifest type %T while creating the CloudFormation stack", t)
}
if err != nil {
return nil, fmt.Errorf("initiate workload template generator: %w", err)
}
return deployer, nil
}
// Validate returns an error for any invalid optional flags.
func (o *packageSvcOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *packageSvcOpts) Ask() error {
if o.appName != "" {
if _, err := o.getTargetApp(); err != nil {
return err
}
} else {
// NOTE: This command is required to be executed under a workspace. We don't prompt for it.
return errNoAppInWorkspace
}
if err := o.validateOrAskSvcName(); err != nil {
return err
}
if err := o.validateOrAskEnvName(); err != nil {
return err
}
return nil
}
// Execute prints the CloudFormation template of the application for the environment.
func (o *packageSvcOpts) Execute() error {
if !o.clientConfigured {
if err := o.configureClients(); err != nil {
return err
}
}
if o.outputDir != "" {
if err := o.setOutputFileWriters(); err != nil {
return err
}
}
targetEnv, err := o.getTargetEnv()
if err != nil {
return nil
}
gen, err := o.getStackGenerator(targetEnv)
if err != nil {
return err
}
stack, err := o.getWorkloadStack(gen)
if err != nil {
return err
}
if o.showDiff {
if err := diff(gen, stack.template, o.diffWriter); err != nil {
var errHasDiff *errHasDiff
if errors.As(err, &errHasDiff) {
return err
}
return &errDiffNotAvailable{
parentErr: err,
}
}
}
if err := o.writeAndClose(o.templateWriter, stack.template); err != nil {
return err
}
if err := o.writeAndClose(o.paramsWriter, stack.parameters); err != nil {
return err
}
addonsTemplate, err := gen.AddonsTemplate()
switch {
case err != nil:
return fmt.Errorf("retrieve addons template: %w", err)
case addonsTemplate == "":
return nil
}
// Addons template won't show up without setting --output-dir flag.
if o.outputDir != "" {
if err := o.setAddonsFileWriter(); err != nil {
return err
}
}
return o.writeAndClose(o.addonsWriter, addonsTemplate)
}
func (o *packageSvcOpts) validateOrAskSvcName() error {
if o.name != "" {
names, err := o.ws.ListServices()
if err != nil {
return fmt.Errorf("list services in the workspace: %w", err)
}
if !contains(o.name, names) {
return fmt.Errorf("service '%s' does not exist in the workspace", o.name)
}
return nil
}
name, err := o.sel.Service(svcPackageSvcNamePrompt, "")
if err != nil {
return fmt.Errorf("select service: %w", err)
}
o.name = name
return nil
}
func (o *packageSvcOpts) validateOrAskEnvName() error {
if o.envName != "" {
_, err := o.getTargetEnv()
return err
}
name, err := o.sel.Environment(svcPackageEnvNamePrompt, "", o.appName)
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
o.envName = name
return nil
}
func (o *packageSvcOpts) configureClients() error {
o.gitShortCommit = imageTagFromGit(o.runner) // Best effort assign git tag.
// client to retrieve an application's resources created with CloudFormation.
defaultSess, err := o.sessProvider.Default()
if err != nil {
return fmt.Errorf("create default session: %w", err)
}
targetEnv, err := o.getTargetEnv()
if err != nil {
return err
}
envSess, err := o.sessProvider.FromRole(targetEnv.ManagerRoleARN, targetEnv.Region)
if err != nil {
return err
}
o.envSess = envSess
// client to retrieve caller identity.
caller, err := identity.New(defaultSess).Get()
if err != nil {
return fmt.Errorf("get identity: %w", err)
}
o.rootUserARN = caller.RootUserARN
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: o.appName,
Env: o.envName,
ConfigStore: o.store,
})
if err != nil {
return err
}
o.envFeaturesDescriber = envDescriber
return nil
}
type cfnStackConfig struct {
template string
parameters string
}
func (o *packageSvcOpts) getStackGenerator(env *config.Environment) (workloadStackGenerator, error) {
mft, err := workloadManifest(&workloadManifestInput{
name: o.name,
appName: o.appName,
envName: o.envName,
interpolator: o.newInterpolator(o.appName, o.envName),
ws: o.ws,
unmarshal: o.unmarshal,
sess: o.envSess,
})
if err != nil {
return nil, err
}
o.appliedDynamicMft = mft
if err := validateWorkloadManifestCompatibilityWithEnv(o.ws, o.envFeaturesDescriber, o.appliedDynamicMft, o.envName); err != nil {
return nil, err
}
return o.newStackGenerator(o)
}
// getWorkloadStack returns the CloudFormation stack's template and its parameters for the service.
func (o *packageSvcOpts) getWorkloadStack(generator workloadStackGenerator) (*cfnStackConfig, error) {
targetApp, err := o.getTargetApp()
if err != nil {
return nil, err
}
var uploadOut clideploy.UploadArtifactsOutput
if o.uploadAssets {
out, err := generator.UploadArtifacts()
if err != nil {
return nil, fmt.Errorf("upload resources required for deployment for %s: %w", o.name, err)
}
uploadOut = *out
}
output, err := generator.GenerateCloudFormationTemplate(&clideploy.GenerateCloudFormationTemplateInput{
StackRuntimeConfiguration: clideploy.StackRuntimeConfiguration{
RootUserARN: o.rootUserARN,
Tags: targetApp.Tags,
EnvFileARNs: uploadOut.EnvFileARNs,
ImageDigests: uploadOut.ImageDigests,
AddonsURL: uploadOut.AddonsURL,
CustomResourceURLs: uploadOut.CustomResourceURLs,
StaticSiteAssetMappingURL: uploadOut.StaticSiteAssetMappingLocation,
},
})
if err != nil {
return nil, fmt.Errorf("generate workload %s template against environment %s: %w", o.name, o.envName, err)
}
return &cfnStackConfig{
template: output.Template,
parameters: output.Parameters}, nil
}
// setOutputFileWriters creates the output directory, and updates the template and param writers to file writers in the directory.
func (o *packageSvcOpts) setOutputFileWriters() error {
if err := o.fs.MkdirAll(o.outputDir, 0755); err != nil {
return fmt.Errorf("create directory %s: %w", o.outputDir, err)
}
templatePath := filepath.Join(o.outputDir,
fmt.Sprintf(deploy.WorkloadCfnTemplateNameFormat, o.name, o.envName))
templateFile, err := o.fs.Create(templatePath)
if err != nil {
return fmt.Errorf("create file %s: %w", templatePath, err)
}
o.templateWriter = templateFile
paramsPath := filepath.Join(o.outputDir,
fmt.Sprintf(deploy.WorkloadCfnTemplateConfigurationNameFormat, o.name, o.envName))
paramsFile, err := o.fs.Create(paramsPath)
if err != nil {
return fmt.Errorf("create file %s: %w", paramsPath, err)
}
o.paramsWriter = paramsFile
return nil
}
func (o *packageSvcOpts) setAddonsFileWriter() error {
addonsPath := filepath.Join(o.outputDir,
fmt.Sprintf(deploy.AddonsCfnTemplateNameFormat, o.name))
addonsFile, err := o.fs.Create(addonsPath)
if err != nil {
return fmt.Errorf("create file %s: %w", addonsPath, err)
}
o.addonsWriter = addonsFile
return nil
}
func (o *packageSvcOpts) getTargetApp() (*config.Application, error) {
if o.targetApp != nil {
return o.targetApp, nil
}
app, err := o.store.GetApplication(o.appName)
if err != nil {
return nil, fmt.Errorf("get application %s configuration: %w", o.appName, err)
}
o.targetApp = app
return o.targetApp, nil
}
func (o *packageSvcOpts) getTargetEnv() (*config.Environment, error) {
if o.targetEnv != nil {
return o.targetEnv, nil
}
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, fmt.Errorf("get environment %s: %w", o.envName, err)
}
o.targetEnv = env
return o.targetEnv, nil
}
func (o *packageSvcOpts) writeAndClose(wc io.WriteCloser, dat string) error {
if _, err := wc.Write([]byte(dat)); err != nil {
return err
}
return wc.Close()
}
// RecommendActions is a no-op.
func (o *packageSvcOpts) RecommendActions() error {
return nil
}
type errDiffNotAvailable struct {
parentErr error
}
// Unwrap returns the parent error that is wrapped inside errDiffNotAvailable.
func (e *errDiffNotAvailable) Unwrap() error {
return e.parentErr
}
func (e *errDiffNotAvailable) Error() string {
return e.parentErr.Error()
}
// ExitCode returns 2 when a diff is unavailable due to a parent error.
func (e *errDiffNotAvailable) ExitCode() int {
return 2
}
func contains(s string, items []string) bool {
for _, item := range items {
if s == item {
return true
}
}
return false
}
// buildSvcPackageCmd builds the command for printing a service's CloudFormation template.
func buildSvcPackageCmd() *cobra.Command {
vars := packageSvcVars{}
cmd := &cobra.Command{
Use: "package",
Short: "Print the AWS CloudFormation template of a service.",
Long: `Print the CloudFormation template used to deploy a service to an environment.`,
Example: `
Print the CloudFormation template for the "frontend" service parametrized for the "test" environment.
/code $ copilot svc package -n frontend -e test
Write the CloudFormation stack and configuration to a "infrastructure/" sub-directory instead of stdout.
/startcodeblock
$ copilot svc package -n frontend -e test --output-dir ./infrastructure
$ ls ./infrastructure
frontend-test.stack.yml frontend-test.params.json
/endcodeblock`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newPackageSvcOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVar(&vars.tag, imageTagFlag, "", imageTagFlagDescription)
cmd.Flags().StringVar(&vars.outputDir, stackOutputDirFlag, "", stackOutputDirFlagDescription)
cmd.Flags().BoolVar(&vars.uploadAssets, uploadAssetsFlag, false, uploadAssetsFlagDescription)
cmd.Flags().BoolVar(&vars.showDiff, diffFlag, false, diffFlagDescription)
cmd.MarkFlagsMutuallyExclusive(diffFlag, stackOutputDirFlag)
cmd.MarkFlagsMutuallyExclusive(diffFlag, uploadAssetsFlag)
return cmd
}
| 513 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"io"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest"
)
type svcPackageAskMock struct {
store *mocks.Mockstore
sel *mocks.MockwsSelector
ws *mocks.MockwsWlDirReader
}
func TestPackageSvcOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inAppName string
inSvcName string
inEnvName string
setupMocks func(m svcPackageAskMock)
wantedAppName string
wantedSvcName string
wantedEnvName string
wantedError error
}{
"validate instead of prompting application name, svc name and environment name": {
inAppName: "phonetool",
inEnvName: "prod-iad",
inSvcName: "frontend",
setupMocks: func(m svcPackageAskMock) {
m.store.EXPECT().GetApplication("phonetool")
m.store.EXPECT().GetEnvironment("phonetool", "prod-iad").Return(&config.Environment{Name: "prod-iad"}, nil)
m.ws.EXPECT().ListServices().Return([]string{"frontend"}, nil)
m.sel.EXPECT().Service(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedAppName: "phonetool",
wantedSvcName: "frontend",
wantedEnvName: "prod-iad",
},
"error instead of prompting for application name if not provided": {
setupMocks: func(m svcPackageAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).Times(0)
},
wantedError: errNoAppInWorkspace,
},
"prompt for the service name": {
inAppName: "phonetool",
inEnvName: "test",
setupMocks: func(m svcPackageAskMock) {
m.sel.EXPECT().Service("Which service would you like to generate a CloudFormation template for?", "").
Return("frontend", nil)
m.ws.EXPECT().ListServices().Times(0)
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
},
wantedAppName: "phonetool",
wantedSvcName: "frontend",
wantedEnvName: "test",
},
"prompt for the env name": {
inAppName: "phonetool",
inSvcName: "frontend",
setupMocks: func(m svcPackageAskMock) {
m.sel.EXPECT().Environment(gomock.Any(), gomock.Any(), "phonetool").Return("prod-iad", nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetApplication("phonetool").AnyTimes()
m.ws.EXPECT().ListServices().Return([]string{"frontend"}, nil).AnyTimes()
},
wantedAppName: "phonetool",
wantedSvcName: "frontend",
wantedEnvName: "prod-iad",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := svcPackageAskMock{
store: mocks.NewMockstore(ctrl),
sel: mocks.NewMockwsSelector(ctrl),
ws: mocks.NewMockwsWlDirReader(ctrl),
}
tc.setupMocks(m)
opts := &packageSvcOpts{
packageSvcVars: packageSvcVars{
name: tc.inSvcName,
envName: tc.inEnvName,
appName: tc.inAppName,
},
sel: m.sel,
store: m.store,
ws: m.ws,
runner: mocks.NewMockexecRunner(ctrl),
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedAppName, opts.appName)
require.Equal(t, tc.wantedSvcName, opts.name)
require.Equal(t, tc.wantedEnvName, opts.envName)
}
})
}
}
type svcPackageExecuteMock struct {
ws *mocks.MockwsWlDirReader
generator *mocks.MockworkloadStackGenerator
interpolator *mocks.Mockinterpolator
envFeaturesDescriber *mocks.MockversionCompatibilityChecker
mft *mockWorkloadMft
}
type mockWriteCloser struct {
w io.Writer
}
func (wc mockWriteCloser) Write(p []byte) (n int, err error) {
return wc.w.Write(p)
}
func (wc mockWriteCloser) Close() error {
return nil
}
func TestPackageSvcOpts_Execute(t *testing.T) {
const (
mockARN = "mockARN"
mockDigest = "mockDigest"
lbwsMft = `name: api
type: Load Balanced Web Service
image:
build: ./Dockerfile
port: 80
http:
path: 'api'
cpu: 256
memory: 512
count: 1`
rdwsMft = `name: api
type: Request-Driven Web Service
image:
build: ./Dockerfile
port: 80
http:
alias: 'hunter.com'
cpu: 256
memory: 512
count: 1`
)
testCases := map[string]struct {
inVars packageSvcVars
setupMocks func(m *svcPackageExecuteMock)
wantedStack string
wantedParams string
wantedAddons string
wantedDiff string
wantedErr error
}{
"fail to get the diff": {
inVars: packageSvcVars{
name: "api",
clientConfigured: true,
showDiff: true,
},
setupMocks: func(m *svcPackageExecuteMock) {
m.ws.EXPECT().ReadWorkloadManifest("api").Return([]byte(lbwsMft), nil)
m.interpolator.EXPECT().Interpolate(lbwsMft).Return(lbwsMft, nil)
m.mft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{}
},
}
m.envFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.envFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{}, nil)
m.generator.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{
Template: "mystack",
Parameters: "myparams",
}, nil)
m.generator.EXPECT().DeployDiff(gomock.Eq("mystack")).Return("", errors.New("some error"))
},
wantedErr: &errDiffNotAvailable{parentErr: errors.New("some error")},
},
"writes the diff": {
inVars: packageSvcVars{
name: "api",
clientConfigured: true,
showDiff: true,
},
setupMocks: func(m *svcPackageExecuteMock) {
m.ws.EXPECT().ReadWorkloadManifest("api").Return([]byte(lbwsMft), nil)
m.interpolator.EXPECT().Interpolate(lbwsMft).Return(lbwsMft, nil)
m.mft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{}
},
}
m.envFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.envFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{}, nil)
m.generator.EXPECT().GenerateCloudFormationTemplate(gomock.Any()).Return(&deploy.GenerateCloudFormationTemplateOutput{
Template: "mystack",
Parameters: "myparams",
}, nil)
m.generator.EXPECT().DeployDiff(gomock.Eq("mystack")).Return("mock diff", nil)
},
wantedDiff: "mock diff",
wantedErr: &errHasDiff{},
},
"writes service template without addons": {
inVars: packageSvcVars{
appName: "ecs-kudos",
name: "api",
envName: "test",
tag: "1234",
clientConfigured: true,
uploadAssets: true,
},
setupMocks: func(m *svcPackageExecuteMock) {
m.ws.EXPECT().ReadWorkloadManifest("api").Return([]byte(lbwsMft), nil)
m.generator.EXPECT().UploadArtifacts().Return(&deploy.UploadArtifactsOutput{
ImageDigests: map[string]deploy.ContainerImageIdentifier{
"api": {
Digest: mockDigest,
},
},
}, nil)
m.generator.EXPECT().GenerateCloudFormationTemplate(&deploy.GenerateCloudFormationTemplateInput{
StackRuntimeConfiguration: deploy.StackRuntimeConfiguration{
ImageDigests: map[string]deploy.ContainerImageIdentifier{
"api": {
Digest: mockDigest,
},
},
RootUserARN: mockARN,
},
}).Return(&deploy.GenerateCloudFormationTemplateOutput{
Template: "mystack",
Parameters: "myparams",
}, nil)
m.interpolator.EXPECT().Interpolate(lbwsMft).Return(lbwsMft, nil)
m.generator.EXPECT().AddonsTemplate().Return("", nil)
m.envFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{}
},
}
m.envFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{}, nil)
},
wantedStack: "mystack",
wantedParams: "myparams",
},
"writes request-driven web service template with custom resource": {
inVars: packageSvcVars{
appName: "ecs-kudos",
name: "api",
envName: "test",
tag: "1234",
clientConfigured: true,
},
setupMocks: func(m *svcPackageExecuteMock) {
m.ws.EXPECT().ReadWorkloadManifest("api").Return([]byte(rdwsMft), nil)
m.interpolator.EXPECT().Interpolate(rdwsMft).Return(rdwsMft, nil)
m.generator.EXPECT().AddonsTemplate().Return("", nil)
m.envFeaturesDescriber.EXPECT().Version().Return("v1.mock", nil)
m.mft = &mockWorkloadMft{
mockRequiredEnvironmentFeatures: func() []string {
return []string{}
},
}
m.envFeaturesDescriber.EXPECT().AvailableFeatures().Return([]string{}, nil)
m.generator.EXPECT().GenerateCloudFormationTemplate(&deploy.GenerateCloudFormationTemplateInput{
StackRuntimeConfiguration: deploy.StackRuntimeConfiguration{
RootUserARN: mockARN,
},
}).Return(&deploy.GenerateCloudFormationTemplateOutput{
Template: "mystack",
Parameters: "myparams",
}, nil)
},
wantedStack: "mystack",
wantedParams: "myparams",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
stackBuf := new(bytes.Buffer)
paramsBuf := new(bytes.Buffer)
addonsBuf := new(bytes.Buffer)
diffBuff := new(bytes.Buffer)
m := &svcPackageExecuteMock{
ws: mocks.NewMockwsWlDirReader(ctrl),
generator: mocks.NewMockworkloadStackGenerator(ctrl),
interpolator: mocks.NewMockinterpolator(ctrl),
envFeaturesDescriber: mocks.NewMockversionCompatibilityChecker(ctrl),
}
tc.setupMocks(m)
opts := &packageSvcOpts{
packageSvcVars: tc.inVars,
templateWriter: mockWriteCloser{w: stackBuf},
paramsWriter: mockWriteCloser{w: paramsBuf},
addonsWriter: mockWriteCloser{w: addonsBuf},
diffWriter: mockWriteCloser{w: diffBuff},
unmarshal: func(b []byte) (manifest.DynamicWorkload, error) {
return m.mft, nil
},
rootUserARN: mockARN,
ws: m.ws,
newInterpolator: func(_, _ string) interpolator {
return m.interpolator
},
newStackGenerator: func(_ *packageSvcOpts) (workloadStackGenerator, error) {
return m.generator, nil
},
envFeaturesDescriber: m.envFeaturesDescriber,
targetApp: &config.Application{},
targetEnv: &config.Environment{},
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedErr != nil {
require.Equal(t, err, tc.wantedErr)
} else {
require.NoError(t, err)
}
require.Equal(t, stackBuf.String(), tc.wantedStack)
require.Equal(t, paramsBuf.String(), tc.wantedParams)
require.Equal(t, addonsBuf.String(), tc.wantedAddons)
require.Equal(t, diffBuff.String(), tc.wantedDiff)
})
}
}
| 372 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/aws/apprunner"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
svcPauseAppNamePrompt = "Which application is the service in?"
svcPauseNamePrompt = "Which service of %s would you like to pause?"
svcPauseSvcNameHelpPrompt = "The selected service will be paused."
fmtSvcPauseStart = "Pausing service %s in environment %s."
fmtsvcPauseFailed = "Failed to pause service %s in environment %s.\n"
fmtSvcPauseSucceed = "Paused service %s in environment %s.\n"
fmtSvcPauseConfirmPrompt = "Are you sure you want to stop processing requests for service %s?"
)
type svcPauseVars struct {
svcName string
envName string
appName string
skipConfirmation bool
}
type svcPauseOpts struct {
svcPauseVars
store store
prompt prompter
sel deploySelector
client servicePauser
initSvcPause func() error
svcARN string
prog progress
// cached variables.
targetEnv *config.Environment
}
func newSvcPauseOpts(vars svcPauseVars) (*svcPauseOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc pause"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, configStore)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
prompter := prompt.New()
opts := &svcPauseOpts{
svcPauseVars: vars,
store: configStore,
prompt: prompter,
sel: selector.NewDeploySelect(prompt.New(), configStore, deployStore),
prog: termprogress.NewSpinner(log.DiagnosticWriter),
}
opts.initSvcPause = func() error {
env, err := opts.getTargetEnv()
if err != nil {
return err
}
wl, err := configStore.GetWorkload(opts.appName, opts.svcName)
if err != nil {
return fmt.Errorf("get workload: %w", err)
}
if wl.Type != manifestinfo.RequestDrivenWebServiceType {
return fmt.Errorf("pausing a service is only supported for services with type: %s", manifestinfo.RequestDrivenWebServiceType)
}
sess, err := sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
opts.client = apprunner.New(sess)
d, err := describe.NewRDWebServiceDescriber(describe.NewServiceConfig{
App: opts.appName,
Svc: opts.svcName,
ConfigStore: opts.store,
})
if err != nil {
return err
}
opts.svcARN, err = d.ServiceARN(opts.envName)
if err != nil {
return fmt.Errorf("retrieve ServiceARN for %s: %w", opts.svcName, err)
}
return nil
}
return opts, nil
}
// Validate returns an error for any invalid optional flags.
func (o *svcPauseOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *svcPauseOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
if err := o.validateAndAskSvcEnvName(); err != nil {
return err
}
if o.skipConfirmation {
return nil
}
pauseConfirmed, err := o.prompt.Confirm(fmt.Sprintf(fmtSvcPauseConfirmPrompt, color.HighlightUserInput(o.svcName)), "", prompt.WithConfirmFinalMessage())
if err != nil {
return fmt.Errorf("svc pause confirmation prompt: %w", err)
}
if !pauseConfirmed {
return errors.New("svc pause cancelled - no changes made")
}
return nil
}
func (o *svcPauseOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.store.GetApplication(o.appName)
return err
}
app, err := o.sel.Application(svcPauseAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *svcPauseOpts) validateAndAskSvcEnvName() error {
if o.envName != "" {
if _, err := o.getTargetEnv(); err != nil {
return err
}
}
if o.svcName != "" {
if _, err := o.store.GetService(o.appName, o.svcName); err != nil {
return err
}
}
// Note: we let prompter handle the case when there is only option for user to choose from.
// This is naturally the case when `o.envName != "" && o.svcName != ""`.
deployedService, err := o.sel.DeployedService(
fmt.Sprintf(svcPauseNamePrompt, color.HighlightUserInput(o.appName)),
svcPauseSvcNameHelpPrompt,
o.appName,
selector.WithEnv(o.envName),
selector.WithName(o.svcName),
selector.WithServiceTypesFilter([]string{manifestinfo.RequestDrivenWebServiceType}),
)
if err != nil {
return fmt.Errorf("select deployed services for application %s: %w", o.appName, err)
}
o.svcName = deployedService.Name
o.envName = deployedService.Env
return nil
}
// Execute pause the running App Runner service.
func (o *svcPauseOpts) Execute() error {
if err := o.initSvcPause(); err != nil {
return err
}
log.Warningln("Your service will be unavailable while paused. You can resume the service once the pause operation is complete.")
o.prog.Start(fmt.Sprintf(fmtSvcPauseStart, o.svcName, o.envName))
err := o.client.PauseService(o.svcARN)
if err != nil {
o.prog.Stop(log.Serrorf(fmtsvcPauseFailed, o.svcName, o.envName))
return err
}
o.prog.Stop(log.Ssuccessf(fmtSvcPauseSucceed, o.svcName, o.envName))
return nil
}
func (o *svcPauseOpts) getTargetEnv() (*config.Environment, error) {
if o.targetEnv != nil {
return o.targetEnv, nil
}
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, fmt.Errorf("get environment: %w", err)
}
o.targetEnv = env
return o.targetEnv, nil
}
// RecommendActions returns follow-up actions the user can take after successfully executing the command.
func (o *svcPauseOpts) RecommendActions() error {
logRecommendedActions([]string{
fmt.Sprintf("Run %s to start processing requests again.", color.HighlightCode(fmt.Sprintf("copilot svc resume -n %s", o.svcName))),
})
return nil
}
// buildSvcPauseCmd builds the command for pausing the running service.
func buildSvcPauseCmd() *cobra.Command {
vars := svcPauseVars{}
cmd := &cobra.Command{
Use: "pause",
Short: "Pause running App Runner service.",
Long: "Pause running App Runner service.",
Example: `
Pause running App Runner service "my-svc".
/code $ copilot svc pause -n my-svc`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newSvcPauseOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.svcName, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
return cmd
}
| 249 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
)
func TestSvcPause_Validate(t *testing.T) {
// NOTE: No optional flag to `copilot svc pause` needs to be validated.
}
type svcPauseAskMock struct {
store *mocks.Mockstore
sel *mocks.MockdeploySelector
prompt *mocks.Mockprompter
}
func TestSvcPause_Ask(t *testing.T) {
const (
inputApp = "my-app"
inputEnv = "my-env"
inputSvc = "my-svc"
)
mockError := errors.New("some error")
testCases := map[string]struct {
inputApp string
inputSvc string
inputEnvironment string
skipConfirmation bool
setupMocks func(m svcPauseAskMock)
mockSelector func(m *mocks.MockdeploySelector)
mockPrompt func(m *mocks.Mockprompter)
wantedApp string
wantedEnv string
wantedSvc string
wantedError error
}{
"validate app env and svc with all flags passed in": {
inputApp: inputApp,
inputSvc: inputSvc,
inputEnvironment: inputEnv,
skipConfirmation: true,
setupMocks: func(m svcPauseAskMock) {
gomock.InOrder(
m.store.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil),
m.store.EXPECT().GetEnvironment("my-app", "my-env").Return(&config.Environment{Name: "my-env"}, nil),
m.store.EXPECT().GetService("my-app", "my-svc").Return(&config.Workload{}, nil),
)
m.sel.EXPECT().DeployedService(fmt.Sprintf(svcPauseNamePrompt, inputApp), svcPauseSvcNameHelpPrompt, "my-app", gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil) // Let prompter handles the case when svc(env) is definite.
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"prompt for app name": {
inputSvc: inputSvc,
inputEnvironment: inputEnv,
skipConfirmation: true,
setupMocks: func(m svcPauseAskMock) {
m.sel.EXPECT().Application(svcPauseAppNamePrompt, wkldAppNameHelpPrompt).Return("my-app", nil)
m.store.EXPECT().GetApplication(gomock.Any()).Times(0)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil).AnyTimes()
m.prompt.EXPECT().Confirm(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"errors if failed to select application": {
skipConfirmation: true,
setupMocks: func(m svcPauseAskMock) {
m.sel.EXPECT().Application(svcPauseAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error"))
},
wantedError: fmt.Errorf("select application: some error"),
},
"prompt for svc and env": {
inputApp: "my-app",
skipConfirmation: true,
setupMocks: func(m svcPauseAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(fmt.Sprintf(svcPauseNamePrompt, inputApp), svcPauseSvcNameHelpPrompt, "my-app", gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
"errors if failed to select deployed service": {
inputApp: inputApp,
skipConfirmation: true,
setupMocks: func(m svcPauseAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(fmt.Sprintf(svcPauseNamePrompt, inputApp), svcPauseSvcNameHelpPrompt, inputApp, gomock.Any(), gomock.Any(), gomock.Any()).
Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("select deployed services for application my-app: some error"),
},
"should wrap error returned from prompter confirmation": {
inputApp: "mockApp",
inputSvc: "mockSvc",
inputEnvironment: "mockEnv",
skipConfirmation: false,
setupMocks: func(m svcPauseAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil)
m.prompt.EXPECT().Confirm("Are you sure you want to stop processing requests for service my-svc?", "", gomock.Any()).
Times(1).Return(true, mockError)
},
wantedError: fmt.Errorf("svc pause confirmation prompt: %w", mockError),
},
"should return error if user doesn't confirm svc pause": {
inputApp: "mockApp",
inputSvc: "mockSvc",
inputEnvironment: "mockEnv",
skipConfirmation: false,
setupMocks: func(m svcPauseAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil)
m.prompt.EXPECT().Confirm("Are you sure you want to stop processing requests for service my-svc?", "", gomock.Any()).
Times(1).Return(false, nil)
},
wantedError: errors.New("svc pause cancelled - no changes made"),
},
"user confirms svc pause": {
inputApp: inputApp,
inputSvc: inputSvc,
inputEnvironment: inputEnv,
skipConfirmation: false,
setupMocks: func(m svcPauseAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "my-env",
Name: "my-svc",
}, nil)
m.prompt.EXPECT().Confirm("Are you sure you want to stop processing requests for service my-svc?", "", gomock.Any()).
Times(1).Return(true, nil)
},
wantedApp: inputApp,
wantedEnv: inputEnv,
wantedSvc: inputSvc,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := svcPauseAskMock{
store: mocks.NewMockstore(ctrl),
sel: mocks.NewMockdeploySelector(ctrl),
prompt: mocks.NewMockprompter(ctrl),
}
tc.setupMocks(m)
svcPause := &svcPauseOpts{
svcPauseVars: svcPauseVars{
skipConfirmation: tc.skipConfirmation,
svcName: tc.inputSvc,
envName: tc.inputEnvironment,
appName: tc.inputApp,
},
sel: m.sel,
prompt: m.prompt,
store: m.store,
}
// WHEN
err := svcPause.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, svcPause.appName, "expected app name to match")
require.Equal(t, tc.wantedSvc, svcPause.svcName, "expected service name to match")
require.Equal(t, tc.wantedEnv, svcPause.envName, "expected service name to match")
}
})
}
}
func TestSvcPause_Execute(t *testing.T) {
mockError := errors.New("some error")
testCases := map[string]struct {
mocking func(t *testing.T, mockPauser *mocks.MockservicePauser, mockProgress *mocks.Mockprogress)
wantedError error
}{
"errors if failed to pause the service": {
mocking: func(t *testing.T, mockPauser *mocks.MockservicePauser, mockProgress *mocks.Mockprogress) {
mockProgress.EXPECT().Start("Pausing service mock-svc in environment mock-env.")
mockPauser.EXPECT().PauseService("mock-svc-arn").Return(mockError)
mockProgress.EXPECT().Stop(log.Serrorf("Failed to pause service mock-svc in environment mock-env.\n"))
},
wantedError: fmt.Errorf("some error"),
},
"success": {
mocking: func(t *testing.T, mockPauser *mocks.MockservicePauser, mockProgress *mocks.Mockprogress) {
mockProgress.EXPECT().Start("Pausing service mock-svc in environment mock-env.")
mockPauser.EXPECT().PauseService("mock-svc-arn").Return(nil)
mockProgress.EXPECT().Stop(log.Ssuccessf("Paused service mock-svc in environment mock-env.\n"))
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
mockServicePauser := mocks.NewMockservicePauser(ctrl)
mockProgress := mocks.NewMockprogress(ctrl)
tc.mocking(t, mockServicePauser, mockProgress)
svcPause := &svcPauseOpts{
svcPauseVars: svcPauseVars{
svcName: "mock-svc",
envName: "mock-env",
appName: "mock-app",
},
svcARN: "mock-svc-arn",
store: mockStore,
client: mockServicePauser,
prog: mockProgress,
initSvcPause: func() error { return nil },
}
// WHEN
err := svcPause.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 289 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/aws/apprunner"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
svcResumeSvcNamePrompt = "Which service of %s would you like to resume?"
svcResumeSvcNameHelpPrompt = "The selected service will be resumed."
fmtSvcResumeStarted = "Resuming service %s in environment %s."
fmtSvcResumeFailed = "Failed to resume service %s in environment %s: %v\n"
fmtSvcResumeSuccess = "Resumed service %s in environment %s.\n"
)
type resumeSvcVars struct {
appName string
svcName string
envName string
}
type resumeSvcInitClients func() error
type resumeSvcOpts struct {
resumeSvcVars
store store
serviceResumer serviceResumer
apprunnerDescriber apprunnerServiceDescriber
spinner progress
sel deploySelector
initClients resumeSvcInitClients
}
// Validate returns an error for any invalid optional flags.
func (o *resumeSvcOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *resumeSvcOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
return o.validateAndAskSvcEnvName()
}
// Execute resumes the service through the prompt.
func (o *resumeSvcOpts) Execute() error {
if o.svcName == "" {
return nil
}
if err := o.initClients(); err != nil {
return err
}
svcARN, err := o.apprunnerDescriber.ServiceARN(o.envName)
if err != nil {
return err
}
o.spinner.Start(fmt.Sprintf(fmtSvcResumeStarted, o.svcName, o.envName))
if err := o.serviceResumer.ResumeService(svcARN); err != nil {
o.spinner.Stop(log.Serrorf(fmtSvcResumeFailed, o.svcName, o.envName, err))
return err
}
o.spinner.Stop(log.Ssuccessf(fmtSvcResumeSuccess, o.svcName, o.envName))
return nil
}
func (o *resumeSvcOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.store.GetApplication(o.appName)
return err
}
appName, err := o.sel.Application(svcAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = appName
return nil
}
func (o *resumeSvcOpts) validateAndAskSvcEnvName() error {
if o.envName != "" {
if _, err := o.store.GetEnvironment(o.appName, o.envName); err != nil {
return err
}
}
if o.svcName != "" {
if _, err := o.store.GetService(o.appName, o.svcName); err != nil {
return err
}
}
// Note: we let prompter handle the case when there is only option for user to choose from.
// This is naturally the case when `o.envName != "" && o.svcName != ""`.
deployedService, err := o.sel.DeployedService(
fmt.Sprintf(svcResumeSvcNamePrompt, color.HighlightUserInput(o.appName)),
svcResumeSvcNameHelpPrompt,
o.appName,
selector.WithEnv(o.envName),
selector.WithName(o.svcName),
selector.WithServiceTypesFilter([]string{manifestinfo.RequestDrivenWebServiceType}),
)
if err != nil {
return fmt.Errorf("select deployed service for application %s: %w", o.appName, err)
}
o.svcName = deployedService.Name
o.envName = deployedService.Env
return nil
}
func newResumeSvcOpts(vars resumeSvcVars) (*resumeSvcOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc resume"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, configStore)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
opts := &resumeSvcOpts{
resumeSvcVars: vars,
store: configStore,
sel: selector.NewDeploySelect(prompt.New(), configStore, deployStore),
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
}
opts.initClients = func() error {
var a *apprunner.AppRunner
var d *describe.RDWebServiceDescriber
env, err := configStore.GetEnvironment(opts.appName, opts.envName)
if err != nil {
return fmt.Errorf("get environment: %w", err)
}
svc, err := opts.store.GetService(opts.appName, opts.svcName)
if err != nil {
return err
}
switch svc.Type {
case manifestinfo.RequestDrivenWebServiceType:
sess, err := sessProvider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return err
}
a = apprunner.New(sess)
d, err = describe.NewRDWebServiceDescriber(describe.NewServiceConfig{
App: opts.appName,
Svc: opts.svcName,
ConfigStore: configStore,
})
if err != nil {
return err
}
default:
return fmt.Errorf("invalid service type %s", svc.Type)
}
if err != nil {
return fmt.Errorf("creating describer for service %s in environment %s and application %s: %w", opts.svcName, opts.envName, opts.appName, err)
}
opts.serviceResumer = a
opts.apprunnerDescriber = d
return nil
}
return opts, nil
}
// buildSvcResumeCmd builds the command for resuming services in an application.
func buildSvcResumeCmd() *cobra.Command {
vars := resumeSvcVars{}
cmd := &cobra.Command{
Use: "resume",
Short: "Resumes a paused service.",
Long: "Resumes a paused service.",
Example: `
Resumes the service named "my-svc" in the "test" environment.
/code $ copilot svc resume --name my-svc --env test`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newResumeSvcOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.svcName, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
return cmd
}
| 215 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
)
func TestResumeSvcOpts_Validate(t *testing.T) {
// NOTE: No optional flag to `copilot svc pause` needs to be validated.
}
type svcResumeAskMock struct {
store *mocks.Mockstore
sel *mocks.MockdeploySelector
}
func TestResumeSvcOpts_Ask(t *testing.T) {
const (
testAppName = "phonetool"
testEnvName = "test"
testSvcName = "api"
)
mockError := fmt.Errorf("mockError")
tests := map[string]struct {
skipConfirmation bool
inputSvc string
inputEnv string
inputApp string
setupMocks func(m svcResumeAskMock)
wantedApp string
wantedEnv string
wantedSvc string
wantedError error
}{
"validate app env and svc with all flags passed in": {
inputApp: testAppName,
inputSvc: testSvcName,
inputEnv: testEnvName,
setupMocks: func(m svcResumeAskMock) {
gomock.InOrder(
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil),
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test"}, nil),
m.store.EXPECT().GetService("phonetool", "api").Return(&config.Workload{}, nil),
)
m.sel.EXPECT().DeployedService(fmt.Sprintf(svcResumeSvcNamePrompt, testAppName), svcResumeSvcNameHelpPrompt, "phonetool", gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "test",
Name: "api",
}, nil) // Let prompter handles the case when svc(env) is definite.
},
wantedApp: testAppName,
wantedEnv: testEnvName,
wantedSvc: testSvcName,
},
"prompt for app name": {
inputEnv: testEnvName,
inputSvc: testSvcName,
skipConfirmation: true,
setupMocks: func(m svcResumeAskMock) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("phonetool", nil)
m.store.EXPECT().GetApplication(gomock.Any()).Times(0)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: testEnvName,
Name: testSvcName,
}, nil).AnyTimes()
},
wantedApp: testAppName,
wantedEnv: testEnvName,
wantedSvc: testSvcName,
},
"errors if failed to select application": {
skipConfirmation: true,
setupMocks: func(m svcResumeAskMock) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error"))
},
wantedError: fmt.Errorf("select application: some error"),
},
"prompt for service and env": {
inputApp: testAppName,
inputEnv: "",
inputSvc: "",
skipConfirmation: true,
setupMocks: func(m svcResumeAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService("Which service of phonetool would you like to resume?",
svcResumeSvcNameHelpPrompt, testAppName, gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: testEnvName,
Name: testSvcName,
}, nil)
},
wantedApp: testAppName,
wantedEnv: testEnvName,
wantedSvc: testSvcName,
},
"returns error if fails to select service": {
inputApp: testAppName,
inputEnv: "",
inputSvc: "",
skipConfirmation: true,
setupMocks: func(m svcResumeAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService("Which service of phonetool would you like to resume?",
svcResumeSvcNameHelpPrompt, testAppName, gomock.Any(), gomock.Any(), gomock.Any()).
Return(nil, mockError)
},
wantedError: fmt.Errorf("select deployed service for application phonetool: %w", mockError),
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := svcResumeAskMock{
store: mocks.NewMockstore(ctrl),
sel: mocks.NewMockdeploySelector(ctrl),
}
test.setupMocks(m)
opts := resumeSvcOpts{
resumeSvcVars: resumeSvcVars{
appName: test.inputApp,
svcName: test.inputSvc,
envName: test.inputEnv,
},
sel: m.sel,
store: m.store,
}
err := opts.Ask()
// THEN
if test.wantedError != nil {
require.EqualError(t, err, test.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, test.wantedApp, opts.appName, "expected app name to match")
require.Equal(t, test.wantedSvc, opts.svcName, "expected service name to match")
require.Equal(t, test.wantedEnv, opts.envName, "expected service name to match")
}
})
}
}
type resumeSvcMocks struct {
store *mocks.Mockstore
spinner *mocks.Mockprogress
serviceResumer *mocks.MockserviceResumer
apprunnerDescriber *mocks.MockapprunnerServiceDescriber
}
func TestResumeSvcOpts_Execute(t *testing.T) {
const (
testAppName = "phonetool"
testEnvName = "test"
testSvcName = "phonetool"
testSvcARN = "service-arn"
)
mockError := fmt.Errorf("mockError")
tests := map[string]struct {
appName string
envName string
svcName string
setupMocks func(mocks *resumeSvcMocks)
wantedError error
}{
"happy path": {
appName: testAppName,
envName: testEnvName,
svcName: testSvcName,
setupMocks: func(m *resumeSvcMocks) {
m.apprunnerDescriber.EXPECT().ServiceARN(testEnvName).Return(testSvcARN, nil)
gomock.InOrder(
m.spinner.EXPECT().Start("Resuming service phonetool in environment test."),
m.serviceResumer.EXPECT().ResumeService(testSvcARN).Return(nil),
m.spinner.EXPECT().Stop(log.Ssuccessf("Resumed service phonetool in environment test.\n")),
)
},
wantedError: nil,
},
"return error if fails to retrieve service ARN": {
appName: testAppName,
envName: testEnvName,
svcName: testSvcName,
setupMocks: func(m *resumeSvcMocks) {
m.apprunnerDescriber.EXPECT().ServiceARN(testEnvName).Return("", mockError)
},
wantedError: mockError,
},
"should display failure spinner and return error if ResumeService fails": {
appName: testAppName,
envName: testEnvName,
svcName: testSvcName,
setupMocks: func(m *resumeSvcMocks) {
m.apprunnerDescriber.EXPECT().ServiceARN(testEnvName).Return(testSvcARN, nil)
gomock.InOrder(
m.spinner.EXPECT().Start("Resuming service phonetool in environment test."),
m.serviceResumer.EXPECT().ResumeService(testSvcARN).Return(mockError),
m.spinner.EXPECT().Stop(log.Serrorf("Failed to resume service phonetool in environment test: mockError\n")),
)
},
wantedError: mockError,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
// GIVEN
mockstore := mocks.NewMockstore(ctrl)
mockSpinner := mocks.NewMockprogress(ctrl)
mockserviceResumer := mocks.NewMockserviceResumer(ctrl)
mockapprunnerDescriber := mocks.NewMockapprunnerServiceDescriber(ctrl)
mocks := &resumeSvcMocks{
store: mockstore,
spinner: mockSpinner,
serviceResumer: mockserviceResumer,
apprunnerDescriber: mockapprunnerDescriber,
}
test.setupMocks(mocks)
opts := resumeSvcOpts{
resumeSvcVars: resumeSvcVars{
appName: test.appName,
envName: test.envName,
svcName: test.svcName,
},
store: mockstore,
spinner: mockSpinner,
serviceResumer: mockserviceResumer,
apprunnerDescriber: mockapprunnerDescriber,
initClients: func() error {
return nil
},
}
// WHEN
err := opts.Execute()
// THEN
if test.wantedError != nil {
require.EqualError(t, err, test.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 280 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"io"
"strings"
"unicode"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
svcShowSvcNamePrompt = "Which service of %s would you like to show?"
svcShowSvcNameHelpPrompt = "The details of a service will be shown (e.g., endpoint URL, CPU, Memory)."
)
type showSvcVars struct {
appName string
svcName string
shouldOutputJSON bool
shouldOutputResources bool
outputManifestForEnv string
}
type showSvcOpts struct {
showSvcVars
w io.Writer
store store
describer workloadDescriber
sel configSelector
initDescriber func() error // Overridden in tests.
// Cached variables.
targetSvc *config.Workload
}
func newShowSvcOpts(vars showSvcVars) (*showSvcOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc show"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
ssmStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, ssmStore)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
opts := &showSvcOpts{
showSvcVars: vars,
store: ssmStore,
w: log.OutputWriter,
sel: selector.NewConfigSelector(prompt.New(), ssmStore),
}
opts.initDescriber = func() error {
var d workloadDescriber
svc, err := opts.getTargetSvc()
if err != nil {
return err
}
config := describe.NewServiceConfig{
App: opts.appName,
Svc: opts.svcName,
ConfigStore: ssmStore,
DeployStore: deployStore,
EnableResources: opts.shouldOutputResources,
}
switch svc.Type {
case manifestinfo.LoadBalancedWebServiceType:
d, err = describe.NewLBWebServiceDescriber(config)
case manifestinfo.RequestDrivenWebServiceType:
d, err = describe.NewRDWebServiceDescriber(config)
case manifestinfo.BackendServiceType:
d, err = describe.NewBackendServiceDescriber(config)
case manifestinfo.WorkerServiceType:
d, err = describe.NewWorkerServiceDescriber(config)
case manifestinfo.StaticSiteType:
d, err = describe.NewStaticSiteDescriber(config)
default:
return fmt.Errorf(`service type %q is not supported for %s`, svc.Type, color.HighlightCode("svc show"))
}
if err != nil {
return fmt.Errorf("creating describer for service %s in application %s: %w", opts.svcName, opts.appName, err)
}
opts.describer = d
return nil
}
return opts, nil
}
// Validate returns an error for any invalid optional flags.
func (o *showSvcOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *showSvcOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
return o.validateOrAskSvcName()
}
// Execute shows the services through the prompt.
func (o *showSvcOpts) Execute() error {
if o.svcName == "" {
return nil
}
if err := o.initDescriber(); err != nil {
return err
}
if o.outputManifestForEnv != "" {
return o.writeManifest()
}
svc, err := o.describer.Describe()
if err != nil {
return fmt.Errorf("describe service %s: %w", o.svcName, err)
}
if o.shouldOutputJSON {
data, err := svc.JSONString()
if err != nil {
return err
}
fmt.Fprint(o.w, data)
} else {
fmt.Fprint(o.w, svc.HumanString())
}
return nil
}
func (o *showSvcOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.store.GetApplication(o.appName)
return err
}
appName, err := o.sel.Application(svcAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application name: %w", err)
}
o.appName = appName
return nil
}
func (o *showSvcOpts) validateOrAskSvcName() error {
if o.svcName != "" {
_, err := o.getTargetSvc()
return err
}
svcName, err := o.sel.Service(fmt.Sprintf(svcShowSvcNamePrompt, color.HighlightUserInput(o.appName)),
svcShowSvcNameHelpPrompt, o.appName)
if err != nil {
return fmt.Errorf("select service for application %s: %w", o.appName, err)
}
o.svcName = svcName
return nil
}
func (o *showSvcOpts) getTargetSvc() (*config.Workload, error) {
if o.targetSvc != nil {
return o.targetSvc, nil
}
svc, err := o.store.GetService(o.appName, o.svcName)
if err != nil {
return nil, err
}
o.targetSvc = svc
return o.targetSvc, nil
}
func (o *showSvcOpts) writeManifest() error {
out, err := o.describer.Manifest(o.outputManifestForEnv)
if err != nil {
var errNotFound *describe.ErrManifestNotFoundInTemplate
if errors.As(err, &errNotFound) {
log.Infof("You must deploy a new version of your service before printing its manifest:\n%s\n",
color.HighlightCodeBlock(fmt.Sprintf(" copilot deploy -n %s -e %s", o.svcName, o.outputManifestForEnv)))
}
return fmt.Errorf("fetch manifest for service %q in environment %q: %v", o.svcName, o.outputManifestForEnv, err)
}
fmt.Fprintln(o.w, strings.TrimRightFunc(string(out), unicode.IsSpace))
return nil
}
// buildSvcShowCmd builds the command for showing services in an application.
func buildSvcShowCmd() *cobra.Command {
vars := showSvcVars{}
cmd := &cobra.Command{
Use: "show",
Short: "Shows info about a deployed service per environment.",
Long: "Shows info about a deployed service, including endpoints, capacity and related resources per environment.",
Example: `
Print service configuration in deployed environments.
/code $ copilot svc show -n api
Print manifest file used for deploying service "api" in the "prod" environment.
/code $ copilot svc show -n api --manifest prod`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newShowSvcOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.svcName, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputResources, resourcesFlag, false, svcResourcesFlagDescription)
cmd.Flags().StringVar(&vars.outputManifestForEnv, manifestFlag, "", svcManifestFlagDescription)
cmd.MarkFlagsMutuallyExclusive(jsonFlag, manifestFlag)
cmd.MarkFlagsMutuallyExclusive(resourcesFlag, manifestFlag)
return cmd
}
| 239 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
)
type showSvcMocks struct {
storeSvc *mocks.Mockstore
describer *mocks.MockworkloadDescriber
ws *mocks.MockwsSvcReader
sel *mocks.MockconfigSelector
}
type mockDescribeData struct {
data string
err error
}
func (m *mockDescribeData) HumanString() string {
return m.data
}
func (m *mockDescribeData) JSONString() (string, error) {
return m.data, m.err
}
func TestSvcShow_Validate(t *testing.T) {
// NOTE: no optional flag needs to be validated for this command.
}
func TestSvcShow_Ask(t *testing.T) {
testCases := map[string]struct {
inputApp string
inputSvc string
setupMocks func(mocks showSvcMocks)
wantedApp string
wantedSvc string
wantedError error
}{
"validate instead of prompting application name and svc name": {
inputApp: "my-app",
inputSvc: "my-svc",
setupMocks: func(m showSvcMocks) {
m.storeSvc.EXPECT().GetApplication("my-app").Return(&config.Application{}, nil)
m.storeSvc.EXPECT().GetService("my-app", "my-svc").Return(&config.Workload{}, nil)
},
wantedApp: "my-app",
wantedSvc: "my-svc",
},
"prompt for app name": {
inputSvc: "my-svc",
setupMocks: func(m showSvcMocks) {
m.sel.EXPECT().Application(gomock.Any(), gomock.Any(), gomock.Any()).Return("my-app", nil)
m.storeSvc.EXPECT().GetApplication("my-app").Times(0)
m.storeSvc.EXPECT().GetService("my-app", "my-svc").AnyTimes()
},
wantedApp: "my-app",
wantedSvc: "my-svc",
},
"error when fail to select apps": {
inputSvc: "my-svc",
setupMocks: func(m showSvcMocks) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error"))
},
wantedError: fmt.Errorf("select application name: some error"),
},
"prompt for service name": {
inputApp: "my-app",
setupMocks: func(m showSvcMocks) {
m.sel.EXPECT().Service(fmt.Sprintf(svcShowSvcNamePrompt, "my-app"), svcShowSvcNameHelpPrompt, "my-app").Return("my-svc", nil)
m.storeSvc.EXPECT().GetService("my-app", "my-svc").Times(0)
m.storeSvc.EXPECT().GetApplication("my-app").AnyTimes()
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).AnyTimes()
},
wantedApp: "my-app",
wantedSvc: "my-svc",
},
"error when fail to select services": {
setupMocks: func(m showSvcMocks) {
gomock.InOrder(
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("my-app", nil),
m.sel.EXPECT().Service(fmt.Sprintf(svcShowSvcNamePrompt, "my-app"), svcShowSvcNameHelpPrompt, "my-app").Return("", errors.New("some error")),
)
},
wantedError: fmt.Errorf("select service for application my-app: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mockWorkspace := mocks.NewMockwsSvcReader(ctrl)
mockSelector := mocks.NewMockconfigSelector(ctrl)
mocks := showSvcMocks{
storeSvc: mockStoreReader,
ws: mockWorkspace,
sel: mockSelector,
}
tc.setupMocks(mocks)
showSvcs := &showSvcOpts{
showSvcVars: showSvcVars{
svcName: tc.inputSvc,
appName: tc.inputApp,
},
store: mockStoreReader,
sel: mockSelector,
}
// WHEN
err := showSvcs.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, showSvcs.appName, "expected app name to match")
require.Equal(t, tc.wantedSvc, showSvcs.svcName, "expected service name to match")
}
})
}
}
func TestSvcShow_Execute(t *testing.T) {
appName := "my-app"
webSvc := mockDescribeData{
data: "mockData",
err: errors.New("some error"),
}
testCases := map[string]struct {
inputSvc string
shouldOutputJSON bool
outputManifestForEnv string
setupMocks func(mocks showSvcMocks)
wantedContent string
wantedError error
}{
"noop if service name is empty": {
setupMocks: func(m showSvcMocks) {
m.describer.EXPECT().Describe().Times(0)
},
},
"print configuration by default": {
inputSvc: "my-svc",
setupMocks: func(m showSvcMocks) {
gomock.InOrder(
m.describer.EXPECT().Describe().Return(&webSvc, nil),
)
},
wantedContent: "mockData",
},
"print manifest file trimmed with spaces if --manifest is provided": {
inputSvc: "my-svc",
outputManifestForEnv: "test",
setupMocks: func(m showSvcMocks) {
m.describer.EXPECT().Manifest(gomock.Any()).Return([]byte("name: my-svc\n\n\n "), nil)
},
wantedContent: "name: my-svc\n",
},
"return error if fail to generate JSON output": {
inputSvc: "my-svc",
shouldOutputJSON: true,
setupMocks: func(m showSvcMocks) {
gomock.InOrder(
m.describer.EXPECT().Describe().Return(&webSvc, nil),
)
},
wantedError: fmt.Errorf("some error"),
},
"return error if fail to describe service": {
inputSvc: "my-svc",
setupMocks: func(m showSvcMocks) {
gomock.InOrder(
m.describer.EXPECT().Describe().Return(nil, errors.New("some error")),
)
},
wantedError: fmt.Errorf("describe service my-svc: some error"),
},
"return wrapped error if --manifest is provided and stack cannot be retrieved": {
inputSvc: "my-svc",
outputManifestForEnv: "test",
setupMocks: func(m showSvcMocks) {
m.describer.EXPECT().Manifest(gomock.Any()).Return(nil, errors.New("some error"))
},
wantedError: errors.New(`fetch manifest for service "my-svc" in environment "test": some error`),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
b := &bytes.Buffer{}
mockSvcDescriber := mocks.NewMockworkloadDescriber(ctrl)
mocks := showSvcMocks{
describer: mockSvcDescriber,
}
tc.setupMocks(mocks)
showSvcs := &showSvcOpts{
showSvcVars: showSvcVars{
appName: appName,
svcName: tc.inputSvc,
shouldOutputJSON: tc.shouldOutputJSON,
outputManifestForEnv: tc.outputManifestForEnv,
},
describer: mockSvcDescriber,
initDescriber: func() error { return nil },
w: b,
}
// WHEN
err := showSvcs.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedContent, b.String(), "expected output content match")
}
})
}
}
| 258 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"io"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
svcStatusNamePrompt = "Which service's status would you like to show?"
svcStatusNameHelpPrompt = "Displays the service's task status, most recent deployment and alarm statuses."
)
type svcStatusVars struct {
shouldOutputJSON bool
svcName string
envName string
appName string
}
type svcStatusOpts struct {
svcStatusVars
w io.Writer
store store
statusDescriber statusDescriber
sel deploySelector
initStatusDescriber func(*svcStatusOpts) error
}
func newSvcStatusOpts(vars svcStatusVars) (*svcStatusOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("svc status"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
configStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
deployStore, err := deploy.NewStore(sessProvider, configStore)
if err != nil {
return nil, fmt.Errorf("connect to deploy store: %w", err)
}
return &svcStatusOpts{
svcStatusVars: vars,
store: configStore,
w: log.OutputWriter,
sel: selector.NewDeploySelect(prompt.New(), configStore, deployStore),
initStatusDescriber: func(o *svcStatusOpts) error {
wkld, err := configStore.GetWorkload(o.appName, o.svcName)
if err != nil {
return fmt.Errorf("retrieve %s from application %s: %w", o.appName, o.svcName, err)
}
switch wkld.Type {
case manifestinfo.RequestDrivenWebServiceType:
d, err := describe.NewAppRunnerStatusDescriber(&describe.NewServiceStatusConfig{
App: o.appName,
Env: o.envName,
Svc: o.svcName,
ConfigStore: configStore,
})
if err != nil {
return fmt.Errorf("create status describer for App Runner service %s in application %s: %w", o.svcName, o.appName, err)
}
o.statusDescriber = d
case manifestinfo.StaticSiteType:
d, err := describe.NewStaticSiteStatusDescriber(&describe.NewServiceStatusConfig{
App: o.appName,
Env: o.envName,
Svc: o.svcName,
ConfigStore: configStore,
})
if err != nil {
return fmt.Errorf("create status describer for Static Site service %s in application %s: %w", o.svcName, o.appName, err)
}
o.statusDescriber = d
default:
d, err := describe.NewECSStatusDescriber(&describe.NewServiceStatusConfig{
App: o.appName,
Env: o.envName,
Svc: o.svcName,
ConfigStore: configStore,
})
if err != nil {
return fmt.Errorf("create status describer for service %s in application %s: %w", o.svcName, o.appName, err)
}
o.statusDescriber = d
}
return nil
},
}, nil
}
// Validate returns an error for any invalid optional flags.
func (o *svcStatusOpts) Validate() error {
return nil
}
// Ask prompts for and validates any required flags.
func (o *svcStatusOpts) Ask() error {
if err := o.validateOrAskApp(); err != nil {
return err
}
return o.validateAndAskSvcEnvName()
}
// Execute displays the status of the service.
func (o *svcStatusOpts) Execute() error {
err := o.initStatusDescriber(o)
if err != nil {
return err
}
svcStatus, err := o.statusDescriber.Describe()
if err != nil {
return fmt.Errorf("describe status of service %s: %w", o.svcName, err)
}
if o.shouldOutputJSON {
data, err := svcStatus.JSONString()
if err != nil {
return err
}
fmt.Fprint(o.w, data)
} else {
fmt.Fprint(o.w, svcStatus.HumanString())
}
return nil
}
func (o *svcStatusOpts) validateOrAskApp() error {
if o.appName != "" {
_, err := o.store.GetApplication(o.appName)
return err
}
app, err := o.sel.Application(svcAppNamePrompt, wkldAppNameHelpPrompt)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
o.appName = app
return nil
}
func (o *svcStatusOpts) validateAndAskSvcEnvName() error {
if o.envName != "" {
if _, err := o.store.GetEnvironment(o.appName, o.envName); err != nil {
return err
}
}
if o.svcName != "" {
if _, err := o.store.GetService(o.appName, o.svcName); err != nil {
return err
}
}
// Note: we let prompter handle the case when there is only option for user to choose from.
// This is naturally the case when `o.envName != "" && o.svcName != ""`.
deployedService, err := o.sel.DeployedService(svcStatusNamePrompt, svcStatusNameHelpPrompt, o.appName, selector.WithEnv(o.envName), selector.WithName(o.svcName))
if err != nil {
return fmt.Errorf("select deployed services for application %s: %w", o.appName, err)
}
o.svcName = deployedService.Name
o.envName = deployedService.Env
return nil
}
// buildSvcStatusCmd builds the command for showing the status of a deployed service.
func buildSvcStatusCmd() *cobra.Command {
vars := svcStatusVars{}
cmd := &cobra.Command{
Use: "status",
Short: "Shows status of a deployed service.",
Long: "Shows status of a deployed service's task status, most recent deployment and alarm statuses.",
Example: `
Shows status of the deployed service "my-svc"
/code $ copilot svc status -n my-svc`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newSvcStatusOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.svcName, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().BoolVar(&vars.shouldOutputJSON, jsonFlag, false, jsonFlagDescription)
return cmd
}
| 206 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"errors"
"fmt"
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
)
func TestSvcStatus_Validate(t *testing.T) {
// NOTE: No optional flag to `copilot svc pause` needs to be validated.
}
type svcStatusAskMock struct {
store *mocks.Mockstore
sel *mocks.MockdeploySelector
}
func TestSvcStatus_Ask(t *testing.T) {
const (
testAppName = "phonetool"
testEnvName = "test"
testSvcName = "api"
)
mockError := errors.New("some error")
testCases := map[string]struct {
inputApp string
inputSvc string
inputEnv string
setupMocks func(m svcStatusAskMock)
wantedApp string
wantedEnv string
wantedSvc string
wantedError error
}{
"validate app env and svc with all flags passed in": {
inputApp: testAppName,
inputSvc: testSvcName,
inputEnv: testEnvName,
setupMocks: func(m svcStatusAskMock) {
gomock.InOrder(
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil),
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test"}, nil),
m.store.EXPECT().GetService("phonetool", "api").Return(&config.Workload{}, nil),
)
m.sel.EXPECT().DeployedService(svcStatusNamePrompt, svcStatusNameHelpPrompt, "phonetool", gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: "test",
Name: "api",
}, nil) // Let prompter handles the case when svc(env) is definite.
},
wantedApp: testAppName,
wantedEnv: testEnvName,
wantedSvc: testSvcName,
},
"prompt for app name": {
inputEnv: testEnvName,
inputSvc: testSvcName,
setupMocks: func(m svcStatusAskMock) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("phonetool", nil)
m.store.EXPECT().GetApplication(gomock.Any()).Times(0)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).AnyTimes()
m.sel.EXPECT().DeployedService(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: testEnvName,
Name: testSvcName,
}, nil).AnyTimes()
},
wantedApp: testAppName,
wantedEnv: testEnvName,
wantedSvc: testSvcName,
},
"errors if failed to select application": {
setupMocks: func(m svcStatusAskMock) {
m.sel.EXPECT().Application(svcAppNamePrompt, wkldAppNameHelpPrompt).Return("", errors.New("some error"))
},
wantedError: fmt.Errorf("select application: some error"),
},
"prompt for service and env": {
inputApp: testAppName,
setupMocks: func(m svcStatusAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(svcStatusNamePrompt, svcStatusNameHelpPrompt, testAppName, gomock.Any(), gomock.Any()).
Return(&selector.DeployedService{
Env: testEnvName,
Name: testSvcName,
}, nil)
},
wantedApp: testAppName,
wantedEnv: testEnvName,
wantedSvc: testSvcName,
},
"errors if failed to select deployed service": {
inputApp: "mockApp",
setupMocks: func(m svcStatusAskMock) {
m.store.EXPECT().GetApplication(gomock.Any()).AnyTimes()
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.store.EXPECT().GetService(gomock.Any(), gomock.Any()).Times(0)
m.sel.EXPECT().DeployedService(svcStatusNamePrompt, svcStatusNameHelpPrompt, "mockApp", gomock.Any(), gomock.Any()).Return(nil, mockError)
},
wantedError: fmt.Errorf("select deployed services for application mockApp: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := svcStatusAskMock{
store: mocks.NewMockstore(ctrl),
sel: mocks.NewMockdeploySelector(ctrl),
}
tc.setupMocks(m)
svcStatus := &svcStatusOpts{
svcStatusVars: svcStatusVars{
svcName: tc.inputSvc,
envName: tc.inputEnv,
appName: tc.inputApp,
},
sel: m.sel,
store: m.store,
}
// WHEN
err := svcStatus.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedApp, svcStatus.appName, "expected app name to match")
require.Equal(t, tc.wantedSvc, svcStatus.svcName, "expected service name to match")
require.Equal(t, tc.wantedEnv, svcStatus.envName, "expected service name to match")
}
})
}
}
func TestSvcStatus_Execute(t *testing.T) {
mockError := errors.New("some error")
testCases := map[string]struct {
shouldOutputJSON bool
mockStatusDescriber func(m *mocks.MockstatusDescriber)
wantedError error
}{
"errors if failed to describe the status of the service": {
mockStatusDescriber: func(m *mocks.MockstatusDescriber) {
m.EXPECT().Describe().Return(nil, mockError)
},
wantedError: fmt.Errorf("describe status of service mockSvc: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
b := &bytes.Buffer{}
mockStatusDescriber := mocks.NewMockstatusDescriber(ctrl)
tc.mockStatusDescriber(mockStatusDescriber)
svcStatus := &svcStatusOpts{
svcStatusVars: svcStatusVars{
svcName: "mockSvc",
envName: "mockEnv",
shouldOutputJSON: tc.shouldOutputJSON,
appName: "mockApp",
},
statusDescriber: mockStatusDescriber,
initStatusDescriber: func(*svcStatusOpts) error { return nil },
w: b,
}
// WHEN
err := svcStatus.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.NotEmpty(t, b.String(), "expected output content to not be empty")
}
})
}
}
| 205 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/spf13/cobra"
)
// BuildTaskCmd is the top level command for task.
func BuildTaskCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "task",
Short: `Commands for tasks.
One-off Amazon ECS tasks that terminate once their work is done.`,
}
cmd.AddCommand(BuildTaskRunCmd())
cmd.AddCommand(buildTaskExecCmd())
cmd.AddCommand(BuildTaskDeleteCmd())
cmd.SetUsageTemplate(template.Usage)
cmd.Annotations = map[string]string{
"group": group.Develop,
}
return cmd
}
| 30 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"os"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/spf13/afero"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
awscfn "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/ecr"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/cobra"
)
const (
taskDeleteNamePrompt = "Which task would you like to delete?"
taskDeleteAppPrompt = "Which application would you like to delete a task from?"
taskDeleteEnvPrompt = "Which environment would you like to delete a task from?"
fmtTaskDeleteDefaultConfirmPrompt = "Are you sure you want to delete %s from the default cluster?"
fmtTaskDeleteFromEnvConfirmPrompt = "Are you sure you want to delete %s from application %s and environment %s?"
taskDeleteConfirmHelp = "This will delete the task's stack and stop all current executions."
)
var errTaskDeleteCancelled = errors.New("task delete cancelled - no changes made")
type deleteTaskVars struct {
name string
app string
env string
skipConfirmation bool
defaultCluster bool
}
type deleteTaskOpts struct {
deleteTaskVars
wsAppName string
// Dependencies to interact with other modules
store store
prompt prompter
spinner progress
provider sessionProvider
sel wsSelector
// Generators for env-specific clients
newTaskSel func(session *session.Session) cfTaskSelector
newTaskStopper func(session *session.Session) taskStopper
newImageRemover func(session *session.Session) imageRemover
newBucketEmptier func(session *session.Session) bucketEmptier
newStackManager func(session *session.Session) taskStackManager
// Cached variables
session *session.Session
stackInfo *deploy.TaskStackInfo
}
func newDeleteTaskOpts(vars deleteTaskVars) (*deleteTaskOpts, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("task delete"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompter := prompt.New()
return &deleteTaskOpts{
deleteTaskVars: vars,
wsAppName: tryReadingAppName(),
store: store,
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
prompt: prompter,
provider: sessProvider,
sel: selector.NewLocalWorkloadSelector(prompter, store, ws),
newTaskSel: func(session *session.Session) cfTaskSelector {
cfn := cloudformation.New(session, cloudformation.WithProgressTracker(os.Stderr))
return selector.NewCFTaskSelect(prompter, store, cfn)
},
newTaskStopper: func(session *session.Session) taskStopper {
return ecs.New(session)
},
newStackManager: func(session *session.Session) taskStackManager {
return cloudformation.New(session, cloudformation.WithProgressTracker(os.Stderr))
},
newImageRemover: func(session *session.Session) imageRemover {
return ecr.New(session)
},
newBucketEmptier: func(session *session.Session) bucketEmptier {
return s3.New(session)
},
}, nil
}
// Validate checks that flag inputs are valid.
func (o *deleteTaskOpts) Validate() error {
if o.name != "" {
if err := basicNameValidation(o.name); err != nil {
return err
}
}
// If default flag specified,
if err := o.validateFlagsWithDefaultCluster(); err != nil {
return err
}
if err := o.validateFlagsWithEnv(); err != nil {
return err
}
return nil
}
func (o *deleteTaskOpts) validateFlagsWithEnv() error {
if o.app != "" {
if _, err := o.store.GetApplication(o.app); err != nil {
return fmt.Errorf("get application: %w", err)
}
}
if o.app != "" && o.env != "" {
if _, err := o.store.GetEnvironment(o.app, o.env); err != nil {
return fmt.Errorf("get environment: %w", err)
}
if err := o.validateTaskName(); err != nil {
return fmt.Errorf("get task: %w", err)
}
}
return nil
}
func (o *deleteTaskOpts) validateTaskName() error {
if o.name != "" {
// If fully specified, validate that the stack exists and is a task.
// This check prevents the command from stopping arbitrary tasks or emptying arbitrary ECR
// repositories.
_, err := o.getTaskInfo()
if err != nil {
return err
}
}
return nil
}
func (o *deleteTaskOpts) validateFlagsWithDefaultCluster() error {
if !o.defaultCluster {
return nil
}
// If app is specified and the same as the workspace app, don't throw an error.
// If app is not the same as the workspace app, either
// a) there is no WS app and it's specified erroneously, in which case we should error
// b) there is a WS app and the flag has been set to a different app, in which case we should error.
// The app flag defaults to the WS app so there's an edge case where it's possible to specify
// `copilot task delete --app ws-app --default` and not error out, but this should be taken as
// specifying "default".
if o.app != o.wsAppName {
return fmt.Errorf("cannot specify both `--app` and `--default`")
}
if o.env != "" {
return fmt.Errorf("cannot specify both `--env` and `--default`")
}
if err := o.validateTaskName(); err != nil {
return fmt.Errorf("get task: %w", err)
}
return nil
}
func (o *deleteTaskOpts) askAppName() error {
if o.defaultCluster {
return nil
}
if o.app != "" {
return nil
}
app, err := o.sel.Application(taskDeleteAppPrompt, "", appEnvOptionNone)
if err != nil {
return fmt.Errorf("select application name: %w", err)
}
if app == appEnvOptionNone {
o.env = ""
o.defaultCluster = true
return nil
}
o.app = app
return nil
}
func (o *deleteTaskOpts) askEnvName() error {
if o.defaultCluster {
return nil
}
if o.env != "" {
return nil
}
env, err := o.sel.Environment(taskDeleteEnvPrompt, "", o.app, appEnvOptionNone)
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
if env == appEnvOptionNone {
o.env = ""
o.app = ""
o.defaultCluster = true
return nil
}
o.env = env
return nil
}
// Ask prompts for missing information and fills in gaps.
func (o *deleteTaskOpts) Ask() error {
if err := o.askAppName(); err != nil {
return err
}
if err := o.askEnvName(); err != nil {
return err
}
if err := o.askTaskName(); err != nil {
return err
}
if o.skipConfirmation {
return nil
}
// Confirm deletion
deletePrompt := fmt.Sprintf(fmtTaskDeleteDefaultConfirmPrompt, color.HighlightUserInput(o.name))
if o.env != "" && o.app != "" {
deletePrompt = fmt.Sprintf(
fmtTaskDeleteFromEnvConfirmPrompt,
color.HighlightUserInput(o.name),
color.HighlightUserInput(o.app),
color.HighlightUserInput(o.env),
)
}
deleteConfirmed, err := o.prompt.Confirm(
deletePrompt,
taskDeleteConfirmHelp,
prompt.WithConfirmFinalMessage())
if err != nil {
return fmt.Errorf("task delete confirmation prompt: %w", err)
}
if !deleteConfirmed {
return errTaskDeleteCancelled
}
return nil
}
func (o *deleteTaskOpts) getSession() (*session.Session, error) {
if o.session != nil {
return o.session, nil
}
if o.defaultCluster {
sess, err := o.provider.Default()
if err != nil {
return nil, err
}
o.session = sess
return sess, nil
}
// Get environment manager role for deleting stack.
env, err := o.store.GetEnvironment(o.app, o.env)
if err != nil {
return nil, err
}
sess, err := o.provider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return nil, err
}
o.session = sess
return sess, nil
}
func (o *deleteTaskOpts) askTaskName() error {
if o.name != "" {
return nil
}
sess, err := o.getSession()
if err != nil {
return fmt.Errorf("get task select session: %w", err)
}
sel := o.newTaskSel(sess)
if o.defaultCluster {
task, err := sel.Task(taskDeleteNamePrompt, "", selector.TaskWithDefaultCluster())
if err != nil {
return fmt.Errorf("select task from default cluster: %w", err)
}
o.name = task
return nil
}
task, err := sel.Task(taskDeleteNamePrompt, "", selector.TaskWithAppEnv(o.app, o.env))
if err != nil {
return fmt.Errorf("select task from environment: %w", err)
}
o.name = task
return nil
}
func (o *deleteTaskOpts) Execute() error {
if err := o.stopTasks(); err != nil {
return err
}
if err := o.clearECRRepository(); err != nil {
return err
}
if err := o.deleteStack(); err != nil {
return err
}
return nil
}
func (o *deleteTaskOpts) stopTasks() error {
sess, err := o.getSession()
if err != nil {
return fmt.Errorf("get session: %w", err)
}
o.spinner.Start(fmt.Sprintf("Stopping all running tasks in family %s.", color.HighlightUserInput(o.name)))
// Stop tasks.
if o.defaultCluster {
if err = o.newTaskStopper(sess).StopDefaultClusterTasks(o.name); err != nil {
o.spinner.Stop(log.Serrorln("Error stopping running tasks in default cluster."))
return fmt.Errorf("stop running tasks in family %s: %w", o.name, err)
}
} else {
if err = o.newTaskStopper(sess).StopOneOffTasks(o.app, o.env, o.name); err != nil {
o.spinner.Stop(log.Serrorln("Error stopping running tasks in environment."))
return fmt.Errorf("stop running tasks in family %s: %w", o.name, err)
}
}
o.spinner.Stop(log.Ssuccessf("Stopped all running tasks in family %s.\n", color.HighlightUserInput(o.name)))
return nil
}
func (o *deleteTaskOpts) clearECRRepository() error {
// ECR Deletion happens from the default profile in app delete. We can do it here too by getting
// a default session in whichever region we're deleting from.
var defaultSess *session.Session
var err error
defaultSess, err = o.getSession()
if err != nil {
return err
}
if !o.defaultCluster {
regionalSession, err := o.getSession()
if err != nil {
return err
}
defaultSess, err = o.provider.DefaultWithRegion(aws.StringValue(regionalSession.Config.Region))
if err != nil {
return fmt.Errorf("get default session for ECR deletion: %s", err)
}
}
// Best effort to construct ECR repo name.
ecrRepoName := fmt.Sprintf(deploy.FmtTaskECRRepoName, o.name)
o.spinner.Start(fmt.Sprintf("Emptying ECR repository for task %s.", color.HighlightUserInput(o.name)))
err = o.newImageRemover(defaultSess).ClearRepository(ecrRepoName)
if err != nil {
o.spinner.Stop(log.Serrorln("Error emptying ECR repository."))
return fmt.Errorf("empty ECR repository for task %s: %w", o.name, err)
}
o.spinner.Stop(log.Ssuccessf("Emptied ECR repository for task %s.\n", color.HighlightUserInput(o.name)))
return nil
}
func (o *deleteTaskOpts) emptyS3Bucket(info *deploy.TaskStackInfo) error {
o.spinner.Start(fmt.Sprintf("Emptying S3 bucket for task %s.", color.HighlightUserInput(o.name)))
err := o.newBucketEmptier(o.session).EmptyBucket(info.BucketName)
if err != nil {
o.spinner.Stop(log.Serrorln("Error emptying S3 bucket."))
return fmt.Errorf("empty S3 bucket for task %s: %w", o.name, err)
}
o.spinner.Stop(log.Ssuccessf("Emptied S3 bucket for task %s.\n", color.HighlightUserInput(o.name)))
return nil
}
// getTaskInfo returns a struct of information about the task, including the app and env it's deployed to, if
// applicable, and the ARN of any CF role it's associated with.
func (o *deleteTaskOpts) getTaskInfo() (*deploy.TaskStackInfo, error) {
if o.stackInfo != nil {
return o.stackInfo, nil
}
sess, err := o.getSession()
if err != nil {
return nil, err
}
info, err := o.newStackManager(sess).GetTaskStack(o.name)
if err != nil {
return nil, err
}
o.stackInfo = info
return info, nil
}
func (o *deleteTaskOpts) deleteStack() error {
sess, err := o.getSession()
if err != nil {
return err
}
info, err := o.getTaskInfo()
if err != nil {
// If the stack doesn't exist, don't error.
var errStackNotExist *awscfn.ErrStackNotFound
if errors.As(err, &errStackNotExist) {
return nil
}
return err
}
if info == nil {
// Stack does not exist; skip deleting it.
return nil
}
if info.BucketName != "" {
if err := o.emptyS3Bucket(info); err != nil {
return err
}
}
o.spinner.Start(fmt.Sprintf("Deleting CloudFormation stack for task %s.", color.HighlightUserInput(o.name)))
err = o.newStackManager(sess).DeleteTask(*info)
if err != nil {
o.spinner.Stop(log.Serrorln("Error deleting CloudFormation stack."))
return fmt.Errorf("delete stack for task %s: %w", o.name, err)
}
o.spinner.Stop(log.Ssuccessf("Deleted resources of task %s.\n", color.HighlightUserInput(o.name)))
return nil
}
func (o *deleteTaskOpts) RecommendActions() error {
return nil
}
// BuildTaskDeleteCmd builds the command to delete application(s).
func BuildTaskDeleteCmd() *cobra.Command {
vars := deleteTaskVars{}
cmd := &cobra.Command{
Use: "delete",
Short: "Deletes a one-off task from an application or default cluster.",
Example: `
Delete the "test" task from the default cluster.
/code $ copilot task delete --name test --default
Delete the "db-migrate" task from the prod environment.
/code $ copilot task delete --name db-migrate --env prod
Delete the "test" task without confirmation prompt.
/code $ copilot task delete --name test --yes`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newDeleteTaskOpts(vars)
if err != nil {
return err
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.app, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", svcFlagDescription)
cmd.Flags().StringVarP(&vars.env, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().BoolVar(&vars.skipConfirmation, yesFlag, false, yesFlagDescription)
cmd.Flags().BoolVar(&vars.defaultCluster, taskDefaultFlag, false, taskDeleteDefaultFlagDescription)
return cmd
}
| 509 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
awscfn "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type validateMocks struct {
store *mocks.Mockstore
cfn *mocks.MocktaskStackManager
provider *mocks.MocksessionProvider
}
func TestDeleteTaskOpts_Validate(t *testing.T) {
testCases := map[string]struct {
inAppName string
inEnvName string
inName string
inDefaultCluster bool
setupMocks func(m validateMocks)
want error
}{
"with only app flag": {
inAppName: "phonetool",
setupMocks: func(m validateMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
},
want: nil,
},
"with no flags": {
setupMocks: func(m validateMocks) {},
want: nil,
},
"with app/env flags set": {
inAppName: "phonetool",
inEnvName: "test",
setupMocks: func(m validateMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
},
want: nil,
},
"with all flags": {
inAppName: "phonetool",
inEnvName: "test",
inName: "oneoff",
setupMocks: func(m validateMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil)
m.cfn.EXPECT().GetTaskStack("oneoff")
},
want: nil,
},
"task does not exist": {
inAppName: "phonetool",
inEnvName: "test",
inName: "oneoff",
want: errors.New("get task: some error"),
setupMocks: func(m validateMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(&config.Application{Name: "phonetool"}, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
m.store.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil)
m.cfn.EXPECT().GetTaskStack("oneoff").Return(nil, errors.New("some error"))
},
},
"with default cluster flag set": {
inDefaultCluster: true,
inName: "oneoff",
setupMocks: func(m validateMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.cfn.EXPECT().GetTaskStack("oneoff")
},
want: nil,
},
"with default cluster and env flag": {
inDefaultCluster: true,
inEnvName: "test",
inAppName: "phonetool",
setupMocks: func(m validateMocks) {},
want: errors.New("cannot specify both `--app` and `--default`"),
},
"with error getting app": {
inAppName: "phonetool",
inEnvName: "test",
setupMocks: func(m validateMocks) {
m.store.EXPECT().GetApplication("phonetool").Return(nil, errors.New("some error"))
},
want: errors.New("get application: some error"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockstore := mocks.NewMockstore(ctrl)
mocktaskStackManager := mocks.NewMocktaskStackManager(ctrl)
mocks := validateMocks{
store: mockstore,
cfn: mocktaskStackManager,
provider: mocks.NewMocksessionProvider(ctrl),
}
tc.setupMocks(mocks)
opts := deleteTaskOpts{
deleteTaskVars: deleteTaskVars{
skipConfirmation: false,
app: tc.inAppName,
env: tc.inEnvName,
name: tc.inName,
defaultCluster: tc.inDefaultCluster,
},
store: mockstore,
newStackManager: func(_ *session.Session) taskStackManager {
return mocktaskStackManager
},
provider: mocks.provider,
}
// WHEN
err := opts.Validate()
// THEN
if tc.want != nil {
require.EqualError(t, err, tc.want.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestDeleteTaskOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inAppName string
inEnvName string
inName string
inDefaultCluster bool
inSkipConfirmation bool
mockStore func(m *mocks.Mockstore)
mockSel func(m *mocks.MockwsSelector)
mockTaskSelect func(m *mocks.MockcfTaskSelector)
mockSess func(m *mocks.MocksessionProvider)
mockPrompter func(m *mocks.Mockprompter)
wantErr string
}{
"all flags specified": {
inAppName: "phonetool",
inEnvName: "test",
inName: "abcd",
inSkipConfirmation: true,
mockStore: func(m *mocks.Mockstore) {},
mockSel: func(m *mocks.MockwsSelector) {},
mockTaskSelect: func(m *mocks.MockcfTaskSelector) {},
mockSess: func(m *mocks.MocksessionProvider) {},
mockPrompter: func(m *mocks.Mockprompter) {},
},
"name flag not specified": {
inAppName: "phonetool",
inEnvName: "test",
mockStore: func(m *mocks.Mockstore) {
// This call is in GetSession when an environment is specified and we need to get the Manager Role's session.
m.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
},
mockSel: func(m *mocks.MockwsSelector) {},
mockTaskSelect: func(m *mocks.MockcfTaskSelector) {
m.EXPECT().Task(taskDeleteNamePrompt, "", gomock.Any()).Return("abc", nil)
},
mockSess: func(m *mocks.MocksessionProvider) {
m.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil)
},
mockPrompter: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm("Are you sure you want to delete abc from application phonetool and environment test?", gomock.Any(), gomock.Any()).Return(true, nil)
},
},
"name flag not specified and confirm cancelled": {
inAppName: "phonetool",
inEnvName: "test",
mockStore: func(m *mocks.Mockstore) {
// This call is in GetSession when an environment is specified and we need to get the Manager Role's session.
m.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
},
mockSel: func(m *mocks.MockwsSelector) {},
mockTaskSelect: func(m *mocks.MockcfTaskSelector) {
m.EXPECT().Task(taskDeleteNamePrompt, "", gomock.Any()).Return("abc", nil)
},
mockSess: func(m *mocks.MocksessionProvider) {
m.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil)
},
mockPrompter: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm("Are you sure you want to delete abc from application phonetool and environment test?", gomock.Any(), gomock.Any()).Return(false, nil)
},
wantErr: "task delete cancelled - no changes made",
},
"default flag specified": {
inDefaultCluster: true,
mockStore: func(m *mocks.Mockstore) {
},
mockSel: func(m *mocks.MockwsSelector) {},
mockTaskSelect: func(m *mocks.MockcfTaskSelector) {
m.EXPECT().Task(taskDeleteNamePrompt, "", gomock.Any()).Return("abc", nil)
},
mockSess: func(m *mocks.MocksessionProvider) {
m.EXPECT().Default().Return(&session.Session{}, nil)
},
mockPrompter: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm("Are you sure you want to delete abc from the default cluster?", gomock.Any(), gomock.Any()).Return(true, nil)
},
},
"no flags specified": {
mockStore: func(m *mocks.Mockstore) {
// This call is in GetSession when an environment is specified and we need to get the Manager Role's session.
m.EXPECT().GetEnvironment("phonetool", "test").Return(&config.Environment{Name: "test", App: "phonetool"}, nil)
},
mockSel: func(m *mocks.MockwsSelector) {
m.EXPECT().Application(taskDeleteAppPrompt, "", appEnvOptionNone).Return("phonetool", nil)
m.EXPECT().Environment(taskDeleteEnvPrompt, "", "phonetool", appEnvOptionNone).Return("test", nil)
},
mockTaskSelect: func(m *mocks.MockcfTaskSelector) {
m.EXPECT().Task(taskDeleteNamePrompt, "", gomock.Any()).Return("abc", nil)
},
mockSess: func(m *mocks.MocksessionProvider) {
m.EXPECT().FromRole(gomock.Any(), gomock.Any()).Return(&session.Session{}, nil)
},
mockPrompter: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm("Are you sure you want to delete abc from application phonetool and environment test?", gomock.Any(), gomock.Any()).Return(true, nil)
},
},
"no flags specified (default path)": {
mockStore: func(m *mocks.Mockstore) {},
mockSel: func(m *mocks.MockwsSelector) {
m.EXPECT().Application(taskDeleteAppPrompt, "", appEnvOptionNone).Return(appEnvOptionNone, nil)
},
mockTaskSelect: func(m *mocks.MockcfTaskSelector) {
m.EXPECT().Task(taskDeleteNamePrompt, "", gomock.Any()).Return("abc", nil)
},
mockSess: func(m *mocks.MocksessionProvider) {
m.EXPECT().Default().Return(&session.Session{}, nil)
},
mockPrompter: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm("Are you sure you want to delete abc from the default cluster?", gomock.Any(), gomock.Any()).Return(true, nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
// GIVEN
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
mockSel := mocks.NewMockwsSelector(ctrl)
mockSess := mocks.NewMocksessionProvider(ctrl)
mockTaskSel := mocks.NewMockcfTaskSelector(ctrl)
mockPrompt := mocks.NewMockprompter(ctrl)
tc.mockStore(mockStore)
tc.mockSel(mockSel)
tc.mockSess(mockSess)
tc.mockTaskSelect(mockTaskSel)
tc.mockPrompter(mockPrompt)
opts := deleteTaskOpts{
deleteTaskVars: deleteTaskVars{
skipConfirmation: tc.inSkipConfirmation,
defaultCluster: tc.inDefaultCluster,
app: tc.inAppName,
env: tc.inEnvName,
name: tc.inName,
},
store: mockStore,
sel: mockSel,
provider: mockSess,
prompt: mockPrompt,
newTaskSel: func(sess *session.Session) cfTaskSelector { return mockTaskSel },
}
// WHEN
err := opts.Ask()
// THEN
if tc.wantErr != "" {
require.EqualError(t, err, tc.wantErr)
} else {
require.NoError(t, err)
}
})
}
}
type deleteTaskMocks struct {
store *mocks.Mockstore
sess *mocks.MocksessionProvider
ecr *mocks.MockimageRemover
s3 *mocks.MockbucketEmptier
ecs *mocks.MocktaskStopper
cfn *mocks.MocktaskStackManager
spinner *mocks.Mockprogress
}
func TestDeleteTaskOpts_Execute(t *testing.T) {
mockApp := "phonetool"
mockEnvName := "pdx"
mockTaskName := "hide-snacks"
mockTaskStackName := "task-hide-snacks"
mockTaskRepoName := "copilot-hide-snacks"
mockManagerARN := "arn:aws:iam:us-west-2:123456789:role/abc"
mockEnv := &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
ManagerRoleARN: mockManagerARN,
}
mockAppEnvTask := &deploy.TaskStackInfo{
App: mockApp,
Env: mockEnvName,
RoleARN: mockManagerARN,
StackName: mockTaskStackName,
BucketName: "arn:aws:s3:::bucket",
}
mockDefaultTask := deploy.TaskStackInfo{
StackName: mockTaskStackName,
BucketName: "arn:aws:s3:::bucket",
}
mockDefaultTaskNoBucket := deploy.TaskStackInfo{
StackName: mockTaskStackName,
}
mockError := errors.New("some error")
testCases := map[string]struct {
inDefault bool
inApp string
inEnv string
inName string
setupMocks func(mocks deleteTaskMocks)
wantedErr error
}{
"success with app/env": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
setupMocks: func(m deleteTaskMocks) {
m.sess.EXPECT().FromRole(mockEnv.ManagerRoleARN, mockEnv.Region).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil)
m.sess.EXPECT().DefaultWithRegion("mockRegion").Return(&session.Session{}, nil)
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(mockEnv, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopOneOffTasks(mockApp, mockEnvName, mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.cfn.EXPECT().GetTaskStack(mockTaskName).Return(mockAppEnvTask, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.s3.EXPECT().EmptyBucket(gomock.Any()).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.cfn.EXPECT().DeleteTask(*mockAppEnvTask).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
"success with default cluster": {
inDefault: true,
inName: mockTaskName,
setupMocks: func(m deleteTaskMocks) {
gomock.InOrder(
m.sess.EXPECT().Default().Return(&session.Session{}, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopDefaultClusterTasks(mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.cfn.EXPECT().GetTaskStack(mockTaskName).Return(&mockDefaultTask, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.s3.EXPECT().EmptyBucket(gomock.Any()).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.cfn.EXPECT().DeleteTask(mockDefaultTask).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
"success with default cluster and no S3 bucket": {
inDefault: true,
inName: mockTaskName,
setupMocks: func(m deleteTaskMocks) {
gomock.InOrder(
m.sess.EXPECT().Default().Return(&session.Session{}, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopDefaultClusterTasks(mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.cfn.EXPECT().GetTaskStack(mockTaskName).Return(&mockDefaultTaskNoBucket, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.cfn.EXPECT().DeleteTask(mockDefaultTaskNoBucket).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
"error when getting environment": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
wantedErr: errors.New("get session: some error"),
setupMocks: func(m deleteTaskMocks) {
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(nil, mockError),
)
},
},
"error deleting task stack": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
wantedErr: errors.New("delete stack for task hide-snacks: some error"),
setupMocks: func(m deleteTaskMocks) {
m.sess.EXPECT().FromRole(mockEnv.ManagerRoleARN, mockEnv.Region).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil)
m.sess.EXPECT().DefaultWithRegion("mockRegion").Return(&session.Session{}, nil)
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(mockEnv, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopOneOffTasks(mockApp, mockEnvName, mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.cfn.EXPECT().GetTaskStack(mockTaskName).Return(mockAppEnvTask, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.s3.EXPECT().EmptyBucket(gomock.Any()).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.cfn.EXPECT().DeleteTask(*mockAppEnvTask).Return(mockError),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
"task stack does not exist (idempotency check)": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
setupMocks: func(m deleteTaskMocks) {
mockErrStackNotFound := awscfn.ErrStackNotFound{}
m.sess.EXPECT().FromRole(mockEnv.ManagerRoleARN, mockEnv.Region).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil)
m.sess.EXPECT().DefaultWithRegion("mockRegion").Return(&session.Session{}, nil)
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(mockEnv, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopOneOffTasks(mockApp, mockEnvName, mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.cfn.EXPECT().GetTaskStack(mockTaskName).Return(nil, &mockErrStackNotFound),
)
},
},
"error clearing ecr repo": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
wantedErr: errors.New("empty ECR repository for task hide-snacks: some error"),
setupMocks: func(m deleteTaskMocks) {
m.sess.EXPECT().FromRole(mockEnv.ManagerRoleARN, mockEnv.Region).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil)
m.sess.EXPECT().DefaultWithRegion("mockRegion").Return(&session.Session{}, nil)
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(mockEnv, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopOneOffTasks(mockApp, mockEnvName, mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(mockError),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
"error clearing s3 bucket": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
wantedErr: errors.New("empty S3 bucket for task hide-snacks: some error"),
setupMocks: func(m deleteTaskMocks) {
m.sess.EXPECT().FromRole(mockEnv.ManagerRoleARN, mockEnv.Region).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil)
m.sess.EXPECT().DefaultWithRegion("mockRegion").Return(&session.Session{}, nil)
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(mockEnv, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopOneOffTasks(mockApp, mockEnvName, mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.cfn.EXPECT().GetTaskStack(mockTaskName).Return(mockAppEnvTask, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.s3.EXPECT().EmptyBucket(gomock.Any()).Return(mockError),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
"error stopping app/env tasks": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
wantedErr: errors.New("stop running tasks in family hide-snacks: some error"),
setupMocks: func(m deleteTaskMocks) {
m.sess.EXPECT().FromRole(mockEnv.ManagerRoleARN, mockEnv.Region).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil)
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(mockEnv, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopOneOffTasks(mockApp, mockEnvName, mockTaskName).Return(mockError),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
"error getting task stack": {
inApp: mockApp,
inEnv: mockEnvName,
inName: mockTaskName,
wantedErr: errors.New("some error"),
setupMocks: func(m deleteTaskMocks) {
m.sess.EXPECT().FromRole(mockEnv.ManagerRoleARN, mockEnv.Region).Return(&session.Session{
Config: &aws.Config{
Region: aws.String("mockRegion"),
},
}, nil)
m.sess.EXPECT().DefaultWithRegion("mockRegion").Return(&session.Session{}, nil)
gomock.InOrder(
m.store.EXPECT().GetEnvironment(mockApp, mockEnvName).Return(mockEnv, nil),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopOneOffTasks(mockApp, mockEnvName, mockTaskName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.spinner.EXPECT().Start(gomock.Any()),
m.ecr.EXPECT().ClearRepository(mockTaskRepoName).Return(nil),
m.spinner.EXPECT().Stop(gomock.Any()),
m.cfn.EXPECT().GetTaskStack(mockTaskName).Return(nil, mockError),
)
},
},
"error stopping default cluster tasks": {
inDefault: true,
inName: mockTaskName,
wantedErr: errors.New("stop running tasks in family hide-snacks: some error"),
setupMocks: func(m deleteTaskMocks) {
m.sess.EXPECT().Default().Return(&session.Session{}, nil)
gomock.InOrder(
m.spinner.EXPECT().Start(gomock.Any()),
m.ecs.EXPECT().StopDefaultClusterTasks(mockTaskName).Return(mockError),
m.spinner.EXPECT().Stop(gomock.Any()),
)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
// GIVEN
mockstore := mocks.NewMockstore(ctrl)
mockECR := mocks.NewMockimageRemover(ctrl)
mockS3 := mocks.NewMockbucketEmptier(ctrl)
mockCFN := mocks.NewMocktaskStackManager(ctrl)
mockECS := mocks.NewMocktaskStopper(ctrl)
//mockSession := sessions.NewProvider()
mockSession := mocks.NewMocksessionProvider(ctrl)
mockSpinner := mocks.NewMockprogress(ctrl)
mockGetECR := func(_ *session.Session) imageRemover {
return mockECR
}
mockGetS3 := func(_ *session.Session) bucketEmptier {
return mockS3
}
mockGetECS := func(_ *session.Session) taskStopper {
return mockECS
}
mockGetCFN := func(_ *session.Session) taskStackManager {
return mockCFN
}
mocks := deleteTaskMocks{
store: mockstore,
sess: mockSession,
ecr: mockECR,
s3: mockS3,
ecs: mockECS,
cfn: mockCFN,
spinner: mockSpinner,
}
tc.setupMocks(mocks)
opts := deleteTaskOpts{
deleteTaskVars: deleteTaskVars{
app: tc.inApp,
env: tc.inEnv,
name: tc.inName,
defaultCluster: tc.inDefault,
},
store: mockstore,
provider: mockSession,
spinner: mockSpinner,
newImageRemover: mockGetECR,
newBucketEmptier: mockGetS3,
newStackManager: mockGetCFN,
newTaskStopper: mockGetECS,
}
// WHEN
err := opts.Execute()
// THEN
if tc.wantedErr != nil {
require.EqualError(t, err, tc.wantedErr.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 704 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"fmt"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/cmd/copilot/template"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/spf13/cobra"
)
const (
useDefaultClusterOption = "None (run in default cluster)"
)
var (
taskExecTaskPrompt = fmt.Sprintf("Which %s would you like to execute into?", color.Emphasize("task"))
taskExecTaskHelpPrompt = fmt.Sprintf("By default we'll execute into the first %s of the task.", color.Emphasize("essential container"))
taskExecAppNamePrompt = fmt.Sprintf("In which %s are you running your %s?", color.Emphasize("application"), color.Emphasize("task"))
taskExecAppNameHelpPrompt = fmt.Sprintf(`Select the application that your task is deployed to.
Select %s to execute in a task running in your default cluster instead of any existing application.`, color.Emphasize(useDefaultClusterOption))
taskExecEnvNamePrompt = fmt.Sprintf("In which %s are you running your %s?", color.Emphasize("environment"), color.Emphasize("task"))
taskExecEnvNameHelpPrompt = fmt.Sprintf(`Select the environment that your task is deployed to.
Select %s to execute in a task running in your default cluster instead of any existing environment.`, color.Emphasize(useDefaultClusterOption))
)
type taskExecVars struct {
execVars
useDefault bool
}
type taskExecOpts struct {
taskExecVars
store store
ssmPluginManager ssmPluginManager
prompter prompter
newTaskSel func(*session.Session) runningTaskSelector
configSel appEnvSelector
newCommandExecutor func(*session.Session) ecsCommandExecutor
provider sessionProvider
task *awsecs.Task
}
func newTaskExecOpts(vars taskExecVars) (*taskExecOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("task exec"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
ssmStore := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
prompter := prompt.New()
return &taskExecOpts{
taskExecVars: vars,
store: ssmStore,
ssmPluginManager: exec.NewSSMPluginCommand(nil),
prompter: prompter,
newTaskSel: func(sess *session.Session) runningTaskSelector {
return selector.NewTaskSelector(prompter, ecs.New(sess))
},
configSel: selector.NewConfigSelector(prompter, ssmStore),
newCommandExecutor: func(s *session.Session) ecsCommandExecutor {
return awsecs.New(s)
},
provider: sessProvider,
}, nil
}
// Validate returns an error if the values provided by the user are invalid.
func (o *taskExecOpts) Validate() error {
if o.useDefault && (o.appName != tryReadingAppName() || o.envName != "") {
return fmt.Errorf("cannot specify both default flag and app or env flags")
}
if o.appName != "" {
if _, err := o.store.GetApplication(o.appName); err != nil {
return err
}
if o.envName != "" {
if _, err := o.store.GetEnvironment(o.appName, o.envName); err != nil {
return err
}
}
}
return validateSSMBinary(o.prompter, o.ssmPluginManager, o.skipConfirmation)
}
// Ask asks for fields that are required but not passed in.
func (o *taskExecOpts) Ask() error {
if o.useDefault {
return o.selectTaskInDefaultCluster()
}
if o.appName == "" {
appName, err := o.configSel.Application(taskExecAppNamePrompt, taskExecAppNameHelpPrompt, useDefaultClusterOption)
if err != nil {
return fmt.Errorf("select application: %w", err)
}
if appName == useDefaultClusterOption {
o.useDefault = true
return o.selectTaskInDefaultCluster()
}
o.appName = appName
}
if o.envName == "" {
envName, err := o.configSel.Environment(taskExecEnvNamePrompt, taskExecEnvNameHelpPrompt, o.appName, useDefaultClusterOption)
if err != nil {
return fmt.Errorf("select environment: %w", err)
}
if envName == useDefaultClusterOption {
o.useDefault = true
return o.selectTaskInDefaultCluster()
}
o.envName = envName
}
return o.selectTaskInAppEnvCluster()
}
// Execute executes a command in a running container.
func (o *taskExecOpts) Execute() error {
sess, err := o.configSession()
if err != nil {
return err
}
cluster, container := aws.StringValue(o.task.ClusterArn), aws.StringValue(o.task.Containers[0].Name)
taskID, err := awsecs.TaskID(aws.StringValue(o.task.TaskArn))
if err != nil {
return fmt.Errorf("parse task ARN %s: %w", aws.StringValue(o.task.TaskArn), err)
}
log.Infof("Execute %s in container %s in task %s.\n", color.HighlightCode(o.command),
color.HighlightUserInput(container), color.HighlightResource(taskID))
if err = o.newCommandExecutor(sess).ExecuteCommand(awsecs.ExecuteCommandInput{
Cluster: cluster,
Command: o.command,
Container: container,
Task: taskID,
}); err != nil {
return fmt.Errorf("execute command %s in container %s: %w", o.command, container, err)
}
return nil
}
func (o *taskExecOpts) selectTaskInDefaultCluster() error {
sess, err := o.provider.Default()
if err != nil {
return fmt.Errorf("create default session: %w", err)
}
task, err := o.newTaskSel(sess).RunningTask(taskExecTaskPrompt, taskExecTaskHelpPrompt,
selector.WithDefault(), selector.WithTaskGroup(o.name), selector.WithTaskID(o.taskID))
if err != nil {
return fmt.Errorf("select running task in default cluster: %w", err)
}
o.task = task
return nil
}
func (o *taskExecOpts) selectTaskInAppEnvCluster() error {
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return fmt.Errorf("get environment %s: %w", o.envName, err)
}
sess, err := o.provider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return fmt.Errorf("get session from role %s and region %s: %w", env.ManagerRoleARN, env.Region, err)
}
task, err := o.newTaskSel(sess).RunningTask(taskExecTaskPrompt, taskExecTaskHelpPrompt,
selector.WithAppEnv(o.appName, o.envName), selector.WithTaskGroup(o.name), selector.WithTaskID(o.taskID))
if err != nil {
return fmt.Errorf("select running task in environment %s: %w", o.envName, err)
}
o.task = task
return nil
}
func (o *taskExecOpts) configSession() (*session.Session, error) {
if o.useDefault {
return o.provider.Default()
}
env, err := o.store.GetEnvironment(o.appName, o.envName)
if err != nil {
return nil, fmt.Errorf("get environment %s: %w", o.envName, err)
}
return o.provider.FromRole(env.ManagerRoleARN, env.Region)
}
// buildTaskExecCmd builds the command for execute a running container in a one-off task.
func buildTaskExecCmd() *cobra.Command {
var skipPrompt bool
vars := taskExecVars{}
cmd := &cobra.Command{
Use: "exec",
Short: "Execute a command in a running container part of a task.",
Example: `
Start an interactive bash session with a task in task group "db-migrate" in the "test" environment under the current workspace.
/code $ copilot task exec -e test -n db-migrate
Runs the 'cat progress.csv' command in the task prefixed with ID "1848c38" part of the "db-migrate" task group.
/code $ copilot task exec --name db-migrate --task-id 1848c38 --command "cat progress.csv"
Start an interactive bash session with a task prefixed with ID "38c3818" in the default cluster.
/code $ copilot task exec --default --task-id 38c3818`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newTaskExecOpts(vars)
if err != nil {
return err
}
if cmd.Flags().Changed(yesFlag) {
opts.skipConfirmation = aws.Bool(false)
if skipPrompt {
opts.skipConfirmation = aws.Bool(true)
}
}
return run(opts)
}),
}
cmd.Flags().StringVarP(&vars.appName, appFlag, appFlagShort, tryReadingAppName(), appFlagDescription)
cmd.Flags().StringVarP(&vars.envName, envFlag, envFlagShort, "", envFlagDescription)
cmd.Flags().StringVarP(&vars.name, nameFlag, nameFlagShort, "", nameFlagDescription)
cmd.Flags().StringVarP(&vars.command, commandFlag, commandFlagShort, defaultCommand, execCommandFlagDescription)
cmd.Flags().StringVar(&vars.taskID, taskIDFlag, "", taskIDFlagDescription)
cmd.Flags().BoolVar(&vars.useDefault, taskDefaultFlag, false, taskExecDefaultFlagDescription)
cmd.Flags().BoolVar(&skipPrompt, yesFlag, false, execYesFlagDescription)
cmd.SetUsageTemplate(template.Usage)
return cmd
}
| 239 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
awsecs "github.com/aws/aws-sdk-go/service/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type execTaskMocks struct {
storeSvc *mocks.Mockstore
configSel *mocks.MockappEnvSelector
taskSel *mocks.MockrunningTaskSelector
commandExec *mocks.MockecsCommandExecutor
ssmPluginManager *mocks.MockssmPluginManager
provider *mocks.MocksessionProvider
}
func TestTaskExec_Validate(t *testing.T) {
const (
mockApp = "my-app"
mockEnv = "my-env"
)
mockErr := errors.New("some error")
testCases := map[string]struct {
inApp string
inEnv string
inTaskGroup string
useDefault bool
setupMocks func(mocks execTaskMocks)
wantedError error
}{
"should bubble error if specify both default and app": {
inApp: mockApp,
useDefault: true,
setupMocks: func(m execTaskMocks) {},
wantedError: fmt.Errorf("cannot specify both default flag and app or env flags"),
},
"should bubble error if specify both default and env": {
inEnv: mockEnv,
useDefault: true,
setupMocks: func(m execTaskMocks) {},
wantedError: fmt.Errorf("cannot specify both default flag and app or env flags"),
},
"should bubble error if failed to get app": {
inApp: mockApp,
setupMocks: func(m execTaskMocks) {
m.storeSvc.EXPECT().GetApplication(mockApp).Return(nil, mockErr)
},
wantedError: fmt.Errorf("some error"),
},
"should bubble error if failed to get env": {
inApp: mockApp,
inEnv: mockEnv,
setupMocks: func(m execTaskMocks) {
m.storeSvc.EXPECT().GetApplication(mockApp).Return(&config.Application{}, nil)
m.storeSvc.EXPECT().GetEnvironment(mockApp, mockEnv).Return(nil, mockErr)
},
wantedError: fmt.Errorf("some error"),
},
"skip validation if app flag is not set": {
inEnv: mockEnv,
setupMocks: func(m execTaskMocks) {
m.ssmPluginManager.EXPECT().ValidateBinary().Return(nil)
},
},
"success": {
inApp: mockApp,
inEnv: mockEnv,
setupMocks: func(m execTaskMocks) {
m.storeSvc.EXPECT().GetApplication(mockApp).Return(&config.Application{}, nil)
m.storeSvc.EXPECT().GetEnvironment(mockApp, mockEnv).Return(&config.Environment{}, nil)
m.ssmPluginManager.EXPECT().ValidateBinary().Return(nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mockSSMValidator := mocks.NewMockssmPluginManager(ctrl)
mocks := execTaskMocks{
storeSvc: mockStoreReader,
ssmPluginManager: mockSSMValidator,
}
tc.setupMocks(mocks)
execTasks := &taskExecOpts{
taskExecVars: taskExecVars{
execVars: execVars{
name: tc.inTaskGroup,
appName: tc.inApp,
envName: tc.inEnv,
},
useDefault: tc.useDefault,
},
store: mockStoreReader,
ssmPluginManager: mockSSMValidator,
}
// WHEN
err := execTasks.Validate()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestTaskExec_Ask(t *testing.T) {
const (
mockApp = "my-app"
mockEnv = "my-env"
)
mockTask := &ecs.Task{
TaskArn: aws.String("mockTaskARN"),
}
mockErr := errors.New("some error")
testCases := map[string]struct {
inApp string
inEnv string
inTaskGroup string
inTaskID string
useDefault bool
setupMocks func(mocks execTaskMocks)
wantedError error
wantedTask *ecs.Task
wantedUseDefault bool
}{
"should bubble error if fail to select task in default cluster": {
useDefault: true,
setupMocks: func(m execTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.taskSel.EXPECT().RunningTask(taskExecTaskPrompt, taskExecTaskHelpPrompt,
gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, mockErr)
},
wantedError: fmt.Errorf("select running task in default cluster: some error"),
},
"should bubble error if fail to select application": {
setupMocks: func(m execTaskMocks) {
m.configSel.EXPECT().Application(taskExecAppNamePrompt, taskExecAppNameHelpPrompt, useDefaultClusterOption).
Return("", mockErr)
},
wantedError: fmt.Errorf("select application: some error"),
},
"should bubble error if fail to select environment": {
inApp: mockApp,
setupMocks: func(m execTaskMocks) {
m.configSel.EXPECT().Environment(taskExecEnvNamePrompt, taskExecEnvNameHelpPrompt, mockApp, useDefaultClusterOption).
Return("", mockErr)
},
wantedError: fmt.Errorf("select environment: some error"),
},
"should bubble error if fail to get environment": {
inApp: mockApp,
inEnv: mockEnv,
setupMocks: func(m execTaskMocks) {
m.storeSvc.EXPECT().GetEnvironment(mockApp, mockEnv).Return(nil, mockErr)
},
wantedError: fmt.Errorf("get environment my-env: some error"),
},
"should bubble error if fail to select running task in env cluster": {
inApp: mockApp,
inEnv: mockEnv,
setupMocks: func(m execTaskMocks) {
m.storeSvc.EXPECT().GetEnvironment(mockApp, mockEnv).Return(&config.Environment{}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any())
m.taskSel.EXPECT().RunningTask(taskExecTaskPrompt, taskExecTaskHelpPrompt,
gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, mockErr)
},
wantedError: fmt.Errorf("select running task in environment my-env: some error"),
},
"success with default flag set": {
useDefault: true,
setupMocks: func(m execTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.taskSel.EXPECT().RunningTask(taskExecTaskPrompt, taskExecTaskHelpPrompt,
gomock.Any(), gomock.Any(), gomock.Any()).Return(mockTask, nil)
},
wantedTask: mockTask,
wantedUseDefault: true,
},
"success with default option chose": {
setupMocks: func(m execTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.configSel.EXPECT().Application(taskExecAppNamePrompt, taskExecAppNameHelpPrompt, useDefaultClusterOption).
Return(useDefaultClusterOption, nil)
m.taskSel.EXPECT().RunningTask(taskExecTaskPrompt, taskExecTaskHelpPrompt,
gomock.Any(), gomock.Any(), gomock.Any()).Return(mockTask, nil)
},
wantedTask: mockTask,
wantedUseDefault: true,
},
"success with env cluster": {
setupMocks: func(m execTaskMocks) {
m.configSel.EXPECT().Application(taskExecAppNamePrompt, taskExecAppNameHelpPrompt, useDefaultClusterOption).
Return(mockApp, nil)
m.configSel.EXPECT().Environment(taskExecEnvNamePrompt, taskExecEnvNameHelpPrompt, mockApp, useDefaultClusterOption).
Return(mockEnv, nil)
m.storeSvc.EXPECT().GetEnvironment(mockApp, mockEnv).Return(&config.Environment{}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any())
m.taskSel.EXPECT().RunningTask(taskExecTaskPrompt, taskExecTaskHelpPrompt,
gomock.Any(), gomock.Any(), gomock.Any()).Return(mockTask, nil)
},
wantedTask: mockTask,
wantedUseDefault: false,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mockConfigSel := mocks.NewMockappEnvSelector(ctrl)
mockTaskSel := mocks.NewMockrunningTaskSelector(ctrl)
mockNewTaskSel := func(_ *session.Session) runningTaskSelector {
return mockTaskSel
}
mockProvider := mocks.NewMocksessionProvider(ctrl)
mocks := execTaskMocks{
storeSvc: mockStoreReader,
configSel: mockConfigSel,
taskSel: mockTaskSel,
provider: mockProvider,
}
tc.setupMocks(mocks)
execTasks := &taskExecOpts{
taskExecVars: taskExecVars{
execVars: execVars{
name: tc.inTaskGroup,
appName: tc.inApp,
envName: tc.inEnv,
taskID: tc.inTaskID,
},
useDefault: tc.useDefault,
},
store: mockStoreReader,
newTaskSel: mockNewTaskSel,
configSel: mockConfigSel,
provider: mockProvider,
}
// WHEN
err := execTasks.Ask()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedTask, execTasks.task)
require.Equal(t, tc.wantedUseDefault, execTasks.useDefault)
}
})
}
}
func TestTaskExec_Execute(t *testing.T) {
const (
mockApp = "my-app"
mockEnv = "my-env"
mockCommand = "mockCommand"
mockBadTaskARN = "mockBadTaskARN"
mockTaskARN = "arn:aws:ecs:us-west-2:123456789:task/4082490ee6c245e09d2145010aa1ba8d"
mockTaskID = "4082490ee6c245e09d2145010aa1ba8d"
mockClusterARN = "mockClusterARN"
mockContainerName = "mockContainerName"
)
mockTask := &ecs.Task{
TaskArn: aws.String(mockTaskARN),
ClusterArn: aws.String(mockClusterARN),
Containers: []*awsecs.Container{
{
Name: aws.String(mockContainerName),
},
},
}
mockErr := errors.New("some error")
testCases := map[string]struct {
inTask *ecs.Task
inUseDefault bool
setupMocks func(mocks execTaskMocks)
wantedError error
}{
"should bubble error if fail to get environment": {
setupMocks: func(m execTaskMocks) {
m.storeSvc.EXPECT().GetEnvironment(mockApp, mockEnv).Return(nil, mockErr)
},
wantedError: fmt.Errorf("get environment my-env: some error"),
},
"should bubble error if fail to parse task id": {
inUseDefault: true,
inTask: &ecs.Task{
TaskArn: aws.String(mockBadTaskARN),
ClusterArn: aws.String(mockClusterARN),
Containers: []*awsecs.Container{
{
Name: aws.String(mockContainerName),
},
},
},
setupMocks: func(m execTaskMocks) {
m.provider.EXPECT().Default()
},
wantedError: fmt.Errorf("parse task ARN mockBadTaskARN: parse ECS task ARN: arn: invalid prefix"),
},
"should bubble error if fail to execute commands": {
inTask: mockTask,
inUseDefault: true,
setupMocks: func(m execTaskMocks) {
m.provider.EXPECT().Default()
m.commandExec.EXPECT().ExecuteCommand(ecs.ExecuteCommandInput{
Cluster: mockClusterARN,
Command: mockCommand,
Container: mockContainerName,
Task: mockTaskID,
}).Return(mockErr)
},
wantedError: fmt.Errorf("execute command mockCommand in container mockContainerName: some error"),
},
"success": {
inTask: mockTask,
setupMocks: func(m execTaskMocks) {
m.storeSvc.EXPECT().GetEnvironment(mockApp, mockEnv).Return(&config.Environment{}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any())
m.commandExec.EXPECT().ExecuteCommand(ecs.ExecuteCommandInput{
Cluster: mockClusterARN,
Command: mockCommand,
Container: mockContainerName,
Task: mockTaskID,
}).Return(nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStoreReader := mocks.NewMockstore(ctrl)
mockCommandExec := mocks.NewMockecsCommandExecutor(ctrl)
mockNewCommandExec := func(_ *session.Session) ecsCommandExecutor {
return mockCommandExec
}
mocks := execTaskMocks{
storeSvc: mockStoreReader,
commandExec: mockCommandExec,
provider: mocks.NewMocksessionProvider(ctrl),
}
tc.setupMocks(mocks)
execTasks := &taskExecOpts{
taskExecVars: taskExecVars{
execVars: execVars{
appName: mockApp,
envName: mockEnv,
command: mockCommand,
},
useDefault: tc.inUseDefault,
},
task: tc.inTask,
store: mockStoreReader,
newCommandExecutor: mockNewCommandExec,
provider: mocks.provider,
}
// WHEN
err := execTasks.Execute()
// THEN
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
| 422 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"context"
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/template/artifactpath"
"golang.org/x/mod/semver"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/spf13/pflag"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/aws-sdk-go/aws/arn"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/ecr"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/logging"
"github.com/aws/copilot-cli/internal/pkg/term/prompt"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/ec2"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/repository"
"github.com/aws/copilot-cli/internal/pkg/task"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/selector"
"github.com/dustin/go-humanize/english"
"github.com/google/shlex"
"github.com/spf13/afero"
"github.com/spf13/cobra"
)
const (
appEnvOptionNone = "None (run in default VPC)"
defaultDockerfilePath = "Dockerfile"
imageTagLatest = "latest"
shortTaskIDLength = 8
)
const (
envFileExt = ".env"
fmtTaskRunEnvUploadStart = "Uploading env file to S3: %s"
fmtTaskRunEnvUploadFailed = "Failed to upload your env file to S3: %s\n"
fmtTaskRunEnvUploadComplete = "Successfully uploaded your env file to S3: %s\n"
)
const (
workloadTypeJob = "job"
workloadTypeSvc = "svc"
workloadTypeInvalid = "invalid"
)
const (
fmtImageURI = "%s:%s"
)
var (
errNumNotPositive = errors.New("number of tasks must be positive")
errCPUNotPositive = errors.New("CPU units must be positive")
errMemNotPositive = errors.New("memory must be positive")
)
var (
taskRunAppPrompt = fmt.Sprintf("In which %s would you like to run this %s?", color.Emphasize("application"), color.Emphasize("task"))
taskRunEnvPrompt = fmt.Sprintf("In which %s would you like to run this %s?", color.Emphasize("environment"), color.Emphasize("task"))
taskRunAppPromptHelp = fmt.Sprintf(`Task will be deployed to the selected application.
Select %s to run the task in your default VPC instead of any existing application.`, color.Emphasize(appEnvOptionNone))
taskRunEnvPromptHelp = fmt.Sprintf(`Task will be deployed to the selected environment.
Select %s to run the task in your default VPC instead of any existing environment.`, color.Emphasize(appEnvOptionNone))
)
var (
taskSecretsPermissionPrompt = "Do you grant permission to the ECS/Fargate agent for these secrets?"
taskSecretsPermissionPromptHelp = "ECS/Fargate agent needs the permissions in order to fetch the secrets and inject them into your container."
)
type runTaskVars struct {
count int
cpu int
memory int
groupName string
image string
dockerfilePath string
dockerfileContextPath string
imageTag string
taskRole string
executionRole string
cluster string
subnets []string
securityGroups []string
env string
appName string
useDefaultSubnetsAndCluster bool
envVars map[string]string
envFile string
secrets map[string]string
acknowledgeSecretsAccess bool
command string
entrypoint string
resourceTags map[string]string
follow bool
generateCommandTarget string
os string
arch string
}
type runTaskOpts struct {
runTaskVars
isDockerfileSet bool
nFlag int
// Interfaces to interact with dependencies.
fs afero.Fs
store store
sel appEnvSelector
spinner progress
prompt prompter
// Fields below are configured at runtime.
deployer taskDeployer
repository repositoryService
runner taskRunner
eventsWriter eventsWriter
defaultClusterGetter defaultClusterGetter
publicIPGetter publicIPGetter
provider sessionProvider
sess *session.Session
targetEnvironment *config.Environment
// Configurer functions.
configureRuntimeOpts func() error
configureRepository func() error
// NOTE: configureEventsWriter is only called when tailing logs (i.e. --follow is specified)
configureEventsWriter func(tasks []*task.Task)
configureECSServiceDescriber func(session *session.Session) ecs.ECSServiceDescriber
configureServiceDescriber func(session *session.Session) ecs.ServiceDescriber
configureJobDescriber func(session *session.Session) ecs.JobDescriber
configureUploader func(session *session.Session) uploader
// Functions to generate a task run command.
runTaskRequestFromECSService func(client ecs.ECSServiceDescriber, cluster, service string) (*ecs.RunTaskRequest, error)
runTaskRequestFromService func(client ecs.ServiceDescriber, app, env, svc string) (*ecs.RunTaskRequest, error)
runTaskRequestFromJob func(client ecs.JobDescriber, app, env, job string) (*ecs.RunTaskRequest, error)
// Cached variables.
ssmParamSecrets map[string]string
secretsManagerSecrets map[string]string
envFileARN string
envCompatibilityChecker func(app, env string) (versionCompatibilityChecker, error)
}
func newTaskRunOpts(vars runTaskVars) (*runTaskOpts, error) {
sessProvider := sessions.ImmutableProvider(sessions.UserAgentExtras("task run"))
defaultSess, err := sessProvider.Default()
if err != nil {
return nil, fmt.Errorf("default session: %v", err)
}
prompter := prompt.New()
store := config.NewSSMStore(identity.New(defaultSess), ssm.New(defaultSess), aws.StringValue(defaultSess.Config.Region))
opts := runTaskOpts{
runTaskVars: vars,
fs: &afero.Afero{Fs: afero.NewOsFs()},
store: store,
prompt: prompter,
sel: selector.NewAppEnvSelector(prompter, store),
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
provider: sessProvider,
secretsManagerSecrets: make(map[string]string),
ssmParamSecrets: make(map[string]string),
}
opts.configureRuntimeOpts = func() error {
opts.runner, err = opts.configureRunner()
if err != nil {
return fmt.Errorf("configure task runner: %w", err)
}
opts.deployer = cloudformation.New(opts.sess, cloudformation.WithProgressTracker(os.Stderr))
opts.defaultClusterGetter = awsecs.New(opts.sess)
opts.publicIPGetter = ec2.New(opts.sess)
return nil
}
opts.configureRepository = func() error {
repoName := fmt.Sprintf(deploy.FmtTaskECRRepoName, opts.groupName)
opts.repository = repository.New(ecr.New(opts.sess), repoName)
return nil
}
opts.configureEventsWriter = func(tasks []*task.Task) {
opts.eventsWriter = logging.NewTaskClient(opts.sess, opts.groupName, tasks)
}
opts.configureECSServiceDescriber = func(session *session.Session) ecs.ECSServiceDescriber {
return awsecs.New(session)
}
opts.configureServiceDescriber = func(session *session.Session) ecs.ServiceDescriber {
return ecs.New(session)
}
opts.configureJobDescriber = func(session *session.Session) ecs.JobDescriber {
return ecs.New(session)
}
opts.configureUploader = func(session *session.Session) uploader {
return s3.New(session)
}
opts.envCompatibilityChecker = func(app, env string) (versionCompatibilityChecker, error) {
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: app,
Env: env,
ConfigStore: opts.store,
})
if err != nil {
return nil, fmt.Errorf("new environment compatibility checker: %v", err)
}
return envDescriber, nil
}
opts.runTaskRequestFromECSService = ecs.RunTaskRequestFromECSService
opts.runTaskRequestFromService = ecs.RunTaskRequestFromService
opts.runTaskRequestFromJob = ecs.RunTaskRequestFromJob
return &opts, nil
}
func (o *runTaskOpts) configureRunner() (taskRunner, error) {
vpcGetter := ec2.New(o.sess)
ecsService := awsecs.New(o.sess)
if o.env != "" {
deployStore, err := deploy.NewStore(o.provider, o.store)
if err != nil {
return nil, fmt.Errorf("connect to copilot deploy store: %w", err)
}
d, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: o.appName,
Env: o.env,
ConfigStore: o.store,
DeployStore: deployStore,
EnableResources: false, // We don't need to show detailed resources.
})
if err != nil {
return nil, fmt.Errorf("create describer for environment %s in application %s: %w", o.env, o.appName, err)
}
ecsClient := ecs.New(o.sess)
return &task.EnvRunner{
Count: o.count,
GroupName: o.groupName,
App: o.appName,
Env: o.env,
SecurityGroups: o.securityGroups,
OS: o.os,
VPCGetter: vpcGetter,
ClusterGetter: ecsClient,
Starter: ecsService,
EnvironmentDescriber: d,
NonZeroExitCodeGetter: ecsClient,
}, nil
}
return &task.ConfigRunner{
Count: o.count,
GroupName: o.groupName,
Cluster: o.cluster,
Subnets: o.subnets,
SecurityGroups: o.securityGroups,
OS: o.os,
VPCGetter: vpcGetter,
ClusterGetter: ecsService,
Starter: ecsService,
NonZeroExitCodeGetter: ecs.New(o.sess),
}, nil
}
func (o *runTaskOpts) configureSessAndEnv() error {
var sess *session.Session
var env *config.Environment
if o.env != "" {
var err error
env, err = o.targetEnv(o.appName, o.env)
if err != nil {
return err
}
sess, err = o.provider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return fmt.Errorf("get session from role %s and region %s: %w", env.ManagerRoleARN, env.Region, err)
}
} else {
var err error
sess, err = o.provider.Default()
if err != nil {
return fmt.Errorf("get default session: %w", err)
}
}
o.targetEnvironment = env
o.sess = sess
return nil
}
// Validate returns an error if the flag values passed by the user are invalid.
func (o *runTaskOpts) Validate() error {
if o.generateCommandTarget != "" {
if o.nFlag >= 2 {
return errors.New("cannot specify `--generate-cmd` with any other flag")
}
}
if o.count <= 0 {
return errNumNotPositive
}
if o.groupName != "" {
if err := basicNameValidation(o.groupName); err != nil {
return err
}
}
if o.image != "" && o.isDockerfileSet {
return errors.New("cannot specify both `--image` and `--dockerfile`")
}
if o.image != "" && o.dockerfileContextPath != "" {
return errors.New("cannot specify both `--image` and `--build-context`")
}
if o.isDockerfileSet {
if _, err := o.fs.Stat(o.dockerfilePath); err != nil {
return fmt.Errorf("invalid `--dockerfile` path: %w", err)
}
}
if o.dockerfileContextPath != "" {
if _, err := o.fs.Stat(o.dockerfileContextPath); err != nil {
return fmt.Errorf("invalid `--build-context` path: %w", err)
}
}
if noOS, noArch := o.os == "", o.arch == ""; noOS != noArch {
return fmt.Errorf("must specify either both `--%s` and `--%s` or neither", osFlag, archFlag)
}
if err := o.validatePlatform(); err != nil {
return err
}
if o.cpu <= 0 {
return errCPUNotPositive
}
if o.memory <= 0 {
return errMemNotPositive
}
if err := o.validateFlagsWithCluster(); err != nil {
return err
}
if err := o.validateFlagsWithDefaultCluster(); err != nil {
return err
}
if err := o.validateFlagsWithSubnets(); err != nil {
return err
}
if err := o.validateFlagsWithWindows(); err != nil {
return err
}
if o.appName != "" {
if err := o.validateAppName(); err != nil {
return err
}
}
if o.env != "" {
if err := o.validateEnvName(); err != nil {
return err
}
}
for _, value := range o.secrets {
if !isSSM(value) && !isSecretsManager(value) {
return fmt.Errorf("must specify a valid secrets ARN")
}
}
if o.envFile != "" {
if filepath.Ext(o.envFile) != envFileExt {
return fmt.Errorf("environment file %s specified in --%s must have a %s file extension", o.envFile, envFileFlag, envFileExt)
}
}
return nil
}
func isSSM(value string) bool {
// For SSM parameter you can specify it as ARN or name if it exists in the same Region as the task you are launching.
return !template.IsARNFunc(value) || strings.Contains(value, ":ssm:")
}
func isSecretsManager(value string) bool {
return template.IsARNFunc(value) && strings.Contains(value, ":secretsmanager:")
}
func (o *runTaskOpts) getCategorizedSecrets() (map[string]string, map[string]string) {
if len(o.ssmParamSecrets) > 0 || len(o.secretsManagerSecrets) > 0 {
return o.secretsManagerSecrets, o.ssmParamSecrets
}
for name, value := range o.secrets {
if isSSM(value) {
o.ssmParamSecrets[name] = value
}
if isSecretsManager(value) {
o.secretsManagerSecrets[name] = value
}
}
return o.secretsManagerSecrets, o.ssmParamSecrets
}
func (o *runTaskOpts) confirmSecretsAccess() error {
if o.executionRole != "" {
return nil
}
if o.appName != "" || o.env != "" {
return nil
}
if o.acknowledgeSecretsAccess {
return nil
}
secretsManagerSecrets, ssmParamSecrets := o.getCategorizedSecrets()
log.Info("Looks like ")
if len(ssmParamSecrets) > 0 {
log.Infoln("you're requesting ssm:GetParameters to the following SSM parameters:")
} else {
log.Infoln("you're requesting secretsmanager:GetSecretValue to the following Secrets Manager secrets:")
}
for _, value := range ssmParamSecrets {
log.Infoln("* " + value)
}
if len(ssmParamSecrets) > 0 && len(secretsManagerSecrets) > 0 {
log.Infoln("\nand secretsmanager:GetSecretValue to the following Secrets Manager secrets:")
}
for _, value := range secretsManagerSecrets {
log.Infoln("* " + value)
}
secretsAccessConfirmed, err := o.prompt.Confirm(taskSecretsPermissionPrompt, taskSecretsPermissionPromptHelp)
if err != nil {
return fmt.Errorf("prompt to confirm secrets access: %w", err)
}
if !secretsAccessConfirmed {
return errors.New("access to secrets denied")
}
return nil
}
func (o *runTaskOpts) validateEnvCompatibilityForGenerateJobCmd(app, env string) error {
envStack, err := o.envCompatibilityChecker(app, env)
if err != nil {
return err
}
version, err := envStack.Version()
if err != nil {
return fmt.Errorf("retrieve version of environment stack %q in application %q: %v", env, app, err)
}
// The '--generate-cmd' flag was introduced in env v1.4.0. In env v1.8.0, EnvManagerRole took over, but
//"states:DescribeStateMachine" permissions weren't added until 1.12.2.
if semver.Compare(version, "v1.12.2") < 0 {
return &errFeatureIncompatibleWithEnvironment{
missingFeature: "task run --generate-cmd",
envName: env,
curVersion: version,
}
}
return nil
}
func (o *runTaskOpts) validatePlatform() error {
if o.os == "" {
return nil
}
o.os = strings.ToUpper(o.os)
o.arch = strings.ToUpper(o.arch)
validPlatforms := task.ValidCFNPlatforms
for _, validPlatform := range validPlatforms {
if dockerengine.PlatformString(o.os, o.arch) == validPlatform {
return nil
}
}
return fmt.Errorf("platform %s is invalid; %s: %s", dockerengine.PlatformString(o.os, o.arch), english.PluralWord(len(validPlatforms), "the valid platform is", "valid platforms are"), english.WordSeries(validPlatforms, "and"))
}
func (o *runTaskOpts) validateFlagsWithCluster() error {
if o.cluster == "" {
return nil
}
if o.appName != "" {
return fmt.Errorf("cannot specify both `--app` and `--cluster`")
}
if o.env != "" {
return fmt.Errorf("cannot specify both `--env` and `--cluster`")
}
if o.useDefaultSubnetsAndCluster {
return fmt.Errorf("cannot specify both `--default` and `--cluster`")
}
return nil
}
func (o *runTaskOpts) validateFlagsWithDefaultCluster() error {
if !o.useDefaultSubnetsAndCluster {
return nil
}
if o.subnets != nil {
return fmt.Errorf("cannot specify both `--subnets` and `--default`")
}
if o.appName != "" {
return fmt.Errorf("cannot specify both `--app` and `--default`")
}
if o.env != "" {
return fmt.Errorf("cannot specify both `--env` and `--default`")
}
return nil
}
func (o *runTaskOpts) validateFlagsWithSubnets() error {
if o.subnets == nil {
return nil
}
if o.useDefaultSubnetsAndCluster {
return fmt.Errorf("cannot specify both `--subnets` and `--default`")
}
if o.appName != "" {
return fmt.Errorf("cannot specify both `--subnets` and `--app`")
}
if o.env != "" {
return fmt.Errorf("cannot specify both `--subnets` and `--env`")
}
return nil
}
func (o *runTaskOpts) validateFlagsWithWindows() error {
if !isWindowsOS(o.os) {
return nil
}
if o.cpu < manifest.MinWindowsTaskCPU {
return fmt.Errorf("CPU is %d, but it must be at least %d for a Windows-based task", o.cpu, manifest.MinWindowsTaskCPU)
}
if o.memory < manifest.MinWindowsTaskMemory {
return fmt.Errorf("memory is %d, but it must be at least %d for a Windows-based task", o.memory, manifest.MinWindowsTaskMemory)
}
return nil
}
func isWindowsOS(os string) bool {
return task.IsValidWindowsOS(os)
}
// Ask prompts the user for any required or important fields that are not provided.
func (o *runTaskOpts) Ask() error {
if o.generateCommandTarget != "" {
return nil
}
if o.shouldPromptForAppEnv() {
if err := o.askAppName(); err != nil {
return err
}
if err := o.askEnvName(); err != nil {
return err
}
}
if len(o.secrets) > 0 {
if err := o.confirmSecretsAccess(); err != nil {
return err
}
}
return nil
}
func (o *runTaskOpts) shouldPromptForAppEnv() bool {
// NOTE: if security groups are specified but subnets are not, then we use the default subnets with the
// specified security groups.
useDefault := o.useDefaultSubnetsAndCluster || (o.securityGroups != nil && o.subnets == nil && o.cluster == "")
useConfig := o.subnets != nil || o.cluster != ""
// if user hasn't specified that they want to use the default subnets, and that they didn't provide specific subnets
// that they want to use, then we prompt.
return !useDefault && !useConfig
}
// Execute deploys and runs the task.
func (o *runTaskOpts) Execute() error {
if o.generateCommandTarget != "" {
return o.generateCommand()
}
if o.groupName == "" {
dir, err := os.Getwd()
if err != nil {
log.Errorf("Cannot retrieve working directory, please use --%s to specify a task group name.\n", taskGroupNameFlag)
return fmt.Errorf("get working directory: %v", err)
}
o.groupName = strings.ToLower(filepath.Base(dir))
}
// NOTE: all runtime options must be configured only after session is configured
if err := o.configureSessAndEnv(); err != nil {
return err
}
if err := o.configureRuntimeOpts(); err != nil {
return err
}
if o.env == "" && o.cluster == "" {
hasDefaultCluster, err := o.defaultClusterGetter.HasDefaultCluster()
if err != nil {
return fmt.Errorf(`find "default" cluster to deploy the task to: %v`, err)
}
if !hasDefaultCluster {
log.Errorf(
"Looks like there is no \"default\" cluster in your region!\nPlease run %s to create the cluster first, and then re-run %s.\n",
color.HighlightCode("aws ecs create-cluster"),
color.HighlightCode("copilot task run"),
)
return errors.New(`cannot find a "default" cluster to deploy the task to`)
}
}
if err := o.deployTaskResources(); err != nil {
return err
}
// NOTE: repository has to be configured only after task resources are deployed
if err := o.configureRepository(); err != nil {
return err
}
var shouldUpdate bool
if o.envFile != "" {
envFileARN, err := o.deployEnvFile()
if err != nil {
return fmt.Errorf("deploy env file %s: %w", o.envFile, err)
}
o.envFileARN = envFileARN
shouldUpdate = true
}
// NOTE: if image is not provided, then we build the image and push to ECR repo
if o.image == "" {
uri, err := o.repository.Login()
if err != nil {
return fmt.Errorf("login to docker: %w", err)
}
tag := imageTagLatest
if o.imageTag != "" {
tag = o.imageTag
}
o.image = fmt.Sprintf(fmtImageURI, uri, tag)
if err := o.buildAndPushImage(uri); err != nil {
return err
}
shouldUpdate = true
}
if shouldUpdate {
if err := o.updateTaskResources(); err != nil {
return err
}
}
tasks, err := o.runTask()
if err != nil {
if strings.Contains(err.Error(), "AccessDeniedException") && strings.Contains(err.Error(), "unable to pull secrets") && o.appName != "" && o.env != "" {
log.Error(`It looks like your task is not able to pull the secrets.
Did you tag your secrets with the "copilot-application" and "copilot-environment" tags?
`)
}
return err
}
o.showPublicIPs(tasks)
if o.follow {
o.configureEventsWriter(tasks)
if err := o.displayLogStream(); err != nil {
return err
}
if err := o.runner.CheckNonZeroExitCode(tasks); err != nil {
return err
}
}
return nil
}
func (o *runTaskOpts) generateCommand() error {
command, err := o.runTaskCommand()
if err != nil {
return err
}
cliString, err := command.CLIString()
if err != nil {
return err
}
log.Infoln(cliString)
return nil
}
func (o *runTaskOpts) runTaskCommand() (cliStringer, error) {
var cmd cliStringer
if arn.IsARN(o.generateCommandTarget) {
clusterName, serviceName, err := o.parseARN()
if err != nil {
return nil, err
}
sess, err := o.provider.Default()
if err != nil {
return nil, fmt.Errorf("get default session: %s", err)
}
return o.runTaskCommandFromECSService(sess, clusterName, serviceName)
}
parts := strings.Split(o.generateCommandTarget, "/")
switch len(parts) {
case 2:
clusterName, serviceName := parts[0], parts[1]
sess, err := o.provider.Default()
if err != nil {
return nil, fmt.Errorf("get default session: %s", err)
}
cmd, err = o.runTaskCommandFromECSService(sess, clusterName, serviceName)
if err != nil {
return nil, err
}
case 3:
appName, envName, workloadName := parts[0], parts[1], parts[2]
env, err := o.targetEnv(appName, envName)
if err != nil {
return nil, err
}
sess, err := o.provider.FromRole(env.ManagerRoleARN, env.Region)
if err != nil {
return nil, fmt.Errorf("get environment session: %s", err)
}
cmd, err = o.runTaskCommandFromWorkload(sess, appName, envName, workloadName)
if err != nil {
return nil, err
}
default:
return nil, errors.New("invalid input to --generate-cmd: must be of format <cluster>/<service> or <app>/<env>/<workload>")
}
return cmd, nil
}
func (o *runTaskOpts) parseARN() (string, string, error) {
svcARN := awsecs.ServiceArn(o.generateCommandTarget)
clusterName, err := svcARN.ClusterName()
if err != nil {
return "", "", fmt.Errorf("extract cluster name from arn %s: %w", svcARN, err)
}
serviceName, err := svcARN.ServiceName()
if err != nil {
return "", "", fmt.Errorf("extract service name from arn %s: %w", svcARN, err)
}
return clusterName, serviceName, nil
}
func (o *runTaskOpts) runTaskCommandFromECSService(sess *session.Session, clusterName, serviceName string) (cliStringer, error) {
cmd, err := o.runTaskRequestFromECSService(o.configureECSServiceDescriber(sess), clusterName, serviceName)
if err != nil {
var errMultipleContainers *ecs.ErrMultipleContainersInTaskDef
if errors.As(err, &errMultipleContainers) {
log.Errorln("`copilot task run` does not support running more than one container.")
}
return nil, fmt.Errorf("generate task run command from ECS service %s: %w", clusterName+"/"+serviceName, err)
}
return cmd, nil
}
func (o *runTaskOpts) runTaskCommandFromWorkload(sess *session.Session, appName, envName, workloadName string) (cliStringer, error) {
workloadType, err := o.workloadType(appName, workloadName)
if err != nil {
return nil, err
}
var cmd cliStringer
switch workloadType {
case workloadTypeJob:
if err := o.validateEnvCompatibilityForGenerateJobCmd(appName, envName); err != nil {
return nil, err
}
cmd, err = o.runTaskRequestFromJob(o.configureJobDescriber(sess), appName, envName, workloadName)
if err != nil {
return nil, fmt.Errorf("generate task run command from job %s of application %s deployed in environment %s: %w", workloadName, appName, envName, err)
}
case workloadTypeSvc:
cmd, err = o.runTaskRequestFromService(o.configureServiceDescriber(sess), appName, envName, workloadName)
if err != nil {
return nil, fmt.Errorf("generate task run command from service %s of application %s deployed in environment %s: %w", workloadName, appName, envName, err)
}
}
return cmd, nil
}
func (o *runTaskOpts) workloadType(appName, workloadName string) (string, error) {
_, err := o.store.GetJob(appName, workloadName)
if err == nil {
return workloadTypeJob, nil
}
var errNoSuchJob *config.ErrNoSuchJob
if !errors.As(err, &errNoSuchJob) {
return "", fmt.Errorf("determine whether workload %s is a job: %w", workloadName, err)
}
_, err = o.store.GetService(appName, workloadName)
if err == nil {
return workloadTypeSvc, nil
}
var errNoSuchService *config.ErrNoSuchService
if !errors.As(err, &errNoSuchService) {
return "", fmt.Errorf("determine whether workload %s is a service: %w", workloadName, err)
}
return workloadTypeInvalid, fmt.Errorf("workload %s is neither a service nor a job", workloadName)
}
func (o *runTaskOpts) displayLogStream() error {
if err := o.eventsWriter.WriteEventsUntilStopped(); err != nil {
return fmt.Errorf("write events: %w", err)
}
log.Infof("%s %s stopped.\n",
english.PluralWord(o.count, "Task", ""),
english.PluralWord(o.count, "has", "have"))
return nil
}
func (o *runTaskOpts) runTask() ([]*task.Task, error) {
o.spinner.Start(fmt.Sprintf("Waiting for %s to be running for %s.", english.Plural(o.count, "task", ""), o.groupName))
tasks, err := o.runner.Run()
if err != nil {
o.spinner.Stop(log.Serrorf("Failed to run %s.\n\n", o.groupName))
return nil, fmt.Errorf("run task %s: %w", o.groupName, err)
}
o.spinner.Stop(log.Ssuccessf("%s %s %s running.\n\n", english.PluralWord(o.count, "Task", ""), o.groupName, english.PluralWord(o.count, "is", "are")))
return tasks, nil
}
func (o *runTaskOpts) showPublicIPs(tasks []*task.Task) {
publicIPs := make(map[string]string)
for _, t := range tasks {
if t.ENI == "" {
continue
}
ip, err := o.publicIPGetter.PublicIP(t.ENI) // We will just not show the ip address if an error occurs.
if err == nil {
publicIPs[t.TaskARN] = ip
}
}
if len(publicIPs) == 0 {
return
}
log.Infof("%s associated with the %s %s:\n",
english.PluralWord(len(publicIPs), "The public IP", "Public IPs"),
english.PluralWord(len(publicIPs), "task", "tasks"),
english.PluralWord(len(publicIPs), "is", "are"))
for taskARN, ip := range publicIPs {
if len(taskARN) >= shortTaskIDLength {
taskARN = taskARN[len(taskARN)-shortTaskIDLength:]
}
log.Infof("- %s (for %s)\n", ip, taskARN)
}
}
func (o *runTaskOpts) buildAndPushImage(uri string) error {
var additionalTags []string
if o.imageTag != "" {
additionalTags = append(additionalTags, o.imageTag)
}
ctx := filepath.Dir(o.dockerfilePath)
if o.dockerfileContextPath != "" {
ctx = o.dockerfileContextPath
}
buildArgs := &dockerengine.BuildArguments{
URI: uri,
Dockerfile: o.dockerfilePath,
Context: ctx,
Tags: append([]string{imageTagLatest}, additionalTags...),
}
buildArgsList, err := buildArgs.GenerateDockerBuildArgs(dockerengine.New(exec.NewCmd()))
if err != nil {
return fmt.Errorf("generate docker build args: %w", err)
}
log.Infof("Building your container image: docker %s\n", strings.Join(buildArgsList, " "))
if _, err := o.repository.BuildAndPush(context.Background(), buildArgs, log.DiagnosticWriter); err != nil {
return fmt.Errorf("build and push image: %w", err)
}
return nil
}
func (o *runTaskOpts) deployTaskResources() error {
if err := o.deploy(); err != nil {
return fmt.Errorf("provision resources for task %s: %w", o.groupName, err)
}
return nil
}
func (o *runTaskOpts) updateTaskResources() error {
if err := o.deploy(); err != nil {
return fmt.Errorf("update resources for task %s: %w", o.groupName, err)
}
return nil
}
func (o *runTaskOpts) deploy() error {
var deployOpts []awscloudformation.StackOption
if o.env != "" {
deployOpts = []awscloudformation.StackOption{awscloudformation.WithRoleARN(o.targetEnvironment.ExecutionRoleARN)}
}
var boundaryPolicy string
if o.appName != "" {
app, err := o.store.GetApplication(o.appName)
if err != nil {
return fmt.Errorf("get application: %w", err)
}
boundaryPolicy = app.PermissionsBoundary
}
secretsManagerSecrets, ssmParamSecrets := o.getCategorizedSecrets()
entrypoint, err := shlex.Split(o.entrypoint)
if err != nil {
return fmt.Errorf("split entrypoint %s into tokens using shell-style rules: %w", o.entrypoint, err)
}
command, err := shlex.Split(o.command)
if err != nil {
return fmt.Errorf("split command %s into tokens using shell-style rules: %w", o.command, err)
}
input := &deploy.CreateTaskResourcesInput{
Name: o.groupName,
CPU: o.cpu,
Memory: o.memory,
Image: o.image,
PermissionsBoundary: boundaryPolicy,
TaskRole: o.taskRole,
ExecutionRole: o.executionRole,
Command: command,
EntryPoint: entrypoint,
EnvVars: o.envVars,
EnvFileARN: o.envFileARN,
SSMParamSecrets: ssmParamSecrets,
SecretsManagerSecrets: secretsManagerSecrets,
OS: o.os,
Arch: o.arch,
App: o.appName,
Env: o.env,
AdditionalTags: o.resourceTags,
}
return o.deployer.DeployTask(input, deployOpts...)
}
// deployEnvFileIfNeeded uploads the env file if needed, ensures that an S3 bucket is available, and returns the ARN of uploaded file.
func (o *runTaskOpts) deployEnvFile() (string, error) {
if o.envFile == "" {
return "", nil
}
info, err := o.deployer.GetTaskStack(o.groupName)
if err != nil {
return "", fmt.Errorf("deploy env file: %w", err)
}
// push env file
o.spinner.Start(fmt.Sprintf(fmtTaskRunEnvUploadStart, color.HighlightUserInput(o.envFile)))
envFileARN, err := o.pushEnvFileToS3(info.BucketName)
if err != nil {
o.spinner.Stop(log.Serrorf(fmtTaskRunEnvUploadFailed, color.HighlightUserInput(o.envFile)))
return "", err
}
o.spinner.Stop(log.Ssuccessf(fmtTaskRunEnvUploadComplete, color.HighlightUserInput(o.envFile)))
return envFileARN, nil
}
// pushEnvFileToS3 reads an env file from disk, uploads it to a unique path, and then returns the ARN of the env file.
func (o *runTaskOpts) pushEnvFileToS3(bucket string) (string, error) {
content, err := afero.ReadFile(o.fs, o.envFile)
if err != nil {
return "", fmt.Errorf("read env file %s: %w", o.envFile, err)
}
reader := bytes.NewReader(content)
uploader := o.configureUploader(o.sess)
url, err := uploader.Upload(bucket, artifactpath.EnvFiles(o.envFile, content), reader)
if err != nil {
return "", fmt.Errorf("put env file %s artifact to bucket %s: %w", o.envFile, bucket, err)
}
bucket, key, err := s3.ParseURL(url)
if err != nil {
return "", fmt.Errorf("parse s3 url: %w", err)
}
// The app and environment are always within the same partition.
partition, err := partitions.Region(aws.StringValue(o.sess.Config.Region)).Partition()
if err != nil {
return "", err
}
return s3.FormatARN(partition.ID(), fmt.Sprintf("%s/%s", bucket, key)), nil
}
func (o *runTaskOpts) validateAppName() error {
if _, err := o.store.GetApplication(o.appName); err != nil {
return fmt.Errorf("get application: %w", err)
}
return nil
}
func (o *runTaskOpts) validateEnvName() error {
if o.appName != "" {
if _, err := o.targetEnv(o.appName, o.env); err != nil {
return err
}
} else {
return errNoAppInWorkspace
}
return nil
}
func (o *runTaskOpts) askAppName() error {
if o.appName != "" {
return nil
}
// If the application is empty then the user wants to run in the default VPC. Do not prompt for an environment name.
app, err := o.sel.Application(taskRunAppPrompt, taskRunAppPromptHelp, appEnvOptionNone)
if err != nil {
return fmt.Errorf("ask for application: %w", err)
}
if app == appEnvOptionNone {
return nil
}
o.appName = app
return nil
}
func (o *runTaskOpts) askEnvName() error {
if o.env != "" {
return nil
}
// If the application is empty then the user wants to run in the default VPC. Do not prompt for an environment name.
if o.appName == "" || o.subnets != nil {
return nil
}
env, err := o.sel.Environment(taskRunEnvPrompt, taskRunEnvPromptHelp, o.appName, appEnvOptionNone)
if err != nil {
return fmt.Errorf("ask for environment: %w", err)
}
if env == appEnvOptionNone {
return nil
}
o.env = env
return nil
}
func (o *runTaskOpts) targetEnv(appName, envName string) (*config.Environment, error) {
env, err := o.store.GetEnvironment(appName, envName)
if err != nil {
return nil, fmt.Errorf("get environment %s config: %w", o.env, err)
}
return env, nil
}
// BuildTaskRunCmd build the command for running a new task
func BuildTaskRunCmd() *cobra.Command {
vars := runTaskVars{}
cmd := &cobra.Command{
Use: "run",
Short: "Run a one-off task on Amazon ECS.",
Example: `
Run a task using your local Dockerfile and display log streams after the task is running.
You will be prompted to specify an environment for the tasks to run in.
/code $ copilot task run
Run a task named "db-migrate" in the "test" environment under the current workspace.
/code $ copilot task run -n db-migrate --env test
Run 4 tasks with 2GB memory, an existing image, and a custom task role.
/code $ copilot task run --count 4 --memory 2048 --image=rds-migrate --task-role migrate-role
Run a task with environment variables.
/code $ copilot task run --env-vars name=myName,user=myUser
Run a task using the current workspace with specific subnets and security groups.
/code $ copilot task run --subnets subnet-123,subnet-456 --security-groups sg-123,sg-456
Run a task with a command.
/code $ copilot task run --command "python migrate-script.py"`,
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
opts, err := newTaskRunOpts(vars)
if err != nil {
return err
}
opts.nFlag = cmd.Flags().NFlag()
if cmd.Flags().Changed(dockerFileFlag) {
opts.isDockerfileSet = true
}
return run(opts)
}),
}
// add flags to comments.
cmd.Flags().StringVarP(&vars.groupName, taskGroupNameFlag, nameFlagShort, "", taskGroupFlagDescription)
cmd.Flags().StringVar(&vars.dockerfilePath, dockerFileFlag, defaultDockerfilePath, dockerFileFlagDescription)
cmd.Flags().StringVar(&vars.dockerfileContextPath, dockerFileContextFlag, "", dockerFileContextFlagDescription)
cmd.Flags().StringVarP(&vars.image, imageFlag, imageFlagShort, "", imageFlagDescription)
cmd.Flags().StringVar(&vars.imageTag, imageTagFlag, "", taskImageTagFlagDescription)
cmd.Flags().StringVar(&vars.appName, appFlag, "", taskAppFlagDescription)
cmd.Flags().StringVar(&vars.env, envFlag, "", taskEnvFlagDescription)
cmd.Flags().StringVar(&vars.cluster, clusterFlag, "", clusterFlagDescription)
cmd.Flags().BoolVar(&vars.acknowledgeSecretsAccess, acknowledgeSecretsAccessFlag, false, acknowledgeSecretsAccessDescription)
cmd.Flags().StringSliceVar(&vars.subnets, subnetsFlag, nil, subnetsFlagDescription)
cmd.Flags().StringSliceVar(&vars.securityGroups, securityGroupsFlag, nil, securityGroupsFlagDescription)
cmd.Flags().BoolVar(&vars.useDefaultSubnetsAndCluster, taskDefaultFlag, false, taskRunDefaultFlagDescription)
cmd.Flags().IntVar(&vars.count, countFlag, 1, countFlagDescription)
cmd.Flags().IntVar(&vars.cpu, cpuFlag, 256, cpuFlagDescription)
cmd.Flags().IntVar(&vars.memory, memoryFlag, 512, memoryFlagDescription)
cmd.Flags().StringVar(&vars.taskRole, taskRoleFlag, "", taskRoleFlagDescription)
cmd.Flags().StringVar(&vars.executionRole, executionRoleFlag, "", executionRoleFlagDescription)
cmd.Flags().StringVar(&vars.os, osFlag, "", osFlagDescription)
cmd.Flags().StringVar(&vars.arch, archFlag, "", archFlagDescription)
cmd.Flags().StringToStringVar(&vars.envVars, envVarsFlag, nil, envVarsFlagDescription)
cmd.Flags().StringVar(&vars.envFile, envFileFlag, "", envFileFlagDescription)
cmd.Flags().StringToStringVar(&vars.secrets, secretsFlag, nil, secretsFlagDescription)
cmd.Flags().StringVar(&vars.command, commandFlag, "", runCommandFlagDescription)
cmd.Flags().StringVar(&vars.entrypoint, entrypointFlag, "", entrypointFlagDescription)
cmd.Flags().StringToStringVar(&vars.resourceTags, resourceTagsFlag, nil, resourceTagsFlagDescription)
cmd.Flags().BoolVar(&vars.follow, followFlag, false, followFlagDescription)
cmd.Flags().StringVar(&vars.generateCommandTarget, generateCommandFlag, "", generateCommandFlagDescription)
// group flags.
nameFlags := pflag.NewFlagSet("Name", pflag.ContinueOnError)
nameFlags.AddFlag(cmd.Flags().Lookup(taskGroupNameFlag))
buildFlags := pflag.NewFlagSet("Build", pflag.ContinueOnError)
buildFlags.AddFlag(cmd.Flags().Lookup(dockerFileFlag))
buildFlags.AddFlag(cmd.Flags().Lookup(dockerFileContextFlag))
buildFlags.AddFlag(cmd.Flags().Lookup(imageFlag))
buildFlags.AddFlag(cmd.Flags().Lookup(imageTagFlag))
placementFlags := pflag.NewFlagSet("Placement", pflag.ContinueOnError)
placementFlags.AddFlag(cmd.Flags().Lookup(appFlag))
placementFlags.AddFlag(cmd.Flags().Lookup(envFlag))
placementFlags.AddFlag(cmd.Flags().Lookup(clusterFlag))
placementFlags.AddFlag(cmd.Flags().Lookup(subnetsFlag))
placementFlags.AddFlag(cmd.Flags().Lookup(securityGroupsFlag))
placementFlags.AddFlag(cmd.Flags().Lookup(taskDefaultFlag))
taskFlags := pflag.NewFlagSet("Task", pflag.ContinueOnError)
taskFlags.AddFlag(cmd.Flags().Lookup(countFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(cpuFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(memoryFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(taskRoleFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(executionRoleFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(osFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(archFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(envVarsFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(envFileFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(secretsFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(commandFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(entrypointFlag))
taskFlags.AddFlag(cmd.Flags().Lookup(resourceTagsFlag))
utilityFlags := pflag.NewFlagSet("Utility", pflag.ContinueOnError)
utilityFlags.AddFlag(cmd.Flags().Lookup(followFlag))
utilityFlags.AddFlag(cmd.Flags().Lookup(generateCommandFlag))
utilityFlags.AddFlag(cmd.Flags().Lookup(acknowledgeSecretsAccessFlag))
// prettify help menu.
cmd.Annotations = map[string]string{
"name": nameFlags.FlagUsages(),
"build": buildFlags.FlagUsages(),
"placement": placementFlags.FlagUsages(),
"task": taskFlags.FlagUsages(),
"utility": utilityFlags.FlagUsages(),
}
cmd.SetUsageTemplate(`{{h1 "Usage"}}
{{- if .Runnable}}
{{.UseLine}}
{{- end }}
{{h1 "Name Flags"}}
{{(index .Annotations "name") | trimTrailingWhitespaces}}
{{h1 "Build Flags"}}
{{(index .Annotations "build") | trimTrailingWhitespaces}}
{{h1 "Placement Flags"}}
{{(index .Annotations "placement") | trimTrailingWhitespaces}}
{{h1 "Task Configuration Flags"}}
{{(index .Annotations "task") | trimTrailingWhitespaces}}
{{h1 "Utility Flags"}}
{{(index .Annotations "utility") | trimTrailingWhitespaces}}
{{if .HasExample }}
{{- h1 "Examples"}}
{{- code .Example}}
{{- end}}
`)
return cmd
}
| 1,303 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"bytes"
"context"
"errors"
"fmt"
"path/filepath"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/ecs"
ecsMocks "github.com/aws/copilot-cli/internal/pkg/ecs/mocks"
"github.com/aws/copilot-cli/internal/pkg/cli/mocks"
"github.com/aws/copilot-cli/internal/pkg/task"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/golang/mock/gomock"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
)
type basicOpts struct {
inCount int
inCPU int
inMemory int
}
var defaultOpts = basicOpts{
inCount: 1,
inCPU: 256,
inMemory: 512,
}
type spinnerTestDouble struct {
startFn func(string)
stopFn func(string)
}
// Assert that spinnerTestDouble implements the [progress] interface.
var _ progress = (*spinnerTestDouble)(nil)
func (s *spinnerTestDouble) Start(label string) {
if s.startFn != nil {
s.startFn(label)
}
}
func (s *spinnerTestDouble) Stop(label string) {
if s.stopFn != nil {
s.stopFn(label)
}
}
func TestTaskRunOpts_Validate(t *testing.T) {
testCases := map[string]struct {
basicOpts
inName string
inImage string
inDockerfilePath string
inDockerfileContextPath string
inTaskRole string
inEnv string
inCluster string
inSubnets []string
inSecurityGroups []string
inEnvVars map[string]string
inEnvFile string
inSecrets map[string]string
inCommand string
inEntryPoint string
inOS string
inArch string
inDefault bool
inGenerateCommandTarget string
appName string
isDockerfileSet bool
mockStore func(m *mocks.Mockstore)
mockFileSystem func(mockFS afero.Fs)
wantedError error
}{
"valid with no flag": {
basicOpts: defaultOpts,
wantedError: nil,
},
"valid with flags image and env": {
basicOpts: defaultOpts,
inName: "my-task",
inImage: "113459295.dkr.ecr.ap-northeast-1.amazonaws.com/my-app",
inTaskRole: "exec-role",
inEnv: "dev",
inEnvVars: map[string]string{
"NAME": "my-app",
"ENV": "dev",
},
inSecrets: map[string]string{
"quiet": "barky doggo",
},
inCommand: "echo hello world",
inEntryPoint: "exec 'enter here'",
appName: "my-app",
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
}, nil)
m.EXPECT().GetEnvironment("my-app", "dev").Return(&config.Environment{
App: "my-app",
Name: "dev",
}, nil)
},
wantedError: nil,
},
"valid without flags image and env": {
basicOpts: defaultOpts,
inName: "my-task",
inDockerfilePath: "hello/world/Dockerfile",
inTaskRole: "exec-role",
inSubnets: []string{"subnet-10d938jds"},
inSecurityGroups: []string{"sg-0d9sjdk", "sg-d33kds99"},
inEnvVars: map[string]string{
"NAME": "pj",
"ENV": "dev",
},
inCommand: "echo hello world",
mockFileSystem: func(mockFS afero.Fs) {
mockFS.MkdirAll("hello/world", 0755)
afero.WriteFile(mockFS, "hello/world/Dockerfile", []byte("FROM nginx"), 0644)
},
wantedError: nil,
},
"invalid with os but not arch": {
basicOpts: defaultOpts,
inOS: "WINDOWS_SERVER_2019_CORE",
wantedError: errors.New("must specify either both `--platform-os` and `--platform-arch` or neither"),
},
"invalid with arch but not os": {
basicOpts: defaultOpts,
inArch: "X86_64",
wantedError: errors.New("must specify either both `--platform-os` and `--platform-arch` or neither"),
},
"invalid platform": {
basicOpts: defaultOpts,
inOS: "OStrich",
inArch: "MAD666",
wantedError: errors.New("platform OSTRICH/MAD666 is invalid; valid platforms are: WINDOWS_SERVER_2019_CORE/X86_64, WINDOWS_SERVER_2019_FULL/X86_64, WINDOWS_SERVER_2022_CORE/X86_64, WINDOWS_SERVER_2022_FULL/X86_64, LINUX/X86_64 and LINUX/ARM64"),
},
"uppercase any lowercase before validating": {
basicOpts: basicOpts{
inCount: 1,
inCPU: 1024,
inMemory: 2048,
},
inOS: "windows_server_2019_core",
inArch: "x86_64",
wantedError: nil,
},
"invalid number of tasks": {
basicOpts: basicOpts{
inCount: -1,
inCPU: 256,
inMemory: 512,
},
wantedError: errNumNotPositive,
},
"invalid number of CPU units": {
basicOpts: basicOpts{
inCount: 1,
inCPU: -15,
inMemory: 512,
},
wantedError: errCPUNotPositive,
},
"invalid number of CPU units for Windows task": {
basicOpts: basicOpts{
inCount: 1,
inCPU: 260,
inMemory: 512,
},
inOS: "WINDOWS_SERVER_2019_CORE",
inArch: "X86_64",
wantedError: errors.New("CPU is 260, but it must be at least 1024 for a Windows-based task"),
},
"invalid memory": {
basicOpts: basicOpts{
inCount: 1,
inCPU: 256,
inMemory: -1024,
},
wantedError: errMemNotPositive,
},
"invalid memory for Windows task": {
basicOpts: basicOpts{
inCount: 1,
inCPU: 1024,
inMemory: 2000,
},
inOS: "WINDOWS_SERVER_2019_CORE",
inArch: "X86_64",
wantedError: errors.New("memory is 2000, but it must be at least 2048 for a Windows-based task"),
},
"both build context and image name specified": {
basicOpts: defaultOpts,
inImage: "113459295.dkr.ecr.ap-northeast-1.amazonaws.com/my-app",
inDockerfileContextPath: "../../other",
wantedError: errors.New("cannot specify both `--image` and `--build-context`"),
},
"both dockerfile and image name specified": {
basicOpts: defaultOpts,
inImage: "113459295.dkr.ecr.ap-northeast-1.amazonaws.com/my-app",
isDockerfileSet: true,
wantedError: errors.New("cannot specify both `--image` and `--dockerfile`"),
},
"invalid dockerfile path": {
basicOpts: defaultOpts,
inDockerfilePath: "world/hello/Dockerfile",
isDockerfileSet: true,
wantedError: fmt.Errorf("invalid `--dockerfile` path: open %s: file does not exist", filepath.FromSlash("world/hello/Dockerfile")),
},
"invalid build context path": {
basicOpts: defaultOpts,
inDockerfileContextPath: "world/hello/Dockerfile",
wantedError: fmt.Errorf("invalid `--build-context` path: open %s: file does not exist", filepath.FromSlash("world/hello/Dockerfile")),
},
"specified app exists": {
basicOpts: defaultOpts,
appName: "my-app",
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
}, nil)
},
wantedError: nil,
},
"unknown app": {
basicOpts: defaultOpts,
appName: "my-app",
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetApplication("my-app").Return(nil, &config.ErrNoSuchApplication{
ApplicationName: "my-app",
AccountID: "115",
Region: "us-east-1",
})
},
wantedError: errors.New("get application: couldn't find an application named my-app in account 115 and region us-east-1"),
},
"env exists in app": {
basicOpts: defaultOpts,
appName: "my-app",
inEnv: "dev",
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetEnvironment("my-app", "dev").Return(&config.Environment{
App: "my-app",
Name: "dev",
}, nil)
m.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
}, nil)
},
wantedError: nil,
},
"unknown env in app": {
basicOpts: defaultOpts,
appName: "my-app",
inEnv: "dev",
mockStore: func(m *mocks.Mockstore) {
m.EXPECT().GetEnvironment("my-app", "dev").Return(nil, &config.ErrNoSuchEnvironment{
ApplicationName: "my-app",
EnvironmentName: "dev",
})
m.EXPECT().GetApplication("my-app").Return(&config.Application{
Name: "my-app",
}, nil)
},
wantedError: errors.New("get environment dev config: couldn't find environment dev in the application my-app"),
},
"no workspace": {
basicOpts: defaultOpts,
inEnv: "test",
wantedError: errNoAppInWorkspace,
},
"both environment and subnets specified": {
basicOpts: defaultOpts,
inEnv: "test",
inSubnets: []string{"subnet id"},
wantedError: errors.New("cannot specify both `--subnets` and `--env`"),
},
"both application and subnets specified": {
basicOpts: defaultOpts,
appName: "my-app",
inSubnets: []string{"subnet id"},
wantedError: errors.New("cannot specify both `--subnets` and `--app`"),
},
"both default and subnets specified": {
basicOpts: defaultOpts,
inDefault: true,
inSubnets: []string{"subnet id"},
wantedError: errors.New("cannot specify both `--subnets` and `--default`"),
},
"both cluster and default specified": {
basicOpts: defaultOpts,
inDefault: true,
inCluster: "special-cluster",
wantedError: errors.New("cannot specify both `--default` and `--cluster`"),
},
"both cluster and application specified": {
basicOpts: defaultOpts,
inCluster: "special-cluster",
appName: "my-app",
wantedError: errors.New("cannot specify both `--app` and `--cluster`"),
},
"both cluster and environment specified": {
basicOpts: defaultOpts,
inCluster: "special-cluster",
inEnv: "my-env",
wantedError: errors.New("cannot specify both `--env` and `--cluster`"),
},
"generate-cmd specified with another flag": {
basicOpts: defaultOpts,
inGenerateCommandTarget: "cluster/service", // nFlag is set to 2.
wantedError: errors.New("cannot specify `--generate-cmd` with any other flag"),
},
"invalid env file extension": {
basicOpts: defaultOpts,
inEnvFile: "test.efdnv",
wantedError: errors.New("environment file test.efdnv specified in --env-file must have a .env file extension"),
},
"valid env file extension": {
basicOpts: defaultOpts,
inEnvFile: "test.env",
wantedError: nil,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStore := mocks.NewMockstore(ctrl)
opts := runTaskOpts{
runTaskVars: runTaskVars{
appName: tc.appName,
count: tc.inCount,
cpu: tc.inCPU,
memory: tc.inMemory,
groupName: tc.inName,
image: tc.inImage,
env: tc.inEnv,
taskRole: tc.inTaskRole,
cluster: tc.inCluster,
subnets: tc.inSubnets,
securityGroups: tc.inSecurityGroups,
dockerfilePath: tc.inDockerfilePath,
dockerfileContextPath: tc.inDockerfileContextPath,
envVars: tc.inEnvVars,
envFile: tc.inEnvFile,
secrets: tc.inSecrets,
command: tc.inCommand,
entrypoint: tc.inEntryPoint,
useDefaultSubnetsAndCluster: tc.inDefault,
generateCommandTarget: tc.inGenerateCommandTarget,
os: tc.inOS,
arch: tc.inArch,
},
isDockerfileSet: tc.isDockerfileSet,
nFlag: 2,
fs: &afero.Afero{Fs: afero.NewMemMapFs()},
store: mockStore,
}
if tc.mockFileSystem != nil {
tc.mockFileSystem(opts.fs)
}
if tc.mockStore != nil {
tc.mockStore(mockStore)
}
err := opts.Validate()
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
func TestTaskRunOpts_Ask(t *testing.T) {
testCases := map[string]struct {
inName string
inCluster string
inSubnets []string
inSecurityGroups []string
inDefault bool
inEnv string
appName string
inSecrets map[string]string
inSsmParamSecrets map[string]string
inSecretsManagerSecrets map[string]string
inAcknowledgeSecretsAccess bool
inExecutionRole string
mockSel func(m *mocks.MockappEnvSelector)
mockPrompt func(m *mocks.Mockprompter)
wantedError error
wantedApp string
wantedEnv string
wantedName string
}{
"selected an existing application": {
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), appEnvOptionNone).Return("app", nil)
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
},
wantedApp: "app",
},
"selected None app": {
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), appEnvOptionNone).Return(appEnvOptionNone, nil)
},
wantedApp: "",
},
"don't prompt for app when under a workspace or app flag is specified": {
appName: "my-app",
inDefault: true,
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).Times(0)
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).AnyTimes()
},
wantedApp: "my-app",
},
"don't prompt for env if env is provided": {
inEnv: "test",
appName: "my-app",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedEnv: "test",
wantedApp: "my-app",
},
"don't prompt for env if no workspace and selected None app": {
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(gomock.Any(), gomock.Any(), appEnvOptionNone).Return(appEnvOptionNone, nil)
m.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedEnv: "",
},
"don't prompt for app if using default": {
inDefault: true,
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).Times(0)
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).AnyTimes()
},
wantedApp: "",
},
"don't prompt for env if using default": {
inDefault: true,
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(gomock.Any(), gomock.Any(), appEnvOptionNone).AnyTimes()
m.EXPECT().Environment(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
},
wantedEnv: "",
},
"don't prompt for app if subnets are specified": {
inSubnets: []string{"subnet-1"},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).Times(0)
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).AnyTimes()
},
},
"don't prompt for app if cluster is specified": {
inCluster: "cluster-1",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).AnyTimes()
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).Times(0)
},
},
"don't prompt for env if subnets are specified": {
inSubnets: []string{"subnet-1"},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).AnyTimes()
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).Times(0)
},
},
"don't prompt for env if cluster is specified": {
inCluster: "cluster-1",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).AnyTimes()
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).Times(0)
},
},
"don't prompt for app if security groups are specified": {
inSecurityGroups: []string{"sg-1"},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).Times(0)
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).AnyTimes()
},
},
"don't prompt for env if security groups are specified": {
inSecurityGroups: []string{"sg-1"},
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Application(taskRunAppPrompt, gomock.Any(), gomock.Any()).AnyTimes()
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).Times(0)
},
},
"selected an existing environment": {
appName: "my-app",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(),
"my-app", appEnvOptionNone).Return("test", nil)
},
wantedEnv: "test",
wantedApp: "my-app",
},
"selected None env": {
appName: "my-app",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(),
"my-app", appEnvOptionNone).Return(appEnvOptionNone, nil)
},
wantedEnv: "",
wantedApp: "my-app",
},
"error selecting environment": {
appName: "my-app",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
},
mockSel: func(m *mocks.MockappEnvSelector) {
m.EXPECT().Environment(taskRunEnvPrompt, gomock.Any(), gomock.Any(), appEnvOptionNone).
Return("", fmt.Errorf("error selecting environment"))
},
wantedError: errors.New("ask for environment: error selecting environment"),
},
"When secrets are provided without app and env leads to a secret access permission prompt": {
inSecrets: map[string]string{
"quiet": "shh",
},
inSsmParamSecrets: map[string]string{
"quiet": "shh",
},
inSecretsManagerSecrets: map[string]string{
"quiet": "shh",
},
inCluster: "cluster-1",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm(taskSecretsPermissionPrompt, taskSecretsPermissionPromptHelp).Return(true, nil)
},
},
"secret access permission prompt is skipped when acknowledge-secret-access flag is provided": {
inSecrets: map[string]string{
"quiet": "shh",
},
inCluster: "cluster-1",
inAcknowledgeSecretsAccess: true,
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm(taskSecretsPermissionPrompt, taskSecretsPermissionPromptHelp).Times(0)
},
},
"secret access permission prompt is skipped when execution-role is provided": {
inSecrets: map[string]string{
"quiet": "shh",
},
inCluster: "cluster-1",
inExecutionRole: "test-role",
mockPrompt: func(m *mocks.Mockprompter) {
m.EXPECT().Confirm(taskSecretsPermissionPrompt, taskSecretsPermissionPromptHelp).Times(0)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockSel := mocks.NewMockappEnvSelector(ctrl)
mockPrompter := mocks.NewMockprompter(ctrl)
if tc.mockSel != nil {
tc.mockSel(mockSel)
}
if tc.mockPrompt != nil {
tc.mockPrompt(mockPrompter)
}
opts := runTaskOpts{
runTaskVars: runTaskVars{
appName: tc.appName,
groupName: tc.inName,
env: tc.inEnv,
useDefaultSubnetsAndCluster: tc.inDefault,
subnets: tc.inSubnets,
securityGroups: tc.inSecurityGroups,
cluster: tc.inCluster,
acknowledgeSecretsAccess: tc.inAcknowledgeSecretsAccess,
secrets: tc.inSecrets,
executionRole: tc.inExecutionRole,
},
sel: mockSel,
prompt: mockPrompter,
secretsManagerSecrets: tc.inSecretsManagerSecrets,
ssmParamSecrets: tc.inSsmParamSecrets,
}
err := opts.Ask()
if tc.wantedError == nil {
require.NoError(t, err)
require.Equal(t, tc.wantedEnv, opts.env)
require.Equal(t, tc.wantedApp, opts.appName)
if tc.wantedName != "" {
require.Equal(t, tc.wantedName, opts.groupName)
}
} else {
require.EqualError(t, tc.wantedError, err.Error())
}
})
}
}
type runTaskMocks struct {
deployer *mocks.MocktaskDeployer
repository *mocks.MockrepositoryService
runner *mocks.MocktaskRunner
store *mocks.Mockstore
eventsWriter *mocks.MockeventsWriter
defaultClusterGetter *mocks.MockdefaultClusterGetter
publicIPGetter *mocks.MockpublicIPGetter
provider *mocks.MocksessionProvider
uploader *mocks.Mockuploader
}
func mockHasDefaultCluster(m runTaskMocks) {
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Return(true, nil).AnyTimes()
}
func mockRepositoryAnytime(m runTaskMocks) {
m.repository.EXPECT().Login().AnyTimes()
m.repository.EXPECT().BuildAndPush(context.Background(), gomock.Any(), gomock.Any()).AnyTimes()
}
func TestTaskRunOpts_Execute(t *testing.T) {
const (
inGroupName = "my-task"
mockRepoURI = "uri/repo"
tag = "tag"
)
ctx := context.Background()
defaultBuildArguments := dockerengine.BuildArguments{
URI: mockRepoURI,
Context: filepath.Dir(defaultDockerfilePath),
Tags: []string{imageTagLatest},
}
testCases := map[string]struct {
inSecrets map[string]string
inImage string
inTag string
inDockerCtx string
inFollow bool
inCommand string
inEntryPoint string
inEnvFile string
inApp string
inEnv string
setupFs func(fs *afero.Afero)
setupMocks func(m runTaskMocks)
wantedError error
}{
"check if default cluster exists if deploying to default cluster": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Return(true, nil)
m.deployer.EXPECT().DeployTask(gomock.Any()).Return(nil).AnyTimes()
mockRepositoryAnytime(m)
m.runner.EXPECT().Run().AnyTimes()
},
},
"do not check for default cluster if deploying to environment": {
inEnv: "test",
setupMocks: func(m runTaskMocks) {
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Times(0)
m.store.EXPECT().
GetEnvironment(gomock.Any(), "test").
Return(&config.Environment{
ExecutionRoleARN: "env execution role",
}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any())
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
mockRepositoryAnytime(m)
m.runner.EXPECT().Run().AnyTimes()
},
},
"error deploying resources": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.deployer.EXPECT().DeployTask(&deploy.CreateTaskResourcesInput{
Name: inGroupName,
Image: "",
Command: []string{},
EntryPoint: []string{},
}).Return(errors.New("error deploying"))
mockHasDefaultCluster(m)
},
wantedError: errors.New("provision resources for task my-task: error deploying"),
},
"error performing docker login": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.deployer.EXPECT().DeployTask(&deploy.CreateTaskResourcesInput{
Name: inGroupName,
Image: "",
Command: []string{},
EntryPoint: []string{},
}).Return(nil)
m.repository.EXPECT().Login().Return(mockRepoURI, errors.New("some error"))
mockHasDefaultCluster(m)
},
wantedError: errors.New("login to docker: some error"),
},
"error updating resources": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.deployer.EXPECT().DeployTask(&deploy.CreateTaskResourcesInput{
Name: inGroupName,
Image: "",
Command: []string{},
EntryPoint: []string{},
}).Return(nil)
m.repository.EXPECT().Login().Return(mockRepoURI, nil)
m.repository.EXPECT().BuildAndPush(ctx, gomock.Any(), gomock.Any())
m.deployer.EXPECT().DeployTask(&deploy.CreateTaskResourcesInput{
Name: inGroupName,
Image: "uri/repo:latest",
Command: []string{},
EntryPoint: []string{},
}).Times(1).Return(errors.New("error updating"))
mockHasDefaultCluster(m)
},
wantedError: errors.New("update resources for task my-task: error updating"),
},
"error running tasks": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.deployer.EXPECT().DeployTask(gomock.Any()).Return(nil).Times(2)
mockRepositoryAnytime(m)
m.runner.EXPECT().Run().Return(nil, errors.New("error running"))
mockHasDefaultCluster(m)
},
wantedError: errors.New("run task my-task: error running"),
},
"deploy with execution role option if env is not empty": {
inEnv: "test",
setupMocks: func(m runTaskMocks) {
m.store.EXPECT().GetEnvironment(gomock.Any(), "test").
Return(&config.Environment{
ExecutionRoleARN: "env execution role",
}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any())
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Len(1)).AnyTimes() // NOTE: matching length because gomock is unable to match function arguments.
mockRepositoryAnytime(m)
m.runner.EXPECT().Run().AnyTimes()
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Times(0)
},
},
"deploy without execution role option if env is empty": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).Times(0)
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Len(0)).AnyTimes() // NOTE: matching length because gomock is unable to match function arguments.
mockRepositoryAnytime(m)
m.runner.EXPECT().Run().AnyTimes()
mockHasDefaultCluster(m)
},
},
"append 'latest' to image tag": {
inTag: tag,
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.deployer.EXPECT().DeployTask(gomock.Any()).AnyTimes()
m.repository.EXPECT().Login().Return(mockRepoURI, nil)
m.repository.EXPECT().BuildAndPush(ctx, gomock.Eq(
&dockerengine.BuildArguments{
URI: mockRepoURI,
Context: filepath.Dir(defaultDockerfilePath),
Tags: []string{imageTagLatest, tag},
}), gomock.Any(),
)
m.runner.EXPECT().Run().AnyTimes()
mockHasDefaultCluster(m)
},
},
"should use provided docker build context instead of dockerfile path": {
inDockerCtx: "../../other",
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.deployer.EXPECT().DeployTask(gomock.Any()).AnyTimes()
m.repository.EXPECT().Login().Return(mockRepoURI, nil)
m.repository.EXPECT().BuildAndPush(ctx, gomock.Eq(
&dockerengine.BuildArguments{
URI: mockRepoURI,
Context: "../../other",
Tags: []string{imageTagLatest},
}), gomock.Any(),
)
m.runner.EXPECT().Run().AnyTimes()
mockHasDefaultCluster(m)
},
},
"update image to task resource if image is not provided": {
inCommand: `/bin/sh -c "curl $ECS_CONTAINER_METADATA_URI_V4"`,
inEntryPoint: `exec "some command"`,
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.store.EXPECT().GetEnvironment(gomock.Any(), gomock.Any()).AnyTimes()
m.deployer.EXPECT().DeployTask(&deploy.CreateTaskResourcesInput{
Name: inGroupName,
Image: "",
Command: []string{"/bin/sh", "-c", "curl $ECS_CONTAINER_METADATA_URI_V4"},
EntryPoint: []string{"exec", "some command"},
}).Times(1).Return(nil)
m.repository.EXPECT().Login().Return(mockRepoURI, nil)
m.repository.EXPECT().BuildAndPush(ctx, gomock.Eq(&defaultBuildArguments), gomock.Any())
m.deployer.EXPECT().DeployTask(&deploy.CreateTaskResourcesInput{
Name: inGroupName,
Image: "uri/repo:latest",
Command: []string{"/bin/sh", "-c", "curl $ECS_CONTAINER_METADATA_URI_V4"},
EntryPoint: []string{"exec", "some command"},
}).Times(1).Return(nil)
m.runner.EXPECT().Run().AnyTimes()
mockHasDefaultCluster(m)
},
},
"fail to get ENI information for some tasks": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.deployer.EXPECT().DeployTask(gomock.Any()).AnyTimes()
m.runner.EXPECT().Run().Return([]*task.Task{
{
TaskARN: "task-1",
ENI: "eni-1",
},
{
TaskARN: "task-2",
},
{
TaskARN: "task-3",
},
}, nil)
m.publicIPGetter.EXPECT().PublicIP("eni-1").Return("1.2.3", nil)
mockHasDefaultCluster(m)
mockRepositoryAnytime(m)
},
},
"fail to get public ips": {
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.deployer.EXPECT().DeployTask(gomock.Any()).AnyTimes()
m.runner.EXPECT().Run().Return([]*task.Task{
{
TaskARN: "task-1",
ENI: "eni-1",
},
}, nil)
m.publicIPGetter.EXPECT().PublicIP("eni-1").Return("", errors.New("some error"))
mockHasDefaultCluster(m)
mockRepositoryAnytime(m)
},
// wantedError is nil because we will just not show the IP address if we can't instead of erroring out.
},
"fail to write events": {
inFollow: true,
inImage: "image",
setupMocks: func(m runTaskMocks) {
m.provider.EXPECT().Default().Return(&session.Session{}, nil)
m.deployer.EXPECT().DeployTask(gomock.Any()).AnyTimes()
m.runner.EXPECT().Run().Return([]*task.Task{
{
TaskARN: "task-1",
ENI: "eni-1",
},
}, nil)
m.publicIPGetter.EXPECT().PublicIP("eni-1").Return("1.2.3", nil)
m.eventsWriter.EXPECT().WriteEventsUntilStopped().Times(1).
Return(errors.New("error writing events"))
mockHasDefaultCluster(m)
},
wantedError: errors.New("write events: error writing events"),
},
"error getting app config (to look for permissions boundary policy)": {
inApp: "my-app",
inEnv: "test",
setupMocks: func(m runTaskMocks) {
m.store.EXPECT().GetEnvironment(gomock.Any(), "test").
Return(&config.Environment{
ExecutionRoleARN: "env execution role",
}, nil)
m.provider.EXPECT().FromRole(gomock.Any(), gomock.Any())
m.store.EXPECT().GetApplication("my-app").Return(nil, errors.New("some error"))
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Len(1)).AnyTimes() // NOTE: matching length because gomock is unable to match function arguments.
mockRepositoryAnytime(m)
m.runner.EXPECT().Run().AnyTimes()
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Times(0)
},
wantedError: fmt.Errorf("provision resources for task %s: get application: some error", "my-task"),
},
"env file happy path": {
inEnvFile: "testdir/../magic.env",
inApp: "my-app",
inImage: "some-image",
setupFs: func(fs *afero.Afero) {
afero.Fs.Mkdir(fs, "testdir", 0755)
afero.WriteFile(fs, "magic.env", []byte("SOMETHING=VALUE"), 0644)
},
setupMocks: func(m runTaskMocks) {
region := "us-east-35"
m.provider.EXPECT().Default().Return(&session.Session{
Config: &aws.Config{
// uh oh, new leaked region
Region: aws.String(region),
},
}, nil)
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Return(true, nil)
info := deploy.TaskStackInfo{BucketName: "arn:aws:s3:::bigbucket"}
m.store.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil).Times(2)
m.deployer.EXPECT().GetTaskStack(inGroupName).Return(&info, nil)
key := "manual/env-files/magic.env/4963d64294508aa3fa103ccac5ad1537944c577d469608ddccad09b6f79b6406.env"
url := "https://bigbucket.s3-us-west-2.amazonaws.com/" + key
m.uploader.EXPECT().Upload("arn:aws:s3:::bigbucket", key,
bytes.NewReader([]byte("SOMETHING=VALUE"))).Return(url, nil)
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
mockRepositoryAnytime(m)
m.runner.EXPECT().Run().AnyTimes()
},
},
"env file not found": {
inEnvFile: "sadness.env",
inApp: "my-app",
setupMocks: func(m runTaskMocks) {
region := "us-east-35"
m.provider.EXPECT().Default().Return(&session.Session{
Config: &aws.Config{
// uh oh, new leaked region
Region: aws.String(region),
},
}, nil)
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Return(true, nil)
info := deploy.TaskStackInfo{BucketName: "arn:aws:s3:::bigbucket"}
m.store.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil)
m.deployer.EXPECT().GetTaskStack(inGroupName).Return(&info, nil)
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Any()).Return(nil)
},
wantedError: errors.New("deploy env file sadness.env: read env file sadness.env: open sadness.env: file does not exist"),
},
"env file pipeline resource add fail": {
inEnvFile: "testdir/../magic.env",
inApp: "my-app",
setupFs: func(fs *afero.Afero) {
afero.Fs.Mkdir(fs, "testdir", 0755)
afero.WriteFile(fs, "magic.env", []byte("SOMETHING=VALUE"), 0644)
},
setupMocks: func(m runTaskMocks) {
region := "us-east-35"
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Any()).Return(nil)
m.provider.EXPECT().Default().Return(&session.Session{
Config: &aws.Config{
// uh oh, new leaked region
Region: aws.String(region),
},
}, nil)
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Return(true, nil)
m.store.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil)
m.deployer.EXPECT().GetTaskStack(inGroupName).Return(nil, errors.New("hull breach in sector 3"))
},
wantedError: errors.New("deploy env file testdir/../magic.env: deploy env file: hull breach in sector 3"),
},
"env file s3 upload failure": {
inEnvFile: "testdir/../magic.env",
inApp: "my-app",
setupFs: func(fs *afero.Afero) {
afero.Fs.Mkdir(fs, "testdir", 0755)
afero.WriteFile(fs, "magic.env", []byte("SOMETHING=VALUE"), 0644)
},
setupMocks: func(m runTaskMocks) {
region := "us-east-35"
m.deployer.EXPECT().DeployTask(gomock.Any(), gomock.Any()).Return(nil)
m.provider.EXPECT().Default().Return(&session.Session{
Config: &aws.Config{
// uh oh, new leaked region
Region: aws.String(region),
},
}, nil)
m.defaultClusterGetter.EXPECT().HasDefaultCluster().Return(true, nil)
info := deploy.TaskStackInfo{BucketName: "arn:aws:s3:::bigbucket"}
m.store.EXPECT().GetApplication("my-app").Return(&config.Application{Name: "my-app"}, nil)
m.deployer.EXPECT().GetTaskStack(inGroupName).Return(&info, nil)
key := "manual/env-files/magic.env/4963d64294508aa3fa103ccac5ad1537944c577d469608ddccad09b6f79b6406.env"
arn := "arn:aws:s3:::bigbucket/" + key
m.uploader.EXPECT().Upload("arn:aws:s3:::bigbucket", key,
bytes.NewReader([]byte("SOMETHING=VALUE"))).Return(arn, errors.New("out of floppy disks"))
},
wantedError: errors.New("deploy env file testdir/../magic.env: put env file testdir/../magic.env artifact to bucket arn:aws:s3:::bigbucket: out of floppy disks"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
fs := &afero.Afero{Fs: afero.NewMemMapFs()}
if tc.setupFs != nil {
tc.setupFs(fs)
}
mocks := runTaskMocks{
deployer: mocks.NewMocktaskDeployer(ctrl),
repository: mocks.NewMockrepositoryService(ctrl),
runner: mocks.NewMocktaskRunner(ctrl),
store: mocks.NewMockstore(ctrl),
eventsWriter: mocks.NewMockeventsWriter(ctrl),
defaultClusterGetter: mocks.NewMockdefaultClusterGetter(ctrl),
publicIPGetter: mocks.NewMockpublicIPGetter(ctrl),
provider: mocks.NewMocksessionProvider(ctrl),
uploader: mocks.NewMockuploader(ctrl),
}
tc.setupMocks(mocks)
opts := &runTaskOpts{
runTaskVars: runTaskVars{
groupName: inGroupName,
image: tc.inImage,
imageTag: tc.inTag,
dockerfileContextPath: tc.inDockerCtx,
appName: tc.inApp,
env: tc.inEnv,
follow: tc.inFollow,
secrets: tc.inSecrets,
command: tc.inCommand,
entrypoint: tc.inEntryPoint,
envFile: tc.inEnvFile,
},
spinner: &spinnerTestDouble{},
store: mocks.store,
provider: mocks.provider,
fs: fs.Fs,
}
opts.configureRuntimeOpts = func() error {
opts.runner = mocks.runner
opts.deployer = mocks.deployer
opts.defaultClusterGetter = mocks.defaultClusterGetter
opts.publicIPGetter = mocks.publicIPGetter
return nil
}
opts.configureRepository = func() error {
opts.repository = mocks.repository
return nil
}
opts.configureEventsWriter = func(tasks []*task.Task) {
opts.eventsWriter = mocks.eventsWriter
}
opts.configureUploader = func(session *session.Session) uploader {
return mocks.uploader
}
err := opts.Execute()
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
}
})
}
}
type mockRunTaskRequester struct {
mockRunTaskRequestFromECSService func(client ecs.ECSServiceDescriber, cluster string, service string) (*ecs.RunTaskRequest, error)
mockRunTaskRequestFromService func(client ecs.ServiceDescriber, app, env, svc string) (*ecs.RunTaskRequest, error)
mockRunTaskRequestFromJob func(client ecs.JobDescriber, app, env, job string) (*ecs.RunTaskRequest, error)
}
type taskRunMocks struct {
store *mocks.Mockstore
provider *mocks.MocksessionProvider
envCompatibilityChecker *mocks.MockversionCompatibilityChecker
}
func TestTaskRunOpts_runTaskCommand(t *testing.T) {
wantedCommand := ecs.RunTaskRequest{}
testCases := map[string]struct {
inGenerateCommandTarget string
setUpMocks func(m *taskRunMocks)
mockRunTaskRequester mockRunTaskRequester
wantedCommand *ecs.RunTaskRequest
wantedError error
}{
"should generate a command given an service ARN": {
inGenerateCommandTarget: "arn:aws:ecs:us-east-1:123456789012:service/crowded-cluster/good-service",
setUpMocks: func(m *taskRunMocks) {
m.provider.EXPECT().Default()
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromECSService: func(client ecs.ECSServiceDescriber, cluster string, service string) (*ecs.RunTaskRequest, error) {
return &wantedCommand, nil
},
},
wantedCommand: &wantedCommand,
},
"fail to generate a command given a service ARN": {
inGenerateCommandTarget: "arn:aws:ecs:us-east-1:123456789012:service/crowded-cluster/good-service",
setUpMocks: func(m *taskRunMocks) {
m.provider.EXPECT().Default()
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromECSService: func(client ecs.ECSServiceDescriber, cluster string, service string) (*ecs.RunTaskRequest, error) {
return nil, errors.New("some error")
},
},
wantedError: fmt.Errorf("generate task run command from ECS service crowded-cluster/good-service: some error"),
},
"should generate a command given a cluster/service target": {
inGenerateCommandTarget: "crowded-cluster/good-service",
setUpMocks: func(m *taskRunMocks) {
m.provider.EXPECT().Default()
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromECSService: func(client ecs.ECSServiceDescriber, cluster string, service string) (*ecs.RunTaskRequest, error) {
return &wantedCommand, nil
},
},
wantedCommand: &wantedCommand,
},
"fail to generate a command given a cluster/service target": {
inGenerateCommandTarget: "crowded-cluster/good-service",
setUpMocks: func(m *taskRunMocks) {
m.provider.EXPECT().Default()
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromECSService: func(client ecs.ECSServiceDescriber, cluster string, service string) (*ecs.RunTaskRequest, error) {
return nil, errors.New("some error")
},
},
wantedError: fmt.Errorf("generate task run command from ECS service crowded-cluster/good-service: some error"),
},
"should generate a command given an app/env/svc target": {
inGenerateCommandTarget: "good-app/good-env/good-service",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "good-service").Return(nil, &config.ErrNoSuchJob{})
m.store.EXPECT().GetService("good-app", "good-service").Return(&config.Workload{}, nil)
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromService: func(client ecs.ServiceDescriber, app, env, svc string) (*ecs.RunTaskRequest, error) {
return &wantedCommand, nil
},
},
wantedCommand: &wantedCommand,
},
"fail to generate a command given an app/env/svc target": {
inGenerateCommandTarget: "good-app/good-env/good-service",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "good-service").Return(nil, &config.ErrNoSuchJob{})
m.store.EXPECT().GetService("good-app", "good-service").Return(&config.Workload{}, nil)
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromService: func(client ecs.ServiceDescriber, app, env, svc string) (*ecs.RunTaskRequest, error) {
return nil, errors.New("some error")
},
},
wantedError: fmt.Errorf("generate task run command from service good-service of application good-app deployed in environment good-env: some error"),
},
"should generate a command given an app/env/job target": {
inGenerateCommandTarget: "good-app/good-env/good-job",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "good-job").Return(&config.Workload{}, nil)
m.envCompatibilityChecker.EXPECT().Version().Return("v1.12.2", nil)
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromJob: func(client ecs.JobDescriber, app, env, svc string) (*ecs.RunTaskRequest, error) {
return &wantedCommand, nil
},
},
wantedCommand: &wantedCommand,
},
"fail to generate a command given an app/env/job target": {
inGenerateCommandTarget: "good-app/good-env/good-job",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "good-job").Return(&config.Workload{}, nil)
m.envCompatibilityChecker.EXPECT().Version().Return("v1.12.2", nil)
},
mockRunTaskRequester: mockRunTaskRequester{
mockRunTaskRequestFromJob: func(client ecs.JobDescriber, app, env, svc string) (*ecs.RunTaskRequest, error) {
return nil, errors.New("some error")
},
},
wantedError: fmt.Errorf("generate task run command from job good-job of application good-app deployed in environment good-env: some error"),
},
"error out if fail to get env version when target is job": {
inGenerateCommandTarget: "good-app/good-env/good-job",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "good-job").Return(&config.Workload{}, nil)
m.envCompatibilityChecker.EXPECT().Version().Return("", errors.New("some error"))
},
wantedError: fmt.Errorf(`retrieve version of environment stack "good-env" in application "good-app": some error`),
},
"error out if env version doesn't support `--generate-cmd` for jobs": {
inGenerateCommandTarget: "good-app/good-env/good-job",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "good-job").Return(&config.Workload{}, nil)
m.envCompatibilityChecker.EXPECT().Version().Return("v1.9.0", nil)
},
wantedError: fmt.Errorf(`environment "good-env" is on version "v1.9.0" which does not support the "task run --generate-cmd" feature`),
},
"fail to determine if the workload is a job given an app/env/workload target": {
inGenerateCommandTarget: "good-app/good-env/bad-workload",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "bad-workload").Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("determine whether workload bad-workload is a job: some error"),
},
"fail to determine if the workload is a service given an app/env/workload target": {
inGenerateCommandTarget: "good-app/good-env/bad-workload",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "bad-workload").Return(nil, &config.ErrNoSuchJob{})
m.store.EXPECT().GetService("good-app", "bad-workload").Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("determine whether workload bad-workload is a service: some error"),
},
"workload is neither a job nor a service": {
inGenerateCommandTarget: "good-app/good-env/bad-workload",
setUpMocks: func(m *taskRunMocks) {
m.store.EXPECT().GetEnvironment("good-app", "good-env").Return(&config.Environment{
ManagerRoleARN: "mock-role",
Region: "mock-region",
}, nil)
m.provider.EXPECT().FromRole("mock-role", "mock-region")
m.store.EXPECT().GetJob("good-app", "bad-workload").Return(nil, &config.ErrNoSuchJob{})
m.store.EXPECT().GetService("good-app", "bad-workload").Return(nil, &config.ErrNoSuchService{})
},
wantedError: fmt.Errorf("workload bad-workload is neither a service nor a job"),
},
"invalid input": {
inGenerateCommandTarget: "invalid/illegal/not-good/input/is/bad",
setUpMocks: func(m *taskRunMocks) {},
wantedError: errors.New("invalid input to --generate-cmd: must be of format <cluster>/<service> or <app>/<env>/<workload>"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &taskRunMocks{
store: mocks.NewMockstore(ctrl),
provider: mocks.NewMocksessionProvider(ctrl),
envCompatibilityChecker: mocks.NewMockversionCompatibilityChecker(ctrl),
}
if tc.setUpMocks != nil {
tc.setUpMocks(m)
}
opts := &runTaskOpts{
runTaskVars: runTaskVars{
generateCommandTarget: tc.inGenerateCommandTarget,
},
store: m.store,
provider: m.provider,
configureECSServiceDescriber: func(session *session.Session) ecs.ECSServiceDescriber {
return ecsMocks.NewMockECSServiceDescriber(ctrl)
},
configureJobDescriber: func(session *session.Session) ecs.JobDescriber {
return ecsMocks.NewMockJobDescriber(ctrl)
},
configureServiceDescriber: func(session *session.Session) ecs.ServiceDescriber {
return ecsMocks.NewMockServiceDescriber(ctrl)
},
runTaskRequestFromECSService: tc.mockRunTaskRequester.mockRunTaskRequestFromECSService,
runTaskRequestFromService: tc.mockRunTaskRequester.mockRunTaskRequestFromService,
runTaskRequestFromJob: tc.mockRunTaskRequester.mockRunTaskRequestFromJob,
envCompatibilityChecker: func(app, env string) (versionCompatibilityChecker, error) {
return m.envCompatibilityChecker, nil
},
}
got, err := opts.runTaskCommand()
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedCommand, got)
}
})
}
}
| 1,483 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"net"
"regexp"
"strconv"
"strings"
"time"
"gopkg.in/yaml.v3"
"github.com/robfig/cron/v3"
"github.com/spf13/afero"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/addon"
"github.com/aws/copilot-cli/internal/pkg/aws/apprunner"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
)
const basicNameRegex = `^[a-z][a-z0-9\-]+$`
var errBasicNameRegexNotMatched = errors.New("value must have a length of at least 2, start with a letter, contain only lower-case letters, numbers, and hyphens, and have no consecutive or trailing hyphen")
var (
errValueEmpty = errors.New("value must not be empty")
errValueTooLong = errors.New("value must not exceed 255 characters")
errValueNotAString = errors.New("value must be a string")
errValueReserved = errors.New("value is reserved")
errValueNotAStringSlice = errors.New("value must be a string slice")
errValueNotAValidPath = errors.New("value must be a valid path")
errValueNotAnIPNet = errors.New("value must be a valid IP address range (example: 10.0.0.0/16)")
errValueNotIPNetSlice = errors.New("value must be a valid slice of IP address range (example: 10.0.0.0/16,10.0.1.0/16)")
errPortInvalid = errors.New("value must be in range 1-65535")
errDomainInvalid = errors.New("value must contain at least one '.' character")
errDurationInvalid = errors.New("value must be a valid Go duration string (example: 1h30m)")
errDurationBadUnits = errors.New("duration cannot be in units smaller than a second")
errScheduleInvalid = errors.New("value must be a valid cron expression (examples: @weekly; @every 30m; 0 0 * * 0)")
)
// Addons validation errors.
var (
fmtErrInvalidStorageType = "invalid storage type %s: must be one of %s"
// S3 errors.
errS3ValueBadSize = errors.New("value must be between 3 and 63 characters in length")
errS3ValueBadFormat = errors.New("value must not contain consecutive periods or dashes, or be formatted as IP address")
errS3ValueTrailingDash = errors.New("value must not have trailing -")
// DDB errors.
errValueBadFormatWithPeriod = errors.New("value must contain only lowercase alphanumeric characters and .-")
errDDBValueBadSize = errors.New("value must be between 3 and 255 characters in length")
errDDBAttributeBadSize = errors.New("value must be between 1 and 255 characters in length")
errValueBadFormatWithPeriodUnderscore = errors.New("value must contain only alphanumeric characters and ._-")
errDDBAttributeBadFormat = errors.New("value must be of the form <name>:<T> where T is one of S, N, or B")
errTooManyLSIKeys = errors.New("number of specified LSI sort keys must be 5 or less")
// Aurora-Serverless-specific errors.
errInvalidRDSNameCharacters = errors.New("value must start with a letter and followed by alphanumeric letters only")
errRDWSNotConnectedToVPC = fmt.Errorf("%s requires a VPC connection", manifestinfo.RequestDrivenWebServiceType)
fmtErrInvalidEngineType = "invalid engine type %s: must be one of %s"
fmtErrInvalidDBNameCharacters = "invalid database name %s: must contain only alphanumeric characters and underscore; should start with a letter"
errInvalidSecretNameCharacters = errors.New("value must contain only letters, numbers, periods, hyphens and underscores")
// Topic subscription errors.
errMissingPublishTopicField = errors.New("field `publish.topics[].name` cannot be empty")
errInvalidPubSubTopicName = errors.New("topic names can only contain letters, numbers, underscores, and hyphens")
errSubscribeBadFormat = errors.New("value must be of the form <serviceName>:<topicName>")
)
const fmtErrValueBadSize = "value must be between %d and %d characters in length"
// App Runner validation errors.
var (
errAppRunnerSvcNameTooLong = errors.New("value must not exceed 40 characters")
errAppRunnerImageNotSupported = errors.New("value must be an ECR or ECR Public image URI")
)
// Pipelines
const (
maxPipelineStackNameLen = 128
fmtErrPipelineNameTooLong = "value must not exceed %d characters"
)
var (
emptyIPNet = net.IPNet{}
emptyIP = net.IP{}
)
// matches alphanumeric, ._-, from 3 to 255 characters long
// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
var ddbRegExp = regexp.MustCompile(`^[a-zA-Z0-9\-\.\_]+$`)
// s3 validation expressions.
// s3RegExp matches alphanumeric, .- from 3 to 63 characters long.
// punctuationRegExp matches consecutive dashes or periods.
// trailingPunctRegExp matches a trailing dash.
// ipAddressRegExp checks for a bucket in the format of an IP address.
// https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-s3-bucket-naming-requirements.html
// The punctuation and trailing punctuation guidelines also apply to ECR repositories, though
// the requirements are not documented.
var (
s3RegExp = regexp.MustCompile("" +
`^` + // start of line.
`[a-z0-9\.\-]{3,63}` + // Main match: lowercase alphanumerics, ., - from 3-63 characters.
`$`, // end of line.
)
punctuationRegExp = regexp.MustCompile(
`[\.\-]{2,}`, // Check for consecutive periods or dashes.
)
trailingPunctRegExp = regexp.MustCompile(
`[\-\.]$`, // Check for trailing dash or dot.
)
ipAddressRegexp = regexp.MustCompile(
`^(?:\d{1,3}\.){3}\d{1,3}$`, // Match any 1-3 digits in xxx.xxx.xxx.xxx format.
)
domainNameRegexp = regexp.MustCompile(`\.`) // Check for at least one dot in domain name.
awsScheduleRegexp = regexp.MustCompile(`(?:rate|cron)\(.*\)`) // Check for strings of the form rate(*) or cron(*).
)
// RDS Aurora Serverless validation expressions.
var (
// Referred to name constraints here: https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html#Aurora.CreateInstance.Settings
// However, the doc on name constraints is somewhat misleading.
// PostgreSQL db name cannot start with an underscore (doc says it must begin with a letter or an underscore).
// MySQL db name can contain underscores (not limited to alphanumeric as described in the doc).
dbNameCharacterRegExp = regexp.MustCompile("" +
"^" + // Start of string.
"[A-Za-z]" + // Starts with a letter.
"[0-9A-Za-z_]*" + // Subsequent characters can be letters, underscores or digits
"$", // End of string.
)
// The storage name for RDS storage type is used as the logical ID of the Aurora Serverless DB cluster in the CFN template.
// When creating the DB cluster, CFN will use the logical ID to generate a DB cluster identifier.
// Since the logical ID has stricter character restrictions than cluster identifier, we only need to check if the
// starting character is a letter.
// https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html#Aurora.CreateInstance.Settings
// https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resources-section-structure.html
rdsStorageNameRegExp = regexp.MustCompile("" +
"^" + // Start of string.
"[A-Za-z]" + // Starts with a letter. The DB cluster identifier must start with a letter.
`[a-zA-Z0-9\-\.\_]*` + // Followed by alphanumeric, ._-. Refers to POSIX portable file name character set.
"$", // End of string.
)
)
// SSM secret parameter name validation expression.
// https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_PutParameter.html#systemsmanager-PutParameter-request-Name
var secretParameterNameRegExp = regexp.MustCompile("^[a-zA-Z0-9_.-]+$")
var (
awsSNSTopicRegexp = regexp.MustCompile(`^[a-zA-Z0-9_-]*$`) // Validates that an expression contains only letters, numbers, underscores, and hyphens.
regexpMatchSubscription = regexp.MustCompile(`^(\S+):(\S+)`) // Validates that an expression contains the format serviceName:topicName
)
const regexpFindAllMatches = -1
// reservedWorkloadNames is a constant map of reserved workload names that users are not allowed to name their workloads
func reservedWorkloadNames() map[string]bool {
return map[string]bool{
"pipelines": true, // reserved to avoid directory conflict with copilot pipelines
"environments": true, // reserved to avoid directory conflict with copilot environments
}
}
func validateAppNameString(val interface{}) error {
if err := basicNameValidation(val); err != nil {
return fmt.Errorf("application name %v is invalid: %w", val, err)
}
return nil
}
func validateSvcName(val interface{}, svcType string) error {
var err error
switch svcType {
case manifestinfo.RequestDrivenWebServiceType:
err = validateAppRunnerSvcName(val)
default:
err = basicNameValidation(val)
}
if err != nil {
return fmt.Errorf("service name %v is invalid: %w", val, err)
}
if err := validateNotReservedWorkloadName(val); err != nil {
return fmt.Errorf("service name %v is invalid: %w", val, err)
}
return nil
}
func validateNotReservedWorkloadName(val interface{}) error {
name, ok := val.(string)
switch {
case !ok:
return errValueNotAString
case reservedWorkloadNames()[name]:
return errValueReserved
}
return nil
}
func validateSvcPort(val interface{}) error {
if err := basicPortValidation(val); err != nil {
return fmt.Errorf("port %v is invalid: %w", val, err)
}
return nil
}
func validateSvcType(val interface{}) error {
svcType, ok := val.(string)
if !ok {
return errValueNotAString
}
return validateWorkloadType(svcType, manifestinfo.ServiceTypes(), service)
}
func validateWorkloadType(wkldType string, validTypes []string, errFlavor string) error {
for _, validType := range validTypes {
if wkldType == validType {
return nil
}
}
return fmt.Errorf("invalid %s type %s: must be one of %s", errFlavor, wkldType, prettify(validTypes))
}
func validateJobType(val interface{}) error {
jobType, ok := val.(string)
if !ok {
return errValueNotAString
}
return validateWorkloadType(jobType, manifestinfo.JobTypes(), job)
}
func validateJobName(val interface{}) error {
if err := basicNameValidation(val); err != nil {
return fmt.Errorf("job name %v is invalid: %w", val, err)
}
if err := validateNotReservedWorkloadName(val); err != nil {
return fmt.Errorf("service name %v is invalid: %w", val, err)
}
return nil
}
func validatePipelineName(val interface{}, appName string) error {
// compute the longest name a user can name their pipeline for this app
// since we prefix their name with 'pipeline-[app]-'. the limit is required
// because it's the name we give the cfn stack for the pipeline.
maxNameLen := maxPipelineStackNameLen - len(fmt.Sprintf(fmtPipelineStackName, appName, ""))
errFmt := "pipeline name %v is invalid: %w"
if err := basicNameValidation(val); err != nil {
return fmt.Errorf(errFmt, val, err)
}
name, ok := val.(string)
switch {
case !ok:
return fmt.Errorf(errFmt, val, errValueNotAString)
case len(name) > maxNameLen:
err := fmt.Errorf(fmtErrPipelineNameTooLong, maxNameLen)
return fmt.Errorf(errFmt, val, err)
}
return nil
}
func validateSchedule(sched interface{}) error {
s, ok := sched.(string)
if !ok {
return errValueNotAString
}
return validateCron(s)
}
func validateAppRunnerImage(img interface{}) error {
if err := apprunnerImageValidation(img); err != nil {
return fmt.Errorf("image %s is not supported by App Runner: %w", img, err)
}
return nil
}
func validateTimeout(timeout interface{}) error {
t, ok := timeout.(string)
if !ok {
return errValueNotAString
}
if err := validateDuration(t, 1*time.Second); err != nil {
return fmt.Errorf("timeout value %s is invalid: %w", t, err)
}
return nil
}
func validateRate(rate interface{}) error {
r, ok := rate.(string)
if !ok {
return errValueNotAString
}
return validateDuration(r, 60*time.Second)
}
func validateDomainName(val interface{}) error {
domainName, ok := val.(string)
if !ok {
return errValueNotAString
}
dots := domainNameRegexp.FindAllString(domainName, regexpFindAllMatches)
if dots == nil {
return errDomainInvalid
}
return nil
}
func validatePath(fs afero.Fs, val interface{}) error {
path, ok := val.(string)
if !ok {
return errValueNotAString
}
if path == "" {
return errValueEmpty
}
_, err := fs.Stat(path)
if err != nil {
return errValueNotAValidPath
}
return nil
}
func validateNonEmptyString(val interface{}) error {
path, ok := val.(string)
if !ok {
return errValueNotAString
}
if path == "" {
return errValueEmpty
}
return nil
}
type validateStorageTypeOpts struct {
ws manifestReader
workloadName string
}
func validateStorageType(val interface{}, opts validateStorageTypeOpts) error {
storageType, ok := val.(string)
if !ok {
return errValueNotAString
}
if !contains(storageType, storageTypes) {
return fmt.Errorf(fmtErrInvalidStorageType, storageType, prettify(storageTypes))
}
if storageType == rdsStorageType {
return validateAuroraStorageType(opts.ws, opts.workloadName)
}
return nil
}
func validateAuroraStorageType(ws manifestReader, workloadName string) error {
if workloadName == "" {
return nil // Workload not yet selected while validating storage type flag.
}
mft, err := ws.ReadWorkloadManifest(workloadName)
if err != nil {
return fmt.Errorf("invalid storage type %s: read manifest file for %s: %w", rdsStorageType, workloadName, err)
}
mftType, err := mft.WorkloadType()
if err != nil {
return fmt.Errorf("invalid storage type %s: read type of workload from manifest file for %s: %w", rdsStorageType, workloadName, err)
}
if mftType != manifestinfo.RequestDrivenWebServiceType {
return nil
}
data := struct {
Network manifest.RequestDrivenWebServiceNetworkConfig `yaml:"network"`
}{}
if err := yaml.Unmarshal(mft, &data); err != nil {
return fmt.Errorf("invalid storage type %s: unmarshal manifest for %s to read network config: %w", rdsStorageType, workloadName, err)
}
if data.Network.IsEmpty() {
return fmt.Errorf("invalid storage type %s: %w", rdsStorageType, errRDWSNotConnectedToVPC)
}
return nil
}
func validateMySQLDBName(val interface{}) error {
const (
minMySQLDBNameLength = 1
maxMySQLDBNameLength = 64
)
dbName, ok := val.(string)
if !ok {
return errValueNotAString
}
// Check for db name length.
if len(dbName) < minMySQLDBNameLength || len(dbName) > maxMySQLDBNameLength {
return fmt.Errorf(fmtErrValueBadSize, minMySQLDBNameLength, maxMySQLDBNameLength)
}
return validateDBNameCharacters(dbName)
}
func validateAppRunnerSvcName(val interface{}) error {
const maxNameLen = 40
name, ok := val.(string)
if !ok {
return errValueNotAString
}
if len(name) > maxNameLen {
return errAppRunnerSvcNameTooLong
}
return basicNameValidation(val)
}
func validatePostgreSQLDBName(val interface{}) error {
const (
minPostgreSQLDBNameLength = 1
maxPostgreSQLDBNameLength = 63
)
dbName, ok := val.(string)
if !ok {
return errValueNotAString
}
// Check for db name length.
if len(dbName) < minPostgreSQLDBNameLength || len(dbName) > maxPostgreSQLDBNameLength {
return fmt.Errorf(fmtErrValueBadSize, minPostgreSQLDBNameLength, maxPostgreSQLDBNameLength)
}
return validateDBNameCharacters(dbName)
}
func validateDBNameCharacters(name string) error {
// Check for character constraints.
match := dbNameCharacterRegExp.FindStringSubmatch(name)
if match != nil {
return nil
}
return fmt.Errorf(fmtErrInvalidDBNameCharacters, name)
}
func validateEngine(val interface{}) error {
engine, ok := val.(string)
if !ok {
return errValueNotAString
}
for _, valid := range engineTypes {
if engine == valid {
return nil
}
}
return fmt.Errorf(fmtErrInvalidEngineType, engine, prettify(engineTypes))
}
func validateEnvironmentName(val interface{}) error {
if err := basicNameValidation(val); err != nil {
return fmt.Errorf("environment name %v is invalid: %w", val, err)
}
return nil
}
func basicNameValidation(val interface{}) error {
s, ok := val.(string)
if !ok {
return errValueNotAString
}
if s == "" {
return errValueEmpty
}
if len(s) > 255 {
return errValueTooLong
}
if !isCorrectFormat(s) {
return errBasicNameRegexNotMatched
}
return nil
}
func validateCron(sched string) error {
// If the schedule is wrapped in aws terms `rate()` or `cron()`, don't validate it--
// instead, pass it in as-is for serverside validation. AWS cron is weird (year field, nonstandard wildcards)
// so for edge cases we need to support it
awsSchedMatch := awsScheduleRegexp.FindStringSubmatch(sched)
if awsSchedMatch != nil {
return nil
}
every := "@every "
if strings.HasPrefix(sched, every) {
if err := validateDuration(sched[len(every):], 60*time.Second); err != nil {
if err == errDurationInvalid {
return fmt.Errorf("interval %s must include a valid Go duration string (example: @every 1h30m)", sched)
}
return fmt.Errorf("interval %s is invalid: %s", sched, err)
}
}
_, err := cron.ParseStandard(sched)
if err != nil {
return fmt.Errorf("schedule %s is invalid: %s", sched, errScheduleInvalid)
}
return nil
}
func validateDuration(duration string, min time.Duration) error {
parsedDuration, err := time.ParseDuration(duration)
if err != nil {
return errDurationInvalid
}
// This checks if the duration has parts smaller than a whole second.
if parsedDuration > parsedDuration.Truncate(time.Second) {
return errDurationBadUnits
}
if parsedDuration < min {
return fmt.Errorf("duration must be %v or greater", min)
}
return nil
}
func isCorrectFormat(s string) bool {
valid, err := regexp.MatchString(basicNameRegex, s)
if err != nil {
return false // bubble up error?
}
// Check for bad punctuation (no consecutive dashes or dots)
formatMatch := punctuationRegExp.FindStringSubmatch(s)
if len(formatMatch) != 0 {
return false
}
trailingMatch := trailingPunctRegExp.FindStringSubmatch(s)
if len(trailingMatch) != 0 {
return false
}
return valid
}
func apprunnerImageValidation(val interface{}) error {
strVal, ok := val.(string)
if ok && apprunner.ImageIsSupported(strVal) {
return nil
}
return errAppRunnerImageNotSupported
}
func basicPortValidation(val interface{}) error {
var err error
switch val := val.(type) {
case []byte:
err = bytePortValidation(val)
case string:
err = stringPortValidation(val)
case uint16:
if val == 0 {
err = errPortInvalid
}
default:
err = errPortInvalid
}
return err
}
func bytePortValidation(val []byte) error {
s := string(val)
err := stringPortValidation(s)
if err != nil {
return err
}
return nil
}
func stringPortValidation(val string) error {
portList := strings.Split(val, ",")
for _, port := range portList {
port64, err := strconv.ParseUint(port, 10, 64)
if err != nil {
return errPortInvalid
}
if port64 < 1 || port64 > 65535 {
return errPortInvalid
}
}
return nil
}
// s3 bucket names: 'a-z0-9.-'
func s3BucketNameValidation(val interface{}) error {
const minS3Length = 3
const maxS3Length = 63
s, ok := val.(string)
if !ok {
return errValueNotAString
}
if len(s) < minS3Length || len(s) > maxS3Length {
return errS3ValueBadSize
}
// check for correct character set
nameMatch := s3RegExp.FindStringSubmatch(s)
if len(nameMatch) == 0 {
return errValueBadFormatWithPeriod
}
// Check for bad punctuation (no consecutive dashes or dots)
formatMatch := punctuationRegExp.FindStringSubmatch(s)
if len(formatMatch) != 0 {
return errS3ValueBadFormat
}
dashMatch := trailingPunctRegExp.FindStringSubmatch(s)
if len(dashMatch) != 0 {
return errS3ValueTrailingDash
}
ipMatch := ipAddressRegexp.FindStringSubmatch(s)
if len(ipMatch) != 0 {
return errS3ValueBadFormat
}
return nil
}
// Dynamo table names: 'a-zA-Z0-9.-_'
func dynamoTableNameValidation(val interface{}) error {
// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
const minDDBTableNameLength = 3
const maxDDBTableNameLength = 255
s, ok := val.(string)
if !ok {
return errValueNotAString
}
if len(s) < minDDBTableNameLength || len(s) > maxDDBTableNameLength {
return errDDBValueBadSize
}
m := ddbRegExp.FindStringSubmatch(s)
if len(m) == 0 {
return errValueBadFormatWithPeriodUnderscore
}
return nil
}
// Dynamo attribute names: 1 to 255 characters
func dynamoAttributeNameValidation(val interface{}) error {
// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
const minDDBAttributeNameLength = 1
const maxDDBAttributeNameLength = 255
s, ok := val.(string)
if !ok {
return errValueNotAString
}
if len(s) < minDDBAttributeNameLength || len(s) > maxDDBAttributeNameLength {
return errDDBAttributeBadSize
}
return nil
}
// RDS storage name: '[a-zA-Z][a-zA-Z0-9]*'
func rdsNameValidation(val interface{}) error {
// This length constrains needs to satisfy: 1. logical ID length; 2. DB Cluster identifier length.
// For 1. logical ID, there is no documented length limit.
// For 2. DB Cluster identifier, the maximal length is 63.
// DB Cluster identifier is auto-generated by CFN using the cluster's logical ID, which is the storage name appended
// by "DBCluster". Hence the maximal length of the storage name is 63 - len("DBCluster")
const minRDSNameLength = 1
const maxRDSNameLength = 63 - len("DBCluster")
s, ok := val.(string)
if !ok {
return errValueNotAString
}
if len(s) < minRDSNameLength || len(s) > maxRDSNameLength {
return fmt.Errorf(fmtErrValueBadSize, minRDSNameLength, maxRDSNameLength)
}
m := rdsStorageNameRegExp.FindStringSubmatch(s)
if m == nil {
return errInvalidRDSNameCharacters
}
return nil
}
func validateKey(val interface{}) error {
s, ok := val.(string)
if !ok {
return errValueNotAString
}
attr, err := addon.DDBAttributeFromKey(s)
if err != nil {
return errDDBAttributeBadFormat
}
err = dynamoAttributeNameValidation(*attr.Name)
if err != nil {
return err
}
err = validateDynamoDataType(*attr.DataType)
if err != nil {
return err
}
return nil
}
func validateDynamoDataType(val interface{}) error {
s, ok := val.(string)
if !ok {
return errValueNotAString
}
if !strings.Contains("SNB", strings.ToUpper(s)) {
return errDDBAttributeBadFormat
}
return nil
}
func validateLSIs(val interface{}) error {
s, ok := val.([]string)
if !ok {
return errValueNotAStringSlice
}
if len(s) > 5 {
return errTooManyLSIKeys
}
for _, att := range s {
err := validateKey(att)
if err != nil {
return err
}
}
return nil
}
func validateSubscribe(noSubscription bool, subscribeTags []string) error {
// --no-subscriptions and --subscribe are mutually exclusive.
if noSubscription && len(subscribeTags) != 0 {
return fmt.Errorf("validate subscribe configuration: cannot specify both --%s and --%s", noSubscriptionFlag, subscribeTopicsFlag)
}
if len(subscribeTags) != 0 {
if err := validateSubscriptions(subscribeTags); err != nil {
return err
}
}
return nil
}
func validateSubscriptions(val interface{}) error {
s, ok := val.([]string)
if !ok {
return errValueNotAStringSlice
}
for _, sub := range s {
err := validateSubscriptionKey(sub)
if err != nil {
return err
}
}
return nil
}
func validateSubscriptionKey(val interface{}) error {
s, ok := val.(string)
if !ok {
return errValueNotAString
}
sub, err := parseSerializedSubscription(s)
if err != nil {
return errSubscribeBadFormat
}
if err := validatePubSubName(aws.StringValue(sub.Name)); err != nil {
return fmt.Errorf("invalid topic subscription topic name `%s`: %w", aws.StringValue(sub.Name), err)
}
if err = basicNameValidation(aws.StringValue(sub.Service)); err != nil {
return fmt.Errorf("invalid topic subscription service name `%s`: %w", aws.StringValue(sub.Service), err)
}
return nil
}
// ValidatePubSubName validates naming is correct for topics in publishing/subscribing cases, such as naming for a
// SNS Topic intended for a publisher.
func validatePubSubName(name string) error {
if len(name) == 0 {
return errMissingPublishTopicField
}
// Name must contain letters, numbers, and can't use special characters besides underscores and hyphens.
if !awsSNSTopicRegexp.MatchString(name) {
return errInvalidPubSubTopicName
}
return nil
}
func prettify(inputStrings []string) string {
prettyTypes := applyAll(inputStrings, strconv.Quote)
return strings.Join(prettyTypes, ", ")
}
func validateCIDR(val interface{}) error {
s, ok := val.(string)
if !ok {
return errValueNotAString
}
ip, _, err := net.ParseCIDR(s)
if err != nil || ip.String() == emptyIP.String() {
return errValueNotAnIPNet
}
return nil
}
func validatePublicSubnetsCIDR(numAZs int) func(v interface{}) error {
return func(v interface{}) error {
s, ok := v.(string)
if !ok {
return errValueNotAString
}
if numCIDRs := len(strings.Split(s, ",")); numCIDRs != numAZs {
return fmt.Errorf("number of public subnet CIDRs (%d) does not match number of AZs (%d)", numCIDRs, numAZs)
}
return validateCIDRSlice(v)
}
}
func validatePrivateSubnetsCIDR(numAZs int) func(v interface{}) error {
return func(v interface{}) error {
s, ok := v.(string)
if !ok {
return errValueNotAString
}
if numCIDRs := len(strings.Split(s, ",")); numCIDRs != numAZs {
return fmt.Errorf("number of private subnet CIDRs (%d) does not match number of AZs (%d)", numCIDRs, numAZs)
}
return validateCIDRSlice(v)
}
}
func validateCIDRSlice(val interface{}) error {
s, ok := val.(string)
if !ok {
return errValueNotAString
}
slice := strings.Split(s, ",")
if len(slice) == 0 {
return errValueNotIPNetSlice
}
for _, str := range slice {
if err := validateCIDR(str); err != nil {
return errValueNotIPNetSlice
}
}
return nil
}
func validateSecretName(val interface{}) error {
const minSecretNameLength = 1
const maxSecretNameLength = 2048 - (len("/copilot/") + len("/") + len("/secrets/"))
s, ok := val.(string)
if !ok {
return errValueNotAString
}
if len(s) < minSecretNameLength || len(s) > maxSecretNameLength {
return fmt.Errorf(fmtErrValueBadSize, minSecretNameLength, maxSecretNameLength)
}
m := secretParameterNameRegExp.FindStringSubmatch(s)
if m == nil {
return errInvalidSecretNameCharacters
}
return nil
}
| 886 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package cli
import (
"errors"
"fmt"
"strings"
"testing"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
)
type testCase struct {
input interface{}
want error
}
var basicNameTestCases = map[string]testCase{
"string as input": {
input: "chicken1234",
want: nil,
},
"number as input": {
input: 1234,
want: errValueNotAString,
},
"bool as input": {
input: false,
want: errValueNotAString,
},
"string with invalid characters": {
input: "myProject!",
want: errBasicNameRegexNotMatched,
},
"empty string": {
input: "",
want: errValueEmpty,
},
"invalid length string": {
input: strings.Repeat("s", 256),
want: errValueTooLong,
},
"does not start with letter": {
input: "123chicken",
want: errBasicNameRegexNotMatched,
},
"contains upper-case letters": {
input: "badGoose",
want: errBasicNameRegexNotMatched,
},
}
func TestValidateAppName(t *testing.T) {
// Any project-specific name validations can be added here
testCases := map[string]testCase{
"contains emoji": {
input: "😀",
want: errBasicNameRegexNotMatched,
},
}
for name, tc := range basicNameTestCases {
t.Run(name, func(t *testing.T) {
got := validateAppNameString(tc.input)
require.True(t, errors.Is(got, tc.want))
})
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateAppNameString(tc.input)
require.True(t, errors.Is(got, tc.want))
})
}
}
func TestValidateSvcName(t *testing.T) {
testCases := map[string]struct {
val interface{}
svcType string
wanted error
}{
"string as input": {
val: "hello",
svcType: manifestinfo.LoadBalancedWebServiceType,
wanted: nil,
},
"number as input": {
val: 1234,
wanted: errValueNotAString,
},
"string with invalid characters": {
val: "mySvc!",
wanted: errBasicNameRegexNotMatched,
},
"longer than 40 characters for app runner services": {
val: strings.Repeat("x", 41),
svcType: manifestinfo.RequestDrivenWebServiceType,
wanted: errAppRunnerSvcNameTooLong,
},
"invalid length string": {
val: strings.Repeat("s", 256),
svcType: manifestinfo.LoadBalancedWebServiceType,
wanted: errValueTooLong,
},
"does not start with letter": {
val: "123chicken",
svcType: manifestinfo.BackendServiceType,
wanted: errBasicNameRegexNotMatched,
},
"contains upper-case letters": {
val: "badGoose",
svcType: manifestinfo.LoadBalancedWebServiceType,
wanted: errBasicNameRegexNotMatched,
},
"is not a reserved name": {
val: "pipelines",
svcType: manifestinfo.LoadBalancedWebServiceType,
wanted: errValueReserved,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateSvcName(tc.val, tc.svcType)
require.True(t, errors.Is(got, tc.wanted), "got %v instead of %v", got, tc.wanted)
})
}
}
func TestValidateEnvironmentName(t *testing.T) {
testCases := basicNameTestCases
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateEnvironmentName(tc.input)
require.True(t, errors.Is(got, tc.want))
})
}
}
func TestValidatePipelineName(t *testing.T) {
testCases := map[string]struct {
val interface{}
appName string
wanted error
wantedErrorSuffix string
}{
"string as input": {
val: "hello",
wanted: nil,
},
"number as input": {
val: 1234,
wanted: errValueNotAString,
},
"string with invalid characters": {
val: "myPipe!",
wanted: errBasicNameRegexNotMatched,
},
"longer than 128 characters": {
val: strings.Repeat("s", 129),
wantedErrorSuffix: fmt.Sprintf(fmtErrPipelineNameTooLong, 118),
},
"longer than 128 characters with pipeline-[app]": {
val: strings.Repeat("x", 114),
appName: "myApp",
wantedErrorSuffix: fmt.Sprintf(fmtErrPipelineNameTooLong, 113),
},
"does not start with letter": {
val: "123chicken",
wanted: errBasicNameRegexNotMatched,
},
"starts with a dash": {
val: "-beta",
wanted: errBasicNameRegexNotMatched,
},
"contains upper-case letters": {
val: "badGoose",
wanted: errBasicNameRegexNotMatched,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validatePipelineName(tc.val, tc.appName)
if tc.wantedErrorSuffix != "" {
require.True(t, strings.HasSuffix(got.Error(), tc.wantedErrorSuffix), "got %v instead of %v", got, tc.wantedErrorSuffix)
return
}
require.True(t, errors.Is(got, tc.wanted), "got %v instead of %v", got, tc.wanted)
})
}
}
func TestValidateS3Name(t *testing.T) {
testCases := map[string]testCase{
"good case": {
input: "happy-s3-bucket",
want: nil,
},
"contains punctuation": {
input: "sadbucket!",
want: errValueBadFormatWithPeriod,
},
"contains spaces": {
input: "bowie is a good dog",
want: errValueBadFormatWithPeriod,
},
"leading whitespace": {
input: " a-Very-GOOD-dog-indeed",
want: errValueBadFormatWithPeriod,
},
"too long": {
input: "sitting-in-the-morning-sun-ill-be-sitting-when-the-evening-comes-watching-the-ships-roll-in",
want: errS3ValueBadSize,
},
"too short": {
input: "oh",
want: errS3ValueBadSize,
},
"consecutive dots": {
input: "b.u..cket",
want: errS3ValueBadFormat,
},
"trailing dash": {
input: "bucket-",
want: errS3ValueTrailingDash,
},
"consecutive -.": {
input: "bu.-cket",
want: errS3ValueBadFormat,
},
"ip address format": {
input: "123.455.999.000",
want: errS3ValueBadFormat,
},
"non-ip-address numbers and dots": {
input: "124.333.333.333.333",
want: nil,
},
"capital letters in bucket name": {
input: "BADbucketname",
want: errValueBadFormatWithPeriod,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := s3BucketNameValidation(tc.input)
require.True(t, errors.Is(got, tc.want))
})
}
}
func TestValidateDDBName(t *testing.T) {
testCases := map[string]testCase{
"good case": {
input: "dynamo_table-1",
want: nil,
},
"too short": {
input: "p",
want: errDDBValueBadSize,
},
"too long": {
input: "i-met-a-traveller-from-an-antique-land-who-said_two-vast-and-trunkless-legs-of-stone_stand-in-the-desert-near-them-on-the-sand_half-sunk-a-shattered-visage-lies-whose-frown_and-wrinkled-lip-and-sneer-of-cold-command_tell-that-its-sculptor-well-those-passions-read_which-yet-survive-stamped-on-these-lifeless-things",
want: errDDBValueBadSize,
},
"bad character": {
input: "badgoose!?",
want: errValueBadFormatWithPeriodUnderscore,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := dynamoTableNameValidation(tc.input)
t.Logf("error: %v", got)
require.True(t, errors.Is(got, tc.want))
})
}
}
func TestValidateRDSName(t *testing.T) {
testCases := map[string]testCase{
"good case": {
input: "goodname",
want: nil,
},
"too long": {
input: "AprilisthecruellestmonthbreedingLilacsoutofthedeadlanda",
want: fmt.Errorf("value must be between 1 and %d characters in length", 63-len("DBCluster")),
},
"bad character": {
input: "not-good!",
want: errInvalidRDSNameCharacters,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := rdsNameValidation(tc.input)
if tc.want != nil {
require.EqualError(t, got, tc.want.Error())
}
})
}
}
func TestValidatePath(t *testing.T) {
testCases := map[string]struct {
input interface{}
want error
}{
"not a string": {
input: 123,
want: errValueNotAString,
},
"empty string": {
input: "",
want: errValueEmpty,
},
"invalid path": {
input: "../Dockerfile",
want: errValueNotAValidPath,
},
"returns nil if valid absolute path": {
input: "frontend/Dockerfile",
want: nil,
},
"returns nil if valid relative path": {
input: "frontend/../backend/Dockerfile",
want: nil,
},
}
for path, tc := range testCases {
t.Run(path, func(t *testing.T) {
// GIVEN
fs := &afero.Afero{Fs: afero.NewMemMapFs()}
fs.MkdirAll("frontend", 0755)
fs.MkdirAll("backend", 0755)
afero.WriteFile(fs, "frontend/Dockerfile", []byte("FROM nginx"), 0644)
afero.WriteFile(fs, "backend/Dockerfile", []byte("FROM nginx"), 0644)
// WHEN
got := validatePath(fs, tc.input)
// THEN
if tc.want == nil {
require.Nil(t, got)
} else {
require.EqualError(t, tc.want, got.Error())
}
})
}
}
type mockManifestReader struct {
out workspace.WorkloadManifest
err error
}
func (m mockManifestReader) ReadWorkloadManifest(name string) (workspace.WorkloadManifest, error) {
return m.out, m.err
}
func TestValidateStorageType(t *testing.T) {
testCases := map[string]struct {
input string
optionals validateStorageTypeOpts
want error
}{
"should allow S3 addons": {
input: "S3",
want: nil,
},
"should allow DynamoDB allows": {
input: "DynamoDB",
want: nil,
},
"should return an error if a storage type does not exist": {
input: "Dropbox",
want: fmt.Errorf(fmtErrInvalidStorageType, "Dropbox", prettify(storageTypes)),
},
"should allow Aurora if workload name is not yet specified": {
input: "Aurora",
want: nil,
},
"should return an error if manifest file cannot be read while initializing an Aurora storage type": {
input: "Aurora",
optionals: validateStorageTypeOpts{
ws: mockManifestReader{
err: errors.New("some error"),
},
workloadName: "api",
},
want: errors.New("invalid storage type Aurora: read manifest file for api: some error"),
},
"should allow Aurora if the workload type is not a RDWS": {
input: "Aurora",
optionals: validateStorageTypeOpts{
ws: mockManifestReader{
out: []byte(`
name: api
type: Load Balanced Web Service
`),
},
workloadName: "api",
},
},
"should return an error if Aurora is selected for a RDWS while not connected to a VPC": {
input: "Aurora",
optionals: validateStorageTypeOpts{
ws: mockManifestReader{
out: []byte(`
name: api
type: Request-Driven Web Service
`),
},
workloadName: "api",
},
want: errors.New("invalid storage type Aurora: Request-Driven Web Service requires a VPC connection"),
},
"should succeed if Aurora is selected and RDWS is connected to a VPC": {
input: "Aurora",
optionals: validateStorageTypeOpts{
ws: mockManifestReader{
out: []byte(`
name: api
type: Request-Driven Web Service
network:
vpc:
placement: private
`),
},
workloadName: "api",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateStorageType(tc.input, tc.optionals)
if tc.want == nil {
require.NoError(t, got)
} else {
require.EqualError(t, got, tc.want.Error())
}
})
}
}
func TestValidateKey(t *testing.T) {
testCases := map[string]struct {
input string
want error
}{
"good key": {
input: "userID:S",
want: nil,
},
"bad key with space": {
input: "user ID:S",
want: errDDBAttributeBadFormat,
},
"nonsense key": {
input: "sfueir555'/",
want: errDDBAttributeBadFormat,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateKey(tc.input)
require.Equal(t, tc.want, got)
})
}
}
func TestValidateLSIs(t *testing.T) {
testCases := map[string]struct {
inputAttributes []string
inputLSIs []string
wantError error
}{
"good case": {
inputLSIs: []string{"userID:S"},
wantError: nil,
},
"bad lsi structure": {
inputLSIs: []string{"userID"},
wantError: errDDBAttributeBadFormat,
},
"too many lsis": {
inputLSIs: []string{"bowie:S", "clyde:S", "keno:S", "kava:S", "meow:S", "hana:S"},
wantError: errTooManyLSIKeys,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateLSIs(tc.inputLSIs)
if tc.wantError != nil {
require.EqualError(t, got, tc.wantError.Error())
} else {
require.Nil(t, got)
}
})
}
}
func TestValidateCIDR(t *testing.T) {
testCases := map[string]struct {
inputCIDR string
wantError error
}{
"good case": {
inputCIDR: "10.10.10.10/24",
wantError: nil,
},
"bad case": {
inputCIDR: "10.10.10.10",
wantError: errValueNotAnIPNet,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateCIDR(tc.inputCIDR)
if tc.wantError != nil {
require.EqualError(t, got, tc.wantError.Error())
} else {
require.Nil(t, got)
}
})
}
}
func Test_validatePublicSubnetsCIDR(t *testing.T) {
testCases := map[string]struct {
in string
numAZs int
wantedErr string
}{
"returns nil if CIDRs are valid and match number of available AZs": {
in: "10.10.10.10/24,10.10.10.10/24",
numAZs: 2,
},
"returns err if number of CIDRs is not equal to number of available AZs": {
in: "10.10.10.10/24,10.10.10.10/24",
numAZs: 3,
wantedErr: "number of public subnet CIDRs (2) does not match number of AZs (3)",
},
"returns err if input is not valid CIDR fmt": {
in: "10.10.10.10,10.10.10.10",
numAZs: 2,
wantedErr: errValueNotIPNetSlice.Error(),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
actual := validatePublicSubnetsCIDR(tc.numAZs)(tc.in)
if tc.wantedErr == "" {
require.NoError(t, actual)
} else {
require.EqualError(t, actual, tc.wantedErr)
}
})
}
}
func Test_validatePrivateSubnetsCIDR(t *testing.T) {
testCases := map[string]struct {
in string
numAZs int
wantedErr string
}{
"returns nil if CIDRs are valid and match number of available AZs": {
in: "10.10.10.10/24,10.10.10.10/24",
numAZs: 2,
},
"returns err if number of CIDRs is not equal to number of available AZs": {
in: "10.10.10.10/24,10.10.10.10/24",
numAZs: 3,
wantedErr: "number of private subnet CIDRs (2) does not match number of AZs (3)",
},
"returns err if input is not valid CIDR fmt": {
in: "10.10.10.10,10.10.10.10",
numAZs: 2,
wantedErr: errValueNotIPNetSlice.Error(),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
actual := validatePrivateSubnetsCIDR(tc.numAZs)(tc.in)
if tc.wantedErr == "" {
require.NoError(t, actual)
} else {
require.EqualError(t, actual, tc.wantedErr)
}
})
}
}
func TestIsCorrectFormat(t *testing.T) {
testCases := map[string]struct {
input string
isLegit bool
}{
"numbers only input": {
input: "1234",
isLegit: false,
},
"lower-case alphabetic input only": {
input: "badgoose",
isLegit: true,
},
"alphanumeric string input": {
input: "abc123",
isLegit: true,
},
"contains hyphen": {
input: "bad-goose",
isLegit: true,
},
"non-alphanumeric string input": {
input: "bad-goose!",
isLegit: false,
},
"starts with non-letter": {
input: "1bad-goose",
isLegit: false,
},
"contains capital letter": {
input: "badGoose",
isLegit: false,
},
"contains consecutive dashes": {
input: "bad--goose",
isLegit: false,
},
"contains trailing dash": {
input: "badgoose-",
isLegit: false,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := isCorrectFormat(tc.input)
require.Equal(t, tc.isLegit, got)
})
}
}
func TestValidateCron(t *testing.T) {
testCases := map[string]struct {
input string
shouldPass bool
}{
"valid cron expression": {
input: "* * * * *",
shouldPass: true,
},
"invalid cron": {
input: "* * * * ? *",
shouldPass: false,
},
"valid schedule descriptor": {
input: "@every 5m",
shouldPass: true,
},
"invalid schedule": {
input: "@every 5 minutes",
shouldPass: false,
},
"bypass with rate()": {
input: "rate(la la la)",
shouldPass: true,
},
"bypass with cron()": {
input: "cron(0 9 3W * ? *)",
shouldPass: true,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateCron(tc.input)
if tc.shouldPass {
require.NoError(t, got)
} else {
require.NotNil(t, got)
}
})
}
}
func TestValidateEngine(t *testing.T) {
testCases := map[string]testCase{
"mysql": {
input: "MySQL",
want: nil,
},
"postgresql": {
input: "PostgreSQL",
want: nil,
},
"invalid engine type": {
input: "weird-engine",
want: errors.New("invalid engine type weird-engine: must be one of \"MySQL\", \"PostgreSQL\""),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateEngine(tc.input)
if tc.want != nil {
require.EqualError(t, got, tc.want.Error())
} else {
require.NoError(t, got)
}
})
}
}
func TestValidateMySQLDBName(t *testing.T) {
testCases := map[string]testCase{
"good case": {
input: "my_db_123_",
want: nil,
},
"too long": {
input: "April-is-the-cruellest-month-breeding-Lilacs-out-of-the-dead-land-m",
want: errors.New("value must be between 1 and 64 characters in length"),
},
"bad character": {
input: "bad_db_name:(",
want: fmt.Errorf(fmtErrInvalidDBNameCharacters, "bad_db_name:("),
},
"bad starting character": {
input: "_not_good",
want: fmt.Errorf(fmtErrInvalidDBNameCharacters, "_not_good"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateMySQLDBName(tc.input)
if tc.want != nil {
require.EqualError(t, got, tc.want.Error())
} else {
require.NoError(t, got)
}
})
}
}
func TestValidatePostgreSQLDBName(t *testing.T) {
testCases := map[string]testCase{
"good case": {
input: "my_db_123_",
want: nil,
},
"too long": {
input: "April-is-the-cruellest-month-breeding-Lilacs-out-of-the-dead-land-m",
want: errors.New("value must be between 1 and 63 characters in length"),
},
"bad character": {
input: "bad_db_name:(",
want: fmt.Errorf(fmtErrInvalidDBNameCharacters, "bad_db_name:("),
},
"bad starting character": {
input: "_not_good",
want: fmt.Errorf(fmtErrInvalidDBNameCharacters, "_not_good"),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validatePostgreSQLDBName(tc.input)
if tc.want != nil {
require.EqualError(t, got, tc.want.Error())
} else {
require.NoError(t, got)
}
})
}
}
func TestValidateSecretName(t *testing.T) {
testCases := map[string]testCase{
"bad character": {
input: "bad!",
want: errInvalidSecretNameCharacters,
},
"bad character space": {
input: "bad ",
want: errInvalidSecretNameCharacters,
},
"secret name too short": {
input: "",
want: fmt.Errorf(fmtErrValueBadSize, 1, 2048-(len("/copilot/")+len("/")+len("/secrets/"))),
},
"secret name too long": {
input: string(make([]rune, 2048)),
want: fmt.Errorf(fmtErrValueBadSize, 1, 2048-(len("/copilot/")+len("/")+len("/secrets/"))),
},
"valid secret name": {
input: "secret.name",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateSecretName(tc.input)
if tc.want != nil {
require.EqualError(t, got, tc.want.Error())
} else {
require.NoError(t, got)
}
})
}
}
func Test_validatePubSubTopicName(t *testing.T) {
testCases := map[string]struct {
inName string
wantErr error
}{
"valid topic name": {
inName: "a-Perfectly_V4l1dString",
},
"error when no topic name": {
inName: "",
wantErr: errMissingPublishTopicField,
},
"error when invalid topic name": {
inName: "OHNO~/`...,",
wantErr: errInvalidPubSubTopicName,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
err := validatePubSubName(tc.inName)
if tc.wantErr == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantErr.Error())
}
})
}
}
func Test_validateSubscriptionKey(t *testing.T) {
testCases := map[string]struct {
inSub interface{}
wantErr error
}{
"valid subscription": {
inSub: "svc:topic",
wantErr: nil,
},
"error when non string": {
inSub: true,
wantErr: errValueNotAString,
},
"error when bad format": {
inSub: "svctopic",
wantErr: errSubscribeBadFormat,
},
"error when bad publisher name": {
inSub: "svc:@@@@@@@h",
wantErr: fmt.Errorf("invalid topic subscription topic name `@@@@@@@h`: %w", errInvalidPubSubTopicName),
},
"error when bad svc name": {
inSub: "n#######:topic",
wantErr: fmt.Errorf("invalid topic subscription service name `n#######`: %w", errBasicNameRegexNotMatched),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
err := validateSubscriptionKey(tc.inSub)
if tc.wantErr == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantErr.Error())
}
})
}
}
func Test_validateSubscribe(t *testing.T) {
testCases := map[string]struct {
inNoSubscriptions bool
inSubscribeTags []string
wantErr error
}{
"valid subscription": {
inNoSubscriptions: false,
inSubscribeTags: []string{"svc1:topic1", "svc2:topic2"},
wantErr: nil,
},
"no error when no subscriptions": {
inNoSubscriptions: true,
inSubscribeTags: nil,
wantErr: nil,
},
"error when no-subscriptions and subscribe": {
inNoSubscriptions: true,
inSubscribeTags: []string{"svc1:topic1", "svc2:topic2"},
wantErr: errors.New("validate subscribe configuration: cannot specify both --no-subscribe and --subscribe-topics"),
},
"error when bad subscription tag": {
inNoSubscriptions: false,
inSubscribeTags: []string{"svc:topic", "svc:@@@@@@@h"},
wantErr: fmt.Errorf("invalid topic subscription topic name `@@@@@@@h`: %w", errInvalidPubSubTopicName),
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
err := validateSubscribe(tc.inNoSubscriptions, tc.inSubscribeTags)
if tc.wantErr == nil {
require.NoError(t, err)
} else {
require.EqualError(t, err, tc.wantErr.Error())
}
})
}
}
func TestValidateJobName(t *testing.T) {
testCases := map[string]struct {
val interface{}
wanted error
}{
"string as input": {
val: "hello",
wanted: nil,
},
"number as input": {
val: 1234,
wanted: errValueNotAString,
},
"is not a reserved name": {
val: "pipelines",
wanted: errValueReserved,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
got := validateJobName(tc.val)
require.True(t, errors.Is(got, tc.wanted), "got %v instead of %v", got, tc.wanted)
})
}
}
| 976 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package cli contains the copilot subcommands.
package cli
import (
"fmt"
"runtime"
"github.com/aws/copilot-cli/cmd/copilot/template"
"github.com/aws/copilot-cli/internal/pkg/cli/group"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/spf13/cobra"
)
// BuildVersionCmd builds the command for displaying the version
func BuildVersionCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "version",
Short: "Print the version number.",
RunE: runCmdE(func(cmd *cobra.Command, args []string) error {
fmt.Printf("version: %s, built for %s\n", version.Version, runtime.GOOS)
return nil
}),
Annotations: map[string]string{
"group": group.Settings,
},
}
cmd.SetUsageTemplate(template.Usage)
return cmd
}
| 34 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// package clean provides structs that clean resources deployed
// by Copilot. It is used prior to deleting a workload or environment
// so that the corresponding CloudFormation stack delete runs successfully.
package clean
// NoOp does nothing.
type NoOp struct{}
// Clean returns nil.
func (*NoOp) Clean() error {
return nil
}
| 16 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package clean
import (
"errors"
"fmt"
"github.com/aws/copilot-cli/internal/pkg/s3"
)
type bucketResourceGetter interface {
BucketName(app, env, wkld string) (string, error)
}
type bucketEmptier interface {
EmptyBucket(string) error
}
// StaticSiteCleaner is used to clean up resources created for a static site.
type StaticSiteCleaner struct {
app, env, svc string
bucketResourceGetter bucketResourceGetter
bucketEmptier bucketEmptier
}
// StaticSite returns an initialized static site cleaner.
func StaticSite(app, env, svc string, rg bucketResourceGetter, emptier bucketEmptier) *StaticSiteCleaner {
return &StaticSiteCleaner{
app: app,
env: env,
svc: svc,
bucketResourceGetter: rg,
bucketEmptier: emptier,
}
}
// Clean looks for the S3 bucket for the service. If no bucket is found,
// it returns no error. If a bucket is found, it is emptied.
func (s *StaticSiteCleaner) Clean() error {
bucket, err := s.bucketResourceGetter.BucketName(s.app, s.env, s.svc)
if err != nil {
var notFound *s3.ErrNotFound
if errors.As(err, ¬Found) {
// bucket doesn't exist, no need to clean up
return nil
}
return fmt.Errorf("get bucket name: %w", err)
}
if err := s.bucketEmptier.EmptyBucket(bucket); err != nil {
return fmt.Errorf("empty bucket: %w", err)
}
return nil
}
| 57 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package clean
import (
"errors"
"testing"
"github.com/stretchr/testify/require"
)
type bucketResourceGetterDouble struct {
BucketNameFn func(app, env, wkld string) (string, error)
}
func (b *bucketResourceGetterDouble) BucketName(app, env, wkld string) (string, error) {
return b.BucketNameFn(app, env, wkld)
}
type bucketEmptierDouble struct {
EmptyBucketFn func(bucket string) error
}
func (b *bucketEmptierDouble) EmptyBucket(bucket string) error {
return b.EmptyBucketFn(bucket)
}
func TestStaticSite_CleanResources(t *testing.T) {
tests := map[string]struct {
cleaner *StaticSiteCleaner
expected string
}{
"error getting bucket": {
cleaner: &StaticSiteCleaner{
bucketResourceGetter: &bucketResourceGetterDouble{
BucketNameFn: func(app, env, wkld string) (string, error) {
return "", errors.New("some error")
},
},
},
expected: "get bucket name: some error",
},
"error emptying bucket": {
cleaner: &StaticSiteCleaner{
bucketResourceGetter: &bucketResourceGetterDouble{
BucketNameFn: func(_, _, _ string) (string, error) {
return "bucket", nil
},
},
bucketEmptier: &bucketEmptierDouble{
EmptyBucketFn: func(_ string) error {
return errors.New("some error")
},
},
},
expected: "empty bucket: some error",
},
"happy path": {
cleaner: &StaticSiteCleaner{
bucketResourceGetter: &bucketResourceGetterDouble{
BucketNameFn: func(_, _, _ string) (string, error) {
return "bucket", nil
},
},
bucketEmptier: &bucketEmptierDouble{
EmptyBucketFn: func(_ string) error {
return nil
},
},
},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
err := tc.cleaner.Clean()
if tc.expected != "" {
require.EqualError(t, err, tc.expected)
return
}
require.NoError(t, err)
})
}
}
| 86 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// cleantest provides stubs for cli.wkldCleaner.
package cleantest
import "errors"
// Succeeds stubs cli.wkldCleaner and simulates success.
type Succeeds struct{}
// Clean succeeds.
func (*Succeeds) Clean() error {
return nil
}
// Fails stubs cli.wkldCleaner and simulates failure.
type Fails struct{}
// Clean fails.
func (*Fails) Clean() error {
return errors.New("an error")
}
| 24 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"fmt"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/acm"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
)
type backendSvcDeployer struct {
*svcDeployer
backendMft *manifest.BackendService
// Overriden in tests.
aliasCertValidator aliasCertValidator
newStack func() cloudformation.StackConfiguration
}
// NewBackendDeployer is the constructor for backendSvcDeployer.
func NewBackendDeployer(in *WorkloadDeployerInput) (*backendSvcDeployer, error) {
in.customResources = backendCustomResources
svcDeployer, err := newSvcDeployer(in)
if err != nil {
return nil, err
}
bsMft, ok := in.Mft.(*manifest.BackendService)
if !ok {
return nil, fmt.Errorf("manifest is not of type %s", manifestinfo.BackendServiceType)
}
return &backendSvcDeployer{
svcDeployer: svcDeployer,
backendMft: bsMft,
aliasCertValidator: acm.New(svcDeployer.envSess),
}, nil
}
func backendCustomResources(fs template.Reader) ([]*customresource.CustomResource, error) {
crs, err := customresource.Backend(fs)
if err != nil {
return nil, fmt.Errorf("read custom resources for a %q: %w", manifestinfo.BackendServiceType, err)
}
return crs, nil
}
// IsServiceAvailableInRegion checks if service type exist in the given region.
func (backendSvcDeployer) IsServiceAvailableInRegion(region string) (bool, error) {
return partitions.IsAvailableInRegion(awsecs.EndpointsID, region)
}
// UploadArtifacts uploads the deployment artifacts such as the container image, custom resources, addons and env files.
func (d *backendSvcDeployer) UploadArtifacts() (*UploadArtifactsOutput, error) {
return d.uploadArtifacts(d.uploadContainerImages, d.uploadArtifactsToS3, d.uploadCustomResources)
}
// GenerateCloudFormationTemplate generates a CloudFormation template and parameters for a workload.
func (d *backendSvcDeployer) GenerateCloudFormationTemplate(in *GenerateCloudFormationTemplateInput) (
*GenerateCloudFormationTemplateOutput, error) {
output, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
return d.generateCloudFormationTemplate(output.conf)
}
// DeployWorkload deploys a backend service using CloudFormation.
func (d *backendSvcDeployer) DeployWorkload(in *DeployWorkloadInput) (ActionRecommender, error) {
stackConfigOutput, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
if err := d.deploy(in.Options, *stackConfigOutput); err != nil {
return nil, err
}
return noopActionRecommender{}, nil
}
func (d *backendSvcDeployer) stackConfiguration(in *StackRuntimeConfiguration) (*svcStackConfigurationOutput, error) {
rc, err := d.runtimeConfig(in)
if err != nil {
return nil, err
}
if err := d.validateALBRuntime(); err != nil {
return nil, err
}
var conf cloudformation.StackConfiguration
switch {
case d.newStack != nil:
conf = d.newStack()
default:
conf, err = stack.NewBackendService(stack.BackendServiceConfig{
App: d.app,
EnvManifest: d.envConfig,
Manifest: d.backendMft,
RawManifest: d.rawMft,
ArtifactBucketName: d.resources.S3Bucket,
RuntimeConfig: *rc,
Addons: d.addons,
})
if err != nil {
return nil, fmt.Errorf("create stack configuration: %w", err)
}
}
return &svcStackConfigurationOutput{
conf: cloudformation.WrapWithTemplateOverrider(conf, d.overrider),
svcUpdater: d.newSvcUpdater(func(s *session.Session) serviceForceUpdater {
return ecs.New(s)
}),
}, nil
}
func (d *backendSvcDeployer) validateALBRuntime() error {
if d.backendMft.HTTP.IsEmpty() {
return nil
}
if err := d.validateRuntimeRoutingRule(d.backendMft.HTTP.Main); err != nil {
return fmt.Errorf(`validate ALB runtime configuration for "http": %w`, err)
}
for idx, rule := range d.backendMft.HTTP.AdditionalRoutingRules {
if err := d.validateRuntimeRoutingRule(rule); err != nil {
return fmt.Errorf(`validate ALB runtime configuration for "http.additional_rules[%d]": %w`, idx, err)
}
}
return nil
}
func (d *backendSvcDeployer) validateRuntimeRoutingRule(rule manifest.RoutingRule) error {
if rule.IsEmpty() {
return nil
}
hasImportedCerts := len(d.envConfig.HTTPConfig.Private.Certificates) != 0
switch {
case rule.Alias.IsEmpty() && hasImportedCerts:
return &errSvcWithNoALBAliasDeployingToEnvWithImportedCerts{
name: d.name,
envName: d.env.Name,
}
case rule.Alias.IsEmpty():
return nil
case !hasImportedCerts:
return fmt.Errorf(`cannot specify "alias" in an environment without imported certs`)
}
aliases, err := rule.Alias.ToStringSlice()
if err != nil {
return fmt.Errorf("convert aliases to string slice: %w", err)
}
if err := d.aliasCertValidator.ValidateCertAliases(aliases, d.envConfig.HTTPConfig.Private.Certificates); err != nil {
return fmt.Errorf("validate aliases against the imported certificate for env %s: %w", d.env.Name, err)
}
return nil
}
| 167 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"errors"
"testing"
"time"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/override"
"gopkg.in/yaml.v3"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestBackendSvcDeployer_GenerateCloudFormationTemplate(t *testing.T) {
t.Run("ensure resulting CloudFormation template custom resource paths are empty", func(t *testing.T) {
// GIVEN
backend := mockBackendServiceDeployer()
// WHEN
out, err := backend.GenerateCloudFormationTemplate(&GenerateCloudFormationTemplateInput{})
// THEN
require.NoError(t, err)
type lambdaFn struct {
Properties struct {
Code struct {
S3Bucket string `yaml:"S3bucket"`
S3Key string `yaml:"S3Key"`
} `yaml:"Code"`
} `yaml:"Properties"`
}
dat := struct {
Resources struct {
EnvControllerFunction lambdaFn `yaml:"EnvControllerFunction"`
RulePriorityFunction lambdaFn `yaml:"RulePriorityFunction"`
} `yaml:"Resources"`
}{}
require.NoError(t, yaml.Unmarshal([]byte(out.Template), &dat))
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Key)
require.Empty(t, dat.Resources.RulePriorityFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.RulePriorityFunction.Properties.Code.S3Key)
})
}
func TestBackendSvcDeployer_stackConfiguration(t *testing.T) {
const (
mockAppName = "mock-app"
mockEnvName = "mock-env"
mockSvcName = "mock-svc"
)
tests := map[string]struct {
App *config.Application
Env *config.Environment
Manifest *manifest.BackendService
// Cached variables.
inEnvironmentConfig func() *manifest.Environment
setupMocks func(m *deployMocks)
expectedErr string
}{
"success if alb not configured": {
App: &config.Application{
Name: mockAppName,
},
Env: &config.Environment{
Name: mockEnvName,
},
Manifest: &manifest.BackendService{},
setupMocks: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return(mockAppName+".local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
},
"failure if alias configured, no env certs": {
App: &config.Application{
Name: mockAppName,
},
Env: &config.Environment{
Name: mockEnvName,
},
Manifest: &manifest.BackendService{
BackendServiceConfig: manifest.BackendServiceConfig{
HTTP: manifest.HTTP{
Main: manifest.RoutingRule{
Alias: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{Alias: aws.String("go.dev")},
},
},
},
},
},
},
setupMocks: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return(mockAppName+".local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
expectedErr: `validate ALB runtime configuration for "http": cannot specify "alias" in an environment without imported certs`,
},
"failure if cert validation fails": {
App: &config.Application{
Name: mockAppName,
},
Env: &config.Environment{
Name: mockEnvName,
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Private.Certificates = []string{"mockCertARN"}
return envConfig
},
Manifest: &manifest.BackendService{
BackendServiceConfig: manifest.BackendServiceConfig{
HTTP: manifest.HTTP{
Main: manifest.RoutingRule{
Alias: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{Alias: aws.String("go.dev")},
},
},
},
},
},
},
setupMocks: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return(mockAppName+".local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"go.dev"}, []string{"mockCertARN"}).Return(errors.New("some error"))
},
expectedErr: "validate ALB runtime configuration for \"http\": validate aliases against the imported certificate for env mock-env: some error",
},
"success if cert validation succeeds": {
App: &config.Application{
Name: mockAppName,
},
Env: &config.Environment{
Name: mockEnvName,
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Private.Certificates = []string{"mockCertARN"}
return envConfig
},
Manifest: &manifest.BackendService{
BackendServiceConfig: manifest.BackendServiceConfig{
HTTP: manifest.HTTP{
Main: manifest.RoutingRule{
Alias: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{Alias: aws.String("go.dev")},
},
},
},
AdditionalRoutingRules: []manifest.RoutingRule{
{
Alias: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{Alias: aws.String("go.test")},
},
},
},
},
},
},
},
setupMocks: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return(mockAppName+".local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"go.dev"}, []string{"mockCertARN"}).Return(nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"go.test"}, []string{"mockCertARN"}).Return(nil)
},
},
"failure if env has imported certs but no alias set": {
App: &config.Application{
Name: mockAppName,
},
Env: &config.Environment{
Name: mockEnvName,
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Private.Certificates = []string{"mockCertARN"}
return envConfig
},
Manifest: &manifest.BackendService{
BackendServiceConfig: manifest.BackendServiceConfig{
HTTP: manifest.HTTP{
Main: manifest.RoutingRule{
Path: aws.String("/"),
},
},
},
},
setupMocks: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return(mockAppName+".local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
expectedErr: `validate ALB runtime configuration for "http": cannot deploy service mock-svc without "alias" to environment mock-env with certificate imported`,
},
"failure if env has imported certs but no alias set in additional rules": {
App: &config.Application{
Name: mockAppName,
},
Env: &config.Environment{
Name: mockEnvName,
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Private.Certificates = []string{"mockCertARN"}
return envConfig
},
Manifest: &manifest.BackendService{
BackendServiceConfig: manifest.BackendServiceConfig{
HTTP: manifest.HTTP{
Main: manifest.RoutingRule{
Path: aws.String("/"),
Alias: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{Alias: aws.String("go.test")},
},
},
},
AdditionalRoutingRules: []manifest.RoutingRule{
{
Path: aws.String("/admin"),
},
},
},
},
},
setupMocks: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return(mockAppName+".local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"go.test"}, []string{"mockCertARN"}).Return(nil)
},
expectedErr: `validate ALB runtime configuration for "http.additional_rules[0]": cannot deploy service mock-svc without "alias" to environment mock-env with certificate imported`,
},
"success if env has imported certs but alb not configured": {
App: &config.Application{
Name: mockAppName,
},
Env: &config.Environment{
Name: mockEnvName,
CustomConfig: &config.CustomizeEnv{
ImportCertARNs: []string{"mockCertARN"},
},
},
Manifest: &manifest.BackendService{},
setupMocks: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return(mockAppName+".local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployMocks{
mockEndpointGetter: mocks.NewMockendpointGetter(ctrl),
mockValidator: mocks.NewMockaliasCertValidator(ctrl),
mockEnvVersionGetter: mocks.NewMockversionGetter(ctrl),
}
if tc.setupMocks != nil {
tc.setupMocks(m)
}
if tc.inEnvironmentConfig == nil {
tc.inEnvironmentConfig = func() *manifest.Environment {
return &manifest.Environment{}
}
}
deployer := &backendSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: mockSvcName,
app: tc.App,
env: tc.Env,
endpointGetter: m.mockEndpointGetter,
resources: &stack.AppRegionalResources{},
envConfig: tc.inEnvironmentConfig(),
envVersionGetter: m.mockEnvVersionGetter,
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return nil
},
},
backendMft: tc.Manifest,
aliasCertValidator: m.mockValidator,
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
_, err := deployer.stackConfiguration(&StackRuntimeConfiguration{})
if tc.expectedErr != "" {
require.EqualError(t, err, tc.expectedErr)
} else {
require.NoError(t, err)
}
})
}
}
func mockBackendServiceDeployer(opts ...func(*backendSvcDeployer)) *backendSvcDeployer {
deployer := &backendSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: "example",
app: &config.Application{
Name: "demo",
},
env: &config.Environment{
App: "demo",
Name: "test",
},
resources: &stack.AppRegionalResources{},
envConfig: new(manifest.Environment),
endpointGetter: &mockEndpointGetter{endpoint: "demo.test.local"},
envVersionGetter: &mockEnvVersionGetter{version: "v1.0.0"},
overrider: new(override.Noop),
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return nil
},
now: func() time.Time {
return time.Date(2020, 11, 23, 0, 0, 0, 0, time.UTC)
},
},
backendMft: &manifest.BackendService{
Workload: manifest.Workload{
Name: aws.String("example"),
},
BackendServiceConfig: manifest.BackendServiceConfig{
TaskConfig: manifest.TaskConfig{
Count: manifest.Count{
Value: aws.Int(1),
},
},
ImageConfig: manifest.ImageWithHealthcheckAndOptionalPort{
ImageWithOptionalPort: manifest.ImageWithOptionalPort{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Build: manifest.BuildArgsOrString{BuildString: aws.String("/Dockerfile")},
},
},
Port: aws.Uint16(80),
},
},
},
},
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
for _, opt := range opts {
opt(deployer)
}
return deployer
}
| 381 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"context"
"errors"
"fmt"
"io"
"os"
"sort"
"strings"
"sync"
awscfn "github.com/aws/aws-sdk-go/service/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/addon"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/ec2"
"github.com/aws/copilot-cli/internal/pkg/aws/elbv2"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
awss3 "github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/patch"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
deploycfn "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
cfnstack "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/describe/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/override"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/template/artifactpath"
"github.com/aws/copilot-cli/internal/pkg/template/diff"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/spf13/afero"
"golang.org/x/sync/errgroup"
)
// WorkspaceAddonsReaderPathGetter reads addons from a workspace and the path of a workspace.
type WorkspaceAddonsReaderPathGetter interface {
addon.WorkspaceAddonsReader
Path() string
}
type appResourcesGetter interface {
GetAppResourcesByRegion(app *config.Application, region string) (*cfnstack.AppRegionalResources, error)
}
type environmentDeployer interface {
UpdateAndRenderEnvironment(conf deploycfn.StackConfiguration, bucketARN string, opts ...cloudformation.StackOption) error
DeployedEnvironmentParameters(app, env string) ([]*awscfn.Parameter, error)
ForceUpdateOutputID(app, env string) (string, error)
}
type patcher interface {
EnsureManagerRoleIsAllowedToUpload(bucketName string) error
}
type prefixListGetter interface {
CloudFrontManagedPrefixListID() (string, error)
}
type envDescriber interface {
ValidateCFServiceDomainAliases() error
Params() (map[string]string, error)
}
type lbDescriber interface {
DescribeRule(context.Context, string) (elbv2.Rule, error)
}
type stackDescriber interface {
Resources() ([]*stack.Resource, error)
}
type addons struct {
stack stackBuilder
err error
}
type envDeployer struct {
app *config.Application
env *config.Environment
// Dependencies to upload artifacts.
templateFS template.Reader
s3 uploader
prefixListGetter prefixListGetter
// Dependencies to deploy an environment.
appCFN appResourcesGetter
envDeployer environmentDeployer
tmplGetter deployedTemplateGetter
patcher patcher
newStack func(input *cfnstack.EnvConfig, forceUpdateID string, prevParams []*awscfn.Parameter) (deploycfn.StackConfiguration, error)
envDescriber envDescriber
lbDescriber lbDescriber
newServiceStackDescriber func(string) stackDescriber
// Dependencies for parsing addons.
ws WorkspaceAddonsReaderPathGetter
parseAddonsOnce sync.Once
parseAddons func() (stackBuilder, error)
// Cached variables.
appRegionalResources *cfnstack.AppRegionalResources
addons addons
}
// NewEnvDeployerInput contains information needed to construct an environment deployer.
type NewEnvDeployerInput struct {
App *config.Application
Env *config.Environment
SessionProvider *sessions.Provider
ConfigStore describe.ConfigStoreSvc
Workspace WorkspaceAddonsReaderPathGetter
Overrider Overrider
}
// NewEnvDeployer constructs an environment deployer.
func NewEnvDeployer(in *NewEnvDeployerInput) (*envDeployer, error) {
defaultSession, err := in.SessionProvider.Default()
if err != nil {
return nil, fmt.Errorf("get default session: %w", err)
}
envRegionSession, err := in.SessionProvider.DefaultWithRegion(in.Env.Region)
if err != nil {
return nil, fmt.Errorf("get default session in env region %s: %w", in.Env.Region, err)
}
envManagerSession, err := in.SessionProvider.FromRole(in.Env.ManagerRoleARN, in.Env.Region)
if err != nil {
return nil, fmt.Errorf("get env session: %w", err)
}
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: in.App.Name,
Env: in.Env.Name,
ConfigStore: in.ConfigStore,
})
if err != nil {
return nil, fmt.Errorf("initialize env describer: %w", err)
}
overrider := in.Overrider
if overrider == nil {
overrider = new(override.Noop)
}
cfnClient := deploycfn.New(envManagerSession, deploycfn.WithProgressTracker(os.Stderr))
deployer := &envDeployer{
app: in.App,
env: in.Env,
templateFS: template.New(),
s3: awss3.New(envManagerSession),
prefixListGetter: ec2.New(envRegionSession),
appCFN: deploycfn.New(defaultSession, deploycfn.WithProgressTracker(os.Stderr)),
envDeployer: cfnClient,
tmplGetter: cfnClient,
patcher: &patch.EnvironmentPatcher{
Prog: termprogress.NewSpinner(log.DiagnosticWriter),
TemplatePatcher: cfnClient,
Env: in.Env,
},
newStack: func(in *cfnstack.EnvConfig, lastForceUpdateID string, oldParams []*awscfn.Parameter) (deploycfn.StackConfiguration, error) {
stack, err := cfnstack.NewEnvConfigFromExistingStack(in, lastForceUpdateID, oldParams)
if err != nil {
return nil, err
}
return deploycfn.WrapWithTemplateOverrider(stack, overrider), nil
},
envDescriber: envDescriber,
lbDescriber: elbv2.New(envManagerSession),
newServiceStackDescriber: func(svc string) stackDescriber {
return stack.NewStackDescriber(cfnstack.NameForWorkload(in.App.Name, in.Env.Name, svc), envManagerSession)
},
ws: in.Workspace,
}
deployer.parseAddons = func() (stackBuilder, error) {
deployer.parseAddonsOnce.Do(func() {
deployer.addons.stack, deployer.addons.err = addon.ParseFromEnv(deployer.ws)
})
return deployer.addons.stack, deployer.addons.err
}
return deployer, nil
}
// Validate returns an error if the environment manifest is incompatible with services and application configurations.
func (d *envDeployer) Validate(mft *manifest.Environment) error {
return d.validateCDN(mft)
}
// UploadEnvArtifactsOutput holds URLs of artifacts pushed to S3 buckets.
type UploadEnvArtifactsOutput struct {
AddonsURL string
CustomResourceURLs map[string]string
}
// UploadArtifacts uploads the deployment artifacts for the environment.
func (d *envDeployer) UploadArtifacts() (*UploadEnvArtifactsOutput, error) {
resources, err := d.getAppRegionalResources()
if err != nil {
return nil, err
}
if err := d.patcher.EnsureManagerRoleIsAllowedToUpload(resources.S3Bucket); err != nil {
return nil, fmt.Errorf("ensure env manager role has permissions to upload: %w", err)
}
customResourceURLs, err := d.uploadCustomResources(resources.S3Bucket)
if err != nil {
return nil, err
}
addonsURL, err := d.uploadAddons(resources.S3Bucket)
if err != nil {
return nil, err
}
return &UploadEnvArtifactsOutput{
AddonsURL: addonsURL,
CustomResourceURLs: customResourceURLs,
}, nil
}
// DeployDiff returns the stringified diff of the template against the deployed template of the environment.
func (d *envDeployer) DeployDiff(template string) (string, error) {
tmpl, err := d.tmplGetter.Template(cfnstack.NameForEnv(d.app.Name, d.env.Name))
if err != nil {
var errNotFound *awscloudformation.ErrStackNotFound
if !errors.As(err, &errNotFound) {
return "", fmt.Errorf("retrieve the deployed template for %q: %w", d.env.Name, err)
}
tmpl = ""
}
diffTree, err := diff.From(tmpl).ParseWithCFNOverriders([]byte(template))
if err != nil {
return "", fmt.Errorf("parse the diff against the deployed env stack %q: %w", d.env.Name, err)
}
buf := strings.Builder{}
if err := diffTree.Write(&buf); err != nil {
return "", err
}
return buf.String(), nil
}
// AddonsTemplate returns the environment addons template.
func (d *envDeployer) AddonsTemplate() (string, error) {
addons, err := d.parseAddons()
if err != nil {
var notFoundErr *addon.ErrAddonsNotFound
if !errors.As(err, ¬FoundErr) {
return "", fmt.Errorf("parse environment addons: %w", err)
}
return "", nil
}
tmpl, err := addons.Template()
if err != nil {
return "", fmt.Errorf("render addons template: %w", err)
}
return tmpl, nil
}
// DeployEnvironmentInput contains information used to deploy the environment.
type DeployEnvironmentInput struct {
RootUserARN string
AddonsURL string
CustomResourcesURLs map[string]string
Manifest *manifest.Environment
ForceNewUpdate bool
RawManifest []byte
PermissionsBoundary string
DisableRollback bool
Version string
}
// GenerateCloudFormationTemplate returns the environment stack's template and parameter configuration.
func (d *envDeployer) GenerateCloudFormationTemplate(in *DeployEnvironmentInput) (*GenerateCloudFormationTemplateOutput, error) {
stackInput, err := d.buildStackInput(in)
if err != nil {
return nil, err
}
oldParams, err := d.envDeployer.DeployedEnvironmentParameters(d.app.Name, d.env.Name)
if err != nil {
return nil, fmt.Errorf("describe environment stack parameters: %w", err)
}
lastForceUpdateID, err := d.envDeployer.ForceUpdateOutputID(d.app.Name, d.env.Name)
if err != nil {
return nil, fmt.Errorf("retrieve environment stack force update ID: %w", err)
}
stack, err := d.newStack(stackInput, lastForceUpdateID, oldParams)
if err != nil {
return nil, err
}
tpl, err := stack.Template()
if err != nil {
return nil, fmt.Errorf("generate stack template: %w", err)
}
params, err := stack.SerializedParameters()
if err != nil {
return nil, fmt.Errorf("generate stack template parameters: %w", err)
}
return &GenerateCloudFormationTemplateOutput{
Template: tpl,
Parameters: params,
}, nil
}
// DeployEnvironment deploys an environment using CloudFormation.
func (d *envDeployer) DeployEnvironment(in *DeployEnvironmentInput) error {
stackInput, err := d.buildStackInput(in)
if err != nil {
return err
}
oldParams, err := d.envDeployer.DeployedEnvironmentParameters(d.app.Name, d.env.Name)
if err != nil {
return fmt.Errorf("describe environment stack parameters: %w", err)
}
lastForceUpdateID, err := d.envDeployer.ForceUpdateOutputID(d.app.Name, d.env.Name)
if err != nil {
return fmt.Errorf("retrieve environment stack force update ID: %w", err)
}
opts := []awscloudformation.StackOption{
awscloudformation.WithRoleARN(d.env.ExecutionRoleARN),
}
if in.DisableRollback {
opts = append(opts, awscloudformation.WithDisableRollback())
}
stack, err := d.newStack(stackInput, lastForceUpdateID, oldParams)
if err != nil {
return err
}
return d.envDeployer.UpdateAndRenderEnvironment(stack, stackInput.ArtifactBucketARN, opts...)
}
func (d *envDeployer) getAppRegionalResources() (*cfnstack.AppRegionalResources, error) {
if d.appRegionalResources != nil {
return d.appRegionalResources, nil
}
resources, err := d.appCFN.GetAppResourcesByRegion(d.app, d.env.Region)
if err != nil {
return nil, fmt.Errorf("get app resources in region %s: %w", d.env.Region, err)
}
if resources.S3Bucket == "" {
return nil, fmt.Errorf("cannot find the S3 artifact bucket in region %s", d.env.Region)
}
return resources, nil
}
func (d *envDeployer) uploadCustomResources(bucket string) (map[string]string, error) {
crs, err := customresource.Env(d.templateFS)
if err != nil {
return nil, fmt.Errorf("read custom resources for environment %s: %w", d.env.Name, err)
}
urls, err := customresource.Upload(func(key string, dat io.Reader) (url string, err error) {
return d.s3.Upload(bucket, key, dat)
}, crs)
if err != nil {
return nil, fmt.Errorf("upload custom resources to bucket %s: %w", bucket, err)
}
return urls, nil
}
func (d *envDeployer) uploadAddons(bucket string) (string, error) {
addons, err := d.parseAddons()
if err != nil {
var notFoundErr *addon.ErrAddonsNotFound
if !errors.As(err, ¬FoundErr) {
return "", fmt.Errorf("parse environment addons: %w", err)
}
return "", nil
}
pkgConfig := addon.PackageConfig{
Bucket: bucket,
Uploader: d.s3,
WorkspacePath: d.ws.Path(),
FS: afero.NewOsFs(),
}
if err := addons.Package(pkgConfig); err != nil {
return "", fmt.Errorf("package environment addons: %w", err)
}
tmpl, err := addons.Template()
if err != nil {
return "", fmt.Errorf("render addons template: %w", err)
}
url, err := d.s3.Upload(bucket, artifactpath.EnvironmentAddons([]byte(tmpl)), strings.NewReader(tmpl))
if err != nil {
return "", fmt.Errorf("upload addons template to bucket %s: %w", bucket, err)
}
return url, nil
}
func (d *envDeployer) buildStackInput(in *DeployEnvironmentInput) (*cfnstack.EnvConfig, error) {
resources, err := d.getAppRegionalResources()
if err != nil {
return nil, err
}
partition, err := partitions.Region(d.env.Region).Partition()
if err != nil {
return nil, err
}
cidrPrefixListIDs, err := d.cidrPrefixLists(in)
if err != nil {
return nil, err
}
addons, err := d.buildAddonsInput(resources.Region, resources.S3Bucket, in.AddonsURL)
if err != nil {
return nil, err
}
return &cfnstack.EnvConfig{
Name: d.env.Name,
App: deploy.AppInformation{
Name: d.app.Name,
Domain: d.app.Domain,
AccountPrincipalARN: in.RootUserARN,
},
AdditionalTags: d.app.Tags,
Addons: addons,
CustomResourcesURLs: in.CustomResourcesURLs,
ArtifactBucketARN: awss3.FormatARN(partition.ID(), resources.S3Bucket),
ArtifactBucketKeyARN: resources.KMSKeyARN,
CIDRPrefixListIDs: cidrPrefixListIDs,
PublicALBSourceIPs: d.publicALBSourceIPs(in),
Mft: in.Manifest,
ForceUpdate: in.ForceNewUpdate,
RawMft: in.RawManifest,
PermissionsBoundary: in.PermissionsBoundary,
Version: in.Version,
}, nil
}
func (d *envDeployer) buildAddonsInput(region, bucket, uploadURL string) (*cfnstack.Addons, error) {
parsedAddons, err := d.parseAddons()
if err != nil {
var notFoundErr *addon.ErrAddonsNotFound
if errors.As(err, ¬FoundErr) {
return nil, nil
}
return nil, err
}
if uploadURL != "" {
return &cfnstack.Addons{
S3ObjectURL: uploadURL,
Stack: parsedAddons,
}, nil
}
tpl, err := parsedAddons.Template()
if err != nil {
return nil, fmt.Errorf("render addons template: %w", err)
}
return &cfnstack.Addons{
S3ObjectURL: awss3.URL(region, bucket, artifactpath.EnvironmentAddons([]byte(tpl))),
Stack: parsedAddons,
}, nil
}
// lbServiceRedirects returns true if svc's HTTP listener rule redirects. We only check
// HTTPListenerRuleWithDomain because HTTPListenerRule doesn't ever redirect.
func (d *envDeployer) lbServiceRedirects(ctx context.Context, svc string) (bool, error) {
stackDescriber := d.newServiceStackDescriber(svc)
resources, err := stackDescriber.Resources()
if err != nil {
return false, fmt.Errorf("get stack resources: %w", err)
}
var ruleARN string
for _, res := range resources {
if res.LogicalID == template.LogicalIDHTTPListenerRuleWithDomain {
ruleARN = res.PhysicalID
break
}
}
if ruleARN == "" {
// this will happen if the service doesn't support https.
return false, nil
}
rule, err := d.lbDescriber.DescribeRule(ctx, ruleARN)
if err != nil {
return false, fmt.Errorf("describe listener rule %q: %w", ruleARN, err)
}
return rule.HasRedirectAction(), nil
}
func (d *envDeployer) validateCDN(mft *manifest.Environment) error {
isManagedCDNEnabled := mft.CDNEnabled() && !mft.HasImportedPublicALBCerts() && d.app.Domain != ""
if isManagedCDNEnabled {
// With managed domain, if the customer isn't using `alias` the A-records are inserted in the service stack as each service domain is unique.
// However, when clients enable CloudFront, they would need to update all their existing records to now point to the distribution.
// Hence, we force users to use `alias` and let the records be written in the environment stack instead.
if err := d.envDescriber.ValidateCFServiceDomainAliases(); err != nil {
return err
}
}
if mft.CDNEnabled() && mft.CDNDoesTLSTermination() {
err := d.validateALBWorkloadsDontRedirect()
var redirErr *errEnvHasPublicServicesWithRedirect
switch {
case errors.As(err, &redirErr) && mft.IsPublicLBIngressRestrictedToCDN():
return err
case errors.As(err, &redirErr):
log.Warningln(redirErr.warning())
case err != nil:
return fmt.Errorf("enable TLS termination on CDN: %w", err)
}
}
return nil
}
// validateALBWorkloadsDontRedirect verifies that none of the public ALB Workloads
// in this environment have a redirect in their HTTPWithDomain listener.
// If any services redirect, an error is returned.
func (d *envDeployer) validateALBWorkloadsDontRedirect() error {
params, err := d.envDescriber.Params()
if err != nil {
return fmt.Errorf("get env params: %w", err)
}
if params[cfnstack.EnvParamALBWorkloadsKey] == "" {
return nil
}
services := strings.Split(params[cfnstack.EnvParamALBWorkloadsKey], ",")
g, ctx := errgroup.WithContext(context.Background())
var badServices []string
var badServicesMu sync.Mutex
for i := range services {
svc := services[i]
g.Go(func() error {
redirects, err := d.lbServiceRedirects(ctx, svc)
switch {
case err != nil:
return fmt.Errorf("verify service %q: %w", svc, err)
case redirects:
badServicesMu.Lock()
defer badServicesMu.Unlock()
badServices = append(badServices, svc)
}
return nil
})
}
if err := g.Wait(); err != nil {
return err
}
if len(badServices) > 0 {
sort.Strings(badServices)
return &errEnvHasPublicServicesWithRedirect{
services: badServices,
}
}
return nil
}
func (d *envDeployer) cidrPrefixLists(in *DeployEnvironmentInput) ([]string, error) {
var cidrPrefixListIDs []string
// Check if ingress is allowed from cloudfront
if in.Manifest == nil || !in.Manifest.IsPublicLBIngressRestrictedToCDN() {
return nil, nil
}
cfManagedPrefixListID, err := d.cfManagedPrefixListID()
if err != nil {
return nil, err
}
cidrPrefixListIDs = append(cidrPrefixListIDs, cfManagedPrefixListID)
return cidrPrefixListIDs, nil
}
func (d *envDeployer) publicALBSourceIPs(in *DeployEnvironmentInput) []string {
if in.Manifest == nil || len(in.Manifest.GetPublicALBSourceIPs()) == 0 {
return nil
}
ips := make([]string, len(in.Manifest.GetPublicALBSourceIPs()))
for i, sourceIP := range in.Manifest.GetPublicALBSourceIPs() {
ips[i] = string(sourceIP)
}
return ips
}
func (d *envDeployer) cfManagedPrefixListID() (string, error) {
id, err := d.prefixListGetter.CloudFrontManagedPrefixListID()
if err != nil {
return "", fmt.Errorf("retrieve CloudFront managed prefix list id: %w", err)
}
return id, nil
}
| 595 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"bytes"
"errors"
"fmt"
"io"
"strings"
"testing"
cfnclient "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
cfnmocks "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/mocks"
"github.com/aws/aws-sdk-go/aws"
awscfn "github.com/aws/aws-sdk-go/service/cloudformation"
awselb "github.com/aws/aws-sdk-go/service/elbv2"
"github.com/aws/copilot-cli/internal/pkg/addon"
"github.com/aws/copilot-cli/internal/pkg/aws/elbv2"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
cfnstack "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/describe/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/template/artifactpath"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type envDeployerMocks struct {
s3 *mocks.Mockuploader
prefixListGetter *mocks.MockprefixListGetter
appCFN *mocks.MockappResourcesGetter
envDeployer *mocks.MockenvironmentDeployer
patcher *mocks.Mockpatcher
stackSerializer *cfnmocks.MockStackConfiguration
envDescriber *mocks.MockenvDescriber
lbDescriber *mocks.MocklbDescriber
stackDescribers map[string]*mocks.MockstackDescriber
ws *mocks.MockWorkspaceAddonsReaderPathGetter
parseAddons func() (stackBuilder, error)
addons *mocks.MockstackBuilder
}
func TestEnvDeployer_UploadArtifacts(t *testing.T) {
const (
mockEnvRegion = "mockEnvRegion"
)
mockApp := &config.Application{}
testCases := map[string]struct {
setUpMocks func(m *envDeployerMocks)
wantedAddonsURL string
wantedCustomResourceURLs map[string]string
wantedError error
}{
"fail to get app resource by region": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("get app resources in region %s: some error", mockEnvRegion),
},
"fail to find S3 bucket in the region": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{}, nil)
},
wantedError: fmt.Errorf("cannot find the S3 artifact bucket in region %s", mockEnvRegion),
},
"fail to patch the environment": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(errors.New("some error"))
},
wantedError: errors.New("ensure env manager role has permissions to upload: some error"),
},
"fail to upload custom resource scripts": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(nil)
m.s3.EXPECT().Upload("mockS3Bucket", gomock.Any(), gomock.Any()).AnyTimes().Return("", fmt.Errorf("some error"))
},
wantedError: errors.New("upload custom resources to bucket mockS3Bucket"),
},
"fail to parse addons": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(nil)
m.s3.EXPECT().Upload("mockS3Bucket", gomock.Any(), gomock.Any()).AnyTimes().Return("", nil)
m.parseAddons = func() (stackBuilder, error) {
return nil, errors.New("some error")
}
},
wantedError: errors.New("parse environment addons: some error"),
},
"fail to package addons asset": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(nil)
m.s3.EXPECT().Upload("mockS3Bucket", gomock.Any(), gomock.Any()).AnyTimes().Return("", nil)
m.parseAddons = func() (stackBuilder, error) {
return m.addons, nil
}
m.ws.EXPECT().Path().Return("mockPath")
m.addons.EXPECT().Package(gomock.Any()).Return(errors.New("some error"))
},
wantedError: errors.New("package environment addons: some error"),
},
"fail to render addons template": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(nil)
m.s3.EXPECT().Upload("mockS3Bucket", gomock.Any(), gomock.Any()).AnyTimes().Return("", nil)
m.parseAddons = func() (stackBuilder, error) {
return m.addons, nil
}
m.ws.EXPECT().Path().Return("mockPath")
m.addons.EXPECT().Package(gomock.Any()).Return(nil)
m.addons.EXPECT().Template().Return("", errors.New("some error"))
},
wantedError: errors.New("render addons template: some error"),
},
"fail to upload addons template": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(nil)
m.s3.EXPECT().Upload("mockS3Bucket", gomock.Not(artifactpath.EnvironmentAddons([]byte("mockAddons"))), gomock.Any()).AnyTimes().Return("", nil)
m.parseAddons = func() (stackBuilder, error) {
return m.addons, nil
}
m.ws.EXPECT().Path().Return("mockPath")
m.addons.EXPECT().Package(gomock.Any()).Return(nil)
m.addons.EXPECT().Template().Return("mockAddons", nil)
m.s3.EXPECT().Upload("mockS3Bucket", artifactpath.EnvironmentAddons([]byte("mockAddons")), gomock.Any()).
Return("", errors.New("some error"))
},
wantedError: errors.New("upload addons template to bucket mockS3Bucket: some error"),
},
"success with addons and custom resources URLs": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(nil)
m.s3.EXPECT().Upload("mockS3Bucket", gomock.Not(artifactpath.EnvironmentAddons([]byte("mockAddons"))), gomock.Any()).AnyTimes().Return("", nil)
m.parseAddons = func() (stackBuilder, error) {
return m.addons, nil
}
m.ws.EXPECT().Path().Return("mockPath")
m.addons.EXPECT().Package(gomock.Any()).Return(nil)
m.addons.EXPECT().Template().Return("mockAddons", nil)
m.s3.EXPECT().Upload("mockS3Bucket", artifactpath.EnvironmentAddons([]byte("mockAddons")), gomock.Any()).
Return("mockAddonsURL", nil)
},
wantedAddonsURL: "mockAddonsURL",
wantedCustomResourceURLs: map[string]string{
"CertificateReplicatorFunction": "",
"CertificateValidationFunction": "",
"CustomDomainFunction": "",
"DNSDelegationFunction": "",
"UniqueJSONValuesFunction": "",
},
},
"success with only custom resource URLs returned": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.patcher.EXPECT().EnsureManagerRoleIsAllowedToUpload("mockS3Bucket").Return(nil)
crs, err := customresource.Env(fakeTemplateFS())
require.NoError(t, err)
m.s3.EXPECT().Upload("mockS3Bucket", gomock.Any(), gomock.Any()).DoAndReturn(func(_, key string, _ io.Reader) (url string, err error) {
for _, cr := range crs {
if strings.Contains(key, strings.ToLower(cr.Name())) {
return "", nil
}
}
return "", errors.New("did not match any custom resource")
}).Times(len(crs))
m.parseAddons = func() (stackBuilder, error) {
return nil, &addon.ErrAddonsNotFound{}
}
},
wantedCustomResourceURLs: map[string]string{
"CertificateReplicatorFunction": "",
"CertificateValidationFunction": "",
"CustomDomainFunction": "",
"DNSDelegationFunction": "",
"UniqueJSONValuesFunction": "",
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &envDeployerMocks{
appCFN: mocks.NewMockappResourcesGetter(ctrl),
s3: mocks.NewMockuploader(ctrl),
patcher: mocks.NewMockpatcher(ctrl),
ws: mocks.NewMockWorkspaceAddonsReaderPathGetter(ctrl),
addons: mocks.NewMockstackBuilder(ctrl),
}
tc.setUpMocks(m)
mockEnv := &config.Environment{
Name: "mockEnv",
ManagerRoleARN: "mockManagerRoleARN",
Region: mockEnvRegion,
App: "mockApp",
}
d := envDeployer{
app: mockApp,
env: mockEnv,
appCFN: m.appCFN,
s3: m.s3,
patcher: m.patcher,
templateFS: fakeTemplateFS(),
ws: m.ws,
parseAddons: m.parseAddons,
}
got, gotErr := d.UploadArtifacts()
if tc.wantedError != nil {
require.Contains(t, gotErr.Error(), tc.wantedError.Error())
} else {
require.NoError(t, gotErr)
require.Equal(t, tc.wantedCustomResourceURLs, got.CustomResourceURLs)
require.Equal(t, tc.wantedAddonsURL, got.AddonsURL)
}
})
}
}
func TestEnvDeployer_DeployDiff(t *testing.T) {
testCases := map[string]struct {
inTemplate string
setUpMocks func(m *deployDiffMocks)
wanted string
checkErr func(t *testing.T, gotErr error)
}{
"error getting the deployed template": {
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.
EXPECT().Template(gomock.Eq(cfnstack.NameForEnv("mockApp", "mockEnv"))).
Return("", errors.New("some error"))
},
checkErr: func(t *testing.T, gotErr error) {
require.EqualError(t, gotErr, `retrieve the deployed template for "mockEnv": some error`)
},
},
"error parsing the diff against the deployed template": {
inTemplate: `!!!???what a weird template`,
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.EXPECT().
Template(gomock.Eq(cfnstack.NameForEnv("mockApp", "mockEnv"))).
Return("wow such template", nil)
},
checkErr: func(t *testing.T, gotErr error) {
require.ErrorContains(t, gotErr, `parse the diff against the deployed env stack "mockEnv"`)
},
},
"get the correct diff": {
inTemplate: `peace: and love`,
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.EXPECT().
Template(gomock.Eq(cfnstack.NameForEnv("mockApp", "mockEnv"))).
Return("peace: und Liebe", nil)
},
wanted: `~ peace: und Liebe -> and love
`,
},
"get the correct diff when there is no deployed diff": {
inTemplate: `peace: and love`,
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.EXPECT().
Template(gomock.Eq(cfnstack.NameForEnv("mockApp", "mockEnv"))).
Return("", &cfnclient.ErrStackNotFound{})
},
wanted: `+ peace: and love
`,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployDiffMocks{
mockDeployedTmplGetter: mocks.NewMockdeployedTemplateGetter(ctrl),
}
tc.setUpMocks(m)
deployer := envDeployer{
app: &config.Application{
Name: "mockApp",
},
env: &config.Environment{
Name: "mockEnv",
},
tmplGetter: m.mockDeployedTmplGetter,
}
got, gotErr := deployer.DeployDiff(tc.inTemplate)
if tc.checkErr != nil {
tc.checkErr(t, gotErr)
} else {
require.NoError(t, gotErr)
require.Equal(t, tc.wanted, got)
}
})
}
}
func TestEnvDeployer_AddonsTemplate(t *testing.T) {
testCases := map[string]struct {
setUpMocks func(m *envDeployerMocks)
wanted string
wantedError error
}{
"error rendering addons template": {
setUpMocks: func(m *envDeployerMocks) {
m.parseAddons = func() (stackBuilder, error) {
return m.addons, nil
}
m.addons.EXPECT().Template().Return("", errors.New("some error"))
},
wantedError: errors.New("render addons template: some error"),
},
"return empty string when no addons is found": {
setUpMocks: func(m *envDeployerMocks) {
m.parseAddons = func() (stackBuilder, error) {
return nil, &addon.ErrAddonsNotFound{}
}
},
},
"return the addon template": {
setUpMocks: func(m *envDeployerMocks) {
m.parseAddons = func() (stackBuilder, error) {
return m.addons, nil
}
m.addons.EXPECT().Template().Return("mockAddonsTemplate", nil)
},
wanted: "mockAddonsTemplate",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &envDeployerMocks{
addons: mocks.NewMockstackBuilder(ctrl),
}
tc.setUpMocks(m)
d := envDeployer{
parseAddons: m.parseAddons,
}
got, gotErr := d.AddonsTemplate()
if tc.wantedError != nil {
require.EqualError(t, gotErr, tc.wantedError.Error())
} else {
require.NoError(t, gotErr)
require.Equal(t, got, tc.wanted)
}
})
}
}
func TestEnvDeployer_GenerateCloudFormationTemplate(t *testing.T) {
const (
mockEnvRegion = "us-west-2"
mockAppName = "mockApp"
mockEnvName = "mockEnv"
)
mockError := errors.New("some error")
mockApp := &config.Application{
Name: mockAppName,
}
testCases := map[string]struct {
inManifest manifest.Environment
setUpMocks func(m *envDeployerMocks, ctrl *gomock.Controller)
wantedTemplate string
wantedParams string
wantedError error
}{
"fail to get app resources by region": {
setUpMocks: func(m *envDeployerMocks, _ *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(gomock.Any(), gomock.Any()).
Return(nil, mockError)
},
wantedError: errors.New("get app resources in region us-west-2: some error"),
},
"fail to get existing parameters": {
setUpMocks: func(m *envDeployerMocks, _ *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(gomock.Any(), gomock.Any()).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
return nil, &addon.ErrAddonsNotFound{}
}
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, mockError)
},
wantedError: errors.New("describe environment stack parameters: some error"),
},
"fail to get existing force update ID": {
setUpMocks: func(m *envDeployerMocks, _ *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(gomock.Any(), gomock.Any()).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
return nil, &addon.ErrAddonsNotFound{}
}
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", mockError)
},
wantedError: errors.New("retrieve environment stack force update ID: some error"),
},
"fail to generate stack template": {
setUpMocks: func(m *envDeployerMocks, _ *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(gomock.Any(), gomock.Any()).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
return nil, &addon.ErrAddonsNotFound{}
}
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.stackSerializer.EXPECT().Template().Return("", mockError)
},
wantedError: errors.New("generate stack template: some error"),
},
"fail to generate stack parameters": {
setUpMocks: func(m *envDeployerMocks, _ *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(gomock.Any(), gomock.Any()).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
return nil, &addon.ErrAddonsNotFound{}
}
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.stackSerializer.EXPECT().Template().Return("", nil)
m.stackSerializer.EXPECT().SerializedParameters().Return("", mockError)
},
wantedError: errors.New("generate stack template parameters: some error"),
},
"return an error when addons cannot be parsed due to unknown reasons": {
setUpMocks: func(m *envDeployerMocks, _ *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
return nil, mockError
}
},
wantedError: errors.New("some error"),
},
"return an error if the URL isn't provided and addons template cannot be retrieved": {
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
mockStack := mocks.NewMockstackBuilder(ctrl)
mockStack.EXPECT().Template().Return("", mockError)
return mockStack, nil
}
},
wantedError: errors.New("render addons template: some error"),
},
"successfully return environment template without addons": {
setUpMocks: func(m *envDeployerMocks, _ *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
return nil, &addon.ErrAddonsNotFound{}
}
m.envDeployer.EXPECT().DeployedEnvironmentParameters(mockAppName, mockEnvName).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.stackSerializer.EXPECT().Template().Return("aloo", nil)
m.stackSerializer.EXPECT().SerializedParameters().Return("gobi", nil)
},
wantedTemplate: "aloo",
wantedParams: "gobi",
},
"successfully return environment template with addons": {
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) {
mockStack := mocks.NewMockstackBuilder(ctrl)
mockStack.EXPECT().Template().Return("template", nil)
return mockStack, nil
}
m.envDeployer.EXPECT().DeployedEnvironmentParameters(mockAppName, mockEnvName).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.stackSerializer.EXPECT().Template().Return("aloo", nil)
m.stackSerializer.EXPECT().SerializedParameters().Return("gobi", nil)
},
wantedTemplate: "aloo",
wantedParams: "gobi",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &envDeployerMocks{
appCFN: mocks.NewMockappResourcesGetter(ctrl),
envDeployer: mocks.NewMockenvironmentDeployer(ctrl),
stackSerializer: cfnmocks.NewMockStackConfiguration(ctrl),
}
tc.setUpMocks(m, ctrl)
d := envDeployer{
app: mockApp,
env: &config.Environment{
Name: mockEnvName,
Region: mockEnvRegion,
},
appCFN: m.appCFN,
envDeployer: m.envDeployer,
newStack: func(_ *cfnstack.EnvConfig, _ string, _ []*awscfn.Parameter) (cloudformation.StackConfiguration, error) {
return m.stackSerializer, nil
},
parseAddons: m.parseAddons,
}
actual, err := d.GenerateCloudFormationTemplate(&DeployEnvironmentInput{
Manifest: &tc.inManifest,
})
if tc.wantedError != nil {
require.EqualError(t, err, tc.wantedError.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.wantedTemplate, actual.Template)
require.Equal(t, tc.wantedParams, actual.Parameters)
}
})
}
}
func TestEnvDeployer_DeployEnvironment(t *testing.T) {
const (
mockManagerRoleARN = "mockManagerRoleARN"
mockEnvRegion = "us-west-2"
mockAppName = "mockApp"
mockEnvName = "mockEnv"
)
mockApp := &config.Application{
Name: mockAppName,
}
testCases := map[string]struct {
setUpMocks func(m *envDeployerMocks)
inManifest *manifest.Environment
inDisableRollback bool
wantedError error
}{
"fail to get app resources by region": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).
Return(nil, errors.New("some error"))
},
wantedError: fmt.Errorf("get app resources in region %s: some error", mockEnvRegion),
},
"fail to get prefix list id": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.prefixListGetter.EXPECT().CloudFrontManagedPrefixListID().Return("", errors.New("some error"))
},
inManifest: &manifest.Environment{
EnvironmentConfig: manifest.EnvironmentConfig{
HTTPConfig: manifest.EnvironmentHTTPConfig{
Public: manifest.PublicHTTPConfig{
DeprecatedSG: manifest.DeprecatedALBSecurityGroupsConfig{
DeprecatedIngress: manifest.DeprecatedIngress{
RestrictiveIngress: manifest.RestrictiveIngress{
CDNIngress: aws.Bool(true),
},
},
},
},
},
},
},
wantedError: fmt.Errorf("retrieve CloudFront managed prefix list id: some error"),
},
"prefix list not retrieved when manifest not present": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.prefixListGetter.EXPECT().CloudFrontManagedPrefixListID().Return("mockPrefixListID", nil).Times(0)
m.parseAddons = func() (stackBuilder, error) { return nil, &addon.ErrAddonsNotFound{} }
m.envDeployer.EXPECT().UpdateAndRenderEnvironment(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
},
inManifest: nil,
},
"fail to get existing parameters": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(gomock.Any(), gomock.Any()).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) { return nil, &addon.ErrAddonsNotFound{} }
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, errors.New("some error"))
},
wantedError: errors.New("describe environment stack parameters: some error"),
},
"fail to get existing force update ID": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(gomock.Any(), gomock.Any()).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.parseAddons = func() (stackBuilder, error) { return nil, &addon.ErrAddonsNotFound{} }
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", errors.New("some error"))
},
wantedError: errors.New("retrieve environment stack force update ID: some error"),
},
"fail to deploy environment": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.prefixListGetter.EXPECT().CloudFrontManagedPrefixListID().Return("mockPrefixListID", nil).Times(0)
m.parseAddons = func() (stackBuilder, error) { return nil, &addon.ErrAddonsNotFound{} }
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.envDeployer.EXPECT().UpdateAndRenderEnvironment(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New("some error"))
},
wantedError: errors.New("some error"),
},
"successful environment deployment": {
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.prefixListGetter.EXPECT().CloudFrontManagedPrefixListID().Return("mockPrefixListID", nil).Times(0)
m.parseAddons = func() (stackBuilder, error) { return nil, &addon.ErrAddonsNotFound{} }
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.envDeployer.EXPECT().UpdateAndRenderEnvironment(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
},
},
"successful environment deployment, no rollback": {
inDisableRollback: true,
setUpMocks: func(m *envDeployerMocks) {
m.appCFN.EXPECT().GetAppResourcesByRegion(mockApp, mockEnvRegion).Return(&cfnstack.AppRegionalResources{
S3Bucket: "mockS3Bucket",
}, nil)
m.prefixListGetter.EXPECT().CloudFrontManagedPrefixListID().Return("mockPrefixListID", nil).Times(0)
m.parseAddons = func() (stackBuilder, error) { return nil, &addon.ErrAddonsNotFound{} }
m.envDeployer.EXPECT().DeployedEnvironmentParameters(gomock.Any(), gomock.Any()).Return(nil, nil)
m.envDeployer.EXPECT().ForceUpdateOutputID(gomock.Any(), gomock.Any()).Return("", nil)
m.envDeployer.EXPECT().UpdateAndRenderEnvironment(gomock.Any(), gomock.Any(), gomock.Len(2)).Return(nil)
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &envDeployerMocks{
appCFN: mocks.NewMockappResourcesGetter(ctrl),
envDeployer: mocks.NewMockenvironmentDeployer(ctrl),
prefixListGetter: mocks.NewMockprefixListGetter(ctrl),
stackSerializer: cfnmocks.NewMockStackConfiguration(ctrl),
}
tc.setUpMocks(m)
d := envDeployer{
app: mockApp,
env: &config.Environment{
Name: mockEnvName,
ManagerRoleARN: mockManagerRoleARN,
Region: mockEnvRegion,
},
appCFN: m.appCFN,
envDeployer: m.envDeployer,
prefixListGetter: m.prefixListGetter,
parseAddons: m.parseAddons,
newStack: func(_ *cfnstack.EnvConfig, _ string, _ []*awscfn.Parameter) (cloudformation.StackConfiguration, error) {
return m.stackSerializer, nil
},
}
mockIn := &DeployEnvironmentInput{
RootUserARN: "mockRootUserARN",
CustomResourcesURLs: map[string]string{
"mockResource": "mockURL",
},
Manifest: tc.inManifest,
DisableRollback: tc.inDisableRollback,
}
gotErr := d.DeployEnvironment(mockIn)
if tc.wantedError != nil {
require.EqualError(t, gotErr, tc.wantedError.Error())
} else {
require.NoError(t, gotErr)
}
})
}
}
func TestEnvDeployer_Validate(t *testing.T) {
listenerRuleNoRedirect := elbv2.Rule{
Actions: []*awselb.Action{
{
Type: aws.String(awselb.ActionTypeEnumForward),
},
},
}
listenerRuleWithRedirect := elbv2.Rule{
Actions: []*awselb.Action{
{
Type: aws.String(awselb.ActionTypeEnumRedirect),
},
},
}
mftCDNTerminateTLSAndHTTPCert := &manifest.Environment{
EnvironmentConfig: manifest.EnvironmentConfig{
HTTPConfig: manifest.EnvironmentHTTPConfig{
Public: manifest.PublicHTTPConfig{
Certificates: []string{"mockCertARN"},
},
},
CDNConfig: manifest.EnvironmentCDNConfig{
Config: manifest.AdvancedCDNConfig{
TerminateTLS: aws.Bool(true),
},
},
},
}
mftCDNTerminateTLS := &manifest.Environment{
EnvironmentConfig: manifest.EnvironmentConfig{
CDNConfig: manifest.EnvironmentCDNConfig{
Config: manifest.AdvancedCDNConfig{
Certificate: aws.String("mockCDNCertARN"),
TerminateTLS: aws.Bool(true),
},
},
},
}
tests := map[string]struct {
app *config.Application
mft *manifest.Environment
setUpMocks func(*envDeployerMocks, *gomock.Controller)
expected string
expectedStdErr string
}{
"cdn enabled, domain imported, no public http certs, and validate aliases fails": {
app: &config.Application{
Domain: "example.com",
},
mft: &manifest.Environment{
EnvironmentConfig: manifest.EnvironmentConfig{
CDNConfig: manifest.EnvironmentCDNConfig{
Enabled: aws.Bool(true),
},
},
},
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.envDescriber.EXPECT().ValidateCFServiceDomainAliases().Return(errors.New("some error"))
},
expected: "some error",
},
"cdn enabled, domain imported, no public http certs, and validate aliases succeeds": {
app: &config.Application{
Domain: "example.com",
},
mft: &manifest.Environment{
EnvironmentConfig: manifest.EnvironmentConfig{
CDNConfig: manifest.EnvironmentCDNConfig{
Enabled: aws.Bool(true),
},
},
},
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.envDescriber.EXPECT().ValidateCFServiceDomainAliases().Return(nil)
},
},
"cdn tls termination enabled, fail to get env stack params": {
app: &config.Application{},
mft: mftCDNTerminateTLSAndHTTPCert,
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.envDescriber.EXPECT().Params().Return(nil, errors.New("some error"))
},
expected: "enable TLS termination on CDN: get env params: some error",
},
"cdn tls termination enabled, skip if no services deployed": {
app: &config.Application{},
mft: mftCDNTerminateTLSAndHTTPCert,
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.stackDescribers = map[string]*mocks.MockstackDescriber{
"svc1": mocks.NewMockstackDescriber(ctrl),
}
m.envDescriber.EXPECT().Params().Return(map[string]string{}, nil)
},
},
"cdn tls termination enabled, fail to get service resources": {
app: &config.Application{},
mft: mftCDNTerminateTLSAndHTTPCert,
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.stackDescribers = map[string]*mocks.MockstackDescriber{
"svc1": mocks.NewMockstackDescriber(ctrl),
}
m.envDescriber.EXPECT().Params().Return(map[string]string{
"ALBWorkloads": "svc1",
}, nil)
m.stackDescribers["svc1"].EXPECT().Resources().Return(nil, errors.New("some error"))
},
expected: `enable TLS termination on CDN: verify service "svc1": get stack resources: some error`,
},
"cdn tls termination enabled, fail to check listener rule": {
app: &config.Application{},
mft: mftCDNTerminateTLSAndHTTPCert,
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.stackDescribers = map[string]*mocks.MockstackDescriber{
"svc1": mocks.NewMockstackDescriber(ctrl),
}
m.envDescriber.EXPECT().Params().Return(map[string]string{
"ALBWorkloads": "svc1",
}, nil)
m.stackDescribers["svc1"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc1RuleARN",
},
}, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc1RuleARN").Return(elbv2.Rule{}, errors.New("some error"))
},
expected: `enable TLS termination on CDN: verify service "svc1": describe listener rule "svc1RuleARN": some error`,
},
"cdn tls termination enabled, warn with one service that doesn't redirect, two that do redirect": {
app: &config.Application{},
mft: mftCDNTerminateTLSAndHTTPCert,
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.stackDescribers = map[string]*mocks.MockstackDescriber{
"svc1": mocks.NewMockstackDescriber(ctrl),
"svc2": mocks.NewMockstackDescriber(ctrl),
"svc3": mocks.NewMockstackDescriber(ctrl),
}
m.envDescriber.EXPECT().Params().Return(map[string]string{
"ALBWorkloads": "svc1,svc2,svc3",
}, nil)
m.stackDescribers["svc1"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc1RuleARN",
},
}, nil)
m.stackDescribers["svc2"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc2RuleARN",
},
}, nil)
m.stackDescribers["svc3"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc3RuleARN",
},
}, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc1RuleARN").Return(listenerRuleWithRedirect, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc2RuleARN").Return(listenerRuleNoRedirect, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc3RuleARN").Return(listenerRuleWithRedirect, nil)
},
expectedStdErr: fmt.Sprintf(`Note: Services "svc1" and "svc3" redirect HTTP traffic to HTTPS.
These services will not be reachable through the CDN.
To fix this, set the following field in each manifest:
%s
http:
redirect_to_https: false
%s
and run %scopilot svc deploy%s.
If you'd like to use these services without a CDN, ensure each service's A record is pointed to the ALB.
`,
"```", "```", "`", "`"), // ugh
},
"cdn tls termination enabled, warn with one service that doesn't redirect, two that do redirect, alb ingress restricted to cdn": {
app: &config.Application{},
mft: &manifest.Environment{
EnvironmentConfig: manifest.EnvironmentConfig{
HTTPConfig: manifest.EnvironmentHTTPConfig{
Public: manifest.PublicHTTPConfig{
Certificates: []string{"mockCertARN"},
DeprecatedSG: manifest.DeprecatedALBSecurityGroupsConfig{
DeprecatedIngress: manifest.DeprecatedIngress{
RestrictiveIngress: manifest.RestrictiveIngress{
CDNIngress: aws.Bool(true),
},
},
},
},
},
CDNConfig: manifest.EnvironmentCDNConfig{
Config: manifest.AdvancedCDNConfig{
TerminateTLS: aws.Bool(true),
},
},
},
},
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.stackDescribers = map[string]*mocks.MockstackDescriber{
"svc1": mocks.NewMockstackDescriber(ctrl),
"svc2": mocks.NewMockstackDescriber(ctrl),
"svc3": mocks.NewMockstackDescriber(ctrl),
}
m.envDescriber.EXPECT().Params().Return(map[string]string{
"ALBWorkloads": "svc1,svc2,svc3",
}, nil)
m.stackDescribers["svc1"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc1RuleARN",
},
}, nil)
m.stackDescribers["svc2"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc2RuleARN",
},
}, nil)
m.stackDescribers["svc3"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc3RuleARN",
},
}, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc1RuleARN").Return(listenerRuleWithRedirect, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc2RuleARN").Return(listenerRuleNoRedirect, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc3RuleARN").Return(listenerRuleWithRedirect, nil)
},
expected: "2 services redirect HTTP to HTTPS",
},
"cdn tls termination enabled, success with three services that don't redirect": {
app: &config.Application{},
mft: mftCDNTerminateTLSAndHTTPCert,
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.stackDescribers = map[string]*mocks.MockstackDescriber{
"svc1": mocks.NewMockstackDescriber(ctrl),
"svc2": mocks.NewMockstackDescriber(ctrl),
"svc3": mocks.NewMockstackDescriber(ctrl),
}
m.envDescriber.EXPECT().Params().Return(map[string]string{
"ALBWorkloads": "svc1,svc2,svc3",
}, nil)
m.stackDescribers["svc1"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc1RuleARN",
},
}, nil)
m.stackDescribers["svc2"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc2RuleARN",
},
}, nil)
m.stackDescribers["svc3"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc3RuleARN",
},
}, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc1RuleARN").Return(listenerRuleNoRedirect, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc2RuleARN").Return(listenerRuleNoRedirect, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc3RuleARN").Return(listenerRuleNoRedirect, nil)
},
},
"cdn tls termination enabled, one http only service deployed": {
app: &config.Application{},
mft: mftCDNTerminateTLS,
setUpMocks: func(m *envDeployerMocks, ctrl *gomock.Controller) {
m.stackDescribers = map[string]*mocks.MockstackDescriber{
"svc1": mocks.NewMockstackDescriber(ctrl),
}
m.envDescriber.EXPECT().Params().Return(map[string]string{
"ALBWorkloads": "svc1",
}, nil)
m.stackDescribers["svc1"].EXPECT().Resources().Return([]*stack.Resource{
{
LogicalID: "HTTPListenerRuleWithDomain",
PhysicalID: "svc1RuleARN",
},
}, nil)
m.lbDescriber.EXPECT().DescribeRule(gomock.Any(), "svc1RuleARN").Return(listenerRuleNoRedirect, nil)
},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &envDeployerMocks{
envDescriber: mocks.NewMockenvDescriber(ctrl),
lbDescriber: mocks.NewMocklbDescriber(ctrl),
}
if tc.setUpMocks != nil {
tc.setUpMocks(m, ctrl)
}
d := &envDeployer{
app: tc.app,
env: &config.Environment{
Name: aws.StringValue(tc.mft.Name),
},
envDescriber: m.envDescriber,
lbDescriber: m.lbDescriber,
newServiceStackDescriber: func(svc string) stackDescriber {
return m.stackDescribers[svc]
},
}
buf := &bytes.Buffer{}
log.DiagnosticWriter = buf
err := d.Validate(tc.mft)
if tc.expected != "" {
require.EqualError(t, err, tc.expected)
} else {
require.NoError(t, err)
}
if tc.expectedStdErr != "" {
require.Equal(t, tc.expectedStdErr, buf.String())
}
})
}
}
| 1,064 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"fmt"
"strconv"
"strings"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/dustin/go-humanize/english"
)
type errSvcWithNoALBAliasDeployingToEnvWithImportedCerts struct {
name string
envName string
}
func (e *errSvcWithNoALBAliasDeployingToEnvWithImportedCerts) Error() string {
return fmt.Sprintf(`cannot deploy service %s without "alias" to environment %s with certificate imported`, e.name, e.envName)
}
type errSvcWithALBAliasHostedZoneWithCDNEnabled struct {
envName string
}
func (e *errSvcWithALBAliasHostedZoneWithCDNEnabled) Error() string {
return fmt.Sprintf("cannot specify alias hosted zones when cdn is enabled in environment %q", e.envName)
}
// RecommendActions returns recommended actions to be taken after the error.
// Implements main.actionRecommender interface.
func (e *errSvcWithALBAliasHostedZoneWithCDNEnabled) RecommendActions() string {
msgs := []string{
"If you already have a Load Balanced Web Service deployed, you can switch to CDN by:",
" 1. Updating the A-record value to be the CDN distribution domain name.",
fmt.Sprintf(" 2. Removing the %s setting from the service manifest.", color.HighlightCode(`"http.alias.hosted_zone"`)),
fmt.Sprintf(" 3. Redeploying the service via %s.", color.HighlightCode("copilot svc deploy")),
}
return strings.Join(msgs, "\n")
}
type errEnvHasPublicServicesWithRedirect struct {
services []string
}
func (e *errEnvHasPublicServicesWithRedirect) Error() string {
return fmt.Sprintf("%v %s HTTP to HTTPS",
len(e.services),
english.PluralWord(len(e.services), "service redirects", "services redirect"),
)
}
// RecommendActions returns recommended actions to be taken after the error.
// Implements main.actionRecommender interface.
func (e *errEnvHasPublicServicesWithRedirect) RecommendActions() string {
n := len(e.services)
quoted := make([]string, len(e.services))
for i := range e.services {
quoted[i] = strconv.Quote(e.services[i])
}
return fmt.Sprintf(`%s %s %s HTTP traffic to HTTPS.
%s
To fix this, set the following field in %s manifest:
%s
and run %s.`,
english.PluralWord(n, "Service", "Services"),
english.OxfordWordSeries(quoted, "and"),
english.PluralWord(n, "redirects", "redirect"),
color.Emphasize(english.PluralWord(n, "This service", "These services")+" will not be reachable through the CDN."),
english.PluralWord(n, "its", "each"),
color.HighlightCodeBlock("http:\n redirect_to_https: false"),
color.HighlightCode("copilot svc deploy"),
)
}
func (e *errEnvHasPublicServicesWithRedirect) warning() string {
return fmt.Sprintf(`%s
If you'd like to use %s without a CDN, ensure %s A record is pointed to the ALB.`,
e.RecommendActions(),
english.PluralWord(len(e.services), "this service", "these services"),
english.PluralWord(len(e.services), "its", "each service's"),
)
}
| 87 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"fmt"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
)
type jobDeployer struct {
*workloadDeployer
jobMft *manifest.ScheduledJob
// Overriden in tests.
newStack func() cloudformation.StackConfiguration
}
// IsServiceAvailableInRegion checks if service type exist in the given region.
func (jobDeployer) IsServiceAvailableInRegion(region string) (bool, error) {
return partitions.IsAvailableInRegion(awsecs.EndpointsID, region)
}
// NewJobDeployer is the constructor for jobDeployer.
func NewJobDeployer(in *WorkloadDeployerInput) (*jobDeployer, error) {
in.customResources = scheduledJobCustomResources
wkldDeployer, err := newWorkloadDeployer(in)
if err != nil {
return nil, err
}
jobMft, ok := in.Mft.(*manifest.ScheduledJob)
if !ok {
return nil, fmt.Errorf("manifest is not of type %s", manifestinfo.ScheduledJobType)
}
return &jobDeployer{
workloadDeployer: wkldDeployer,
jobMft: jobMft,
}, nil
}
func scheduledJobCustomResources(fs template.Reader) ([]*customresource.CustomResource, error) {
crs, err := customresource.ScheduledJob(fs)
if err != nil {
return nil, fmt.Errorf("read custom resources for a %q: %w", manifestinfo.ScheduledJobType, err)
}
return crs, nil
}
// UploadArtifacts uploads the deployment artifacts such as the container image, custom resources, addons and env files.
func (d *jobDeployer) UploadArtifacts() (*UploadArtifactsOutput, error) {
return d.uploadArtifacts(d.uploadContainerImages, d.uploadArtifactsToS3, d.uploadCustomResources)
}
// GenerateCloudFormationTemplate generates a CloudFormation template and parameters for a workload.
func (d *jobDeployer) GenerateCloudFormationTemplate(in *GenerateCloudFormationTemplateInput) (
*GenerateCloudFormationTemplateOutput, error) {
output, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
return d.generateCloudFormationTemplate(output.conf)
}
// DeployWorkload deploys a job using CloudFormation.
func (d *jobDeployer) DeployWorkload(in *DeployWorkloadInput) (ActionRecommender, error) {
opts := []awscloudformation.StackOption{
awscloudformation.WithRoleARN(d.env.ExecutionRoleARN),
}
if in.DisableRollback {
opts = append(opts, awscloudformation.WithDisableRollback())
}
stackConfigOutput, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
if err := d.deployer.DeployService(stackConfigOutput.conf, d.resources.S3Bucket, opts...); err != nil {
return nil, fmt.Errorf("deploy job: %w", err)
}
return noopActionRecommender{}, nil
}
type jobStackConfigurationOutput struct {
conf cloudformation.StackConfiguration
}
func (d *jobDeployer) stackConfiguration(in *StackRuntimeConfiguration) (*jobStackConfigurationOutput, error) {
rc, err := d.runtimeConfig(in)
if err != nil {
return nil, err
}
var conf cloudformation.StackConfiguration
switch {
case d.newStack != nil:
conf = d.newStack()
default:
conf, err = stack.NewScheduledJob(stack.ScheduledJobConfig{
App: d.app,
Env: d.env.Name,
Manifest: d.jobMft,
RawManifest: d.rawMft,
ArtifactBucketName: d.resources.S3Bucket,
RuntimeConfig: *rc,
Addons: d.addons,
})
if err != nil {
return nil, fmt.Errorf("create stack configuration: %w", err)
}
}
return &jobStackConfigurationOutput{
conf: cloudformation.WrapWithTemplateOverrider(conf, d.overrider),
}, nil
}
| 124 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"testing"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/stretchr/testify/require"
"gopkg.in/yaml.v3"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/override"
)
func TestJobDeployer_GenerateCloudFormationTemplate(t *testing.T) {
t.Run("ensure resulting CloudFormation template custom resource paths are empty", func(t *testing.T) {
// GIVEN
job := mockJobDeployer()
// WHEN
out, err := job.GenerateCloudFormationTemplate(&GenerateCloudFormationTemplateInput{})
// THEN
require.NoError(t, err)
type lambdaFn struct {
Properties struct {
Code struct {
S3Bucket string `yaml:"S3bucket"`
S3Key string `yaml:"S3Key"`
} `yaml:"Code"`
} `yaml:"Properties"`
}
dat := struct {
Resources struct {
EnvControllerFunction lambdaFn `yaml:"EnvControllerFunction"`
} `yaml:"Resources"`
}{}
require.NoError(t, yaml.Unmarshal([]byte(out.Template), &dat))
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Key)
})
}
func mockJobDeployer(opts ...func(*jobDeployer)) *jobDeployer {
deployer := &jobDeployer{
workloadDeployer: &workloadDeployer{
name: "example",
app: &config.Application{
Name: "demo",
},
env: &config.Environment{
App: "demo",
Name: "test",
},
resources: &stack.AppRegionalResources{},
envConfig: new(manifest.Environment),
endpointGetter: &mockEndpointGetter{endpoint: "demo.test.local"},
envVersionGetter: &mockEnvVersionGetter{version: "v1.0.0"},
overrider: new(override.Noop),
},
jobMft: &manifest.ScheduledJob{
Workload: manifest.Workload{
Name: aws.String("example"),
},
ScheduledJobConfig: manifest.ScheduledJobConfig{
TaskConfig: manifest.TaskConfig{
Count: manifest.Count{
Value: aws.Int(1),
},
},
On: manifest.JobTriggerConfig{
Schedule: aws.String("@daily"),
},
ImageConfig: manifest.ImageWithHealthcheck{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Build: manifest.BuildArgsOrString{BuildString: aws.String("/Dockerfile")},
},
},
},
},
},
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
for _, opt := range opts {
opt(deployer)
}
return deployer
}
| 100 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/aws/acm"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudfront"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/version"
)
var (
ecsALBAliasUsedWithoutDomainFriendlyText = fmt.Sprintf(`To use %s, your application must be:
* Associated with a domain:
%s
* Or, using imported certificates to your environment:
%s
`,
color.HighlightCode("http.alias"),
color.HighlightCode("copilot app init --domain example.com"),
color.HighlightCode("copilot env init --import-cert-arns arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012"))
ecsNLBAliasUsedWithoutDomainFriendlyText = fmt.Sprintf("To use %s, your application must be associated with a domain: %s",
color.HighlightCode("nlb.alias"),
color.HighlightCode("copilot app init --domain example.com"))
)
type publicCIDRBlocksGetter interface {
PublicCIDRBlocks() ([]string, error)
}
type lbWebSvcDeployer struct {
*svcDeployer
appVersionGetter versionGetter
publicCIDRBlocksGetter publicCIDRBlocksGetter
lbMft *manifest.LoadBalancedWebService
// Overriden in tests.
newAliasCertValidator func(optionalRegion *string) aliasCertValidator
newStack func() cloudformation.StackConfiguration
}
// NewLBWSDeployer is the constructor for lbWebSvcDeployer.
func NewLBWSDeployer(in *WorkloadDeployerInput) (*lbWebSvcDeployer, error) {
in.customResources = lbwsCustomResources
svcDeployer, err := newSvcDeployer(in)
if err != nil {
return nil, err
}
versionGetter, err := describe.NewAppDescriber(in.App.Name)
if err != nil {
return nil, fmt.Errorf("new app describer for application %s: %w", in.App.Name, err)
}
deployStore, err := deploy.NewStore(in.SessionProvider, svcDeployer.store)
if err != nil {
return nil, fmt.Errorf("new deploy store: %w", err)
}
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: in.App.Name,
Env: in.Env.Name,
ConfigStore: svcDeployer.store,
DeployStore: deployStore,
})
if err != nil {
return nil, fmt.Errorf("create describer for environment %s in application %s: %w", in.Env.Name, in.App.Name, err)
}
lbMft, ok := in.Mft.(*manifest.LoadBalancedWebService)
if !ok {
return nil, fmt.Errorf("manifest is not of type %s", manifestinfo.LoadBalancedWebServiceType)
}
return &lbWebSvcDeployer{
svcDeployer: svcDeployer,
appVersionGetter: versionGetter,
publicCIDRBlocksGetter: envDescriber,
lbMft: lbMft,
newAliasCertValidator: func(optionalRegion *string) aliasCertValidator {
sess := svcDeployer.envSess.Copy(&aws.Config{
Region: optionalRegion,
})
return acm.New(sess)
},
}, nil
}
func lbwsCustomResources(fs template.Reader) ([]*customresource.CustomResource, error) {
crs, err := customresource.LBWS(fs)
if err != nil {
return nil, fmt.Errorf("read custom resources for a %q: %w", manifestinfo.LoadBalancedWebServiceType, err)
}
return crs, nil
}
// IsServiceAvailableInRegion checks if service type exist in the given region.
func (lbWebSvcDeployer) IsServiceAvailableInRegion(region string) (bool, error) {
return partitions.IsAvailableInRegion(awsecs.EndpointsID, region)
}
// UploadArtifacts uploads the deployment artifacts such as the container image, custom resources, addons and env files.
func (d *lbWebSvcDeployer) UploadArtifacts() (*UploadArtifactsOutput, error) {
return d.uploadArtifacts(d.uploadContainerImages, d.uploadArtifactsToS3, d.uploadCustomResources)
}
// GenerateCloudFormationTemplate generates a CloudFormation template and parameters for a workload.
func (d *lbWebSvcDeployer) GenerateCloudFormationTemplate(in *GenerateCloudFormationTemplateInput) (
*GenerateCloudFormationTemplateOutput, error) {
output, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
return d.generateCloudFormationTemplate(output.conf)
}
// DeployWorkload deploys a load balanced web service using CloudFormation.
func (d *lbWebSvcDeployer) DeployWorkload(in *DeployWorkloadInput) (ActionRecommender, error) {
stackConfigOutput, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
if err := d.deploy(in.Options, *stackConfigOutput); err != nil {
return nil, err
}
return noopActionRecommender{}, nil
}
func (d *lbWebSvcDeployer) stackConfiguration(in *StackRuntimeConfiguration) (*svcStackConfigurationOutput, error) {
rc, err := d.runtimeConfig(in)
if err != nil {
return nil, err
}
if err := d.validateALBRuntime(); err != nil {
return nil, err
}
if err := d.validateNLBRuntime(); err != nil {
return nil, err
}
var opts []stack.LoadBalancedWebServiceOption
if !d.lbMft.NLBConfig.IsEmpty() {
cidrBlocks, err := d.publicCIDRBlocksGetter.PublicCIDRBlocks()
if err != nil {
return nil, fmt.Errorf("get public CIDR blocks information from the VPC of environment %s: %w", d.env.Name, err)
}
opts = append(opts, stack.WithNLB(cidrBlocks))
}
var conf cloudformation.StackConfiguration
switch {
case d.newStack != nil:
conf = d.newStack()
default:
conf, err = stack.NewLoadBalancedWebService(stack.LoadBalancedWebServiceConfig{
App: d.app,
EnvManifest: d.envConfig,
Manifest: d.lbMft,
RawManifest: d.rawMft,
ArtifactBucketName: d.resources.S3Bucket,
RuntimeConfig: *rc,
RootUserARN: in.RootUserARN,
Addons: d.addons,
}, opts...)
if err != nil {
return nil, fmt.Errorf("create stack configuration: %w", err)
}
}
return &svcStackConfigurationOutput{
conf: cloudformation.WrapWithTemplateOverrider(conf, d.overrider),
svcUpdater: d.newSvcUpdater(func(s *session.Session) serviceForceUpdater {
return ecs.New(s)
}),
}, nil
}
func (d *lbWebSvcDeployer) validateALBRuntime() error {
if err := d.validateRuntimeRoutingRule(d.lbMft.HTTPOrBool.Main); err != nil {
return fmt.Errorf(`validate ALB runtime configuration for "http": %w`, err)
}
for idx, rule := range d.lbMft.HTTPOrBool.AdditionalRoutingRules {
if err := d.validateRuntimeRoutingRule(rule); err != nil {
return fmt.Errorf(`validate ALB runtime configuration for "http.additional_rule[%d]": %w`, idx, err)
}
}
return nil
}
func (d *lbWebSvcDeployer) validateRuntimeRoutingRule(rule manifest.RoutingRule) error {
hasALBCerts := len(d.envConfig.HTTPConfig.Public.Certificates) != 0
hasCDNCerts := d.envConfig.CDNConfig.Config.Certificate != nil
hasImportedCerts := hasALBCerts || hasCDNCerts
if rule.RedirectToHTTPS != nil && d.app.Domain == "" && !hasImportedCerts {
return fmt.Errorf("cannot configure http to https redirect without having a domain associated with the app %q or importing any certificates in env %q", d.app.Name, d.env.Name)
}
if rule.Alias.IsEmpty() {
if hasImportedCerts {
return &errSvcWithNoALBAliasDeployingToEnvWithImportedCerts{
name: d.name,
envName: d.env.Name,
}
}
return nil
}
importedHostedZones := rule.Alias.HostedZones()
if len(importedHostedZones) != 0 {
if !hasImportedCerts {
return fmt.Errorf("cannot specify alias hosted zones %v when no certificates are imported in environment %q", importedHostedZones, d.env.Name)
}
if d.envConfig.CDNEnabled() {
return &errSvcWithALBAliasHostedZoneWithCDNEnabled{
envName: d.env.Name,
}
}
}
if hasImportedCerts {
aliases, err := rule.Alias.ToStringSlice()
if err != nil {
return fmt.Errorf("convert aliases to string slice: %w", err)
}
if hasALBCerts {
albCertValidator := d.newAliasCertValidator(nil)
if err := albCertValidator.ValidateCertAliases(aliases, d.envConfig.HTTPConfig.Public.Certificates); err != nil {
return fmt.Errorf("validate aliases against the imported public ALB certificate for env %s: %w", d.env.Name, err)
}
}
if hasCDNCerts {
cfCertValidator := d.newAliasCertValidator(aws.String(cloudfront.CertRegion))
if err := cfCertValidator.ValidateCertAliases(aliases, []string{*d.envConfig.CDNConfig.Config.Certificate}); err != nil {
return fmt.Errorf("validate aliases against the imported CDN certificate for env %s: %w", d.env.Name, err)
}
}
return nil
}
if d.app.Domain != "" {
err := validateMinAppVersion(d.app.Name, aws.StringValue(d.lbMft.Name), d.appVersionGetter, version.AppTemplateMinAlias)
if err != nil {
return fmt.Errorf("alias not supported: %w", err)
}
if err := validateLBWSAlias(rule.Alias, d.app, d.env.Name); err != nil {
return fmt.Errorf(`validate 'alias': %w`, err)
}
return nil
}
log.Errorf(ecsALBAliasUsedWithoutDomainFriendlyText)
return fmt.Errorf(`cannot specify "alias" when application is not associated with a domain and env %s doesn't import one or more certificates`, d.env.Name)
}
func (d *lbWebSvcDeployer) validateNLBRuntime() error {
if d.lbMft.NLBConfig.Aliases.IsEmpty() {
return nil
}
hasImportedCerts := len(d.envConfig.HTTPConfig.Public.Certificates) != 0
if hasImportedCerts {
return fmt.Errorf("cannot specify nlb.alias when env %s imports one or more certificates", d.env.Name)
}
if d.app.Domain == "" {
log.Errorf(ecsNLBAliasUsedWithoutDomainFriendlyText)
return fmt.Errorf("cannot specify nlb.alias when application is not associated with a domain")
}
err := validateMinAppVersion(d.app.Name, aws.StringValue(d.lbMft.Name), d.appVersionGetter, version.AppTemplateMinAlias)
if err != nil {
return fmt.Errorf("alias not supported: %w", err)
}
if err := validateLBWSAlias(d.lbMft.NLBConfig.Aliases, d.app, d.env.Name); err != nil {
return fmt.Errorf(`validate 'nlb.alias': %w`, err)
}
return nil
}
func validateLBWSAlias(alias manifest.Alias, app *config.Application, envName string) error {
if alias.IsEmpty() {
return nil
}
aliases, err := alias.ToStringSlice()
if err != nil {
return err
}
return validateAliases(app, envName, aliases...)
}
| 300 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"testing"
"time"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/template"
"gopkg.in/yaml.v3"
"github.com/stretchr/testify/require"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/override"
)
func TestLbWebSvcDeployer_GenerateCloudFormationTemplate(t *testing.T) {
t.Run("ensure resulting CloudFormation template custom resource paths are empty", func(t *testing.T) {
// GIVEN
lbws := mockLoadBalancedWebServiceDeployer()
// WHEN
out, err := lbws.GenerateCloudFormationTemplate(&GenerateCloudFormationTemplateInput{})
// THEN
require.NoError(t, err)
type lambdaFn struct {
Properties struct {
Code struct {
S3Bucket string `yaml:"S3bucket"`
S3Key string `yaml:"S3Key"`
} `yaml:"Code"`
} `yaml:"Properties"`
}
dat := struct {
Resources struct {
EnvControllerFunction lambdaFn `yaml:"EnvControllerFunction"`
RulePriorityFunction lambdaFn `yaml:"RulePriorityFunction"`
} `yaml:"Resources"`
}{}
require.NoError(t, yaml.Unmarshal([]byte(out.Template), &dat))
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Key)
require.Empty(t, dat.Resources.RulePriorityFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.RulePriorityFunction.Properties.Code.S3Key)
})
}
func mockLoadBalancedWebServiceDeployer(opts ...func(deployer *lbWebSvcDeployer)) *lbWebSvcDeployer {
deployer := &lbWebSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: "example",
app: &config.Application{
Name: "demo",
},
env: &config.Environment{
App: "demo",
Name: "test",
},
resources: &stack.AppRegionalResources{},
envConfig: new(manifest.Environment),
endpointGetter: &mockEndpointGetter{endpoint: "demo.test.local"},
envVersionGetter: &mockEnvVersionGetter{version: "v1.0.0"},
overrider: new(override.Noop),
templateFS: template.New(),
customResources: lbwsCustomResources,
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return nil
},
now: func() time.Time {
return time.Date(2020, 11, 23, 0, 0, 0, 0, time.UTC)
},
},
lbMft: &manifest.LoadBalancedWebService{
Workload: manifest.Workload{
Name: aws.String("example"),
},
LoadBalancedWebServiceConfig: manifest.LoadBalancedWebServiceConfig{
TaskConfig: manifest.TaskConfig{
Count: manifest.Count{
Value: aws.Int(1),
},
},
ImageConfig: manifest.ImageWithPortAndHealthcheck{
ImageWithPort: manifest.ImageWithPort{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Build: manifest.BuildArgsOrString{BuildString: aws.String("/Dockerfile")},
},
},
Port: aws.Uint16(80),
},
},
HTTPOrBool: manifest.HTTPOrBool{
HTTP: manifest.HTTP{
Main: manifest.RoutingRule{
Path: aws.String("/"),
},
},
},
},
},
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
for _, opt := range opts {
opt(deployer)
}
return deployer
}
| 127 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"errors"
"fmt"
"github.com/aws/copilot-cli/internal/pkg/override"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/spf13/afero"
)
// An Overrider transforms the content in body to out.
type Overrider interface {
Override(body []byte) (out []byte, err error)
}
// UserAgentAdder is the interface that adds values to the User-Agent HTTP request header.
type UserAgentAdder interface {
UserAgentExtras(extras ...string)
}
// NewOverrider looks up if a CDK or YAMLPatch Overrider exists at pathsToOverriderDir and initializes the respective Overrider.
// If the directory is empty, then returns a noop Overrider.
func NewOverrider(pathToOverridesDir, app, env string, fs afero.Fs, sess UserAgentAdder) (Overrider, error) {
info, err := override.Lookup(pathToOverridesDir, fs)
if err != nil {
var errNotExist *override.ErrNotExist
if errors.As(err, &errNotExist) {
return new(override.Noop), nil
}
return nil, fmt.Errorf("look up overrider at %q: %w", pathToOverridesDir, err)
}
switch {
case info.IsCDK():
sess.UserAgentExtras("override cdk")
return override.WithCDK(info.Path(), override.CDKOpts{
// Write out-of-band info from sub-commands to stderr as users expect stdout to only
// contain the final override output.
ExecWriter: log.DiagnosticWriter,
FS: fs,
EnvVars: map[string]string{
"COPILOT_APPLICATION_NAME": app,
"COPILOT_ENVIRONMENT_NAME": env,
},
}), nil
case info.IsYAMLPatch():
sess.UserAgentExtras("override yamlpatch")
return override.WithPatch(info.Path(), override.PatchOpts{
FS: fs,
}), nil
default:
return new(override.Noop), nil
}
}
| 58 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"path/filepath"
"testing"
"github.com/aws/copilot-cli/internal/pkg/override"
"github.com/stretchr/testify/require"
"github.com/spf13/afero"
)
type mockSessProvider struct {
UserAgent []string
}
func (m *mockSessProvider) UserAgentExtras(extras ...string) {
m.UserAgent = append(m.UserAgent, extras...)
}
func TestNewOverrider(t *testing.T) {
t.Run("should return override.Noop when the directory does not exist", func(t *testing.T) {
// GIVEN
fs := afero.NewMemMapFs()
// WHEN
ovrdr, err := NewOverrider("overrides", "demo", "test", fs, new(mockSessProvider))
// THEN
require.NoError(t, err)
_, ok := ovrdr.(*override.Noop)
require.True(t, ok)
})
t.Run("should return a wrapped error when the directory is not empty but cannot be identified", func(t *testing.T) {
// GIVEN
fs := afero.NewMemMapFs()
_ = fs.MkdirAll("overrides", 0755)
// WHEN
_, err := NewOverrider("overrides", "demo", "test", fs, new(mockSessProvider))
// THEN
require.ErrorContains(t, err, `look up overrider at "overrides":`)
})
t.Run("should initialize a CDK overrider", func(t *testing.T) {
// GIVEN
fs := afero.NewMemMapFs()
_ = fs.MkdirAll("overrides", 0755)
_ = afero.WriteFile(fs, filepath.Join("overrides", "cdk.json"), []byte(""), 0755)
_ = afero.WriteFile(fs, filepath.Join("overrides", "package.json"), []byte(""), 0755)
_ = afero.WriteFile(fs, filepath.Join("overrides", "stack.ts"), []byte(""), 0755)
sess := new(mockSessProvider)
// WHEN
ovrdr, err := NewOverrider("overrides", "demo", "test", fs, sess)
// THEN
require.NoError(t, err)
_, ok := ovrdr.(*override.CDK)
require.True(t, ok)
require.Contains(t, sess.UserAgent, "override cdk")
})
}
| 67 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"errors"
"fmt"
"regexp"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/apprunner"
awsapprunner "github.com/aws/copilot-cli/internal/pkg/aws/apprunner"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/version"
)
var rdwsAliasUsedWithoutDomainFriendlyText = fmt.Sprintf("To use %s, your application must be associated with a domain: %s.\n",
color.HighlightCode("http.alias"),
color.HighlightCode("copilot app init --domain example.com"))
type rdwsDeployer struct {
*svcDeployer
rdwsMft *manifest.RequestDrivenWebService
// Overriden in tests.
customResourceS3Client uploader
appVersionGetter versionGetter
newStack func() cloudformation.StackConfiguration
}
// NewRDWSDeployer is the constructor for RDWSDeployer.
func NewRDWSDeployer(in *WorkloadDeployerInput) (*rdwsDeployer, error) {
in.customResources = rdwsCustomResources
svcDeployer, err := newSvcDeployer(in)
if err != nil {
return nil, err
}
versionGetter, err := describe.NewAppDescriber(in.App.Name)
if err != nil {
return nil, fmt.Errorf("new app describer for application %s: %w", in.App.Name, err)
}
rdwsMft, ok := in.Mft.(*manifest.RequestDrivenWebService)
if !ok {
return nil, fmt.Errorf("manifest is not of type %s", manifestinfo.RequestDrivenWebServiceType)
}
return &rdwsDeployer{
svcDeployer: svcDeployer,
customResourceS3Client: s3.New(svcDeployer.defaultSessWithEnvRegion),
appVersionGetter: versionGetter,
rdwsMft: rdwsMft,
}, nil
}
func rdwsCustomResources(fs template.Reader) ([]*customresource.CustomResource, error) {
crs, err := customresource.RDWS(fs)
if err != nil {
return nil, fmt.Errorf("read custom resources for a %q: %w", manifestinfo.RequestDrivenWebServiceType, err)
}
return crs, nil
}
// IsServiceAvailableInRegion checks if service type exist in the given region.
func (rdwsDeployer) IsServiceAvailableInRegion(region string) (bool, error) {
return partitions.IsAvailableInRegion(awsapprunner.EndpointsID, region)
}
// UploadArtifacts uploads the deployment artifacts such as the container image, custom resources, addons and env files.
func (d *rdwsDeployer) UploadArtifacts() (*UploadArtifactsOutput, error) {
return d.uploadArtifacts(d.uploadContainerImages, d.uploadArtifactsToS3, d.uploadCustomResources)
}
type rdwsDeployOutput struct {
rdwsAlias string
}
// RecommendedActions returns the recommended actions after deployment.
func (d *rdwsDeployOutput) RecommendedActions() []string {
if d.rdwsAlias == "" {
return nil
}
return []string{fmt.Sprintf(`The validation process for https://%s can take more than 15 minutes.
Please visit %s to check the validation status.`, d.rdwsAlias, color.Emphasize("https://console.aws.amazon.com/apprunner/home"))}
}
// GenerateCloudFormationTemplate generates a CloudFormation template and parameters for a workload.
func (d *rdwsDeployer) GenerateCloudFormationTemplate(in *GenerateCloudFormationTemplateInput) (
*GenerateCloudFormationTemplateOutput, error) {
output, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
return d.generateCloudFormationTemplate(output.conf)
}
// DeployWorkload deploys a request driven web service using CloudFormation.
func (d *rdwsDeployer) DeployWorkload(in *DeployWorkloadInput) (ActionRecommender, error) {
stackConfigOutput, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
if err := d.deploy(in.Options, stackConfigOutput.svcStackConfigurationOutput); err != nil {
return nil, err
}
return &rdwsDeployOutput{
rdwsAlias: stackConfigOutput.rdSvcAlias,
}, nil
}
type rdwsStackConfigurationOutput struct {
svcStackConfigurationOutput
rdSvcAlias string
}
func (d *rdwsDeployer) stackConfiguration(in *StackRuntimeConfiguration) (*rdwsStackConfigurationOutput, error) {
rc, err := d.runtimeConfig(in)
if err != nil {
return nil, err
}
if d.app.Domain == "" && d.rdwsMft.Alias != nil {
log.Errorf(rdwsAliasUsedWithoutDomainFriendlyText)
return nil, errors.New("alias specified when application is not associated with a domain")
}
var conf cloudformation.StackConfiguration
switch {
case d.newStack != nil:
conf = d.newStack()
default:
conf, err = stack.NewRequestDrivenWebService(stack.RequestDrivenWebServiceConfig{
App: deploy.AppInformation{
Name: d.app.Name,
Domain: d.app.Domain,
PermissionsBoundary: d.app.PermissionsBoundary,
AccountPrincipalARN: in.RootUserARN,
},
Env: d.env.Name,
Manifest: d.rdwsMft,
RawManifest: d.rawMft,
ArtifactBucketName: d.resources.S3Bucket,
RuntimeConfig: *rc,
Addons: d.addons,
})
if err != nil {
return nil, fmt.Errorf("create stack configuration: %w", err)
}
}
if d.rdwsMft.Alias == nil {
return &rdwsStackConfigurationOutput{
svcStackConfigurationOutput: svcStackConfigurationOutput{
conf: cloudformation.WrapWithTemplateOverrider(conf, d.overrider),
svcUpdater: d.newSvcUpdater(func(s *session.Session) serviceForceUpdater {
return apprunner.New(s)
}),
},
}, nil
}
if err = validateRDSvcAliasAndAppVersion(d.name,
aws.StringValue(d.rdwsMft.Alias), d.env.Name, d.app, d.appVersionGetter); err != nil {
return nil, err
}
return &rdwsStackConfigurationOutput{
svcStackConfigurationOutput: svcStackConfigurationOutput{
conf: cloudformation.WrapWithTemplateOverrider(conf, d.overrider),
svcUpdater: d.newSvcUpdater(func(s *session.Session) serviceForceUpdater {
return apprunner.New(s)
}),
},
rdSvcAlias: aws.StringValue(d.rdwsMft.Alias),
}, nil
}
func validateRDSvcAliasAndAppVersion(svcName, alias, envName string, app *config.Application, appVersionGetter versionGetter) error {
if alias == "" {
return nil
}
if err := validateMinAppVersion(app.Name, svcName, appVersionGetter, version.AppTemplateMinAlias); err != nil {
return fmt.Errorf("alias not supported: %w", err)
}
// Alias should be within root hosted zone.
aliasInvalidLog := fmt.Sprintf(`%s of %s field should match the pattern <subdomain>.%s
Where <subdomain> cannot be the application name.
`, color.HighlightUserInput(alias), color.HighlightCode("http.alias"), app.Domain)
if err := checkUnsupportedRDSvcAlias(alias, envName, app); err != nil {
log.Errorf(aliasInvalidLog)
return err
}
// Example: subdomain.domain
regRootHostedZone, err := regexp.Compile(fmt.Sprintf(`^([^\.]+\.)%s`, app.Domain))
if err != nil {
return err
}
if regRootHostedZone.MatchString(alias) {
return nil
}
log.Errorf(aliasInvalidLog)
return fmt.Errorf("alias is not supported in hosted zones that are not managed by Copilot")
}
func checkUnsupportedRDSvcAlias(alias, envName string, app *config.Application) error {
var regEnvHostedZone, regAppHostedZone *regexp.Regexp
var err error
// Example: subdomain.env.app.domain, env.app.domain
if regEnvHostedZone, err = regexp.Compile(fmt.Sprintf(`^([^\.]+\.)?%s.%s.%s`, envName, app.Name, app.Domain)); err != nil {
return err
}
// Example: subdomain.app.domain, app.domain
if regAppHostedZone, err = regexp.Compile(fmt.Sprintf(`^([^\.]+\.)?%s.%s`, app.Name, app.Domain)); err != nil {
return err
}
if regEnvHostedZone.MatchString(alias) {
return fmt.Errorf("%s is an environment-level alias, which is not supported yet", alias)
}
if regAppHostedZone.MatchString(alias) {
return fmt.Errorf("%s is an application-level alias, which is not supported yet", alias)
}
if alias == app.Domain {
return fmt.Errorf("%s is a root domain alias, which is not supported yet", alias)
}
return nil
}
| 246 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"errors"
"fmt"
"testing"
"time"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/override"
"gopkg.in/yaml.v3"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestRdwsDeployer_GenerateCloudFormationTemplate(t *testing.T) {
t.Run("ensure resulting CloudFormation template custom resource paths are empty", func(t *testing.T) {
// GIVEN
rdws := mockRDWSDeployer()
// WHEN
out, err := rdws.GenerateCloudFormationTemplate(&GenerateCloudFormationTemplateInput{})
// THEN
require.NoError(t, err)
type lambdaFn struct {
Properties struct {
Code struct {
S3Bucket string `yaml:"S3bucket"`
S3Key string `yaml:"S3Key"`
} `yaml:"Code"`
} `yaml:"Properties"`
}
dat := struct {
Resources struct {
EnvControllerFunction lambdaFn `yaml:"EnvControllerFunction"`
} `yaml:"Resources"`
}{}
require.NoError(t, yaml.Unmarshal([]byte(out.Template), &dat))
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Key)
})
}
type deployRDSvcMocks struct {
mockAppVersionGetter *mocks.MockversionGetter
mockEnvVersionGetter *mocks.MockversionGetter
mockEndpointGetter *mocks.MockendpointGetter
}
func TestSvcDeployOpts_rdWebServiceStackConfiguration(t *testing.T) {
const (
mockAppName = "mockApp"
mockEnvName = "mockEnv"
mockName = "mockWkld"
mockAddonsURL = "mockAddonsURL"
mockBucket = "mockBucket"
)
mockResources := &stack.AppRegionalResources{
S3Bucket: mockBucket,
}
tests := map[string]struct {
inAlias string
inApp *config.Application
inEnvironment *config.Environment
mock func(m *deployRDSvcMocks)
wantAlias string
wantErr error
}{
"alias used while app is not associated with a domain": {
inAlias: "v1.mockDomain",
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployRDSvcMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: errors.New("alias specified when application is not associated with a domain"),
},
"invalid alias with unknown domain": {
inAlias: "v1.someRandomDomain",
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployRDSvcMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("alias is not supported in hosted zones that are not managed by Copilot"),
},
"invalid environment level alias": {
inAlias: "mockEnv.mockApp.mockDomain",
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployRDSvcMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("mockEnv.mockApp.mockDomain is an environment-level alias, which is not supported yet"),
},
"invalid application level alias": {
inAlias: "someSub.mockApp.mockDomain",
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployRDSvcMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("someSub.mockApp.mockDomain is an application-level alias, which is not supported yet"),
},
"invalid root level alias": {
inAlias: "mockDomain",
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployRDSvcMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("mockDomain is a root domain alias, which is not supported yet"),
},
"success": {
inAlias: "v1.mockDomain",
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployRDSvcMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantAlias: "v1.mockDomain",
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployRDSvcMocks{
mockAppVersionGetter: mocks.NewMockversionGetter(ctrl),
mockEnvVersionGetter: mocks.NewMockversionGetter(ctrl),
mockEndpointGetter: mocks.NewMockendpointGetter(ctrl),
}
tc.mock(m)
deployer := rdwsDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: mockName,
app: tc.inApp,
env: tc.inEnvironment,
resources: mockResources,
endpointGetter: m.mockEndpointGetter,
envVersionGetter: m.mockEnvVersionGetter,
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return nil
},
},
appVersionGetter: m.mockAppVersionGetter,
rdwsMft: &manifest.RequestDrivenWebService{
Workload: manifest.Workload{
Name: aws.String(mockName),
},
RequestDrivenWebServiceConfig: manifest.RequestDrivenWebServiceConfig{
ImageConfig: manifest.ImageWithPort{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Build: manifest.BuildArgsOrString{BuildString: aws.String("/Dockerfile")},
},
},
Port: aws.Uint16(80),
},
RequestDrivenWebServiceHttpConfig: manifest.RequestDrivenWebServiceHttpConfig{
Alias: aws.String(tc.inAlias),
},
},
},
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
got, gotErr := deployer.stackConfiguration(&StackRuntimeConfiguration{
AddonsURL: mockAddonsURL,
})
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
} else {
require.NoError(t, gotErr)
require.Equal(t, tc.wantAlias, got.rdSvcAlias)
}
})
}
}
func mockRDWSDeployer(opts ...func(*rdwsDeployer)) *rdwsDeployer {
deployer := &rdwsDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: "example",
app: &config.Application{
Name: "demo",
},
env: &config.Environment{
App: "demo",
Name: "test",
},
resources: &stack.AppRegionalResources{},
envConfig: new(manifest.Environment),
endpointGetter: &mockEndpointGetter{endpoint: "demo.test.local"},
envVersionGetter: &mockEnvVersionGetter{version: "v1.0.0"},
overrider: new(override.Noop),
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return nil
},
now: func() time.Time {
return time.Date(2020, 11, 23, 0, 0, 0, 0, time.UTC)
},
},
rdwsMft: &manifest.RequestDrivenWebService{
Workload: manifest.Workload{
Name: aws.String("example"),
},
RequestDrivenWebServiceConfig: manifest.RequestDrivenWebServiceConfig{
ImageConfig: manifest.ImageWithPort{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Location: aws.String("111111111111.dkr.ecr.us-west-2.amazonaws.com/nginx:latest"),
},
},
Port: aws.Uint16(80),
},
InstanceConfig: manifest.AppRunnerInstanceConfig{
CPU: aws.Int(1024),
Memory: aws.Int(2048),
},
},
},
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
for _, opt := range opts {
opt(deployer)
}
return deployer
}
| 308 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"fmt"
"io"
"path/filepath"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/asset"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
)
const artifactBucketAssetsDir = "local-assets"
type fileUploader interface {
UploadFiles(files []manifest.FileUpload) (string, error)
}
type staticSiteDeployer struct {
*svcDeployer
appVersionGetter versionGetter
staticSiteMft *manifest.StaticSite
fs afero.Fs
uploader fileUploader
newStack func(*stack.StaticSiteConfig) (*stack.StaticSite, error)
// cached.
wsRoot string
}
// NewStaticSiteDeployer is the constructor for staticSiteDeployer.
func NewStaticSiteDeployer(in *WorkloadDeployerInput) (*staticSiteDeployer, error) {
in.customResources = staticSiteCustomResources
svcDeployer, err := newSvcDeployer(in)
if err != nil {
return nil, err
}
versionGetter, err := describe.NewAppDescriber(in.App.Name)
if err != nil {
return nil, fmt.Errorf("new app describer for application %s: %w", in.App.Name, err)
}
mft, ok := in.Mft.(*manifest.StaticSite)
if !ok {
return nil, fmt.Errorf("manifest is not of type %s", manifestinfo.StaticSiteType)
}
ws, err := workspace.Use(svcDeployer.fs)
if err != nil {
return nil, err
}
return &staticSiteDeployer{
svcDeployer: svcDeployer,
appVersionGetter: versionGetter,
staticSiteMft: mft,
fs: svcDeployer.fs,
uploader: &asset.ArtifactBucketUploader{
FS: svcDeployer.fs,
AssetDir: artifactBucketAssetsDir,
AssetMappingFileDir: fmt.Sprintf("%s/environments/%s/workloads/%s/mapping", artifactBucketAssetsDir, svcDeployer.env.Name, svcDeployer.name),
Upload: func(path string, data io.Reader) error {
_, err := svcDeployer.s3Client.Upload(svcDeployer.resources.S3Bucket, path, data)
return err
},
},
wsRoot: ws.ProjectRoot(),
newStack: stack.NewStaticSite,
}, nil
}
func staticSiteCustomResources(fs template.Reader) ([]*customresource.CustomResource, error) {
crs, err := customresource.StaticSite(fs)
if err != nil {
return nil, fmt.Errorf("read custom resources for a %q: %w", manifestinfo.StaticSiteType, err)
}
return crs, nil
}
// IsServiceAvailableInRegion checks if service type exist in the given region.
func (*staticSiteDeployer) IsServiceAvailableInRegion(region string) (bool, error) {
return partitions.IsAvailableInRegion(s3.EndpointsID, region)
}
// GenerateCloudFormationTemplate generates a CloudFormation template and parameters for a workload.
func (d *staticSiteDeployer) GenerateCloudFormationTemplate(in *GenerateCloudFormationTemplateInput) (
*GenerateCloudFormationTemplateOutput, error) {
conf, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
return d.generateCloudFormationTemplate(conf)
}
// DeployWorkload deploys a static site service using CloudFormation.
func (d *staticSiteDeployer) DeployWorkload(in *DeployWorkloadInput) (ActionRecommender, error) {
conf, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
if err := d.deploy(in.Options, svcStackConfigurationOutput{conf: conf}); err != nil {
return nil, err
}
return noopActionRecommender{}, nil
}
func (d *staticSiteDeployer) deploy(deployOptions Options, stackConfigOutput svcStackConfigurationOutput) error {
opts := []awscloudformation.StackOption{
awscloudformation.WithRoleARN(d.env.ExecutionRoleARN),
}
if deployOptions.DisableRollback {
opts = append(opts, awscloudformation.WithDisableRollback())
}
if err := d.deployer.DeployService(stackConfigOutput.conf, d.resources.S3Bucket, opts...); err != nil {
return fmt.Errorf("deploy service: %w", err)
}
return nil
}
// UploadArtifacts uploads static assets to the app stackset bucket.
func (d *staticSiteDeployer) UploadArtifacts() (*UploadArtifactsOutput, error) {
return d.uploadArtifacts(d.uploadStaticFiles, d.uploadArtifactsToS3, d.uploadCustomResources)
}
func (d *staticSiteDeployer) uploadStaticFiles(out *UploadArtifactsOutput) error {
if err := d.validateSources(); err != nil {
return err
}
fullPathSources, err := d.convertSources()
if err != nil {
return err
}
path, err := d.uploader.UploadFiles(fullPathSources)
if err != nil {
return fmt.Errorf("upload static files: %w", err)
}
out.StaticSiteAssetMappingLocation = s3.Location(d.resources.S3Bucket, path)
return nil
}
func (d *staticSiteDeployer) stackConfiguration(in *StackRuntimeConfiguration) (cloudformation.StackConfiguration, error) {
rc, err := d.runtimeConfig(in)
if err != nil {
return nil, err
}
if err := d.validateAlias(); err != nil {
return nil, err
}
if err := validateMinAppVersion(d.app.Name, d.name, d.appVersionGetter, version.AppTemplateMinStaticSite); err != nil {
return nil, fmt.Errorf("static sites not supported: %w", err)
}
conf, err := d.newStack(&stack.StaticSiteConfig{
App: d.app,
EnvManifest: d.envConfig,
Manifest: d.staticSiteMft,
RawManifest: d.rawMft,
ArtifactBucketName: d.resources.S3Bucket,
RuntimeConfig: *rc,
RootUserARN: in.RootUserARN,
Addons: d.addons,
AssetMappingURL: in.StaticSiteAssetMappingURL,
})
if err != nil {
return nil, fmt.Errorf("create stack configuration: %w", err)
}
return cloudformation.WrapWithTemplateOverrider(conf, d.overrider), nil
}
func (d *staticSiteDeployer) validateSources() error {
for _, upload := range d.staticSiteMft.FileUploads {
_, err := d.fs.Stat(filepath.Join(d.wsRoot, upload.Source))
if err != nil {
return fmt.Errorf("source %q must be a valid path relative to the workspace root %q: %w", upload.Source, d.wsRoot, err)
}
}
return nil
}
// convertSources transforms the source's path relative to the project root into the absolute path.
func (d *staticSiteDeployer) convertSources() ([]manifest.FileUpload, error) {
convertedFileUploads := make([]manifest.FileUpload, len(d.staticSiteMft.FileUploads))
for i, upload := range d.staticSiteMft.FileUploads {
convertedFileUploads[i] = manifest.FileUpload{
Source: filepath.Join(d.wsRoot, upload.Source),
Destination: upload.Destination,
Recursive: upload.Recursive,
Exclude: upload.Exclude,
Reinclude: upload.Reinclude,
}
}
return convertedFileUploads, nil
}
func (d *staticSiteDeployer) validateAlias() error {
if d.staticSiteMft.HTTP.Alias == "" {
return nil
}
hasImportedCerts := len(d.envConfig.HTTPConfig.Public.Certificates) != 0
if hasImportedCerts {
return fmt.Errorf("cannot specify alias when env %q imports one or more certificates", d.env.Name)
}
if d.app.Domain == "" {
return fmt.Errorf("cannot specify alias when application is not associated with a domain")
}
return validateAliases(d.app, d.env.Name, d.staticSiteMft.HTTP.Alias)
}
| 221 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"errors"
"fmt"
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/golang/mock/gomock"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
)
func TestStaticSiteDeployer_UploadArtifacts(t *testing.T) {
type mockDeps struct {
uploader *mocks.MockfileUploader
fs func() afero.Fs
cachedWSRoot string
}
tests := map[string]struct {
mock func(m *mockDeps)
expected *UploadArtifactsOutput
wantErr error
}{
"error if failed to upload": {
mock: func(m *mockDeps) {
m.cachedWSRoot = "mockRoot"
m.fs = func() afero.Fs {
fs := afero.NewMemMapFs()
_ = fs.Mkdir("mockRoot/assets/", 0755)
return fs
}
m.uploader.EXPECT().UploadFiles(gomock.Any()).Return("", errors.New("some error"))
},
wantErr: fmt.Errorf("upload static files: some error"),
},
"error if source path does not exist": {
mock: func(m *mockDeps) {
m.cachedWSRoot = "mockRoot"
m.fs = func() afero.Fs {
fs := afero.NewMemMapFs()
_ = fs.Mkdir("mockrOOt/assets/", 0755)
return fs
}
},
wantErr: errors.New(`source "assets" must be a valid path relative to the workspace root "mockRoot": open mockRoot/assets: file does not exist`),
},
"success": {
mock: func(m *mockDeps) {
m.cachedWSRoot = "mockRoot"
m.fs = func() afero.Fs {
fs := afero.NewMemMapFs()
_ = fs.Mkdir("mockRoot/assets/", 0755)
return fs
}
m.uploader.EXPECT().UploadFiles([]manifest.FileUpload{
{
Source: "mockRoot/assets",
Destination: "static",
Recursive: true,
Exclude: manifest.StringSliceOrString{
String: aws.String("*.manifest"),
},
},
}).Return("asdf", nil)
},
expected: &UploadArtifactsOutput{
CustomResourceURLs: map[string]string{},
StaticSiteAssetMappingLocation: "s3://mockArtifactBucket/asdf",
},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &mockDeps{
uploader: mocks.NewMockfileUploader(ctrl),
}
if tc.mock != nil {
tc.mock(m)
}
deployer := &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
customResources: func(fs template.Reader) ([]*customresource.CustomResource, error) {
return nil, nil
},
mft: &mockWorkloadMft{},
resources: &stack.AppRegionalResources{
S3Bucket: "mockArtifactBucket",
},
},
},
staticSiteMft: &manifest.StaticSite{
StaticSiteConfig: manifest.StaticSiteConfig{
FileUploads: []manifest.FileUpload{
{
Source: "assets",
Destination: "static",
Recursive: true,
Exclude: manifest.StringSliceOrString{
String: aws.String("*.manifest"),
},
},
},
},
},
uploader: m.uploader,
fs: m.fs(),
wsRoot: m.cachedWSRoot,
}
actual, err := deployer.UploadArtifacts()
if tc.wantErr != nil {
require.EqualError(t, err, tc.wantErr.Error())
} else {
require.NoError(t, err)
require.Equal(t, tc.expected, actual)
}
})
}
}
func TestStaticSiteDeployer_stackConfiguration(t *testing.T) {
tests := map[string]struct {
deployer *staticSiteDeployer
wantErr string
wantTemplate string
}{
"error getting service discovery endpoint": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", errors.New("some error")),
},
},
},
},
wantErr: "get service discovery endpoint: some error",
},
"error getting env version": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
env: &config.Environment{
Name: "mockEnv",
},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", errors.New("some error")),
},
},
},
},
wantErr: `get version of environment "mockEnv": some error`,
},
"error getting app version": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{
Name: "mockApp",
},
env: &config.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", errors.New("some error")),
},
staticSiteMft: &manifest.StaticSite{},
},
wantErr: `static sites not supported: get version for app "mockApp": some error`,
},
"error bc app version out of date": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{},
env: &config.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.1.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{},
},
wantErr: `static sites not supported: app version must be >= v1.2.0`,
},
"error bc alias specified and env has imported certs": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{},
env: &config.Environment{
Name: "mockEnv",
},
envConfig: &manifest.Environment{
EnvironmentConfig: manifest.EnvironmentConfig{
HTTPConfig: manifest.EnvironmentHTTPConfig{
Public: manifest.PublicHTTPConfig{
Certificates: []string{"mockCert"},
},
},
},
},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
resources: &stack.AppRegionalResources{},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.2.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{
StaticSiteConfig: manifest.StaticSiteConfig{
HTTP: manifest.StaticSiteHTTP{
Alias: "hi.com",
},
},
},
},
wantErr: `cannot specify alias when env "mockEnv" imports one or more certificates`,
},
"error bc alias specified no domain imported": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{},
env: &config.Environment{},
envConfig: &manifest.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
resources: &stack.AppRegionalResources{},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.2.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{
StaticSiteConfig: manifest.StaticSiteConfig{
HTTP: manifest.StaticSiteHTTP{
Alias: "hi.com",
},
},
},
},
wantErr: `cannot specify alias when application is not associated with a domain`,
},
"error bc invalid alias": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{
Name: "mockApp",
Domain: "example.com",
},
env: &config.Environment{
Name: "mockEnv",
},
envConfig: &manifest.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
resources: &stack.AppRegionalResources{},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.2.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{
StaticSiteConfig: manifest.StaticSiteConfig{
HTTP: manifest.StaticSiteHTTP{
Alias: "hi.com",
},
},
},
},
wantErr: `alias "hi.com" is not supported in hosted zones managed by Copilot`,
},
"error creating stack": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{},
env: &config.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
resources: &stack.AppRegionalResources{},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.2.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{},
newStack: func(*stack.StaticSiteConfig) (*stack.StaticSite, error) {
return nil, errors.New("some error")
},
},
wantErr: `create stack configuration: some error`,
},
"success": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{},
env: &config.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
resources: &stack.AppRegionalResources{},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.2.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{},
newStack: func(*stack.StaticSiteConfig) (*stack.StaticSite, error) {
return nil, nil
},
},
},
"success with alias": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{
Name: "mockApp",
Domain: "example.com",
},
env: &config.Environment{
Name: "mockEnv",
},
envConfig: &manifest.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
resources: &stack.AppRegionalResources{},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.2.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{
StaticSiteConfig: manifest.StaticSiteConfig{
HTTP: manifest.StaticSiteHTTP{
Alias: "hi.mockApp.example.com",
},
},
},
newStack: func(*stack.StaticSiteConfig) (*stack.StaticSite, error) {
return nil, nil
},
},
},
"success with overrider": {
deployer: &staticSiteDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
app: &config.Application{
Name: "mockApp",
Domain: "example.com",
},
env: &config.Environment{
Name: "mockEnv",
},
envConfig: &manifest.Environment{},
endpointGetter: &endpointGetterDouble{
ServiceDiscoveryEndpointFn: ReturnsValues("", error(nil)),
},
envVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("", error(nil)),
},
resources: &stack.AppRegionalResources{},
overrider: &mockOverrider{},
},
},
appVersionGetter: &versionGetterDouble{
VersionFn: ReturnsValues("v1.2.0", error(nil)),
},
staticSiteMft: &manifest.StaticSite{
StaticSiteConfig: manifest.StaticSiteConfig{
HTTP: manifest.StaticSiteHTTP{
Alias: "hi.mockApp.example.com",
},
},
},
newStack: func(*stack.StaticSiteConfig) (*stack.StaticSite, error) {
return stack.NewStaticSite(&stack.StaticSiteConfig{
EnvManifest: &manifest.Environment{
Workload: manifest.Workload{
Name: aws.String("mockEnv"),
},
},
App: &config.Application{
Name: "mockApp",
},
Manifest: &manifest.StaticSite{
Workload: manifest.Workload{
Name: aws.String("static"),
Type: aws.String(manifestinfo.StaticSiteType),
},
},
RuntimeConfig: stack.RuntimeConfig{
Region: "us-west-2",
},
ArtifactBucketName: "mockBucket",
})
},
},
wantTemplate: "mockOverride",
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
out, gotErr := tc.deployer.stackConfiguration(&StackRuntimeConfiguration{})
if tc.wantErr != "" {
require.EqualError(t, gotErr, tc.wantErr)
return
}
require.NoError(t, gotErr)
if tc.wantTemplate != "" {
s, err := out.Template()
require.NoError(t, err)
require.Equal(t, tc.wantTemplate, s)
}
})
}
}
func ReturnsValues[A, B any](a A, b B) func() (A, B) {
return func() (A, B) {
return a, b
}
}
type mockOverrider struct{}
func (o *mockOverrider) Override(body []byte) (out []byte, err error) {
return []byte("mockOverride"), nil
}
| 493 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
// Package deploy holds the structures to deploy a workload.
package deploy
import (
"errors"
"fmt"
"io"
"regexp"
"time"
"github.com/aws/aws-sdk-go/aws/session"
"golang.org/x/mod/semver"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
)
type uploader interface {
Upload(bucket, key string, data io.Reader) (string, error)
}
type versionGetter interface {
Version() (string, error)
}
type serviceForceUpdater interface {
ForceUpdateService(app, env, svc string) error
LastUpdatedAt(app, env, svc string) (time.Time, error)
}
type aliasCertValidator interface {
ValidateCertAliases(aliases []string, certs []string) error
}
type svcDeployer struct {
*workloadDeployer
newSvcUpdater func(func(*session.Session) serviceForceUpdater) serviceForceUpdater
now func() time.Time
}
func newSvcDeployer(in *WorkloadDeployerInput) (*svcDeployer, error) {
wkldDeployer, err := newWorkloadDeployer(in)
if err != nil {
return nil, err
}
return &svcDeployer{
workloadDeployer: wkldDeployer,
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return f(wkldDeployer.envSess)
},
now: time.Now,
}, nil
}
func (d *svcDeployer) deploy(deployOptions Options, stackConfigOutput svcStackConfigurationOutput) error {
opts := []awscloudformation.StackOption{
awscloudformation.WithRoleARN(d.env.ExecutionRoleARN),
}
if deployOptions.DisableRollback {
opts = append(opts, awscloudformation.WithDisableRollback())
}
cmdRunAt := d.now()
if err := d.deployer.DeployService(stackConfigOutput.conf, d.resources.S3Bucket, opts...); err != nil {
var errEmptyCS *awscloudformation.ErrChangeSetEmpty
if !errors.As(err, &errEmptyCS) {
return fmt.Errorf("deploy service: %w", err)
}
if !deployOptions.ForceNewUpdate {
log.Warningln("Set --force to force an update for the service.")
return fmt.Errorf("deploy service: %w", err)
}
}
// Force update the service if --force is set and the service is not updated by the CFN.
if deployOptions.ForceNewUpdate {
lastUpdatedAt, err := stackConfigOutput.svcUpdater.LastUpdatedAt(d.app.Name, d.env.Name, d.name)
if err != nil {
return fmt.Errorf("get the last updated deployment time for %s: %w", d.name, err)
}
if cmdRunAt.After(lastUpdatedAt) {
if err := d.forceDeploy(&forceDeployInput{
spinner: d.spinner,
svcUpdater: stackConfigOutput.svcUpdater,
}); err != nil {
return err
}
}
}
return nil
}
type svcStackConfigurationOutput struct {
conf cloudformation.StackConfiguration
svcUpdater serviceForceUpdater
}
type errAppOutOfDate struct {
svc string
curVersion string
neededVersion string
}
func (e *errAppOutOfDate) Error() string {
return fmt.Sprintf("app version must be >= %s", e.neededVersion)
}
func (e *errAppOutOfDate) RecommendActions() string {
return fmt.Sprintf(`Cannot deploy service %q because the current application version %q
is incompatible. To upgrade the application, please run %s.
(see https://aws.github.io/copilot-cli/docs/credentials/#application-credentials)
`, e.svc, e.curVersion, color.HighlightCode("copilot app upgrade"))
}
func validateMinAppVersion(app, svc string, appVersionGetter versionGetter, minVersion string) error {
appVersion, err := appVersionGetter.Version()
if err != nil {
return fmt.Errorf("get version for app %q: %w", app, err)
}
diff := semver.Compare(appVersion, minVersion)
if diff < 0 {
return &errAppOutOfDate{
svc: svc,
curVersion: appVersion,
neededVersion: minVersion,
}
}
return nil
}
func validateAliases(app *config.Application, env string, aliases ...string) error {
// Alias should be within either env, app, or root hosted zone.
regRoot, err := regexp.Compile(fmt.Sprintf(`^([^\.]+\.)?%s`, app.Domain))
if err != nil {
return err
}
regApp, err := regexp.Compile(fmt.Sprintf(`^([^\.]+\.)?%s.%s`, app.Name, app.Domain))
if err != nil {
return err
}
regEnv, err := regexp.Compile(fmt.Sprintf(`^([^\.]+\.)?%s.%s.%s`, env, app.Name, app.Domain))
if err != nil {
return err
}
regexps := []*regexp.Regexp{regRoot, regApp, regEnv}
validate := func(alias string) error {
for _, reg := range regexps {
if reg.MatchString(alias) {
return nil
}
}
return &errInvalidAlias{
alias: alias,
app: app,
env: env,
}
}
for _, alias := range aliases {
if err := validate(alias); err != nil {
return err
}
}
return nil
}
type errInvalidAlias struct {
alias string
app *config.Application
env string
}
func (e *errInvalidAlias) Error() string {
return fmt.Sprintf("alias %q is not supported in hosted zones managed by Copilot", e.alias)
}
func (e *errInvalidAlias) RecommmendActions() string {
return fmt.Sprintf(`Copilot-managed aliases must match one of the following patterns:
- <name>.%s.%s.%s
- %s.%s.%s
- <name>.%s.%s
- %s.%s
- <name>.%s
- %s
`, e.env, e.app.Name, e.app.Domain,
e.env, e.app.Name, e.app.Domain,
e.app.Name, e.app.Domain,
e.app.Name, e.app.Domain,
e.app.Domain,
e.app.Domain)
}
| 201 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
type versionGetterDouble struct {
VersionFn func() (string, error)
}
func (d *versionGetterDouble) Version() (string, error) {
return d.VersionFn()
}
| 13 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"fmt"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/aws/session"
awsecs "github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/ecs"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/manifest/manifestinfo"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"golang.org/x/text/cases"
"golang.org/x/text/language"
)
var (
fmtErrTopicSubscriptionNotAllowed = "SNS topic %s does not exist in environment %s"
resourceNameFormat = "%s-%s-%s-%s" // Format for copilot resource names of form app-env-svc-name
)
type snsTopicsLister interface {
ListSNSTopics(appName string, envName string) ([]deploy.Topic, error)
}
type workerSvcDeployer struct {
*svcDeployer
wsMft *manifest.WorkerService
// Overriden in tests.
topicLister snsTopicsLister
newStack func() cloudformation.StackConfiguration
}
// IsServiceAvailableInRegion checks if service type exist in the given region.
func (workerSvcDeployer) IsServiceAvailableInRegion(region string) (bool, error) {
return partitions.IsAvailableInRegion(awsecs.EndpointsID, region)
}
// NewWorkerSvcDeployer is the constructor for workerSvcDeployer.
func NewWorkerSvcDeployer(in *WorkloadDeployerInput) (*workerSvcDeployer, error) {
in.customResources = workerCustomResources
svcDeployer, err := newSvcDeployer(in)
if err != nil {
return nil, err
}
deployStore, err := deploy.NewStore(in.SessionProvider, svcDeployer.store)
if err != nil {
return nil, fmt.Errorf("new deploy store: %w", err)
}
wsMft, ok := in.Mft.(*manifest.WorkerService)
if !ok {
return nil, fmt.Errorf("manifest is not of type %s", manifestinfo.WorkerServiceType)
}
return &workerSvcDeployer{
svcDeployer: svcDeployer,
topicLister: deployStore,
wsMft: wsMft,
}, nil
}
func workerCustomResources(fs template.Reader) ([]*customresource.CustomResource, error) {
crs, err := customresource.Worker(fs)
if err != nil {
return nil, fmt.Errorf("read custom resources for a %q: %w", manifestinfo.WorkerServiceType, err)
}
return crs, nil
}
// UploadArtifacts uploads the deployment artifacts such as the container image, custom resources, addons and env files.
func (d *workerSvcDeployer) UploadArtifacts() (*UploadArtifactsOutput, error) {
return d.uploadArtifacts(d.uploadContainerImages, d.uploadArtifactsToS3, d.uploadCustomResources)
}
type workerSvcDeployOutput struct {
subs []manifest.TopicSubscription
}
// RecommendedActions returns the recommended actions after deployment.
func (d *workerSvcDeployOutput) RecommendedActions() []string {
if d.subs == nil {
return nil
}
retrieveEnvVarCode := "const eventsQueueURI = process.env.COPILOT_QUEUE_URI"
actionRetrieveEnvVar := fmt.Sprintf(
`Update worker service code to leverage the injected environment variable "COPILOT_QUEUE_URI".
In JavaScript you can write %s.`,
color.HighlightCode(retrieveEnvVarCode),
)
recs := []string{actionRetrieveEnvVar}
topicQueueNames := d.buildWorkerQueueNames()
if topicQueueNames == "" {
return recs
}
retrieveTopicQueueEnvVarCode := fmt.Sprintf("const {%s} = JSON.parse(process.env.COPILOT_TOPIC_QUEUE_URIS)", topicQueueNames)
actionRetrieveTopicQueues := fmt.Sprintf(
`You can retrieve topic-specific queues by writing
%s.`,
color.HighlightCode(retrieveTopicQueueEnvVarCode),
)
recs = append(recs, actionRetrieveTopicQueues)
return recs
}
// GenerateCloudFormationTemplate generates a CloudFormation template and parameters for a workload.
func (d *workerSvcDeployer) GenerateCloudFormationTemplate(in *GenerateCloudFormationTemplateInput) (
*GenerateCloudFormationTemplateOutput, error) {
output, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
return d.generateCloudFormationTemplate(output.conf)
}
// DeployWorkload deploys a worker service using CloudFormation.
func (d *workerSvcDeployer) DeployWorkload(in *DeployWorkloadInput) (ActionRecommender, error) {
stackConfigOutput, err := d.stackConfiguration(&in.StackRuntimeConfiguration)
if err != nil {
return nil, err
}
if err := d.deploy(in.Options, stackConfigOutput.svcStackConfigurationOutput); err != nil {
return nil, err
}
return &workerSvcDeployOutput{
subs: stackConfigOutput.subscriptions,
}, nil
}
func (d *workerSvcDeployOutput) buildWorkerQueueNames() string {
var queueNames []string
for _, subscription := range d.subs {
if subscription.Queue.IsEmpty() {
continue
}
svc := template.StripNonAlphaNumFunc(aws.StringValue(subscription.Service))
topic := template.StripNonAlphaNumFunc(aws.StringValue(subscription.Name))
queueNames = append(queueNames, fmt.Sprintf("%s%sEventsQueue", svc, cases.Title(language.English).String(topic)))
}
return strings.Join(queueNames, ", ")
}
type workerSvcStackConfigurationOutput struct {
svcStackConfigurationOutput
subscriptions []manifest.TopicSubscription
}
func (d *workerSvcDeployer) stackConfiguration(in *StackRuntimeConfiguration) (*workerSvcStackConfigurationOutput, error) {
rc, err := d.runtimeConfig(in)
if err != nil {
return nil, err
}
var topics []deploy.Topic
topics, err = d.topicLister.ListSNSTopics(d.app.Name, d.env.Name)
if err != nil {
return nil, fmt.Errorf("get SNS topics for app %s and environment %s: %w", d.app.Name, d.env.Name, err)
}
var topicARNs []string
for _, topic := range topics {
topicARNs = append(topicARNs, topic.ARN())
}
subs := d.wsMft.Subscriptions()
if err = validateTopicsExist(subs, topicARNs, d.app.Name, d.env.Name); err != nil {
return nil, err
}
var conf cloudformation.StackConfiguration
switch {
case d.newStack != nil:
conf = d.newStack()
default:
conf, err = stack.NewWorkerService(stack.WorkerServiceConfig{
App: d.app,
Env: d.env.Name,
Manifest: d.wsMft,
RawManifest: d.rawMft,
ArtifactBucketName: d.resources.S3Bucket,
RuntimeConfig: *rc,
Addons: d.addons,
})
if err != nil {
return nil, fmt.Errorf("create stack configuration: %w", err)
}
}
return &workerSvcStackConfigurationOutput{
svcStackConfigurationOutput: svcStackConfigurationOutput{
conf: cloudformation.WrapWithTemplateOverrider(conf, d.overrider),
svcUpdater: d.newSvcUpdater(func(s *session.Session) serviceForceUpdater {
return ecs.New(s)
}),
},
subscriptions: subs,
}, nil
}
func validateTopicsExist(subscriptions []manifest.TopicSubscription, topicARNs []string, app, env string) error {
validTopicResources := make([]string, 0, len(topicARNs))
for _, topic := range topicARNs {
parsedTopic, err := arn.Parse(topic)
if err != nil {
continue
}
validTopicResources = append(validTopicResources, parsedTopic.Resource)
}
for _, ts := range subscriptions {
topicName := fmt.Sprintf(resourceNameFormat, app, env, aws.StringValue(ts.Service), aws.StringValue(ts.Name))
if !contains(topicName, validTopicResources) {
return fmt.Errorf(fmtErrTopicSubscriptionNotAllowed, topicName, env)
}
}
return nil
}
func contains(s string, items []string) bool {
for _, item := range items {
if s == item {
return true
}
}
return false
}
| 234 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"errors"
"fmt"
"testing"
"time"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/override"
"gopkg.in/yaml.v3"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
func TestWorkerSvcDeployer_GenerateCloudFormationTemplate(t *testing.T) {
t.Run("ensure resulting CloudFormation template custom resource paths are empty", func(t *testing.T) {
// GIVEN
worker := mockWorkerServiceDeployer()
// WHEN
out, err := worker.GenerateCloudFormationTemplate(&GenerateCloudFormationTemplateInput{})
// THEN
require.NoError(t, err)
type lambdaFn struct {
Properties struct {
Code struct {
S3Bucket string `yaml:"S3bucket"`
S3Key string `yaml:"S3Key"`
} `yaml:"Code"`
} `yaml:"Properties"`
}
dat := struct {
Resources struct {
EnvControllerFunction lambdaFn `yaml:"EnvControllerFunction"`
BacklogPerTaskCalculatorFunction lambdaFn `yaml:"BacklogPerTaskCalculatorFunction"`
} `yaml:"Resources"`
}{}
require.NoError(t, yaml.Unmarshal([]byte(out.Template), &dat))
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.EnvControllerFunction.Properties.Code.S3Key)
require.Empty(t, dat.Resources.BacklogPerTaskCalculatorFunction.Properties.Code.S3Bucket)
require.Empty(t, dat.Resources.BacklogPerTaskCalculatorFunction.Properties.Code.S3Key)
})
}
func TestSvcDeployOpts_stackConfiguration_worker(t *testing.T) {
mockError := errors.New("some error")
topic, _ := deploy.NewTopic("arn:aws:sns:us-west-2:0123456789012:mockApp-mockEnv-mockwkld-givesdogs", "mockApp", "mockEnv", "mockwkld")
const (
mockAppName = "mockApp"
mockEnvName = "mockEnv"
mockName = "mockwkld"
mockBucket = "mockBucket"
)
mockResources := &stack.AppRegionalResources{
S3Bucket: mockBucket,
}
mockTopics := []manifest.TopicSubscription{
{
Name: aws.String("givesdogs"),
Service: aws.String("mockwkld"),
},
}
tests := map[string]struct {
inAlias string
inApp *config.Application
inEnvironment *config.Environment
inBuildRequire bool
mock func(m *deployMocks)
wantErr error
wantedSubscriptions []manifest.TopicSubscription
}{
"fail to get deployed topics": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockSNSTopicsLister.EXPECT().ListSNSTopics(mockAppName, mockEnvName).Return(nil, mockError)
},
wantErr: fmt.Errorf("get SNS topics for app mockApp and environment mockEnv: %w", mockError),
},
"success": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockEnv.mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockSNSTopicsLister.EXPECT().ListSNSTopics(mockAppName, mockEnvName).Return([]deploy.Topic{
*topic,
}, nil)
},
wantedSubscriptions: mockTopics,
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployMocks{
mockEndpointGetter: mocks.NewMockendpointGetter(ctrl),
mockSNSTopicsLister: mocks.NewMocksnsTopicsLister(ctrl),
mockEnvVersionGetter: mocks.NewMockversionGetter(ctrl),
}
tc.mock(m)
deployer := workerSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: mockName,
app: tc.inApp,
env: tc.inEnvironment,
resources: mockResources,
endpointGetter: m.mockEndpointGetter,
envVersionGetter: m.mockEnvVersionGetter,
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return nil
},
},
topicLister: m.mockSNSTopicsLister,
wsMft: &manifest.WorkerService{
Workload: manifest.Workload{
Name: aws.String(mockName),
},
WorkerServiceConfig: manifest.WorkerServiceConfig{
ImageConfig: manifest.ImageWithHealthcheck{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Build: manifest.BuildArgsOrString{BuildString: aws.String("/Dockerfile")},
},
},
},
Subscribe: manifest.SubscribeConfig{
Topics: mockTopics,
},
},
},
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
got, gotErr := deployer.stackConfiguration(&StackRuntimeConfiguration{})
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
} else {
require.NoError(t, gotErr)
require.ElementsMatch(t, tc.wantedSubscriptions, got.subscriptions)
}
})
}
}
func Test_validateTopicsExist(t *testing.T) {
mockApp := "app"
mockEnv := "env"
mockAllowedTopics := []string{
"arn:aws:sqs:us-west-2:123456789012:app-env-database-events",
"arn:aws:sqs:us-west-2:123456789012:app-env-database-orders",
"arn:aws:sqs:us-west-2:123456789012:app-env-api-events",
}
duration10Hours := 10 * time.Hour
testGoodTopics := []manifest.TopicSubscription{
{
Name: aws.String("events"),
Service: aws.String("database"),
},
{
Name: aws.String("orders"),
Service: aws.String("database"),
Queue: manifest.SQSQueueOrBool{
Advanced: manifest.SQSQueue{
Retention: &duration10Hours,
},
},
},
}
testCases := map[string]struct {
inTopics []manifest.TopicSubscription
inTopicARNs []string
wantErr string
}{
"empty subscriptions": {
inTopics: nil,
inTopicARNs: mockAllowedTopics,
},
"topics are valid": {
inTopics: testGoodTopics,
inTopicARNs: mockAllowedTopics,
},
"topic is invalid": {
inTopics: testGoodTopics,
inTopicARNs: []string{},
wantErr: "SNS topic app-env-database-events does not exist in environment env",
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
err := validateTopicsExist(tc.inTopics, tc.inTopicARNs, mockApp, mockEnv)
if tc.wantErr != "" {
require.EqualError(t, err, tc.wantErr)
} else {
require.NoError(t, err)
}
})
}
}
func mockWorkerServiceDeployer(opts ...func(*workerSvcDeployer)) *workerSvcDeployer {
deployer := &workerSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: "example",
app: &config.Application{
Name: "demo",
},
env: &config.Environment{
App: "demo",
Name: "test",
},
resources: &stack.AppRegionalResources{},
envConfig: new(manifest.Environment),
endpointGetter: &mockEndpointGetter{endpoint: "demo.test.local"},
envVersionGetter: &mockEnvVersionGetter{version: "v1.0.0"},
overrider: new(override.Noop),
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return nil
},
now: func() time.Time {
return time.Date(2020, 11, 23, 0, 0, 0, 0, time.UTC)
},
},
topicLister: &mockTopicLister{},
wsMft: &manifest.WorkerService{
Workload: manifest.Workload{
Name: aws.String("example"),
},
WorkerServiceConfig: manifest.WorkerServiceConfig{
TaskConfig: manifest.TaskConfig{
Count: manifest.Count{
Value: aws.Int(1),
},
},
ImageConfig: manifest.ImageWithHealthcheck{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Build: manifest.BuildArgsOrString{BuildString: aws.String("/Dockerfile")},
},
},
},
},
},
newStack: func() cloudformation.StackConfiguration {
return new(stubCloudFormationStack)
},
}
for _, opt := range opts {
opt(deployer)
}
return deployer
}
| 297 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"sync"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/ssm"
"github.com/aws/copilot-cli/internal/pkg/addon"
awscloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/ecr"
"github.com/aws/copilot-cli/internal/pkg/aws/identity"
"github.com/aws/copilot-cli/internal/pkg/aws/partitions"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/aws/sessions"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/describe"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/exec"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/repository"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/template/artifactpath"
"github.com/aws/copilot-cli/internal/pkg/template/diff"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/cursor"
"github.com/aws/copilot-cli/internal/pkg/term/log"
termprogress "github.com/aws/copilot-cli/internal/pkg/term/progress"
"github.com/aws/copilot-cli/internal/pkg/term/syncbuffer"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/aws/copilot-cli/internal/pkg/workspace"
"github.com/spf13/afero"
"golang.org/x/sync/errgroup"
)
const (
fmtForceUpdateSvcStart = "Forcing an update for service %s from environment %s"
fmtForceUpdateSvcFailed = "Failed to force an update for service %s from environment %s: %v.\n"
fmtForceUpdateSvcComplete = "Forced an update for service %s from environment %s.\n"
)
const (
imageTagLatest = "latest"
)
const (
labelForBuilder = "com.aws.copilot.image.builder"
labelForVersion = "com.aws.copilot.image.version"
labelForContainerName = "com.aws.copilot.image.container.name"
)
const (
paddingInSpacesForBuildAndPush = 5
pollIntervalForBuildAndPush = 60 * time.Millisecond
defaultNumLinesForBuildAndPush = 5
)
// ActionRecommender contains methods that output action recommendation.
type ActionRecommender interface {
RecommendedActions() []string
}
type noopActionRecommender struct{}
func (noopActionRecommender) RecommendedActions() []string {
return nil
}
type repositoryService interface {
Login() (string, error)
BuildAndPush(ctx context.Context, args *dockerengine.BuildArguments, w io.Writer) (string, error)
}
type templater interface {
Template() (string, error)
}
type stackBuilder interface {
templater
Parameters() (string, error)
Package(addon.PackageConfig) error
}
type stackSerializer interface {
templater
SerializedParameters() (string, error)
}
type endpointGetter interface {
ServiceDiscoveryEndpoint() (string, error)
}
type serviceDeployer interface {
DeployService(conf cloudformation.StackConfiguration, bucketName string, opts ...awscloudformation.StackOption) error
}
type deployedTemplateGetter interface {
Template(stackName string) (string, error)
}
type spinner interface {
Start(label string)
Stop(label string)
}
type labeledTermPrinter interface {
IsDone() bool
Print()
}
type dockerEngineRunChecker interface {
CheckDockerEngineRunning() error
}
// StackRuntimeConfiguration contains runtime configuration for a workload CloudFormation stack.
type StackRuntimeConfiguration struct {
ImageDigests map[string]ContainerImageIdentifier // Container name to image.
EnvFileARNs map[string]string
AddonsURL string
RootUserARN string
Tags map[string]string
CustomResourceURLs map[string]string
StaticSiteAssetMappingURL string
}
// DeployWorkloadInput is the input of DeployWorkload.
type DeployWorkloadInput struct {
StackRuntimeConfiguration
Options
}
// Options specifies options for the deployment.
type Options struct {
ForceNewUpdate bool
DisableRollback bool
}
// GenerateCloudFormationTemplateInput is the input of GenerateCloudFormationTemplate.
type GenerateCloudFormationTemplateInput struct {
StackRuntimeConfiguration
}
// GenerateCloudFormationTemplateOutput is the output of GenerateCloudFormationTemplate.
type GenerateCloudFormationTemplateOutput struct {
Template string
Parameters string
}
type workloadDeployer struct {
name string
app *config.Application
env *config.Environment
image ContainerImageIdentifier
resources *stack.AppRegionalResources
mft interface{}
rawMft []byte
workspacePath string
// Dependencies.
fs afero.Fs
s3Client uploader
addons stackBuilder
repository repositoryService
deployer serviceDeployer
tmplGetter deployedTemplateGetter
endpointGetter endpointGetter
spinner spinner
templateFS template.Reader
envVersionGetter versionGetter
overrider Overrider
docker dockerEngineRunChecker
customResources customResourcesFunc
labeledTermPrinter func(fw syncbuffer.FileWriter, bufs []*syncbuffer.LabeledSyncBuffer, opts ...syncbuffer.LabeledTermPrinterOption) labeledTermPrinter
// Cached variables.
defaultSess *session.Session
defaultSessWithEnvRegion *session.Session
envSess *session.Session
store *config.Store
envConfig *manifest.Environment
}
// WorkloadDeployerInput is the input to for workloadDeployer constructor.
type WorkloadDeployerInput struct {
SessionProvider *sessions.Provider
Name string
App *config.Application
Env *config.Environment
Image ContainerImageIdentifier
Mft interface{} // Interpolated, applied, and unmarshaled manifest.
RawMft []byte // Content of the manifest file without any transformations.
EnvVersionGetter versionGetter
Overrider Overrider
// Workload specific configuration.
customResources customResourcesFunc
}
// ContainerImageIdentifier is the configuration of the image digest and tags of an ECR image.
type ContainerImageIdentifier struct {
Digest string
CustomTag string
GitShortCommitTag string
}
// newWorkloadDeployer is the constructor for workloadDeployer.
func newWorkloadDeployer(in *WorkloadDeployerInput) (*workloadDeployer, error) {
ws, err := workspace.Use(afero.NewOsFs())
if err != nil {
return nil, err
}
defaultSession, err := in.SessionProvider.Default()
if err != nil {
return nil, fmt.Errorf("create default: %w", err)
}
envSession, err := in.SessionProvider.FromRole(in.Env.ManagerRoleARN, in.Env.Region)
if err != nil {
return nil, fmt.Errorf("create env session with region %s: %w", in.Env.Region, err)
}
defaultSessEnvRegion, err := in.SessionProvider.DefaultWithRegion(in.Env.Region)
if err != nil {
return nil, fmt.Errorf("create default session with region %s: %w", in.Env.Region, err)
}
resources, err := cloudformation.New(defaultSession, cloudformation.WithProgressTracker(os.Stderr)).GetAppResourcesByRegion(in.App, in.Env.Region)
if err != nil {
return nil, fmt.Errorf("get application %s resources from region %s: %w", in.App.Name, in.Env.Region, err)
}
var addons stackBuilder
addons, err = addon.ParseFromWorkload(in.Name, ws)
if err != nil {
var notFoundErr *addon.ErrAddonsNotFound
if !errors.As(err, ¬FoundErr) {
return nil, fmt.Errorf("parse addons stack for workload %s: %w", in.Name, err)
}
addons = nil // so that we can check for no addons with nil comparison
}
repoName := fmt.Sprintf("%s/%s", in.App.Name, in.Name)
repository := repository.NewWithURI(
ecr.New(defaultSessEnvRegion), repoName, resources.RepositoryURLs[in.Name])
store := config.NewSSMStore(identity.New(defaultSession), ssm.New(defaultSession), aws.StringValue(defaultSession.Config.Region))
envDescriber, err := describe.NewEnvDescriber(describe.NewEnvDescriberConfig{
App: in.App.Name,
Env: in.Env.Name,
ConfigStore: store,
})
if err != nil {
return nil, err
}
mft, err := envDescriber.Manifest()
if err != nil {
return nil, fmt.Errorf("read the manifest used to deploy environment %s: %w", in.Env.Name, err)
}
envConfig, err := manifest.UnmarshalEnvironment(mft)
if err != nil {
return nil, fmt.Errorf("unmarshal the manifest used to deploy environment %s: %w", in.Env.Name, err)
}
cfn := cloudformation.New(envSession, cloudformation.WithProgressTracker(os.Stderr))
labeledTermPrinter := func(fw syncbuffer.FileWriter, bufs []*syncbuffer.LabeledSyncBuffer, opts ...syncbuffer.LabeledTermPrinterOption) labeledTermPrinter {
return syncbuffer.NewLabeledTermPrinter(fw, bufs, opts...)
}
docker := dockerengine.New(exec.NewCmd())
return &workloadDeployer{
name: in.Name,
app: in.App,
env: in.Env,
image: in.Image,
resources: resources,
workspacePath: ws.Path(),
fs: afero.NewOsFs(),
s3Client: s3.New(envSession),
addons: addons,
repository: repository,
deployer: cfn,
tmplGetter: cfn,
endpointGetter: envDescriber,
spinner: termprogress.NewSpinner(log.DiagnosticWriter),
templateFS: template.New(),
envVersionGetter: in.EnvVersionGetter,
overrider: in.Overrider,
docker: docker,
customResources: in.customResources,
defaultSess: defaultSession,
defaultSessWithEnvRegion: defaultSessEnvRegion,
envSess: envSession,
store: store,
envConfig: envConfig,
labeledTermPrinter: labeledTermPrinter,
mft: in.Mft,
rawMft: in.RawMft,
}, nil
}
// DeployDiff returns the stringified diff of the template against the deployed template of the workload.
func (d *workloadDeployer) DeployDiff(template string) (string, error) {
tmpl, err := d.tmplGetter.Template(stack.NameForWorkload(d.app.Name, d.env.Name, d.name))
if err != nil {
var errNotFound *awscloudformation.ErrStackNotFound
if !errors.As(err, &errNotFound) {
return "", fmt.Errorf("retrieve the deployed template for %q: %w", d.name, err)
}
tmpl = ""
}
diffTree, err := diff.From(tmpl).ParseWithCFNOverriders([]byte(template))
if err != nil {
return "", fmt.Errorf("parse the diff against the deployed %q in environment %q: %w", d.name, d.env.Name, err)
}
buf := strings.Builder{}
if err := diffTree.Write(&buf); err != nil {
return "", err
}
return buf.String(), nil
}
// AddonsTemplate returns this workload's addon template.
func (d *workloadDeployer) AddonsTemplate() (string, error) {
if d.addons == nil {
return "", nil
}
return d.addons.Template()
}
func (d *workloadDeployer) generateCloudFormationTemplate(conf stackSerializer) (
*GenerateCloudFormationTemplateOutput, error) {
tpl, err := conf.Template()
if err != nil {
return nil, err
}
params, err := conf.SerializedParameters()
if err != nil {
return nil, fmt.Errorf("generate stack template parameters: %w", err)
}
return &GenerateCloudFormationTemplateOutput{
Template: tpl,
Parameters: params,
}, nil
}
type forceDeployInput struct {
spinner spinner
svcUpdater serviceForceUpdater
}
func (d *workloadDeployer) forceDeploy(in *forceDeployInput) error {
in.spinner.Start(fmt.Sprintf(fmtForceUpdateSvcStart, color.HighlightUserInput(d.name), color.HighlightUserInput(d.env.Name)))
if err := in.svcUpdater.ForceUpdateService(d.app.Name, d.env.Name, d.name); err != nil {
errLog := fmt.Sprintf(fmtForceUpdateSvcFailed, color.HighlightUserInput(d.name),
color.HighlightUserInput(d.env.Name), err)
var terr timeoutError
if errors.As(err, &terr) {
errLog = fmt.Sprintf("%s Run %s to check for the fail reason.\n", errLog,
color.HighlightCode(fmt.Sprintf("copilot svc status --name %s --env %s", d.name, d.env.Name)))
}
in.spinner.Stop(log.Serror(errLog))
return fmt.Errorf("force an update for service %s: %w", d.name, err)
}
in.spinner.Stop(log.Ssuccessf(fmtForceUpdateSvcComplete, color.HighlightUserInput(d.name), color.HighlightUserInput(d.env.Name)))
return nil
}
// Tag returns the tag that should be used to reference the image.
// If the user provided their own tag then just use that
// Otherwise, return git short commit id.
func (img ContainerImageIdentifier) Tag() string {
if img.CustomTag != "" {
return img.CustomTag
}
return img.GitShortCommitTag
}
func (d *workloadDeployer) uploadContainerImages(out *UploadArtifactsOutput) error {
// If it is built from local Dockerfile, build and push to the ECR repo.
buildArgsPerContainer, err := buildArgsPerContainer(d.name, d.workspacePath, d.image, d.mft)
if err != nil {
return err
}
if len(buildArgsPerContainer) == 0 {
return nil
}
if err := d.docker.CheckDockerEngineRunning(); err != nil {
return fmt.Errorf("check if docker engine is running: %w", err)
}
uri, err := d.repository.Login()
if err != nil {
return fmt.Errorf("login to image repository: %w", err)
}
var digestsMu sync.Mutex
out.ImageDigests = make(map[string]ContainerImageIdentifier, len(buildArgsPerContainer))
var labeledBuffers []*syncbuffer.LabeledSyncBuffer
g, ctx := errgroup.WithContext(context.Background())
cursor := cursor.New()
cursor.Hide()
for name, buildArgs := range buildArgsPerContainer {
// create a copy of loop variables to avoid data race.
name := name
buildArgs := buildArgs
buildArgs.URI = uri
buildArgsList, err := buildArgs.GenerateDockerBuildArgs(dockerengine.New(exec.NewCmd()))
if err != nil {
return fmt.Errorf("generate docker build args for %q: %w", name, err)
}
buf := syncbuffer.New()
labeledBuffers = append(labeledBuffers, buf.WithLabel(fmt.Sprintf("Building your container image %q: docker %s", name, strings.Join(buildArgsList, " "))))
pr, pw := io.Pipe()
g.Go(func() error {
defer pw.Close()
digest, err := d.repository.BuildAndPush(ctx, buildArgs, pw)
if err != nil {
return fmt.Errorf("build and push the image %q: %w", name, err)
}
digestsMu.Lock()
defer digestsMu.Unlock()
out.ImageDigests[name] = ContainerImageIdentifier{
Digest: digest,
CustomTag: d.image.CustomTag,
GitShortCommitTag: d.image.GitShortCommitTag,
}
return nil
})
g.Go(func() error {
if err := buf.Copy(pr); err != nil {
return fmt.Errorf("copy build and push output for %q: %w", name, err)
}
return nil
})
}
opts := []syncbuffer.LabeledTermPrinterOption{syncbuffer.WithPadding(paddingInSpacesForBuildAndPush)}
if os.Getenv("CI") != "true" {
opts = append(opts, syncbuffer.WithNumLines(defaultNumLinesForBuildAndPush))
}
ltp := d.labeledTermPrinter(os.Stderr, labeledBuffers, opts...)
g.Go(func() error {
for {
ltp.Print()
if ltp.IsDone() {
return nil
}
select {
case <-ctx.Done():
return nil
case <-time.After(pollIntervalForBuildAndPush):
}
}
})
if err := g.Wait(); err != nil {
return err
}
return nil
}
func buildArgsPerContainer(name, workspacePath string, img ContainerImageIdentifier, unmarshaledManifest interface{}) (map[string]*dockerengine.BuildArguments, error) {
type dfArgs interface {
BuildArgs(rootDirectory string) (map[string]*manifest.DockerBuildArgs, error)
ContainerPlatform() string
}
mf, ok := unmarshaledManifest.(dfArgs)
if !ok {
return nil, fmt.Errorf("%T does not have required methods BuildArgs() and ContainerPlatform()", name)
}
argsPerContainer, err := mf.BuildArgs(workspacePath)
if err != nil {
return nil, fmt.Errorf("check if manifest requires building from local Dockerfile: %w", err)
}
dArgs := make(map[string]*dockerengine.BuildArguments, len(argsPerContainer))
for container, buildArgs := range argsPerContainer {
tags := []string{imageTagLatest}
if img.Tag() != "" {
tags = append(tags, img.Tag())
}
if container != name {
tags = []string{fmt.Sprintf("%s-%s", container, imageTagLatest)}
if img.GitShortCommitTag != "" {
tags = append(tags, fmt.Sprintf("%s-%s", container, img.GitShortCommitTag))
}
}
labels := make(map[string]string, 3)
labels[labelForBuilder] = "copilot-cli"
if version.Version != "" {
labels[labelForVersion] = version.Version
}
labels[labelForContainerName] = container
dArgs[container] = &dockerengine.BuildArguments{
Dockerfile: aws.StringValue(buildArgs.Dockerfile),
Context: aws.StringValue(buildArgs.Context),
Args: buildArgs.Args,
CacheFrom: buildArgs.CacheFrom,
Target: aws.StringValue(buildArgs.Target),
Platform: mf.ContainerPlatform(),
Tags: tags,
Labels: labels,
}
}
return dArgs, nil
}
func (d *workloadDeployer) uploadArtifactsToS3(out *UploadArtifactsOutput) error {
var err error
out.EnvFileARNs, err = d.pushEnvFilesToS3Bucket(&pushEnvFilesToS3BucketInput{
fs: d.fs,
uploader: d.s3Client,
})
if err != nil {
return err
}
out.AddonsURL, err = d.pushAddonsTemplateToS3Bucket()
if err != nil {
return err
}
return nil
}
type customResourcesFunc func(fs template.Reader) ([]*customresource.CustomResource, error)
// UploadArtifactsOutput is the output of UploadArtifacts.
type UploadArtifactsOutput struct {
ImageDigests map[string]ContainerImageIdentifier // Container name to image.
EnvFileARNs map[string]string // map[container name]envFileARN
AddonsURL string
CustomResourceURLs map[string]string
StaticSiteAssetMappingLocation string
}
// uploadArtifactFunc uploads an artifact and updates out
// with any relevant information to be returned by uploadArtifacts.
type uploadArtifactFunc func(out *UploadArtifactsOutput) error
// uploadArtifacts runs each of the uploadArtifact functions sequentially and returns
// the output built by each of those functions. It short-circuts and returns
// the error if one of steps returns an error.
func (d *workloadDeployer) uploadArtifacts(steps ...uploadArtifactFunc) (*UploadArtifactsOutput, error) {
out := &UploadArtifactsOutput{}
for _, step := range steps {
if err := step(out); err != nil {
return nil, err
}
}
return out, nil
}
func (d *workloadDeployer) uploadCustomResources(out *UploadArtifactsOutput) error {
crs, err := d.customResources(d.templateFS)
if err != nil {
return err
}
urls, err := customresource.Upload(func(key string, contents io.Reader) (string, error) {
return d.s3Client.Upload(d.resources.S3Bucket, key, contents)
}, crs)
if err != nil {
return fmt.Errorf("upload custom resources for %q: %w", d.name, err)
}
out.CustomResourceURLs = urls
return nil
}
type pushEnvFilesToS3BucketInput struct {
fs afero.Fs
uploader uploader
}
// pushEnvFilesToS3Bucket collects all environment files required by the workload container and any sidecars,
// uploads each one exactly once, and returns a map structured in the following way. map[containerName]envFileARN
// Example content:
//
// {
// "frontend": "arn:aws:s3:::bucket/key1",
// "firelens_log_router": "arn:aws:s3:::bucket/key2",
// "nginx": "arn:aws:s3:::bucket/key1"
// }
func (d *workloadDeployer) pushEnvFilesToS3Bucket(in *pushEnvFilesToS3BucketInput) (map[string]string, error) {
envFilesByContainer := envFiles(d.mft)
uniqueEnvFiles := make(map[string][]string)
// Invert the map of containers to env files to get the unique env files to upload.
for container, path := range envFilesByContainer {
if path == "" {
continue
}
if containers, ok := uniqueEnvFiles[path]; !ok {
uniqueEnvFiles[path] = []string{container}
} else {
uniqueEnvFiles[path] = append(containers, container)
}
}
if len(uniqueEnvFiles) == 0 {
return nil, nil
}
// Upload each file to s3 exactly once and generate its ARN.
// Save those ARNs in a map from container name to env file ARN and return.
envFileARNs := make(map[string]string)
for path, containers := range uniqueEnvFiles {
content, err := afero.ReadFile(in.fs, filepath.Join(d.workspacePath, path))
if err != nil {
return nil, fmt.Errorf("read env file %s: %w", path, err)
}
reader := bytes.NewReader(content)
url, err := in.uploader.Upload(d.resources.S3Bucket, artifactpath.EnvFiles(path, content), reader)
if err != nil {
return nil, fmt.Errorf("put env file %s artifact to bucket %s: %w", path, d.resources.S3Bucket, err)
}
bucket, key, err := s3.ParseURL(url)
if err != nil {
return nil, fmt.Errorf("parse s3 url: %w", err)
}
// The app and environment are always within the same partition.
partition, err := partitions.Region(d.env.Region).Partition()
if err != nil {
return nil, err
}
for _, container := range containers {
envFileARNs[container] = s3.FormatARN(partition.ID(), fmt.Sprintf("%s/%s", bucket, key))
}
}
return envFileARNs, nil
}
// envFiles gets a map from container name to env file for all containers in the task,
// including sidecars and Firelens logging.
func envFiles(unmarshaledManifest interface{}) map[string]string {
type envFile interface {
EnvFiles() map[string]string
}
mf, ok := unmarshaledManifest.(envFile)
if ok {
return mf.EnvFiles()
}
// If the manifest type doesn't support envFiles, ignore and move forward.
return nil
}
func (d *workloadDeployer) pushAddonsTemplateToS3Bucket() (string, error) {
if d.addons == nil {
return "", nil
}
config := addon.PackageConfig{
Bucket: d.resources.S3Bucket,
Uploader: d.s3Client,
WorkspacePath: d.workspacePath,
FS: afero.NewOsFs(),
}
if err := d.addons.Package(config); err != nil {
return "", fmt.Errorf("package addons: %w", err)
}
tmpl, err := d.addons.Template()
if err != nil {
return "", fmt.Errorf("retrieve addons template: %w", err)
}
reader := strings.NewReader(tmpl)
url, err := d.s3Client.Upload(d.resources.S3Bucket, artifactpath.Addons(d.name, []byte(tmpl)), reader)
if err != nil {
return "", fmt.Errorf("put addons artifact to bucket %s: %w", d.resources.S3Bucket, err)
}
return url, nil
}
func (d *workloadDeployer) runtimeConfig(in *StackRuntimeConfiguration) (*stack.RuntimeConfig, error) {
endpoint, err := d.endpointGetter.ServiceDiscoveryEndpoint()
if err != nil {
return nil, fmt.Errorf("get service discovery endpoint: %w", err)
}
envVersion, err := d.envVersionGetter.Version()
if err != nil {
return nil, fmt.Errorf("get version of environment %q: %w", d.env.Name, err)
}
if len(in.ImageDigests) == 0 {
return &stack.RuntimeConfig{
AddonsTemplateURL: in.AddonsURL,
EnvFileARNs: in.EnvFileARNs,
AdditionalTags: in.Tags,
ServiceDiscoveryEndpoint: endpoint,
AccountID: d.env.AccountID,
Region: d.env.Region,
CustomResourcesURL: in.CustomResourceURLs,
EnvVersion: envVersion,
}, nil
}
images := make(map[string]stack.ECRImage, len(in.ImageDigests))
for container, img := range in.ImageDigests {
// Currently we do not tag sidecar container images with custom tag provided by the user.
// This is the reason for having different ImageTag for main and sidecar container images
// that is needed to create CloudFormation stack.
imageTag := img.Tag()
if container != d.name {
imageTag = img.GitShortCommitTag
}
images[container] = stack.ECRImage{
RepoURL: d.resources.RepositoryURLs[d.name],
ImageTag: imageTag,
Digest: img.Digest,
MainContainerName: d.name,
ContainerName: container,
}
}
return &stack.RuntimeConfig{
AddonsTemplateURL: in.AddonsURL,
EnvFileARNs: in.EnvFileARNs,
AdditionalTags: in.Tags,
PushedImages: images,
ServiceDiscoveryEndpoint: endpoint,
AccountID: d.env.AccountID,
Region: d.env.Region,
CustomResourcesURL: in.CustomResourceURLs,
EnvVersion: envVersion,
}, nil
}
type timeoutError interface {
error
Timeout() bool
}
| 735 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package deploy
import (
"bytes"
"errors"
"fmt"
"io"
"path/filepath"
"strings"
"testing"
"time"
cloudformation0 "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/version"
"github.com/spf13/afero"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
sdkcfn "github.com/aws/aws-sdk-go/service/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/ecs"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/deploy/upload/customresource"
"github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
"github.com/aws/copilot-cli/internal/pkg/manifest"
"github.com/aws/copilot-cli/internal/pkg/override"
"github.com/aws/copilot-cli/internal/pkg/template"
"github.com/aws/copilot-cli/internal/pkg/term/color"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/term/syncbuffer"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type endpointGetterDouble struct {
ServiceDiscoveryEndpointFn func() (string, error)
}
func (d *endpointGetterDouble) ServiceDiscoveryEndpoint() (string, error) {
return d.ServiceDiscoveryEndpointFn()
}
type deployMocks struct {
mockRepositoryService *mocks.MockrepositoryService
mockEndpointGetter *mocks.MockendpointGetter
mockSpinner *mocks.Mockspinner
mockPublicCIDRBlocksGetter *mocks.MockpublicCIDRBlocksGetter
mockSNSTopicsLister *mocks.MocksnsTopicsLister
mockServiceDeployer *mocks.MockserviceDeployer
mockServiceForceUpdater *mocks.MockserviceForceUpdater
mockAddons *mocks.MockstackBuilder
mockUploader *mocks.Mockuploader
mockAppVersionGetter *mocks.MockversionGetter
mockEnvVersionGetter *mocks.MockversionGetter
mockFileSystem afero.Fs
mockValidator *mocks.MockaliasCertValidator
mockLabeledTermPrinter *mocks.MocklabeledTermPrinter
mockdockerEngineRunChecker *mocks.MockdockerEngineRunChecker
}
type mockTemplateFS struct {
read func(path string) (*template.Content, error)
}
// Read implements the template.Reader interface.
func (fs *mockTemplateFS) Read(path string) (*template.Content, error) {
return fs.read(path)
}
func fakeTemplateFS() *mockTemplateFS {
return &mockTemplateFS{
read: func(path string) (*template.Content, error) {
return &template.Content{
Buffer: bytes.NewBufferString("fake content"),
}, nil
},
}
}
type mockEndpointGetter struct {
endpoint string
err error
}
// ServiceDiscoveryEndpoint implements the endpointGetter interface.
func (m *mockEndpointGetter) ServiceDiscoveryEndpoint() (string, error) {
return m.endpoint, m.err
}
type mockEnvVersionGetter struct {
version string
err error
}
// Version implements the envVersionGetter interface.
func (m *mockEnvVersionGetter) Version() (string, error) {
return m.version, m.err
}
type mockTopicLister struct {
topics []deploy.Topic
err error
}
// ListSNSTopics implements the snsTopicsLister interface.
func (m *mockTopicLister) ListSNSTopics(_, _ string) ([]deploy.Topic, error) {
return m.topics, m.err
}
type mockWorkloadMft struct {
fileName string
dockerBuildArgs map[string]*manifest.DockerBuildArgs
workloadName string
customEnvFiles map[string]string
}
func (m *mockWorkloadMft) EnvFiles() map[string]string {
if m.customEnvFiles != nil {
return m.customEnvFiles
}
return map[string]string{
m.workloadName: m.fileName,
}
}
func (m *mockWorkloadMft) BuildArgs(rootDirectory string) (map[string]*manifest.DockerBuildArgs, error) {
return m.dockerBuildArgs, nil
}
func (m *mockWorkloadMft) ContainerPlatform() string {
return "mockContainerPlatform"
}
// stubCloudFormationStack implements the cloudformation.StackConfiguration interface.
type stubCloudFormationStack struct{}
func (s *stubCloudFormationStack) StackName() string {
return "demo"
}
func (s *stubCloudFormationStack) Template() (string, error) {
return `
Resources:
Queue:
Type: AWS::SQS::Queue`, nil
}
func (s *stubCloudFormationStack) Parameters() ([]*sdkcfn.Parameter, error) {
return []*sdkcfn.Parameter{}, nil
}
func (s *stubCloudFormationStack) Tags() []*sdkcfn.Tag {
return []*sdkcfn.Tag{}
}
func (s *stubCloudFormationStack) SerializedParameters() (string, error) {
return "", nil
}
func mockEnvFilePath(path string) string {
return fmt.Sprintf("%s/%s/%s/%s.env", "manual", "env-files", path, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
}
func TestWorkloadDeployer_UploadArtifacts(t *testing.T) {
const (
mockName = "mockWkld"
mockEnvName = "test"
mockAppName = "press"
mockURI = "mockRepoURI"
mockWorkspacePath = "."
mockEnvFile = "foo.env"
mockS3Bucket = "mockBucket"
mockAddonsS3URL = "https://mockS3DomainName/mockPath"
mockBadEnvFileS3URL = "badURL"
mockEnvFileS3URL = "https://stackset-demo-infrastruc-pipelinebuiltartifactbuc-11dj7ctf52wyf.s3.us-west-2.amazonaws.com/manual/1638391936/env"
mockEnvFileS3URL2 = "https://stackset-demo-infrastruc-pipelinebuiltartifactbuc-11dj7ctf52wyf.s3.us-west-2.amazonaws.com/manual/1638391936/envbar"
mockEnvFileS3ARN = "arn:aws:s3:::stackset-demo-infrastruc-pipelinebuiltartifactbuc-11dj7ctf52wyf/manual/1638391936/env"
mockEnvFileS3ARN2 = "arn:aws:s3:::stackset-demo-infrastruc-pipelinebuiltartifactbuc-11dj7ctf52wyf/manual/1638391936/envbar"
)
var mockEnvFilesOutput = map[string]string{"mockWkld": mockEnvFileS3ARN}
mockResources := &stack.AppRegionalResources{
S3Bucket: mockS3Bucket,
}
mockAddonPath := fmt.Sprintf("%s/%s/%s/%s.yml", "manual", "addons", mockName, "1307990e6ba5ca145eb35e99182a9bec46531bc54ddf656a602c780fa0240dee")
mockError := errors.New("some error")
type artifactsUploader interface {
UploadArtifacts() (*UploadArtifactsOutput, error)
}
tests := map[string]struct {
inEnvFile string
customEnvFiles map[string]string
inRegion string
inMockUserTag string
inMockGitTag string
inDockerBuildArgs map[string]*manifest.DockerBuildArgs
mock func(t *testing.T, m *deployMocks)
mockServiceDeployer func(deployer *workloadDeployer) artifactsUploader
customResourcesFunc customResourcesFunc
wantAddonsURL string
wantEnvFileARNs map[string]string
wantImages map[string]ContainerImageIdentifier
wantBuildRequired bool
wantErr error
}{
"error if docker engine is not running": {
inMockUserTag: "v1.0",
inDockerBuildArgs: map[string]*manifest.DockerBuildArgs{
"mockWkld": {
Dockerfile: aws.String("mockDockerfile"),
Context: aws.String("mockContext"),
},
},
mock: func(t *testing.T, m *deployMocks) {
m.mockdockerEngineRunChecker.EXPECT().CheckDockerEngineRunning().Return(errors.New("some error"))
},
wantErr: fmt.Errorf("check if docker engine is running: some error"),
},
"error if failed to build and push image": {
inMockUserTag: "v1.0",
inDockerBuildArgs: map[string]*manifest.DockerBuildArgs{
"mockWkld": {
Dockerfile: aws.String("mockDockerfile"),
Context: aws.String("mockContext"),
},
},
mock: func(t *testing.T, m *deployMocks) {
m.mockdockerEngineRunChecker.EXPECT().CheckDockerEngineRunning().Return(nil)
m.mockRepositoryService.EXPECT().Login().Return(mockURI, nil)
m.mockRepositoryService.EXPECT().BuildAndPush(gomock.Any(), &dockerengine.BuildArguments{
URI: mockURI,
Dockerfile: "mockDockerfile",
Context: "mockContext",
Platform: "mockContainerPlatform",
Tags: []string{"latest", "v1.0"},
Labels: map[string]string{
"com.aws.copilot.image.builder": "copilot-cli",
"com.aws.copilot.image.container.name": "mockWkld",
},
}, gomock.Any()).Return("", mockError)
m.mockLabeledTermPrinter.EXPECT().IsDone().Return(true).AnyTimes()
m.mockLabeledTermPrinter.EXPECT().Print().AnyTimes()
},
wantErr: fmt.Errorf("build and push the image \"mockWkld\": some error"),
},
"build and push image with usertag successfully": {
inMockUserTag: "v1.0",
inMockGitTag: "gitTag",
inDockerBuildArgs: map[string]*manifest.DockerBuildArgs{
"mockWkld": {
Dockerfile: aws.String("mockDockerfile"),
Context: aws.String("mockContext"),
},
},
mock: func(t *testing.T, m *deployMocks) {
m.mockdockerEngineRunChecker.EXPECT().CheckDockerEngineRunning().Return(nil)
m.mockRepositoryService.EXPECT().Login().Return(mockURI, nil)
m.mockRepositoryService.EXPECT().BuildAndPush(gomock.Any(), &dockerengine.BuildArguments{
URI: mockURI,
Dockerfile: "mockDockerfile",
Context: "mockContext",
Platform: "mockContainerPlatform",
Tags: []string{"latest", "v1.0"},
Labels: map[string]string{
"com.aws.copilot.image.builder": "copilot-cli",
"com.aws.copilot.image.container.name": "mockWkld",
},
}, gomock.Any()).Return("mockDigest", nil)
m.mockLabeledTermPrinter.EXPECT().IsDone().Return(true).AnyTimes()
m.mockLabeledTermPrinter.EXPECT().Print().AnyTimes()
m.mockAddons = nil
},
wantImages: map[string]ContainerImageIdentifier{
mockName: {
Digest: "mockDigest",
CustomTag: "v1.0",
GitShortCommitTag: "gitTag",
},
},
},
"build and push image with gitshortcommit successfully": {
inMockGitTag: "gitTag",
inDockerBuildArgs: map[string]*manifest.DockerBuildArgs{
"mockWkld": {
Dockerfile: aws.String("mockDockerfile"),
Context: aws.String("mockContext"),
},
},
mock: func(t *testing.T, m *deployMocks) {
m.mockdockerEngineRunChecker.EXPECT().CheckDockerEngineRunning().Return(nil)
m.mockRepositoryService.EXPECT().Login().Return(mockURI, nil)
m.mockRepositoryService.EXPECT().BuildAndPush(gomock.Any(), &dockerengine.BuildArguments{
URI: mockURI,
Dockerfile: "mockDockerfile",
Context: "mockContext",
Platform: "mockContainerPlatform",
Tags: []string{"latest", "gitTag"},
Labels: map[string]string{
"com.aws.copilot.image.builder": "copilot-cli",
"com.aws.copilot.image.container.name": "mockWkld",
},
}, gomock.Any()).Return("mockDigest", nil)
m.mockLabeledTermPrinter.EXPECT().IsDone().Return(true).AnyTimes()
m.mockLabeledTermPrinter.EXPECT().Print().AnyTimes()
m.mockAddons = nil
},
wantImages: map[string]ContainerImageIdentifier{
mockName: {
Digest: "mockDigest",
GitShortCommitTag: "gitTag",
},
},
},
"build and push sidecar container images only with git tag succesfully": {
inDockerBuildArgs: map[string]*manifest.DockerBuildArgs{
"nginx": {
Dockerfile: aws.String("sidecarMockDockerfile"),
Context: aws.String("sidecarMockContext"),
},
"logging": {
Dockerfile: aws.String("web/Dockerfile"),
Context: aws.String("Users/bowie"),
},
},
inMockGitTag: "gitTag",
mock: func(t *testing.T, m *deployMocks) {
m.mockdockerEngineRunChecker.EXPECT().CheckDockerEngineRunning().Return(nil)
m.mockRepositoryService.EXPECT().Login().Return(mockURI, nil)
m.mockRepositoryService.EXPECT().BuildAndPush(gomock.Any(), &dockerengine.BuildArguments{
URI: mockURI,
Dockerfile: "sidecarMockDockerfile",
Context: "sidecarMockContext",
Platform: "mockContainerPlatform",
Tags: []string{fmt.Sprintf("nginx-%s", "latest"), fmt.Sprintf("nginx-%s", "gitTag")},
Labels: map[string]string{
"com.aws.copilot.image.builder": "copilot-cli",
"com.aws.copilot.image.container.name": "nginx",
},
}, gomock.Any()).Return("sidecarMockDigest1", nil)
m.mockRepositoryService.EXPECT().BuildAndPush(gomock.Any(), &dockerengine.BuildArguments{
URI: mockURI,
Dockerfile: "web/Dockerfile",
Context: "Users/bowie",
Platform: "mockContainerPlatform",
Tags: []string{"logging-latest", fmt.Sprintf("logging-%s", "gitTag")},
Labels: map[string]string{
"com.aws.copilot.image.builder": "copilot-cli",
"com.aws.copilot.image.container.name": "logging",
},
}, gomock.Any()).Return("sidecarMockDigest2", nil)
m.mockLabeledTermPrinter.EXPECT().IsDone().Return(true).AnyTimes()
m.mockLabeledTermPrinter.EXPECT().Print().AnyTimes()
m.mockAddons = nil
},
wantImages: map[string]ContainerImageIdentifier{
"nginx": {
Digest: "sidecarMockDigest1",
GitShortCommitTag: "gitTag",
},
"logging": {
Digest: "sidecarMockDigest2",
GitShortCommitTag: "gitTag",
},
},
},
"should retrieve Load Balanced Web Service custom resource URLs": {
mock: func(t *testing.T, m *deployMocks) {
// Ignore addon uploads.
m.mockAddons = nil
// Ensure all custom resources were uploaded.
crs, err := customresource.LBWS(fakeTemplateFS())
require.NoError(t, err)
m.mockUploader.EXPECT().Upload(mockS3Bucket, gomock.Any(), gomock.Any()).DoAndReturn(func(_, key string, _ io.Reader) (url string, err error) {
for _, cr := range crs {
if strings.Contains(key, strings.ToLower(cr.Name())) {
return "", nil
}
}
return "", errors.New("did not match any custom resource")
}).Times(len(crs))
},
customResourcesFunc: func(fs template.Reader) ([]*customresource.CustomResource, error) {
return customresource.LBWS(fs)
},
mockServiceDeployer: func(deployer *workloadDeployer) artifactsUploader {
return &lbWebSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: deployer,
},
}
},
},
"should retrieve Backend Service custom resource URLs": {
mock: func(t *testing.T, m *deployMocks) {
// Ignore addon uploads.
m.mockAddons = nil
// Ensure all custom resources were uploaded.
crs, err := customresource.Backend(fakeTemplateFS())
require.NoError(t, err)
m.mockUploader.EXPECT().Upload(mockS3Bucket, gomock.Any(), gomock.Any()).DoAndReturn(func(_, key string, _ io.Reader) (url string, err error) {
for _, cr := range crs {
if strings.Contains(key, strings.ToLower(cr.Name())) {
return "", nil
}
}
return "", errors.New("did not match any custom resource")
}).Times(len(crs))
},
customResourcesFunc: func(fs template.Reader) ([]*customresource.CustomResource, error) {
return customresource.Backend(fs)
},
mockServiceDeployer: func(deployer *workloadDeployer) artifactsUploader {
return &backendSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: deployer,
},
}
},
},
"should retrieve Worker Service custom resource URLs": {
mock: func(t *testing.T, m *deployMocks) {
// Ignore addon uploads.
m.mockAddons = nil
// Ensure all custom resources were uploaded.
crs, err := customresource.Worker(fakeTemplateFS())
require.NoError(t, err)
m.mockUploader.EXPECT().Upload(mockS3Bucket, gomock.Any(), gomock.Any()).DoAndReturn(func(_, key string, _ io.Reader) (url string, err error) {
for _, cr := range crs {
if strings.Contains(key, strings.ToLower(cr.Name())) {
return "", nil
}
}
return "", errors.New("did not match any custom resource")
}).Times(len(crs))
},
customResourcesFunc: func(fs template.Reader) ([]*customresource.CustomResource, error) {
return customresource.Worker(fs)
},
mockServiceDeployer: func(deployer *workloadDeployer) artifactsUploader {
return &workerSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: deployer,
},
}
},
},
"should retrieve Request-Driven Web Service custom resource URLs": {
mock: func(t *testing.T, m *deployMocks) {
// Ignore addon uploads.
m.mockAddons = nil
// Ensure all custom resources were uploaded.
crs, err := customresource.RDWS(fakeTemplateFS())
require.NoError(t, err)
m.mockUploader.EXPECT().Upload(mockS3Bucket, gomock.Any(), gomock.Any()).DoAndReturn(func(_, key string, _ io.Reader) (url string, err error) {
for _, cr := range crs {
if strings.Contains(key, strings.ToLower(cr.Name())) {
return "", nil
}
}
return "", errors.New("did not match any custom resource")
}).Times(len(crs))
},
customResourcesFunc: func(fs template.Reader) ([]*customresource.CustomResource, error) {
return customresource.RDWS(fs)
},
mockServiceDeployer: func(deployer *workloadDeployer) artifactsUploader {
return &rdwsDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: deployer,
},
}
},
},
"should retrieve Scheduled Job custom resource URLs": {
mock: func(t *testing.T, m *deployMocks) {
// Ignore addon uploads.
m.mockAddons = nil
// Ensure all custom resources were uploaded.
crs, err := customresource.ScheduledJob(fakeTemplateFS())
require.NoError(t, err)
m.mockUploader.EXPECT().Upload(mockS3Bucket, gomock.Any(), gomock.Any()).DoAndReturn(func(_, key string, _ io.Reader) (url string, err error) {
for _, cr := range crs {
if strings.Contains(key, strings.ToLower(cr.Name())) {
return "", nil
}
}
return "", errors.New("did not match any custom resource")
}).Times(len(crs))
},
customResourcesFunc: func(fs template.Reader) ([]*customresource.CustomResource, error) {
return customresource.ScheduledJob(fs)
},
mockServiceDeployer: func(deployer *workloadDeployer) artifactsUploader {
return &jobDeployer{
workloadDeployer: deployer,
}
},
},
"error if fail to read env file": {
inEnvFile: mockEnvFile,
mock: func(t *testing.T, m *deployMocks) {},
wantErr: fmt.Errorf("read env file foo.env: open foo.env: file does not exist"),
},
"successfully share one env file between containers": {
customEnvFiles: map[string]string{"nginx": mockEnvFile, mockName: mockEnvFile},
inRegion: "us-west-2",
mock: func(t *testing.T, m *deployMocks) {
m.mockFileSystem.Create(filepath.Join(mockWorkspacePath, mockEnvFile))
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockEnvFilePath(mockEnvFile), gomock.Any()).Return(mockEnvFileS3URL, nil)
m.mockAddons.EXPECT().Package(gomock.Any()).Return(nil)
m.mockAddons.EXPECT().Template().Return("", nil)
m.mockUploader.EXPECT().Upload(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockAddonsS3URL, nil)
},
wantEnvFileARNs: map[string]string{"nginx": mockEnvFileS3ARN, mockName: mockEnvFileS3ARN},
wantAddonsURL: mockAddonsS3URL,
},
"upload multiple env files": {
customEnvFiles: map[string]string{"nginx": mockEnvFile, mockName: "bar.env"},
inRegion: "us-west-2",
mock: func(t *testing.T, m *deployMocks) {
m.mockFileSystem.Create(filepath.Join(mockWorkspacePath, mockEnvFile))
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockEnvFilePath(mockEnvFile), gomock.Any()).Return(mockEnvFileS3URL, nil)
m.mockFileSystem.Create(filepath.Join(mockWorkspacePath, "bar.env"))
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockEnvFilePath("bar.env"), gomock.Any()).Return(mockEnvFileS3URL2, nil)
m.mockAddons.EXPECT().Package(gomock.Any()).Return(nil)
m.mockAddons.EXPECT().Template().Return("", nil)
m.mockUploader.EXPECT().Upload(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockAddonsS3URL, nil)
},
wantEnvFileARNs: map[string]string{"nginx": mockEnvFileS3ARN, mockName: mockEnvFileS3ARN2},
wantAddonsURL: mockAddonsS3URL,
},
"success with no env files present but logging sidecar exists": {
inRegion: "us-west-2",
customEnvFiles: map[string]string{manifest.FirelensContainerName: "", mockName: ""},
mock: func(t *testing.T, m *deployMocks) {
m.mockAddons.EXPECT().Package(gomock.Any()).Return(nil)
m.mockAddons.EXPECT().Template().Return("", nil)
m.mockUploader.EXPECT().Upload(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockAddonsS3URL, nil)
},
wantEnvFileARNs: nil,
wantAddonsURL: mockAddonsS3URL,
},
"error if fail to put env file to s3 bucket": {
inEnvFile: mockEnvFile,
mock: func(t *testing.T, m *deployMocks) {
m.mockFileSystem.Create(filepath.Join(mockWorkspacePath, mockEnvFile))
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockEnvFilePath(mockEnvFile), gomock.Any()).
Return("", mockError)
},
wantErr: fmt.Errorf("put env file foo.env artifact to bucket mockBucket: some error"),
},
"error if fail to parse s3 url": {
inEnvFile: mockEnvFile,
mock: func(t *testing.T, m *deployMocks) {
m.mockFileSystem.Create(filepath.Join(mockWorkspacePath, mockEnvFile))
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockEnvFilePath(mockEnvFile), gomock.Any()).
Return(mockBadEnvFileS3URL, nil)
},
wantErr: fmt.Errorf("parse s3 url: cannot parse S3 URL badURL into bucket name and key"),
},
"error if fail to find the partition": {
inEnvFile: mockEnvFile,
inRegion: "sun-south-0",
mock: func(t *testing.T, m *deployMocks) {
m.mockFileSystem.Create(filepath.Join(mockWorkspacePath, mockEnvFile))
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockEnvFilePath(mockEnvFile), gomock.Any()).
Return(mockEnvFileS3URL, nil)
},
wantErr: fmt.Errorf("find the partition for region sun-south-0"),
},
"should push addons template to S3 bucket": {
inEnvFile: mockEnvFile,
inRegion: "us-west-2",
mock: func(t *testing.T, m *deployMocks) {
m.mockFileSystem.Create(filepath.Join(mockWorkspacePath, mockEnvFile))
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockEnvFilePath(mockEnvFile), gomock.Any()).
Return(mockEnvFileS3URL, nil)
m.mockAddons.EXPECT().Package(gomock.Any()).Return(nil)
m.mockAddons.EXPECT().Template().Return("some data", nil)
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockAddonPath, gomock.Any()).
Return(mockAddonsS3URL, nil)
},
wantAddonsURL: mockAddonsS3URL,
wantEnvFileARNs: mockEnvFilesOutput,
},
"should return error if fail to upload to S3 bucket": {
inRegion: "us-west-2",
mock: func(t *testing.T, m *deployMocks) {
m.mockAddons.EXPECT().Package(gomock.Any()).Return(nil)
m.mockAddons.EXPECT().Template().Return("some data", nil)
m.mockUploader.EXPECT().Upload(mockS3Bucket, mockAddonPath, gomock.Any()).
Return("", mockError)
},
wantErr: fmt.Errorf("put addons artifact to bucket mockBucket: some error"),
},
"should return empty url if the service doesn't have any addons and env files": {
mock: func(t *testing.T, m *deployMocks) {
m.mockAddons = nil
},
},
"should fail if packaging addons fails": {
mock: func(t *testing.T, m *deployMocks) {
m.mockAddons.EXPECT().Package(gomock.Any()).Return(mockError)
},
wantErr: fmt.Errorf("package addons: %w", mockError),
},
"should fail if addons template can't be created": {
mock: func(t *testing.T, m *deployMocks) {
m.mockAddons.EXPECT().Package(gomock.Any()).Return(nil)
m.mockAddons.EXPECT().Template().Return("", mockError)
},
wantErr: fmt.Errorf("retrieve addons template: %w", mockError),
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployMocks{
mockUploader: mocks.NewMockuploader(ctrl),
mockAddons: mocks.NewMockstackBuilder(ctrl),
mockRepositoryService: mocks.NewMockrepositoryService(ctrl),
mockFileSystem: afero.NewMemMapFs(),
mockLabeledTermPrinter: mocks.NewMocklabeledTermPrinter(ctrl),
mockdockerEngineRunChecker: mocks.NewMockdockerEngineRunChecker(ctrl),
}
tc.mock(t, m)
crFn := tc.customResourcesFunc
if crFn == nil {
crFn = func(fs template.Reader) ([]*customresource.CustomResource, error) {
return nil, nil
}
}
wkldDeployer := &workloadDeployer{
name: mockName,
env: &config.Environment{
Name: mockEnvName,
Region: tc.inRegion,
},
app: &config.Application{
Name: mockAppName,
},
resources: mockResources,
image: ContainerImageIdentifier{
CustomTag: tc.inMockUserTag,
GitShortCommitTag: tc.inMockGitTag,
},
workspacePath: mockWorkspacePath,
mft: &mockWorkloadMft{
workloadName: mockName,
fileName: tc.inEnvFile,
customEnvFiles: tc.customEnvFiles,
dockerBuildArgs: tc.inDockerBuildArgs,
},
fs: m.mockFileSystem,
s3Client: m.mockUploader,
docker: m.mockdockerEngineRunChecker,
repository: m.mockRepositoryService,
templateFS: fakeTemplateFS(),
overrider: new(override.Noop),
customResources: crFn,
labeledTermPrinter: func(fw syncbuffer.FileWriter, bufs []*syncbuffer.LabeledSyncBuffer, opts ...syncbuffer.LabeledTermPrinterOption) labeledTermPrinter {
return m.mockLabeledTermPrinter
},
}
if m.mockAddons != nil {
wkldDeployer.addons = m.mockAddons
}
var deployer artifactsUploader
deployer = &lbWebSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: wkldDeployer,
},
}
if tc.mockServiceDeployer != nil {
deployer = tc.mockServiceDeployer(wkldDeployer)
}
got, gotErr := deployer.UploadArtifacts()
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
} else {
require.NoError(t, gotErr)
require.Equal(t, tc.wantAddonsURL, got.AddonsURL)
require.Equal(t, tc.wantEnvFileARNs, got.EnvFileARNs)
require.Equal(t, tc.wantImages, got.ImageDigests)
}
})
}
}
func TestWorkloadDeployer_DeployWorkload(t *testing.T) {
mockError := errors.New("some error")
const (
mockAppName = "mockApp"
mockEnvName = "mockEnv"
mockName = "mockWkld"
mockS3Bucket = "mockBucket"
)
mockMultiAliases := []manifest.AdvancedAlias{
{
Alias: aws.String("example.com"),
},
{
Alias: aws.String("foobar.com"),
},
}
mockAlias := []manifest.AdvancedAlias{
{
Alias: aws.String("mockAlias"),
},
}
mockCertARNs := []string{"mockCertARN"}
mockCDNCertARN := "mockCDNCertARN"
mockResources := &stack.AppRegionalResources{
S3Bucket: mockS3Bucket,
}
mockNowTime := time.Unix(1494505750, 0)
mockBeforeTime := time.Unix(1494505743, 0)
mockAfterTime := time.Unix(1494505756, 0)
tests := map[string]struct {
inAliases manifest.Alias
inNLB manifest.NetworkLoadBalancerConfiguration
inApp *config.Application
inEnvironment *config.Environment
inForceDeploy bool
inDisableRollback bool
inRedirectToHTTPS *bool
// Cached variables.
inEnvironmentConfig func() *manifest.Environment
mock func(m *deployMocks)
wantErr error
}{
"fail to get service discovery endpoint": {
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("", mockError)
},
wantErr: fmt.Errorf("get service discovery endpoint: some error"),
},
"fail to get env version": {
inEnvironment: &config.Environment{
Name: mockEnvName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("", errors.New("some error"))
},
wantErr: fmt.Errorf(`get version of environment "mockEnv": some error`),
},
"fail if alias is not specified with env has imported certs": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Public.Certificates = mockCertARNs
return envConfig
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf(`validate ALB runtime configuration for "http": cannot deploy service mockWkld without "alias" to environment mockEnv with certificate imported`),
},
"fail if http redirect to https configured without custom domain": {
inRedirectToHTTPS: aws.Bool(true),
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
return &manifest.Environment{}
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf(`validate ALB runtime configuration for "http": cannot configure http to https redirect without having a domain associated with the app "mockApp" or importing any certificates in env "mockEnv"`),
},
"cannot specify alias hosted zone when no certificates are imported in the env": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-east-1",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
return envConfig
},
inAliases: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{
Alias: aws.String("example.com"),
HostedZone: aws.String("mockHostedZone1"),
},
{
Alias: aws.String("foobar.com"),
HostedZone: aws.String("mockHostedZone2"),
},
},
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("validate ALB runtime configuration for \"http\": cannot specify alias hosted zones [mockHostedZone1 mockHostedZone2] when no certificates are imported in environment \"mockEnv\""),
},
"cannot specify alias hosted zone when cdn is enabled": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-east-1",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Public.Certificates = mockCertARNs
envConfig.CDNConfig.Config.Certificate = aws.String(mockCDNCertARN)
return envConfig
},
inAliases: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{
Alias: aws.String("example.com"),
HostedZone: aws.String("mockHostedZone1"),
},
{
Alias: aws.String("foobar.com"),
HostedZone: aws.String("mockHostedZone2"),
},
},
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("validate ALB runtime configuration for \"http\": cannot specify alias hosted zones when cdn is enabled in environment \"mockEnv\""),
},
"fail to validate certificate aliases": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Public.Certificates = mockCertARNs
return envConfig
},
inAliases: manifest.Alias{
AdvancedAliases: mockMultiAliases,
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"example.com", "foobar.com"}, mockCertARNs).Return(mockError)
},
wantErr: fmt.Errorf("validate ALB runtime configuration for \"http\": validate aliases against the imported public ALB certificate for env mockEnv: some error"),
},
"fail to validate cdn certificate aliases": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-east-1",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Public.Certificates = mockCertARNs
envConfig.CDNConfig.Config.Certificate = aws.String(mockCDNCertARN)
return envConfig
},
inAliases: manifest.Alias{
AdvancedAliases: mockMultiAliases,
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"example.com", "foobar.com"}, mockCertARNs).Return(nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"example.com", "foobar.com"}, []string{mockCDNCertARN}).Return(mockError)
},
wantErr: fmt.Errorf("validate ALB runtime configuration for \"http\": validate aliases against the imported CDN certificate for env mockEnv: some error"),
},
"fail to get public CIDR blocks": {
inNLB: manifest.NetworkLoadBalancerConfiguration{
Listener: manifest.NetworkLoadBalancerListener{
Port: aws.String("443/tcp"),
},
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockPublicCIDRBlocksGetter.EXPECT().PublicCIDRBlocks().Return(nil, errors.New("some error"))
},
wantErr: fmt.Errorf("get public CIDR blocks information from the VPC of environment mockEnv: some error"),
},
"alias used while app is not associated with a domain": {
inAliases: manifest.Alias{AdvancedAliases: mockAlias},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: errors.New(`validate ALB runtime configuration for "http": cannot specify "alias" when application is not associated with a domain and env mockEnv doesn't import one or more certificates`),
},
"nlb alias used while app is not associated with a domain": {
inNLB: manifest.NetworkLoadBalancerConfiguration{
Listener: manifest.NetworkLoadBalancerListener{
Port: aws.String("80"),
},
Aliases: manifest.Alias{AdvancedAliases: mockAlias},
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: errors.New("cannot specify nlb.alias when application is not associated with a domain"),
},
"nlb alias used while env has imported certs": {
inAliases: manifest.Alias{AdvancedAliases: mockAlias},
inNLB: manifest.NetworkLoadBalancerConfiguration{
Listener: manifest.NetworkLoadBalancerListener{
Port: aws.String("80"),
},
Aliases: manifest.Alias{AdvancedAliases: mockAlias},
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Public.Certificates = mockCertARNs
return envConfig
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"mockAlias"}, mockCertARNs).Return(nil).Times(2)
},
wantErr: errors.New("cannot specify nlb.alias when env mockEnv imports one or more certificates"),
},
"fail to get app version": {
inAliases: manifest.Alias{AdvancedAliases: mockAlias},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("", mockError)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("validate ALB runtime configuration for \"http\": alias not supported: get version for app %q: %w", mockAppName, mockError),
},
"fail to enable https alias because of incompatible app version": {
inAliases: manifest.Alias{AdvancedAliases: mockAlias},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v0.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("validate ALB runtime configuration for \"http\": alias not supported: app version must be >= %s", version.AppTemplateMinAlias),
},
"fail to enable nlb alias because of incompatible app version": {
inNLB: manifest.NetworkLoadBalancerConfiguration{
Listener: manifest.NetworkLoadBalancerListener{
Port: aws.String("80"),
},
Aliases: manifest.Alias{AdvancedAliases: mockAlias},
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v0.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf("alias not supported: app version must be >= %s", version.AppTemplateMinAlias),
},
"fail to enable https alias because of invalid alias": {
inAliases: manifest.Alias{AdvancedAliases: []manifest.AdvancedAlias{
{Alias: aws.String("v1.v2.mockDomain")},
}},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf(`validate ALB runtime configuration for "http": validate 'alias': alias "v1.v2.mockDomain" is not supported in hosted zones managed by Copilot`),
},
"fail to enable nlb alias because of invalid alias": {
inNLB: manifest.NetworkLoadBalancerConfiguration{
Listener: manifest.NetworkLoadBalancerListener{
Port: aws.String("80"),
},
Aliases: manifest.Alias{AdvancedAliases: []manifest.AdvancedAlias{
{Alias: aws.String("v1.v2.mockDomain")},
}},
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil)
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
},
wantErr: fmt.Errorf(`validate 'nlb.alias': alias "v1.v2.mockDomain" is not supported in hosted zones managed by Copilot`),
},
"error if fail to deploy service": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).Return(errors.New("some error"))
},
wantErr: fmt.Errorf("deploy service: some error"),
},
"error if change set is empty but force flag is not set": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).Return(cloudformation.NewMockErrChangeSetEmpty())
},
wantErr: fmt.Errorf("deploy service: change set with name mockChangeSet for stack mockStack has no changes"),
},
"error if fail to get last update time when force an update": {
inForceDeploy: true,
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).
Return(nil)
m.mockServiceForceUpdater.EXPECT().LastUpdatedAt(mockAppName, mockEnvName, mockName).
Return(time.Time{}, mockError)
},
wantErr: fmt.Errorf("get the last updated deployment time for mockWkld: some error"),
},
"skip force updating when cmd run time is after the last update time": {
inForceDeploy: true,
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).
Return(nil)
m.mockServiceForceUpdater.EXPECT().LastUpdatedAt(mockAppName, mockEnvName, mockName).
Return(mockAfterTime, nil)
},
},
"error if fail to force an update": {
inForceDeploy: true,
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).
Return(cloudformation.NewMockErrChangeSetEmpty())
m.mockServiceForceUpdater.EXPECT().LastUpdatedAt(mockAppName, mockEnvName, mockName).
Return(mockBeforeTime, nil)
m.mockSpinner.EXPECT().Start(fmt.Sprintf(fmtForceUpdateSvcStart, mockName, mockEnvName))
m.mockServiceForceUpdater.EXPECT().ForceUpdateService(mockAppName, mockEnvName, mockName).Return(mockError)
m.mockSpinner.EXPECT().Stop(log.Serrorf(fmtForceUpdateSvcFailed, mockName, mockEnvName, mockError))
},
wantErr: fmt.Errorf("force an update for service mockWkld: some error"),
},
"error if fail to force an update because of timeout": {
inForceDeploy: true,
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).
Return(cloudformation.NewMockErrChangeSetEmpty())
m.mockServiceForceUpdater.EXPECT().LastUpdatedAt(mockAppName, mockEnvName, mockName).
Return(mockBeforeTime, nil)
m.mockSpinner.EXPECT().Start(fmt.Sprintf(fmtForceUpdateSvcStart, mockName, mockEnvName))
m.mockServiceForceUpdater.EXPECT().ForceUpdateService(mockAppName, mockEnvName, mockName).
Return(&ecs.ErrWaitServiceStableTimeout{})
m.mockSpinner.EXPECT().Stop(
log.Serror(fmt.Sprintf("%s Run %s to check for the fail reason.\n",
fmt.Sprintf(fmtForceUpdateSvcFailed, mockName, mockEnvName, &ecs.ErrWaitServiceStableTimeout{}),
color.HighlightCode(fmt.Sprintf("copilot svc status --name %s --env %s", mockName, mockEnvName)))))
},
wantErr: fmt.Errorf("force an update for service mockWkld: max retries 0 exceeded"),
},
"skip validating": {
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).Return(nil)
},
},
"success": {
inAliases: manifest.Alias{
AdvancedAliases: mockMultiAliases,
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Public.Certificates = mockCertARNs
return envConfig
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"example.com", "foobar.com"}, mockCertARNs).Return(nil).Times(2)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).Return(nil)
},
},
"success with http redirect disabled and alb certs imported": {
inRedirectToHTTPS: aws.Bool(false),
inAliases: manifest.Alias{
AdvancedAliases: mockMultiAliases,
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.HTTPConfig.Public.Certificates = mockCertARNs
return envConfig
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"example.com", "foobar.com"}, mockCertARNs).Return(nil).Times(2)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).Return(nil)
},
},
"success with only cdn certs imported": {
inAliases: manifest.Alias{
AdvancedAliases: mockMultiAliases,
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
envConfig.CDNConfig.Config.Certificate = aws.String(mockCDNCertARN)
return envConfig
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockValidator.EXPECT().ValidateCertAliases([]string{"example.com", "foobar.com"}, []string{mockCDNCertARN}).Return(nil).Times(2)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).Return(nil)
},
},
"success with http redirect disabled and domain imported": {
inRedirectToHTTPS: aws.Bool(false),
inAliases: manifest.Alias{
AdvancedAliases: []manifest.AdvancedAlias{
{
Alias: aws.String("hi.mockDomain"),
},
},
},
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inEnvironmentConfig: func() *manifest.Environment {
envConfig := &manifest.Environment{}
return envConfig
},
inApp: &config.Application{
Name: mockAppName,
Domain: "mockDomain",
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockAppVersionGetter.EXPECT().Version().Return("v1.0.0", nil).Times(2)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).Return(nil)
},
},
"success with force update": {
inForceDeploy: true,
inEnvironment: &config.Environment{
Name: mockEnvName,
Region: "us-west-2",
},
inApp: &config.Application{
Name: mockAppName,
},
mock: func(m *deployMocks) {
m.mockEndpointGetter.EXPECT().ServiceDiscoveryEndpoint().Return("mockApp.local", nil)
m.mockEnvVersionGetter.EXPECT().Version().Return("v1.42.0", nil)
m.mockServiceDeployer.EXPECT().DeployService(gomock.Any(), "mockBucket", gomock.Any()).
Return(cloudformation.NewMockErrChangeSetEmpty())
m.mockServiceForceUpdater.EXPECT().LastUpdatedAt(mockAppName, mockEnvName, mockName).
Return(mockBeforeTime, nil)
m.mockSpinner.EXPECT().Start(fmt.Sprintf(fmtForceUpdateSvcStart, mockName, mockEnvName))
m.mockServiceForceUpdater.EXPECT().ForceUpdateService(mockAppName, mockEnvName, mockName).Return(nil)
m.mockSpinner.EXPECT().Stop(log.Ssuccessf(fmtForceUpdateSvcComplete, mockName, mockEnvName))
},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployMocks{
mockAppVersionGetter: mocks.NewMockversionGetter(ctrl),
mockEnvVersionGetter: mocks.NewMockversionGetter(ctrl),
mockEndpointGetter: mocks.NewMockendpointGetter(ctrl),
mockServiceDeployer: mocks.NewMockserviceDeployer(ctrl),
mockServiceForceUpdater: mocks.NewMockserviceForceUpdater(ctrl),
mockSpinner: mocks.NewMockspinner(ctrl),
mockPublicCIDRBlocksGetter: mocks.NewMockpublicCIDRBlocksGetter(ctrl),
mockValidator: mocks.NewMockaliasCertValidator(ctrl),
}
tc.mock(m)
if tc.inEnvironmentConfig == nil {
tc.inEnvironmentConfig = func() *manifest.Environment {
return &manifest.Environment{}
}
}
deployer := lbWebSvcDeployer{
svcDeployer: &svcDeployer{
workloadDeployer: &workloadDeployer{
name: mockName,
app: tc.inApp,
env: tc.inEnvironment,
envConfig: tc.inEnvironmentConfig(),
resources: mockResources,
deployer: m.mockServiceDeployer,
endpointGetter: m.mockEndpointGetter,
spinner: m.mockSpinner,
envVersionGetter: m.mockEnvVersionGetter,
overrider: new(override.Noop),
},
newSvcUpdater: func(f func(*session.Session) serviceForceUpdater) serviceForceUpdater {
return m.mockServiceForceUpdater
},
now: func() time.Time {
return mockNowTime
},
},
appVersionGetter: m.mockAppVersionGetter,
publicCIDRBlocksGetter: m.mockPublicCIDRBlocksGetter,
newAliasCertValidator: func(region *string) aliasCertValidator {
return m.mockValidator
},
lbMft: &manifest.LoadBalancedWebService{
Workload: manifest.Workload{
Name: aws.String(mockName),
},
LoadBalancedWebServiceConfig: manifest.LoadBalancedWebServiceConfig{
ImageConfig: manifest.ImageWithPortAndHealthcheck{
ImageWithPort: manifest.ImageWithPort{
Image: manifest.Image{
ImageLocationOrBuild: manifest.ImageLocationOrBuild{
Build: manifest.BuildArgsOrString{BuildString: aws.String("/Dockerfile")},
},
},
Port: aws.Uint16(80),
},
},
HTTPOrBool: manifest.HTTPOrBool{
HTTP: manifest.HTTP{
Main: manifest.RoutingRule{
Path: aws.String("/"),
Alias: tc.inAliases,
RedirectToHTTPS: tc.inRedirectToHTTPS,
},
AdditionalRoutingRules: []manifest.RoutingRule{
{
Path: aws.String("/admin"),
Alias: tc.inAliases,
RedirectToHTTPS: tc.inRedirectToHTTPS,
},
},
},
},
NLBConfig: tc.inNLB,
},
},
newStack: func() cloudformation0.StackConfiguration {
return new(stubCloudFormationStack)
},
}
_, gotErr := deployer.DeployWorkload(&DeployWorkloadInput{
Options: Options{
ForceNewUpdate: tc.inForceDeploy,
DisableRollback: tc.inDisableRollback,
},
})
if tc.wantErr != nil {
require.EqualError(t, gotErr, tc.wantErr.Error())
} else {
require.NoError(t, gotErr)
}
})
}
}
func TestUploadArtifacts(t *testing.T) {
d := &workloadDeployer{}
errFunc := func(out *UploadArtifactsOutput) error {
return errors.New("test error")
}
noErrFunc := func(out *UploadArtifactsOutput) error {
out.AddonsURL = "an addons url"
return nil
}
out, err := d.uploadArtifacts(noErrFunc, errFunc)
require.EqualError(t, err, "test error")
require.Nil(t, out)
out, err = d.uploadArtifacts(errFunc, noErrFunc)
require.EqualError(t, err, "test error")
require.Nil(t, out)
out, err = d.uploadArtifacts(noErrFunc)
require.NoError(t, err)
require.Equal(t, &UploadArtifactsOutput{AddonsURL: "an addons url"}, out)
}
type deployDiffMocks struct {
mockDeployedTmplGetter *mocks.MockdeployedTemplateGetter
}
func TestWorkloadDeployer_DeployDiff(t *testing.T) {
testCases := map[string]struct {
inTemplate string
setUpMocks func(m *deployDiffMocks)
wanted string
checkErr func(t *testing.T, gotErr error)
}{
"error getting the deployed template": {
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.
EXPECT().Template(gomock.Eq(stack.NameForWorkload("mockApp", "mockEnv", "mockSvc"))).
Return("", errors.New("some error"))
},
checkErr: func(t *testing.T, gotErr error) {
require.EqualError(t, gotErr, `retrieve the deployed template for "mockSvc": some error`)
},
},
"error parsing the diff against the deployed template": {
inTemplate: `!!!???what a weird template`,
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.EXPECT().
Template(gomock.Eq(stack.NameForWorkload("mockApp", "mockEnv", "mockSvc"))).
Return("wow such template", nil)
},
checkErr: func(t *testing.T, gotErr error) {
require.ErrorContains(t, gotErr, `parse the diff against the deployed "mockSvc" in environment "mockEnv"`)
},
},
"get the correct diff": {
inTemplate: `peace: and love`,
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.EXPECT().
Template(gomock.Eq(stack.NameForWorkload("mockApp", "mockEnv", "mockSvc"))).
Return("peace: und Liebe", nil)
},
wanted: `~ peace: und Liebe -> and love
`,
},
"get the correct diff when there is no deployed diff": {
inTemplate: `peace: and love`,
setUpMocks: func(m *deployDiffMocks) {
m.mockDeployedTmplGetter.EXPECT().
Template(gomock.Eq(stack.NameForWorkload("mockApp", "mockEnv", "mockSvc"))).
Return("", &cloudformation.ErrStackNotFound{})
},
wanted: `+ peace: and love
`,
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &deployDiffMocks{
mockDeployedTmplGetter: mocks.NewMockdeployedTemplateGetter(ctrl),
}
tc.setUpMocks(m)
deployer := workloadDeployer{
name: "mockSvc",
app: &config.Application{
Name: "mockApp",
},
env: &config.Environment{
Name: "mockEnv",
},
tmplGetter: m.mockDeployedTmplGetter,
}
got, gotErr := deployer.DeployDiff(tc.inTemplate)
if tc.checkErr != nil {
tc.checkErr(t, gotErr)
} else {
require.NoError(t, gotErr)
require.Equal(t, tc.wanted, got)
}
})
}
}
| 1,557 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/backend.go
// Package mocks is a generated GoMock package.
package mocks
| 6 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/env.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
cloudformation "github.com/aws/aws-sdk-go/service/cloudformation"
cloudformation0 "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
elbv2 "github.com/aws/copilot-cli/internal/pkg/aws/elbv2"
config "github.com/aws/copilot-cli/internal/pkg/config"
cloudformation1 "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
stack "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
stack0 "github.com/aws/copilot-cli/internal/pkg/describe/stack"
gomock "github.com/golang/mock/gomock"
)
// MockWorkspaceAddonsReaderPathGetter is a mock of WorkspaceAddonsReaderPathGetter interface.
type MockWorkspaceAddonsReaderPathGetter struct {
ctrl *gomock.Controller
recorder *MockWorkspaceAddonsReaderPathGetterMockRecorder
}
// MockWorkspaceAddonsReaderPathGetterMockRecorder is the mock recorder for MockWorkspaceAddonsReaderPathGetter.
type MockWorkspaceAddonsReaderPathGetterMockRecorder struct {
mock *MockWorkspaceAddonsReaderPathGetter
}
// NewMockWorkspaceAddonsReaderPathGetter creates a new mock instance.
func NewMockWorkspaceAddonsReaderPathGetter(ctrl *gomock.Controller) *MockWorkspaceAddonsReaderPathGetter {
mock := &MockWorkspaceAddonsReaderPathGetter{ctrl: ctrl}
mock.recorder = &MockWorkspaceAddonsReaderPathGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWorkspaceAddonsReaderPathGetter) EXPECT() *MockWorkspaceAddonsReaderPathGetterMockRecorder {
return m.recorder
}
// EnvAddonFileAbsPath mocks base method.
func (m *MockWorkspaceAddonsReaderPathGetter) EnvAddonFileAbsPath(fName string) string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EnvAddonFileAbsPath", fName)
ret0, _ := ret[0].(string)
return ret0
}
// EnvAddonFileAbsPath indicates an expected call of EnvAddonFileAbsPath.
func (mr *MockWorkspaceAddonsReaderPathGetterMockRecorder) EnvAddonFileAbsPath(fName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnvAddonFileAbsPath", reflect.TypeOf((*MockWorkspaceAddonsReaderPathGetter)(nil).EnvAddonFileAbsPath), fName)
}
// EnvAddonsAbsPath mocks base method.
func (m *MockWorkspaceAddonsReaderPathGetter) EnvAddonsAbsPath() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EnvAddonsAbsPath")
ret0, _ := ret[0].(string)
return ret0
}
// EnvAddonsAbsPath indicates an expected call of EnvAddonsAbsPath.
func (mr *MockWorkspaceAddonsReaderPathGetterMockRecorder) EnvAddonsAbsPath() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnvAddonsAbsPath", reflect.TypeOf((*MockWorkspaceAddonsReaderPathGetter)(nil).EnvAddonsAbsPath))
}
// ListFiles mocks base method.
func (m *MockWorkspaceAddonsReaderPathGetter) ListFiles(dirPath string) ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListFiles", dirPath)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListFiles indicates an expected call of ListFiles.
func (mr *MockWorkspaceAddonsReaderPathGetterMockRecorder) ListFiles(dirPath interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFiles", reflect.TypeOf((*MockWorkspaceAddonsReaderPathGetter)(nil).ListFiles), dirPath)
}
// Path mocks base method.
func (m *MockWorkspaceAddonsReaderPathGetter) Path() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Path")
ret0, _ := ret[0].(string)
return ret0
}
// Path indicates an expected call of Path.
func (mr *MockWorkspaceAddonsReaderPathGetterMockRecorder) Path() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockWorkspaceAddonsReaderPathGetter)(nil).Path))
}
// ReadFile mocks base method.
func (m *MockWorkspaceAddonsReaderPathGetter) ReadFile(fPath string) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReadFile", fPath)
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReadFile indicates an expected call of ReadFile.
func (mr *MockWorkspaceAddonsReaderPathGetterMockRecorder) ReadFile(fPath interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFile", reflect.TypeOf((*MockWorkspaceAddonsReaderPathGetter)(nil).ReadFile), fPath)
}
// WorkloadAddonFileAbsPath mocks base method.
func (m *MockWorkspaceAddonsReaderPathGetter) WorkloadAddonFileAbsPath(wkldName, fName string) string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WorkloadAddonFileAbsPath", wkldName, fName)
ret0, _ := ret[0].(string)
return ret0
}
// WorkloadAddonFileAbsPath indicates an expected call of WorkloadAddonFileAbsPath.
func (mr *MockWorkspaceAddonsReaderPathGetterMockRecorder) WorkloadAddonFileAbsPath(wkldName, fName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkloadAddonFileAbsPath", reflect.TypeOf((*MockWorkspaceAddonsReaderPathGetter)(nil).WorkloadAddonFileAbsPath), wkldName, fName)
}
// WorkloadAddonsAbsPath mocks base method.
func (m *MockWorkspaceAddonsReaderPathGetter) WorkloadAddonsAbsPath(name string) string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "WorkloadAddonsAbsPath", name)
ret0, _ := ret[0].(string)
return ret0
}
// WorkloadAddonsAbsPath indicates an expected call of WorkloadAddonsAbsPath.
func (mr *MockWorkspaceAddonsReaderPathGetterMockRecorder) WorkloadAddonsAbsPath(name interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkloadAddonsAbsPath", reflect.TypeOf((*MockWorkspaceAddonsReaderPathGetter)(nil).WorkloadAddonsAbsPath), name)
}
// MockappResourcesGetter is a mock of appResourcesGetter interface.
type MockappResourcesGetter struct {
ctrl *gomock.Controller
recorder *MockappResourcesGetterMockRecorder
}
// MockappResourcesGetterMockRecorder is the mock recorder for MockappResourcesGetter.
type MockappResourcesGetterMockRecorder struct {
mock *MockappResourcesGetter
}
// NewMockappResourcesGetter creates a new mock instance.
func NewMockappResourcesGetter(ctrl *gomock.Controller) *MockappResourcesGetter {
mock := &MockappResourcesGetter{ctrl: ctrl}
mock.recorder = &MockappResourcesGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockappResourcesGetter) EXPECT() *MockappResourcesGetterMockRecorder {
return m.recorder
}
// GetAppResourcesByRegion mocks base method.
func (m *MockappResourcesGetter) GetAppResourcesByRegion(app *config.Application, region string) (*stack.AppRegionalResources, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAppResourcesByRegion", app, region)
ret0, _ := ret[0].(*stack.AppRegionalResources)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetAppResourcesByRegion indicates an expected call of GetAppResourcesByRegion.
func (mr *MockappResourcesGetterMockRecorder) GetAppResourcesByRegion(app, region interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAppResourcesByRegion", reflect.TypeOf((*MockappResourcesGetter)(nil).GetAppResourcesByRegion), app, region)
}
// MockenvironmentDeployer is a mock of environmentDeployer interface.
type MockenvironmentDeployer struct {
ctrl *gomock.Controller
recorder *MockenvironmentDeployerMockRecorder
}
// MockenvironmentDeployerMockRecorder is the mock recorder for MockenvironmentDeployer.
type MockenvironmentDeployerMockRecorder struct {
mock *MockenvironmentDeployer
}
// NewMockenvironmentDeployer creates a new mock instance.
func NewMockenvironmentDeployer(ctrl *gomock.Controller) *MockenvironmentDeployer {
mock := &MockenvironmentDeployer{ctrl: ctrl}
mock.recorder = &MockenvironmentDeployerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockenvironmentDeployer) EXPECT() *MockenvironmentDeployerMockRecorder {
return m.recorder
}
// DeployedEnvironmentParameters mocks base method.
func (m *MockenvironmentDeployer) DeployedEnvironmentParameters(app, env string) ([]*cloudformation.Parameter, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeployedEnvironmentParameters", app, env)
ret0, _ := ret[0].([]*cloudformation.Parameter)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeployedEnvironmentParameters indicates an expected call of DeployedEnvironmentParameters.
func (mr *MockenvironmentDeployerMockRecorder) DeployedEnvironmentParameters(app, env interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeployedEnvironmentParameters", reflect.TypeOf((*MockenvironmentDeployer)(nil).DeployedEnvironmentParameters), app, env)
}
// ForceUpdateOutputID mocks base method.
func (m *MockenvironmentDeployer) ForceUpdateOutputID(app, env string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ForceUpdateOutputID", app, env)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ForceUpdateOutputID indicates an expected call of ForceUpdateOutputID.
func (mr *MockenvironmentDeployerMockRecorder) ForceUpdateOutputID(app, env interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUpdateOutputID", reflect.TypeOf((*MockenvironmentDeployer)(nil).ForceUpdateOutputID), app, env)
}
// UpdateAndRenderEnvironment mocks base method.
func (m *MockenvironmentDeployer) UpdateAndRenderEnvironment(conf cloudformation1.StackConfiguration, bucketARN string, opts ...cloudformation0.StackOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{conf, bucketARN}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "UpdateAndRenderEnvironment", varargs...)
ret0, _ := ret[0].(error)
return ret0
}
// UpdateAndRenderEnvironment indicates an expected call of UpdateAndRenderEnvironment.
func (mr *MockenvironmentDeployerMockRecorder) UpdateAndRenderEnvironment(conf, bucketARN interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{conf, bucketARN}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAndRenderEnvironment", reflect.TypeOf((*MockenvironmentDeployer)(nil).UpdateAndRenderEnvironment), varargs...)
}
// Mockpatcher is a mock of patcher interface.
type Mockpatcher struct {
ctrl *gomock.Controller
recorder *MockpatcherMockRecorder
}
// MockpatcherMockRecorder is the mock recorder for Mockpatcher.
type MockpatcherMockRecorder struct {
mock *Mockpatcher
}
// NewMockpatcher creates a new mock instance.
func NewMockpatcher(ctrl *gomock.Controller) *Mockpatcher {
mock := &Mockpatcher{ctrl: ctrl}
mock.recorder = &MockpatcherMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockpatcher) EXPECT() *MockpatcherMockRecorder {
return m.recorder
}
// EnsureManagerRoleIsAllowedToUpload mocks base method.
func (m *Mockpatcher) EnsureManagerRoleIsAllowedToUpload(bucketName string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EnsureManagerRoleIsAllowedToUpload", bucketName)
ret0, _ := ret[0].(error)
return ret0
}
// EnsureManagerRoleIsAllowedToUpload indicates an expected call of EnsureManagerRoleIsAllowedToUpload.
func (mr *MockpatcherMockRecorder) EnsureManagerRoleIsAllowedToUpload(bucketName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureManagerRoleIsAllowedToUpload", reflect.TypeOf((*Mockpatcher)(nil).EnsureManagerRoleIsAllowedToUpload), bucketName)
}
// MockprefixListGetter is a mock of prefixListGetter interface.
type MockprefixListGetter struct {
ctrl *gomock.Controller
recorder *MockprefixListGetterMockRecorder
}
// MockprefixListGetterMockRecorder is the mock recorder for MockprefixListGetter.
type MockprefixListGetterMockRecorder struct {
mock *MockprefixListGetter
}
// NewMockprefixListGetter creates a new mock instance.
func NewMockprefixListGetter(ctrl *gomock.Controller) *MockprefixListGetter {
mock := &MockprefixListGetter{ctrl: ctrl}
mock.recorder = &MockprefixListGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockprefixListGetter) EXPECT() *MockprefixListGetterMockRecorder {
return m.recorder
}
// CloudFrontManagedPrefixListID mocks base method.
func (m *MockprefixListGetter) CloudFrontManagedPrefixListID() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloudFrontManagedPrefixListID")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CloudFrontManagedPrefixListID indicates an expected call of CloudFrontManagedPrefixListID.
func (mr *MockprefixListGetterMockRecorder) CloudFrontManagedPrefixListID() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloudFrontManagedPrefixListID", reflect.TypeOf((*MockprefixListGetter)(nil).CloudFrontManagedPrefixListID))
}
// MockenvDescriber is a mock of envDescriber interface.
type MockenvDescriber struct {
ctrl *gomock.Controller
recorder *MockenvDescriberMockRecorder
}
// MockenvDescriberMockRecorder is the mock recorder for MockenvDescriber.
type MockenvDescriberMockRecorder struct {
mock *MockenvDescriber
}
// NewMockenvDescriber creates a new mock instance.
func NewMockenvDescriber(ctrl *gomock.Controller) *MockenvDescriber {
mock := &MockenvDescriber{ctrl: ctrl}
mock.recorder = &MockenvDescriberMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockenvDescriber) EXPECT() *MockenvDescriberMockRecorder {
return m.recorder
}
// Params mocks base method.
func (m *MockenvDescriber) Params() (map[string]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Params")
ret0, _ := ret[0].(map[string]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Params indicates an expected call of Params.
func (mr *MockenvDescriberMockRecorder) Params() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Params", reflect.TypeOf((*MockenvDescriber)(nil).Params))
}
// ValidateCFServiceDomainAliases mocks base method.
func (m *MockenvDescriber) ValidateCFServiceDomainAliases() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateCFServiceDomainAliases")
ret0, _ := ret[0].(error)
return ret0
}
// ValidateCFServiceDomainAliases indicates an expected call of ValidateCFServiceDomainAliases.
func (mr *MockenvDescriberMockRecorder) ValidateCFServiceDomainAliases() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateCFServiceDomainAliases", reflect.TypeOf((*MockenvDescriber)(nil).ValidateCFServiceDomainAliases))
}
// MocklbDescriber is a mock of lbDescriber interface.
type MocklbDescriber struct {
ctrl *gomock.Controller
recorder *MocklbDescriberMockRecorder
}
// MocklbDescriberMockRecorder is the mock recorder for MocklbDescriber.
type MocklbDescriberMockRecorder struct {
mock *MocklbDescriber
}
// NewMocklbDescriber creates a new mock instance.
func NewMocklbDescriber(ctrl *gomock.Controller) *MocklbDescriber {
mock := &MocklbDescriber{ctrl: ctrl}
mock.recorder = &MocklbDescriberMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MocklbDescriber) EXPECT() *MocklbDescriberMockRecorder {
return m.recorder
}
// DescribeRule mocks base method.
func (m *MocklbDescriber) DescribeRule(arg0 context.Context, arg1 string) (elbv2.Rule, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DescribeRule", arg0, arg1)
ret0, _ := ret[0].(elbv2.Rule)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DescribeRule indicates an expected call of DescribeRule.
func (mr *MocklbDescriberMockRecorder) DescribeRule(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRule", reflect.TypeOf((*MocklbDescriber)(nil).DescribeRule), arg0, arg1)
}
// MockstackDescriber is a mock of stackDescriber interface.
type MockstackDescriber struct {
ctrl *gomock.Controller
recorder *MockstackDescriberMockRecorder
}
// MockstackDescriberMockRecorder is the mock recorder for MockstackDescriber.
type MockstackDescriberMockRecorder struct {
mock *MockstackDescriber
}
// NewMockstackDescriber creates a new mock instance.
func NewMockstackDescriber(ctrl *gomock.Controller) *MockstackDescriber {
mock := &MockstackDescriber{ctrl: ctrl}
mock.recorder = &MockstackDescriberMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockstackDescriber) EXPECT() *MockstackDescriberMockRecorder {
return m.recorder
}
// Resources mocks base method.
func (m *MockstackDescriber) Resources() ([]*stack0.Resource, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Resources")
ret0, _ := ret[0].([]*stack0.Resource)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Resources indicates an expected call of Resources.
func (mr *MockstackDescriberMockRecorder) Resources() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resources", reflect.TypeOf((*MockstackDescriber)(nil).Resources))
}
| 456 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/job.go
// Package mocks is a generated GoMock package.
package mocks
| 6 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/lbws.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
gomock "github.com/golang/mock/gomock"
)
// MockpublicCIDRBlocksGetter is a mock of publicCIDRBlocksGetter interface.
type MockpublicCIDRBlocksGetter struct {
ctrl *gomock.Controller
recorder *MockpublicCIDRBlocksGetterMockRecorder
}
// MockpublicCIDRBlocksGetterMockRecorder is the mock recorder for MockpublicCIDRBlocksGetter.
type MockpublicCIDRBlocksGetterMockRecorder struct {
mock *MockpublicCIDRBlocksGetter
}
// NewMockpublicCIDRBlocksGetter creates a new mock instance.
func NewMockpublicCIDRBlocksGetter(ctrl *gomock.Controller) *MockpublicCIDRBlocksGetter {
mock := &MockpublicCIDRBlocksGetter{ctrl: ctrl}
mock.recorder = &MockpublicCIDRBlocksGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockpublicCIDRBlocksGetter) EXPECT() *MockpublicCIDRBlocksGetterMockRecorder {
return m.recorder
}
// PublicCIDRBlocks mocks base method.
func (m *MockpublicCIDRBlocksGetter) PublicCIDRBlocks() ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PublicCIDRBlocks")
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// PublicCIDRBlocks indicates an expected call of PublicCIDRBlocks.
func (mr *MockpublicCIDRBlocksGetterMockRecorder) PublicCIDRBlocks() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicCIDRBlocks", reflect.TypeOf((*MockpublicCIDRBlocksGetter)(nil).PublicCIDRBlocks))
}
| 50 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/rdws.go
// Package mocks is a generated GoMock package.
package mocks
| 6 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/static_site.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
manifest "github.com/aws/copilot-cli/internal/pkg/manifest"
gomock "github.com/golang/mock/gomock"
)
// MockfileUploader is a mock of fileUploader interface.
type MockfileUploader struct {
ctrl *gomock.Controller
recorder *MockfileUploaderMockRecorder
}
// MockfileUploaderMockRecorder is the mock recorder for MockfileUploader.
type MockfileUploaderMockRecorder struct {
mock *MockfileUploader
}
// NewMockfileUploader creates a new mock instance.
func NewMockfileUploader(ctrl *gomock.Controller) *MockfileUploader {
mock := &MockfileUploader{ctrl: ctrl}
mock.recorder = &MockfileUploaderMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockfileUploader) EXPECT() *MockfileUploaderMockRecorder {
return m.recorder
}
// UploadFiles mocks base method.
func (m *MockfileUploader) UploadFiles(files []manifest.FileUpload) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UploadFiles", files)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UploadFiles indicates an expected call of UploadFiles.
func (mr *MockfileUploaderMockRecorder) UploadFiles(files interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadFiles", reflect.TypeOf((*MockfileUploader)(nil).UploadFiles), files)
}
| 51 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/svc.go
// Package mocks is a generated GoMock package.
package mocks
import (
io "io"
reflect "reflect"
time "time"
gomock "github.com/golang/mock/gomock"
)
// Mockuploader is a mock of uploader interface.
type Mockuploader struct {
ctrl *gomock.Controller
recorder *MockuploaderMockRecorder
}
// MockuploaderMockRecorder is the mock recorder for Mockuploader.
type MockuploaderMockRecorder struct {
mock *Mockuploader
}
// NewMockuploader creates a new mock instance.
func NewMockuploader(ctrl *gomock.Controller) *Mockuploader {
mock := &Mockuploader{ctrl: ctrl}
mock.recorder = &MockuploaderMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockuploader) EXPECT() *MockuploaderMockRecorder {
return m.recorder
}
// Upload mocks base method.
func (m *Mockuploader) Upload(bucket, key string, data io.Reader) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Upload", bucket, key, data)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Upload indicates an expected call of Upload.
func (mr *MockuploaderMockRecorder) Upload(bucket, key, data interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*Mockuploader)(nil).Upload), bucket, key, data)
}
// MockversionGetter is a mock of versionGetter interface.
type MockversionGetter struct {
ctrl *gomock.Controller
recorder *MockversionGetterMockRecorder
}
// MockversionGetterMockRecorder is the mock recorder for MockversionGetter.
type MockversionGetterMockRecorder struct {
mock *MockversionGetter
}
// NewMockversionGetter creates a new mock instance.
func NewMockversionGetter(ctrl *gomock.Controller) *MockversionGetter {
mock := &MockversionGetter{ctrl: ctrl}
mock.recorder = &MockversionGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockversionGetter) EXPECT() *MockversionGetterMockRecorder {
return m.recorder
}
// Version mocks base method.
func (m *MockversionGetter) Version() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Version")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Version indicates an expected call of Version.
func (mr *MockversionGetterMockRecorder) Version() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockversionGetter)(nil).Version))
}
// MockserviceForceUpdater is a mock of serviceForceUpdater interface.
type MockserviceForceUpdater struct {
ctrl *gomock.Controller
recorder *MockserviceForceUpdaterMockRecorder
}
// MockserviceForceUpdaterMockRecorder is the mock recorder for MockserviceForceUpdater.
type MockserviceForceUpdaterMockRecorder struct {
mock *MockserviceForceUpdater
}
// NewMockserviceForceUpdater creates a new mock instance.
func NewMockserviceForceUpdater(ctrl *gomock.Controller) *MockserviceForceUpdater {
mock := &MockserviceForceUpdater{ctrl: ctrl}
mock.recorder = &MockserviceForceUpdaterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockserviceForceUpdater) EXPECT() *MockserviceForceUpdaterMockRecorder {
return m.recorder
}
// ForceUpdateService mocks base method.
func (m *MockserviceForceUpdater) ForceUpdateService(app, env, svc string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ForceUpdateService", app, env, svc)
ret0, _ := ret[0].(error)
return ret0
}
// ForceUpdateService indicates an expected call of ForceUpdateService.
func (mr *MockserviceForceUpdaterMockRecorder) ForceUpdateService(app, env, svc interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUpdateService", reflect.TypeOf((*MockserviceForceUpdater)(nil).ForceUpdateService), app, env, svc)
}
// LastUpdatedAt mocks base method.
func (m *MockserviceForceUpdater) LastUpdatedAt(app, env, svc string) (time.Time, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LastUpdatedAt", app, env, svc)
ret0, _ := ret[0].(time.Time)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// LastUpdatedAt indicates an expected call of LastUpdatedAt.
func (mr *MockserviceForceUpdaterMockRecorder) LastUpdatedAt(app, env, svc interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastUpdatedAt", reflect.TypeOf((*MockserviceForceUpdater)(nil).LastUpdatedAt), app, env, svc)
}
// MockaliasCertValidator is a mock of aliasCertValidator interface.
type MockaliasCertValidator struct {
ctrl *gomock.Controller
recorder *MockaliasCertValidatorMockRecorder
}
// MockaliasCertValidatorMockRecorder is the mock recorder for MockaliasCertValidator.
type MockaliasCertValidatorMockRecorder struct {
mock *MockaliasCertValidator
}
// NewMockaliasCertValidator creates a new mock instance.
func NewMockaliasCertValidator(ctrl *gomock.Controller) *MockaliasCertValidator {
mock := &MockaliasCertValidator{ctrl: ctrl}
mock.recorder = &MockaliasCertValidatorMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockaliasCertValidator) EXPECT() *MockaliasCertValidatorMockRecorder {
return m.recorder
}
// ValidateCertAliases mocks base method.
func (m *MockaliasCertValidator) ValidateCertAliases(aliases, certs []string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ValidateCertAliases", aliases, certs)
ret0, _ := ret[0].(error)
return ret0
}
// ValidateCertAliases indicates an expected call of ValidateCertAliases.
func (mr *MockaliasCertValidatorMockRecorder) ValidateCertAliases(aliases, certs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateCertAliases", reflect.TypeOf((*MockaliasCertValidator)(nil).ValidateCertAliases), aliases, certs)
}
| 179 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/worker.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
deploy "github.com/aws/copilot-cli/internal/pkg/deploy"
gomock "github.com/golang/mock/gomock"
)
// MocksnsTopicsLister is a mock of snsTopicsLister interface.
type MocksnsTopicsLister struct {
ctrl *gomock.Controller
recorder *MocksnsTopicsListerMockRecorder
}
// MocksnsTopicsListerMockRecorder is the mock recorder for MocksnsTopicsLister.
type MocksnsTopicsListerMockRecorder struct {
mock *MocksnsTopicsLister
}
// NewMocksnsTopicsLister creates a new mock instance.
func NewMocksnsTopicsLister(ctrl *gomock.Controller) *MocksnsTopicsLister {
mock := &MocksnsTopicsLister{ctrl: ctrl}
mock.recorder = &MocksnsTopicsListerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MocksnsTopicsLister) EXPECT() *MocksnsTopicsListerMockRecorder {
return m.recorder
}
// ListSNSTopics mocks base method.
func (m *MocksnsTopicsLister) ListSNSTopics(appName, envName string) ([]deploy.Topic, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListSNSTopics", appName, envName)
ret0, _ := ret[0].([]deploy.Topic)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListSNSTopics indicates an expected call of ListSNSTopics.
func (mr *MocksnsTopicsListerMockRecorder) ListSNSTopics(appName, envName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSNSTopics", reflect.TypeOf((*MocksnsTopicsLister)(nil).ListSNSTopics), appName, envName)
}
| 51 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/workload.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
io "io"
reflect "reflect"
addon "github.com/aws/copilot-cli/internal/pkg/addon"
cloudformation "github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
cloudformation0 "github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation"
dockerengine "github.com/aws/copilot-cli/internal/pkg/docker/dockerengine"
gomock "github.com/golang/mock/gomock"
)
// MockActionRecommender is a mock of ActionRecommender interface.
type MockActionRecommender struct {
ctrl *gomock.Controller
recorder *MockActionRecommenderMockRecorder
}
// MockActionRecommenderMockRecorder is the mock recorder for MockActionRecommender.
type MockActionRecommenderMockRecorder struct {
mock *MockActionRecommender
}
// NewMockActionRecommender creates a new mock instance.
func NewMockActionRecommender(ctrl *gomock.Controller) *MockActionRecommender {
mock := &MockActionRecommender{ctrl: ctrl}
mock.recorder = &MockActionRecommenderMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockActionRecommender) EXPECT() *MockActionRecommenderMockRecorder {
return m.recorder
}
// RecommendedActions mocks base method.
func (m *MockActionRecommender) RecommendedActions() []string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RecommendedActions")
ret0, _ := ret[0].([]string)
return ret0
}
// RecommendedActions indicates an expected call of RecommendedActions.
func (mr *MockActionRecommenderMockRecorder) RecommendedActions() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecommendedActions", reflect.TypeOf((*MockActionRecommender)(nil).RecommendedActions))
}
// MockrepositoryService is a mock of repositoryService interface.
type MockrepositoryService struct {
ctrl *gomock.Controller
recorder *MockrepositoryServiceMockRecorder
}
// MockrepositoryServiceMockRecorder is the mock recorder for MockrepositoryService.
type MockrepositoryServiceMockRecorder struct {
mock *MockrepositoryService
}
// NewMockrepositoryService creates a new mock instance.
func NewMockrepositoryService(ctrl *gomock.Controller) *MockrepositoryService {
mock := &MockrepositoryService{ctrl: ctrl}
mock.recorder = &MockrepositoryServiceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockrepositoryService) EXPECT() *MockrepositoryServiceMockRecorder {
return m.recorder
}
// BuildAndPush mocks base method.
func (m *MockrepositoryService) BuildAndPush(ctx context.Context, args *dockerengine.BuildArguments, w io.Writer) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BuildAndPush", ctx, args, w)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// BuildAndPush indicates an expected call of BuildAndPush.
func (mr *MockrepositoryServiceMockRecorder) BuildAndPush(ctx, args, w interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildAndPush", reflect.TypeOf((*MockrepositoryService)(nil).BuildAndPush), ctx, args, w)
}
// Login mocks base method.
func (m *MockrepositoryService) Login() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Login")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Login indicates an expected call of Login.
func (mr *MockrepositoryServiceMockRecorder) Login() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockrepositoryService)(nil).Login))
}
// Mocktemplater is a mock of templater interface.
type Mocktemplater struct {
ctrl *gomock.Controller
recorder *MocktemplaterMockRecorder
}
// MocktemplaterMockRecorder is the mock recorder for Mocktemplater.
type MocktemplaterMockRecorder struct {
mock *Mocktemplater
}
// NewMocktemplater creates a new mock instance.
func NewMocktemplater(ctrl *gomock.Controller) *Mocktemplater {
mock := &Mocktemplater{ctrl: ctrl}
mock.recorder = &MocktemplaterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mocktemplater) EXPECT() *MocktemplaterMockRecorder {
return m.recorder
}
// Template mocks base method.
func (m *Mocktemplater) Template() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Template")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Template indicates an expected call of Template.
func (mr *MocktemplaterMockRecorder) Template() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Template", reflect.TypeOf((*Mocktemplater)(nil).Template))
}
// MockstackBuilder is a mock of stackBuilder interface.
type MockstackBuilder struct {
ctrl *gomock.Controller
recorder *MockstackBuilderMockRecorder
}
// MockstackBuilderMockRecorder is the mock recorder for MockstackBuilder.
type MockstackBuilderMockRecorder struct {
mock *MockstackBuilder
}
// NewMockstackBuilder creates a new mock instance.
func NewMockstackBuilder(ctrl *gomock.Controller) *MockstackBuilder {
mock := &MockstackBuilder{ctrl: ctrl}
mock.recorder = &MockstackBuilderMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockstackBuilder) EXPECT() *MockstackBuilderMockRecorder {
return m.recorder
}
// Package mocks base method.
func (m *MockstackBuilder) Package(arg0 addon.PackageConfig) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Package", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Package indicates an expected call of Package.
func (mr *MockstackBuilderMockRecorder) Package(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Package", reflect.TypeOf((*MockstackBuilder)(nil).Package), arg0)
}
// Parameters mocks base method.
func (m *MockstackBuilder) Parameters() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Parameters")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Parameters indicates an expected call of Parameters.
func (mr *MockstackBuilderMockRecorder) Parameters() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parameters", reflect.TypeOf((*MockstackBuilder)(nil).Parameters))
}
// Template mocks base method.
func (m *MockstackBuilder) Template() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Template")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Template indicates an expected call of Template.
func (mr *MockstackBuilderMockRecorder) Template() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Template", reflect.TypeOf((*MockstackBuilder)(nil).Template))
}
// MockstackSerializer is a mock of stackSerializer interface.
type MockstackSerializer struct {
ctrl *gomock.Controller
recorder *MockstackSerializerMockRecorder
}
// MockstackSerializerMockRecorder is the mock recorder for MockstackSerializer.
type MockstackSerializerMockRecorder struct {
mock *MockstackSerializer
}
// NewMockstackSerializer creates a new mock instance.
func NewMockstackSerializer(ctrl *gomock.Controller) *MockstackSerializer {
mock := &MockstackSerializer{ctrl: ctrl}
mock.recorder = &MockstackSerializerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockstackSerializer) EXPECT() *MockstackSerializerMockRecorder {
return m.recorder
}
// SerializedParameters mocks base method.
func (m *MockstackSerializer) SerializedParameters() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SerializedParameters")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SerializedParameters indicates an expected call of SerializedParameters.
func (mr *MockstackSerializerMockRecorder) SerializedParameters() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SerializedParameters", reflect.TypeOf((*MockstackSerializer)(nil).SerializedParameters))
}
// Template mocks base method.
func (m *MockstackSerializer) Template() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Template")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Template indicates an expected call of Template.
func (mr *MockstackSerializerMockRecorder) Template() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Template", reflect.TypeOf((*MockstackSerializer)(nil).Template))
}
// MockendpointGetter is a mock of endpointGetter interface.
type MockendpointGetter struct {
ctrl *gomock.Controller
recorder *MockendpointGetterMockRecorder
}
// MockendpointGetterMockRecorder is the mock recorder for MockendpointGetter.
type MockendpointGetterMockRecorder struct {
mock *MockendpointGetter
}
// NewMockendpointGetter creates a new mock instance.
func NewMockendpointGetter(ctrl *gomock.Controller) *MockendpointGetter {
mock := &MockendpointGetter{ctrl: ctrl}
mock.recorder = &MockendpointGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockendpointGetter) EXPECT() *MockendpointGetterMockRecorder {
return m.recorder
}
// ServiceDiscoveryEndpoint mocks base method.
func (m *MockendpointGetter) ServiceDiscoveryEndpoint() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ServiceDiscoveryEndpoint")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ServiceDiscoveryEndpoint indicates an expected call of ServiceDiscoveryEndpoint.
func (mr *MockendpointGetterMockRecorder) ServiceDiscoveryEndpoint() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceDiscoveryEndpoint", reflect.TypeOf((*MockendpointGetter)(nil).ServiceDiscoveryEndpoint))
}
// MockserviceDeployer is a mock of serviceDeployer interface.
type MockserviceDeployer struct {
ctrl *gomock.Controller
recorder *MockserviceDeployerMockRecorder
}
// MockserviceDeployerMockRecorder is the mock recorder for MockserviceDeployer.
type MockserviceDeployerMockRecorder struct {
mock *MockserviceDeployer
}
// NewMockserviceDeployer creates a new mock instance.
func NewMockserviceDeployer(ctrl *gomock.Controller) *MockserviceDeployer {
mock := &MockserviceDeployer{ctrl: ctrl}
mock.recorder = &MockserviceDeployerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockserviceDeployer) EXPECT() *MockserviceDeployerMockRecorder {
return m.recorder
}
// DeployService mocks base method.
func (m *MockserviceDeployer) DeployService(conf cloudformation0.StackConfiguration, bucketName string, opts ...cloudformation.StackOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{conf, bucketName}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeployService", varargs...)
ret0, _ := ret[0].(error)
return ret0
}
// DeployService indicates an expected call of DeployService.
func (mr *MockserviceDeployerMockRecorder) DeployService(conf, bucketName interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{conf, bucketName}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeployService", reflect.TypeOf((*MockserviceDeployer)(nil).DeployService), varargs...)
}
// MockdeployedTemplateGetter is a mock of deployedTemplateGetter interface.
type MockdeployedTemplateGetter struct {
ctrl *gomock.Controller
recorder *MockdeployedTemplateGetterMockRecorder
}
// MockdeployedTemplateGetterMockRecorder is the mock recorder for MockdeployedTemplateGetter.
type MockdeployedTemplateGetterMockRecorder struct {
mock *MockdeployedTemplateGetter
}
// NewMockdeployedTemplateGetter creates a new mock instance.
func NewMockdeployedTemplateGetter(ctrl *gomock.Controller) *MockdeployedTemplateGetter {
mock := &MockdeployedTemplateGetter{ctrl: ctrl}
mock.recorder = &MockdeployedTemplateGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockdeployedTemplateGetter) EXPECT() *MockdeployedTemplateGetterMockRecorder {
return m.recorder
}
// Template mocks base method.
func (m *MockdeployedTemplateGetter) Template(stackName string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Template", stackName)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Template indicates an expected call of Template.
func (mr *MockdeployedTemplateGetterMockRecorder) Template(stackName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Template", reflect.TypeOf((*MockdeployedTemplateGetter)(nil).Template), stackName)
}
// Mockspinner is a mock of spinner interface.
type Mockspinner struct {
ctrl *gomock.Controller
recorder *MockspinnerMockRecorder
}
// MockspinnerMockRecorder is the mock recorder for Mockspinner.
type MockspinnerMockRecorder struct {
mock *Mockspinner
}
// NewMockspinner creates a new mock instance.
func NewMockspinner(ctrl *gomock.Controller) *Mockspinner {
mock := &Mockspinner{ctrl: ctrl}
mock.recorder = &MockspinnerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockspinner) EXPECT() *MockspinnerMockRecorder {
return m.recorder
}
// Start mocks base method.
func (m *Mockspinner) Start(label string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Start", label)
}
// Start indicates an expected call of Start.
func (mr *MockspinnerMockRecorder) Start(label interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*Mockspinner)(nil).Start), label)
}
// Stop mocks base method.
func (m *Mockspinner) Stop(label string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Stop", label)
}
// Stop indicates an expected call of Stop.
func (mr *MockspinnerMockRecorder) Stop(label interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*Mockspinner)(nil).Stop), label)
}
// MocklabeledTermPrinter is a mock of labeledTermPrinter interface.
type MocklabeledTermPrinter struct {
ctrl *gomock.Controller
recorder *MocklabeledTermPrinterMockRecorder
}
// MocklabeledTermPrinterMockRecorder is the mock recorder for MocklabeledTermPrinter.
type MocklabeledTermPrinterMockRecorder struct {
mock *MocklabeledTermPrinter
}
// NewMocklabeledTermPrinter creates a new mock instance.
func NewMocklabeledTermPrinter(ctrl *gomock.Controller) *MocklabeledTermPrinter {
mock := &MocklabeledTermPrinter{ctrl: ctrl}
mock.recorder = &MocklabeledTermPrinterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MocklabeledTermPrinter) EXPECT() *MocklabeledTermPrinterMockRecorder {
return m.recorder
}
// IsDone mocks base method.
func (m *MocklabeledTermPrinter) IsDone() bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsDone")
ret0, _ := ret[0].(bool)
return ret0
}
// IsDone indicates an expected call of IsDone.
func (mr *MocklabeledTermPrinterMockRecorder) IsDone() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDone", reflect.TypeOf((*MocklabeledTermPrinter)(nil).IsDone))
}
// Print mocks base method.
func (m *MocklabeledTermPrinter) Print() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Print")
}
// Print indicates an expected call of Print.
func (mr *MocklabeledTermPrinterMockRecorder) Print() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Print", reflect.TypeOf((*MocklabeledTermPrinter)(nil).Print))
}
// MockdockerEngineRunChecker is a mock of dockerEngineRunChecker interface.
type MockdockerEngineRunChecker struct {
ctrl *gomock.Controller
recorder *MockdockerEngineRunCheckerMockRecorder
}
// MockdockerEngineRunCheckerMockRecorder is the mock recorder for MockdockerEngineRunChecker.
type MockdockerEngineRunCheckerMockRecorder struct {
mock *MockdockerEngineRunChecker
}
// NewMockdockerEngineRunChecker creates a new mock instance.
func NewMockdockerEngineRunChecker(ctrl *gomock.Controller) *MockdockerEngineRunChecker {
mock := &MockdockerEngineRunChecker{ctrl: ctrl}
mock.recorder = &MockdockerEngineRunCheckerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockdockerEngineRunChecker) EXPECT() *MockdockerEngineRunCheckerMockRecorder {
return m.recorder
}
// CheckDockerEngineRunning mocks base method.
func (m *MockdockerEngineRunChecker) CheckDockerEngineRunning() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CheckDockerEngineRunning")
ret0, _ := ret[0].(error)
return ret0
}
// CheckDockerEngineRunning indicates an expected call of CheckDockerEngineRunning.
func (mr *MockdockerEngineRunCheckerMockRecorder) CheckDockerEngineRunning() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckDockerEngineRunning", reflect.TypeOf((*MockdockerEngineRunChecker)(nil).CheckDockerEngineRunning))
}
// MocktimeoutError is a mock of timeoutError interface.
type MocktimeoutError struct {
ctrl *gomock.Controller
recorder *MocktimeoutErrorMockRecorder
}
// MocktimeoutErrorMockRecorder is the mock recorder for MocktimeoutError.
type MocktimeoutErrorMockRecorder struct {
mock *MocktimeoutError
}
// NewMocktimeoutError creates a new mock instance.
func NewMocktimeoutError(ctrl *gomock.Controller) *MocktimeoutError {
mock := &MocktimeoutError{ctrl: ctrl}
mock.recorder = &MocktimeoutErrorMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MocktimeoutError) EXPECT() *MocktimeoutErrorMockRecorder {
return m.recorder
}
// Error mocks base method.
func (m *MocktimeoutError) Error() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Error")
ret0, _ := ret[0].(string)
return ret0
}
// Error indicates an expected call of Error.
func (mr *MocktimeoutErrorMockRecorder) Error() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MocktimeoutError)(nil).Error))
}
// Timeout mocks base method.
func (m *MocktimeoutError) Timeout() bool {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Timeout")
ret0, _ := ret[0].(bool)
return ret0
}
// Timeout indicates an expected call of Timeout.
func (mr *MocktimeoutErrorMockRecorder) Timeout() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timeout", reflect.TypeOf((*MocktimeoutError)(nil).Timeout))
}
| 568 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package patch
import (
"errors"
"fmt"
"strings"
"github.com/aws/aws-sdk-go/aws/endpoints"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/aws/s3"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/aws/copilot-cli/internal/pkg/term/log"
"github.com/aws/copilot-cli/internal/pkg/version"
"golang.org/x/mod/semver"
"gopkg.in/yaml.v3"
)
type environmentTemplateUpdateGetter interface {
Template(stackName string) (string, error)
UpdateEnvironmentTemplate(appName, envName, templateBody, cfnExecRoleARN string) error
}
type progress interface {
Start(label string)
Stop(label string)
}
// EnvironmentPatcher checks if the environment needs a patch and perform the patch when necessary.
type EnvironmentPatcher struct {
Prog progress
Env *config.Environment
TemplatePatcher environmentTemplateUpdateGetter
}
// EnsureManagerRoleIsAllowedToUpload checks if the environment manager role has the necessary permissions to upload
// objects to bucket and patches the permissions if not.
func (p *EnvironmentPatcher) EnsureManagerRoleIsAllowedToUpload(bucket string) error {
body, err := p.TemplatePatcher.Template(stack.NameForEnv(p.Env.App, p.Env.Name))
if err != nil {
return fmt.Errorf("get environment template for %q: %w", p.Env.Name, err)
}
ok, err := isManagerRoleAllowedToUpload(body)
if err != nil {
return err
}
if ok {
return nil
}
return p.grantManagerRolePermissionToUpload(p.Env.App, p.Env.Name, p.Env.ExecutionRoleARN, body, s3.FormatARN(endpoints.AwsPartitionID, bucket))
}
func (p *EnvironmentPatcher) grantManagerRolePermissionToUpload(app, env, execRole, body, bucketARN string) error {
// Detect which line number the EnvironmentManagerRole's PolicyDocument Statement is at.
// We will add additional permissions after that line.
type Template struct {
Resources struct {
ManagerRole struct {
Properties struct {
Policies []struct {
Document struct {
Statements yaml.Node `yaml:"Statement"`
} `yaml:"PolicyDocument"`
} `yaml:"Policies"`
} `yaml:"Properties"`
} `yaml:"EnvironmentManagerRole"`
} `yaml:"Resources"`
}
var tpl Template
if err := yaml.Unmarshal([]byte(body), &tpl); err != nil {
return fmt.Errorf("unmarshal environment template to find EnvironmentManagerRole policy statement: %v", err)
}
if len(tpl.Resources.ManagerRole.Properties.Policies) == 0 {
return errors.New("unable to find policies for the EnvironmentManagerRole")
}
// lines and columns are 1-indexed, so we have to subtract one from each.
statementLineIndex := tpl.Resources.ManagerRole.Properties.Policies[0].Document.Statements.Line - 1
numSpaces := tpl.Resources.ManagerRole.Properties.Policies[0].Document.Statements.Column - 1
pad := strings.Repeat(" ", numSpaces)
// Create the additional permissions needed with the appropriate indentation.
permissions := fmt.Sprintf(`- Sid: PatchPutObjectsToArtifactBucket
Effect: Allow
Action:
- s3:PutObject
- s3:PutObjectAcl
Resource:
- %s
- %s/*`, bucketARN, bucketARN)
permissions = pad + strings.Replace(permissions, "\n", "\n"+pad, -1)
// Add the new permissions to the body.
lines := strings.Split(body, "\n")
linesBefore := lines[:statementLineIndex]
linesAfter := lines[statementLineIndex:]
updatedLines := append(linesBefore, append(strings.Split(permissions, "\n"), linesAfter...)...)
updatedBody := strings.Join(updatedLines, "\n")
// Update the Environment template with the new content.
// CloudFormation is the only entity that's allowed to update the EnvManagerRole so we have to go through this route.
// See #3556.
var errEmptyChangeSet *cloudformation.ErrChangeSetEmpty
p.Prog.Start("Update the environment's manager role with permission to upload artifacts to S3")
err := p.TemplatePatcher.UpdateEnvironmentTemplate(app, env, updatedBody, execRole)
if err != nil && !errors.As(err, &errEmptyChangeSet) {
p.Prog.Stop(log.Serrorln("Unable to update the environment's manager role with upload artifacts permission"))
return fmt.Errorf("update environment template with PutObject permissions: %v", err)
}
p.Prog.Stop(log.Ssuccessln("Updated the environment's manager role with permissions to upload artifacts to S3"))
return nil
}
func isManagerRoleAllowedToUpload(body string) (bool, error) {
type Template struct {
Metadata struct {
Version string `yaml:"Version"`
} `yaml:"Metadata"`
}
var tpl Template
if err := yaml.Unmarshal([]byte(body), &tpl); err != nil {
return false, fmt.Errorf("unmarshal environment template to detect Metadata.Version: %v", err)
}
if tpl.Metadata.Version == version.EnvTemplateBootstrap {
// "bootstrap" version is introduced after v1.9.0. The environment manager roles must have had the permissions.
return true, nil
}
if !semver.IsValid(tpl.Metadata.Version) { // The template doesn't contain a version.
return false, nil
}
if semver.Compare(tpl.Metadata.Version, "v1.9.0") < 0 {
// The permissions to grant the EnvManagerRole to upload artifacts was granted with template v1.9.0.
return false, nil
}
return true, nil
}
| 140 |
copilot-cli | aws | Go | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package patch
import (
"errors"
"fmt"
"testing"
"github.com/aws/copilot-cli/internal/pkg/aws/cloudformation"
"github.com/aws/copilot-cli/internal/pkg/cli/deploy/patch/mocks"
"github.com/aws/copilot-cli/internal/pkg/config"
"github.com/aws/copilot-cli/internal/pkg/deploy/cloudformation/stack"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
)
type envPatcherMock struct {
templatePatcher *mocks.MockenvironmentTemplateUpdateGetter
prog *mocks.Mockprogress
}
func TestEnvironmentPatcher_EnsureManagerRoleIsAllowedToUpload(t *testing.T) {
testCases := map[string]struct {
setupMocks func(m *envPatcherMock)
wantedError error
}{
"error getting environment template": {
setupMocks: func(m *envPatcherMock) {
m.templatePatcher.EXPECT().Template(stack.NameForEnv("mockApp", "mockEnv")).
Return("", errors.New("some error"))
},
wantedError: errors.New(`get environment template for "mockEnv": some error`),
},
"error updating the environment template with the patch": {
setupMocks: func(m *envPatcherMock) {
m.templatePatcher.EXPECT().Template(stack.NameForEnv("mockApp", "mockEnv")).
Return(`
Metadata:
Version: v1.7.0
Resources:
EnvironmentManagerRole:
Properties:
Policies:
- PolicyDocument:
Statement:
- Sid: CloudwatchLogs
OtherResource:`, nil)
m.prog.EXPECT().Start(gomock.Any())
m.templatePatcher.EXPECT().UpdateEnvironmentTemplate("mockApp", "mockEnv", `
Metadata:
Version: v1.7.0
Resources:
EnvironmentManagerRole:
Properties:
Policies:
- PolicyDocument:
Statement:
- Sid: PatchPutObjectsToArtifactBucket
Effect: Allow
Action:
- s3:PutObject
- s3:PutObjectAcl
Resource:
- arn:aws:s3:::mockBucket
- arn:aws:s3:::mockBucket/*
- Sid: CloudwatchLogs
OtherResource:`, "mockExecutionRoleARN").Return(errors.New("some error"))
m.prog.EXPECT().Stop(gomock.Any())
},
wantedError: errors.New("update environment template with PutObject permissions: some error"),
},
"success when template version is later than v1.9.0": {
setupMocks: func(m *envPatcherMock) {
m.templatePatcher.EXPECT().Template(stack.NameForEnv("mockApp", "mockEnv")).
Return(`
Metadata:
Version: v1.9.0`, nil)
},
},
"should upgrade non-legacy environments and ignore ErrChangeSet if the environment template already has permissions to upload artifacts": {
setupMocks: func(m *envPatcherMock) {
m.templatePatcher.EXPECT().Template(stack.NameForEnv("mockApp", "mockEnv")).Return(`
Metadata:
Version: v1.1.0
Resources:
EnvironmentManagerRole:
Properties:
Policies:
- PolicyDocument:
Statement:
- Sid: PatchPutObjectsToArtifactBucket
Effect: Allow
Action:
- s3:PutObject
- s3:PutObjectAcl
Resource:
- arn:aws:s3:::mockBucket
- arn:aws:s3:::mockBucket/*
`, nil)
m.prog.EXPECT().Start(gomock.Any())
m.templatePatcher.EXPECT().UpdateEnvironmentTemplate(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(fmt.Errorf("wrapped err: %w", &cloudformation.ErrChangeSetEmpty{}))
m.prog.EXPECT().Stop(gomock.Any())
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := &envPatcherMock{
templatePatcher: mocks.NewMockenvironmentTemplateUpdateGetter(ctrl),
prog: mocks.NewMockprogress(ctrl),
}
tc.setupMocks(m)
p := EnvironmentPatcher{
Env: &config.Environment{
App: "mockApp",
Name: "mockEnv",
ExecutionRoleARN: "mockExecutionRoleARN",
},
TemplatePatcher: m.templatePatcher,
Prog: m.prog,
}
got := p.EnsureManagerRoleIsAllowedToUpload("mockBucket")
if tc.wantedError != nil {
require.EqualError(t, got, tc.wantedError.Error())
} else {
require.NoError(t, got)
}
})
}
}
| 138 |
copilot-cli | aws | Go | // Code generated by MockGen. DO NOT EDIT.
// Source: ./internal/pkg/cli/deploy/patch/env.go
// Package mocks is a generated GoMock package.
package mocks
import (
reflect "reflect"
gomock "github.com/golang/mock/gomock"
)
// MockenvironmentTemplateUpdateGetter is a mock of environmentTemplateUpdateGetter interface.
type MockenvironmentTemplateUpdateGetter struct {
ctrl *gomock.Controller
recorder *MockenvironmentTemplateUpdateGetterMockRecorder
}
// MockenvironmentTemplateUpdateGetterMockRecorder is the mock recorder for MockenvironmentTemplateUpdateGetter.
type MockenvironmentTemplateUpdateGetterMockRecorder struct {
mock *MockenvironmentTemplateUpdateGetter
}
// NewMockenvironmentTemplateUpdateGetter creates a new mock instance.
func NewMockenvironmentTemplateUpdateGetter(ctrl *gomock.Controller) *MockenvironmentTemplateUpdateGetter {
mock := &MockenvironmentTemplateUpdateGetter{ctrl: ctrl}
mock.recorder = &MockenvironmentTemplateUpdateGetterMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockenvironmentTemplateUpdateGetter) EXPECT() *MockenvironmentTemplateUpdateGetterMockRecorder {
return m.recorder
}
// Template mocks base method.
func (m *MockenvironmentTemplateUpdateGetter) Template(stackName string) (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Template", stackName)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Template indicates an expected call of Template.
func (mr *MockenvironmentTemplateUpdateGetterMockRecorder) Template(stackName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Template", reflect.TypeOf((*MockenvironmentTemplateUpdateGetter)(nil).Template), stackName)
}
// UpdateEnvironmentTemplate mocks base method.
func (m *MockenvironmentTemplateUpdateGetter) UpdateEnvironmentTemplate(appName, envName, templateBody, cfnExecRoleARN string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateEnvironmentTemplate", appName, envName, templateBody, cfnExecRoleARN)
ret0, _ := ret[0].(error)
return ret0
}
// UpdateEnvironmentTemplate indicates an expected call of UpdateEnvironmentTemplate.
func (mr *MockenvironmentTemplateUpdateGetterMockRecorder) UpdateEnvironmentTemplate(appName, envName, templateBody, cfnExecRoleARN interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEnvironmentTemplate", reflect.TypeOf((*MockenvironmentTemplateUpdateGetter)(nil).UpdateEnvironmentTemplate), appName, envName, templateBody, cfnExecRoleARN)
}
// Mockprogress is a mock of progress interface.
type Mockprogress struct {
ctrl *gomock.Controller
recorder *MockprogressMockRecorder
}
// MockprogressMockRecorder is the mock recorder for Mockprogress.
type MockprogressMockRecorder struct {
mock *Mockprogress
}
// NewMockprogress creates a new mock instance.
func NewMockprogress(ctrl *gomock.Controller) *Mockprogress {
mock := &Mockprogress{ctrl: ctrl}
mock.recorder = &MockprogressMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockprogress) EXPECT() *MockprogressMockRecorder {
return m.recorder
}
// Start mocks base method.
func (m *Mockprogress) Start(label string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Start", label)
}
// Start indicates an expected call of Start.
func (mr *MockprogressMockRecorder) Start(label interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*Mockprogress)(nil).Start), label)
}
// Stop mocks base method.
func (m *Mockprogress) Stop(label string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Stop", label)
}
// Stop indicates an expected call of Stop.
func (mr *MockprogressMockRecorder) Stop(label interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*Mockprogress)(nil).Stop), label)
}
| 111 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.