def get_branch_interactive(repository):
source_control = SourceControl.get_source_control()
# Give list of code commit branches to use
new_branch = False
branch_list = codecommit.list_branches(repository)["branches"]
current_branch = source_control.get_current_branch()
# If there are existing branches prompt the user to pick one
if len(branch_list) > 0:
io.echo('Select a branch')
new_branch_option = '[ Create new Branch with local HEAD ]'
branch_list.append(new_branch_option)
try:
default_option = branch_list.index(current_branch) + 1
except ValueError:
default_option = len(branch_list)
branch_name = utils.prompt_for_item_in_list(branch_list,
default=default_option)
if branch_name == new_branch_option:
new_branch = True
# Create a new branch if the user specifies or there are no existing branches
if len(branch_list) == 0 or new_branch:
new_branch = True
io.echo()
io.echo('Enter Branch Name')
io.echo(
'***** Must have at least one commit to create a new branch with CodeCommit *****'
)
unique_name = utils.get_unique_name(current_branch, branch_list)
branch_name = io.prompt_for_unique_name(unique_name, branch_list)
# Setup git to push to this repo
result = codecommit.get_repository(repository)
remote_url = result['repositoryMetadata']['cloneUrlHttp']
source_control.setup_codecommit_remote_repo(remote_url=remote_url)
if len(branch_list) == 0 or new_branch:
LOG.debug("Creating a new branch")
try:
create_codecommit_branch(source_control, branch_name)
except ServiceError:
io.echo(
"Could not set CodeCommit branch with the current commit, run with '--debug' to get the full error"
)
return None
elif not new_branch:
LOG.debug("Setting up an existing branch")
succesful_branch = source_control.setup_existing_codecommit_branch(
branch_name, remote_url)
if not succesful_branch:
io.echo(
"Could not set CodeCommit branch, run with '--debug' to get the full error"
)
return None
return branch_name
def test_get_repository(
self,
make_api_call_mock
):
make_api_call_mock.return_value = mock_responses.GET_REPOSITORY_RESPONSE
self.assertEqual(
mock_responses.GET_REPOSITORY_RESPONSE,
codecommit.get_repository('my-repository')
)
def get_branch_interactive(repository):
source_control = SourceControl.get_source_control()
# Give list of code commit branches to use
new_branch = False
branch_list = codecommit.list_branches(repository)["branches"]
current_branch = source_control.get_current_branch()
# If there are existing branches prompt the user to pick one
if len(branch_list) > 0:
io.echo('Select a branch')
new_branch_option = '[ Create new Branch with local HEAD ]'
branch_list.append(new_branch_option)
try:
default_option = branch_list.index(current_branch) + 1
except ValueError:
default_option = len(branch_list)
branch_name = utils.prompt_for_item_in_list(branch_list,
default=default_option)
if branch_name == new_branch_option:
new_branch = True
# Create a new branch if the user specifies or there are no existing branches
if len(branch_list) == 0 or new_branch:
new_branch = True
io.echo()
io.echo('Enter Branch Name')
io.echo('***** Must have at least one commit to create a new branch with CodeCommit *****')
unique_name = utils.get_unique_name(current_branch, branch_list)
branch_name = io.prompt_for_unique_name(unique_name, branch_list)
# Setup git to push to this repo
result = codecommit.get_repository(repository)
remote_url = result['repositoryMetadata']['cloneUrlHttp']
source_control.setup_codecommit_remote_repo(remote_url=remote_url)
if len(branch_list) == 0 or new_branch:
LOG.debug("Creating a new branch")
try:
create_codecommit_branch(source_control, branch_name)
except ServiceError:
io.echo("Could not set CodeCommit branch with the current commit, run with '--debug' to get the full error")
return None
elif not new_branch:
LOG.debug("Setting up an existing branch")
succesful_branch = source_control.setup_existing_codecommit_branch(branch_name, remote_url)
if not succesful_branch:
io.echo("Could not set CodeCommit branch, run with '--debug' to get the full error")
return None
return branch_name
def setup_codecommit_remote_repo(repository, source_control):
result = codecommit.get_repository(repository)
remote_url = result['repositoryMetadata']['cloneUrlHttp']
source_control.setup_codecommit_remote_repo(remote_url=remote_url)
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 get_branch_interactive(repository):
source_control = SourceControl.get_source_control()
# Give list of code commit branches to use
new_branch = False
branch_list = codecommit.list_branches(repository)["branches"]
current_branch = source_control.get_current_branch()
# If there are existing branches prompt the user to pick one
if len(branch_list) > 0:
io.echo()
io.echo('Select a branch')
new_branch_option = '[ Create new Branch with local HEAD ]'
branch_list.append(new_branch_option)
try:
default_option = branch_list.index(current_branch) + 1
except ValueError:
default_option = len(branch_list)
branch_name = utils.prompt_for_item_in_list(branch_list,
default=default_option)
if branch_name == new_branch_option:
new_branch = True
# Create a new branch if the user specifies or there are no existing branches
current_commit = source_control.get_current_commit()
if len(branch_list) == 0 or new_branch:
new_branch = True
io.echo()
io.echo('Enter Branch Name')
io.echo(
'***** Must have at least one commit to create a new branch with CodeCommit *****'
)
unique_name = utils.get_unique_name(current_branch, branch_list)
branch_name = io.prompt_for_unique_name(unique_name, branch_list)
# Setup git to push to this repo
result = codecommit.get_repository(repository)
source_control.setup_codecommit_remote_repo(
remote_url=result['repositoryMetadata']['cloneUrlHttp'])
if len(branch_list) == 0 or new_branch:
LOG.debug("Creating a new branch")
try:
# Creating the branch requires that we setup the remote branch first
# to ensure the code commit branch is synced with the local branch
if current_commit is None:
# TODO: Test on windows for weird empty returns with the staged files
staged_files = source_control.get_list_of_staged_files()
if staged_files is None or not staged_files:
source_control.create_initial_commit()
else:
LOG.debug(
"Cannot create placeholder commit because there are staged files: {0}"
.format(staged_files))
io.echo(
"Could not set create a commit with staged files; cannot setup CodeCommit branch without a commit"
)
return None
current_commit = source_control.get_current_commit()
source_control.setup_new_codecommit_branch(branch_name=branch_name)
codecommit.create_branch(repository, branch_name, current_commit)
io.echo("Successfully created branch: {0}".format(branch_name))
except ServiceError:
io.echo(
"Could not set CodeCommit branch with the current commit, run with '--debug' to get the full error"
)
return None
elif not new_branch:
LOG.debug("Setting up an existing branch")
succesful_branch = source_control.setup_existing_codecommit_branch(
branch_name)
if not succesful_branch:
io.echo(
"Could not set CodeCommit branch, run with '--debug' to get the full error"
)
return None
return branch_name
def setup_codecommit_remote_repo(repository, source_control):
result = codecommit.get_repository(repository)
remote_url = result['repositoryMetadata']['cloneUrlHttp']
source_control.setup_codecommit_remote_repo(remote_url=remote_url)
