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)
