def test_get_default_solution_stack(self): ebcli_root = os.getcwd() test_dir = 'testDir' os.mkdir(test_dir) os.mkdir(os.path.join(test_dir, '.elasticbeanstalk')) os.chdir(test_dir) with open(os.path.join('.elasticbeanstalk', 'config.yml'), 'w') as config_yml: config_yml_contents = { 'branch-defaults': { 'default': { 'environment': 'default-environment' } }, 'global': { 'application_name': 'default-application', 'default_platform': 'Python 3.6' } } yaml.dump(config_yml_contents, config_yml) config_yml.close() try: self.assertEqual('Python 3.6', solution_stack_ops.get_default_solution_stack()) finally: os.chdir(ebcli_root) shutil.rmtree(test_dir)
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'])
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 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 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 = platformops.get_platform_for_platform_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 get_solution_stack(self): # Get solution stack from command line arguments solution_string = self.app.pargs.platform # Get solution stack from config file, if exists if not solution_string: try: solution_string = solution_stack_ops.get_default_solution_stack() except NotInitializedError: solution_string = None # Validate that the platform exists if solution_string: solution_stack_ops.find_solution_stack_from_string(solution_string) return solution_string
def get_solution_stack(self): # Get solution stack from command line arguments solution_string = self.app.pargs.platform # Get solution stack from config file, if exists if not solution_string: try: solution_string = solution_stack_ops.get_default_solution_stack() except NotInitializedError: solution_string = None # Validate that the platform exists if solution_string: solution_stack_ops.find_solution_stack_from_string(solution_string) return solution_string
def get_solution_stack(platform, sstack, interactive): customer_provided_platform = not not platform if not platform: try: platform = solution_stack_ops.get_default_solution_stack() except NotInitializedError: platform = None # Validate that the platform exists if platform: solution_stack_ops.find_solution_stack_from_string(platform) platform = platform or sstack if fileoperations.env_yaml_exists(): platform = platform or extract_solution_stack_from_env_yaml() if not platform or (interactive and not customer_provided_platform): platform = solution_stack_ops.get_solution_stack_from_customer( ).platform_shorthand return platform
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 or solution_stack_ops.get_default_solution_stack( ) 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 provided_env_name = env_name 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']) if cname and tier and Tier.looks_like_worker_tier(tier): raise InvalidOptionsError(strings['worker.cname']) if cname and not elasticbeanstalk.is_cname_available(cname): raise AlreadyExistsError(strings['cname.unavailable'].replace( '{cname}', cname)) if tier and Tier.looks_like_worker_tier(tier): if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets or self.app.pargs.vpc_publicip: raise InvalidOptionsError( strings['create.worker_and_incompatible_vpc_arguments']) if (not tier or Tier.looks_like_webserver_tier(tier)) and single: if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets: raise InvalidOptionsError( strings['create.single_and_elbpublic_or_elb_subnet']) app_name = self.get_app_name() tags = createops.get_and_validate_tags(tags) envvars = get_and_validate_envars(envvars) process_app_version = fileoperations.env_yaml_exists() or process platform = get_platform(solution_string, iprofile) template_name = get_template_name(app_name, cfg) tier = get_environment_tier(tier) env_name = provided_env_name or get_environment_name(app_name, group) cname = cname or get_environment_cname(env_name, provided_env_name, tier) key_name = key_name or commonops.get_default_keyname() elb_type = elb_type or get_elb_type_from_customer( interactive, single, region, tier) database = self.form_database_object() vpc = self.form_vpc_object(tier, single) # avoid prematurely timing out in the CLI when an environment is launched with a RDS DB if not timeout and database: timeout = 15 env_request = CreateEnvironmentRequest(app_name=app_name, env_name=env_name, group_name=group, cname=cname, template_name=template_name, platform=platform, 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) env_request.option_settings += envvars createops.make_new_env(env_request, branch_default=branch_default, process_app_version=process_app_version, nohang=nohang, interactive=interactive, timeout=timeout, source=source)