def _get_solution_stack():
solution_string = solution_stack_ops.get_default_solution_stack()
soln_stk = None
# Test out sstack and tier before we ask any questions (Fast Fail)
if solution_string:
if PlatformVersion.is_valid_arn(solution_string):
try:
platformops.describe_custom_platform_version(solution_string)
except NotFoundError:
raise NotFoundError(
'Platform arn {} does not appear to be valid'.format(
solution_string))
soln_stk = PlatformVersion(solution_string)
else:
try:
soln_stk = solution_stack_ops.find_solution_stack_from_string(
solution_string)
if PlatformVersion.is_valid_arn(soln_stk):
soln_stk = PlatformVersion.get_platform_name(soln_stk)
except NotFoundError:
raise NotFoundError(
'Solution stack {} does not appear to be valid'.format(
solution_string))
if not soln_stk:
raise NotInitializedError
return soln_stk
def do_upgrade(env_name, add_rolling, timeout, solution_stack_name,
health_based=False, platform_arn=None):
if add_rolling:
if health_based:
roll_type = 'Health'
else:
roll_type = 'Time'
changes = [
elasticbeanstalk.create_option_setting(
namespaces.ROLLING_UPDATES,
option_names.ROLLING_UPDATE_ENABLED,
'true'),
elasticbeanstalk.create_option_setting(
namespaces.ROLLING_UPDATES,
option_names.ROLLING_UPDATE_TYPE,
roll_type)
]
io.log_warning(prompts['upgrade.applyrolling'].format(roll_type))
else:
changes = None
if PlatformVersion.is_valid_arn(platform_arn):
commonops.update_environment(
env_name, changes, None, timeout=timeout,
platform_arn=platform_arn)
else:
commonops.update_environment(
env_name, changes, None, timeout=timeout,
solution_stack_name=solution_stack_name)
def do_upgrade(env_name,
add_rolling,
timeout,
solution_stack_name,
health_based=False,
platform_arn=None):
if add_rolling:
if health_based:
roll_type = 'Health'
else:
roll_type = 'Time'
changes = [
elasticbeanstalk.create_option_setting(
namespaces.ROLLING_UPDATES,
option_names.ROLLING_UPDATE_ENABLED, 'true'),
elasticbeanstalk.create_option_setting(
namespaces.ROLLING_UPDATES, option_names.ROLLING_UPDATE_TYPE,
roll_type)
]
io.log_warning(prompts['upgrade.applyrolling'].format(roll_type))
else:
changes = None
if PlatformVersion.is_valid_arn(platform_arn):
commonops.update_environment(env_name,
changes,
None,
timeout=timeout,
platform_arn=platform_arn)
else:
commonops.update_environment(env_name,
changes,
None,
timeout=timeout,
solution_stack_name=solution_stack_name)
def _get_solution_stack():
solution_string = commonops.get_default_solution_stack()
soln_stk = None
# Test out sstack and tier before we ask any questions (Fast Fail)
if solution_string:
if PlatformVersion.is_valid_arn(solution_string):
try:
elasticbeanstalk.describe_platform_version(solution_string)['PlatformDescription']
except NotFoundError:
raise NotFoundError('Platform arn %s does not appear to be valid' % solution_string)
soln_stk = PlatformVersion(solution_string)
else:
try:
soln_stk = commonops.get_solution_stack(solution_string)
except NotFoundError:
raise NotFoundError('Solution stack ' + solution_string +
' does not appear to be valid')
LOG.debug(soln_stk)
if soln_stk is None:
raise NotInitializedError
else:
return soln_stk
def get_latest_solution_stack(platform_version, stack_list=None):
if PlatformVersion.is_valid_arn(platform_version):
return get_latest_platform(platform_version)
if stack_list:
solution_stacks = stack_list
else:
solution_stacks = elasticbeanstalk.\
get_available_solution_stacks()
#filter
solution_stacks = [
x for x in solution_stacks if x.version == platform_version
]
#Lastly choose a server type
servers = []
for stack in solution_stacks:
if stack.server not in servers:
servers.append(stack.server)
# Default to latest version of server
# We are assuming latest is always first in list.
if len(servers) < 1:
raise NotFoundError(strings['sstacks.notaversion'].replace(
'{version}', platform_version))
server = servers[0]
#filter
solution_stacks = [x for x in solution_stacks if x.server == server]
#should have 1 and only have 1 result
assert len(solution_stacks) == 1, 'Filtered Solution Stack list ' \
'contains multiple results'
return solution_stacks[0]
def do_command(self):
version = self.app.pargs.version
stream = self.app.pargs.stream
if version is None:
platform_name = fileoperations.get_platform_name()
version = fileoperations.get_platform_version()
else:
platform_name = fileoperations.get_platform_name()
if VALID_PLATFORM_VERSION_FORMAT.match(version):
pass
elif PlatformVersion.is_valid_arn(version):
_, platform_name, version = PlatformVersion.arn_to_platform(version)
elif VALID_PLATFORM_SHORT_FORMAT.match(version):
match = VALID_PLATFORM_SHORT_FORMAT.match(version)
platform_name, version = match.group(1, 2)
else:
raise InvalidPlatformVersionError(strings['exit.invalidversion'])
io.echo('Retrieving logs...')
if stream:
try:
logsops.stream_platform_logs(
platform_name,
version,
log_name="%s/%s" % (platform_name, version),
formatter=platformops.PackerStreamFormatter())
except NotFoundError:
raise NotFoundError('Unable to find logs in CloudWatch.')
else:
paginate_cloudwatch_logs(platform_name, version)
def do_command(self):
version = self.app.pargs.version
stream = self.app.pargs.stream
if version is None:
platform_name = fileoperations.get_platform_name()
version = fileoperations.get_platform_version()
else:
platform_name = fileoperations.get_platform_name()
if VALID_PLATFORM_VERSION_FORMAT.match(version):
pass
elif PlatformVersion.is_valid_arn(version):
_, platform_name, version = PlatformVersion.arn_to_platform(version)
elif VALID_PLATFORM_SHORT_FORMAT.match(version):
match = VALID_PLATFORM_SHORT_FORMAT.match(version)
platform_name, version = match.group(1, 2)
else:
raise InvalidPlatformVersionError(strings['exit.invalidversion'])
io.echo('Retrieving logs...')
if stream:
try:
logsops.stream_platform_logs(
platform_name,
version,
log_name="%s/%s" % (platform_name, version),
# Packer is our only builder type at this point
formatter=platformops.PackerStreamFormatter())
except NotFoundError:
raise NotFoundError('Unable to find logs in CloudWatch.')
else:
# print with paginator
paginate_cloudwatch_logs(platform_name, version)
def get_platform_for_platform_string(platform_string):
if PlatformVersion.is_valid_arn(platform_string):
return PlatformVersion(platform_string).hydrate(
elasticbeanstalk.describe_platform_version)
if platform_branch_ops.is_platform_branch_name(platform_string):
return platform_version_ops.get_preferred_platform_version_for_branch(platform_string)
return solution_stack_ops.find_solution_stack_from_string(platform_string)
def put(self):
app_name = self.get_app_name()
name = self._get_cfg_name('put')
platform = solution_stack_ops.get_default_solution_stack()
if not PlatformVersion.is_valid_arn(platform):
platform = solution_stack_ops.find_solution_stack_from_string(platform)
platform = platform.name
saved_configs.update_config(app_name, name)
filename = fileoperations.get_filename_without_extension(name)
saved_configs.validate_config_file(app_name, filename, platform)
def _name_to_arn(platform_name):
arn = None
if PlatformRegExpressions.VALID_PLATFORM_NAME_FORMAT.match(platform_name):
arn = platform_version_ops.get_platform_arn(platform_name, "latest", owner=Constants.OWNED_BY_SELF)
elif PlatformVersion.is_valid_arn(platform_name):
arn = platform_name
elif PlatformRegExpressions.VALID_PLATFORM_SHORT_FORMAT.match(platform_name):
match = PlatformRegExpressions.VALID_PLATFORM_SHORT_FORMAT.match(platform_name)
platform_name, platform_version = match.group(1, 2)
arn = platform_version_ops.get_platform_arn(platform_name, platform_version, owner=Constants.OWNED_BY_SELF)
if not arn:
raise InvalidPlatformVersionError(strings['exit.nosuchplatform'])
return arn
def _name_to_arn(platform_name):
arn = None
if VALID_PLATFORM_NAME_FORMAT.match(platform_name):
arn = _get_platform_arn(platform_name, "latest", owner=Constants.OWNED_BY_SELF)
elif PlatformVersion.is_valid_arn(platform_name):
arn = platform_name
elif VALID_PLATFORM_SHORT_FORMAT.match(platform_name):
match = VALID_PLATFORM_SHORT_FORMAT.match(platform_name)
platform_name, platform_version = match.group(1, 2)
arn = _get_platform_arn(platform_name, platform_version, owner=Constants.OWNED_BY_SELF)
if not arn:
raise InvalidPlatformVersionError(strings['exit.nosuchplatform'])
return arn
def _version_to_arn(platform_version):
platform_name = fileoperations.get_platform_name()
if VALID_PLATFORM_VERSION_FORMAT.match(platform_version):
arn = _get_platform_arn(platform_name, platform_version, owner=Constants.OWNED_BY_SELF)
elif PlatformVersion.is_valid_arn(platform_version):
arn = platform_version
elif VALID_PLATFORM_SHORT_FORMAT.match(platform_version):
match = VALID_PLATFORM_SHORT_FORMAT.match(platform_version)
platform_name, platform_version = match.group(1, 2)
arn = _get_platform_arn(platform_name, platform_version, owner=Constants.OWNED_BY_SELF)
if not arn:
raise InvalidPlatformVersionError(strings['exit.nosuchplatformversion'])
return arn
def validate_template(app_name, template_name, platform=None):
kwargs = {}
if platform:
if PlatformVersion.is_valid_arn(platform):
kwargs['TemplateSpecification'] = \
{'TemplateSource':
{'PlatformArn': platform}}
else:
kwargs['TemplateSpecification'] = \
{'TemplateSource':
{'SolutionStackName': platform}}
result = _make_api_call('validate_configuration_settings',
ApplicationName=app_name,
TemplateName=template_name,
**kwargs)
return result
def version_to_arn(platform_version):
platform_name = fileoperations.get_platform_name()
arn = None
if PlatformRegExpressions.VALID_PLATFORM_VERSION_FORMAT.match(platform_version):
arn = get_platform_arn(platform_name, platform_version, owner=Constants.OWNED_BY_SELF)
elif PlatformVersion.is_valid_arn(platform_version):
arn = platform_version
elif PlatformRegExpressions.VALID_PLATFORM_SHORT_FORMAT.match(platform_version):
match = PlatformRegExpressions.VALID_PLATFORM_SHORT_FORMAT.match(platform_version)
platform_name, platform_version = match.group(1, 2)
arn = get_platform_arn(platform_name, platform_version, owner=Constants.OWNED_BY_SELF)
if not arn:
raise InvalidPlatformVersionError(strings['exit.nosuchplatformversion'])
return arn
def _version_to_arn(platform_version):
platform_name = fileoperations.get_platform_name()
if VALID_PLATFORM_VERSION_FORMAT.match(platform_version):
arn = _get_platform_arn(platform_name,
platform_version,
owner=Constants.OWNED_BY_SELF)
elif PlatformVersion.is_valid_arn(platform_version):
arn = platform_version
elif VALID_PLATFORM_SHORT_FORMAT.match(platform_version):
match = VALID_PLATFORM_SHORT_FORMAT.match(platform_version)
platform_name, platform_version = match.group(1, 2)
arn = _get_platform_arn(platform_name,
platform_version,
owner=Constants.OWNED_BY_SELF)
else:
raise InvalidPlatformVersionError(strings['exit.invalidversion'])
return arn
def validate_template(app_name, template_name, platform=None):
kwargs = {}
if platform:
if PlatformVersion.is_valid_arn(platform):
kwargs['TemplateSpecification'] = \
{'TemplateSource':
{'PlatformArn': platform}}
else:
kwargs['TemplateSpecification'] = \
{'TemplateSource':
{'SolutionStackName': platform}}
result = _make_api_call('validate_configuration_settings',
ApplicationName=app_name,
TemplateName=template_name,
**kwargs)
return result
def do_command(self):
app_name = self.get_app_name()
env_name = self.get_env_name(noerror=True)
# This could be an ARN or a solution stack platform / or solution stack short name
config_platform = commonops.get_default_solution_stack()
want_solution_stack = False
if PlatformVersion.is_valid_arn(config_platform):
platform_name, latest_platform = self.get_latest_platform(
config_platform)
else:
want_solution_stack = True
platform_name, latest_platform = self.get_latest_solution_stack(
config_platform)
io.echo('Current default platform:', config_platform)
if config_platform.lower() is platform_name.lower():
io.echo('Most recent platform: ', latest_platform)
else:
io.echo('New environments will be running: ', platform_name)
if env_name:
if want_solution_stack:
platform = platformops.get_environment_platform(
app_name,
env_name,
want_solution_stack=want_solution_stack).name
else:
platform = platformops.get_environment_platform(
app_name,
env_name,
want_solution_stack=want_solution_stack).arn
io.echo()
io.echo('Platform info for environment "{env_name}":'.format(
env_name=env_name))
io.echo('Current:', platform)
io.echo('Latest: ', latest_platform)
if latest_platform is platform:
io.echo(strings['platformstatus.upgrade'])
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
# Get original environment
env = elasticbeanstalk.get_environment(app_name, env_name)
# Get tier of original environment
tier = env.tier
if 'worker' in tier.name.lower() and cname:
raise InvalidOptionsError(strings['worker.cname'])
if cname:
if not commonops.is_cname_available(cname):
raise AlreadyExistsError(strings['cname.unavailable'].
replace('{cname}', cname))
# get tags
tags = get_and_validate_tags(tags)
envvars = get_and_validate_envars(envvars)
# Get env_name for clone
if not clone_name:
if len(env_name) < 16:
unique_name = env_name + '-clone'
else:
unique_name = 'my-cloned-env'
env_list = commonops.get_env_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(clone_name)
elif not cname:
cname = None
if not exact:
if not provided_clone_name: # interactive mode
latest = commonops.get_latest_solution_stack(
env.platform.version)
if latest != env.platform:
# ask for latest or exact
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:
# assume latest - get original platform
platform = commonops.get_latest_solution_stack(
env.platform.version)
if platform != env.platform:
io.log_warning(prompts['clone.latestwarn'])
if platform and PlatformVersion.is_valid_arn(platform.version):
clone_request = CloneEnvironmentRequest(
app_name=app_name,
env_name=clone_name,
original_name=env_name,
cname=cname,
platform_arn=platform.version,
scale=scale,
tags=tags,
)
else:
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)
def test_is_valid_arn__returns_none_when_arn_is_not_found(self):
arn = 'node.js'
self.assertFalse(PlatformVersion.is_valid_arn(arn))
def test_is_valid_arn__custom_platform_arn(self):
arn = 'arn:aws:elasticbeanstalk:us-east-1:00000000000:platform/Name/0.0.0'
self.assertTrue(PlatformVersion.is_valid_arn(arn))
def test_is_valid_arn__managed_platform_arn(self):
arn = 'arn:aws:elasticbeanstalk:us-east-1::platform/Name/1.0.0'
self.assertTrue(PlatformVersion.is_valid_arn(arn))
def do_command(self):
# save command line args
env_name = self.app.pargs.environment_name
modules = self.app.pargs.modules
if modules and len(modules) > 0:
self.compose_multiple_apps()
return
group = self.app.pargs.env_group_suffix
cname = self.app.pargs.cname
tier = self.app.pargs.tier
itype = self.app.pargs.instance_type
solution_string = self.app.pargs.platform
single = self.app.pargs.single
iprofile = self.app.pargs.instance_profile
service_role = self.app.pargs.service_role
label = self.app.pargs.version
branch_default = self.app.pargs.branch_default
key_name = self.app.pargs.keyname
sample = self.app.pargs.sample
nohang = self.app.pargs.nohang
tags = self.app.pargs.tags
envvars = self.app.pargs.envvars
scale = self.app.pargs.scale
timeout = self.app.pargs.timeout
cfg = self.app.pargs.cfg
elb_type = self.app.pargs.elb_type
source = self.app.pargs.source
process = self.app.pargs.process
region = self.app.pargs.region
interactive = False if env_name else True
platform_arn = None
solution = None
provided_env_name = env_name is not None
if sample and label:
raise InvalidOptionsError(strings['create.sampleandlabel'])
if single and scale:
raise InvalidOptionsError(strings['create.singleandsize'])
if single and elb_type:
raise InvalidOptionsError(strings['create.single_and_elb_type'])
app_name = self.get_app_name()
# get tags
tags = createops.get_and_validate_tags(tags)
#load solution stack
if not solution_string:
solution_string = solution_stack_ops.get_default_solution_stack()
# Test out sstack and tier before we ask any questions (Fast Fail)
if solution_string:
if PlatformVersion.is_valid_arn(solution_string):
platform_arn = solution_string
else:
try:
solution = solution_stack_ops.find_solution_stack_from_string(
solution_string)
except NotFoundError:
raise NotFoundError('Platform ' + solution_string +
' does not appear to be valid')
if tier:
if 'worker' in tier.lower() and cname:
raise InvalidOptionsError(strings['worker.cname'])
try:
tier = Tier.parse_tier(tier)
except NotFoundError:
raise NotFoundError('Provided tier ' + tier + ' does not '
'appear to be valid')
if cname:
if not commonops.is_cname_available(cname):
raise AlreadyExistsError(strings['cname.unavailable'].replace(
'{cname}', cname))
# If we still dont have what we need, ask for it
if not solution_string:
solution = solution_stack_ops.get_solution_stack_from_customer()
if solution:
if isinstance(solution,
PlatformVersion) and PlatformVersion.is_valid_arn(
solution.arn):
platform_arn = solution
solution = None
elif solution.language_name == 'Multi-container Docker' and not iprofile:
io.log_warning(prompts['ecs.permissions'])
if not env_name:
# default is app-name plus '-dev'
default_name = app_name + '-dev'
current_environments = commonops.get_all_env_names()
unique_name = utils.get_unique_name(default_name,
current_environments)
if fileoperations.env_yaml_exists():
env_name = fileoperations.get_env_name_from_env_yaml()
if env_name is not None:
if env_name.endswith('+') and group is None:
io.echo(strings['create.missinggroupsuffix'])
return
else:
env_name = env_name[:-1] + '-' + group
else:
env_name = io.prompt_for_environment_name(unique_name)
else:
env_name = io.prompt_for_environment_name(unique_name)
# Get template if applicable
template_name = get_template_name(app_name, cfg)
if template_name:
template_contents = elasticbeanstalk.describe_template(
app_name, template_name)
if template_contents['Tier']['Name'] == 'Worker':
tier = Tier.parse_tier('worker')
if not tier or tier.name.lower() == 'webserver':
if not cname and not provided_env_name:
cname = get_cname(env_name)
elif not cname:
cname = None
if not key_name:
key_name = commonops.get_default_keyname()
if not elb_type and interactive and not single:
elb_type = get_elb_type(region)
database = self.form_database_object()
vpc = self.form_vpc_object()
envvars = get_and_validate_envars(envvars)
env_request = CreateEnvironmentRequest(app_name=app_name,
env_name=env_name,
group_name=group,
cname=cname,
template_name=template_name,
platform=solution,
tier=tier,
instance_type=itype,
version_label=label,
instance_profile=iprofile,
service_role=service_role,
single_instance=single,
key_name=key_name,
sample_application=sample,
tags=tags,
scale=scale,
database=database,
vpc=vpc,
elb_type=elb_type,
platform_arn=platform_arn)
env_request.option_settings += envvars
process_app_version = fileoperations.env_yaml_exists() or process
# avoid prematurely timing out in the CLI when an environment is launched with a RDS DB
if not timeout and database:
timeout = 15
createops.make_new_env(env_request,
branch_default=branch_default,
process_app_version=process_app_version,
nohang=nohang,
interactive=interactive,
timeout=timeout,
source=source)
def is_platform_branch_name(platform_string):
return bool(
# a platform branch name cannot be an arn
not PlatformVersion.is_valid_arn(platform_string)
# request the platform branch from the api to determine if it exists
and get_platform_branch_by_name(platform_string))
