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)
