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 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], ' ')
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():
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('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
class BeanstalkTerminal(TerminalBase):
@classmethod
def ask_application_name(cls, parameter_pool):
if not parameter_pool.has(ParameterName.ApplicationName):
app_name = shell_utils.get_current_dir_name()
cls.ask_parameter(parameter_pool,
ParameterName.ApplicationName,
autogen_value=app_name)
else:
cls.ask_parameter(parameter_pool, ParameterName.ApplicationName)
@classmethod
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))
@classmethod
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)))
# Hardcoded list of supported tiers
ENVIRONMENT_TIERS = [
EnvironmentTier.from_values("WebServer", "Standard", "1.0"),
EnvironmentTier.from_values("Worker", "SQS/HTTP", "1.0"),
]
@classmethod
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)
@classmethod
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, False)))
return
original_value = parameter_pool.get_value(ParameterName.SolutionStack)
append_message = u'' 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)
@classmethod
def ask_branch(cls, parameter_pool):
current_branch = parameter_pool.get_value(ParameterName.CurrentBranch,
False)
prompt.result(TerminalPromptSettingParameterMessage[ParameterName.CurrentBranch]\
.format(current_branch))
previous_env_name = parameter_pool.get_value(
ParameterName.EnvironmentName)
cls.ask_branch_environment_name(parameter_pool)
# Ask whether copy from default
def_env_name = parameter_pool.get_value(
ParameterName.DefaultEnvironmentName, False)
if previous_env_name is None:
if cls.ask_confirmation(
TerminalMessage.CopyDefaultToBranch.format(def_env_name)):
return True #Copy from default
# Ask for branch environment settings
cls.ask_environment_type(parameter_pool)
RdsTerminal.ask_rds_creation(parameter_pool)
IamTerminal.ask_profile_creation(parameter_pool)
return False # Use user input
@classmethod
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 = u'' 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)
#--------------------------------
# Helper methods
@classmethod
def generate_env_name(cls, prefix):
env_name = re.sub(ServiceDefault.Environment.REGEX_NAME_FILTER,
u'',
prefix,
flags=re.UNICODE)
if len(env_name) > 0:
env_name = env_name + ServiceDefault.Environment.NAME_POSTFIX
if len(env_name) > ServiceDefault.Environment.MAX_NAME_LEN:
env_name = env_name[:ServiceDefault.Environment.MAX_NAME_LEN]
else:
env_name = None
return env_name
def deserialize_environment_tier(value):
return EnvironmentTier.from_serialized_string(value)
def deserialize_environment_tier(value):
return EnvironmentTier.from_serialized_string(value)
