column_map = {

'is_protected': 'protected',

'owner_id': 'owner'

}

hidden_columns = [

'location', 'checksum', 'copy_from', 'created_at', 'status',

'updated_at',

]

return utils.get_osc_show_columns_for_sdk_resource(

item.to_dict(), column_map, hidden_columns,

def human_readable(self):

"""Return a formatted visibility string

if self._value:

return utils.format_size(self._value)

else:

def human_readable(self):

"""Return a formatted visibility string

if self._value:

return 'public'

else:

_description = _("Create/upload an image")

def get_parser(self, prog_name):

parser = super(CreateImage, self).get_parser(prog_name)

parser.add_argument(

"name",

metavar="<image-name>",

help=_("New image name"),

)

parser.add_argument(

"--id",

metavar="<id>",

help=_("Image ID to reserve"),

)

parser.add_argument(

"--store",

metavar="<store>",

help=_("Upload image to this store"),

)

parser.add_argument(

"--container-format",

default=DEFAULT_CONTAINER_FORMAT,

metavar="<container-format>",

choices=CONTAINER_CHOICES,

help=(_("Image container format. "

"The supported options are: %(option_list)s. "

"The default format is: %(default_opt)s") %

{'option_list': ', '.join(CONTAINER_CHOICES),

'default_opt': DEFAULT_CONTAINER_FORMAT})

)

parser.add_argument(

"--disk-format",

default=DEFAULT_DISK_FORMAT,

metavar="<disk-format>",

choices=DISK_CHOICES,

help=_("Image disk format. The supported options are: %s. "

"The default format is: raw") % ', '.join(DISK_CHOICES)

)

parser.add_argument(

"--size",

metavar="<size>",

help=_("Image size, in bytes (only used with --location and"

" --copy-from)"),

)

parser.add_argument(

"--min-disk",

metavar="<disk-gb>",

type=int,

help=_("Minimum disk size needed to boot image, in gigabytes"),

)

parser.add_argument(

"--min-ram",

metavar="<ram-mb>",

type=int,

help=_("Minimum RAM size needed to boot image, in megabytes"),

)

parser.add_argument(

"--location",

metavar="<image-url>",

help=_("Download image from an existing URL"),

)

parser.add_argument(

"--copy-from",

metavar="<image-url>",

help=_("Copy image from the data store (similar to --location)"),

)

source_group = parser.add_mutually_exclusive_group()

source_group.add_argument(

"--file",

metavar="<file>",

help=_("Upload image from local file"),

)

source_group.add_argument(

"--volume",

metavar="<volume>",

help=_("Create image from a volume"),

)

parser.add_argument(

"--force",

dest='force',

action='store_true',

default=False,

help=_("Force image creation if volume is in use "

"(only meaningful with --volume)"),

)

parser.add_argument(

"--checksum",

metavar="<checksum>",

help=_("Image hash used for verification"),

)

protected_group = parser.add_mutually_exclusive_group()

protected_group.add_argument(

"--protected",

action="store_true",

help=_("Prevent image from being deleted"),

)

protected_group.add_argument(

"--unprotected",

action="store_true",

help=_("Allow image to be deleted (default)"),

)

public_group = parser.add_mutually_exclusive_group()

public_group.add_argument(

"--public",

action="store_true",

help=_("Image is accessible to the public"),

)

public_group.add_argument(

"--private",

action="store_true",

help=_("Image is inaccessible to the public (default)"),

)

parser.add_argument(

"--property",

dest="properties",

metavar="<key=value>",

action=parseractions.KeyValueAction,

help=_("Set a property on this image "

"(repeat option to set multiple properties)"),

)

parser.add_argument(

"--project",

metavar="<project>",

help=_("Set an alternate project on this image (name or ID)"),

)

return parser

def take_action(self, parsed_args):

image_client = self.app.client_manager.image

# Build an attribute dict from the parsed args, only include

# attributes that were actually set on the command line

kwargs = {}

copy_attrs = ('name', 'id', 'store', 'container_format',

'disk_format', 'owner', 'size', 'min_disk', 'min_ram',

'location', 'copy_from', 'volume', 'force',

'checksum', 'properties')

for attr in copy_attrs:

if attr in parsed_args:

val = getattr(parsed_args, attr, None)

if val:

# Only include a value in kwargs for attributes that are

# actually present on the command line

kwargs[attr] = val

# Special case project option back to API attribute name 'owner'

val = getattr(parsed_args, 'project', None)

if val:

kwargs['owner_id'] = val

# Handle exclusive booleans with care

# Avoid including attributes in kwargs if an option is not

# present on the command line. These exclusive booleans are not

# a single value for the pair of options because the default must be

# to do nothing when no options are present as opposed to always

# setting a default.

if parsed_args.protected:

kwargs['is_protected'] = True

if parsed_args.unprotected:

kwargs['is_protected'] = False

if parsed_args.public:

kwargs['is_public'] = True

if parsed_args.private:

kwargs['is_public'] = False

info = {}

if not parsed_args.location and not parsed_args.copy_from:

if parsed_args.volume:

volume_client = self.app.client_manager.volume

source_volume = utils.find_resource(

volume_client.volumes,

parsed_args.volume,

)

response, body = volume_client.volumes.upload_to_image(

source_volume.id,

parsed_args.force,

parsed_args.name,

parsed_args.container_format,

parsed_args.disk_format,

)

info = body['os-volume_upload_image']

elif parsed_args.file:

# Send an open file handle to glanceclient so it will

# do a chunked transfer

kwargs["data"] = io.open(parsed_args.file, "rb")

else:

# Read file from stdin

if not sys.stdin.isatty():

if msvcrt:

msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)

