Openstack server list가 출력되는 과정 Tracing 하기¶

#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
import re
import sys
from openstackclient.shell import main
if __name__ == '__main__':
   sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
   sys.exit(main())

def main(argv=None):
   if argv is None:
      argv = sys.argv[1:]
      if six.PY2:
         # Emulate Py3, decode argv into Unicode based on locale so that
         # commands always see arguments as text instead of binary data
         encoding = locale.getpreferredencoding()
         if encoding:
            argv = map(lambda arg: arg.decode(encoding), argv)
   return OpenStackShell().run(argv)

class OpenStackShell(app.App):
   def run(self, argv):
      ret_val = 1
      self.command_options = argv
      try:
         ret_val = super(OpenStackShell, self).run(argv)
            return ret_val
      except Exception as e:
         if not logging.getLogger('').handlers:
            logging.basicConfig()
         if self.dump_stack_trace:
            self.log.error(traceback.format_exc())
         else:
            self.log.error('Exception raised: ' + str(e))
         return ret_val
      finally:
         self.log.info("END return value: %s", ret_val)

class App(object):
   def run(self, argv):
   """
   Equivalent to the main program for the application.
   :param argv: input arguments and options
   :paramtype argv: list of str
   """
      try:
         self.options, remainder = self.parser.parse_known_args(argv)
         self.configure_logging()
         self.interactive_mode = not remainder
         if self.deferred_help and self.options.deferred_help and remainder:
            # When help is requested and `remainder` has any values disable
            # `deferred_help` and instead allow the help subcommand to
            # handle the request during run_subcommand(). This turns
            # "app foo bar --help" into "app help foo bar". However, when
            # `remainder` is empty use print_help_if_requested() to allow
            # for an early exit.
            # Disabling `deferred_help` here also ensures that
            # print_help_if_requested will not fire if called by a subclass
            # during its initialize_app().
            self.options.deferred_help = False
            remainder.insert(0, "help")
         self.initialize_app(remainder)
         self.print_help_if_requested()
      except Exception as err:
         if hasattr(self, 'options'):
            debug = self.options.debug
         else:
            debug = True
         if debug:
            self.LOG.exception(err)
            raise
         else:
            self.LOG.error(err)
         return 1
      result = 1
      if self.interactive_mode:
         result = self.interact()
      else:
         result = self.run_subcommand(remainder)
      return result

class App(object):
   def run_subcommand(self, argv):
      try:
         subcommand = self.command_manager.find_command(argv)
      except ValueError as err:
         # If there was no exact match, try to find a fuzzy match
         the_cmd = argv[0]
         fuzzy_matches = self.get_fuzzy_matches(the_cmd)
         if fuzzy_matches:
            article = 'a'
            if self.NAME[0] in 'aeiou':
               article = 'an'
            self.stdout.write('%s: \'%s\' is not %s %s command. ''See \'%s --help\'.\n'% (self.NAME, ' '.join(argv), article,self.NAME, self.NAME))
            self.stdout.write('Did you mean one of these?\n')
            for match in fuzzy_matches:
               self.stdout.write('  %s\n' % match)
         else:
               if self.options.debug:
               raise
               else:
                  self.LOG.error(err)
            return 2
      cmd_factory, cmd_name, sub_argv = subcommand
      kwargs = {}
      if 'cmd_name' in utils.getargspec(cmd_factory.__init__).args:
         kwargs['cmd_name'] = cmd_name
      cmd = cmd_factory(self, self.options, **kwargs)
      result = 1
      try:
         self.prepare_to_run_command(cmd)
         full_name = (cmd_name if self.interactive_mode else ' '.join([self.NAME, cmd_name]))
         cmd_parser = cmd.get_parser(full_name)
         parsed_args = cmd_parser.parse_args(sub_argv)
         result = cmd.run(parsed_args)
      except Exception as err:
         if self.options.debug:
            self.LOG.exception(err)
         else:
            self.LOG.error(err)
         try:
            self.clean_up(cmd, result, err)
         except Exception as err2:
            if self.options.debug:
               self.LOG.exception(err2)
            else:
               self.LOG.error('Could not clean up: %s', err2)
         if self.options.debug:
            # 'raise' here gets caught and does not exit like we want
            return result
      else:
         try:
            self.clean_up(cmd, result, None)
         except Exception as err3:
            if self.options.debug:
               self.LOG.exception(err3)
            else:
               self.LOG.error('Could not clean up: %s', err3)
      return result

