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 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]))