if hasattr(sys.stdin, 'buffer'):

kwargs['data'] = sys.stdin.buffer

else:

kwargs["data"] = sys.stdin

if not parsed_args.volume:

# Wrap the call to catch exceptions in order to close files

try:

image = image_client.create_image(**kwargs)

finally:

# Clean up open files - make sure data isn't a string

if ('data' in kwargs and hasattr(kwargs['data'], 'close') and

kwargs['data'] != sys.stdin):

kwargs['data'].close()

if image:

display_columns, columns = _get_columns(image)

_formatters['properties'] = format_columns.DictColumn

data = utils.get_item_properties(image, columns,

formatters=_formatters)

return (display_columns, data)

elif info:

info.update(image._info)

info['properties'] = format_columns.DictColumn(

info.get('properties', {}))

_description = _("Delete image(s)")

def get_parser(self, prog_name):

parser = super(DeleteImage, self).get_parser(prog_name)

parser.add_argument(

"images",

metavar="<image>",

nargs="+",

help=_("Image(s) to delete (name or ID)"),

)

return parser

def take_action(self, parsed_args):

image_client = self.app.client_manager.image

for image in parsed_args.images:

image_obj = image_client.find_image(image)

_description = _("List available images")

def get_parser(self, prog_name):

parser = super(ListImage, self).get_parser(prog_name)

public_group = parser.add_mutually_exclusive_group()

public_group.add_argument(

"--public",

dest="public",

action="store_true",

default=False,

help=_("List only public images"),

)

public_group.add_argument(

"--private",

dest="private",

action="store_true",

default=False,

help=_("List only private images"),

)

# Included for silent CLI compatibility with v2

public_group.add_argument(

"--shared",

dest="shared",

action="store_true",

default=False,

help=argparse.SUPPRESS,

)

parser.add_argument(

'--property',

metavar='<key=value>',

action=parseractions.KeyValueAction,

help=_('Filter output based on property'),

)

parser.add_argument(

'--long',

action='store_true',

default=False,

help=_('List additional fields in output'),

)

# --page-size has never worked, leave here for silent compatibility

# We'll implement limit/marker differently later

parser.add_argument(

"--page-size",

metavar="<size>",

help=argparse.SUPPRESS,

)

