Add an 'aws configure list' command

awscli/argparser.py

@@ -94,18 +94,26 @@ class ArgTableArgParser(CLIArgParser):
  """CLI arg parser based on an argument table."""
  Usage = ("aws [options] <command> <subcommand> [parameters]")
 
- def __init__(self, argument_table):
+ def __init__(self, argument_table, command_table=None):
+ # command_table is an optional subcommand_table. If it's passed
+ # in, then we'l update the argparse to parse a 'subcommand' argument
+ # and populate the choices field with the command table keys.
  super(ArgTableArgParser, self).__init__(
  formatter_class=self.Formatter,
  add_help=False,
  usage=self.Usage,
  conflict_handler='resolve')
- self._build(argument_table)
+ if command_table is None:
+ command_table = {}
+ self._build(argument_table, command_table)
 
- def _build(self, argument_table):
+ def _build(self, argument_table, command_table):
  for arg_name in argument_table:
  argument = argument_table[arg_name]
  argument.add_to_parser(self)
+ if command_table:
+ self.add_argument('subcommand', choices=list(command_table.keys()),
+ nargs='?')
 
  def parse_known_args(self, args, namespace=None):
  if len(args) == 1 and args[0] == 'help':

awscli/customizations/commands.py

@@ -1,5 +1,7 @@
 import bcdoc.docevents
 
+from botocore.compat import OrderedDict
+
 from awscli.clidocs import CLIDocumentEventHandler
 from awscli.argparser import ArgTableArgParser
 from awscli.clidriver import CLICommand
@@ -43,6 +45,15 @@ class BasicCommand(CLICommand):
  # 'action': 'store', 'choices': ['a', 'b', 'c']},
  # ]
  ARG_TABLE = []
+ # If you want the command to have subcommands, you can provide a list of
+ # dicts. We use a list here because we want to allow a user to provide
+ # the order they want to use for subcommands.
+ # SUBCOMMANDS = [
+ # {'name': 'subcommand1', 'command_class': SubcommandClass},
+ # {'name': 'subcommand2', 'command_class': SubcommandClass2},
+ # ]
+ # The command_class must subclass from ``BasicCommand``.
+ SUBCOMMANDS = []
 
  # At this point, the only other thing you have to implement is a _run_main
  # method (see the method for more information).
@@ -54,12 +65,17 @@ def __call__(self, args, parsed_globals):
  # args is the remaining unparsed args.
  # We might be able to parse these args so we need to create
  # an arg parser and parse them.
- parser = ArgTableArgParser(self.arg_table)
- parsed_args = parser.parse_args(args)
+ subcommand_table = self._build_subcommand_table()
+ parser = ArgTableArgParser(self.arg_table, subcommand_table)
+ parsed_args, remaining = parser.parse_known_args(args)
  if hasattr(parsed_args, 'help'):
  self._display_help(parsed_args, parsed_globals)
- else:
+ elif getattr(parsed_args, 'subcommand', None) is None:
+ # No subcommand was specified was call the main
+ # function for this top level command.
  self._run_main(parsed_args, parsed_globals)
+ else:
+ subcommand_table[parsed_args.subcommand](remaining, parsed_globals)
 
  def _run_main(self, parsed_args, parsed_globals):
  # Subclasses should implement this method.
@@ -70,7 +86,18 @@ def _run_main(self, parsed_args, parsed_globals):
  # provided as the 'dest' key. Otherwise they default to the
  # 'name' key. For example: ARG_TABLE[0] = {"name": "foo-arg", ...}
  # can be accessed by ``parsed_args.foo_arg``.
- raise NotImlementedError("_run_main")
+ raise NotImplementedError("_run_main")
+
+ def _build_subcommand_table(self):
+ subcommand_table = OrderedDict()
+ for subcommand in self.SUBCOMMANDS:
+ subcommand_name = subcommand['name']
+ subcommand_class = subcommand['command_class']
+ subcommand_table[subcommand_name] = subcommand_class(self._session)
+ self._session.emit('building-command-table.%s' % self.NAME,
+ command_table=subcommand_table,
+ session=self._session)
+ return subcommand_table
 
  def _display_help(self, parsed_args, parsed_globals):
  help_command = self.create_help_command()

awscli/customizations/configure.py

@@ -12,6 +12,7 @@
 # language governing permissions and limitations under the License.
 import os
 import re
+import sys
 import logging
 
 import six
@@ -27,24 +28,41 @@
 
 
 logger = logging.getLogger(__name__)
+NOT_SET = '<not set>'
 
 
 def register_configure_cmd(cli):
  cli.register('building-command-table.main',
  ConfigureCommand.add_command)
 
-def add_configure_cmd(command_table, session, **kwargs):
- command_table['configure'] = ConfigureCommand(session)
+
+class ConfigValue(object):
+ def __init__(self, value, config_type, config_variable):
+ self.value = value
+ self.config_type = config_type
+ self.config_variable = config_variable
+
+ def mask_value(self):
+ if self.value is NOT_SET:
+ return
+ self.value = _mask_value(self.value)
 
 
 class SectionNotFoundError(Exception):
  pass
 
 
+def _mask_value(current_value):
+ if current_value is None:
+ return 'None'
+ else:
+ return ('*' * 16) + current_value[-4:]
+
+
 class InteractivePrompter(object):
  def get_value(self, current_value, config_name, prompt_text=''):
  if config_name in ('aws_access_key_id', 'aws_secret_access_key'):