class Command(command.Command, metaclass=CommandMeta):
   def run(self, parsed_args):
      self.log.debug('run(%s)', parsed_args)
      return super(Command, self).run(parsed_args)

class Command(command.Command, metaclass=CommandMeta):
   def run(self, parsed_args):
      """Invoked by the application when the command is run.
      Developers implementing commands should override
      :meth:`take_action`.
      Developers creating new command base classes (such as
      :class:`Lister` and :class:`ShowOne`) should override this
      method to wrap :meth:`take_action`.
      Return the value returned by :meth:`take_action` or 0.
      """
      parsed_args = self._run_before_hooks(parsed_args)
      return_code = self.take_action(parsed_args) or 0
      return_code = self._run_after_hooks(parsed_args, return_code)
      return return_code

@six.add_metaclass(abc.ABCMeta)
class DisplayCommandBase(command.Command):
def run(self, parsed_args):
   parsed_args = self._run_before_hooks(parsed_args)
   self.formatter = self._formatter_plugins[parsed_args.formatter].obj
   column_names, data = self.take_action(parsed_args)
   column_names, data = self._run_after_hooks(parsed_args,(column_names, data))
   self.produce_output(parsed_args, column_names, data)
   return 0

@six.add_metaclass(abc.ABCMeta)
class DisplayCommandBase(command.Command):
   def run(self, parsed_args):
   parsed_args = self._run_before_hooks(parsed_args)
   self.formatter = self._formatter_plugins[parsed_args.formatter].obj
   column_names, data = self.take_action(parsed_args)
   column_names, data = self._run_after_hooks(parsed_args,(column_names, data))
   self.produce_output(parsed_args, column_names, data)
   return 0

+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+
| ID                                   | Name    | Status | Networks                                                             | Image | Flavor  |
+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+
| 6f91eb30-8687-49d7-859f-7284887d57f8 | 1st_Ins | ACTIVE | private=10.0.0.53, fd30:b09a:8b83:0:f816:3eff:fe79:1bec, 172.24.4.59 |       | m1.nano |
+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+

@six.add_metaclass(abc.ABCMeta)
class DisplayCommandBase(command.Command):
   def run(self, parsed_args):
      self.produce_output(parsed_args, column_names, data)
      return 0
@abc.abstractmethod
   def produce_output(self, parsed_args, column_names, data):
      """Use the formatter to generate the output.
      :param parsed_args: argparse.Namespace instance with argument values
      :param column_names: sequence of strings containing names of output columns
      :param data: iterable with values matching the column names
      """

@six.add_metaclass(abc.ABCMeta)
class Lister(display.DisplayCommandBase):
   def produce_output(self, parsed_args, column_names, data):
      if parsed_args.sort_columns and self.need_sort_by_cliff:
         indexes = [column_names.index(c) for c in parsed_args.sort_columns if c in column_names]
         if indexes:
            data = sorted(data, key=operator.itemgetter(*indexes))
      (columns_to_include, selector) = self._generate_columns_and_selector(
         parsed_args, column_names)
      if selector:
         # Generator expression to only return the parts of a row
         # of data that the user has expressed interest in
         # seeing. We have to convert the compress() output to a
         # list so the table formatter can ask for its length.
         data = (list(self._compress_iterable(row, selector)) for row in data)
         self.formatter.emit_list(columns_to_include,data,self.app.stdout,parsed_args,)
      return 0

+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+
| ID                                   | Name    | Status | Networks                                                             | Image | Flavor  |
+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+
| 6f91eb30-8687-49d7-859f-7284887d57f8 | 1st_Ins | ACTIVE | private=10.0.0.53, fd30:b09a:8b83:0:f816:3eff:fe79:1bec, 172.24.4.59 |       | m1.nano |
+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+

