def ask_rds_creation(cls, parameter_pool): stack = parameter_pool.get_value(PName.SolutionStack, False) snippet_url = parameter_pool.get_value(PName.RdsSnippetUrl, False) if not rds_utils.is_rds_snippet_compatible(parameter_pool, stack, snippet_url): parameter_pool.put( Parameter(PName.RdsEnabled, False, PSource.Terminal), True) return # solution stack not compatible with snippet if parameter_pool.has(PName.RdsEnabled): ori_rds_creation = parameter_pool.get_value( PName.RdsEnabled, False) msg = AskMsg[PName.RdsEnabled].format(TerminalMessage.CurrentValue.\ format(misc.bool_to_yesno(ori_rds_creation))) raw_answer = cls.line_input(msg, True) if raw_answer is None: rds_creation = ori_rds_creation else: rds_creation = misc.string_to_boolean(raw_answer) else: raw_answer = cls.line_input(AskMsg[PName.RdsEnabled].format('')) rds_creation = misc.string_to_boolean(raw_answer) parameter_pool.put( Parameter(PName.RdsEnabled, rds_creation, PSource.Terminal), True) if rds_creation: cls.ask_snapshot_name(parameter_pool) cls.ask_master_password(parameter_pool) cls.ask_delete_to_snapshot(parameter_pool)
def generate_endpoint(parameter_pool, region, source, force=False): parameter_pool.put( Parameter(ParameterName.ServiceEndpoint, ServiceEndpoint[region], source)) parameter_pool.put( Parameter(ParameterName.DevToolsEndpoint, DevToolsEndpoint[region], source))
def generate_endpoint(parameter_pool, region, source, force = False): parameter_pool.put(Parameter(ParameterName.RdsEndpoint, RdsEndpoint[region], source)) parameter_pool.put(Parameter(ParameterName.RdsSnippetUrl, RdsDefault.get_snippet_url(region), source))
def execute(self, parameter_pool): current_branch, branch_count = shell_utils.get_working_branch(True) parameter_pool.put( Parameter(ParameterName.CurrentBranch, current_branch, ParameterSource.ConfigFile)) if current_branch: log.info('Current working branch is "{0}".'.format(current_branch)) branches = parameter_pool.get_value(ParameterName.Branches)\ if parameter_pool.has(ParameterName.Branches) else None if branches and current_branch in list(branches.keys()): log.info( 'Found registered environment for branch "{0}".'.format( current_branch)) for key, value in branches[current_branch].items(): parameter_pool.put( Parameter(key, value, ParameterSource.ConfigFile)) else: if branch_count == 1: log.info( 'Only one unregistered branch found. Using default settings.' ) pass else: msg = TerminalMessage.FallBackToDefaultBranch.format( current_branch) log.error(msg) prompt.error(msg) else: # local repository does not have more than one branch, using default pass
def parse(parameter_pool, line=None): ''' Parse command arguments''' parser = ArgumentParser(description=EBSCliAttr.Name, usage=EBSCliAttr.Usage) _init_parser(parser) if line is not None: args = vars(parser.parse_args(line.split())) else: args = vars(parser.parse_args()) # Post prcessing if args[ParameterName.EnvironmentTier] is not None: tier_serialized = args[ParameterName.EnvironmentTier] args[ParameterName. EnvironmentTier] = EnvironmentTier.from_serialized_string( tier_serialized) if args[ParameterName.SolutionStack] is not None: solution_stack = _word_join(args[ParameterName.SolutionStack], u' ') args[ParameterName.SolutionStack] = solution_stack if args[ParameterName.Region] is not None: region_id = args[ParameterName.Region] region = ServiceRegionId.keys()[ServiceRegionId.values().index( region_id)] args[ParameterName.Region] = region # Store command line arguments into parameter pool for arg, value in args.iteritems(): arg = misc.to_unicode(arg, convert_none=False) # Try to convert string/list-of-string parameters to unicode if arg not in NON_STRING_PARAMETERS: if isinstance(value, list): value = [misc.to_unicode(item) for item in value] else: value = misc.to_unicode(value, convert_none=False) if arg == CLISwitch[ParameterName.Command]: parameter_pool.put( Parameter(ParameterName.Command, value, ParameterSource.CliArgument)) elif arg == CLISwitch[ParameterName.SubCommand]: parameter_pool.put( Parameter(ParameterName.SubCommand, value, ParameterSource.CliArgument)) elif value is not None: parameter_pool.put( Parameter(arg, value, ParameterSource.CliArgument)) log.info(u'Finished parsing command line arguments') if log.isEnabledFor(logging.DEBUG): log.debug(u'Received arguments: {0}'.\ format(misc.collection_to_string(parameter_pool.parameter_names))) return args
def ask_environment_name(cls, parameter_pool): # Auto generate environment name if not specified by user if not parameter_pool.has(ParameterName.EnvironmentName): old_env_name = None app_name = parameter_pool.get_value(ParameterName.ApplicationName, False) env_name = cls.generate_env_name(app_name) cls.ask_parameter(parameter_pool, ParameterName.EnvironmentName, autogen_value=env_name) else: old_env_name = parameter_pool.get_value( ParameterName.EnvironmentName, False) cls.ask_parameter(parameter_pool, ParameterName.EnvironmentName) # Post processing new_env_name = parameter_pool.get_value(ParameterName.EnvironmentName, False) new_env_source = parameter_pool.get_source( ParameterName.EnvironmentName) # Reload RDS password if environment name changes if old_env_name != new_env_name: location = parameter_pool.get_value( ParameterName.AwsCredentialFile) rds_password = config_file.read_rds_master_password( new_env_name, location) if rds_password: parameter_pool.put( Parameter(ParameterName.RdsMasterPassword, rds_password, new_env_source)) else: parameter_pool.remove(ParameterName.RdsMasterPassword) # Generate option setting file pathname if parameter_pool.get_source(ParameterName.OptionSettingFile) == ParameterSource.Default\ or not misc.string_equal_ignore_case(old_env_name, new_env_name): new_opsetting_path = os.path.join( os.getcwdu(), EbLocalDir.Path, OptionSettingFile.Name + u'.' + new_env_name) old_opsetting_path = parameter_pool.get_value( ParameterName.OptionSettingFile, False) # Rename old style optionsetting file if parameter_pool.get_source(ParameterName.OptionSettingFile) == ParameterSource.Default\ and parameter_pool.has(ParameterName.OriginalSolutionStack)\ and old_opsetting_path and os.path.exists(old_opsetting_path): os.rename(old_opsetting_path, new_opsetting_path) # Update optionsetting file name in parameter pool parameter_pool.put( Parameter(ParameterName.OptionSettingFile, new_opsetting_path, new_env_source))
def execute(self, parameter_pool): location = EbLocalDir.Path + os.path.sep + EbConfigFile.Name try: config_file.load_eb_config_file(location, parameter_pool, False) if config_file.check_access_permission(location) is False: message = ConfigFileErrorMessage.PermissionError.format(EbConfigFile.Name) log.info(message) prompt.error(message) #Post processing if not parameter_pool.has(ParameterName.RdsSnippetUrl)\ and parameter_pool.has(ParameterName.Region): region = parameter_pool.get_value(ParameterName.Region, False) parameter_pool.put(Parameter(ParameterName.RdsSnippetUrl, RdsDefault.get_snippet_url(region), ParameterSource.ConfigFile)) except EBConfigFileNotExistError: log.error(u'Configuration file "{0}" not exist.'.format(EbConfigFile.Name)) prompt.error(ConfigFileMessage.CannotFind.format\ (EbConfigFile.Name, CommandType.INIT.lower())) raise EBSCliException() except BaseException as ex: log.error(u'Encountered error when load configuration file "{0}", becuase "{1}".'.\ format(EbConfigFile.Name, ex)) prompt.error(ConfigFileMessage.CorrectionSuggestion. format(location,CommandType.INIT.lower())) raise ret_result = OperationResult(self, None, None, None) return ret_result
def execute(self, parameter_pool): eb_client = ElasticBeanstalkClient( parameter_pool.get_value(ParameterName.AwsAccessKeyId), parameter_pool.get_value(ParameterName.AwsSecretAccessKey), parameter_pool.get_value(ParameterName.ServiceEndpoint)) prompt.action(ListSolutionStackOpMessage.Start) response = eb_client.list_available_solutionstacks() name_set = set() name_string = u'\n\t' for stack in response.result: name_set.add(stack.solutionstack_name) name_string += stack.solutionstack_name + u'\n\t' log.info(u'Available solution stacks: \n{0}'.format(name_string)) prompt.result(ListSolutionStackOpMessage.Result.format(name_string)) parameter_pool.put( Parameter(ParameterName.AvailableSolutionStacks, name_set, ParameterSource.OperationOutput)) ret_result = OperationResult( self, response.request_id, ListSolutionStackOpMessage.Result.format(name_string), response.result) return ret_result
def ask_snapshot_name(cls, parameter_pool): original_value = parameter_pool.get_value(PName.RdsSourceSnapshotName) append_message = TerminalMessage.CurrentValue.format(RdsTerminalMessage.NoSnapshot)\ if original_value is None else TerminalMessage.CurrentValue.format(original_value) print( (RdsTerminalMessage.RdsSnapshotNameSelect.format(append_message))) snapshots = api_wrapper.retrive_rds_snapshots(parameter_pool) sorted_snapshots = cls._sort_snapshots_by_create_time(snapshots) snapshot_list = [ RdsTerminalMessage.NoSnapshot, ] for i in range( 0, min(len(sorted_snapshots), TerminalConstant.RdsSnapshotListNumber)): snapshot_list.append(sorted_snapshots[i].db_snapshot_identifier) snapshot_list.append(RdsTerminalMessage.OtherSnapshot) snapshot_index = cls.single_choice(choice_list=snapshot_list, can_return_none=True) if snapshot_index == 0: # Create RDS instance from scratch value = None elif snapshot_index == len(snapshot_list) - 1: # Name not in list value = cls.ask_value(parameter_pool, PName.RdsSourceSnapshotName) else: value = snapshot_list[ snapshot_index] if snapshot_index is not None else original_value snapshot = Parameter(PName.RdsSourceSnapshotName, value, PSource.Terminal) parameter_pool.put(snapshot, True)
def read_aws_credential_file(location, parameter_pool, func_matrix, source, quiet=False): try: env_name = parameter_pool.get_value(ParameterName.EnvironmentName) \ if parameter_pool.has(ParameterName.EnvironmentName) else u'' log.info(u'Reading AWS credential from file: "{0}"'.format(location)) parser = NoSectionConfigParser() parser.read(location) for name, from_file_func in func_matrix: if name == ParameterName.RdsMasterPassword: key_name = rds_utils.password_key_name(env_name) else: key_name = AwsCredentialFileDefault.KeyName[name] if parser.has_option(key_name): value = parser.get(key_name) value = from_file_func( value) if from_file_func is not None else value parameter_pool.put(Parameter(name, value, source)) log.info(u'Finished reading AWS credential from file.') except BaseException as ex: log.error(u'Failed to retrieve AWS credential from file "{0}", because: "{1}"'.\ format(location, ex)) if not quiet: msg = CredentialFileErrorMessage.ReadError.format(location) prompt.error(msg) raise EBSCliException(msg) else: return False # if failed, just skip
def execute(self, parameter_pool): eb_client = self._get_eb_client(parameter_pool) prompt.action(ListSolutionStackOpMessage.Start) response = eb_client.list_available_solutionstacks() name_set = set() name_string = '\n\t' for stack in response.result: name_set.add(stack.solutionstack_name) name_string += stack.solutionstack_name + '\n\t' log.info('Available solution stacks: \n{0}'.format(name_string)) prompt.result(ListSolutionStackOpMessage.Result.format(name_string)) parameter_pool.put(Parameter(ParameterName.AvailableSolutionStacks, name_set, ParameterSource.OperationOutput)) ret_result = OperationResult(self, response.request_id, ListSolutionStackOpMessage.Result.format(name_string), response.result) return ret_result
def execute(self, parameter_pool): eb_client = self._get_eb_client(parameter_pool) app_name = parameter_pool.get_value(ParameterName.ApplicationName, False) env_name = parameter_pool.get_value(ParameterName.EnvironmentName, False) response = eb_client.describe_environments(app_name, env_name, include_deleted=False) if len(response.result) > 0: # If have result version_name = response.result[0].version_label log.info( 'Retrieved application version {0} for environment {1}'.format( version_name, env_name)) prompt.info( RecordApplicationVersionOpMessage.Succeed.format(version_name)) parameter_pool.put( Parameter(ParameterName.ApplicationVersionName, version_name, ParameterSource.OperationOutput), True) ret_result = OperationResult(self, response.request_id, None, response.result) return ret_result
def execute(self, parameter_pool): eb_client = self._get_eb_client(parameter_pool) env_name = parameter_pool.get_value(ParameterName.EnvironmentName) prompt.action(TerminateEnvironmentOpMessage.Start.format(env_name)) try: response = eb_client.terminate_environment(env_name) except: raise else: log.info(u'Received response for TerminateEnvironemnt call.') prompt.result( TerminateEnvironmentOpMessage.Succeed.format(env_name)) self._log_api_result(self.__class__.__name__, u'TerminateEnvironment', response.result) parameter_pool.put( Parameter(ParameterName.TerminateEnvironmentRequestID, response.request_id, ParameterSource.OperationOutput)) ret_result = OperationResult(self, response.request_id, TerminateEnvironmentOpMessage.Succeed, response.result) return ret_result
def ask_master_password(cls, parameter_pool): for _ in range(0, RdsDefault.PasswordMismatchThreshold): password = cls.ask_value(parameter_pool, PName.RdsMasterPassword, no_echo=True) if password is None: return else: if not ParameterValidator.validate_alphanumeric( password, RdsDefault.PasswordMinSize, RdsDefault.PasswordMaxSize): prompt.error(RdsTerminalMessage.PasswordWrongFormat) continue confirm = cls.line_input( RdsTerminalMessage.PasswordConfirmation, can_return_none=False, no_echo=True) if confirm != password: prompt.error(RdsTerminalMessage.PasswordNotMatch) else: parameter_pool.put( Parameter(PName.RdsMasterPassword, password, PSource.Terminal), True) return else: prompt.error(RdsTerminalMessage.PasswordMatchFailure) raise EBSCliException()
def ask_branch_environment_name(cls, parameter_pool): # Auto generate environment name if not specified by user if not parameter_pool.has(ParameterName.EnvironmentName): old_env_name = None app_name = parameter_pool.get_value(ParameterName.ApplicationName, False) current_branch = parameter_pool.get_value( ParameterName.CurrentBranch, False) env_name = cls.generate_env_name(app_name \ + ServiceDefault.Environment.BRANCH_NAME_SEPERATOR\ + current_branch) cls.ask_parameter(parameter_pool, ParameterName.EnvironmentName, autogen_value=env_name) else: old_env_name = parameter_pool.get_value( ParameterName.EnvironmentName, False) cls.ask_parameter(parameter_pool, ParameterName.EnvironmentName) # Generate option setting file pathname new_env_name = parameter_pool.get_value(ParameterName.EnvironmentName, False) if not misc.string_equal_ignore_case(old_env_name, new_env_name): new_opsetting_path = os.path.join( os.getcwdu(), EbLocalDir.Path, OptionSettingFile.Name + u'.' + new_env_name) parameter_pool.put( Parameter( ParameterName.OptionSettingFile, new_opsetting_path, parameter_pool.get_source(ParameterName.EnvironmentName)))
def ask_solution_stack(cls, parameter_pool): # Skip if user supplies solution stack string as CLI arguments, or already by terminal if parameter_pool.has(ParameterName.SolutionStack) \ and ParameterSource.is_ahead(parameter_pool.get_source(ParameterName.SolutionStack), ParameterSource.ConfigFile): print((TerminalPromptSettingParameterMessage[ParameterName.SolutionStack].\ format(parameter_pool.get_value(ParameterName.SolutionStack)))) return original_value = parameter_pool.get_value(ParameterName.SolutionStack) \ if parameter_pool.has(ParameterName.SolutionStack) else None append_message = '' if original_value is None \ else TerminalMessage.CurrentValue.format(original_value) print((TerminalPromptAskingMessage[ParameterName.SolutionStack].\ format(append_message))) stacks = api_wrapper.retrieve_solution_stacks(parameter_pool) stack_index = cls.single_choice(stacks, TerminalMessage.AvailableSolutionStack, None, original_value is not None) value = stacks[ stack_index] if stack_index is not None else original_value stack = Parameter(ParameterName.SolutionStack, value, ParameterSource.Terminal) parameter_pool.put(stack, True)
def ask_environment_tier(cls, parameter_pool): # Skip if user supplies environment tier string as CLI arguments, or already by terminal if parameter_pool.has(ParameterName.EnvironmentTier) \ and ParameterSource.is_ahead(parameter_pool.get_source(ParameterName.EnvironmentTier), ParameterSource.ConfigFile): serialized_tier = parameter_pool.get_value( ParameterName.EnvironmentTier, False).to_serialized_string() print(TerminalPromptSettingParameterMessage[ParameterName.EnvironmentTier].\ format(serialized_tier)) return original_value = parameter_pool.get_value( ParameterName.EnvironmentTier) append_message = u'' if original_value is None \ else TerminalMessage.CurrentValue.format(original_value.to_serialized_string()) print(TerminalPromptAskingMessage[ParameterName.EnvironmentTier].\ format(append_message)) # TODO replace with call to list tiers API once it is created tiers = BeanstalkTerminal.ENVIRONMENT_TIERS serialized_tiers = [tier.to_serialized_string() for tier in tiers] tier_index = cls.single_choice( serialized_tiers, TerminalMessage.AvailableEnvironmentTier, None, original_value is not None) value = tiers[tier_index] if tier_index is not None else original_value tier = Parameter(ParameterName.EnvironmentTier, value, ParameterSource.Terminal) parameter_pool.put(tier, True)
def ask_environment_type(cls, parameter_pool): # Ensure application existence eb_client = api_wrapper.create_eb_client(parameter_pool) app_name = parameter_pool.get_value(ParameterName.ApplicationName, False) api_wrapper.create_application(parameter_pool, app_name, eb_client = eb_client) # Get available environment types solution_stack = parameter_pool.get_value(ParameterName.SolutionStack, False) optionDef = eb_utils.get_option_def(eb_client = eb_client, app_name = app_name, namespace = OptionSettingEnvironmentType.Namespace, option_name = OptionSettingEnvironmentType.OptionName, solution_stack = solution_stack) if optionDef and len(optionDef.value_options) > 0: # Ask for environment type is option is available original_value = parameter_pool.get_value(ParameterName.EnvironmentType) append_message = '' if original_value is None \ else TerminalMessage.CurrentValue.format(original_value) print((TerminalPromptAskingMessage[ParameterName.EnvironmentType].\ format(append_message))) availableTypes = optionDef.value_options type_index = cls.single_choice(choice_list = availableTypes, title = TerminalMessage.AvailableEnvironmentType, message = None, can_return_none = original_value is not None) value = availableTypes[type_index] if type_index is not None else original_value envtype = Parameter(ParameterName.EnvironmentType, value, ParameterSource.Terminal) parameter_pool.put(envtype, True) else: # Remove environment type parameter_pool.remove(ParameterName.EnvironmentType)
def execute(self, parameter_pool): eb_client = self._get_eb_client(parameter_pool) app_name = parameter_pool.get_value(ParameterName.ApplicationName, False) env_name = parameter_pool.get_value(ParameterName.EnvironmentName, False) stack_name = parameter_pool.get_value(ParameterName.SolutionStack, False) prompt.action( UpdateEnvironmentOptionSettingOpMessage.Start.format(env_name)) spec = TemplateSpecification() # Try load option setting file if exist option_location = parameter_pool.get_value( ParameterName.OptionSettingFile, False) option_settings = config_file.load_env_option_setting_file( option_location, quiet=True) if option_settings is not None and len(option_settings) > 0: prompt.info( UpdateEnvironmentOptionSettingOpMessage.UsingOptionSetting. format(option_location)) else: option_settings = dict() option_remove = dict() self._option_setting_handler(parameter_pool, spec, stack_name, option_settings, option_remove) self._validate_change(parameter_pool, eb_client, app_name, env_name, option_settings, option_remove, spec) try: response = eb_client.update_environment( env_name, option_settings=option_settings, option_remove=option_remove, template_specification=spec) except: raise else: log.info(u'Received response for UpdateEnvironemnt call.') prompt.result( UpdateEnvironmentOptionSettingOpMessage.Succeed.format( env_name)) self._log_api_result(self.__class__.__name__, u'UpdateEnvironment', response.result) parameter_pool.put( Parameter(ParameterName.UpdateEnvironmentRequestID, response.request_id, ParameterSource.OperationOutput)) ret_result = OperationResult( self, response.request_id, UpdateEnvironmentOptionSettingOpMessage.Succeed.format( env_name), response.result) return ret_result
def execute(self, parameter_pool): eb_client = ElasticBeanstalkClient( parameter_pool.get_value(ParameterName.AwsAccessKeyId), parameter_pool.get_value(ParameterName.AwsSecretAccessKey), parameter_pool.get_value(ParameterName.ServiceEndpoint)) app_name = parameter_pool.get_value(ParameterName.ApplicationName) env_name = parameter_pool.get_value(ParameterName.EnvironmentName) stack_name = parameter_pool.get_value(ParameterName.SolutionStack) prompt.action( UpdateEnvironmentOptionSettingOpMessage.Start.format(env_name)) location = parameter_pool.get_value(ParameterName.OptionSettingFile) option_settings = config_file.load_env_option_setting_file(location, quiet=True) if option_settings is not None and len(option_settings) > 0: prompt.info( UpdateEnvironmentOptionSettingOpMessage.UsingOptionSetting. format(location)) else: option_settings = [] option_remove = set() spec = TemplateSpecification() rds_utils.rds_handler(parameter_pool, spec, stack_name, option_settings, option_remove) self._option_setting_handler(option_settings, option_remove) self._validate_change(parameter_pool, eb_client, app_name, env_name, option_settings, option_remove, spec) try: response = eb_client.update_environment( env_name, option_settings=option_settings, option_remove=option_remove, template_specification=spec) except: raise else: log.info('Received response for UpdateEnvironemnt call.') prompt.result( UpdateEnvironmentOptionSettingOpMessage.Succeed.format( env_name)) self._log_api_result(self.__class__.__name__, 'UpdateEnvironment', response.result) parameter_pool.put( Parameter(ParameterName.UpdateEnvironmentRequestID, response.request_id, ParameterSource.OperationOutput)) ret_result = OperationResult( self, response.request_id, UpdateEnvironmentOptionSettingOpMessage.Succeed.format( env_name), response.result) return ret_result
def execute(self, parameter_pool): func_matrix = [] # Loop over default settings for name, _, to_file in CredentialFileParameters: if not parameter_pool.has(name): continue elif ParameterSource.is_ahead(ParameterSource.Terminal,\ parameter_pool.get_source(name)): continue else: func_matrix.append((None, name, to_file)) # Loop over current branch settings cur_branch = parameter_pool.get_value(ParameterName.CurrentBranch)\ if parameter_pool.has(ParameterName.CurrentBranch) else None if cur_branch and ParameterSource.is_ahead( parameter_pool.get_source(ParameterName.Branches), ParameterSource.ConfigFile): branch_setting = parameter_pool.get_value( ParameterName.Branches)[cur_branch] for name, _, to_file in CredentialFileParameters: if not name in branch_setting: continue else: func_matrix.append((cur_branch, name, to_file)) if len(func_matrix) < 1: log.info( 'Skipped updating credential file as credentials are not changed.' ) return location = config_file.default_aws_credential_file_location() # Create directory if needed try: config_file.create_directory( config_file.default_aws_credential_file_path()) config_file.write_aws_credential_file(location, parameter_pool, func_matrix) except BaseException as ex: log.error('Encountered error when creating AWS Credential file at "{0}", because {1}.'.\ format(location, ex)) return else: log.info(WriteAwsCredentialFileOpMessage.Succeed.format(location)) prompt.result( WriteAwsCredentialFileOpMessage.Succeed.format(location)) parameter_pool.put( Parameter(ParameterName.AwsCredentialFile, location, ParameterSource.OperationOutput), True) ret_result = OperationResult(self, None, None, None) return ret_result
def execute(self, parameter_pool): eb_client = ElasticBeanstalkClient(parameter_pool.get_value(ParameterName.AwsAccessKeyId), parameter_pool.get_value(ParameterName.AwsSecretAccessKey), parameter_pool.get_value(ParameterName.ServiceEndpoint)) app_name = parameter_pool.get_value(ParameterName.ApplicationName) version_name = parameter_pool.get_value(ParameterName.ApplicationVersionName) env_name = parameter_pool.get_value(ParameterName.EnvironmentName) stack_name = parameter_pool.get_value(ParameterName.SolutionStack) # Try load option setting file if exist option_file_location = parameter_pool.get_value(ParameterName.OptionSettingFile) option_settings = config_file.load_env_option_setting_file(option_file_location, quiet = True) if option_settings is not None and len(option_settings) > 0: prompt.info(CreateEnvironmentOpMessage.UsingOptionSetting.format(option_file_location)) else: option_settings = [] option_remove = set() spec = TemplateSpecification() rds_utils.rds_handler(parameter_pool, spec, stack_name, option_settings, option_remove) self._option_setting_handler(option_settings, option_remove) prompt.action(CreateEnvironmentOpMessage.Start.format(env_name)) try: response = eb_client.create_environment(application = app_name, environment = env_name, solution_stack = stack_name, version_label = version_name, option_settings = option_settings, option_remove = option_remove, template_specification = spec, ) except AlreadyExistException: log.info(u'Environment "{0}" already exist.'.format(env_name)) prompt.result(CreateEnvironmentOpMessage.AlreadyExist.format(env_name)) ret_result = OperationResult(self, None, CreateEnvironmentOpMessage.AlreadyExist.format(env_name), None) else: log.info(u'Received response for CreateEnvironemnt call.') prompt.info(CreateEnvironmentOpMessage.Succeed) prompt.result(CreateEnvironmentOpMessage.WaitAfterLaunch.format(env_name)) self._log_api_result(self.__class__.__name__, u'CreateEnvironment', response.result) parameter_pool.put(Parameter(ParameterName.CreateEnvironmentRequestID, response.request_id, ParameterSource.OperationOutput)) ret_result = OperationResult(self, response.request_id, CreateEnvironmentOpMessage.Succeed, response.result) return ret_result
def execute(self, parameter_pool): eb_client = ElasticBeanstalkClient( parameter_pool.get_value(ParameterName.AwsAccessKeyId), parameter_pool.get_value(ParameterName.AwsSecretAccessKey), parameter_pool.get_value(ParameterName.ServiceEndpoint)) app_name = parameter_pool.get_value(ParameterName.ApplicationName) version_name = parameter_pool.get_value( ParameterName.ApplicationVersionName) solution_stack = parameter_pool.get_value(ParameterName.SolutionStack) container_name = eb_utils.match_solution_stack(solution_stack) log.info('App container is "{0}".'.format(container_name)) try: response = eb_client.create_application_version( app_name, version_name) except AlreadyExistException: log.info('Version "{0}" of Application "{1}" already exists.'.\ format(version_name, app_name)) prompt.info( CreateApplicationVersionOpMessage.AlreadyExist.format( version_name)) ret_result = OperationResult(self, None, CreateApplicationVersionOpMessage.AlreadyExist.\ format(version_name), None) else: log.info('Received response for CreateApplicationVersion call.') prompt.info( CreateApplicationVersionOpMessage.Succeed.format(version_name)) self._log_api_result(self.__class__.__name__, 'CreateApplicationVersion', response.result) ret_result = OperationResult(self, response.request_id, CreateApplicationVersionOpMessage.Succeed.\ format(version_name), response.result) if eb_utils.has_default_app(parameter_pool, solution_stack): log.info('Solution stack "{0}" has default sample app.'.format( solution_stack)) prompt.info( CreateApplicationVersionOpMessage.HasDefaultAppSource.format( solution_stack)) else: # Set version to None source = parameter_pool.get_source( ParameterName.ApplicationVersionName) parameter_pool.put( Parameter(ParameterName.ApplicationVersionName, None, source), True) return ret_result
def parse(parameter_pool, line = None): ''' Parse command arguments''' parser = ArgumentParser(description = EBSCliAttr.Name, usage = EBSCliAttr.Usage) _init_parser(parser) if line is not None: args = vars(parser.parse_args(line.split())) else: args = vars(parser.parse_args()) # Post prcessing if args[ParameterName.SolutionStack] is not None: solution_stack = _word_join(args[ParameterName.SolutionStack], ' ') args[ParameterName.SolutionStack] = solution_stack if args[ParameterName.Region] is not None: region_id = args[ParameterName.Region] region = list(ServiceRegionId.keys())[list(ServiceRegionId.values()).index(region_id)] args[ParameterName.Region] = region # Store command line arguments into parameter pool for arg, value in args.items(): if value is not None: arg = misc.to_unicode(arg) value = misc.to_unicode(value) if arg == CLISwitch[ParameterName.Command]: parameter_pool.put(Parameter(ParameterName.Command, value, ParameterSource.CliArgument)) else: parameter_pool.put(Parameter(arg, value, ParameterSource.CliArgument)) log.info('Finished parsing command line arguments') if log.isEnabledFor(_logging.DEBUG): log.debug('Received arguments: {0}'.\ format(misc.collection_to_string(parameter_pool.parameter_names))) return args
def read_rds_master_password(env_name, location): empty_pool = ParameterPool() empty_pool.put(Parameter(ParameterName.EnvironmentName, env_name, ParameterSource.Default)) func_matrix = [(None, ParameterName.RdsMasterPassword, None)] if location is None: location = default_aws_credential_file_location() read_aws_credential_file(location, empty_pool, func_matrix, empty_pool, True) return empty_pool.get_value(ParameterName.RdsMasterPassword)
def execute(self, parameter_pool): eb_client = self._get_eb_client(parameter_pool) env_name = parameter_pool.get_value(ParameterName.EnvironmentName, False) _, subcommands = parameter_pool.command info_type = subcommands[0].lower() if len(subcommands) > 0 else EbDefault.TailLog response = eb_client.request_environment_info(env_name, info_type=info_type) parameter_pool.put(Parameter(ParameterName.RequestEnvInfoRequestID, response.request_id, ParameterSource.OperationOutput)) ret_result = OperationResult(self, response.request_id, None, None) return ret_result
def _set_parameter_value(cls, parameter_pool, name, value, source, force=False): # Set parameter value if not specified as before with higher priority if parameter_pool.has(name) \ and Source.is_ahead(parameter_pool.get_source(name), Source.Terminal): value = parameter_pool.get_value(name) else: parameter_pool.put(Parameter(name, value, source), force) prompt.info(TerminalPromptSettingParameterMessage[name].format(value))
def load_eb_config_file(location, parameter_pool, quiet=False): try: log.info(u'Reading EB configuration from file: "{0}"'.format(location)) parser = NoSectionConfigParser() parser.read(location) for (name, from_file, _) in ConfigFileParameters: if parser.has_option(name): value = parser.get(name) if from_file is not None: value = from_file(value) parameter_pool.put( Parameter(name, value, ParameterSource.ConfigFile)) # Add original solution stack infos if parser.has_option(ParameterName.SolutionStack): parameter_pool.put( Parameter(ParameterName.OriginalSolutionStack, parser.get(ParameterName.SolutionStack), ParameterSource.ConfigFile)) log.info(u'Finished reading from EB configuration file.') except BaseException as ex: log.error( u'Failed to parse EB configuration from file, because: "{0}"'. format(ex)) if not quiet: if (isinstance(ex, OSError) or isinstance(ex, IOError)) and\ ex.errno == FileErrorConstant.FileNotFoundErrorCode: raise EBConfigFileNotExistError(ex) else: msg = ConfigFileErrorMessage.ReadError.format(location) prompt.error(msg) raise EBConfigFileNotExistError(msg) else: pass # if failed, just skip
def _generate_service_endpoint(self, pool): ''' Generate EB service endpoint from region if not presents, or overwrite if specified region has higher priority. ''' if pool.has(ParameterName.Region) and \ (not pool.has(ParameterName.ServiceEndpoint) or \ ParameterSource.is_ahead(pool.get_source(ParameterName.Region), pool.get_source(ParameterName.ServiceEndpoint))): region = pool.get(ParameterName.Region) log.info(u'Generate service endpoint from region "{0}".'.format( region.value)) pool.put( Parameter(ParameterName.ServiceEndpoint, ServiceEndpoint[region.value], region.source))
def ask_region(cls, parameter_pool): original_value = parameter_pool.get_value(ParameterName.Region) \ if parameter_pool.has(ParameterName.Region) else None original_source = parameter_pool.get_source(ParameterName.Region) \ if parameter_pool.has(ParameterName.Region) else None if original_value is not None and \ ParameterSource.is_ahead(original_source, ParameterSource.Terminal): print(TerminalPromptSettingParameterMessage[ParameterName.Region].\ format(ServiceRegionName[original_value])) region_value = original_value else: append_message = u'' if original_value is None \ else TerminalMessage.CurrentValue.format(ServiceRegionName[original_value]) print TerminalPromptAskingMessage[ParameterName.Region].format(append_message) region_name_list = list() for region in AvailableServiceRegion: region_name_list.append(ServiceRegionName[region]) region_index = cls.single_choice(region_name_list, TerminalMessage.AvailableRegion, None, original_value is not None) region_value = AvailableServiceRegion[region_index] \ if region_index is not None else original_value region = Parameter(ParameterName.Region, misc.to_unicode(region_value), ParameterSource.Terminal) parameter_pool.put(region, True) # Set service endpoint if not specified as CLI arguments cls._set_parameter_value(parameter_pool, ParameterName.ServiceEndpoint, misc.to_unicode(ServiceEndpoint[region_value]), ParameterSource.Terminal) # Set RDS endpont and snippet if not specified as CLI arguments cls._set_parameter_value(parameter_pool, ParameterName.RdsEndpoint, RdsEndpoint[region_value], ParameterSource.Terminal) cls._set_parameter_value(parameter_pool, ParameterName.RdsSnippetUrl, RdsDefault.get_snippet_url(region_value), ParameterSource.Terminal)