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))