def _choose_cfg_name(app_name, env_name):
configs = saved_configs.get_configurations(app_name)
io.echo()
io.echo('Enter desired name of configuration.')
default = utils.get_unique_name(env_name + '-sc', configs)
cfg_name = io.prompt_for_unique_name(default, configs)
return cfg_name
def _get_application_name_interactive():
app_list = commonops.get_application_names()
file_name = fileoperations.get_current_directory_name()
new_app = False
if len(app_list) > 0:
io.echo()
io.echo('Select an application to use')
new_app_option = '[ Create new Application ]'
app_list.append(new_app_option)
try:
default_option = app_list.index(file_name) + 1
except ValueError:
default_option = len(app_list)
app_name = utils.prompt_for_item_in_list(app_list,
default=default_option)
if app_name == new_app_option:
new_app = True
if len(app_list) == 0 or new_app:
io.echo()
io.echo('Enter Application Name')
unique_name = utils.get_unique_name(file_name, app_list)
app_name = io.prompt_for_unique_name(unique_name, app_list)
return app_name
def get_platform_name_and_version_interactive():
platforms = get_platforms(owner=Constants.OWNED_BY_SELF, platform_version="latest")
platform_list = list(platforms)
file_name = fileoperations.get_current_directory_name()
new_platform = False
version = None
if len(platform_list) > 0:
io.echo()
io.echo('Select a platform to use')
new_platform_option = '[ Create new Platform ]'
platform_list.append(new_platform_option)
try:
default_option = platform_list.index(file_name) + 1
except ValueError:
default_option = len(platform_list)
platform_name = utils.prompt_for_item_in_list(platform_list, default=default_option)
if platform_name == new_platform_option:
new_platform = True
else:
version = platforms[platform_name]
if len(platform_list) == 0 or new_platform:
io.echo()
io.echo('Enter Platform Name')
unique_name = utils.get_unique_name(file_name, platform_list)
platform_name = io.prompt_for_unique_name(unique_name, platform_list)
return platform_name, version
def _get_application_name_interactive():
app_list = elasticbeanstalk.get_application_names()
file_name = fileoperations.get_current_directory_name()
new_app = False
if len(app_list) > 0:
io.echo()
io.echo('Select an application to use')
new_app_option = '[ Create new Application ]'
app_list.append(new_app_option)
try:
default_option = app_list.index(file_name) + 1
except ValueError:
default_option = len(app_list)
app_name = utils.prompt_for_item_in_list(app_list,
default=default_option)
if app_name == new_app_option:
new_app = True
if len(app_list) == 0 or new_app:
io.echo()
io.echo('Enter Application Name')
unique_name = utils.get_unique_name(file_name, app_list)
app_name = io.prompt_for_unique_name(unique_name, app_list)
return app_name
def get_platform_name_and_version_interactive():
platforms = get_platforms(owner=Constants.OWNED_BY_SELF,
platform_version="latest")
platform_list = list(platforms)
file_name = fileoperations.get_current_directory_name()
new_platform = False
version = None
if len(platform_list) > 0:
io.echo()
io.echo('Select a platform to use')
new_platform_option = '[ Create new Platform ]'
platform_list.append(new_platform_option)
try:
default_option = platform_list.index(file_name) + 1
except ValueError:
default_option = len(platform_list)
platform_name = utils.prompt_for_item_in_list(platform_list,
default=default_option)
if platform_name == new_platform_option:
new_platform = True
else:
version = platforms[platform_name]
if len(platform_list) == 0 or new_platform:
io.echo()
io.echo('Enter Platform Name')
unique_name = utils.get_unique_name(file_name, platform_list)
platform_name = io.prompt_for_unique_name(unique_name, platform_list)
return platform_name, version
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 get_unique_environment_name(app_name):
"""
Derive a unique name for a new environment based on the application name
to suggest to the customer
:param app_name: name of the application associated with the present working
directory
:return: A unique name for a new environment
"""
default_name = app_name + '-dev'
current_environments = elasticbeanstalk.get_all_environment_names()
return utils.get_unique_name(default_name, current_environments)
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 get_unique_cname(env_name):
"""
Derive a unique CNAME for a new environment based on the environment name
:param env_name: name of the environment
directory
:return: A unique CNAME for a new environment
"""
cname = env_name
tried_cnames = []
while not elasticbeanstalk.is_cname_available(cname):
tried_cnames.append(cname)
_sleep(0.5)
cname = utils.get_unique_name(cname, tried_cnames)
return cname
def create_env(env_request, interactive=True):
# If a template is being used, we want to try using just the template
if env_request.template_name:
platform = env_request.platform
env_request.platform = None
else:
platform = None
while True:
try:
return elasticbeanstalk.create_environment(env_request)
except InvalidParameterValueError as e:
if e.message == responses['app.notexists'].replace(
'{app-name}', '\'' + env_request.app_name + '\''):
# App doesnt exist, must be a new region.
## Lets create the app in the region
commonops.create_app(env_request.app_name)
elif e.message == responses['create.noplatform']:
if platform:
env_request.platform = platform
else:
raise
elif interactive:
LOG.debug('creating env returned error: ' + e.message)
if re.match(responses['env.cnamenotavailable'], e.message):
io.echo(prompts['cname.unavailable'])
cname = io.prompt_for_cname()
elif re.match(responses['env.nameexists'], e.message):
io.echo(strings['env.exists'])
current_environments = elasticbeanstalk.get_all_environment_names(
)
unique_name = utils.get_unique_name(
env_request.env_name, current_environments)
env_request.env_name = io.prompt_for_environment_name(
default_name=unique_name)
elif e.message == responses['app.notexists'].replace(
'{app-name}', '\'' + env_request.app_name + '\''):
# App doesnt exist, must be a new region.
## Lets create the app in the region
commonops.create_app(env_request.app_name)
else:
raise
else:
raise
def clone_env(clone_request):
while True:
try:
return elasticbeanstalk.clone_environment(clone_request)
except InvalidParameterValueError as e:
LOG.debug('cloning env returned error: ' + e.message)
if re.match(responses['env.cnamenotavailable'], e.message):
io.echo(prompts['cname.unavailable'])
clone_request.cname = io.prompt_for_cname()
elif re.match(responses['env.nameexists'], e.message):
io.echo(strings['env.exists'])
current_environments = elasticbeanstalk.get_environment_names(
clone_request.app_name)
unique_name = utils.get_unique_name(clone_request.env_name,
current_environments)
clone_request.env_name = io.prompt_for_environment_name(
default_name=unique_name)
else:
raise
def create_env(env_request, interactive=True):
# If a template is being used, we want to try using just the template
if env_request.template_name:
platform = env_request.platform
env_request.platform = None
else:
platform = None
while True:
try:
return elasticbeanstalk.create_environment(env_request)
except InvalidParameterValueError as e:
if e.message == responses['app.notexists'].replace(
'{app-name}', '\'' + env_request.app_name + '\''):
# App doesnt exist, must be a new region.
## Lets create the app in the region
commonops.create_app(env_request.app_name)
elif e.message == responses['create.noplatform']:
if platform:
env_request.platform = platform
else:
raise
elif interactive:
LOG.debug('creating env returned error: ' + e.message)
if re.match(responses['env.cnamenotavailable'], e.message):
io.echo(prompts['cname.unavailable'])
cname = io.prompt_for_cname()
elif re.match(responses['env.nameexists'], e.message):
io.echo(strings['env.exists'])
current_environments = elasticbeanstalk.get_all_environment_names()
unique_name = utils.get_unique_name(env_request.env_name,
current_environments)
env_request.env_name = io.prompt_for_environment_name(
default_name=unique_name)
elif e.message == responses['app.notexists'].replace(
'{app-name}', '\'' + env_request.app_name + '\''):
# App doesnt exist, must be a new region.
## Lets create the app in the region
commonops.create_app(env_request.app_name)
else:
raise
else:
raise
def _generate_and_upload_keypair(keys):
io.echo()
io.echo(prompts['keypair.nameprompt'])
unique = utils.get_unique_name('aws-eb', keys)
keyname = io.prompt('Default is ' + unique, default=unique)
file_name = fileoperations.get_ssh_folder() + keyname
try:
exitcode = subprocess.call(
['ssh-keygen', '-f', file_name, '-C', keyname])
except OSError:
raise CommandError(strings['ssh.notpresent'])
if exitcode == 0 or exitcode == 1:
commonops.upload_keypair_if_needed(keyname)
return keyname
else:
LOG.debug('ssh-keygen returned exitcode: ' + str(exitcode) +
' with filename: ' + file_name)
raise CommandError('An error occurred while running ssh-keygen.')
def get_repository_interactive():
source_control = SourceControl.get_source_control()
# Give list of code commit repositories to use
new_repo = False
repo_list = codecommit.list_repositories()["repositories"]
current_repository = source_control.get_current_repository()
current_repository = fileoperations.get_current_directory_name() \
if current_repository is None else current_repository
# If there are existing repositories prompt the user to pick one
# otherwise set default as the file name
if len(repo_list) > 0:
repo_list = list(map(lambda r: r["repositoryName"], repo_list))
io.echo()
io.echo('Select a repository')
new_repo_option = '[ Create new Repository ]'
repo_list.append(new_repo_option)
try:
default_option = repo_list.index(current_repository) + 1
except ValueError:
default_option = len(repo_list)
repo_name = utils.prompt_for_item_in_list(repo_list,
default=default_option)
if repo_name == new_repo_option:
new_repo = True
# Create a new repository if the user specifies or there are no existing repositories
if len(repo_list) == 0 or new_repo:
io.echo()
io.echo('Enter Repository Name')
unique_name = utils.get_unique_name(current_repository, repo_list)
repo_name = io.prompt_for_unique_name(unique_name, repo_list)
# Create the repository if we get here
codecommit.create_repository(repo_name, "Created with EB CLI")
io.echo("Successfully created repository: {0}".format(repo_name))
return repo_name
def get_repository_interactive():
source_control = SourceControl.get_source_control()
# Give list of code commit repositories to use
new_repo = False
repo_list = codecommit.list_repositories()["repositories"]
current_repository = source_control.get_current_repository()
current_repository = current_repository or fileoperations.get_current_directory_name()
# If there are existing repositories prompt the user to pick one
# otherwise set default as the file name
if len(repo_list) > 0:
repo_list = list(map(lambda r: r["repositoryName"], repo_list))
io.echo()
io.echo('Select a repository')
new_repo_option = '[ Create new Repository ]'
repo_list.append(new_repo_option)
try:
default_option = repo_list.index(current_repository) + 1
except ValueError:
default_option = len(repo_list)
repo_name = utils.prompt_for_item_in_list(repo_list,
default=default_option)
if repo_name == new_repo_option:
new_repo = True
# Create a new repository if the user specifies or there are no existing repositories
if len(repo_list) == 0 or new_repo:
io.echo()
io.echo('Enter Repository Name')
unique_name = utils.get_unique_name(current_repository, repo_list)
repo_name = io.prompt_for_unique_name(unique_name, repo_list)
create_codecommit_repository(repo_name)
return repo_name
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 do_command(self):
app_name = self.get_app_name()
env_name = self.get_env_name()
clone_name = self.app.pargs.clone_name
cname = self.app.pargs.cname
scale = self.app.pargs.scale
nohang = self.app.pargs.nohang
tags = self.app.pargs.tags
envvars = self.app.pargs.envvars
exact = self.app.pargs.exact
timeout = self.app.pargs.timeout
provided_clone_name = clone_name is not None
platform = None
env = elasticbeanstalk.get_environment(app_name=app_name,
env_name=env_name)
tier = env.tier
if 'worker' in tier.name.lower() and cname:
raise InvalidOptionsError(strings['worker.cname'])
if cname:
if not elasticbeanstalk.is_cname_available(cname):
raise AlreadyExistsError(strings['cname.unavailable'].replace(
'{cname}', cname))
tags = tagops.get_and_validate_tags(tags)
envvars = get_and_validate_envars(envvars)
if not clone_name:
if len(env_name) < 16:
unique_name = env_name + '-clone'
else:
unique_name = 'my-cloned-env'
env_list = elasticbeanstalk.get_environment_names(app_name)
unique_name = utils.get_unique_name(unique_name, env_list)
clone_name = io.prompt_for_environment_name(
default_name=unique_name,
prompt_text='Enter name for Environment Clone')
if tier.name.lower() == 'webserver':
if not cname and not provided_clone_name:
cname = get_cname_from_customer(clone_name)
elif not cname:
cname = None
if not exact:
if not provided_clone_name:
latest = solution_stack_ops.find_solution_stack_from_string(
env.platform.name, find_newer=True)
if latest != env.platform:
io.echo()
io.echo(prompts['clone.latest'])
lst = [
'Latest (' + str(latest) + ')',
'Same (' + str(env.platform) + ')'
]
result = utils.prompt_for_item_in_list(lst)
if result == lst[0]:
platform = latest
else:
platform = latest
else:
platform = solution_stack_ops.find_solution_stack_from_string(
env.platform.name, find_newer=True)
if platform != env.platform:
io.log_warning(prompts['clone.latestwarn'])
clone_request = CloneEnvironmentRequest(
app_name=app_name,
env_name=clone_name,
original_name=env_name,
cname=cname,
platform=platform,
scale=scale,
tags=tags,
)
clone_request.option_settings += envvars
cloneops.make_cloned_env(clone_request, nohang=nohang, timeout=timeout)