- current_value = self._mask_value(current_value)
+ current_value = _mask_value(current_value)
  response = raw_input("%s [%s]: " % (prompt_text, current_value))
  if not response:
  # If the user hits enter, we return a value of None
@@ -53,12 +71,6 @@ def get_value(self, current_value, config_name, prompt_text=''):
  response = None
  return response
 
- def _mask_value(self, current_value):
- if current_value is None:
- return 'None'
- else:
- return ('*' * 16) + current_value[-4:]
-
 
 class ConfigFileWriter(object):
  SECTION_REGEX = re.compile(r'\[(?P<header>[^]]+)\]')
@@ -157,6 +169,108 @@ def _matches_section(self, match, section_name):
  return unquoted_match
 
 
+class ConfigureListCommand(BasicCommand):
+ NAME = 'list'
+ DESCRIPTION = (
+ 'List the AWS CLI configuration data. This command will '
+ 'show you the current configuration data. For each configuration '
+ 'item, it will show you the value, where the configuration value '
+ 'was retrieved, and the configuration variable name. For example, '
+ 'if you provide the AWS region in an environment variable, this '
+ 'command will show you the name of the region you\'ve configured, '
+ 'it will tell you that this value came from an environment '
+ 'variable, and it will tell you the name of the environment '
+ 'variable.\n'
+ )
+ SYNOPSIS = ('aws configure list [--profile profile-name]')
+ EXAMPLES = (
+ 'To show your current configuration values::\n'
+ '\n'
+ ' $ aws configure list\n'
+ ' Name Value Type Location\n'
+ ' ---- ----- ---- --------\n'
+ ' profile <not set> None None\n'
+ ' access_key ****************ABCD config_file ~/.aws/config\n'
+ ' secret_key ****************ABCD config_file ~/.aws/config\n'
+ ' region us-west-2 env AWS_DEFAULT_REGION\n'
+ '\n'
+ )
+
+ def __init__(self, session, stream=sys.stdout):
+ super(ConfigureListCommand, self).__init__(session)
+ self._stream = stream
+
+ def _run_main(self, args, parsed_globals):
+ self._display_config_value(ConfigValue('Value', 'Type', 'Location'),
+ 'Name')
+ self._display_config_value(ConfigValue('-----', '----', '--------'),
+ '----')
+
+ if self._session.profile is not None:
+ profile = ConfigValue(self._session.profile, 'manual',
+ '--profile')
+ else:
+ profile = self._lookup_config('profile')
+ self._display_config_value(profile, 'profile')
+
+ access_key, secret_key = self._lookup_credentials()
+ self._display_config_value(access_key, 'access_key')
+ self._display_config_value(secret_key, 'secret_key')
+
+ region = self._lookup_config('region')
+ self._display_config_value(region, 'region')
+
+ def _display_config_value(self, config_value, config_name):
+ self._stream.write('%10s %24s %16s %s\n' % (
+ config_name, config_value.value, config_value.config_type,
+ config_value.config_variable))
+
+ def _lookup_credentials(self):
+ # First try it with _lookup_config. It's possible
+ # that we don't find credentials this way (for example,
+ # if we're using an IAM role).
+ access_key = self._lookup_config('access_key')
+ if access_key.value is not NOT_SET:
+ secret_key = self._lookup_config('secret_key')
+ access_key.mask_value()
+ secret_key.mask_value()
+ return access_key, secret_key
+ else:
+ # Otherwise we can try to use get_credentials().
+ # This includes a few more lookup locations
+ # (IAM roles, some of the legacy configs, etc.)
+ credentials = self._session.get_credentials()
+ if credentials is None:
+ no_config = ConfigValue(NOT_SET, None, None)
+ return no_config, no_config
+ else:
+ # For the ConfigValue, we don't track down the
+ # config_variable because that info is not
+ # visible from botocore.credentials. I think
+ # the credentials.method is sufficient to show
+ # where the credentials are coming from.
+ access_key = ConfigValue(credentials.access_key,
+ credentials.method, '')
+ secret_key = ConfigValue(credentials.secret_key,
+ credentials.method, '')
+ access_key.mask_value()
+ secret_key.mask_value()
+ return access_key, secret_key
+
+ def _lookup_config(self, name):
+ # First try to look up the variable in the env.
+ value = self._session.get_variable(name, methods=('env',))
+ if value is not None:
+ return ConfigValue(value, 'env', self._session.env_vars[name][1])
+ # Then try to look up the variable in the config file.
+ value = self._session.get_variable(name, methods=('config',))
+ if value is not None:
+ return ConfigValue(value, 'config_file',
+ self._session.get_variable('config_file'))
+ else:
+ return ConfigValue(NOT_SET, None, None)
+
+
 class ConfigureCommand(BasicCommand):
  NAME = 'configure'
  DESCRIPTION = (
@@ -192,6 +306,9 @@ class ConfigureCommand(BasicCommand):
  ' Default region name [us-west-1]: us-west-2\n'
  ' Default output format [None]:\n'
  )
+ SUBCOMMANDS = [
+ {'name': 'list', 'command_class': ConfigureListCommand}
+ ]
 
  # If you want to add new values to prompt, update this list here.
  VALUES_TO_PROMPT = [