def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ['name', 'status', 'container_format', 'disk_format',
'size_min', 'size_max', 'is_public']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
if args.properties:
property_filter_items = [p.split('=', 1) for p in args.properties]
filters['properties'] = dict(property_filter_items)
kwargs = {'filters': filters}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
kwargs['sort_key'] = args.sort_key
kwargs['sort_dir'] = args.sort_dir
kwargs['owner'] = args.owner
if args.all_tenants is True:
kwargs['is_public'] = None
images = gc.images.list(**kwargs)
if args.human_readable:
def convert_size(image):
image.size = utils.make_size_human_readable(image.size)
return image
images = (convert_size(image) for image in images)
columns = ['ID', 'Name', 'Disk Format', 'Container Format',
'Size', 'Status']
utils.print_list(images, columns)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ["name", "status", "container_format", "disk_format", "size_min", "size_max", "is_public"]
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
if args.properties:
property_filter_items = [p.split("=", 1) for p in args.properties]
filters["properties"] = dict(property_filter_items)
kwargs = {"filters": filters}
if args.page_size is not None:
kwargs["page_size"] = args.page_size
kwargs["sort_key"] = args.sort_key
kwargs["sort_dir"] = args.sort_dir
kwargs["owner"] = args.owner
if args.all_tenants is True:
kwargs["is_public"] = None
images = gc.images.list(**kwargs)
if args.human_readable:
def convert_size(image):
image.size = utils.make_size_human_readable(image.size)
return image
images = (convert_size(image) for image in images)
columns = ["ID", "Name", "Disk Format", "Container Format", "Size", "Status"]
utils.print_list(images, columns)
def do_md_tag_create_multiple(gc, args):
"""Create new metadata definitions tags inside a namespace."""
delim = args.delim or ','
tags = []
names_list = args.names.split(delim)
for name in names_list:
name = name.strip()
if name:
tags.append(name)
if not tags:
utils.exit('Please supply at least one tag name. For example: '
'--names Tag1')
fields = {'tags': tags}
new_tags = gc.metadefs_tag.create_multiple(args.namespace, **fields)
columns = ['name']
column_settings = {
"description": {
"max_width": 50,
"align": "l"
}
}
utils.print_list(new_tags, columns, field_settings=column_settings)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ["visibility", "member_status", "owner", "checksum", "tag"]
filter_items = [(key, getattr(args, key)) for key in filter_keys]
if args.properties:
filter_properties = [prop.split("=", 1) for prop in args.properties]
if any(len(pair) != 2 for pair in filter_properties):
utils.exit("Argument --property-filter expected properties in the" " format KEY=VALUE")
filter_items += filter_properties
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {"filters": filters}
if args.limit is not None:
kwargs["limit"] = args.limit
if args.page_size is not None:
kwargs["page_size"] = args.page_size
if args.sort_key:
kwargs["sort_key"] = args.sort_key
if args.sort_dir:
kwargs["sort_dir"] = args.sort_dir
if args.sort is not None:
kwargs["sort"] = args.sort
elif not args.sort_dir and not args.sort_key:
kwargs["sort_key"] = "name"
kwargs["sort_dir"] = "asc"
columns = ["ID", "Name"]
if args.verbose:
columns += ["Disk_format", "Container_format", "Size", "Status", "Owner"]
images = gc.images.list(**kwargs)
utils.print_list(images, columns)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ['visibility', 'member_status', 'owner', 'checksum', 'tag']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
if args.properties:
filter_properties = [prop.split('=', 1) for prop in args.properties]
if any(len(pair) != 2 for pair in filter_properties):
utils.exit('Argument --property-filter expected properties in the'
' format KEY=VALUE')
filter_items += filter_properties
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {'filters': filters}
if args.limit is not None:
kwargs['limit'] = args.limit
if args.page_size is not None:
kwargs['page_size'] = args.page_size
if args.sort_key:
kwargs['sort_key'] = args.sort_key
if args.sort_dir:
kwargs['sort_dir'] = args.sort_dir
if args.sort is not None:
kwargs['sort'] = args.sort
elif not args.sort_dir and not args.sort_key:
kwargs['sort'] = 'name:asc'
columns = ['ID', 'Name']
if args.verbose:
columns += ['owner', 'status']
images = gc.images.list(**kwargs)
utils.print_list(images, columns)
def test_print_list_with_list_no_unicode(self):
class Struct(object):
def __init__(self, **entries):
self.__dict__.update(entries)
# test for removing 'u' from lists in print_list output
columns = ['ID', 'Tags']
images = [Struct(**{'id': 'b8e1c57e-907a-4239-aed8-0df8e54b8d2d',
'tags': [u'Name1', u'Tag_123', u'veeeery long']})]
saved_stdout = sys.stdout
try:
sys.stdout = output_list = six.StringIO()
utils.print_list(images, columns)
finally:
sys.stdout = saved_stdout
self.assertEqual('''\
+--------------------------------------+--------------------------------------+
| ID | Tags |
+--------------------------------------+--------------------------------------+
| b8e1c57e-907a-4239-aed8-0df8e54b8d2d | ['Name1', 'Tag_123', 'veeeery long'] |
+--------------------------------------+--------------------------------------+
''',
output_list.getvalue())
def do_image_list(gc, args):
"""List images you can access."""
kwargs = {}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
images = gc.images.list(**kwargs)
columns = ['ID', 'Name']
utils.print_list(images, columns)
def do_member_create(gc, args):
"""Create member for a given image."""
if not (args.image_id and args.member_id):
utils.exit("Unable to create member. Specify image_id and member_id")
else:
member = gc.image_members.create(args.image_id, args.member_id)
member = [member]
columns = ["Image ID", "Member ID", "Status"]
utils.print_list(member, columns)
def do_member_update(gc, args):
"""Update the status of a member for a given image."""
if not (args.image_id and args.member_id and args.member_status):
utils.exit("Unable to update member. Specify image_id, member_id and" " member_status")
else:
member = gc.image_members.update(args.image_id, args.member_id, args.member_status)
member = [member]
columns = ["Image ID", "Member ID", "Status"]
utils.print_list(member, columns)
def test_prettytable(self):
class Struct(object):
def __init__(self, **entries):
self.__dict__.update(entries)
# test that the prettytable output is wellformatted (left-aligned)
columns = ["ID", "Name"]
val = ["Name1", "another", "veeeery long"]
images = [Struct(**{"id": i ** 16, "name": val[i]}) for i in range(len(val))]
saved_stdout = sys.stdout
try:
sys.stdout = output_list = six.StringIO()
utils.print_list(images, columns)
sys.stdout = output_dict = six.StringIO()
utils.print_dict(
{
"K": "k",
"Key": "veeeeeeeeeeeeeeeeeeeeeeee"
"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
"eeeeeeeeeeeery long value",
},
max_column_width=60,
)
finally:
sys.stdout = saved_stdout
self.assertEqual(
"""\
+-------+--------------+
| ID | Name |
+-------+--------------+
| | Name1 |
| 1 | another |
| 65536 | veeeery long |
+-------+--------------+
""",
output_list.getvalue(),
)
self.assertEqual(
"""\
+----------+--------------------------------------------------------------+
| Property | Value |
+----------+--------------------------------------------------------------+
| K | k |
| Key | veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee |
| | eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee |
| | ery long value |
+----------+--------------------------------------------------------------+
""",
output_dict.getvalue(),
)
def do_explain(gc, args):
"""Describe a specific model."""
try:
schema = gc.schemas.get(args.model)
except exc.HTTPNotFound:
utils.exit("Unable to find requested model '%s'" % args.model)
else:
formatters = {"Attribute": lambda m: m.name}
columns = ["Attribute", "Description"]
utils.print_list(schema.properties, columns, formatters)
def do_explain(gc, args):
"""Describe a specific model."""
try:
schema = gc.schemas.get(args.model)
except exc.SchemaNotFound:
utils.exit('Unable to find requested model \'%s\'' % args.model)
else:
formatters = {'Attribute': lambda m: m.name}
columns = ['Attribute', 'Description']
utils.print_list(schema.properties, columns, formatters)
def do_image_tag_update(gc, args):
"""Update an image with the given tag."""
if not (args.image_id and args.tag_value):
utils.exit("Unable to update tag. Specify image_id and tag_value")
else:
gc.image_tags.update(args.image_id, args.tag_value)
image = gc.images.get(args.image_id)
image = [image]
columns = ["ID", "Tags"]
utils.print_list(image, columns)
def do_md_tag_list(gc, args):
"""List metadata definitions tags inside a specific namespace."""
tags = gc.metadefs_tag.list(args.namespace)
columns = ['name']
column_settings = {
"description": {
"max_width": 50,
"align": "l"
}
}
utils.print_list(tags, columns, field_settings=column_settings)
def do_md_object_list(gc, args):
"""List metadata definitions objects inside a specific namespace."""
objects = gc.metadefs_object.list(args.namespace)
columns = ['name', 'description']
column_settings = {
"description": {
"max_width": 50,
"align": "l"
}
}
utils.print_list(objects, columns, field_settings=column_settings)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ['visibility', 'member_status', 'owner', 'checksum', 'tag']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {'filters': filters}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
images = gc.images.list(**kwargs)
columns = ['ID', 'Name']
utils.print_list(images, columns)
def do_md_namespace_list(gc, args):
"""List metadata definitions namespaces."""
filter_keys = ["resource_types", "visibility"]
filter_items = [(key, getattr(args, key, None)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {"filters": filters}
if args.page_size is not None:
kwargs["page_size"] = args.page_size
namespaces = gc.metadefs_namespace.list(**kwargs)
columns = ["namespace"]
utils.print_list(namespaces, columns)
def print_images(self):
columns = ['ID', 'Name', 'Disk Format',
'Container Format', 'Size', 'Status']
tenant_images = self.glance.image_list(owner=self.glance.project_id)
snapshots = []
images = []
for image in tenant_images:
if 'image_type' in image.properties:
if image.properties['image_type'] == "snapshot":
snapshots.append(image)
else:
images.append(image)
print('\n\nTENANT IMAGES')
glance_utils.print_list(images, columns)
print('\n\nTENANT SNAPSHOTS')
glance_utils.print_list(snapshots, columns)
tenant_images = self.glance.image_list()
shared_images_ids = \
self.glance.image_member_list(self.glance.project_id)
print('\n\nSHARED IMAGES')
tenant_images_1 = []
for simg in shared_images_ids:
for img in tenant_images:
if img.id == simg.image_id:
tenant_images_1.append(img)
glance_utils.print_list(tenant_images_1, columns)
print('\n\nALL AVAILABLE IMAGES')
tenant_images = self.glance.image_list()
glance_utils.print_list(tenant_images, columns)
def do_member_list(gc, args):
if args.image_id and args.tenant_id:
print 'Unable to filter members by both --image-id and --tenant-id.'
sys.exit(1)
elif args.image_id:
kwargs = {'image': args.image_id}
elif args.tenant_id:
kwargs = {'member': args.tenant_id}
else:
print 'Unable to list all members. Specify --image-id or --tenant-id'
sys.exit(1)
members = gc.image_members.list(**kwargs)
columns = ['Image ID', 'Member ID', 'Can Share']
utils.print_list(members, columns)
def do_image_list(gc, args):
"""List images."""
filter_keys = ['name', 'status', 'container_format', 'disk_format',
'size_min', 'size_max']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
if args.properties:
property_filter_items = [p.split('=', 1) for p in args.properties]
filters['properties'] = dict(property_filter_items)
images = gc.images.list(filters=filters)
columns = ['ID', 'Name', 'Disk Format', 'Container Format',
'Size', 'Status']
utils.print_list(images, columns)
def test_prettytable(self):
class Struct(object):
def __init__(self, **entries):
self.__dict__.update(entries)
# test that the prettytable output is wellformatted (left-aligned)
columns = ['ID', 'Name']
val = ['Name1', 'another', 'veeeery long']
images = [Struct(**{'id': i ** 16, 'name': val[i]})
for i in range(len(val))]
saved_stdout = sys.stdout
try:
sys.stdout = output_list = six.StringIO()
utils.print_list(images, columns)
sys.stdout = output_dict = six.StringIO()
utils.print_dict({'K': 'k', 'Key': 'veeeeeeeeeeeeeeeeeeeeeeee'
'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
'eeeeeeeeeeeery long value'},
max_column_width=60)
finally:
sys.stdout = saved_stdout
self.assertEqual('''\
+-------+--------------+
| ID | Name |
+-------+--------------+
| | Name1 |
| 1 | another |
| 65536 | veeeery long |
+-------+--------------+
''',
output_list.getvalue())
self.assertEqual('''\
+----------+--------------------------------------------------------------+
| Property | Value |
+----------+--------------------------------------------------------------+
| K | k |
| Key | veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee |
| | eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee |
| | ery long value |
+----------+--------------------------------------------------------------+
''',
output_dict.getvalue())
def do_member_list(gc, args):
"""Describe sharing permissions by image or tenant."""
if args.image_id and args.tenant_id:
print("Unable to filter members by both --image-id and --tenant-id.")
sys.exit(1)
elif args.image_id:
kwargs = {"image": args.image_id}
elif args.tenant_id:
kwargs = {"member": args.tenant_id}
else:
print("Unable to list all members. Specify --image-id or --tenant-id")
sys.exit(1)
members = gc.image_members.list(**kwargs)
columns = ["Image ID", "Member ID", "Can Share"]
utils.print_list(members, columns)
def do_member_list(gc, args):
"""Describe sharing permissions by image or tenant."""
if args.image_id and args.tenant_id:
utils.exit('Unable to filter members by both --image-id and'
' --tenant-id.')
elif args.image_id:
kwargs = {'image': args.image_id}
elif args.tenant_id:
kwargs = {'member': args.tenant_id}
else:
utils.exit('Unable to list all members. Specify --image-id or'
' --tenant-id')
members = gc.image_members.list(**kwargs)
columns = ['Image ID', 'Member ID', 'Can Share']
utils.print_list(members, columns)
def do_member_list(gc, args):
"""Describe sharing permissions by image or tenant."""
if args.image_id and args.tenant_id:
utils.exit('Unable to filter members by both --image-id and'
' --tenant-id.')
elif args.image_id:
kwargs = {'image': args.image_id}
elif args.tenant_id:
kwargs = {'member': args.tenant_id}
else:
utils.exit('Unable to list all members. Specify --image-id or'
' --tenant-id')
members = gc.image_members.list(**kwargs)
columns = ['Image ID', 'Member ID', 'Can Share']
utils.print_list(members, columns)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ['visibility', 'member_status', 'owner', 'checksum', 'tag']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
if args.properties:
filter_properties = [prop.split('=', 1) for prop in args.properties]
if any(len(pair) != 2 for pair in filter_properties):
utils.exit('Argument --property-filter expected properties in the'
' format KEY=VALUE')
filter_items += filter_properties
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {'filters': filters}
if args.limit is not None:
kwargs['limit'] = args.limit
if args.page_size is not None:
kwargs['page_size'] = args.page_size
if args.sort_key:
kwargs['sort_key'] = args.sort_key
if args.sort_dir:
kwargs['sort_dir'] = args.sort_dir
if args.sort is not None:
kwargs['sort'] = args.sort
elif not args.sort_dir and not args.sort_key:
kwargs['sort_key'] = 'name'
kwargs['sort_dir'] = 'asc'
columns = ['ID', 'Name']
if args.verbose:
columns += [
'Store', 'Disk_format', 'Container_format', 'Size', 'Status',
'Cache Size', 'Raw Cache', 'Owner'
]
images = gc.images.list(**kwargs)
def add_attributes(image):
image.raw_cache = getattr(image, "cache_raw_status", "")
image.cache_size = getattr(image, "cache_raw_size", "")
return image
images = (add_attributes(image) for image in images)
utils.print_list(images, columns)
def do_task_list(gc, args):
"""List tasks you can access."""
filter_keys = ['type', 'status']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {'filters': filters}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
kwargs['sort_key'] = args.sort_key
kwargs['sort_dir'] = args.sort_dir
tasks = gc.tasks.list(**kwargs)
columns = ['ID', 'Type', 'Status', 'Owner']
utils.print_list(tasks, columns)
def test_prettytable(self):
class Struct:
def __init__(self, **entries):
self.__dict__.update(entries)
# test that the prettytable output is wellformatted (left-aligned)
columns = ['ID', 'Name']
val = ['Name1', 'another', 'veeeery long']
images = [
Struct(**{
'id': i**16,
'name': val[i]
}) for i in range(len(val))
]
saved_stdout = sys.stdout
try:
sys.stdout = output_list = StringIO.StringIO()
utils.print_list(images, columns)
sys.stdout = output_dict = StringIO.StringIO()
utils.print_dict({'K': 'k', 'Key': 'Value'})
finally:
sys.stdout = saved_stdout
self.assertEqual(
output_list.getvalue(), '''\
+-------+--------------+
| ID | Name |
+-------+--------------+
| | Name1 |
| 1 | another |
| 65536 | veeeery long |
+-------+--------------+
''')
self.assertEqual(
output_dict.getvalue(), '''\
+----------+-------+
| Property | Value |
+----------+-------+
| K | k |
| Key | Value |
+----------+-------+
''')
def do_task_list(gc, args):
"""List tasks you can access."""
filter_keys = ['type', 'status']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {'filters': filters}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
kwargs['sort_key'] = args.sort_key
kwargs['sort_dir'] = args.sort_dir
tasks = gc.tasks.list(**kwargs)
columns = ['ID', 'Type', 'Status', 'Owner']
utils.print_list(tasks, columns)
def do_task_list(gc, args):
"""List tasks you can access."""
filter_keys = ["type", "status"]
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {"filters": filters}
if args.page_size is not None:
kwargs["page_size"] = args.page_size
kwargs["sort_key"] = args.sort_key
kwargs["sort_dir"] = args.sort_dir
tasks = gc.tasks.list(**kwargs)
columns = ["ID", "Type", "Status", "Owner"]
utils.print_list(tasks, columns)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ['name', 'status', 'container_format', 'disk_format',
'size_min', 'size_max']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
if args.properties:
property_filter_items = [p.split('=', 1) for p in args.properties]
filters['properties'] = dict(property_filter_items)
kwargs = {'filters': filters}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
images = gc.images.list(**kwargs)
columns = ['ID', 'Name', 'Disk Format', 'Container Format',
'Size', 'Status']
utils.print_list(images, columns)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = [
'name', 'status', 'container_format', 'disk_format', 'size_min',
'size_max', 'is_public', 'changes_since'
]
filter_items = [(key, getattr(args, key)) for key in filter_keys]
filters = dict([item for item in filter_items if item[1] is not None])
if 'changes_since' in filters:
filters['changes-since'] = filters.pop('changes_since')
if args.properties:
property_filter_items = [p.split('=', 1) for p in args.properties]
if any(len(pair) != 2 for pair in property_filter_items):
utils.exit('Argument --property-filter requires properties in the'
' format KEY=VALUE')
filters['properties'] = dict(property_filter_items)
kwargs = {'filters': filters}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
kwargs['sort_key'] = args.sort_key
kwargs['sort_dir'] = args.sort_dir
kwargs['owner'] = args.owner
if args.all_tenants is True:
kwargs['is_public'] = None
images = gc.images.list(**kwargs)
if args.human_readable:
def convert_size(image):
image.size = utils.make_size_human_readable(image.size)
return image
images = (convert_size(image) for image in images)
columns = [
'ID', 'Name', 'Disk Format', 'Container Format', 'Size', 'Status'
]
utils.print_list(images, columns)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ['visibility', 'member_status', 'owner', 'checksum', 'tag']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
if args.properties:
filter_properties = [prop.split('=', 1) for prop in args.properties]
if False in (len(pair) == 2 for pair in filter_properties):
utils.exit('Argument --property-filter expected properties in the'
' format KEY=VALUE')
filter_items += filter_properties
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {'filters': filters}
if args.page_size is not None:
kwargs['page_size'] = args.page_size
images = gc.images.list(**kwargs)
columns = ['ID', 'Name']
utils.print_list(images, columns)
def do_md_tag_create_multiple(gc, args):
"""Create new metadata definitions tags inside a namespace."""
delim = args.delim or ','
tags = []
names_list = args.names.split(delim)
for name in names_list:
name = name.strip()
if name:
tags.append(name)
if not tags:
utils.exit('Please supply at least one tag name. For example: '
'--names Tag1')
fields = {'tags': tags}
new_tags = gc.metadefs_tag.create_multiple(args.namespace, **fields)
columns = ['name']
column_settings = {"description": {"max_width": 50, "align": "l"}}
utils.print_list(new_tags, columns, field_settings=column_settings)
def do_image_list(gc, args):
"""List images you can access."""
filter_keys = ['visibility', 'member_status', 'owner', 'checksum', 'tag']
filter_items = [(key, getattr(args, key)) for key in filter_keys]
if args.properties:
filter_properties = [prop.split('=', 1) for prop in args.properties]
if False in (len(pair) == 2 for pair in filter_properties):
utils.exit('Argument --property-filter expected properties in the'
' format KEY=VALUE')
filter_items += filter_properties
filters = dict([item for item in filter_items if item[1] is not None])
kwargs = {'filters': filters}
if args.limit is not None:
kwargs['limit'] = args.page_size
if args.page_size is not None:
kwargs['page_size'] = args.page_size
images = gc.images.list(**kwargs)
columns = ['ID', 'Name']
utils.print_list(images, columns)
def do_md_tag_list(gc, args):
"""List metadata definitions tags inside a specific namespace."""
tags = gc.metadefs_tag.list(args.namespace)
columns = ['name']
column_settings = {"description": {"max_width": 50, "align": "l"}}
utils.print_list(tags, columns, field_settings=column_settings)
def do_md_property_list(gc, args):
"""List metadata definitions properties inside a specific namespace."""
properties = gc.metadefs_property.list(args.namespace)
columns = ["name", "title", "type"]
utils.print_list(properties, columns)
def do_md_namespace_resource_type_list(gc, args):
"""List resource types associated to specific namespace."""
resource_types = gc.metadefs_resource_type.get(args.namespace)
utils.print_list(resource_types, ["name", "prefix", "properties_target"])
def do_md_resource_type_list(gc, args):
"""List available resource type names."""
resource_types = gc.metadefs_resource_type.list()
utils.print_list(resource_types, ["name"])
def do_md_property_list(gc, args):
"""List metadata definitions properties inside a specific namespace."""
properties = gc.metadefs_property.list(args.namespace)
columns = ['name', 'title', 'type']
utils.print_list(properties, columns)
def do_md_namespace_resource_type_list(gc, args):
"""List resource types associated to specific namespace."""
resource_types = gc.metadefs_resource_type.get(args.namespace)
utils.print_list(resource_types, ['name', 'prefix', 'properties_target'])
def do_explain(gc, args):
"""Describe a specific model."""
schema = gc.schemas.get(args.name)
columns = ['Name', 'Description']
utils.print_list(schema.properties, columns)
def do_member_list(gc, args):
"""Describe sharing permissions by image."""
members = gc.image_members.list(args.image_id)
columns = ["Image ID", "Member ID", "Status"]
utils.print_list(members, columns)
def do_md_resource_type_list(gc, args):
"""List available resource type names."""
resource_types = gc.metadefs_resource_type.list()
utils.print_list(resource_types, ['name'])
def do_image_list(gc, args):
"""List images."""
images = gc.images.list()
columns = ['ID', 'Name']
utils.print_list(images, columns)
def do_member_list(gc, args):
"""Describe sharing permissions by image."""
members = gc.image_members.list(args.image_id)
columns = ['Image ID', 'Member ID', 'Status']
utils.print_list(members, columns)
def do_md_object_list(gc, args):
"""List metadata definitions objects inside a specific namespace."""
objects = gc.metadefs_object.list(args.namespace)
columns = ['name', 'description']
column_settings = {"description": {"max_width": 50, "align": "l"}}
utils.print_list(objects, columns, field_settings=column_settings)
