示例#1
0
文件: stack.py 项目: xinni-ge/eclcli
def _list(client, args=None):
    kwargs = {}
    columns = [
        'ID',
        'Stack Name',
        'Stack Status',
        'Creation Time',
        # 'Updated Time',
    ]

    if args:
        kwargs = {
            'limit': args.limit,
            'marker': args.marker,
            # 'filters': heat_utils.format_parameters(args.properties),
            'tags': None,
            'tags_any': None,
            'not_tags': None,
            'not_tags_any': None,
            # 'global_tenant': args.all_projects or args.long,
            'show_deleted': args.deleted,
            # 'show_hidden': args.hidden
        }

        if args.tags:
            if args.tag_mode:
                if args.tag_mode == 'any':
                    kwargs['tags_any'] = args.tags
                elif args.tag_mode == 'not':
                    kwargs['not_tags'] = args.tags
                elif args.tag_mode == 'not-any':
                    kwargs['not_tags_any'] = args.tags
                else:
                    err = _('tag mode must be one of "any", "not", "not-any"')
                    raise exc.CommandError(err)
            else:
                kwargs['tags'] = args.tags

        if args.short:
            columns.pop()
            columns.pop()
        # if args.long:
        #     columns.insert(2, 'Stack Owner')
        # if args.long or args.all_projects:
        #     columns.insert(2, 'Project')

        # if args.nested:
        #     columns.append('Parent')
        #     kwargs['show_nested'] = True

    data = client.stacks.list(**kwargs)
    data = utils.sort_items(data, args.sort if args else None)

    return (
        columns,
        (utils.get_item_properties(s, columns) for s in data)
    )
示例#2
0
    def take_action(self, parsed_args):
        image_client = self.app.client_manager.image

        kwargs = {}
        if parsed_args.public:
            kwargs['public'] = True
        if parsed_args.private:
            kwargs['private'] = True
        if parsed_args.shared:
            kwargs['shared'] = True
        if parsed_args.limit:
            kwargs['limit'] = parsed_args.limit
        if parsed_args.marker:
            kwargs['marker'] = utils.find_resource(image_client.images,
                                                   parsed_args.marker).id

        if parsed_args.long:
            columns = (
                'ID',
                'Name',
                'Disk Format',
                'Container Format',
                'Size',
                'Status',
                'visibility',
                'protected',
                'owner',
                'tags',
            )
            column_headers = (
                'ID',
                'Name',
                'Disk Format',
                'Container Format',
                'Size',
                'Status',
                'Visibility',
                'Protected',
                'Project',
                'Tags',
            )
        else:
            columns = ("ID", "Name", "Status")
            column_headers = columns

        # List of image data received
        data = image_client.api.image_list(**kwargs)

        if parsed_args.property:
            # NOTE(dtroyer): coerce to a list to subscript it in py3
            attr, value = list(parsed_args.property.items())[0]
            api_utils.simple_filter(
                data,
                attr=attr,
                value=value,
                property_field='properties',
            )

        data = utils.sort_items(data, parsed_args.sort)

        return (column_headers, (utils.get_dict_properties(
            s,
            columns,
            formatters={
                'tags': utils.format_list,
            },
        ) for s in data))
示例#3
0
    def take_action(self, parsed_args):
        self.log.debug('take_action(%s)', parsed_args)

        client = self.app.client_manager.orchestration

        columns = [
            'id', 'resource_status', 'resource_status_reason', 'event_time',
            'physical_resource_id'
        ]

        kwargs = {
            'resource_name': parsed_args.resource,
            'limit': parsed_args.limit,
            'marker': parsed_args.marker,
            # 'filters': heat_utils.format_parameters(parsed_args.filter),
            'sort_dir': 'asc'
        }

        # if parsed_args.resource and parsed_args.nested_depth:
        #     msg = _('--nested-depth cannot be specified with --resource')
        #     raise exc.CommandError(msg)

        # if parsed_args.nested_depth:
        #     # Until the API supports recursive event listing we'll have to do
        #     # the marker/limit filtering client-side
        #     del kwargs['marker']
        #     del kwargs['limit']
        #     columns.append('stack_name')
        #     # nested_depth = parsed_args.nested_depth
        # else:
        #     nested_depth = 0

        if parsed_args.follow:
            if parsed_args.formatter != 'value':
                msg = _('--follow can only be specified with --format value')
                raise exc.CommandError(msg)

            marker = parsed_args.marker
            try:
                while True:
                    kwargs['marker'] = marker
                    events = event_utils.get_events(
                        client,
                        stack_id=parsed_args.stack,
                        event_args=kwargs,
                        # nested_depth=nested_depth,
                        nested_depth=0,
                        marker=marker)
                    if events:
                        marker = getattr(events[-1], 'id', None)
                        events_log = heat_utils.event_log_formatter(events)
                        self.app.stdout.write(events_log)
                        self.app.stdout.write('\n')
                    time.sleep(5)
                    # this loop never exits
            except (KeyboardInterrupt, EOFError):  # ctrl-c, ctrl-d
                return [], []

        events = event_utils.get_events(
            client,
            stack_id=parsed_args.stack,
            event_args=kwargs,
            # nested_depth=nested_depth,
            nested_depth=0,
            marker=parsed_args.marker,
            limit=parsed_args.limit)

        if parsed_args.sort:
            events = utils.sort_items(events, ','.join(parsed_args.sort))

        if parsed_args.formatter == 'value':
            events = heat_utils.event_log_formatter(events).split('\n')
            return [], [e.split(' ') for e in events]

        if len(events):
            if hasattr(events[0], 'resource_name'):
                columns.insert(0, 'resource_name')
                columns.append('logical_resource_id')
            else:
                columns.insert(0, 'logical_resource_id')

        return (columns, (utils.get_item_properties(s, columns)
                          for s in events))