def do_command(self):
commonops.raise_if_inside_platform_workspace()
interactive = self.app.pargs.interactive
region_name = self.app.pargs.region
noverify = self.app.pargs.no_verify_ssl
keyname = self.app.pargs.keyname
profile = self.app.pargs.profile
platform = self.app.pargs.platform
source = self.app.pargs.source
app_name = self.app.pargs.application_name
modules = self.app.pargs.modules
force_non_interactive = _customer_is_avoiding_interactive_flow(
self.app.pargs)
tags = self.app.pargs.tags
# The user specifies directories to initialize
if modules and len(modules) > 0:
self.initialize_multiple_directories(modules, region_name,
interactive,
force_non_interactive,
keyname, profile, noverify,
platform)
return
fileoperations.touch_config_folder()
region_name = commonops.set_region_for_application(
interactive, region_name, force_non_interactive, platform)
commonops.set_up_credentials(profile, region_name, interactive)
app_name = get_app_name(app_name, interactive, force_non_interactive)
default_env = set_default_env(interactive, force_non_interactive)
tags = tagops.get_and_validate_tags(tags)
platform_arn, keyname_of_existing_application = create_app_or_use_existing_one(
app_name, default_env, tags)
platform = _determine_platform(customer_provided_platform=platform,
existing_app_platform=platform_arn,
force_interactive=interactive
and not force_non_interactive)
handle_buildspec_image(platform, force_non_interactive)
prompt_codecommit = should_prompt_customer_to_opt_into_codecommit(
force_non_interactive, region_name, source)
repository, branch = None, None
if prompt_codecommit:
repository, branch = configure_codecommit(source)
initializeops.setup(app_name,
region_name,
platform,
dir_path=None,
repository=repository,
branch=branch)
configure_keyname(platform, keyname, keyname_of_existing_application,
interactive, force_non_interactive)
fileoperations.write_config_setting('global', 'include_git_submodules',
True)
if noverify:
fileoperations.write_config_setting('global', 'no-verify-ssl',
True)
def save(self):
cfg_name = self.app.pargs.cfg
env_name = self.get_env_name(varname='name',
cmd_example='eb config save')
app_name = self.get_app_name()
tags = self.app.pargs.tags
tags = tagops.get_and_validate_tags(tags)
if not cfg_name:
cfg_name = self._choose_cfg_name(app_name, env_name)
saved_configs.create_config(app_name, env_name, cfg_name, tags)
if fileoperations.env_yaml_exists():
io.echo(strings['config.envyamlexists'])
def create_platform_version(
version,
major_increment,
minor_increment,
patch_increment,
instance_type,
vpc=None,
staged=False,
timeout=None,
tags=None,
):
_raise_if_directory_is_empty()
_raise_if_platform_definition_file_is_missing()
version and _raise_if_version_format_is_invalid(version)
platform_name = fileoperations.get_platform_name()
instance_profile = fileoperations.get_instance_profile(None)
key_name = commonops.get_default_keyname()
version = version or _resolve_version_number(
platform_name, major_increment, minor_increment, patch_increment)
tags = tagops.get_and_validate_tags(tags)
source_control = SourceControl.get_source_control()
io.log_warning(strings['sc.unstagedchanges']
) if source_control.untracked_changes_exist() else None
version_label = _resolve_version_label(source_control, staged)
bucket, key, file_path = _resolve_s3_bucket_and_key(
platform_name, version_label, source_control, staged)
_upload_platform_version_to_s3_if_necessary(bucket, key, file_path)
io.log_info('Creating Platform Version ' + version_label)
response = elasticbeanstalk.create_platform_version(
platform_name, version, bucket, key, instance_profile, key_name,
instance_type, tags, vpc)
environment_name = 'eb-custom-platform-builder-packer'
io.echo(
colored(
strings['platformbuildercreation.info'].format(environment_name),
attrs=['reverse']))
fileoperations.update_platform_version(version)
commonops.set_environment_for_current_branch(environment_name)
stream_platform_logs(response, platform_name, version, timeout)
def test_get_and_validate_tags__tags_is_empty__add_multiple_new_tags(self):
taglist = TagList([])
addition_string = ','.join(
['key1=value1', 'key2=value2', 'key3=value3'])
expected_additions_list = [{
'Key': 'key1',
'Value': 'value1'
}, {
'Key': 'key2',
'Value': 'value2'
}, {
'Key': 'key3',
'Value': 'value3'
}]
self.assertEqual(expected_additions_list,
tagops.get_and_validate_tags(addition_string))
def do_command(self):
self.get_instance_profile()
tags = self.app.pargs.tags
if tags:
tags = tagops.get_and_validate_tags(tags)
create_platform_version(
self.app.pargs.version,
self.app.pargs.major_increment,
self.app.pargs.minor_increment,
self.app.pargs.patch_increment,
self.app.pargs.instance_type,
{
'id': self.app.pargs.vpc_id,
'subnets': self.app.pargs.vpc_subnets,
'publicip': self.app.pargs.vpc_publicip
},
timeout=self.app.pargs.timeout,
tags=tags,
)
def do_command(self):
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
platform = 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
enable_spot = self.app.pargs.enable_spot
spot_max_price = self.app.pargs.spot_max_price
instance_types = self.app.pargs.instance_types
on_demand_base_capacity = self.app.pargs.on_demand_base_capacity
on_demand_above_base_capacity = self.app.pargs.on_demand_above_base_capacity
max_instances = self.app.pargs.max_instances
min_instances = self.app.pargs.min_instances
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 (max_instances or min_instances) and scale:
raise InvalidOptionsError(strings['create.scaleandminmax'])
if (max_instances or min_instances) and single:
raise InvalidOptionsError(strings['create.singleandminmax'])
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'])
if (spot_max_price or on_demand_base_capacity
or on_demand_above_base_capacity) and not enable_spot:
raise InvalidOptionsError(strings['create.missing_enable_spot'])
if instance_types is "":
raise InvalidOptionsError(
strings['spot.instance_types_validation'])
if itype and instance_types:
raise InvalidOptionsError(strings['create.itype_and_instances'])
platform = _determine_platform(platform, iprofile)
app_name = self.get_app_name()
tags = tagops.get_and_validate_tags(tags)
envvars = get_and_validate_envars(envvars)
process_app_version = fileoperations.env_yaml_exists() or process
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, tier)
enable_spot = enable_spot or spotops.get_spot_request_from_customer(
interactive)
instance_types = instance_types or spotops.get_spot_instance_types_from_customer(
interactive, enable_spot)
database = self.form_database_object()
vpc = self.form_vpc_object(tier, single)
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,
enable_spot=enable_spot,
instance_types=instance_types,
spot_max_price=spot_max_price,
on_demand_base_capacity=on_demand_base_capacity,
on_demand_above_base_capacity=on_demand_above_base_capacity,
min_instances=min_instances,
max_instances=max_instances)
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)
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
env = elasticbeanstalk.get_environment(app_name=app_name,
env_name=env_name)
tier = env.tier
if 'worker' in tier.name.lower() and cname:
raise InvalidOptionsError(strings['worker.cname'])
if cname:
if not elasticbeanstalk.is_cname_available(cname):
raise AlreadyExistsError(strings['cname.unavailable'].replace(
'{cname}', cname))
tags = tagops.get_and_validate_tags(tags)
envvars = get_and_validate_envars(envvars)
if not clone_name:
if len(env_name) < 16:
unique_name = env_name + '-clone'
else:
unique_name = 'my-cloned-env'
env_list = elasticbeanstalk.get_environment_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_from_customer(clone_name)
elif not cname:
cname = None
if not exact:
if not provided_clone_name:
latest = solution_stack_ops.find_solution_stack_from_string(
env.platform.name, find_newer=True)
if latest != env.platform:
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:
platform = solution_stack_ops.find_solution_stack_from_string(
env.platform.name, find_newer=True)
if platform != env.platform:
io.log_warning(prompts['clone.latestwarn'])
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_get_and_validate_tags__tags_is_empty(self):
tags = ''
self.assertEqual([], tagops.get_and_validate_tags(tags))