parser.add_argument(

'--sort',

metavar="<key>[:<direction>]",

default='name:asc',

help=_("Sort output by selected keys and directions(asc or desc) "

"(default: name:asc), multiple keys and directions can be "

"specified separated by comma"),

)

return parser

def take_action(self, parsed_args):

image_client = self.app.client_manager.image

kwargs = {}

if parsed_args.public:

kwargs['is_public'] = True

if parsed_args.private:

kwargs['is_private'] = True

if parsed_args.long:

columns = (

'ID',

'Name',

'Disk Format',

'Container Format',

'Size',

'Checksum',

'Status',

'is_public',

'is_protected',

'owner_id',

'properties',

)

column_headers = (

'ID',

'Name',

'Disk Format',

'Container Format',

'Size',

'Checksum',

'Status',

'Visibility',

'Protected',

'Project',

'Properties',

)

else:

columns = ("ID", "Name", "Status")

column_headers = columns

# List of image data received

data = list(image_client.images(**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_item_properties(

s,

columns,

formatters={

'is_public': VisibilityColumn,

'properties': format_columns.DictColumn,

},

) for s in data)

_description = _("Save an image locally")

def get_parser(self, prog_name):

parser = super(SaveImage, self).get_parser(prog_name)

parser.add_argument(

"--file",

metavar="<filename>",

help=_("Downloaded image save filename (default: stdout)"),

)

parser.add_argument(

"image",

metavar="<image>",

help=_("Image to save (name or ID)"),

)

return parser

def take_action(self, parsed_args):

image_client = self.app.client_manager.image

image = image_client.find_image(parsed_args.image)

output_file = parsed_args.file

if output_file is None:

output_file = getattr(sys.stdout, "buffer", sys.stdout)

_description = _("Set image properties")

def get_parser(self, prog_name):

parser = super(SetImage, self).get_parser(prog_name)

parser.add_argument(

"image",

metavar="<image>",

help=_("Image to modify (name or ID)"),

)

parser.add_argument(

"--name",

metavar="<name>",

help=_("New image name"),

)

parser.add_argument(

"--min-disk",

metavar="<disk-gb>",

type=int,

help=_("Minimum disk size needed to boot image, in gigabytes"),

)

parser.add_argument(

"--min-ram",

metavar="<disk-ram>",

type=int,

help=_("Minimum RAM size needed to boot image, in megabytes"),

)

parser.add_argument(

"--container-format",

metavar="<container-format>",

choices=CONTAINER_CHOICES,

help=_("Image container format. The supported options are: %s") %

', '.join(CONTAINER_CHOICES)

)

parser.add_argument(

"--disk-format",

metavar="<disk-format>",

choices=DISK_CHOICES,

help=_("Image disk format. The supported options are: %s.") %

', '.join(DISK_CHOICES)

)

parser.add_argument(

"--size",

metavar="<size>",

type=int,

help=_("Size of image data (in bytes)")

)

protected_group = parser.add_mutually_exclusive_group()

protected_group.add_argument(

"--protected",

action="store_true",

help=_("Prevent image from being deleted"),

)

protected_group.add_argument(

"--unprotected",

action="store_true",

help=_("Allow image to be deleted (default)"),

)

public_group = parser.add_mutually_exclusive_group()

public_group.add_argument(

"--public",

action="store_true",

help=_("Image is accessible to the public"),

)

public_group.add_argument(

"--private",

action="store_true",

help=_("Image is inaccessible to the public (default)"),

)

parser.add_argument(

"--property",

dest="properties",

metavar="<key=value>",

action=parseractions.KeyValueAction,

help=_("Set a property on this image "

"(repeat option to set multiple properties)"),

)

parser.add_argument(

"--store",

metavar="<store>",

help=_("Upload image to this store"),

)

parser.add_argument(

"--location",

metavar="<image-url>",

help=_("Download image from an existing URL"),

)

parser.add_argument(

"--copy-from",

metavar="<image-url>",

help=_("Copy image from the data store (similar to --location)"),

)

parser.add_argument(

"--file",

metavar="<file>",

help=_("Upload image from local file"),

)

parser.add_argument(

"--volume",

metavar="<volume>",

help=_("Create image from a volume"),

)

parser.add_argument(

"--force",

dest='force',

action='store_true',

default=False,

help=_("Force image change if volume is in use "

"(only meaningful with --volume)"),

)

parser.add_argument(

"--stdin",

dest='stdin',

action='store_true',

default=False,

help=_("Read image data from standard input"),

)

parser.add_argument(

"--checksum",

metavar="<checksum>",

help=_("Image hash used for verification"),

)

parser.add_argument(

"--project",

metavar="<project>",

help=_("Set an alternate project on this image (name or ID)"),

)

return parser

def take_action(self, parsed_args):

image_client = self.app.client_manager.image

kwargs = {}

copy_attrs = ('name', 'owner', 'min_disk', 'min_ram', 'properties',

'container_format', 'disk_format', 'size', 'store',

'location', 'copy_from', 'volume', 'checksum')

for attr in copy_attrs:

if attr in parsed_args:

val = getattr(parsed_args, attr, None)

if val is not None:

# Only include a value in kwargs for attributes that are

# actually present on the command line

kwargs[attr] = val

# Special case project option back to API attribute name 'owner'

val = getattr(parsed_args, 'project', None)

if val:

kwargs['owner'] = val

# Handle exclusive booleans with care

# Avoid including attributes in kwargs if an option is not

# present on the command line. These exclusive booleans are not

# a single value for the pair of options because the default must be

# to do nothing when no options are present as opposed to always

# setting a default.

if parsed_args.protected:

kwargs['is_protected'] = True

if parsed_args.unprotected:

kwargs['is_protected'] = False

if parsed_args.public:

kwargs['is_public'] = True

if parsed_args.private:

kwargs['is_public'] = False

# Wrap the call to catch exceptions in order to close files

try:

image = image_client.find_image(parsed_args.image)

if not parsed_args.location and not parsed_args.copy_from:

if parsed_args.volume:

volume_client = self.app.client_manager.volume

source_volume = utils.find_resource(

volume_client.volumes,

parsed_args.volume,

)

volume_client.volumes.upload_to_image(

source_volume.id,

parsed_args.force,

parsed_args.image,

(parsed_args.container_format

if parsed_args.container_format

else image.container_format),

(parsed_args.disk_format

if parsed_args.disk_format

else image.disk_format),

)

elif parsed_args.file:

# Send an open file handle to glanceclient so it will

# do a chunked transfer

kwargs["data"] = io.open(parsed_args.file, "rb")

else:

# Read file from stdin

if sys.stdin.isatty() is not True:

if parsed_args.stdin:

if msvcrt:

msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)