class TableFormatter(base.ListFormatter, base.SingleFormatter):
   def emit_list(self, column_names, data, stdout, parsed_args):
      x = prettytable.PrettyTable(column_names,print_empty=parsed_args.print_empty,)
      x.padding_width = 1
      # Add rows if data is provided
      if data:
         self.add_rows(x, column_names, data)
      # Choose a reasonable min_width to better handle many columns on a
      # narrow console. The table will overflow the console width in
      # preference to wrapping columns smaller than 8 characters.
      min_width = 8
      self._assign_max_widths(stdout, x, int(parsed_args.max_width), min_width,parsed_args.fit_width)
      formatted = x.get_string()
      stdout.write(formatted)
      stdout.write('\n')
      return

+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+
| ID                                   | Name    | Status | Networks                                                             | Image | Flavor  |
+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+
| 6f91eb30-8687-49d7-859f-7284887d57f8 | 1st_Ins | ACTIVE | private=10.0.0.53, fd30:b09a:8b83:0:f816:3eff:fe79:1bec, 172.24.4.59 |       | m1.nano |
+--------------------------------------+---------+--------+----------------------------------------------------------------------+-------+---------+

class TableFormatter(base.ListFormatter, base.SingleFormatter):
   def emit_list(self, column_names, data, stdout, parsed_args):
      x = prettytable.PrettyTable( column_names, print_empty=parsed_args.print_empty, )
      x.padding_width = 1
      # Add rows if data is provided if data: self.add_rows(x, column_names, data)
      # Choose a reasonable min_width to better handle many columns on a
      # narrow console. The table will overflow the console width in
      # preference to wrapping columns smaller than 8 characters.
      min_width = 8
      self._assign_max_widths( stdout, x, int(parsed_args.max_width), min_width, parsed_args.fit_width)
      formatted = x.get_string()
      stdout.write(formatted)
      stdout.write('\n')
      return

class TableFormatter(base.ListFormatter, base.SingleFormatter):
   def add_rows(self, table, column_names, data):
      # Figure out the types of the columns in the
      # first row and set the alignment of the
      # output accordingly.
      data_iter = iter(data)
      try:
         first_row = next(data_iter)
      except StopIteration:
         pass
      else:
         for value, name in zip(first_row, column_names):
            alignment = self.ALIGNMENTS.get(type(value), 'l')
            table.align[name] = alignment
         # Now iterate over the data and add the rows.
         table.add_row(_format_row(first_row))
         for row in data_iter:
            table.add_row(_format_row(row))

first_row
('6f91eb30-8687-49d7-8...84887d57f8', '1st_Ins', 'ACTIVE', 'private=10.0.0.53, f...72.24.4.59', '', 'm1.nano')
special variables
function variables
0:'6f91eb30-8687-49d7-859f-7284887d57f8'
1:'1st_Ins'
2:'ACTIVE'
3:'private=10.0.0.53, fd30:b09a:8b83:0:f816:3eff:fe79:1bec, 172.24.4.59'
4:''
5:'m1.nano'
len():6

first_row += ('Test:)',)
first_row
('6f91eb30-8687-49d7-8...84887d57f8', '1st_Ins', 'ACTIVE', 'private=10.0.0.53, f...72.24.4.59', '', 'm1.nano', 'Test:)')

column_names += ("TestL:)",)
column_names
('ID', 'Name', 'Status', 'Networks', 'Image', 'Flavor', 'TestL:)')

@six.add_metaclass(abc.ABCMeta)
class DisplayCommandBase(command.Command):
   def run(self, parsed_args):
      parsed_args = self._run_before_hooks(parsed_args)
      self.formatter = self._formatter_plugins[parsed_args.formatter].obj
=>    column_names, data = self.take_action(parsed_args)
      column_names, data = self._run_after_hooks(parsed_args, (column_names, data))
      self.produce_output(parsed_args, column_names, data)
      return 0

