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
