def do_command(self):
fileoperations.touch_config_folder()
self.interactive = self.app.pargs.interactive or not self.app.pargs.platform_name
self.region = self.app.pargs.region
if self.interactive or not self.app.pargs.platform_name:
self.region = get_region(self.app.pargs.region, self.interactive)
else:
self.region = get_region_from_inputs(self.app.pargs.region)
aws.set_region(self.region)
self.region = set_up_credentials(self.app.pargs.profile, self.region,
self.interactive)
self.platform_name, version = get_platform_name_and_version(
self.app.pargs.platform_name)
self.keyname = self.app.pargs.keyname
if not self.keyname and self.interactive:
self.keyname = get_keyname()
initializeops.setup('Custom Platform Builder',
self.region,
None,
workspace_type=Constants.WorkSpaceTypes.PLATFORM,
platform_name=self.platform_name,
platform_version=version)
fileoperations.write_keyname(self.keyname)
if version is None:
platformops.set_workspace_to_latest()
def do_command(self):
commonops.raise_if_inside_platform_workspace()
interactive = self.app.pargs.interactive
region_name = self.app.pargs.region
noverify = self.app.pargs.no_verify_ssl
keyname = self.app.pargs.keyname
profile = self.app.pargs.profile
platform = self.app.pargs.platform
source = self.app.pargs.source
app_name = self.app.pargs.application_name
modules = self.app.pargs.modules
force_non_interactive = _customer_is_avoiding_interactive_flow(
self.app.pargs)
tags = self.app.pargs.tags
# The user specifies directories to initialize
if modules and len(modules) > 0:
self.initialize_multiple_directories(modules, region_name,
interactive,
force_non_interactive,
keyname, profile, noverify,
platform)
return
fileoperations.touch_config_folder()
region_name = commonops.set_region_for_application(
interactive, region_name, force_non_interactive, platform)
commonops.set_up_credentials(profile, region_name, interactive)
app_name = get_app_name(app_name, interactive, force_non_interactive)
default_env = set_default_env(interactive, force_non_interactive)
tags = tagops.get_and_validate_tags(tags)
platform_arn, keyname_of_existing_application = create_app_or_use_existing_one(
app_name, default_env, tags)
platform = _determine_platform(customer_provided_platform=platform,
existing_app_platform=platform_arn,
force_interactive=interactive
and not force_non_interactive)
handle_buildspec_image(platform, force_non_interactive)
prompt_codecommit = should_prompt_customer_to_opt_into_codecommit(
force_non_interactive, region_name, source)
repository, branch = None, None
if prompt_codecommit:
repository, branch = configure_codecommit(source)
initializeops.setup(app_name,
region_name,
platform,
dir_path=None,
repository=repository,
branch=branch)
configure_keyname(platform, keyname, keyname_of_existing_application,
interactive, force_non_interactive)
fileoperations.write_config_setting('global', 'include_git_submodules',
True)
if noverify:
fileoperations.write_config_setting('global', 'no-verify-ssl',
True)
def initialize_multiple_directories(
self,
modules,
region,
interactive,
force_non_interactive,
keyname,
profile,
noverify,
platform
):
application_created = False
app_name = None
cwd = os.getcwd()
for module in modules:
if os.path.exists(module) and os.path.isdir(module):
os.chdir(module)
fileoperations.touch_config_folder()
# Region should be set once for all modules
region = region or commonops.set_region_for_application(interactive, region, force_non_interactive)
commonops.set_up_credentials(profile, region, interactive)
# App name should be set once for all modules
if not app_name:
# Switching back to the root dir will suggest the root dir name
# as the application name
os.chdir(cwd)
app_name = get_app_name(None, interactive, force_non_interactive)
os.chdir(module)
if noverify:
fileoperations.write_config_setting('global', 'no-verify-ssl', True)
default_env = '/ni' if force_non_interactive else None
if not application_created:
platform_arn, keyname_of_existing_application = commonops.create_app(
app_name,
default_env=default_env
)
application_created = True
else:
platform_arn, keyname_of_existing_application = commonops.pull_down_app_info(
app_name,
default_env=default_env
)
io.echo('\n--- Configuring module: {0} ---'.format(module))
module_platform = _determine_platform(
customer_provided_platform=platform,
existing_app_platform=platform_arn,
force_interactive=interactive)
initializeops.setup(app_name, region, module_platform)
configure_keyname(module_platform, keyname, keyname_of_existing_application, interactive, force_non_interactive)
os.chdir(cwd)
def initialize_multiple_directories(self, modules, region, interactive,
force_non_interactive, keyname,
profile, noverify, platform):
application_created = False
app_name = None
cwd = os.getcwd()
for module in modules:
if os.path.exists(module) and os.path.isdir(module):
os.chdir(module)
fileoperations.touch_config_folder()
# Region should be set once for all modules
region = region or commonops.set_region_for_application(
interactive, region, force_non_interactive)
commonops.set_up_credentials(profile, region, interactive)
# App name should be set once for all modules
if not app_name:
# Switching back to the root dir will suggest the root dir name
# as the application name
os.chdir(cwd)
app_name = get_app_name(None, interactive,
force_non_interactive)
os.chdir(module)
if noverify:
fileoperations.write_config_setting(
'global', 'no-verify-ssl', True)
default_env = '/ni' if force_non_interactive else None
if not application_created:
sstack, keyname_of_existing_application = commonops.create_app(
app_name, default_env=default_env)
application_created = True
else:
sstack, keyname_of_existing_application = commonops.pull_down_app_info(
app_name, default_env=default_env)
solution = get_solution_stack(platform, sstack, interactive)
io.echo('\n--- Configuring module: {0} ---'.format(module))
solution = solution or sstack
if not solution and fileoperations.env_yaml_exists():
solution = extract_solution_stack_from_env_yaml()
if solution:
io.echo(strings['init.usingenvyamlplatform'].replace(
'{platform}', solution))
solution = solution or solution_stack_ops.get_solution_stack_from_customer(
)
initializeops.setup(app_name, region, solution)
configure_keyname(solution, keyname,
keyname_of_existing_application, interactive,
force_non_interactive)
os.chdir(cwd)
def setup_credentials(access_id=None, secret_key=None):
io.log_info('Setting up ~/aws/ directory with config file')
if access_id is None or secret_key is None:
io.echo(strings['cred.prompt'])
if access_id is None:
access_id = io.prompt('aws-access-id',
default='ENTER_AWS_ACCESS_ID_HERE')
if secret_key is None:
secret_key = io.prompt('aws-secret-key', default='ENTER_SECRET_HERE')
fileoperations.save_to_aws_config(access_id, secret_key)
fileoperations.touch_config_folder()
fileoperations.write_config_setting('global', 'profile', 'eb-cli')
aws.set_session_creds(access_id, secret_key)
def do_command(self):
fileoperations.touch_config_folder()
self.interactive = self.app.pargs.interactive
self.region = self.app.pargs.region
if self.interactive:
self.region = get_region(self.app.pargs.region, self.app.pargs.interactive)
else:
self.region = get_region_from_inputs(self.app.pargs.region)
aws.set_region(self.region)
self.region = set_up_credentials(self.app.pargs.profile, self.region, self.interactive)
self.platform_name, version = self.get_platform_name_and_version()
# If interactive mode, or explicit interactive due to missing platform_name
if self.interactive or not self.platform_name:
self.keyname = self.get_keyname(self.app.pargs.keyname)
else:
self.keyname = None
if self.keyname == -1:
self.keyname = None
initializeops.setup(
'Custom Platform Builder',
self.region,
None,
workspace_type=Constants.WorkSpaceTypes.PLATFORM,
platform_name=self.platform_name,
platform_version=version)
fileoperations.write_keyname(self.keyname)
if version is None:
platformops.set_workspace_to_latest()
def do_command(self):
# get arguments
self.interactive = self.app.pargs.interactive
self.region = self.app.pargs.region
self.noverify = self.app.pargs.no_verify_ssl
self.force_non_interactive = False
# Determine if the customer is avoiding interactive mode by setting the platform flag
if self.app.pargs.platform:
self.force_non_interactive = True
# Code Commit integration
self.source = self.app.pargs.source
source_location = None
branch = None
repository = None
if self.source is not None:
source_location, repository, branch = utils.parse_source(self.source)
# The user specifies directories to initialize
self.modules = self.app.pargs.modules
if self.modules and len(self.modules) > 0:
self.initialize_multiple_directories()
return
default_env = self.get_old_values()
fileoperations.touch_config_folder()
if self.interactive:
self.region = get_region(self.region, self.interactive, self.force_non_interactive)
else:
self.region = get_region_from_inputs(self.region)
aws.set_region(self.region)
self.region = set_up_credentials(self.app.pargs.profile, self.region, self.interactive)
self.solution = self.get_solution_stack()
self.app_name = self.get_app_name()
if self.noverify:
fileoperations.write_config_setting('global',
'no-verify-ssl', True)
if not default_env and not self.interactive:
# try to get default env from config file if exists
try:
default_env = commonops.get_current_branch_environment()
except NotInitializedError:
default_env = None
elif self.interactive:
default_env = None
if self.force_non_interactive:
default_env = '/ni'
# Create application
sstack, key = commonops.pull_down_app_info(self.app_name, default_env=default_env) if elasticbeanstalk.application_exist(self.app_name) \
else commonops.create_app(self.app_name, default_env=default_env)
if not self.solution:
self.solution = sstack
platform_set = False
if not self.solution or \
(self.interactive and not self.app.pargs.platform):
if fileoperations.env_yaml_exists():
env_yaml_platform = fileoperations.get_platform_from_env_yaml()
if env_yaml_platform:
platform = solutionstack.SolutionStack(env_yaml_platform).platform_shorthand
self.solution = platform
platform_set = True
if not platform_set:
self.solution = solution_stack_ops.get_solution_stack_from_customer().platform_shorthand
# Select CodeBuild image if BuildSpec is present do not prompt or show if we are non-interactive
if fileoperations.build_spec_exists() and not self.force_non_interactive:
build_spec = fileoperations.get_build_configuration()
if build_spec is not None and build_spec.image is None:
LOG.debug("Buildspec file is present but image is does not exist. Attempting to fill best guess.")
platform_image = initializeops.get_codebuild_image_from_platform(self.solution)
# If the return is a dictionary then it must be a single image and we can use that automatically
if type(platform_image) is dict:
io.echo('codebuild.latestplatform'.replace('{platform}', self.solution))
else:
# Otherwise we have an array for images which we must prompt the customer to pick from
io.echo(prompts['codebuild.getplatform'].replace('{platform}', self.solution))
selected = utils.prompt_for_index_in_list(map(lambda image: image['description'], platform_image))
platform_image = platform_image[selected]
platform_image['name'] = utils.decode_bytes(platform_image['name'])
# Finally write the CodeBuild image back to the buildspec file
fileoperations.write_config_setting(fileoperations.buildspec_config_header,
'Image',
platform_image['name'],
file=fileoperations.buildspec_name)
# Setup code commit integration
# Ensure that git is setup
source_control = SourceControl.get_source_control()
try:
source_control_setup = source_control.is_setup()
if source_control_setup is None:
source_control_setup = False
except CommandError:
source_control_setup = False
default_branch_exists = False
if gitops.git_management_enabled() and not self.interactive:
default_branch_exists = True
# Warn the customer if they picked a region that CodeCommit is not supported
codecommit_region_supported = codecommit.region_supported(self.region)
if self.source is not None and not codecommit_region_supported:
io.log_warning(strings['codecommit.badregion'])
# Prompt customer to opt into CodeCommit unless one of the follows holds:
if self.force_non_interactive:
prompt_codecommit = False
elif not codecommit.region_supported(self.region):
prompt_codecommit = False
elif self.source and source_location.lower() != 'codecommit':
# Do not prompt if customer has already specified a code source to
# associate the EB workspace with
prompt_codecommit = False
elif default_branch_exists:
# Do not prompt if customer has already configured the EB application
# in the present working directory with Git
prompt_codecommit = False
else:
prompt_codecommit = True
# Prompt for interactive CodeCommit
if prompt_codecommit:
if not source_control_setup:
io.echo(strings['codecommit.nosc'])
else:
io.echo(strings['codecommit.ccwarning'])
try:
if not self.source:
io.validate_action(prompts['codecommit.usecc'], "y")
# Setup git config settings for code commit credentials
source_control.setup_codecommit_cred_config()
# Get user specified repository
remote_url = None
if repository is None:
repository = get_repository_interactive()
else:
try:
setup_codecommit_remote_repo(repository, source_control)
except ServiceError as ex:
if self.source:
create_codecommit_repository(repository)
setup_codecommit_remote_repo(repository, source_control)
else:
io.log_error(strings['codecommit.norepo'])
raise ex
# Get user specified branch
if branch is None:
branch = get_branch_interactive(repository)
else:
try:
codecommit.get_branch(repository, branch)
except ServiceError as ex:
if self.source:
create_codecommit_branch(source_control, branch)
else:
io.log_error(strings['codecommit.nobranch'])
raise ex
source_control.setup_existing_codecommit_branch(branch, remote_url)
except ValidationError:
LOG.debug("Denied option to use CodeCommit, continuing initialization")
# Initialize the whole setup
initializeops.setup(self.app_name, self.region, self.solution, dir_path=None, repository=repository, branch=branch)
if 'IIS' not in self.solution:
self.keyname = self.get_keyname(default=key)
if self.keyname == -1:
self.keyname = None
fileoperations.write_config_setting('global', 'default_ec2_keyname',
self.keyname)
# Default to including git submodules when creating zip files through `eb create`/`eb deploy`.
fileoperations.write_config_setting('global', 'include_git_submodules', True)
def initialize_multiple_directories(self):
application_created = False
self.app_name = None
cwd = os.getcwd()
for module in self.modules:
if os.path.exists(module) and os.path.isdir(module):
os.chdir(module)
fileoperations.touch_config_folder()
# Region should be set once for all modules
if not self.region:
if self.interactive:
self.region = get_region(self.region, self.interactive, self.force_non_interactive)
else:
self.region = get_region_from_inputs(self.app.pargs.region)
aws.set_region(self.region)
self.region = set_up_credentials(self.app.pargs.profile, self.region, self.interactive)
solution = self.get_solution_stack()
# App name should be set once for all modules
if not self.app_name:
# Switching back to the root dir will suggest the root dir name
# as the application name
os.chdir(cwd)
self.app_name = self.get_app_name()
os.chdir(module)
if self.noverify:
fileoperations.write_config_setting('global',
'no-verify-ssl', True)
default_env = None
if self.force_non_interactive:
default_env = '/ni'
if not application_created:
sstack, key = commonops.create_app(self.app_name,
default_env=default_env)
application_created = True
else:
sstack, key = commonops.pull_down_app_info(self.app_name,
default_env=default_env)
io.echo('\n--- Configuring module: {0} ---'.format(module))
if not solution:
solution = sstack
platform_set = False
# TODO: Do not require a solution stack if one has already been set by this point
if not solution or \
(self.interactive and not self.app.pargs.platform):
if fileoperations.env_yaml_exists():
env_yaml_platform = fileoperations.get_platform_from_env_yaml()
if env_yaml_platform:
platform = solutionstack.SolutionStack(env_yaml_platform).platform_shorthand
solution = platform
io.echo(strings['init.usingenvyamlplatform'].replace('{platform}', platform))
platform_set = True
if not platform_set:
solution = solution_stack_ops.get_solution_stack_from_customer()
initializeops.setup(self.app_name, self.region,
solution)
if 'IIS' not in solution:
keyname = self.get_keyname(default=key)
if keyname == -1:
self.keyname = None
fileoperations.write_config_setting('global', 'default_ec2_keyname',
keyname)
os.chdir(cwd)
def do_command(self):
# get arguments
self.interactive = self.app.pargs.interactive
self.region = self.app.pargs.region
self.noverify = self.app.pargs.no_verify_ssl
self.force_non_interactive = False
# Determine if the customer is avoiding interactive mode by setting the platform flag
if self.app.pargs.platform:
self.force_non_interactive = True
# Code Commit integration
self.source = self.app.pargs.source
source_location = None
branch = None
repository = None
if self.source is not None:
source_location, repository, branch = utils.parse_source(
self.source)
# The user specifies directories to initialize
self.modules = self.app.pargs.modules
if self.modules and len(self.modules) > 0:
self.initialize_multiple_directories()
return
default_env = self.get_old_values()
fileoperations.touch_config_folder()
if self.interactive:
self.region = get_region(self.region, self.interactive,
self.force_non_interactive)
else:
self.region = get_region_from_inputs(self.app.pargs.region)
aws.set_region(self.region)
# Warn the customer if they picked a region that CodeCommit is not supported
codecommit_region_supported = codecommit.region_supported(self.region)
if self.source is not None and not codecommit_region_supported:
io.log_warning(strings['codecommit.badregion'])
self.region = set_up_credentials(self.app.pargs.profile, self.region,
self.interactive)
self.solution = self.get_solution_stack()
self.app_name = self.get_app_name()
if self.noverify:
fileoperations.write_config_setting('global', 'no-verify-ssl',
True)
if not default_env and not self.interactive:
# try to get default env from config file if exists
try:
default_env = commonops.get_current_branch_environment()
except NotInitializedError:
default_env = None
elif self.interactive:
default_env = None
if self.force_non_interactive:
default_env = '/ni'
# Create application
sstack, key = commonops.pull_down_app_info(self.app_name, default_env=default_env) if elasticbeanstalk.application_exist(self.app_name) \
else commonops.create_app(self.app_name, default_env=default_env)
if not self.solution:
self.solution = sstack
platform_set = False
if not self.solution or \
(self.interactive and not self.app.pargs.platform):
if fileoperations.env_yaml_exists():
env_yaml_platform = fileoperations.get_platform_from_env_yaml()
if env_yaml_platform:
platform = solutionstack.SolutionStack(
env_yaml_platform).version
self.solution = platform
platform_set = True
if not platform_set:
result = commonops.prompt_for_solution_stack()
self.solution = result.version
# Select CodeBuild image if BuildSpec is present do not prompt or show if we are non-interactive
if fileoperations.build_spec_exists(
) and not self.force_non_interactive:
build_spec = fileoperations.get_build_configuration()
if build_spec is not None and build_spec.image is None:
LOG.debug(
"Buildspec file is present but image is does not exist. Attempting to fill best guess."
)
platform_image = initializeops.get_codebuild_image_from_platform(
self.solution)
# If the return is a dictionary then it must be a single image and we can use that automatically
if type(platform_image) is dict:
io.echo('codebuild.latestplatform'.replace(
'{platform}', self.solution))
else:
# Otherwise we have an array for images which we must prompt the customer to pick from
io.echo(prompts['codebuild.getplatform'].replace(
'{platform}', self.solution))
selected = utils.prompt_for_index_in_list(
map(lambda image: image['description'],
platform_image))
platform_image = platform_image[selected]
platform_image['name'] = utils.decode_bytes(
platform_image['name'])
# Finally write the CodeBuild image back to the buildspec file
fileoperations.write_config_setting(
fileoperations.buildspec_config_header,
'Image',
platform_image['name'],
file=fileoperations.buildspec_name)
# Setup code commit integration
# Ensure that git is setup
source_control = SourceControl.get_source_control()
try:
source_control_setup = source_control.is_setup()
if source_control_setup is None:
source_control_setup = False
except CommandError:
source_control_setup = False
default_branch_exists = False
if gitops.git_management_enabled() and not self.interactive:
default_branch_exists = True
prompt_codecommit = True
# Do not prompt if we are in non-interactive mode, the region is not supported for CodeCommit,
# the specified source is from CodeCommit OR we already have default CodeCommit values set.
if self.force_non_interactive \
or not codecommit.region_supported(self.region) \
or self.source is not None \
or default_branch_exists:
prompt_codecommit = False
# Prompt for interactive CodeCommit
if prompt_codecommit:
if not source_control_setup:
io.echo(strings['codecommit.nosc'])
else:
io.echo(strings['codecommit.ccwarning'])
try:
io.validate_action(prompts['codecommit.usecc'], "y")
# Setup git config settings for code commit credentials
source_control.setup_codecommit_cred_config()
# Get user specified repository
if repository is None:
repository = get_repository_interactive()
else:
try:
result = codecommit.get_repository(repository)
source_control.setup_codecommit_remote_repo(
remote_url=result['repositoryMetadata']
['cloneUrlHttp'])
except ServiceError as ex:
io.log_error(strings['codecommit.norepo'])
raise ex
# Get user specified branch
if branch is None:
branch = get_branch_interactive(repository)
else:
try:
codecommit.get_branch(repository, branch)
except ServiceError as ex:
io.log_error(strings['codecommit.nobranch'])
raise ex
source_control.setup_existing_codecommit_branch(branch)
except ValidationError:
LOG.debug(
"Denied option to use CodeCommit, continuing initialization"
)
# Initialize the whole setup
initializeops.setup(self.app_name,
self.region,
self.solution,
dir_path=None,
repository=repository,
branch=branch)
if 'IIS' not in self.solution:
self.keyname = self.get_keyname(default=key)
if self.keyname == -1:
self.keyname = None
fileoperations.write_config_setting('global',
'default_ec2_keyname',
self.keyname)
# Default to including git submodules when creating zip files through `eb create`/`eb deploy`.
fileoperations.write_config_setting('global', 'include_git_submodules',
True)
def initialize_multiple_directories(self):
application_created = False
self.app_name = None
cwd = os.getcwd()
for module in self.modules:
if os.path.exists(module) and os.path.isdir(module):
os.chdir(module)
fileoperations.touch_config_folder()
# Region should be set once for all modules
if not self.region:
if self.interactive:
self.region = get_region(self.region, self.interactive,
self.force_non_interactive)
else:
self.region = get_region_from_inputs(
self.app.pargs.region)
aws.set_region(self.region)
self.region = set_up_credentials(self.app.pargs.profile,
self.region, self.interactive)
solution = self.get_solution_stack()
# App name should be set once for all modules
if not self.app_name:
# Switching back to the root dir will suggest the root dir name
# as the application name
os.chdir(cwd)
self.app_name = self.get_app_name()
os.chdir(module)
if self.noverify:
fileoperations.write_config_setting(
'global', 'no-verify-ssl', True)
default_env = None
if self.force_non_interactive:
default_env = '/ni'
if not application_created:
sstack, key = commonops.create_app(self.app_name,
default_env=default_env)
application_created = True
else:
sstack, key = commonops.pull_down_app_info(
self.app_name, default_env=default_env)
io.echo('\n--- Configuring module: {0} ---'.format(module))
if not solution:
solution = sstack
platform_set = False
if not solution or \
(self.interactive and not self.app.pargs.platform):
if fileoperations.env_yaml_exists():
env_yaml_platform = fileoperations.get_platform_from_env_yaml(
)
if env_yaml_platform:
platform = solutionstack.SolutionStack(
env_yaml_platform).version
solution = platform
io.echo(
strings['init.usingenvyamlplatform'].replace(
'{platform}', platform))
platform_set = True
if not platform_set:
result = commonops.prompt_for_solution_stack()
solution = result.version
initializeops.setup(self.app_name, self.region, solution)
if 'IIS' not in solution:
keyname = self.get_keyname(default=key)
if keyname == -1:
self.keyname = None
fileoperations.write_config_setting(
'global', 'default_ec2_keyname', keyname)
os.chdir(cwd)
def do_command(self):
# get arguments
self.interactive = self.app.pargs.interactive
self.region = self.app.pargs.region
self.noverify = self.app.pargs.no_verify_ssl
self.force_non_interactive = False
# Determine if the customer is avoiding interactive mode by setting the platform flag
if self.app.pargs.platform:
self.force_non_interactive = True
# The user specifies directories to initialize
self.modules = self.app.pargs.modules
if self.modules and len(self.modules) > 0:
self.initialize_multiple_directories()
return
source_location, branch, repository = None, None, None
if self.app.pargs.source:
source_location, repository, branch = utils.parse_source(
self.app.pargs.source)
default_env = self.get_old_values()
fileoperations.touch_config_folder()
self.region = set_region_for_application(self.interactive, self.region,
self.force_non_interactive)
self.region = set_up_credentials(self.app.pargs.profile, self.region,
self.interactive)
self.solution = self.get_solution_stack()
self.app_name = self.get_app_name()
if self.noverify:
fileoperations.write_config_setting('global', 'no-verify-ssl',
True)
default_env = set_default_env(default_env, self.interactive,
self.force_non_interactive)
sstack, key = create_app_or_use_existing_one(self.app_name,
default_env)
self.solution = self.solution or sstack
if fileoperations.env_yaml_exists():
self.solution = self.solution or extract_solution_stack_from_env_yaml(
)
self.solution = self.solution or solution_stack_ops.get_solution_stack_from_customer(
).platform_shorthand
handle_buildspec_image(self.solution, self.force_non_interactive)
# Setup code commit integration
# Ensure that git is setup
source_control = SourceControl.get_source_control()
try:
source_control_setup = source_control.is_setup()
if source_control_setup is None:
source_control_setup = False
except CommandError:
source_control_setup = False
default_branch_exists = not not (gitops.git_management_enabled()
and not self.interactive)
if source_location and not codecommit.region_supported(self.region):
io.log_warning(strings['codecommit.badregion'])
# Prompt customer to opt into CodeCommit unless one of the follows holds:
if self.force_non_interactive:
prompt_codecommit = False
elif not codecommit.region_supported(self.region):
prompt_codecommit = False
elif source_location and source_location.lower() != 'codecommit':
# Do not prompt if customer has already specified a code source to
# associate the EB workspace with
prompt_codecommit = False
elif default_branch_exists:
# Do not prompt if customer has already configured the EB application
# in the present working directory with Git
prompt_codecommit = False
elif not source_control_setup:
if source_location:
io.echo(strings['codecommit.nosc'])
prompt_codecommit = False
else:
prompt_codecommit = True
# Prompt for interactive CodeCommit
if prompt_codecommit:
try:
if not source_location:
io.validate_action(prompts['codecommit.usecc'], "y")
# Setup git config settings for code commit credentials
source_control.setup_codecommit_cred_config()
# Get user specified repository
remote_url = None
if repository is None:
repository = get_repository_interactive()
else:
try:
setup_codecommit_remote_repo(repository,
source_control)
except ServiceError as ex:
if source_location:
create_codecommit_repository(repository)
setup_codecommit_remote_repo(
repository, source_control)
else:
io.log_error(strings['codecommit.norepo'])
raise ex
# Get user specified branch
if branch is None:
branch = get_branch_interactive(repository)
else:
try:
codecommit.get_branch(repository, branch)
except ServiceError as ex:
if source_location:
create_codecommit_branch(source_control, branch)
else:
io.log_error(strings['codecommit.nobranch'])
raise ex
source_control.setup_existing_codecommit_branch(
branch, remote_url)
except ValidationError:
LOG.debug(
"Denied option to use CodeCommit, continuing initialization"
)
# Initialize the whole setup
initializeops.setup(self.app_name,
self.region,
self.solution,
dir_path=None,
repository=repository,
branch=branch)
if 'IIS' not in self.solution:
self.keyname = self.get_keyname(default=key)
if self.keyname == -1:
self.keyname = None
fileoperations.write_config_setting('global',
'default_ec2_keyname',
self.keyname)
# Default to including git submodules when creating zip files through `eb create`/`eb deploy`.
fileoperations.write_config_setting('global', 'include_git_submodules',
True)