class ListServer(command.Lister):
   def take_action(self, parsed_args):
      compute_client = self.app.client_manager.compute
      identity_client = self.app.client_manager.identity
      image_client = self.app.client_manager.image

      project_id = None
      # None 이어서 실행되지 않는 문장 제거

      ## 명령어 입력시 --long을 해야함. 아래 참고한 페이지 서술
      if parsed_args.long:
      else:
         if: parsed_args.no_name_lookup:
         else:
            columns = (
               'ID',
               'Name',
               'Status',
               'Networks',
               'Image Name',
               'Flavor Name',
            )
         column_headers = (
            'ID',
            'Name',
            'Status',
            'Networks',
            'Image',
            'Flavor',
         )
         mixed_case_fields = []
      marker_id = None
=>    data = compute_client.servers.list(search_opts=search_opts,marker=marker_id,limit=parsed_args.limit)

parsed_args
all_projects:False
changes_before:None
changes_since:None
columns:[]
deleted:False
fit_width:False
flavor:None
formatter:'table'
no_name_lookup:False
noindent:False
print_empty:False
project:None
project_domain:None
quote_mode:'nonnumeric'
reservation_id:None
sort_columns:[]
status:None
unlocked:False
user:None
user_domain:None

class ServerManager(base.BootingManagerWithFind):
def list(self, detailed=True, search_opts=None, marker=None, limit=None,sort_keys=None, sort_dirs=None):
   """
   Get a list of servers.
   :param detailed: Whether to return detailed server info (optional).
   :param search_opts: Search options to filter out servers which don't
      match the search_opts (optional). The search opts format is a
      dictionary of key / value pairs that will be appended to the query
      string.  For a complete list of keys see:
      https://docs.openstack.org/api-ref/compute/#list-servers
   :param marker: Begin returning servers that appear later in the server list than that represented by this server id (optional).
   :param limit: Maximum number of servers to return (optional).
      Note the API server has a configurable default limit.
      If no limit is specified here or limit is larger than
      default, the default limit will be used.
      If limit == -1, all servers will be returned.
   :param sort_keys: List of sort keys
   :param sort_dirs: List of sort directions
   :rtype: list of :class:`Server`

   Examples:

   client.servers.list() - returns detailed list of servers

   client.servers.list(search_opts={'status': 'ERROR'}) -
   returns list of servers in error state.

   client.servers.list(limit=10) - returns only 10 servers

   """
   if search_opts is None:
      search_opts = {}
      ....
=>    servers = self._list("/servers%s%s" % (detail, query_string),"servers")
      result.extend(servers)
      result.append_request_ids(servers.request_ids)
   return result

'hostId':'f0b0f1375254bb6ee4a83c7f4e2ad6331d94f497bb3a9b1848af817a'
'image':''
'flavor':{'id': '42', 'links': [{...}]}
'created':'2020-08-06T13:21:28Z'
'updated':'2020-08-06T13:21:46Z'
'addresses':{'private': [{...}, {...}, {...}]}
'accessIPv4':''
'accessIPv6':''
'links':[{'href': 'http://192.168.1.10/...84887d57f8', 'rel': 'self'}, {'href': 'http://192.168.1.10/...84887d57f8', 'rel': 'bookmark'}]
'OS-DCF:diskConfig':'AUTO'
'progress':0
'OS-EXT-AZ:availability_zone':'nova'
'config_drive':''

class ListServer(command.Lister):
   def take_action(self, parsed_args):
      data = compute_client.servers.list(search_opts=search_opts,marker=marker_id,limit=parsed_args.limit)
      #있는 list를 싹 다 긁어옴
      # 싹다 긁어온거랑, server 에서 가져온거랑 matching 시킴
      table =  (column_headers,
               (utils.get_item_properties(
                  s, columns,
                  mixed_case_fields=mixed_case_fields,
                  formatters={'OS-EXT-STS:power_state': _format_servers_list_power_state,
                     'Networks': _format_servers_list_networks,
                     'Metadata': utils.format_dict,
                  },
               ) for s in data))
      return table