def __formatted_platform_descriptions(platforms_list, show_status):
platform_tuples = []
for platform in platforms_list:
platform_tuples.append(
{
'PlatformArn': platform['PlatformArn'],
'PlatformStatus': platform['PlatformStatus']
}
)
# Sort by name, then by version
platform_tuples.sort(
key=lambda platform_tuple: (
PlatformVersion.get_platform_name(platform_tuple['PlatformArn']),
Version(PlatformVersion.get_platform_version(platform_tuple['PlatformArn']))
),
reverse=True
)
formatted_platform_descriptions = []
for index, platform_tuple in enumerate(platform_tuples):
if show_status:
formatted_platform_description = '{platform_arn} Status: {platform_status}'.format(
platform_arn=platform_tuple['PlatformArn'],
platform_status=platform_tuple['PlatformStatus']
)
else:
formatted_platform_description = platform_tuple['PlatformArn']
formatted_platform_descriptions.append(formatted_platform_description)
return formatted_platform_descriptions
def alert_platform_status(
platform_version,
platform_old_alert=alerts['platform.old'],
platform_not_recommended_alert=alerts['platform.notrecommended'],
branch_deprecated_alert=alerts['platformbranch.deprecated'],
branch_retired_alert=alerts['platformbranch.retired']):
"""
Logs an alert for a platform version status and it's platform branch's
status if either are out-of-date or reaching end-of-life.
"""
if not isinstance(platform_version, PlatformVersion):
platform_version = PlatformVersion(platform_arn=platform_version)
platform_version.hydrate(elasticbeanstalk.describe_platform_version)
if platform_version.platform_branch_name:
branch = platform_version.platform_branch_name
alert_platform_branch_status(
branch,
branch_deprecated_alert=branch_deprecated_alert,
branch_retired_alert=branch_retired_alert,
)
alert_platform_version_status(
platform_version,
platform_old_alert=platform_old_alert,
platform_not_recommended_alert=platform_not_recommended_alert,
)
def __formatted_platform_descriptions(platforms_list, show_status):
platform_tuples = []
for platform in platforms_list:
platform_tuples.append({
'PlatformArn': platform['PlatformArn'],
'PlatformStatus': platform['PlatformStatus']
})
# Sort by name, then by version
platform_tuples.sort(
key=lambda platform_tuple:
(PlatformVersion.get_platform_name(platform_tuple['PlatformArn']),
Version(
PlatformVersion.get_platform_version(platform_tuple['PlatformArn']
))),
reverse=True)
formatted_platform_descriptions = []
for index, platform_tuple in enumerate(platform_tuples):
if show_status:
formatted_platform_description = '{platform_arn} Status: {platform_status}'.format(
platform_arn=platform_tuple['PlatformArn'],
platform_status=platform_tuple['PlatformStatus'])
else:
formatted_platform_description = platform_tuple['PlatformArn']
formatted_platform_descriptions.append(formatted_platform_description)
return formatted_platform_descriptions
def test_status__verbose_mode__elbv2(
self, get_target_group_healths_mock,
get_target_groups_for_load_balancer_mock,
get_environment_resources_mock, get_default_repository_mock,
get_default_branch_mock, echo_mock, log_alert_mock,
find_solution_stack_from_string_mock, get_environment_mock):
environment_object = Environment.json_to_environment_object(
mock_responses.DESCRIBE_ENVIRONMENTS_RESPONSE['Environments'][0])
environment_object.platform = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.6'
)
get_environment_mock.return_value = environment_object
find_solution_stack_from_string_mock.return_value = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.6'
)
get_default_branch_mock.return_value = 'branch'
get_default_repository_mock.return_value = 'repository'
get_environment_resources_mock.return_value = mock_responses.DESCRIBE_ENVIRONMENT_RESOURCES_RESPONSE__ELBV2_ENVIRONMENT
get_target_groups_for_load_balancer_mock.return_value = mock_responses.DESCRIBE_TARGET_GROUPS_RESPONSE[
'TargetGroups']
get_target_group_healths_mock.return_value = {
"arn:aws:elasticloadbalancing:us-west-2:123123123123:targetgroup/awseb-AWSEB-179V6JWWL9HI5/e57decc4139bfdd2":
mock_responses.DESCRIBE_TARGET_HEALTH_RESPONSE
}
statusops.status('my-application', 'environment-1', True)
log_alert_mock.assert_not_called()
echo_mock.assert_has_calls([
mock.call('Environment details for:', 'environment-1'),
mock.call(' Application name:', 'my-application'),
mock.call(' Region:', 'us-west-2'),
mock.call(' Deployed Version:', 'Sample Application'),
mock.call(' Environment ID:', 'e-sfsdfsfasdads'),
mock.call(
' Platform:',
PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.6'
)),
mock.call(' Tier:', Tier.from_raw_string('webserver')),
mock.call(' CNAME:',
'environment-1.us-west-2.elasticbeanstalk.com'),
mock.call(
' Updated:',
datetime.datetime(2018,
3,
27,
23,
47,
41,
830000,
tzinfo=tz.tzutc())),
mock.call(' Status:', 'Ready'),
mock.call(' Health:', 'Green'),
mock.call(' Running instances:', 1),
mock.call(' ', 'i-01641763db1c0cb47: healthy'),
mock.call('Current CodeCommit settings:'),
mock.call(' Repository: repository'),
mock.call(' Branch: branch')
])
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 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 list_platform_versions_sorted_by_name(platform_name=None, status=None, owner=None, show_status=False, excludeEBOwned=True):
platform_list = elasticbeanstalk.list_platform_versions(
platform_name=platform_name, status=status, owner=owner)
platform_tuples = list()
platforms = list()
arn_index = 0
status_index = 1
for platform in platform_list:
arn = platform['PlatformArn']
owner = platform['PlatformOwner']
if excludeEBOwned and owner == Constants.AWS_ELASTIC_BEANSTALK_ACCOUNT:
continue
_, platform_name, _ = PlatformVersion.arn_to_platform(arn)
platform_tuples.append((arn, platform['PlatformStatus']))
# Sort by name, then by version
platform_tuples.sort(key=lambda platform: (PlatformVersion.get_platform_name(platform[arn_index]), Version(PlatformVersion.get_platform_version(platform[arn_index]))), reverse=True)
for platform in platform_tuples:
if show_status:
platforms.append("%s Status: %s" % (platform[arn_index], platform[status_index]))
else:
platforms.append(platform[arn_index])
return platforms
def _get_solution_stack():
solution_string = solution_stack_ops.get_default_solution_stack()
soln_stk = None
if solution_string:
if PlatformVersion.is_custom_platform_arn(solution_string):
try:
platform_version_ops.describe_custom_platform_version(
solution_string)
except NotFoundError:
raise NotFoundError(
alerts['platform.invalidstring'].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_eb_managed_platform_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 _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_custom_platform_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_eb_managed_platform_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 _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_custom_platform_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_eb_managed_platform_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 _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 generate_version_to_arn_mappings(custom_platforms, specified_platform_name):
version_to_arn_mappings = {}
for custom_platform in custom_platforms:
custom_platform_name = PlatformVersion.get_platform_name(custom_platform)
if custom_platform_name == specified_platform_name:
version_to_arn_mappings[PlatformVersion.get_platform_version(custom_platform)] = custom_platform
return version_to_arn_mappings
def test_arn_to_platform__raises_when_argument_is_not_arn_like(self):
arn = 'node.js'
with self.assertRaises(
PlatformVersion.UnableToParseArnException) as context_manager:
PlatformVersion.arn_to_platform(arn)
self.assertEqual("Unable to parse arn 'node.js'",
context_manager.exception.message)
def test_has_healthd_support(self):
platform_arn_1 = 'arn:aws:elasticbeanstalk:ap-southeast-2::platform/PHP 5.4 running on 64bit Amazon Linux/2.6.0'
platform_arn_2 = 'arn:aws:elasticbeanstalk:ap-southeast-2::platform/PHP 5.4 running on 64bit Amazon Linux/1.4.6'
platform_arn_3 = 'arn:aws:elasticbeanstalk:ap-southeast-2::platform/IIS 10.0 running on 64bit Windows Server 2016/1.2.0'
self.assertTrue(PlatformVersion(platform_arn_1).has_healthd_support)
self.assertFalse(PlatformVersion(platform_arn_2).has_healthd_support)
self.assertFalse(PlatformVersion(platform_arn_3).has_healthd_support)
def generate_version_to_arn_mappings(custom_platforms, specified_platform_name):
version_to_arn_mappings = {}
for custom_platform in custom_platforms:
custom_platform_name = PlatformVersion.get_platform_name(custom_platform)
if custom_platform_name == specified_platform_name:
version_to_arn_mappings[PlatformVersion.get_platform_version(custom_platform)] = custom_platform
return version_to_arn_mappings
def test_clone__prompt_for_choice_between_current_and_latest_platform_arn_in_interactive_mode(
self,
prompt_for_item_in_list_mock,
find_solution_stack_from_string_mock,
is_cname_available_mock,
get_app_name_mock,
get_env_name_mock,
make_cloned_env_mock,
clone_environment_request_mock,
prompt_for_environment_name_mock,
get_environment_names_mock,
get_environment_mock
):
is_cname_available_mock.return_value = True
find_solution_stack_from_string_mock.return_value = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.2 running on 64bit Amazon Linux/2.6.5'
)
get_app_name_mock.return_value = 'my-application'
get_env_name_mock.return_value = 'environment-1'
prompt_for_environment_name_mock.return_value = 'environment-1-clone'
get_environment_names_mock.return_value = Environment.json_to_environment_objects_array(
mock_responses.DESCRIBE_ENVIRONMENTS_RESPONSE['Environments']
)
get_environment_mock.return_value = environment_from_mock_responses('environment-1')
prompt_for_item_in_list_mock.return_value = 'Latest (arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.2 running on 64bit Amazon Linux/2.6.5)'
clone_environment_request_mock.return_value = mock.MagicMock()
clone_environment_request = clone_environment_request_mock.return_value
app = EB(argv=['clone', '--cname', 'some-cname'])
app.setup()
app.run()
prompt_for_environment_name_mock.assert_called_once_with(
default_name='my-application-clone',
prompt_text='Enter name for Environment Clone'
)
prompt_for_item_in_list_mock.assert_called_once_with(
[
'Latest (arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.2 running on 64bit Amazon Linux/2.6.5)',
'Same (arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.5)'
]
)
clone_environment_request_mock.assert_called_once_with(
app_name='environment-1',
cname='some-cname',
env_name='environment-1-clone',
original_name='my-application',
platform=PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.2 running on 64bit Amazon Linux/2.6.5'
),
scale=None,
tags=[]
)
make_cloned_env_mock.assert_called_once_with(
clone_environment_request,
nohang=False,
timeout=None
)
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 test_get_platform_name__returns_none_when_arn_is_not_found(self):
arn = 'node.js'
with self.assertRaises(
PlatformVersion.UnableToParseArnException) as context_manager:
PlatformVersion.get_platform_name(arn)
self.assertEqual("Unable to parse arn 'node.js'",
context_manager.exception.message)
def test_is_recommended(self):
platform_arn = self.platform_version_description['PlatformArn']
platform_version = PlatformVersion(
platform_arn, platform_lifecycle_state='Recommended')
self.assertTrue(platform_version.is_recommended)
platform_version = PlatformVersion(platform_arn)
self.assertFalse(platform_version.is_recommended)
def test_status__verbose_mode__elb(
self, get_health_of_instances_mock, get_environment_resources_mock,
get_default_repository_mock, get_default_branch_mock, echo_mock,
log_alert_mock, find_solution_stack_from_string_mock,
get_environment_mock):
environment_object = Environment.json_to_environment_object(
mock_responses.DESCRIBE_ENVIRONMENTS_RESPONSE['Environments'][0])
environment_object.platform = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.6'
)
get_environment_mock.return_value = environment_object
find_solution_stack_from_string_mock.return_value = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.6'
)
get_default_branch_mock.return_value = 'branch'
get_default_repository_mock.return_value = 'repository'
get_environment_resources_mock.return_value = mock_responses.DESCRIBE_ENVIRONMENT_RESOURCES_RESPONSE
get_health_of_instances_mock.return_value = mock_responses.DESCRIBE_INSTANCE_HEALTH[
'InstanceStates']
statusops.status('my-application', 'environment-1', True)
log_alert_mock.assert_not_called()
echo_mock.assert_has_calls([
mock.call('Environment details for:', 'environment-1'),
mock.call(' Application name:', 'my-application'),
mock.call(' Region:', 'us-west-2'),
mock.call(' Deployed Version:', 'Sample Application'),
mock.call(' Environment ID:', 'e-sfsdfsfasdads'),
mock.call(
' Platform:',
PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.6'
)),
mock.call(' Tier:', Tier.from_raw_string('webserver')),
mock.call(' CNAME:',
'environment-1.us-west-2.elasticbeanstalk.com'),
mock.call(
' Updated:',
datetime.datetime(2018,
3,
27,
23,
47,
41,
830000,
tzinfo=tz.tzutc())),
mock.call(' Status:', 'Ready'),
mock.call(' Health:', 'Green'),
mock.call(' Running instances:', 2),
mock.call(' ', 'i-23452345346456566:', 'InService'),
mock.call(' ', 'i-21312312312312312:', 'OutOfService'),
mock.call('Current CodeCommit settings:'),
mock.call(' Repository: repository'),
mock.call(' Branch: branch')
])
def get_latest_eb_managed_platform(platform_arn):
account_id, platform_name, platform_version = PlatformVersion.arn_to_platform(
platform_arn)
if not account_id:
matching_platforms = list_eb_managed_platform_versions(
platform_name=platform_name, status='Ready')
if matching_platforms:
return PlatformVersion(matching_platforms[0])
def get_latest_platform(platform_arn):
account_id, platform_name, platform_version = PlatformVersion.arn_to_platform(platform_arn)
platforms = elasticbeanstalk.list_platform_versions(platform_name, 'latest', 'Ready', account_id)
if len(platforms) == 1:
return PlatformVersion(platforms[0]['PlatformArn'])
# The customer doesn't have access to the platform anymore?
return PlatformVersion(platform_arn)
def get_custom_platform(custom_platforms):
accounts = dict()
platform_names = []
for platform_arn in custom_platforms:
account_id, platform_name, platform_version = PlatformVersion.arn_to_platform(
platform_arn)
try:
platforms = accounts[account_id]
except KeyError:
platforms = dict()
try:
platform = platforms[platform_name]
except KeyError:
platform = dict()
platform[platform_version] = platform_arn
platforms[platform_name] = platform
accounts[account_id] = platforms
platform_names.append(platform_name)
longest_platform_name = len(max(platform_names, key=len))
platforms = []
for account in accounts:
for platform in accounts[account]:
platforms.append("%-*s (Owned by: %s)" %
(longest_platform_name, platform, account))
io.echo()
io.echo(prompts['platform.prompt'])
selected_platform = utils.prompt_for_item_in_list(platforms)
option_pattern = re.compile('^(.+)\s+\(Owned by: (.+)\)$')
match = option_pattern.match(selected_platform)
selected_platform_name, selected_account = match.group(1, 2)
selected_platform_name = selected_platform_name.strip()
versions = []
for version in accounts[selected_account][selected_platform_name]:
versions.append(version)
if len(versions) > 1:
versions.sort(key=lambda arn: Version(arn), reverse=True)
io.echo()
io.echo(prompts['sstack.version'])
version = utils.prompt_for_item_in_list(versions)
else:
version = versions[0]
return PlatformVersion(
accounts[selected_account][selected_platform_name][version])
def test_status__non_verbose_mode__codecommit_not_setup__using_non_latest_platform(
self, get_default_repository_mock, get_default_branch_mock,
echo_mock, log_alert_mock, find_solution_stack_from_string_mock,
get_environment_mock):
environment_object = Environment.json_to_environment_object(
mock_responses.DESCRIBE_ENVIRONMENTS_RESPONSE['Environments'][0])
environment_object.platform = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.5'
)
get_environment_mock.return_value = environment_object
get_environment_mock.platform = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.5'
)
find_solution_stack_from_string_mock.return_value = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.6'
)
get_default_branch_mock.return_value = None
get_default_repository_mock.return_value = None
statusops.status('my-application', 'environment-1', False)
log_alert_mock.assert_called_once_with(
'There is a newer version of the platform used by your environment. '
'You can upgrade your environment to the most recent platform version by typing "eb upgrade".'
)
echo_mock.assert_has_calls([
mock.call('Environment details for:', 'environment-1'),
mock.call(' Application name:', 'my-application'),
mock.call(' Region:', 'us-west-2'),
mock.call(' Deployed Version:', 'Sample Application'),
mock.call(' Environment ID:', 'e-sfsdfsfasdads'),
mock.call(
' Platform:',
PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.5'
)),
mock.call(' Tier:', Tier.from_raw_string('webserver')),
mock.call(' CNAME:',
'environment-1.us-west-2.elasticbeanstalk.com'),
mock.call(
' Updated:',
datetime.datetime(2018,
3,
27,
23,
47,
41,
830000,
tzinfo=tz.tzutc())),
mock.call(' Status:', 'Ready'),
mock.call(' Health:', 'Green')
])
def get_latest_custom_platform(platform):
"""
:param platform: A custom platform ARN or a custom platform name
:return: A PlatformVersion object representing the latest version of `platform`
"""
account_id, platform_name, platform_version = PlatformVersion.arn_to_platform(
platform)
if account_id:
matching_platforms = list_custom_platform_versions(
platform_name=platform_name, status='Ready')
if matching_platforms:
return PlatformVersion(matching_platforms[0])
def test_hydrate(self):
platform_version_description = self.platform_version_description
platform_arn = platform_version_description['PlatformArn']
describe_platform_version = mock.Mock(
return_value=platform_version_description)
platform_version = PlatformVersion(platform_arn)
platform_version.hydrate(describe_platform_version)
self.assertEqual(platform_version_description['CustomAmiList'],
platform_version.custom_ami_list)
self.assertEqual(platform_version_description['DateCreated'],
platform_version.date_created)
self.assertEqual(platform_version_description['DateUpdated'],
platform_version.date_updated)
self.assertEqual(platform_version_description['Maintainer'],
platform_version.maintainer)
self.assertEqual(platform_version_description['OperatingSystemName'],
platform_version.operating_system_name)
self.assertEqual(
platform_version_description['OperatingSystemVersion'],
platform_version.operating_system_version)
self.assertEqual(platform_version_description['PlatformArn'],
platform_version.platform_arn)
self.assertEqual(
platform_version_description['PlatformBranchLifecycleState'],
platform_version.platform_branch_lifecycle_state)
self.assertEqual(platform_version_description['PlatformBranchName'],
platform_version.platform_branch_name)
self.assertEqual(platform_version_description['PlatformCategory'],
platform_version.platform_category)
self.assertEqual(
platform_version_description['PlatformLifecycleState'],
platform_version.platform_lifecycle_state)
self.assertEqual(platform_version_description['PlatformName'],
platform_version.platform_name)
self.assertEqual(platform_version_description['PlatformOwner'],
platform_version.platform_owner)
self.assertEqual(platform_version_description['PlatformStatus'],
platform_version.platform_status)
self.assertEqual(platform_version_description['PlatformVersion'],
platform_version.platform_version)
self.assertEqual(platform_version_description['SolutionStackName'],
platform_version.solution_stack_name)
self.assertEqual(platform_version_description['SupportedAddonList'],
platform_version.supported_addon_list)
self.assertEqual(platform_version_description['SupportedTierList'],
platform_version.supported_tier_list)
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_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 = solution_stack_ops.get_default_solution_stack()
want_solution_stack = False
if PlatformVersion.is_custom_platform_arn(config_platform):
platform_name, latest_platform = self.get_latest_custom_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'])
class ListTest(unittest.TestCase):
platform = PlatformVersion(
'arn:aws:elasticbeanstalk:us-west-2::platform/PHP 7.1 running on 64bit Amazon Linux/2.6.5'
)
solution_stack = SolutionStack(
'64bit Amazon Linux 2017.09 v4.4.0 running Node.js')
def setUp(self):
self.root_dir = os.getcwd()
if not os.path.exists('testDir'):
os.mkdir('testDir')
os.chdir('testDir')
def tearDown(self):
os.chdir(self.root_dir)
shutil.rmtree('testDir')
aws.set_region(None)
def setup_platform_workspace(self):
fileoperations.create_config_file('my-platform',
'us-west-2',
self.platform.name,
workspace_type='Platform')
def setup_application_workspace(self):
fileoperations.create_config_file('my-application',
'us-west-2',
self.solution_stack.name,
workspace_type='Application')
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_version_status(version):
platform_name = fileoperations.get_platform_name()
if version is None:
version = fileoperations.get_platform_version()
if version is None:
version = _get_latest_version(platform_name)
fileoperations.update_platform_version(version)
if version is None:
raise InvalidPlatformVersionError(
strings['exit.nosuchplatformversion'])
arn = _version_to_arn(version)
_, platform_name, platform_version = PlatformVersion.arn_to_platform(arn)
platform = describe_custom_platform_version(
platform_arn=arn,
owner=Constants.OWNED_BY_SELF,
platform_name=platform_name,
platform_version=platform_version,
)
if not platform:
raise InvalidPlatformVersionError(
strings['exit.nosuchplatformversion'])
created = platform.get('DateCreated')
description = platform.get('Description')
maintainer = platform.get('Maintainer')
status = platform.get('PlatformStatus')
updated = platform.get('DateUpdated')
framework_name = platform.get('FrameworkName')
framework_version = platform.get('FrameworkVersion')
os_name = platform.get('OperatingSystemName')
os_version = platform.get('OperatingSystemVersion')
language_name = platform.get('ProgrammingLanguageName')
language_version = platform.get('ProgrammingLanguageVersion')
supported_tiers = platform.get('SupportedTierList')
io.echo('Platform: ', arn)
io.echo('Name: ', platform_name)
io.echo('Version: ', version)
io.echo('Maintainer: ', maintainer) if maintainer else None
io.echo('Description: ', description) if description else None
io.echo('Framework: ', framework_name) if framework_name else None
io.echo('Framework: ', framework_name) if framework_name else None
io.echo('Framework Version: ',
framework_version) if framework_version else None
io.echo('Operating System: ', os_name) if os_name else None
io.echo('Operating System Version: ', os_version) if os_version else None
io.echo('Programming Language: ', language_name) if language_name else None
io.echo('Programming Language Version: ',
language_version) if language_version else None
io.echo('Supported Tiers: ', supported_tiers) if supported_tiers else None
io.echo('Status: ', status)
io.echo('Created: ', created)
io.echo('Updated: ', updated)
def test_from_platform_version_summary(self):
platform_version_summary = self.platform_version_summary
result = PlatformVersion.from_platform_version_summary(
platform_version_summary)
self.assertEqual(platform_version_summary['OperatingSystemName'],
result.operating_system_name)
self.assertEqual(platform_version_summary['OperatingSystemVersion'],
result.operating_system_version)
self.assertEqual(platform_version_summary['PlatformArn'],
result.platform_arn)
self.assertEqual(
platform_version_summary['PlatformBranchLifecycleState'],
result.platform_branch_lifecycle_state)
self.assertEqual(platform_version_summary['PlatformBranchName'],
result.platform_branch_name)
self.assertEqual(platform_version_summary['PlatformCategory'],
result.platform_category)
self.assertEqual(platform_version_summary['PlatformLifecycleState'],
result.platform_lifecycle_state)
self.assertEqual(platform_version_summary['PlatformOwner'],
result.platform_owner)
self.assertEqual(platform_version_summary['PlatformStatus'],
result.platform_status)
self.assertEqual(platform_version_summary['PlatformVersion'],
result.platform_version)
self.assertEqual(platform_version_summary['SupportedAddonList'],
result.supported_addon_list)
self.assertEqual(platform_version_summary['SupportedTierList'],
result.supported_tier_list)
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 _api_to_environment(api_dict, want_solution_stack = False):
# Convert solution_stack and tier to objects
try:
if want_solution_stack:
solution_stack_name = api_dict['SolutionStackName']
platform = SolutionStack(solution_stack_name)
else:
platform_arn = api_dict['PlatformArn']
platform = PlatformVersion(platform_arn)
except KeyError:
platform = SolutionStack(api_dict['SolutionStackName'])
tier = api_dict['Tier']
tier = Tier(tier['Name'], tier['Type'], tier['Version'])
env = Environment(
version_label=api_dict.get('VersionLabel'),
status=api_dict.get('Status'),
app_name=api_dict.get('ApplicationName'),
health=api_dict.get('Health'),
id=api_dict.get('EnvironmentId'),
date_updated=api_dict.get('DateUpdated'),
platform=platform,
description=api_dict.get('Description'),
name=api_dict.get('EnvironmentName'),
date_created=api_dict.get('DateCreated'),
tier=tier,
cname=api_dict.get('CNAME', 'UNKNOWN'),
option_settings=api_dict.get('OptionSettings'),
is_abortable=api_dict.get('AbortableOperationInProgress', False),
environment_links=api_dict.get('EnvironmentLinks'),
environment_arn=api_dict.get('EnvironmentArn')
)
return env
def delete_platform_version(platform_version, force=False):
arn = _version_to_arn(platform_version)
if not force:
io.echo(prompts['platformdelete.confirm'].replace(
'{platform-arn}', arn))
io.validate_action(prompts['platformdelete.validate'], arn)
environments = []
try:
environments = [
env for env in elasticbeanstalk.get_environments()
if env.platform.version == arn
]
except NotFoundError:
pass
if len(environments) > 0:
_, platform_name, platform_version = PlatformVersion.arn_to_platform(
arn)
raise ValidationError(strings['platformdeletevalidation.error'].format(
platform_name, platform_version,
'\n '.join([env.name for env in environments])))
response = elasticbeanstalk.delete_platform(arn)
request_id = response['ResponseMetadata']['RequestId']
timeout = 10
commonops.wait_for_success_events(request_id,
timeout_in_minutes=timeout,
platform_arn=arn)
def delete_platform_version(platform_version, force=False):
arn = _version_to_arn(platform_version)
if not force:
io.echo(prompts['platformdelete.confirm'].replace('{platform-arn}', arn))
io.validate_action(prompts['platformdelete.validate'], arn)
environments = []
try:
environments = [env for env in elasticbeanstalk.get_environments() if env.platform.version == arn]
except NotFoundError:
pass
if len(environments) > 0:
_, platform_name, platform_version = PlatformVersion.arn_to_platform(arn)
raise ValidationError(strings['platformdeletevalidation.error'].format(
platform_name,
platform_version,
'\n '.join([env.name for env in environments])
))
response = elasticbeanstalk.delete_platform(arn)
request_id = response['ResponseMetadata']['RequestId']
timeout = 10
commonops.wait_for_success_events(request_id, timeout_in_minutes=timeout, platform_arn=arn)
def get_version_status(version):
platform_name = fileoperations.get_platform_name()
if version is None:
version = fileoperations.get_platform_version()
if version is None:
version = _get_latest_version(platform_name)
fileoperations.update_platform_version(version)
if version is None:
raise InvalidPlatformVersionError(strings['exit.nosuchplatformversion'])
arn = _version_to_arn(version)
_, platform_name, platform_version = PlatformVersion.arn_to_platform(arn)
platform = describe_custom_platform_version(
platform_arn=arn,
owner=Constants.OWNED_BY_SELF,
platform_name=platform_name,
platform_version=platform_version,
)
if not platform:
raise InvalidPlatformVersionError(strings['exit.nosuchplatformversion'])
created = platform.get('DateCreated')
description = platform.get('Description')
maintainer = platform.get('Maintainer')
status = platform.get('PlatformStatus')
updated = platform.get('DateUpdated')
framework_name = platform.get('FrameworkName')
framework_version = platform.get('FrameworkVersion')
os_name = platform.get('OperatingSystemName')
os_version = platform.get('OperatingSystemVersion')
language_name = platform.get('ProgrammingLanguageName')
language_version = platform.get('ProgrammingLanguageVersion')
supported_tiers = platform.get('SupportedTierList')
io.echo('Platform: ', arn)
io.echo('Name: ', platform_name)
io.echo('Version: ', version)
io.echo('Maintainer: ', maintainer) if maintainer else None
io.echo('Description: ', description) if description else None
io.echo('Framework: ', framework_name) if framework_name else None
io.echo('Framework: ', framework_name) if framework_name else None
io.echo('Framework Version: ', framework_version) if framework_version else None
io.echo('Operating System: ', os_name) if os_name else None
io.echo('Operating System Version: ', os_version) if os_version else None
io.echo('Programming Language: ', language_name) if language_name else None
io.echo('Programming Language Version: ', language_version) if language_version else None
io.echo('Supported Tiers: ', supported_tiers) if supported_tiers else None
io.echo('Status: ', status)
io.echo('Created: ', created)
io.echo('Updated: ', updated)
def get_latest_eb_managed_platform(platform_arn):
account_id, platform_name, platform_version = PlatformVersion.arn_to_platform(platform_arn)
if not account_id:
matching_platforms = list_eb_managed_platform_versions(
platform_name=platform_name,
status='Ready'
)
if matching_platforms:
return PlatformVersion(matching_platforms[0])
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 platform_arn_to_solution_stack(platform_arn): """ Method determines the EB-managed solution stack represented by a PlatformArn :param platform_arn: PlatformArn of a solution stack :return: SolutionStack representing the PlatformArn if it an EB-managed platform, otherwise None """ if not PlatformVersion.is_eb_managed_platform_arn(platform_arn): return platform_description = elasticbeanstalk.describe_platform_version(platform_arn) return SolutionStack(platform_description['SolutionStackName'])
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 get_platforms(platform_name=None, ignored_states=None, owner=None, platform_version=None):
platform_list = list_custom_platform_versions(
platform_name=platform_name,
platform_version=platform_version
)
platforms = dict()
for platform in platform_list:
if ignored_states and platform['PlatformStatus'] in ignored_states:
continue
_, platform_name, platform_version = PlatformVersion.arn_to_platform(platform)
platforms[platform_name] = platform_version
return platforms
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 do_command(self):
verbose = self.app.pargs.verbose
solution_stacks = platformops.get_all_platforms()
if verbose:
platform_arns = platformops.list_custom_platform_versions()
lst = [s.name for s in solution_stacks]
lst.extend(platform_arns)
else:
platform_arns = platformops.list_custom_platform_versions(platform_version='latest')
lst = sorted(set([s.pythonify() for s in solution_stacks]))
lst.extend([PlatformVersion.get_platform_name(arn) for arn in platform_arns])
if len(lst) > 20:
io.echo_with_pager(os.linesep.join(lst))
else:
io.echo(*lst, sep=os.linesep)
def set_platform(platform_name, platform_version=None, verify=True):
if verify:
arn = _name_to_arn(platform_name)
_, platform_name, platform_version = PlatformVersion.arn_to_platform(arn)
fileoperations.update_platform_name(platform_name)
fileoperations.update_platform_version(platform_version)
io.echo(strings['platformset.version'])
# This could fail if the customer elected to create a new platform
try:
get_version_status(platform_version)
except InvalidPlatformVersionError:
io.echo(strings['platformset.newplatform'] % platform_name)
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 get_latest_custom_platform(platform):
"""
:param platform: A custom platform ARN or a custom platform name
:return: A PlatformVersion object representing the latest version of `platform`
"""
account_id, platform_name, platform_version = PlatformVersion.arn_to_platform(platform)
if account_id:
matching_platforms = list_custom_platform_versions(
platform_name=platform_name,
status='Ready'
)
if matching_platforms:
return PlatformVersion(matching_platforms[0])
matching_platforms = list_custom_platform_versions(
platform_name=platform,
status='Ready'
)
if matching_platforms:
return PlatformVersion(matching_platforms[0])
def find_solution_stack_from_string(solution_string, find_newer=False):
"""
Method returns a SolutionStack object representing the given `solution_string`.
If the `solution_string` matches ARNs and complete names of solution stacks, the exact
match is returned. In the event when there are multiple matches, the latest version is
returned.
:param solution_string: A string in one of the following (case-insensitive) forms:
- PlatformArn:
- EB-managed: 'arn:aws:elasticbeanstalk:us-west-2::platform/Multi-container Docker running on 64bit Amazon Linux/2.8.0'
- Custom: arn:aws:elasticbeanstalk:us-west-2:123412341234:platform/custom_platform/1.0.0
- complete name: '64bit Amazon Linux 2017.03 v2.7.5 running Multi-container Docker 17.03.2-ce (Generic)'
- shorthand: 'Multi-container Docker 17.03.2-ce (Generic)'
- language name: 'Multi-container Docker'
- pythonified shorthand: 'multi-container-docker-17.03.2-ce-(generic)'
:param find_newer: If solution_string is a complete name or a PlatformArn that uniquely matches a
solution stack or platform, find the newest version of the solution stack.
:return: A SolutionStack object representing the latest version of the `solution_string`. In case of a custom
platform, the return value is a PlatformVersion object.
"""
# Compare input with PlatformARNs
match = None
if PlatformVersion.is_eb_managed_platform_arn(solution_string):
if find_newer:
match = platformops.get_latest_eb_managed_platform(solution_string)
else:
match = platform_arn_to_solution_stack(solution_string)
elif PlatformVersion.is_custom_platform_arn(solution_string):
if find_newer:
match = platformops.get_latest_custom_platform(solution_string)
else:
match = platformops.find_custom_platform_from_string(solution_string)
# Compare input with complete SolutionStack name and retrieve latest SolutionStack
# in the series if `find_newer` is set to True
if not match:
available_solution_stacks = elasticbeanstalk.get_available_solution_stacks()
match = SolutionStack.match_with_complete_solution_string(available_solution_stacks, solution_string)
if match and find_newer:
language_name = SolutionStack(solution_string).language_name
match = SolutionStack.match_with_solution_string_language_name(available_solution_stacks, language_name)
# Compare input with other forms
for solution_string_matcher in [
SolutionStack.match_with_solution_string_shorthand,
SolutionStack.match_with_solution_string_language_name,
SolutionStack.match_with_pythonified_solution_string,
]:
if not match:
match = solution_string_matcher(available_solution_stacks, solution_string)
# Compare input with custom platform names
if not match:
match = platformops.find_custom_platform_from_string(solution_string)
if not match:
raise NotFoundError('Platform "{}" does not appear to be valid'.format(solution_string))
return match
def group_custom_platforms_by_platform_name(custom_platforms):
return sorted(set([PlatformVersion.get_platform_name(custom_platform) for custom_platform in custom_platforms]))
