def set_options(self, options_to_describe):
index = 1
for namespace, options in options_to_describe.items():
for option_name in options:
self._request["Options.member." + misc.to_unicode(index) + ".Namespace"] = misc.to_unicode(namespace)
self._request["Options.member." + misc.to_unicode(index) + ".OptionName"] = misc.to_unicode(option_name)
index = index + 1
def load_env_option_setting_file(location, option_settings = None, quiet = False):
log.info('Reading environment option settings from file at "{0}".'.format(location))
if option_settings is None:
option_settings = dict()
try:
parser = SectionedConfigParser()
parser.read(location)
for section in parser.sections():
for option, value in parser.items(section):
section = misc.to_unicode(section)
option = misc.to_unicode(option)
value = misc.to_unicode(value)
if section not in option_settings:
option_settings[section] = dict()
option_settings[section][option] = value
log.debug('Option settings read from file include: "{0}".'.\
format(misc.collection_to_string(option_settings)))
check_access_permission(location, True)
return option_settings
except BaseException as ex:
log.error('Failed to load environment option setting file, because: "{0}"'.format(ex))
if quiet:
return option_settings
else:
prompt.error(OptionSettingFileErrorMessage.ReadError.format(location))
raise
def load_env_option_setting_file(location, option_settings = None, quiet = False):
log.info(u'Reading environment option settings from file at "{0}".'.format(location))
if option_settings is None:
option_settings = []
try:
parser = SectionedConfigParser()
parser.read(location)
for section in parser.sections():
for option, value in parser.items(section):
cos = ConfigurationOptionSetting()
cos._namespace = misc.to_unicode(section)
cos._option_name = misc.to_unicode(option)
cos._value = misc.to_unicode(value)
option_settings.append(cos)
log.debug(u'Option settings read from file include: "{0}".'.\
format(misc.collection_to_string(option_settings)))
check_access_permission(location, True)
return option_settings
except BaseException as ex:
log.error(u'Failed to load environment option setting file, because: "{0}"'.format(ex))
if quiet:
return []
else:
prompt.error(OptionSettingFileErrorMessage.ReadError.format(location))
raise
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], 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():
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(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 set_options(self, options):
index = 1
for namespace, options in options.items():
for option_name in options:
self._request['Options.member.' + misc.to_unicode(index) + '.Namespace'] \
= misc.to_unicode(namespace)
self._request['Options.member.' + misc.to_unicode(index) + '.OptionName'] \
= misc.to_unicode(option_name)
index = index + 1
def set_options_to_remove(self, options_to_remove):
index = 1
for namespace, options in options_to_remove.iteritems():
for option_name in options:
self._request[u'OptionsToRemove.member.' + misc.to_unicode(index) + u'.Namespace'] \
= misc.to_unicode(namespace)
self._request[u'OptionsToRemove.member.' + misc.to_unicode(index) + u'.OptionName'] \
= misc.to_unicode(option_name)
index = index + 1
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
def set_option_settings(self, option_settings):
index = 1
for namespace, options in option_settings.items():
for option_name, value in options.items():
self._request["OptionSettings.member." + misc.to_unicode(index) + ".Namespace"] = misc.to_unicode(
namespace
)
self._request["OptionSettings.member." + misc.to_unicode(index) + ".OptionName"] = misc.to_unicode(
option_name
)
self._request["OptionSettings.member." + misc.to_unicode(index) + ".Value"] = misc.to_unicode(value)
index = index + 1
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)
def set_auto_create_app(self, switch):
if isinstance(switch, bool):
if switch:
switch = u'true'
else:
switch = u'false'
self._request[u'AutoCreateApplication'] = misc.to_unicode(switch)
def call(self, request):
"""Make API call and translate AWSServiceException to more specific exception"""
try:
log.debug(request)
return_msg = self._client.call(request, self._format)
log.debug(u"Request ID: {0}".format(return_msg.json().values()[0][u"ResponseMetadata"][u"RequestId"]))
# TODO: set more specific charset code
return return_msg.json()
except AwsServiceException as ex:
log.debug(misc.to_unicode(ex))
# Translate general Elastic Beanstalk exception
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.OptInRequired):
raise OptInRequiredException(ex)
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.InsufficientPrivileges):
raise InsufficientPrivilegesException(ex)
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.InvalidParameterValue):
raise InvalidParameterValueException(ex)
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.MissingParameter):
raise MissingParameterException(ex)
raise
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('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 git_aws_push(push_only=False, quiet=False):
output = prompt.info if quiet else prompt.result
cmd = DevToolsDefault.AwsCreateAppVersion if push_only else DevToolsDefault.AwsPush
try:
output(
misc.to_unicode(call(cmd, quiet=quiet),
locale.getpreferredencoding()))
return True
except subprocess.CalledProcessError as ex:
# Git returned with an error code
log.error(u'Failed to push local HEAD to EB: "{0}".'.format(ex))
if quiet:
return False
else:
raise EBSCliException(DevToolsMessage.PushFail.format(ex.message))
except (OSError, IOError) as ex:
log.error(u'Failed to call git, because "{0}".'.format(ex))
if quiet:
return False
else:
# Cannot find or run script
if ex.errno == FileErrorConstant.FileNotFoundErrorCode:
log.error(u'Cannot find Git executable "git".')
raise EBSCliException(
DevToolsMessage.GitCommandError.format(ex.message))
def call(command, quiet = True):
'''
Call external process. command is a list of command line arguments including name
of external process and arguments.
'''
if isinstance(command, str):
command_line = shlex.split(command)
elif isinstance(command, list):
command_line = command
else:
raise EBSCliException('Parameter must be instance of list or string.')
log.debug('Running external commands "{0}".'.\
format(misc.collection_to_string(command_line)))
# Using OS native code page
command_line = [x.encode(locale.getpreferredencoding()) for x in command_line]
args = {'args':command_line}
if misc.is_os_windows():
# TODO: set shell to True will allow Windows translate "git" to "git.cmd",
# but might introduce other issues.
args['shell'] = True
if quiet:
args['stderr'] = subprocess.STDOUT
return misc.to_unicode(subprocess.check_output(**args), False, locale.getpreferredencoding())
def _create_default_profile(cls, iam_client, parameter_pool):
try:
region = parameter_pool.get_value(PName.Region, False)
log.info(u'Creating IAM role {0}'.format(EbDefault.DefaultRoleName))
assume_policy_url = EbDefault.RoleAssumePolicyUrlMask.format(PolicyBucket[region])
assume_policy = misc.to_unicode(requests.get(assume_policy_url).content)
iam_client.create_role(EbDefault.DefaultRoleName, assume_policy)
except IamEntityAlreadyExistsException:
log.info(u'Role {0} already exists.'.format(EbDefault.DefaultRoleName))
pass
try:
log.info(u'Creating IAM instance profile {0}'.format(EbDefault.DefaultInstanceProfileName))
iam_client.create_instance_profile(EbDefault.DefaultInstanceProfileName)
except IamEntityAlreadyExistsException:
log.info(u'Profile {0} already exists.'.format(EbDefault.DefaultInstanceProfileName))
pass
try:
log.info(u'Adding IAM role {0} to instance profile {1}'.format
(EbDefault.DefaultRoleName, EbDefault.DefaultInstanceProfileName))
iam_client.add_role_to_instance_profile(EbDefault.DefaultRoleName,
EbDefault.DefaultInstanceProfileName)
except IamLimitExceededException:
log.info(u'Profile {0} already has one role.'.format(EbDefault.DefaultInstanceProfileName))
pass
return EbDefault.DefaultInstanceProfileName
def get_working_branch(quiet = False):
try:
result = misc.to_unicode(call(GitDefault.GetBranch), locale.getpreferredencoding())
branches = result.splitlines()
if len(branches) == 0:
return None, 0
else:
head_re = re.compile(GitDefault.HeadRe, re.UNICODE)
for branch in branches:
if head_re.match(branch):
return branch.split(' ')[1], len(branches)
except subprocess.CalledProcessError as ex:
# Git returned with an error code
log.error('Git local repository is not set up: "{0}".'.format(ex))
if quiet:
return None, 0
else:
raise EBSCliException(DevToolsMessage.GitRepoNotExist.format(ex.message))
except (OSError, IOError) as ex:
log.error('Failed to call git, because "{0}".'.format(ex))
if quiet:
return None, 0
else:
# Cannot find or run script
if ex.errno == FileErrorConstant.FileNotFoundErrorCode:
log.error('Cannot find Git executable "git".')
raise EBSCliException(DevToolsMessage.GitCommandError.format(ex.message))
def call(self, request):
'''Make API call and translate AWSServiceException to more specific exception'''
try:
log.debug(request)
return_msg = self._client.call(request, self._format)
log.debug(u'Request ID: {0}'.format(return_msg.json().values()[0]\
[u'ResponseMetadata'][u'RequestId']))
return return_msg.json()
except AwsServiceException as ex:
log.debug(misc.to_unicode(ex))
# Translate general RDS exception
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.OptInRequired):
raise OptInRequiredException(ex)
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.InsufficientPrivileges):
raise InsufficientPrivilegesException(ex)
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.InvalidParameterValue):
raise InvalidParameterValueException(ex)
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.MissingParameter):
raise MissingParameterException(ex)
raise
def get_repo_head_hash(quiet=False):
try:
headhash = misc.to_unicode(call(GitDefault.GetHeadHash),
locale.getpreferredencoding())
return headhash.replace(os.linesep, u'')
except subprocess.CalledProcessError as ex:
# Git returned with an error code
log.error(
u'Git local repository does not have HEAD info: "{0}".'.format(
ex))
if quiet:
return None
else:
raise EBSCliException(
DevToolsMessage.GitHeadNotExist.format(ex.message))
except (OSError, IOError) as ex:
log.error(u'Failed to call git, because "{0}".'.format(ex))
if quiet:
return None
else:
# Cannot find or run script
if ex.errno == FileErrorConstant.FileNotFoundErrorCode:
log.error(u'Cannot find Git executable "git".')
raise EBSCliException(
DevToolsMessage.GitCommandError.format(ex.message))
def main(cmdline=None):
# Initialization
configureLogging(quiet=False)
log.info("EB CLI start")
parameter_pool = ParameterPool() # pool of all parameters
validator = ParameterValidator()
DefaultParameterValue.fill_default(parameter_pool)
log.debug("Finished initialization")
try:
# Parse command line arguments
cli_parse.parse(parameter_pool, cmdline)
log.debug("Finished parsing command line arguments.")
# TODO: set quiet level here.
if (
parameter_pool.has(ParameterName.Verbose)
and parameter_pool.get_value(ParameterName.Verbose) == ServiceDefault.ENABLED
):
prompt.set_level(OutputLevel.Info)
else:
prompt.set_level(OutputLevel.ResultOnly)
validator.validate(parameter_pool, ParameterSource.CliArgument)
# Compile operation queue
queue = command.compile_operation_queue(parameter_pool.command)
except SystemExit as ex:
_exit(0)
except BaseException as ex:
print((misc.to_unicode(ex)))
log.error(ex)
_exit(1)
# Execute queue
results = []
try:
queue.run(parameter_pool, results)
log.debug("Finished executing operation queue")
except BaseException as ex:
print((misc.to_unicode(ex)))
log.error(ex)
_exit(1)
_exit(0)
def line_input(cls, message, can_return_none = False, no_echo = False):
value = ''
codec = _locale.getpreferredencoding()
if no_echo:
input_method = _getpass
elif _sys.version_info > (3, 0):
input_method = input
else:
input_method = raw_input
while len(value) < 1:
if _sys.version_info > (3, 0):
value = misc.to_unicode(input_method(message), codec)
else:
value = misc.to_unicode(input_method(message.encode(codec)), codec)
if len(value) < 1:
if can_return_none:
return None
return value
def line_input(cls, message, can_return_none=False, no_echo=False):
value = ''
codec = _locale.getpreferredencoding()
if no_echo:
input_method = _getpass
elif _sys.version_info > (3, 0):
input_method = input
else:
input_method = raw_input
while len(value) < 1:
if _sys.version_info > (3, 0):
value = misc.to_unicode(input_method(message), codec)
else:
value = misc.to_unicode(input_method(message.encode(codec)),
codec)
if len(value) < 1:
if can_return_none:
return None
return value
def call(self, request):
'''Make API call and translate AWSServiceException to more specific exception'''
try:
log.debug(request)
return_msg = self._client.call(request, self._format)
log.debug(u'Request ID: {0}'.format(return_msg.json().values()[0]\
[u'ResponseMetadata'][u'RequestId']))
return return_msg.json()
except AwsServiceException as ex:
log.debug(misc.to_unicode(ex))
# Translate general IAM exception
if misc.string_equal_ignore_case(ex.code,
AwsErrorCode.AccessDenied):
raise AccessDeniedException(ex)
elif misc.string_equal_ignore_case(ex.code,
AwsErrorCode.OptInRequired):
raise OptInRequiredException(ex)
elif misc.string_equal_ignore_case(
ex.code, AwsErrorCode.InsufficientPrivileges):
raise InsufficientPrivilegesException(ex)
elif misc.string_equal_ignore_case(
ex.code, AwsErrorCode.InvalidParameterValue):
raise InvalidParameterValueException(ex)
elif misc.string_equal_ignore_case(ex.code,
AwsErrorCode.MissingParameter):
raise MissingParameterException(ex)
elif misc.string_equal_ignore_case(
ex.code, IamErrorCode.EntityAlreadyExists):
raise IamEntityAlreadyExistsException(ex)
elif misc.string_equal_ignore_case(ex.code,
IamErrorCode.NoSuchEntity):
raise IamNoSuchEntityException(ex)
elif misc.string_equal_ignore_case(
ex.code, IamErrorCode.MalformedPolicyDocument):
raise IamMalformedPolicyDocumentException(ex)
elif misc.string_equal_ignore_case(ex.code,
IamErrorCode.LimitExceeded):
raise IamLimitExceededException(ex)
raise
def set_option_settings(self, settings):
for i, setting in enumerate(settings):
self._request[u'OptionSettings.member.' + misc.to_unicode(i + 1) + u'.Namespace'] \
= misc.to_unicode(setting.namespace)
self._request[u'OptionSettings.member.' + misc.to_unicode(i + 1) + u'.OptionName'] \
= misc.to_unicode(setting.option_name)
self._request[u'OptionSettings.member.' + misc.to_unicode(i + 1) + u'.Value'] \
= misc.to_unicode(setting.value)
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 = '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 instance_id not in instance_timestamps\
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 set_option_settings(self, option_settings):
index = 1
for namespace, options in option_settings.iteritems():
for option_name, value in options.iteritems():
self._request[u'OptionSettings.member.' + misc.to_unicode(index) + u'.Namespace'] \
= misc.to_unicode(namespace)
self._request[u'OptionSettings.member.' + misc.to_unicode(index) + u'.OptionName'] \
= misc.to_unicode(option_name)
self._request[u'OptionSettings.member.' + misc.to_unicode(index) + u'.Value'] \
= misc.to_unicode(value)
index = index + 1
def call(self, request):
'''Make API call and translate AWSServiceException to more specific exception'''
try:
log.debug(request)
return_msg = self._client.call(request, self._format)
log.debug(u'Request ID: {0}'.format(return_msg.json().values()[0]\
[u'ResponseMetadata'][u'RequestId']))
return return_msg.json()
except AwsServiceException as ex:
log.debug(misc.to_unicode(ex))
# Translate general IAM exception
if misc.string_equal_ignore_case(ex.code, AwsErrorCode.AccessDenied):
raise AccessDeniedException(ex)
elif misc.string_equal_ignore_case(ex.code, AwsErrorCode.OptInRequired):
raise OptInRequiredException(ex)
elif misc.string_equal_ignore_case(ex.code, AwsErrorCode.InsufficientPrivileges):
raise InsufficientPrivilegesException(ex)
elif misc.string_equal_ignore_case(ex.code, AwsErrorCode.InvalidParameterValue):
raise InvalidParameterValueException(ex)
elif misc.string_equal_ignore_case(ex.code, AwsErrorCode.MissingParameter):
raise MissingParameterException(ex)
elif misc.string_equal_ignore_case(ex.code, IamErrorCode.EntityAlreadyExists):
raise IamEntityAlreadyExistsException(ex)
elif misc.string_equal_ignore_case(ex.code, IamErrorCode.NoSuchEntity):
raise IamNoSuchEntityException(ex)
elif misc.string_equal_ignore_case(ex.code, IamErrorCode.MalformedPolicyDocument):
raise IamMalformedPolicyDocumentException(ex)
elif misc.string_equal_ignore_case(ex.code, IamErrorCode.LimitExceeded):
raise IamLimitExceededException(ex)
raise
def get_repo_head_hash(quiet = False):
try:
headhash = misc.to_unicode(call(GitDefault.GetHeadHash), locale.getpreferredencoding())
return headhash.replace(os.linesep, '')
except subprocess.CalledProcessError as ex:
# Git returned with an error code
log.error('Git local repository does not have HEAD info: "{0}".'.format(ex))
if quiet:
return None
else:
raise EBSCliException(DevToolsMessage.GitHeadNotExist.format(ex.message))
except (OSError, IOError) as ex:
log.error('Failed to call git, because "{0}".'.format(ex))
if quiet:
return None
else:
# Cannot find or run script
if ex.errno == FileErrorConstant.FileNotFoundErrorCode:
log.error('Cannot find Git executable "git".')
raise EBSCliException(DevToolsMessage.GitCommandError.format(ex.message))
def git_aws_push(quiet = False):
output = prompt.info if quiet else prompt.result
try:
output(misc.to_unicode(call(DevToolsDefault.AwsPush), locale.getpreferredencoding()))
return True
except subprocess.CalledProcessError as ex:
# Git returned with an error code
log.error('Failed to push local HEAD to EB: "{0}".'.format(ex))
if quiet:
return False
else:
raise EBSCliException(DevToolsMessage.PushFail.format(ex.message))
except (OSError, IOError) as ex:
log.error('Failed to call git, because "{0}".'.format(ex))
if quiet:
return False
else:
# Cannot find or run script
if ex.errno == FileErrorConstant.FileNotFoundErrorCode:
log.error('Cannot find Git executable "git".')
raise EBSCliException(DevToolsMessage.GitCommandError.format(ex.message))
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 RDS service endpoints if not specified as CLI arguments
log.info(u'Generate RDS endpoint from region "{0}".'.format(region_value))
eb_utils.generate_endpoint(parameter_pool, region_value, ParameterSource.Terminal)
# Set RDS endpont and snippet if not specified as CLI arguments
log.info(u'Generate RDS snippet URL from region "{0}".'.format(region_value))
rds_utils.generate_endpoint(parameter_pool, region_value, ParameterSource.Terminal)
def set_template_specification(self, template_spec):
#TemplateSource
if template_spec.template_source is not None:
ts = template_spec.template_source
if ts.solution_stack_name is not None:
self._request[u'TemplateSpecification.TemplateSource.SolutionStackName'] \
= misc.to_unicode(ts.solution_stack_name)
#Snippets
if template_spec.template_snippets is not None:
for i, snippet in enumerate(template_spec.template_snippets):
if snippet.snippet_name is not None:
self._request[u'TemplateSpecification.TemplateSnippets.member.' \
+ misc.to_unicode(i + 1)+u'.SnippetName'] \
= misc.to_unicode(snippet.snippet_name)
if snippet.source_url is not None:
self._request[u'TemplateSpecification.TemplateSnippets.member.' \
+ misc.to_unicode(i + 1)+u'.SourceUrl'] \
= misc.to_unicode(snippet.source_url)
if snippet.order is not None:
self._request[u'TemplateSpecification.TemplateSnippets.member.' \
+ misc.to_unicode(i + 1)+u'.Order'] \
= misc.to_unicode(snippet.order)
def subcommand(string):
subcommand = misc.to_unicode(string)
return subcommand
def command(string):
command = misc.to_unicode(string)
for item in CommandType:
if item.lower() == command.lower().strip():
return item
raise AttributeError(EBSCliAttr.InvalidCommand.format(command))
def set_info_type(self, info_type):
self._request["InfoType"] = misc.to_unicode(info_type)
def _extractAwsErrorMessage(e):
try :
eDoc = json.loads(e.read().decode('utf-8'))[u'Error']
return (misc.to_unicode(eDoc[u'Code']), misc.to_unicode(eDoc[u'Message']))
except :
return (u'Error', u'{0}:{1}'.format(e.code, e.msg))
