openstack server list 명령어 분석¶

# super(Command, self).run(parsed_args)
#    -> /cliff/lister.py

            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

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

def parse_known_args(self, args=None, namespace=None):
    # args default to the system args
    if args is None:
        args = _sys.argv[1:]

    # default Namespace built from parser defaults
    if namespace is None:
        namespace = Namespace()

    # add any action defaults that aren't present
    for action in self._actions:
        if action.dest is not SUPPRESS:
            if not hasattr(namespace, action.dest):
                if action.default is not SUPPRESS:
                    setattr(namespace, action.dest, action.default)

# parse the arguments and exit if there are any errors
try:
    namespace, args = self._parse_known_args(args, namespace)
    return namespace, args

def _parse_known_args(self, arg_strings, namespace):
    # replace arg strings that are file references
    if self.fromfile_prefix_chars is not None:
        arg_strings = self._read_args_from_files(arg_strings)

    # find all option indices, and determine the arg_string_pattern
    # which has an 'O' if there is an option at an index,
    # an 'A' if there is an argument, or a '-' if there is a '--'
    option_string_indices = {}
    arg_string_pattern_parts = []
    arg_strings_iter = iter(arg_strings)
    for i, arg_string in enumerate(arg_strings_iter):

        # all args after -- are non-options
        if arg_string == '--':
            arg_string_pattern_parts.append('-')
            for arg_string in arg_strings_iter:
                arg_string_pattern_parts.append('A')

        # otherwise, add the arg to the arg strings
        # and note the index if it was an option
        else:
            option_tuple = self._parse_optional(arg_string)
            if option_tuple is None:
                pattern = 'A'
            else:
                option_string_indices[i] = option_tuple
                pattern = 'O'
            arg_string_pattern_parts.append(pattern)

    # join the pieces together to form the pattern
    arg_strings_pattern = ''.join(arg_string_pattern_parts)

    # converts arg strings to the appropriate and then takes the action
    seen_actions = set()
    seen_non_default_actions = set()