def execute(self, parameter_pool): eb_client = self._get_eb_client(parameter_pool) app_name = parameter_pool.get_value(ParameterName.ApplicationName, False) try: response = eb_client.create_application_version( app_name, ServiceDefault.DEFAULT_VERSION_NAME) except AlreadyExistException: log.info('Version "{0}" of Application "{1}" already exists.'.\ format(ServiceDefault.DEFAULT_VERSION_NAME, app_name)) msg = CreateApplicationVersionOpMessage.AlreadyExist.format( ServiceDefault.DEFAULT_VERSION_NAME) prompt.info(msg) ret_result = OperationResult(self, None, msg, None) else: log.info('Received response for CreateApplicationVersion call.') self._log_api_result(self.__class__.__name__, 'CreateApplicationVersion', response.result) msg = CreateApplicationVersionOpMessage.Succeed.format( ServiceDefault.DEFAULT_VERSION_NAME) prompt.info(msg) ret_result = OperationResult(self, response.request_id, msg, 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) try: response = eb_client.create_application(app_name) prompt.result(CreateApplicationOpMessage.Start.format(app_name)) except AlreadyExistException: log.info(u'Application "{0}" already exists.'.format(app_name)) prompt.result( CreateApplicationOpMessage.AlreadyExist.format(app_name)) ret_result = OperationResult( self, None, CreateApplicationOpMessage.AlreadyExist.format(app_name), None) else: log.info(u'Received response for CreateApplication call.') prompt.info(CreateApplicationOpMessage.Succeed.format(app_name)) self._log_api_result(self.__class__.__name__, u'CreateApplication', response.result) ret_result = OperationResult( self, response.request_id, CreateApplicationOpMessage.Succeed.format(app_name), 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) prompt.action(DeleteApplicationOpMessage.Start.format(app_name)) try: response = eb_client.delete_application(app_name, u'true') except OperationInProgressException: log.info(u'Deleting Application "{0}" already in progress'.format( app_name)) prompt.result( DeleteApplicationOpMessage.AlreadyDelete.format(app_name)) ret_result = OperationResult( self, None, DeleteApplicationOpMessage.AlreadyDelete.format(app_name), None) else: log.info(u'Received response for DeleteApplication call.') self._log_api_result(self.__class__.__name__, u'DeleteApplication', response.result) prompt.result(DeleteApplicationOpMessage.Succeed.format(app_name)) ret_result = OperationResult( self, response.request_id, DeleteApplicationOpMessage.Succeed.format(app_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) 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 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 = 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): 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 execute(self, parameter_pool): ori_stack = parameter_pool.get_value(ParameterName.OriginalSolutionStack)\ if parameter_pool.has(ParameterName.OriginalSolutionStack) else None stack = parameter_pool.get_value(ParameterName.SolutionStack)\ if parameter_pool.has(ParameterName.SolutionStack) else None if ori_stack is None or ori_stack == stack: log.info(u'Solution stack is not changed. Keeping current optionsettings file.') else: log.info(u'Rotate optionsettings file because solution stack is changed.') # Rotate default option setting file location = parameter_pool.get_value(ParameterName.OptionSettingFile) config_file.rotate_file(location) # Rotate branch environment option setting file if any branches = parameter_pool.get_value(ParameterName.Branches)\ if parameter_pool.has(ParameterName.Branches) else None if branches: for _, branch in branches.iteritems(): location = branch[ParameterName.OptionSettingFile] config_file.rotate_file(location) ret_result = OperationResult(self, None, None, None) 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 execute(self, pool): # Test if git local repo exists if not os.path.isdir(os.path.join(os.getcwdu(), DevToolsConfigFile.Path)): prompt.error(DevToolsMessage.GitRepoNotExist.format('')) return error = False current_path = os.getcwdu() try: log.info(u'Running Dev Tools initialization script.') if misc.is_os_windows(): path = shell_utils.climb_dir_tree(shell_utils.ori_path(), OSSpecific.WindowsClimbUpDepth) #TODO: replace current workaround for WindowsModuleScript current_path = os.getcwdu() script_path = os.path.join(path, OSSpecific.WindowsModuleScriptPath) log.debug(u'Changing path to {0}.'.format(script_path)) os.chdir(script_path) log.info(u'Running script "{0}".'.format(OSSpecific.WindowsModuleScriptName)) shell_utils.call([OSSpecific.WindowsModuleScriptName]) log.debug(u'Changing path to {0}.'.format(current_path)) os.chdir(current_path) log.info(u'Running script "{0}".'.format(OSSpecific.WindowsRepoScript)) fullpath = os.path.join(path, OSSpecific.WindowsRepoScript) prompt.error(shell_utils.call([fullpath])) else: path = shell_utils.climb_dir_tree(shell_utils.ori_path(), OSSpecific.LinuxClimbUpDepth) log.info(u'Running script "{0}" at {1}.'.format(OSSpecific.LinuxRepoScript, path)) fullpath = os.path.join(path, OSSpecific.LinuxRepoScript) prompt.error(shell_utils.call([fullpath])) location = DevToolsConfigFile.Path + os.path.sep + DevToolsConfigFile.Name config_file.set_access_permission(location, True) except subprocess.CalledProcessError as ex: # Git returned with an error code log.error(u'Dev Tools initialization script report an error, because "{0}".'.format(ex)) error = True prompt.error(DevToolsMessage.InitError.format(ex.message)) except (OSError, IOError) as ex: log.error(u'Failed to call Dev Tools initialization script, because "{0}".'.format(ex)) # Cannot find or run script error = True if ex.errno == FileErrorConstant.FileNotFoundErrorCode: if fullpath: prompt.error(DevToolsMessage.FileMissingError.format(fullpath)) else: prompt.error(ex) finally: if error: prompt.error(DevToolsMessage.ExecutionError.format(DevToolsConfigFile.InitHelpUrl)) ret_result = OperationResult(self, None, None, None) return ret_result
def execute(self, parameter_pool): command = parameter_pool.get_value(PName.Command, False) if command == CommandType.INIT: sanitize = False for name, ori_name in EbConfigFile.BranchResetParameters.iteritems(): if parameter_pool.has(ori_name) and \ parameter_pool.get_value(name, False) != parameter_pool.get_value(ori_name, False): sanitize = True break blast = False if sanitize: if parameter_pool.has(PName.Branches): parameter_pool.remove(PName.Branches) blast = True if parameter_pool.has(PName.BranchMapping): parameter_pool.remove(PName.BranchMapping) blast = True if blast: prompt.error(ConfigFileMessage.BranchResetWarning); ret_result = OperationResult(self, None, u'Need clean: {0}. Removed branch: {1}'.format(sanitize, blast), None) return ret_result
def execute(self, parameter_pool): location = EbLocalDir.Path + os.path.sep + EbConfigFile.Name config_file.load_eb_config_file(location, parameter_pool, True) ret_result = OperationResult(self, None, None, None) return ret_result
def execute(self, pool): # Test if git local repo exists if not os.path.isdir(os.path.join(os.getcwd(), DevToolsConfigFile.Path)): prompt.error(DevToolsMessage.GitRepoNotExist) # raise EBSCliException() return try: self.run_dev_tools_script() location = DevToolsConfigFile.Path + os.path.sep + DevToolsConfigFile.Name config_file.set_access_permission(location, True) except (OSError, IOError, subprocess.CalledProcessError) as ex: log.error( "Encountered error when updating AWS Dev Tools settings: {0}.". format(ex)) message = DevToolsMessage.ExecutionError.format( DevToolsConfigFile.InitHelpUrl) prompt.error(message) # raise EBSCliException() ret_result = OperationResult(self, None, None, None) 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) max_records = parameter_pool.get_value(ParameterName.SubCommand) try: max_records = int(max_records[0]) if len( max_records) > 0 else ServiceDefault.EVENT_DEFAULT_NUM except ValueError: raise EBSCliException( GetEnvironmentEventsOpMessage.NotValidNumber.format( max_records[0])) response = eb_client.describe_events(app_name, env_name, max_records=max_records) if len(response.result) > 0: for event in response.result: msg = u'{0}\t{1}\t{2}'.format(event.event_date, event.severity, event.message) prompt.plain(msg) ret_result = OperationResult(self, response.request_id, None, response.result) return ret_result
def execute(self, parameter_pool): create_request_id = parameter_pool.get_value(PName.CreateEnvironmentRequestID) delay = ServiceDefault.CREATE_ENV_POLL_DELAY if create_request_id is not None else 0 _time.sleep(delay) ret_result = OperationResult(self, None, None, None) return ret_result
def execute(self, parameter_pool): create_eb_local_dir() app_name = parameter_pool.get_value(ParameterName.ApplicationName) env_name = parameter_pool.get_value(ParameterName.EnvironmentName) location = parameter_pool.get_value(ParameterName.OptionSettingFile) prompt.action(SaveConfigurationSettingOpMessage.Start.format(env_name)) try: option_settings = api_wrapper.retrieve_configuration_settings(parameter_pool, app_name, env_name) config_file.save_env_option_setting_file(location, option_settings) except Exception as ex: # Never fail. Just log event if any exception log.info(u'Cannot dump environment option settings before termination, because '.\ format(misc.to_unicode(ex))) option_settings = None else: log.info(SaveConfigurationSettingOpMessage.Succeed.format(location)) prompt.info(SaveConfigurationSettingOpMessage.Succeed.format(location)) ret_result = OperationResult(self, None, None, option_settings) 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) 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): create_eb_local_dir() location = EbLocalDir.Path + os.path.sep + EbConfigFile.Name config_file.save_eb_config_file(location, parameter_pool, False) config_file.set_access_permission(location) ret_result = OperationResult(self, None, None, None) return ret_result
def execute(self, parameter_pool): eb_client = self._get_eb_client(parameter_pool) env_name = parameter_pool.get_value(ParameterName.EnvironmentName, False) wait_timeout = parameter_pool.get_value( ParameterName.WaitForUpdateTimeout, False) poll_delay = parameter_pool.get_value(ParameterName.PollDelay, False) info_request_id = parameter_pool.get_value( ParameterName.RequestEnvInfoRequestID) self._wait_for_env_operation_finish( eb_client=eb_client, env_name=env_name, original_request_id=info_request_id, pending_status=EnvironmentStatus.Updating, expected_health=None, operation_name=self.__class__.__name__, action_name=EnvRetrieveInfoOpMessage.Action, wait_timeout=wait_timeout, poll_delay=poll_delay, include_deleted=u'false', initial_delay=ServiceDefault.UPDATE_ENV_POLL_DELAY, quiet=False) # After polling _, subcommands = parameter_pool.command info_type = subcommands[0].lower( ) if len(subcommands) > 0 else EbDefault.TailLog response = eb_client.retrieve_environment_info(env_name, info_type=info_type) # Sort and find latest log for each instance instance_timestamps = dict() instance_logs = dict() for env_info in response.result: instance_id = env_info.ec2_instance_id timestamp = env_info.sample_timestamp url = env_info.message if not instance_timestamps.has_key(instance_id)\ or instance_timestamps[instance_id] < timestamp: instance_timestamps[instance_id] = timestamp instance_logs[instance_id] = url for instance_id in sorted(instance_logs.keys()): content = misc.to_unicode( requests.get(instance_logs[instance_id]).content) prompt.result(os.linesep + misc.to_terminal_codepage( EnvRetrieveInfoOpMessage.FileOuputPrefix.format(instance_id))) prompt.result(misc.to_terminal_codepage(content)) ret_result = OperationResult(self, None, None, None) return ret_result
def execute(self, parameter_pool): command = parameter_pool.get_value(PName.Command, False) self._probe_rds_change(parameter_pool, command) if parameter_pool.get_value(PName.Force) == ServiceDefault.ENABLED \ or TerminalBase.ask_confirmation(AskConfirmationOpMessage.CommandConfirmation[command]): ret_result = OperationResult(self, None, None, None) return ret_result else: log.info(u'User cancelled command.') raise EBSCliException()
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) prompt.action(DeleteApplicationOpMessage.Start.format(app_name)) try: response = eb_client.delete_application(app_name, 'true') except OperationInProgressException: log.info('Deleting Application "{0}" already in progress'.format( app_name)) prompt.result( DeleteApplicationOpMessage.AlreadyDelete.format(app_name)) ret_result = OperationResult( self, None, DeleteApplicationOpMessage.AlreadyDelete.format(app_name), None) else: log.info('Received response for DeleteApplication call.') self._log_api_result(self.__class__.__name__, 'DeleteApplication', response.result) prompt.result(DeleteApplicationOpMessage.Succeed.format(app_name)) credential_file_loc = config_file.default_aws_credential_file_location( ) param_list = [rds_utils.password_key_name(env_name)] config_file.trim_aws_credential_file(credential_file_loc, parameter_pool, param_list, True) ret_result = OperationResult( self, response.request_id, DeleteApplicationOpMessage.Succeed.format(app_name), response.result) return ret_result
def execute(self, parameter_pool): self._generate_service_endpoint(parameter_pool) self._check_rds_parameter(parameter_pool) required_params = self._operation_queue.required_parameters missing_params = required_params - parameter_pool.parameter_names if len(missing_params) > 0: terminal = Terminal() terminal.ask_parameters(parameter_pool, missing_params, 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)) env_name = parameter_pool.get_value(ParameterName.EnvironmentName) wait_timeout = parameter_pool.get_value( ParameterName.WaitForUpdateTimeout) poll_delay = parameter_pool.get_value(ParameterName.PollDelay) # update_request_id = parameter_pool.get_value(ParameterName.UpdateEnvironmentRequestID)\ # if parameter_pool.has(ParameterName.UpdateEnvironmentRequestID) else None result = self._wait_for_env_operation_finish( eb_client=eb_client, env_name=env_name, original_request_id=None, pending_status=EnvironmentStatus.Updating, expected_health=EnvironmentHealth.Green, operation_name=self.__class__.__name__, action_name=WaitForUpdateEnvOptionSettingFinishOpMessage.Action, wait_timeout=wait_timeout, poll_delay=poll_delay, include_deleted='false', initial_delay=ServiceDefault.UPDATE_ENV_POLL_DELAY) # After polling status = result[0].status health = result[0].health cname = result[0].cname log.info('Stopped polling. Environment "{0}" is now {1}, health is {2}.\nURL is "{3}".'.\ format(env_name, status, health, cname)) if status.lower() == EnvironmentStatus.Ready.lower() \ and health.lower() == EnvironmentHealth.Green.lower(): prompt.result( WaitForUpdateEnvOptionSettingFinishOpMessage.Succeed.format( env_name)) else: prompt.result( WaitForUpdateEnvOptionSettingFinishOpMessage.Timeout.format( env_name)) prompt.info(WaitForUpdateEnvOptionSettingFinishOpMessage.Result.\ format(cname, status, health)) ret_result = OperationResult(self, None, WaitForUpdateEnvOptionSettingFinishOpMessage.Result.\ format(cname, status, health), 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, 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 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)) env_name = parameter_pool.get_value(ParameterName.EnvironmentName) wait_timeout = parameter_pool.get_value( ParameterName.WaitForFinishTimeout) poll_delay = parameter_pool.get_value(ParameterName.PollDelay) terminate_request_id = parameter_pool.get_value(ParameterName.TerminateEnvironmentRequestID)\ if parameter_pool.has(ParameterName.TerminateEnvironmentRequestID) else None result = self._wait_for_env_operation_finish( eb_client=eb_client, env_name=env_name, original_request_id=terminate_request_id, pending_status=EnvironmentStatus.Terminating, expected_health=None, operation_name=self.__class__.__name__, action_name=WaitForTerminateEnvironmentFinishOpMessage.Action, wait_timeout=wait_timeout, poll_delay=poll_delay, include_deleted='true', initial_delay=ServiceDefault.TERMINATE_ENV_POLL_DELAY) # After polling status = result[0].status health = result[0].health log.info('Stopped polling. Environment "{0}" is now {1}, health is {2}.'.format\ (env_name, status, health)) if status.lower() == EnvironmentStatus.Terminated.lower(): prompt.result( WaitForTerminateEnvironmentFinishOpMessage.Succeed.format( env_name)) else: prompt.result( WaitForTerminateEnvironmentFinishOpMessage.Timeout.format( env_name)) prompt.result( WaitForTerminateEnvironmentFinishOpMessage.Status.format( status, health)) ret_result = OperationResult( self, None, WaitForTerminateEnvironmentFinishOpMessage.Result.format(status), 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, False) wait_timeout = parameter_pool.get_value( ParameterName.WaitForFinishTimeout, False) poll_delay = parameter_pool.get_value(ParameterName.PollDelay, False) create_request_id = parameter_pool.get_value( ParameterName.CreateEnvironmentRequestID) result = self._wait_for_env_operation_finish( eb_client=eb_client, env_name=env_name, original_request_id=create_request_id, pending_status=EnvironmentStatus.Launching, expected_health=None, operation_name=self.__class__.__name__, action_name=WaitForCreateEnvironmentFinishOpMessage.Action, wait_timeout=wait_timeout, poll_delay=poll_delay, include_deleted=u'false', initial_delay=0) # After polling status = result[0].status health = result[0].health cname = result[0].cname log.info(u'Stopped polling. Environment "{0}" is now {1}, health is {2}.\nURL is "{3}".'.\ format(env_name, status, health, cname)) if status.lower() == EnvironmentStatus.Ready.lower() \ and health.lower() == EnvironmentHealth.Green.lower(): prompt.info( WaitForCreateEnvironmentFinishOpMessage.Succeed.format( env_name)) prompt.result( WaitForCreateEnvironmentFinishOpMessage.Result.format(cname)) else: prompt.info( WaitForCreateEnvironmentFinishOpMessage.Timeout.format( env_name)) ret_result = OperationResult(self, None, WaitForCreateEnvironmentFinishOpMessage.Result.\ format(cname, status, health), result) return ret_result