if hasattr(sys.stdin, 'buffer'):

kwargs['data'] = sys.stdin.buffer

else:

kwargs["data"] = sys.stdin

else:

LOG.warning(_('Use --stdin to enable read image '

'data from standard input'))

if image.properties and parsed_args.properties:

image.properties.update(kwargs['properties'])

kwargs['properties'] = image.properties

image = image_client.update_image(image.id, **kwargs)

finally:

# Clean up open files - make sure data isn't a string

if ('data' in kwargs and hasattr(kwargs['data'], 'close') and

kwargs['data'] != sys.stdin):

_description = _("Display image details")

def get_parser(self, prog_name):

parser = super(ShowImage, self).get_parser(prog_name)

parser.add_argument(

"--human-readable",

default=False,

action='store_true',

help=_("Print image size in a human-friendly format."),

)

parser.add_argument(

"image",

metavar="<image>",

help=_("Image to display (name or ID)"),

)

return parser

def take_action(self, parsed_args):

image_client = self.app.client_manager.image

image = image_client.find_image(parsed_args.image)

if parsed_args.human_readable:

_formatters['size'] = HumanReadableSizeColumn

display_columns, columns = _get_columns(image)

_formatters['properties'] = format_columns.DictColumn

data = utils.get_item_properties(image, columns,

formatters=_formatters)