# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"). You # may not use this file except in compliance with the License. A copy of # the License is located at # # http://aws.amazon.com/apache2.0/ # # or in the "license" file accompanying this file. This file is # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF # ANY KIND, either express or implied. See the License for the specific # language governing permissions and limitations under the License. import argparse import os import time from ebcli.core import io, fileoperations, hooks from ebcli.core.abstractcontroller import AbstractBaseController from ebcli.lib import elasticbeanstalk, utils, iam from ebcli.objects.exceptions import ( AlreadyExistsError, InvalidOptionsError, RetiredPlatformBranchError, NotFoundError, ) from ebcli.objects.platform import PlatformVersion, PlatformBranch from ebcli.objects.solutionstack import SolutionStack from ebcli.objects.requests import CreateEnvironmentRequest from ebcli.objects.tier import Tier from ebcli.operations import ( commonops, composeops, createops, envvarops, platformops, platform_branch_ops, saved_configs, solution_stack_ops, shared_lb_ops, spotops, statusops, ) from ebcli.operations.tagops import tagops from ebcli.resources.strings import strings, prompts, flag_text, alerts from ebcli.resources.statics import elb_names, platform_branch_lifecycle_states class CreateController(AbstractBaseController): class Meta: label = 'create' usage = AbstractBaseController.Meta.usage.replace('{cmd}', label) description = strings['create.info'] epilog = strings['create.epilog'] arguments = [ (['environment_name'], dict( action='store', nargs='?', default=None, help=flag_text['create.name'])), (['-m', '--modules'], dict(nargs='*', help=flag_text['create.modules'])), (['-g', '--env-group-suffix'], dict(help=flag_text['create.group'])), (['-c', '--cname'], dict(help=flag_text['create.cname'])), (['-t', '--tier'], dict(help=flag_text['create.tier'])), (['-i', '--instance_type'], dict( help=flag_text['create.itype'])), (['-p', '--platform'], dict(help=flag_text['create.platform'])), (['-s', '--single'], dict( action='store_true', help=flag_text['create.single'])), (['--sample'], dict( action='store_true', help=flag_text['create.sample'])), (['-d', '--branch_default'], dict( action='store_true', help=flag_text['create.default'])), (['-ip', '--instance_profile'], dict( help=flag_text['create.iprofile'])), (['-sr', '--service-role'], dict( help=flag_text['create.servicerole'])), (['--version'], dict(help=flag_text['create.version'])), (['-k', '--keyname'], dict(help=flag_text['create.keyname'])), (['--scale'], dict(type=int, help=flag_text['create.scale'])), (['-nh', '--nohang'], dict( action='store_true', help=flag_text['create.nohang'])), (['--timeout'], dict(type=int, help=flag_text['general.timeout'])), (['--tags'], dict(help=flag_text['create.tags'])), (['--envvars'], dict(help=flag_text['create.envvars'])), (['--cfg'], dict(help=flag_text['create.config'])), (['--source'], dict(help=flag_text['create.source'])), (['--elb-type'], dict(help=flag_text['create.elb_type'])), (['-ls', '--shared-lb'], dict(help=flag_text['create.shared_lb'])), (['-lp', '--shared-lb-port'], dict(help=flag_text['create.shared_lb_port'])), (['-es', '--enable-spot'], dict(action='store_true', help=flag_text['create.enable_spot'])), (['-sm', '--spot-max-price'], dict(help=flag_text['create.maxprice'])), (['-it', '--instance-types'], dict(help=flag_text['create.instance_types'])), (['-sb', '--on-demand-base-capacity'], dict(help=flag_text['create.on_demand_capacity'])), (['-sp', '--on-demand-above-base-capacity'], dict(help=flag_text['create.on_demand_above_base_percent'])), (['-im', '--min-instances'], dict(help=flag_text['create.min_instances'])), (['-ix', '--max-instances'], dict(help=flag_text['create.max_instances'])), (['-db', '--database'], dict( action="store_true", help=flag_text['create.database'])), # Hidden RDS commands ( ['-db.user', '--database.username'], dict( dest='db_user', help=argparse.SUPPRESS ) ), (['-db.pass', '--database.password'], dict(dest='db_pass', help=argparse.SUPPRESS)), (['-db.i', '--database.instance'], dict(dest='db_instance', help=argparse.SUPPRESS)), (['-db.version', '--database.version'], dict(dest='db_version', help=argparse.SUPPRESS)), (['-db.size', '--database.size'], dict(type=int, dest='db_size', help=argparse.SUPPRESS)), (['-db.engine', '--database.engine'], dict(dest='db_engine', help=argparse.SUPPRESS)), (['--vpc'], dict(action='store_true', help=flag_text['create.vpc'])), (['--vpc.id'], dict(dest='vpc_id', help=argparse.SUPPRESS)), (['--vpc.ec2subnets'], dict( dest='vpc_ec2subnets', help=argparse.SUPPRESS)), (['--vpc.elbsubnets'], dict( dest='vpc_elbsubnets', help=argparse.SUPPRESS)), (['--vpc.elbpublic'], dict( action='store_true', dest='vpc_elbpublic', help=argparse.SUPPRESS)), (['--vpc.publicip'], dict( action='store_true', dest='vpc_publicip', help=argparse.SUPPRESS)), (['--vpc.securitygroups'], dict( dest='vpc_securitygroups', help=argparse.SUPPRESS)), (['--vpc.dbsubnets'], dict( dest='vpc_dbsubnets', help=argparse.SUPPRESS)), (['-pr', '--process'], dict( action='store_true', help=flag_text['create.process'])), ] 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 shared_lb = self.app.pargs.shared_lb shared_lb_port = self.app.pargs.shared_lb_port 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 single and shared_lb: raise InvalidOptionsError(alerts['create.can_not_use_options_together'].format("--single", "--shared-lb")) if (shared_lb or shared_lb_port) and elb_type != 'application': raise InvalidOptionsError(alerts['sharedlb.wrong_elb_type']) if shared_lb_port and not shared_lb: raise InvalidOptionsError(alerts['sharedlb.missing_shared_lb']) 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 == "": raise InvalidOptionsError(strings['spot.instance_types_validation']) if itype and instance_types: raise InvalidOptionsError(strings['create.itype_and_instances']) if service_role and not iam.role_exists(service_role): raise InvalidOptionsError(f"The specified service role '{service_role}' does not exist. Please use a role that exists or create a new role .") 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() vpc = self.form_vpc_object(tier, single) elb_type = elb_type or get_elb_type_from_customer(interactive, single, tier) shared_lb = get_shared_load_balancer(interactive, elb_type, platform, shared_lb, vpc) shared_lb_port = shared_lb_port or shared_lb_ops.get_shared_lb_port_from_customer(interactive, shared_lb) 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() 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, shared_lb = shared_lb, shared_lb_port = shared_lb_port, 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 form_database_object(self): create_db = self.app.pargs.database username = self.app.pargs.db_user password = self.app.pargs.db_pass engine = self.app.pargs.db_engine size = self.app.pargs.db_size instance = self.app.pargs.db_instance version = self.app.pargs.db_version if create_db or username or password or engine or size \ or instance or version: db_object = dict() if not username: io.echo() username = io.get_input(prompts['rds.username'], default='ebroot') if not password: password = io.get_pass(prompts['rds.password']) db_object['username'] = username db_object['password'] = password db_object['engine'] = engine db_object['size'] = str(size) if size else None db_object['instance'] = instance db_object['version'] = version return db_object else: return {} def form_vpc_object(self, tier, single): vpc = self.app.pargs.vpc vpc_id = self.app.pargs.vpc_id ec2subnets = self.app.pargs.vpc_ec2subnets elbsubnets = self.app.pargs.vpc_elbsubnets elbpublic = self.app.pargs.vpc_elbpublic publicip = self.app.pargs.vpc_publicip securitygroups = self.app.pargs.vpc_securitygroups dbsubnets = self.app.pargs.vpc_dbsubnets database = self.app.pargs.database if vpc: io.echo() vpc_id = vpc_id or io.get_input(prompts['vpc.id']) if not tier or tier.is_webserver(): publicip = publicip or io.get_boolean_response(text=prompts['vpc.publicip']) ec2subnets = ec2subnets or io.get_input(prompts['vpc.ec2subnets']) if (not tier or tier.is_webserver()) and not single: elbsubnets = elbsubnets or io.get_input(prompts['vpc.elbsubnets']) elbpublic = elbpublic or io.get_boolean_response(text=prompts['vpc.elbpublic']) securitygroups = securitygroups or io.get_input(prompts['vpc.securitygroups']) if database: dbsubnets = dbsubnets or io.get_input(prompts['vpc.dbsubnets']) if vpc_id or vpc: vpc_object = dict() vpc_object['id'] = vpc_id vpc_object['ec2subnets'] = ec2subnets if (not tier or tier.is_webserver()) and not single: vpc_object['elbsubnets'] = elbsubnets vpc_object['elbscheme'] = 'public' if elbpublic else 'internal' else: vpc_object['elbsubnets'] = None vpc_object['elbscheme'] = None if not tier or tier.is_webserver(): vpc_object['publicip'] = 'true' if publicip else 'false' else: vpc_object['publicip'] = None vpc_object['securitygroups'] = securitygroups vpc_object['dbsubnets'] = dbsubnets return vpc_object else: return {} def compose_multiple_apps(self): module_names = self.app.pargs.modules group = self.app.pargs.env_group_suffix or 'dev' nohang = self.app.pargs.nohang timeout = self.app.pargs.timeout root_dir = os.getcwd() version_labels = [] grouped_env_names = [] app_name = None for module in module_names: if not os.path.isdir(os.path.join(root_dir, module)): io.log_warning(strings['create.appdoesntexist'].replace('{app_name}', module)) continue os.chdir(os.path.join(root_dir, module)) if not fileoperations.env_yaml_exists(): io.log_warning(strings['compose.noenvyaml'].replace('{module}', module)) continue io.echo('--- Creating application version for module: {0} ---'.format(module)) hooks.set_region(None) hooks.set_ssl(None) hooks.set_profile(None) commonops.set_group_suffix_for_current_branch(group) if not app_name: app_name = self.get_app_name() process_app_version = fileoperations.env_yaml_exists() version_label = commonops.create_app_version(app_name, process=process_app_version) version_labels.append(version_label) environment_name = fileoperations.get_env_name_from_env_yaml() if environment_name is not None: commonops.set_environment_for_current_branch(environment_name. replace('+', '-{0}'. format(group))) grouped_env_names.append(environment_name.replace('+', '-{0}'. format(group))) os.chdir(root_dir) if len(version_labels) > 0: composeops.compose(app_name, version_labels, grouped_env_names, group, nohang, timeout) else: io.log_warning(strings['compose.novalidmodules']) def get_environment_cname(env_name, provided_env_name, tier): """ Returns the CNAME for the environment that will be created. Suggests to customer a name based of the environment name, which the customer is free to disregard. :param env_name: Name of the environment determined by `create.get_environment_name` :param provided_env_name: True/False depending on whether or not the customer passed an environment name through the command line :return: Unique CNAME for the environment which will be created by `eb create` """ if tier and tier.is_worker(): return if not provided_env_name: return get_cname_from_customer(env_name) 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 get_environment_tier(tier): """ Set the 'tier' for the environment from the raw value received for the `--tier` argument. If a configuration template corresponding to `template_name` is also resolved, and the tier corresponding to the configuration template is a 'worker' tier, any previously set value for 'tier' is replaced with the value from the saved config. :return: A Tier object representing the environment's tier type """ if tier: tier = Tier.from_raw_string(tier) return tier def get_unique_cname(env_name): """ Derive a unique CNAME for a new environment based on the environment name :param env_name: name of the environment directory :return: A unique CNAME for a new environment """ cname = env_name tried_cnames = [] while not elasticbeanstalk.is_cname_available(cname): tried_cnames.append(cname) _sleep(0.5) cname = utils.get_unique_name(cname, tried_cnames) return cname def get_unique_environment_name(app_name): """ Derive a unique name for a new environment based on the application name to suggest to the customer :param app_name: name of the application associated with the present working directory :return: A unique name for a new environment """ default_name = app_name + '-dev' current_environments = elasticbeanstalk.get_all_environment_names() return utils.get_unique_name(default_name, current_environments) def get_cname_from_customer(env_name): """ Prompt customer to specify the CNAME for the environment. Selection defaults to the Environment's name when provided with blank input. :param env_name: name of the environment whose CNAME to configure :return: CNAME chosen for the environment """ cname = get_unique_cname(env_name) while True: cname = io.prompt_for_cname(default=cname) if cname and not elasticbeanstalk.is_cname_available(cname): io.echo('That cname is not available. Please choose another.') else: break return cname def get_elb_type_from_customer(interactive, single, tier): """ Prompt customer to specify the ELB type if operating in the interactive mode and on a load-balanced environment. Selection defaults to 'application' when provided with blank input. :param interactive: True/False depending on whether operating in the interactive mode or not :param single: False/True depending on whether environment is load balanced or not :param region: AWS region in which in load balancer will be created :param tier: the tier type of the environment :return: selected ELB type which is one among ['application', 'classic', 'network'] """ if single or (tier and not tier.is_webserver()): return elif not interactive: return elb_names.APPLICATION_VERSION io.echo() io.echo('Select a load balancer type') result = utils.prompt_for_item_in_list( [elb_names.CLASSIC_VERSION, elb_names.APPLICATION_VERSION, elb_names.NETWORK_VERSION], default=2 ) elb_type = result return elb_type def get_shared_load_balancer(interactive, elb_type, platform, shared_lb=None, vpc=None): if shared_lb: shared_lb = shared_lb_ops.validate_shared_lb_for_non_interactive(shared_lb) else: shared_lb = shared_lb_ops.get_shared_lb_from_customer(interactive, elb_type, platform, vpc) return shared_lb def get_and_validate_envars(environment_variables_input): """ Returns a list of environment variables as option settings from the raw environment variables string input provided by the customer :param environment_variables_input: a string of the form "KEY_1=VALUE_1,...,KYE_N=VALUE_N" :return: the list of option settings derived from the key-value pairs in `environment_variables_input` """ environment_variables = envvarops.sanitize_environment_variables_from_customer_input( environment_variables_input ) environment_variable_option_settings, options_to_remove = envvarops.create_environment_variables_list( environment_variables ) return environment_variable_option_settings def get_template_name(app_name, cfg): """ Returns the name of the saved configuration template: - specified by the customer stored in S3 - identified as 'default' present locally For more information, please refer to saved_configs.resolve_config_name :param app_name: name of the application associated with this directory :param cfg: saved config name specified by the customer :return: normalized """ if not cfg: if not saved_configs.resolve_config_location('default'): return else: cfg = 'default' return saved_configs.resolve_config_name(app_name, cfg) def _determine_platform(platform_string=None, iprofile=None): platform = None if not platform_string: platform_string = platformops.get_configured_default_platform() if platform_string: platform = platformops.get_platform_for_platform_string( platform_string) else: platform = platformops.prompt_for_platform() if isinstance(platform, SolutionStack): if platform.language_name == 'Multi-container Docker' and not iprofile: io.log_warning(prompts['ecs.permissions']) if isinstance(platform, PlatformVersion): platform.hydrate(elasticbeanstalk.describe_platform_version) if platform.platform_branch_lifecycle_state == platform_branch_lifecycle_states.RETIRED: raise RetiredPlatformBranchError(alerts['platformbranch.retired']) statusops.alert_platform_status(platform) if 'Multi-container Docker' in platform.platform_name and not iprofile: io.log_warning(prompts['ecs.permissions']) return platform def _sleep(seconds): time.sleep(seconds)