def normalize_log_group_name(env_name,
log_group=None,
cloudwatch_log_source=None):
"""
Converts the given (potentially None) `log_group` name to a value that can be consumed by `describe_log_groups`.
:param env_name: An Elastic Beanstalk environment name
:param log_group: A value for the logGroup name specified by the customer, which is potentially None
:param cloudwatch_log_source: Name of the log source `log_group` belongs to. One among: instance, environment-health
:return: A normalized logGroup name
"""
if not cloudwatch_log_source or cloudwatch_log_source == logs_operations_constants.LOG_SOURCES.INSTANCE_LOG_SOURCE:
log_group = beanstalk_log_group_builder(env_name, log_group)
elif cloudwatch_log_source == logs_operations_constants.LOG_SOURCES.ENVIRONMENT_HEALTH_LOG_SOURCE:
if log_group:
raise InvalidOptionsError(
strings['logs.log_group_and_environment_health_log_source'])
log_group = beanstalk_log_group_builder(
env_name,
cloudwatch_log_group_for_environment_health_streaming(env_name))
else:
raise InvalidOptionsError(strings[
'logs.cloudwatch_log_source_argumnent_is_invalid_for_retrieval'].
format(cloudwatch_log_source))
return log_group
def get_environment_name(app_name, group):
"""
Returns:
- environment name is present in the env.yaml file if one exists, or
- prompts customer interactively to enter an environment name
If using env.yaml to create an environment with, `group` must be passed through
the `-g/--env-group-suffix/` argument.
:param app_name: name of the application associated with the present working
directory
:param group: name of the group associated with
:return: Unique name of the environment which will be created by `eb create`
"""
env_name = None
if fileoperations.env_yaml_exists():
env_name = fileoperations.get_env_name_from_env_yaml()
if env_name:
if env_name.endswith('+') and not group:
raise InvalidOptionsError(strings['create.missinggroupsuffix'])
elif not env_name.endswith('+') and group:
raise InvalidOptionsError(
strings['create.missing_plus_sign_in_group_name'])
else:
env_name = env_name[:-1] + '-' + group
return env_name or io.prompt_for_environment_name(
get_unique_environment_name(app_name))
def __assert_list_argument_xor_modifier_arguments_specified(self):
if self.list_argument:
if self.__modifier_arguments_specified():
raise InvalidOptionsError(
strings['tags.list_with_other_arguments'])
else:
if not self.__modifier_arguments_specified():
raise InvalidOptionsError('usage: {0}'.format(
self._usage_text))
def do_command(self):
workspace_type = fileoperations.get_workspace_type(None)
if workspace_type == Constants.WorkSpaceTypes.PLATFORM:
echo(self.custom_platforms())
elif workspace_type == Constants.WorkSpaceTypes.APPLICATION:
if self.app.pargs.status:
raise InvalidOptionsError('You cannot use the "--status" option in application workspaces.')
if self.app.pargs.all_platforms:
raise InvalidOptionsError('You cannot use the "--all-platforms" option in application workspaces.')
echo(self.all_platforms())
def __raise_if_incompatible_arguments_are_present(self):
if self.all and self.instance:
raise InvalidOptionsError(
strings['logs.all_argument_and_instance_argument'])
if self.all and self.zip:
raise InvalidOptionsError(
strings['logs.all_argument_and_zip_argument'])
if self.cloudwatch_logs and self.log_group:
raise InvalidOptionsError(
strings['logs.cloudwatch_logs_argument_and_log_group_argument']
)
if self.cloudwatch_logs and self.instance:
raise InvalidOptionsError(
strings['logs.cloudwatch_logs_argument_and_instance_argument'])
if self.cloudwatch_logs and self.all:
raise InvalidOptionsError(
strings['logs.cloudwatch_logs_argument_and_all_argument'])
if self.cloudwatch_logs and self.zip:
raise InvalidOptionsError(
strings['logs.cloudwatch_logs_argument_and_zip_argument'])
if self.cloudwatch_log_source and self.cloudwatch_log_source not in [
logs_operations_constants.LOG_SOURCES.ALL_LOG_SOURCES,
logs_operations_constants.LOG_SOURCES.INSTANCE_LOG_SOURCE,
logs_operations_constants.LOG_SOURCES.
ENVIRONMENT_HEALTH_LOG_SOURCE,
]:
raise InvalidOptionsError(strings[
'logs.cloudwatch_log_source_argumnent_is_invalid_for_enabling_streaming']
)
if (self.cloudwatch_log_source == logs_operations_constants.
LOG_SOURCES.ENVIRONMENT_HEALTH_LOG_SOURCE and self.instance):
raise InvalidOptionsError(
strings['logs.health_and_instance_argument'])
if (self.cloudwatch_log_source == logs_operations_constants.
LOG_SOURCES.ENVIRONMENT_HEALTH_LOG_SOURCE and self.log_group):
raise InvalidOptionsError(
strings['logs.log_group_and_environment_health_log_source'])
if self.cloudwatch_log_source == logs_operations_constants.LOG_SOURCES.ALL_LOG_SOURCES and self.stream:
raise InvalidOptionsError(strings[
'logs.cloudwatch_log_source_argumnent_is_invalid_for_enabling_streaming']
)
def get_logs(self):
"""
Determines the type of logs to get and how to package them from the flags given to the command. The method
will either zip or save the individual logs in '.elasticbeanstalk/logs/' directory OR return a pager that
will allow the user to page through the tail logs.
"""
if self.all and self.instance:
raise InvalidOptionsError(strings['logs.allandinstance'])
if self.zip:
info_type = 'bundle'
do_zip = True
elif self.all:
info_type = 'bundle'
do_zip = False
else:
info_type = 'tail'
do_zip = False
if logsops.log_streaming_enabled(self.app_name, self.env_name):
log_group = logsops.beanstalk_log_group_builder(self.env_name, self.log_group)
try:
logsops.retrieve_cloudwatch_logs(log_group, info_type, do_zip=do_zip, instance_id=self.instance)
except NotFoundError:
raise NotFoundError('The specified log group does not exist. "{0}"'.format(log_group))
else:
logsops.retrieve_beanstalk_logs(self.env_name, info_type, do_zip=do_zip, instance_id=self.instance)
def do_command(self):
self.timeout = self.app.pargs.timeout
self.nohang = self.app.pargs.nohang
if self.nohang:
self.timeout = 0
if self.app.pargs.modules:
self.multiple_app_deploy()
return
self.message = self.app.pargs.message
self.staged = self.app.pargs.staged
self.source = self.app.pargs.source
self.app_name = self.get_app_name()
self.env_name = self.get_env_name()
self.version = self.app.pargs.version
self.label = self.app.pargs.label
self.process = self.app.pargs.process
group_name = self.app.pargs.env_group_suffix
if self.version and (self.message or self.label):
raise InvalidOptionsError(strings['deploy.invalidoptions'])
process_app_versions = fileoperations.env_yaml_exists() or self.process
deployops.deploy(self.app_name, self.env_name, self.version, self.label,
self.message, group_name=group_name, process_app_versions=process_app_versions,
staged=self.staged, timeout=self.timeout, source=self.source)
def do_command(self):
number = self.app.pargs.number
env_name = self.get_env_name()
instance = self.app.pargs.instance
cmd = self.app.pargs.command
custom_ssh = self.app.pargs.custom
keep_open = self.app.pargs.keep_open
force = self.app.pargs.force
setup = self.app.pargs.setup
timeout = self.app.pargs.timeout
if timeout and not setup:
raise InvalidOptionsError(strings['ssh.timeout_without_setup'])
sshops.prepare_for_ssh(
env_name=env_name,
instance=instance,
keep_open=keep_open,
force=force,
setup=setup,
number=number,
custom_ssh=custom_ssh,
command=cmd,
timeout=timeout
)
def __stream_cloudwatch_logs(self):
self.cloudwatch_log_source = self.cloudwatch_log_source or logs_operations_constants.LOG_SOURCES.INSTANCE_LOG_SOURCE
if self.cloudwatch_log_source == logs_operations_constants.LOG_SOURCES.INSTANCE_LOG_SOURCE:
if not logsops.instance_log_streaming_enabled(self.app_name, self.env_name):
raise InvalidOptionsError(strings['logs.instance_log_streaming_disabled'].format(self.env_name))
logsops.stream_instance_logs_from_cloudwatch(
log_group=self.__normalized_log_group_name(),
specific_log_stream=self.instance
)
if self.cloudwatch_log_source == logs_operations_constants.LOG_SOURCES.ENVIRONMENT_HEALTH_LOG_SOURCE:
if not logsops.environment_health_streaming_enabled(self.app_name, self.env_name):
raise InvalidOptionsError(strings['logs.environment_health_log_streaming_disabled'].format(self.env_name))
logsops.stream_instance_logs_from_cloudwatch(log_group=self.__normalized_log_group_name())
def do_command(self):
app_name = self.get_app_name()
env_name = self.get_env_name(cmd_example='eb labs setup-ssl')
certfile = self.app.pargs.cert_file
privatekey = self.app.pargs.private_key
certchain = self.app.pargs.cert_chain
cert_name = self.app.pargs.name
# Make sure arguments are valid
if certfile or privatekey or certfile:
if not (certfile and privatekey):
raise InvalidOptionsError(
'When providing your own certificate the --cert-file '
'and --private-key options are both required.')
_validate_files_exists(certfile, privatekey, certchain)
if not cert_name:
cert_name = env_name
# Check environment is not single instance
if _is_single_instance(app_name, env_name):
raise NotSupportedError('This command is currently not supported '
'for single instance environments. \n'
'For more information please see '
'http://docs.aws.amazon.com/elasticbeanstalk/'
'latest/dg/SSL.SingleInstance.html')
# Generate cert if not provided
if not certfile:
privatekey, certfile = generate_self_signed_cert(cert_name)
certfile = fileoperations.read_from_text_file(certfile)
privatekey = fileoperations.read_from_text_file(privatekey)
if certchain:
certchain = fileoperations.read_from_text_file(certchain)
result = iam.upload_server_certificate(cert_name + '.crt', certfile,
privatekey, chain=certchain)
arn = result['Arn']
# Update environment
option_settings = [
elasticbeanstalk.create_option_setting(
namespaces.LOAD_BALANCER,
option_names.LOAD_BALANCER_HTTP_PORT,
'OFF'
),
elasticbeanstalk.create_option_setting(
namespaces.LOAD_BALANCER,
option_names.LOAD_BALANCER_HTTPS_PORT,
'443'
),
elasticbeanstalk.create_option_setting(
namespaces.LOAD_BALANCER,
option_names.SSL_CERT_ID,
arn
),
]
commonops.update_environment(env_name, changes=option_settings,
nohang=False)
def validate_source_location(source_location):
valid_source_locations = ['codecommit']
if source_location in valid_source_locations:
return
else:
raise InvalidOptionsError(
"Source location '{0}' is not in the list of valid locations: {1}".
format(source_location, valid_source_locations))
def prepare_for_ssh(env_name,
instance,
keep_open,
force,
setup,
number,
keyname=None,
no_keypair_error_message=None,
custom_ssh=None,
command=None,
timeout=None):
if setup:
setup_ssh(env_name, keyname, timeout=timeout)
return
if instance and number:
raise InvalidOptionsError(strings['ssh.instanceandnumber'])
if not instance:
instances = commonops.get_instance_ids(env_name)
if number is not None:
if number > len(instances) or number < 1:
raise InvalidOptionsError('Invalid index number (' +
str(number) +
') for environment with ' +
str(len(instances)) + ' instances')
else:
instance = instances[number - 1]
elif len(instances) == 1:
instance = instances[0]
else:
io.echo()
io.echo('Select an instance to ssh into')
instance = utils.prompt_for_item_in_list(instances)
try:
ssh_into_instance(instance,
keep_open=keep_open,
force_open=force,
custom_ssh=custom_ssh,
command=command)
except NoKeypairError:
if not no_keypair_error_message:
no_keypair_error_message = prompts['ssh.nokey']
io.log_error(no_keypair_error_message)
def raise_if_environment_health_log_streaming_is_not_enabled(app_name, env_name):
"""
Raises if CloudWatch environment-health log streaming is not enabled for the environment, `env_name`
:param app_name: An Elastic Beanstalk application name
:param env_name: An Elastic Beanstalk environment name contained within `app_name`
:return: None
"""
if not environment_health_streaming_enabled(app_name, env_name):
raise InvalidOptionsError(strings['logs.environment_health_log_streaming_disabled'].format(env_name))
def _raise_if_environment_is_not_using_enhanced_health(configuration_settings):
option_settings = configuration_settings.get('OptionSettings')
health_type = elasticbeanstalk.get_option_setting(
option_settings,
namespaces.HEALTH_SYSTEM,
option_names.SYSTEM_TYPE
)
if health_type != 'enhanced':
raise InvalidOptionsError(strings['cloudwatch_environment_health_log_streaming.enhanced_health_not_found'])
def get_and_validate_tags(tags):
if not tags:
return []
tags = tags.strip().strip('"').strip('\'')
tags = tags.split(',')
tag_list = []
if len(tags) > 47:
raise InvalidOptionsError(strings['tags.max'])
for t in tags:
# validate
if not re.match('^[\w\s.:/+%@-]{1,128}=[\w\s.:/+=@-]{0,256}$', t):
raise InvalidOptionsError(strings['tags.invalidformat'])
else:
# build tag
key, value = t.split('=', 1)
tag_list.append(
{'Key': key,
'Value': value}
)
return tag_list
def collect_changes(self, usr_model):
"""
Because we can't remove options from the lifecycle config we can only add to them so we just take the
direct user model and apply that.
:param usr_model: User model, key-value style
:return: api_model
"""
# Validate the service role they gave us exists
if 'ServiceRole' in usr_model['Configurations']:
service_role = usr_model['Configurations']['ServiceRole'].split('/')[-1]
try:
get_role(service_role)
except (NotFoundError, ServiceError):
raise InvalidOptionsError(strings['lifecycle.invalidrole'].replace('{role}', service_role))
return usr_model['Configurations']
def __attempt_to_checkout_branch_specified_in_source_input(source):
source_location, repo, branch = utils.parse_source(source)
if not branch or not repo:
raise InvalidOptionsError(strings['codecommit.bad_source'])
source_control = SourceControl.get_source_control()
source_control.is_setup()
repo = repo or gitops.get_default_repository()
useops.switch_default_repo_and_branch(repo, branch)
successfully_checked_out_branch = source_control.checkout_branch(
branch)
if not successfully_checked_out_branch:
raise NotFoundError(
"Could not checkout branch {0}.".format(branch))
def __get_logs(self):
"""
Determines whether to:
- retrieve logs from CloudWatch or Beanstalk
- from CloudWatch when log-streaming to CloudWatch is enabled
- from Beanstalk when log-streaming to CloudWatch is disabled
- retrieve instance or environment-health logs
- instance logs when --cloudwatch-log-source is 'instance' or None
- environment-health logs when --cloudwatch-log-source is 'environment-health'
- all other values for --cloudwatch-log-source will result in an exception being thrown
- determine whether to tail the logs, or to download them as a zip file or regular log files
"""
info_type = logsops.resolve_log_result_type(self.zip, self.all)
should_zip_logs = self.zip
if self.cloudwatch_log_source == logs_operations_constants.LOG_SOURCES.ENVIRONMENT_HEALTH_LOG_SOURCE:
logsops.raise_if_environment_health_log_streaming_is_not_enabled(
self.app_name, self.env_name)
logsops.retrieve_cloudwatch_environment_health_logs(
self.__normalized_log_group_name(),
info_type,
do_zip=should_zip_logs,
)
elif self.cloudwatch_log_source == logs_operations_constants.LOG_SOURCES.INSTANCE_LOG_SOURCE:
logsops.raise_if_instance_log_streaming_is_not_enabled(
self.app_name, self.env_name)
self.__retrieve_cloudwatch_instance_logs(info_type,
should_zip_logs)
elif self.cloudwatch_log_source:
raise InvalidOptionsError(strings[
'logs.cloudwatch_log_source_argumnent_is_invalid_for_retrieval']
)
elif logsops.instance_log_streaming_enabled(self.app_name,
self.env_name):
self.__retrieve_cloudwatch_instance_logs(info_type,
should_zip_logs)
else:
logsops.retrieve_beanstalk_logs(self.env_name,
info_type,
do_zip=should_zip_logs,
instance_id=self.instance)
def do_command(self):
self.timeout = self.app.pargs.timeout
self.nohang = self.app.pargs.nohang
if self.nohang:
self.timeout = 0
if self.app.pargs.modules:
self.multiple_app_deploy()
return
self.message = self.app.pargs.message
self.staged = self.app.pargs.staged
self.source = self.app.pargs.source
self.app_name = self.get_app_name()
self.env_name = self.get_env_name()
self.version = self.app.pargs.version
self.label = self.app.pargs.label
self.process = self.app.pargs.process
group_name = self.app.pargs.env_group_suffix
if self.version and (self.message or self.label):
raise InvalidOptionsError(strings['deploy.invalidoptions'])
# ToDo add support for deploying to multiples?
# for arg in self.app.pargs.environment_name:
# # deploy to every environment listed
# ## Right now you can only list one
process_app_versions = fileoperations.env_yaml_exists() or self.process
deployops.deploy(self.app_name,
self.env_name,
self.version,
self.label,
self.message,
group_name=group_name,
process_app_versions=process_app_versions,
staged=self.staged,
timeout=self.timeout,
source=self.source)
def __assert_resource_argument_conflict(self):
if self.environment_passed and self.resource:
raise InvalidOptionsError(
strings['tags.resource_environment_conflict'])
def raise_if_source_location_is_not_codecommit(source_location):
if source_location != 'codecommit':
raise InvalidOptionsError('Source location "{0}" is not supported by the EBCLI'.format(source_location))
def create_app_version_from_source(
app_name,
source,
process=False,
label=None,
message=None,
build_config=None
):
cwd = os.getcwd()
fileoperations.ProjectRoot.traverse()
try:
if heuristics.directory_is_empty():
io.echo('NOTE: {}'.format(strings['appversion.none']))
return None
finally:
os.chdir(cwd)
source_control = SourceControl.get_source_control()
if source_control.untracked_changes_exist():
io.log_warning(strings['sc.unstagedchanges'])
if label:
version_label = label
else:
version_label = source_control.get_version_label()
if message:
description = message
else:
description = source_control.get_message()
if len(description) > 200:
description = description[:195] + '...'
source_location, repository, branch = utils.parse_source(source)
if not branch or not repository:
raise InvalidOptionsError(strings['codecommit.bad_source'])
if source_location == "codecommit":
try:
result = codecommit.get_branch(repository, branch)
except ServiceError as ex:
io.log_error(
"Could not get branch '{0}' for the repository '{1}' "
"because of this error: {2}".format(
branch,
repository,
ex.code
)
)
raise ex
commit_id = result['branch']['commitId']
if repository is None or commit_id is None:
raise ServiceError("Could not find repository or commit id to create an application version")
else:
LOG.debug("Source location '{0}' is not supported".format(source_location))
raise InvalidOptionsError(
"This command does not support the given source location: {0}".format(
source_location
)
)
io.log_info('Creating AppVersion ' + version_label)
return _create_application_version(app_name, version_label, description,
None, None, process, repository=repository, commit_id=commit_id,
build_config=build_config)
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):
# 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)
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)
