bd589778c2
Openstack image create command updates existing image (with same name) by default. That might be confusing since glance allows create multiple images with same names and may lead to unwanted image update by image create command. Image update code was moved from image create action to image set action. BackwardsIncompatibleImpact Change-Id: I1686c6544c366262efab9e33c066d5f8a667f707 Closes-Bug: #1461817
706 lines
23 KiB
Python
706 lines
23 KiB
Python
# Copyright 2012-2013 OpenStack Foundation
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
|
|
"""Image V1 Action Implementations"""
|
|
|
|
import argparse
|
|
import io
|
|
import logging
|
|
import os
|
|
import six
|
|
import sys
|
|
|
|
if os.name == "nt":
|
|
import msvcrt
|
|
else:
|
|
msvcrt = None
|
|
|
|
from cliff import command
|
|
from cliff import lister
|
|
from cliff import show
|
|
|
|
from glanceclient.common import utils as gc_utils
|
|
from openstackclient.api import utils as api_utils
|
|
from openstackclient.common import parseractions
|
|
from openstackclient.common import utils
|
|
|
|
|
|
DEFAULT_CONTAINER_FORMAT = 'bare'
|
|
DEFAULT_DISK_FORMAT = 'raw'
|
|
|
|
|
|
def _format_visibility(data):
|
|
"""Return a formatted visibility string
|
|
|
|
:param data:
|
|
The server's visibility (is_public) status value: True, False
|
|
:rtype:
|
|
A string formatted to public/private
|
|
"""
|
|
|
|
if data:
|
|
return 'public'
|
|
else:
|
|
return 'private'
|
|
|
|
|
|
class CreateImage(show.ShowOne):
|
|
"""Create/upload an image"""
|
|
|
|
log = logging.getLogger(__name__ + ".CreateImage")
|
|
|
|
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>",
|
|
help="Image container format "
|
|
"(default: %s)" % DEFAULT_CONTAINER_FORMAT,
|
|
)
|
|
parser.add_argument(
|
|
"--disk-format",
|
|
default=DEFAULT_DISK_FORMAT,
|
|
metavar="<disk-format>",
|
|
help="Image disk format "
|
|
"(default: %s)" % DEFAULT_DISK_FORMAT,
|
|
)
|
|
parser.add_argument(
|
|
"--owner",
|
|
metavar="<project>",
|
|
help="Image owner project name or ID",
|
|
)
|
|
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)",
|
|
)
|
|
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 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)",
|
|
)
|
|
return parser
|
|
|
|
def take_action(self, parsed_args):
|
|
self.log.debug("take_action(%s)", 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
|
|
# 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['protected'] = True
|
|
if parsed_args.unprotected:
|
|
kwargs['protected'] = False
|
|
if parsed_args.public:
|
|
kwargs['is_public'] = True
|
|
if parsed_args.private:
|
|
kwargs['is_public'] = False
|
|
|
|
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 sys.stdin.isatty() is not True:
|
|
if msvcrt:
|
|
msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
|
|
# Send an open file handle to glanceclient so it will
|
|
# do a chunked transfer
|
|
kwargs["data"] = sys.stdin
|
|
|
|
# Wrap the call to catch exceptions in order to close files
|
|
try:
|
|
image = image_client.images.create(**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()
|
|
|
|
info = {}
|
|
info.update(image._info)
|
|
return zip(*sorted(six.iteritems(info)))
|
|
|
|
|
|
class DeleteImage(command.Command):
|
|
"""Delete image(s)"""
|
|
|
|
log = logging.getLogger(__name__ + ".DeleteImage")
|
|
|
|
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):
|
|
self.log.debug("take_action(%s)", parsed_args)
|
|
|
|
image_client = self.app.client_manager.image
|
|
for image in parsed_args.images:
|
|
image_obj = utils.find_resource(
|
|
image_client.images,
|
|
image,
|
|
)
|
|
image_client.images.delete(image_obj.id)
|
|
|
|
|
|
class ListImage(lister.Lister):
|
|
"""List available images"""
|
|
|
|
log = logging.getLogger(__name__ + ".ListImage")
|
|
|
|
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>]",
|
|
help="Sort output by selected keys and directions(asc or desc) "
|
|
"(default: asc), multiple keys and directions can be "
|
|
"specified separated by comma",
|
|
)
|
|
return parser
|
|
|
|
def take_action(self, parsed_args):
|
|
self.log.debug("take_action(%s)", parsed_args)
|
|
|
|
image_client = self.app.client_manager.image
|
|
|
|
kwargs = {}
|
|
if parsed_args.public:
|
|
kwargs['public'] = True
|
|
if parsed_args.private:
|
|
kwargs['private'] = True
|
|
kwargs['detailed'] = bool(parsed_args.property or parsed_args.long)
|
|
|
|
if parsed_args.long:
|
|
columns = (
|
|
'ID',
|
|
'Name',
|
|
'Disk Format',
|
|
'Container Format',
|
|
'Size',
|
|
'Status',
|
|
'is_public',
|
|
'protected',
|
|
'owner',
|
|
'properties',
|
|
)
|
|
column_headers = (
|
|
'ID',
|
|
'Name',
|
|
'Disk Format',
|
|
'Container Format',
|
|
'Size',
|
|
'Status',
|
|
'Visibility',
|
|
'Protected',
|
|
'Owner',
|
|
'Properties',
|
|
)
|
|
else:
|
|
columns = ("ID", "Name")
|
|
column_headers = columns
|
|
|
|
# List of image data received
|
|
data = []
|
|
# No pages received yet, so start the page marker at None.
|
|
marker = None
|
|
while True:
|
|
page = image_client.api.image_list(marker=marker, **kwargs)
|
|
if not page:
|
|
break
|
|
data.extend(page)
|
|
# Set the marker to the id of the last item we received
|
|
marker = page[-1]['id']
|
|
|
|
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={
|
|
'is_public': _format_visibility,
|
|
'properties': utils.format_dict,
|
|
},
|
|
) for s in data)
|
|
)
|
|
|
|
|
|
class SaveImage(command.Command):
|
|
"""Save an image locally"""
|
|
|
|
log = logging.getLogger(__name__ + ".SaveImage")
|
|
|
|
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):
|
|
self.log.debug("take_action(%s)", parsed_args)
|
|
|
|
image_client = self.app.client_manager.image
|
|
image = utils.find_resource(
|
|
image_client.images,
|
|
parsed_args.image,
|
|
)
|
|
data = image_client.images.data(image)
|
|
|
|
gc_utils.save_image(data, parsed_args.file)
|
|
|
|
|
|
class SetImage(show.ShowOne):
|
|
"""Set image properties"""
|
|
|
|
log = logging.getLogger(__name__ + ".SetImage")
|
|
|
|
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(
|
|
"--owner",
|
|
metavar="<project>",
|
|
help="New image owner project (name or ID)",
|
|
)
|
|
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",
|
|
)
|
|
container_choices = ["ami", "ari", "aki", "bare", "ovf"]
|
|
parser.add_argument(
|
|
"--container-format",
|
|
metavar="<container-format>",
|
|
help=("Container format of image. Acceptable formats: %s" %
|
|
container_choices),
|
|
choices=container_choices
|
|
)
|
|
disk_choices = ["ami", "ari", "aki", "vhd", "vmdk", "raw", "qcow2",
|
|
"vdi", "iso"]
|
|
parser.add_argument(
|
|
"--disk-format",
|
|
metavar="<disk-format>",
|
|
help="Disk format of image. Acceptable formats: %s" % disk_choices,
|
|
choices=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",
|
|
)
|
|
return parser
|
|
|
|
def take_action(self, parsed_args):
|
|
self.log.debug("take_action(%s)", 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', 'force', 'checksum')
|
|
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
|
|
# 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['protected'] = True
|
|
if parsed_args.unprotected:
|
|
kwargs['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 = utils.find_resource(
|
|
image_client.images,
|
|
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,
|
|
)
|
|
response, body = 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),
|
|
)
|
|
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 sys.stdin.isatty() is not True:
|
|
if parsed_args.stdin:
|
|
if msvcrt:
|
|
msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
|
|
# Send an open file handle to glanceclient so it
|
|
# will do a chunked transfer
|
|
kwargs["data"] = sys.stdin
|
|
else:
|
|
self.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
|
|
|
|
if not kwargs:
|
|
self.log.warning('no arguments specified')
|
|
return {}, {}
|
|
|
|
image = image_client.images.update(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):
|
|
kwargs['data'].close()
|
|
|
|
info = {}
|
|
info.update(image._info)
|
|
return zip(*sorted(six.iteritems(info)))
|
|
|
|
|
|
class ShowImage(show.ShowOne):
|
|
"""Display image details"""
|
|
|
|
log = logging.getLogger(__name__ + ".ShowImage")
|
|
|
|
def get_parser(self, prog_name):
|
|
parser = super(ShowImage, self).get_parser(prog_name)
|
|
parser.add_argument(
|
|
"image",
|
|
metavar="<image>",
|
|
help="Image to display (name or ID)",
|
|
)
|
|
return parser
|
|
|
|
def take_action(self, parsed_args):
|
|
self.log.debug("take_action(%s)", parsed_args)
|
|
|
|
image_client = self.app.client_manager.image
|
|
image = utils.find_resource(
|
|
image_client.images,
|
|
parsed_args.image,
|
|
)
|
|
|
|
info = {}
|
|
info.update(image._info)
|
|
return zip(*sorted(six.iteritems(info)))
|