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