# Copyright (c) 2013-2014 OpenStack Foundation
# All Rights Reserved.
#
# 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.

from __future__ import print_function

import argparse
import collections
import copy
import os
import warnings

from oslo_utils import strutils
import six

from cinderclient import base
from cinderclient import exceptions
from cinderclient import shell_utils
from cinderclient import utils
from cinderclient.v2 import availability_zones


def _translate_attachments(info):
    attachments = []
    attached_servers = []
    for attachment in info['attachments']:
        attachments.append(attachment['attachment_id'])
        attached_servers.append(attachment['server_id'])
    info.pop('attachments', None)
    info['attachment_ids'] = attachments
    info['attached_servers'] = attached_servers
    return info


@utils.arg('--all-tenants',
           dest='all_tenants',
           metavar='<0|1>',
           nargs='?',
           type=int,
           const=1,
           default=0,
           help='Shows details for all tenants. Admin only.')
@utils.arg('--all_tenants',
           nargs='?',
           type=int,
           const=1,
           help=argparse.SUPPRESS)
@utils.arg('--name',
           metavar='<name>',
           default=None,
           help='Filters results by a name. Default=None.')
@utils.arg('--display-name',
           help=argparse.SUPPRESS)
@utils.arg('--status',
           metavar='<status>',
           default=None,
           help='Filters results by a status. Default=None.')
@utils.arg('--bootable',
           metavar='<True|true|False|false>',
           const=True,
           nargs='?',
           choices=['True', 'true', 'False', 'false'],
           help='Filters results by bootable status. Default=None.')
@utils.arg('--migration_status',
           metavar='<migration_status>',
           default=None,
           help='Filters results by a migration status. Default=None. '
                'Admin only.')
@utils.arg('--metadata',
           nargs='*',
           metavar='<key=value>',
           default=None,
           help='Filters results by a image metadata key and value pair. '
                'Default=None.')
@utils.arg('--marker',
           metavar='<marker>',
           default=None,
           help='Begin returning volumes that appear later in the volume '
                'list than that represented by this volume id. '
                'Default=None.')
@utils.arg('--limit',
           metavar='<limit>',
           default=None,
           help='Maximum number of volumes to return. Default=None.')
@utils.arg('--fields',
           default=None,
           metavar='<fields>',
           help='Comma-separated list of fields to display. '
                'Use the show command to see which fields are available. '
                'Unavailable/non-existent fields will be ignored. '
                'Default=None.')
@utils.arg('--sort_key',
           metavar='<sort_key>',
           default=None,
           help=argparse.SUPPRESS)
@utils.arg('--sort_dir',
           metavar='<sort_dir>',
           default=None,
           help=argparse.SUPPRESS)
@utils.arg('--sort',
           metavar='<key>[:<direction>]',
           default=None,
           help=(('Comma-separated list of sort keys and directions in the '
                  'form of <key>[:<asc|desc>]. '
                  'Valid keys: %s. '
                  'Default=None.') % ', '.join(base.SORT_KEY_VALUES)))
@utils.arg('--tenant',
           type=str,
           dest='tenant',
           nargs='?',
           metavar='<tenant>',
           help='Display information from single tenant (Admin only).')
def do_list(cs, args):
    """Lists all volumes."""
    # NOTE(thingee): Backwards-compatibility with v1 args
    if args.display_name is not None:
        args.name = args.display_name

    all_tenants = 1 if args.tenant else \
        int(os.environ.get("ALL_TENANTS", args.all_tenants))
    search_opts = {
        'all_tenants': all_tenants,
        'project_id': args.tenant,
        'name': args.name,
        'status': args.status,
        'bootable': args.bootable,
        'migration_status': args.migration_status,
        'metadata': (shell_utils.extract_metadata(args) if args.metadata
                     else None),
    }

    # If unavailable/non-existent fields are specified, these fields will
    # be removed from key_list at the print_list() during key validation.
    field_titles = []
    if args.fields:
        for field_title in args.fields.split(','):
            field_titles.append(field_title)

    # --sort_key and --sort_dir deprecated in kilo and is not supported
    # with --sort
    if args.sort and (args.sort_key or args.sort_dir):
        raise exceptions.CommandError(
            'The --sort_key and --sort_dir arguments are deprecated and are '
            'not supported with --sort.')

    volumes = cs.volumes.list(search_opts=search_opts, marker=args.marker,
                              limit=args.limit, sort_key=args.sort_key,
                              sort_dir=args.sort_dir, sort=args.sort)
    shell_utils.translate_volume_keys(volumes)

    # Create a list of servers to which the volume is attached
    for vol in volumes:
        servers = [s.get('server_id') for s in vol.attachments]
        setattr(vol, 'attached_to', ','.join(map(str, servers)))

    if field_titles:
        # Remove duplicate fields
        key_list = ['ID']
        unique_titles = [k for k in collections.OrderedDict.fromkeys(
            [x.title().strip() for x in field_titles]) if k != 'Id']
        key_list.extend(unique_titles)
    else:
        key_list = ['ID', 'Status', 'Name', 'Size', 'Volume Type',
                    'Bootable', 'Attached to']
        # If all_tenants is specified, print
        # Tenant ID as well.
        if search_opts['all_tenants']:
            key_list.insert(1, 'Tenant ID')

    if args.sort_key or args.sort_dir or args.sort:
        sortby_index = None
    else:
        sortby_index = 0
    utils.print_list(volumes, key_list, exclude_unavailable=True,
                     sortby_index=sortby_index)


@utils.arg('volume',
           metavar='<volume>',
           help='Name or ID of volume.')
def do_show(cs, args):
    """Shows volume details."""
    info = dict()
    volume = utils.find_volume(cs, args.volume)
    info.update(volume._info)

    if 'readonly' in info['metadata']:
        info['readonly'] = info['metadata']['readonly']

    info.pop('links', None)
    info = _translate_attachments(info)
    utils.print_dict(info,
                     formatters=['metadata', 'volume_image_metadata',
                                 'attachment_ids', 'attached_servers'])


class CheckSizeArgForCreate(argparse.Action):
    def __call__(self, parser, args, values, option_string=None):
        if ((args.snapshot_id or args.source_volid)
                is None and values is None):
            if not hasattr(args, 'backup_id') or args.backup_id is None:
                parser.error('Size is a required parameter if snapshot '
                             'or source volume or backup is not specified.')
        setattr(args, self.dest, values)


@utils.arg('size',
           metavar='<size>',
           nargs='?',
           type=int,
           action=CheckSizeArgForCreate,
           help='Size of volume, in GiBs. (Required unless '
                'snapshot-id/source-volid is specified).')
@utils.arg('--consisgroup-id',
           metavar='<consistencygroup-id>',
           default=None,
           help='ID of a consistency group where the new volume belongs to. '
                'Default=None.')
@utils.arg('--snapshot-id',
           metavar='<snapshot-id>',
           default=None,
           help='Creates volume from snapshot ID. Default=None.')
@utils.arg('--snapshot_id',
           help=argparse.SUPPRESS)
@utils.arg('--source-volid',
           metavar='<source-volid>',
           default=None,
           help='Creates volume from volume ID. Default=None.')
@utils.arg('--source_volid',
           help=argparse.SUPPRESS)
@utils.arg('--image-id',
           metavar='<image-id>',
           default=None,
           help='Creates volume from image ID. Default=None.')
@utils.arg('--image_id',
           help=argparse.SUPPRESS)
@utils.arg('--image',
           metavar='<image>',
           default=None,
           help='Creates a volume from image (ID or name). Default=None.')
@utils.arg('--image_ref',
           help=argparse.SUPPRESS)
@utils.arg('--name',
           metavar='<name>',
           default=None,
           help='Volume name. Default=None.')
@utils.arg('--display-name',
           help=argparse.SUPPRESS)
@utils.arg('--display_name',
           help=argparse.SUPPRESS)
@utils.arg('--description',
           metavar='<description>',
           default=None,
           help='Volume description. Default=None.')
@utils.arg('--display-description',
           help=argparse.SUPPRESS)
@utils.arg('--display_description',
           help=argparse.SUPPRESS)
@utils.arg('--volume-type',
           metavar='<volume-type>',
           default=None,
           help='Volume type. Default=None.')
@utils.arg('--volume_type',
           help=argparse.SUPPRESS)
@utils.arg('--availability-zone',
           metavar='<availability-zone>',
           default=None,
           help='Availability zone for volume. Default=None.')
@utils.arg('--availability_zone',
           help=argparse.SUPPRESS)
@utils.arg('--metadata',
           nargs='*',
           metavar='<key=value>',
           default=None,
           help='Metadata key and value pairs. Default=None.')
@utils.arg('--hint',
           metavar='<key=value>',
           dest='scheduler_hints',
           action='append',
           default=[],
           help='Scheduler hint, similar to nova. Repeat option to set '
                'multiple hints. Values with the same key will be stored '
                'as a list.')
@utils.arg('--allow-multiattach',
           dest='multiattach',
           action="store_true",
           help=('Allow volume to be attached more than once. (DEPRECATED)'
                 ' Default=False'),
           default=False)
def do_create(cs, args):
    """Creates a volume."""
    # NOTE(thingee): Backwards-compatibility with v1 args
    if args.display_name is not None:
        args.name = args.display_name

    if args.display_description is not None:
        args.description = args.display_description

    volume_metadata = None
    if args.metadata is not None:
        volume_metadata = shell_utils.extract_metadata(args)

    # NOTE(N.S.): take this piece from novaclient
    hints = {}
    if args.scheduler_hints:
        for hint in args.scheduler_hints:
            key, _sep, value = hint.partition('=')
            # NOTE(vish): multiple copies of same hint will
            #             result in a list of values
            if key in hints:
                if isinstance(hints[key], six.string_types):
                    hints[key] = [hints[key]]
                hints[key] += [value]
            else:
                hints[key] = value
    # NOTE(N.S.): end of taken piece

    # Keep backward compatibility with image_id, favoring explicit ID
    image_ref = args.image_id or args.image or args.image_ref

    volume = cs.volumes.create(args.size,
                               args.consisgroup_id,
                               args.snapshot_id,
                               args.source_volid,
                               args.name,
                               args.description,
                               args.volume_type,
                               availability_zone=args.availability_zone,
                               imageRef=image_ref,
                               metadata=volume_metadata,
                               scheduler_hints=hints,
                               multiattach=args.multiattach)

    info = dict()
    volume = cs.volumes.get(volume.id)
    info.update(volume._info)

    if 'readonly' in info['metadata']:
        info['readonly'] = info['metadata']['readonly']

    info.pop('links', None)
    info = _translate_attachments(info)
    utils.print_dict(info)


@utils.arg('--cascade',
           action='store_true',
           default=False,
           help='Remove any snapshots along with volume. Default=False.')
@utils.arg('volume',
           metavar='<volume>', nargs='+',
           help='Name or ID of volume or volumes to delete.')
def do_delete(cs, args):
    """Removes one or more volumes."""
    failure_count = 0
    for volume in args.volume:
        try:
            utils.find_volume(cs, volume).delete(cascade=args.cascade)
            print("Request to delete volume %s has been accepted." % (volume))
        except Exception as e:
            failure_count += 1
            print("Delete for volume %s failed: %s" % (volume, e))
    if failure_count == len(args.volume):
        raise exceptions.CommandError("Unable to delete any of the specified "
                                      "volumes.")


@utils.arg('volume',
           metavar='<volume>', nargs='+',
           help='Name or ID of volume or volumes to delete.')
def do_force_delete(cs, args):
    """Attempts force-delete of volume, regardless of state."""
    failure_count = 0
    for volume in args.volume:
        try:
            utils.find_volume(cs, volume).force_delete()
        except Exception as e:
            failure_count += 1
            print("Delete for volume %s failed: %s" % (volume, e))
    if failure_count == len(args.volume):
        raise exceptions.CommandError("Unable to force delete any of the "
                                      "specified volumes.")


@utils.arg('volume', metavar='<volume>', nargs='+',
           help='Name or ID of volume to modify.')
@utils.arg('--state', metavar='<state>', default=None,
           help=('The state to assign to the volume. Valid values are '
                 '"available", "error", "creating", "deleting", "in-use", '
                 '"attaching", "detaching", "error_deleting" and '
                 '"maintenance". '
                 'NOTE: This command simply changes the state of the '
                 'Volume in the DataBase with no regard to actual status, '
                 'exercise caution when using. Default=None, that means the '
                 'state is unchanged.'))
@utils.arg('--attach-status', metavar='<attach-status>', default=None,
           help=('The attach status to assign to the volume in the DataBase, '
                 'with no regard to the actual status. Valid values are '
                 '"attached" and "detached". Default=None, that means the '
                 'status is unchanged.'))
@utils.arg('--reset-migration-status',
           action='store_true',
           help=('Clears the migration status of the volume in the DataBase '
                 'that indicates the volume is source or destination of '
                 'volume migration, with no regard to the actual status.'))
def do_reset_state(cs, args):
    """Explicitly updates the volume state in the Cinder database.

    Note that this does not affect whether the volume is actually attached to
    the Nova compute host or instance and can result in an unusable volume.
    Being a database change only, this has no impact on the true state of the
    volume and may not match the actual state. This can render a volume
    unusable in the case of change to the 'available' state.
    """
    failure_flag = False
    migration_status = 'none' if args.reset_migration_status else None
    if not (args.state or args.attach_status or migration_status):
        # Nothing specified, default to resetting state
        args.state = 'available'

    for volume in args.volume:
        try:
            utils.find_volume(cs, volume).reset_state(args.state,
                                                      args.attach_status,
                                                      migration_status)
        except Exception as e:
            failure_flag = True
            msg = "Reset state for volume %s failed: %s" % (volume, e)
            print(msg)

    if failure_flag:
        msg = "Unable to reset the state for the specified volume(s)."
        raise exceptions.CommandError(msg)


@utils.arg('volume',
           metavar='<volume>',
           help='Name or ID of volume to rename.')
@utils.arg('name',
           nargs='?',
           metavar='<name>',
           help='New name for volume.')
@utils.arg('--description', metavar='<description>',
           help='Volume description. Default=None.',
           default=None)
@utils.arg('--display-description',
           help=argparse.SUPPRESS)
@utils.arg('--display_description',
           help=argparse.SUPPRESS)
def do_rename(cs, args):
    """Renames a volume."""
    kwargs = {}

    if args.name is not None:
        kwargs['name'] = args.name
    if args.display_description is not None:
        kwargs['description'] = args.display_description
    elif args.description is not None:
        kwargs['description'] = args.description

    if not any(kwargs):
        msg = 'Must supply either name or description.'
        raise exceptions.ClientException(code=1, message=msg)

    utils.find_volume(cs, args.volume).update(**kwargs)


@utils.arg('volume',
           metavar='<volume>',
           help='Name or ID of volume for which to update metadata.')
@utils.arg('action',
           metavar='<action>',
           choices=['set', 'unset'],
           help='The action. Valid values are "set" or "unset."')
@utils.arg('metadata',
           metavar='<key=value>',
           nargs='+',
           default=[],
           help='Metadata key and value pair to set or unset. '
                'For unset, specify only the key.')
def do_metadata(cs, args):
    """Sets or deletes volume metadata."""
    volume = utils.find_volume(cs, args.volume)
    metadata = shell_utils.extract_metadata(args)

    if args.action == 'set':
        cs.volumes.set_metadata(volume, metadata)
    elif args.action == 'unset':
        # NOTE(zul): Make sure py2/py3 sorting is the same
        cs.volumes.delete_metadata(volume, sorted(metadata.keys(),
                                   reverse=True))


@utils.arg('volume',
           metavar='<volume>',
           help='Name or ID of volume for which to update metadata.')
@utils.arg('action',
           metavar='<action>',
           choices=['set', 'unset'],
           help="The action. Valid values are 'set' or 'unset.'")
@utils.arg('metadata',
           metavar='<key=value>',
           nargs='+',
           default=[],
           help='Metadata key and value pair to set or unset. '
           'For unset, specify only the key.')
def do_image_metadata(cs, args):
    """Sets or deletes volume image metadata."""
    volume = utils.find_volume(cs, args.volume)
    metadata = shell_utils.extract_metadata(args)

    if args.action == 'set':
        cs.volumes.set_image_metadata(volume, metadata)
    elif args.action == 'unset':
        cs.volumes.delete_image_metadata(volume, sorted(metadata.keys(),
                                         reverse=True))


@utils.arg('--all-tenants',
           dest='all_tenants',
           metavar='<0|1>',
           nargs='?',
           type=int,
           const=1,
           default=0,
           help='Shows details for all tenants. Admin only.')
@utils.arg('--all_tenants',
           nargs='?',
           type=int,
           const=1,
           help=argparse.SUPPRESS)
@utils.arg('--name',
           metavar='<name>',
           default=None,
           help='Filters results by a name. Default=None.')
@utils.arg('--display-name',
           help=argparse.SUPPRESS)
@utils.arg('--display_name',
           help=argparse.SUPPRESS)
@utils.arg('--status',
           metavar='<status>',
           default=None,
           help='Filters results by a status. Default=None.')
@utils.arg('--volume-id',
           metavar='<volume-id>',
           default=None,
           help='Filters results by a volume ID. Default=None.')
@utils.arg('--volume_id',
           help=argparse.SUPPRESS)
@utils.arg('--marker',
           metavar='<marker>',
           default=None,
           help='Begin returning snapshots that appear later in the snapshot '
                'list than that represented by this id. '
                'Default=None.')
@utils.arg('--limit',
           metavar='<limit>',
           default=None,
           help='Maximum number of snapshots to return. Default=None.')
@utils.arg('--sort',
           metavar='<key>[:<direction>]',
           default=None,
           help=(('Comma-separated list of sort keys and directions in the '
                  'form of <key>[:<asc|desc>]. '
                  'Valid keys: %s. '
                  'Default=None.') % ', '.join(base.SORT_KEY_VALUES)))
@utils.arg('--tenant',
           type=str,
           dest='tenant',
           nargs='?',
           metavar='<tenant>',
           help='Display information from single tenant (Admin only).')
def do_snapshot_list(cs, args):
    """Lists all snapshots."""
    all_tenants = (1 if args.tenant else
                   int(os.environ.get("ALL_TENANTS", args.all_tenants)))

    if args.display_name is not None:
        args.name = args.display_name

    search_opts = {
        'all_tenants': all_tenants,
        'name': args.name,
        'status': args.status,
        'volume_id': args.volume_id,
        'project_id': args.tenant,
    }

    snapshots = cs.volume_snapshots.list(search_opts=search_opts,
                                         marker=args.marker,
                                         limit=args.limit,
                                         sort=args.sort)
    shell_utils.translate_volume_snapshot_keys(snapshots)
    if args.sort:
        sortby_index = None
    else:
        sortby_index = 0

    utils.print_list(snapshots,
                     ['ID', 'Volume ID', 'Status', 'Name', 'Size'],
                     sortby_index=sortby_index)


@utils.arg('snapshot',
           metavar='<snapshot>',
           help='Name or ID of snapshot.')
def do_snapshot_show(cs, args):
    """Shows snapshot details."""
    snapshot = shell_utils.find_volume_snapshot(cs, args.snapshot)
    shell_utils.print_volume_snapshot(snapshot)


@utils.arg('volume',
           metavar='<volume>',
           help='Name or ID of volume to snapshot.')
@utils.arg('--force',
           metavar='<True|False>',
           const=True,
           nargs='?',
           default=False,
           help='Allows or disallows snapshot of '
           'a volume when the volume is attached to an instance. '
           'If set to True, ignores the current status of the '
           'volume when attempting to snapshot it rather '
           'than forcing it to be available. '
           'Default=False.')
@utils.arg('--name',
           metavar='<name>',
           default=None,
           help='Snapshot name. Default=None.')
@utils.arg('--display-name',
           help=argparse.SUPPRESS)
@utils.arg('--display_name',
           help=argparse.SUPPRESS)
@utils.arg('--description',
           metavar='<description>',
           default=None,
           help='Snapshot description. Default=None.')
@utils.arg('--display-description',
           help=argparse.SUPPRESS)
@utils.arg('--display_description',
           help=argparse.SUPPRESS)
@utils.arg('--metadata',
           nargs='*',
           metavar='<key=value>',
           default=None,
           help='Snapshot metadata key and value pairs. Default=None.')
def do_snapshot_create(cs, args):
    """Creates a snapshot."""
    if args.display_name is not None:
        args.name = args.display_name

    if args.display_description is not None:
        args.description = args.display_description

    snapshot_metadata = None
    if args.metadata is not None:
        snapshot_metadata = shell_utils.extract_metadata(args)

    volume = utils.find_volume(cs, args.volume)
    snapshot = cs.volume_snapshots.create(volume.id,
                                          args.force,
                                          args.name,
                                          args.description,
                                          metadata=snapshot_metadata)
    shell_utils.print_volume_snapshot(snapshot)


@utils.arg('snapshot',
           metavar='<snapshot>', nargs='+',
           help='Name or ID of the snapshot(s) to delete.')
@utils.arg('--force',
           action="store_true",
           help='Allows deleting snapshot of a volume '
           'when its status is other than "available" or "error". '
           'Default=False.')
def do_snapshot_delete(cs, args):
    """Removes one or more snapshots."""
    failure_count = 0

    for snapshot in args.snapshot:
        try:
            shell_utils.find_volume_snapshot(cs, snapshot).delete(args.force)
        except Exception as e:
            failure_count += 1
            print("Delete for snapshot %s failed: %s" % (snapshot, e))
    if failure_count == len(args.snapshot):
        raise exceptions.CommandError("Unable to delete any of the specified "
                                      "snapshots.")


@utils.arg('snapshot', metavar='<snapshot>',
           help='Name or ID of snapshot.')
@utils.arg('name', nargs='?', metavar='<name>',
           help='New name for snapshot.')
@utils.arg('--description', metavar='<description>',
           default=None,
           help='Snapshot description. Default=None.')
@utils.arg('--display-description',
           help=argparse.SUPPRESS)
@utils.arg('--display_description',
           help=argparse.SUPPRESS)
def do_snapshot_rename(cs, args):
    """Renames a snapshot."""
    kwargs = {}

    if args.name is not None:
        kwargs['name'] = args.name

    if args.description is not None:
        kwargs['description'] = args.description
    elif args.display_description is not None:
        kwargs['description'] = args.display_description

    if not any(kwargs):
        msg = 'Must supply either name or description.'
        raise exceptions.ClientException(code=1, message=msg)

    shell_utils.find_volume_snapshot(cs, args.snapshot).update(**kwargs)
    print("Request to rename snapshot '%s' has been accepted." % (
        args.snapshot))


@utils.arg('snapshot', metavar='<snapshot>', nargs='+',
           help='Name or ID of snapshot to modify.')
@utils.arg('--state', metavar='<state>',
           default='available',
           help=('The state to assign to the snapshot. Valid values are '
                 '"available", "error", "creating", "deleting", and '
                 '"error_deleting". NOTE: This command simply changes '
                 'the state of the Snapshot in the DataBase with no regard '
                 'to actual status, exercise caution when using. '
                 'Default=available.'))
def do_snapshot_reset_state(cs, args):
    """Explicitly updates the snapshot state."""
    failure_count = 0

    single = (len(args.snapshot) == 1)

    for snapshot in args.snapshot:
        try:
            shell_utils.find_volume_snapshot(
                cs, snapshot).reset_state(args.state)
        except Exception as e:
            failure_count += 1
            msg = "Reset state for snapshot %s failed: %s" % (snapshot, e)
            if not single:
                print(msg)

    if failure_count == len(args.snapshot):
        if not single:
            msg = ("Unable to reset the state for any of the specified "
                   "snapshots.")
        raise exceptions.CommandError(msg)


def do_type_list(cs, args):
    """Lists available 'volume types'.

    (Only admin and tenant users will see private types)
    """
    vtypes = cs.volume_types.list()
    shell_utils.print_volume_type_list(vtypes)


def do_type_default(cs, args):
    """List the default volume type."""
    vtype = cs.volume_types.default()
    shell_utils.print_volume_type_list([vtype])


@utils.arg('volume_type',
           metavar='<volume_type>',
           help='Name or ID of the volume type.')
def do_type_show(cs, args):
    """Show volume type details."""
    vtype = shell_utils.find_vtype(cs, args.volume_type)
    info = dict()
    info.update(vtype._info)

    info.pop('links', None)
    utils.print_dict(info, formatters=['extra_specs'])


@utils.arg('id',
           metavar='<id>',
           help='ID of the volume type.')
@utils.arg('--name',
           metavar='<name>',
           help='Name of the volume type.')
@utils.arg('--description',
           metavar='<description>',
           help='Description of the volume type.')
@utils.arg('--is-public',
           metavar='<is-public>',
           help='Make type accessible to the public or not.')
def do_type_update(cs, args):
    """Updates volume type name, description, and/or is_public."""
    is_public = args.is_public
    if args.name is None and args.description is None and is_public is None:
        raise exceptions.CommandError('Specify a new type name, description, '
                                      'is_public or a combination thereof.')

    if is_public is not None:
        is_public = strutils.bool_from_string(args.is_public, strict=True)
    vtype = cs.volume_types.update(args.id, args.name, args.description,
                                   is_public)
    shell_utils.print_volume_type_list([vtype])


def do_extra_specs_list(cs, args):
    """Lists current volume types and extra specs."""
    vtypes = cs.volume_types.list()
    utils.print_list(vtypes, ['ID', 'Name', 'extra_specs'])


@utils.arg('name',
           metavar='<name>',
           help='Name of new volume type.')
@utils.arg('--description',
           metavar='<description>',
           help='Description of new volume type.')
@utils.arg('--is-public',
           metavar='<is-public>',
           default=True,
           help='Make type accessible to the public (default true).')
def do_type_create(cs, args):
    """Creates a volume type."""
    is_public = strutils.bool_from_string(args.is_public, strict=True)
    vtype = cs.volume_types.create(args.name, args.description, is_public)
    shell_utils.print_volume_type_list([vtype])


@utils.arg('vol_type',
           metavar='<vol_type>', nargs='+',
           help='Name or ID of volume type or types to delete.')
def do_type_delete(cs, args):
    """Deletes volume type or types."""
    failure_count = 0
    for vol_type in args.vol_type:
        try:
            vtype = shell_utils.find_volume_type(cs, vol_type)
            cs.volume_types.delete(vtype)
            print("Request to delete volume type %s has been accepted."
                  % (vol_type))
        except Exception as e:
            failure_count += 1
            print("Delete for volume type %s failed: %s" % (vol_type, e))
    if failure_count == len(args.vol_type):
        raise exceptions.CommandError("Unable to delete any of the "
                                      "specified types.")


@utils.arg('vtype',
           metavar='<vtype>',
           help='Name or ID of volume type.')
@utils.arg('action',
           metavar='<action>',
           choices=['set', 'unset'],
           help='The action. Valid values are "set" or "unset."')
@utils.arg('metadata',
           metavar='<key=value>',
           nargs='+',
           default=[],
           help='The extra specs key and value pair to set or unset. '
                'For unset, specify only the key.')
def do_type_key(cs, args):
    """Sets or unsets extra_spec for a volume type."""
    vtype = shell_utils.find_volume_type(cs, args.vtype)
    keypair = shell_utils.extract_metadata(args)

    if args.action == 'set':
        vtype.set_keys(keypair)
    elif args.action == 'unset':
        vtype.unset_keys(list(keypair))


@utils.arg('--volume-type', metavar='<volume_type>', required=True,
           help='Filter results by volume type name or ID.')
def do_type_access_list(cs, args):
    """Print access information about the given volume type."""
    volume_type = shell_utils.find_volume_type(cs, args.volume_type)
    if volume_type.is_public:
        raise exceptions.CommandError("Failed to get access list "
                                      "for public volume type.")
    access_list = cs.volume_type_access.list(volume_type)

    columns = ['Volume_type_ID', 'Project_ID']
    utils.print_list(access_list, columns)


@utils.arg('--volume-type', metavar='<volume_type>', required=True,
           help='Volume type name or ID to add access for the given project.')
@utils.arg('--project-id', metavar='<project_id>', required=True,
           help='Project ID to add volume type access for.')
def do_type_access_add(cs, args):
    """Adds volume type access for the given project."""
    vtype = shell_utils.find_volume_type(cs, args.volume_type)
    cs.volume_type_access.add_project_access(vtype, args.project_id)


@utils.arg('--volume-type', metavar='<volume_type>', required=True,
           help=('Volume type name or ID to remove access '
                 'for the given project.'))
@utils.arg('--project-id', metavar='<project_id>', required=True,
           help='Project ID to remove volume type access for.')
def do_type_access_remove(cs, args):
    """Removes volume type access for the given project."""
    vtype = shell_utils.find_volume_type(cs, args.volume_type)
    cs.volume_type_access.remove_project_access(
        vtype, args.project_id)


def do_endpoints(cs, args):
    """Discovers endpoints registered by authentication service."""
    warnings.warn(
        "``cinder endpoints`` is deprecated, use ``openstack catalog list`` "
        "instead. The ``cinder endpoints`` command may be removed in the P "
        "release or next major release of cinderclient (v2.0.0 or greater).")
    catalog = cs.client.service_catalog.catalog
    for e in catalog:
        utils.print_dict(e['endpoints'][0], e['name'])


def do_credentials(cs, args):
    """Shows user credentials returned from auth."""
    warnings.warn(
        "``cinder credentials`` is deprecated, use ``openstack token issue`` "
        "indead.")


@utils.arg('tenant',
           metavar='<tenant_id>',
           help='ID of tenant for which to list quotas.')
def do_quota_show(cs, args):
    """Lists quotas for a tenant."""

    shell_utils.quota_show(cs.quotas.get(args.tenant))


@utils.arg('tenant', metavar='<tenant_id>',
           help='ID of tenant for which to list quota usage.')
def do_quota_usage(cs, args):
    """Lists quota usage for a tenant."""

    shell_utils.quota_usage_show(cs.quotas.get(args.tenant, usage=True))


@utils.arg('tenant',
           metavar='<tenant_id>',
           help='ID of tenant for which to list quota defaults.')
def do_quota_defaults(cs, args):
    """Lists default quotas for a tenant."""

    shell_utils.quota_show(cs.quotas.defaults(args.tenant))


@utils.arg('tenant',
           metavar='<tenant_id>',
           help='ID of tenant for which to set quotas.')
@utils.arg('--volumes',
           metavar='<volumes>',
           type=int, default=None,
           help='The new "volumes" quota value. Default=None.')
@utils.arg('--snapshots',
           metavar='<snapshots>',
           type=int, default=None,
           help='The new "snapshots" quota value. Default=None.')
@utils.arg('--gigabytes',
           metavar='<gigabytes>',
           type=int, default=None,
           help='The new "gigabytes" quota value. Default=None.')
@utils.arg('--backups',
           metavar='<backups>',
           type=int, default=None,
           help='The new "backups" quota value. Default=None.')
@utils.arg('--backup-gigabytes',
           metavar='<backup_gigabytes>',
           type=int, default=None,
           help='The new "backup_gigabytes" quota value. Default=None.')
@utils.arg('--volume-type',
           metavar='<volume_type_name>',
           default=None,
           help='Volume type. Default=None.')
@utils.arg('--per-volume-gigabytes',
           metavar='<per_volume_gigabytes>',
           type=int, default=None,
           help='Set max volume size limit. Default=None.')
def do_quota_update(cs, args):
    """Updates quotas for a tenant."""

    shell_utils.quota_update(cs.quotas, args.tenant, args)


@utils.arg('tenant', metavar='<tenant_id>',
           help='UUID of tenant to delete the quotas for.')
def do_quota_delete(cs, args):
    """Delete the quotas for a tenant."""

    cs.quotas.delete(args.tenant)


@utils.arg('class_name',
           metavar='<class>',
           help='Name of quota class for which to list quotas.')
def do_quota_class_show(cs, args):
    """Lists quotas for a quota class."""

    shell_utils.quota_show(cs.quota_classes.get(args.class_name))


@utils.arg('class_name',
           metavar='<class_name>',
           help='Name of quota class for which to set quotas.')
@utils.arg('--volumes',
           metavar='<volumes>',
           type=int, default=None,
           help='The new "volumes" quota value. Default=None.')
@utils.arg('--snapshots',
           metavar='<snapshots>',
           type=int, default=None,
           help='The new "snapshots" quota value. Default=None.')
@utils.arg('--gigabytes',
           metavar='<gigabytes>',
           type=int, default=None,
           help='The new "gigabytes" quota value. Default=None.')
@utils.arg('--backups',
           metavar='<backups>',
           type=int, default=None,
           help='The new "backups" quota value. Default=None.')
@utils.arg('--backup-gigabytes',
           metavar='<backup_gigabytes>',
           type=int, default=None,
           help='The new "backup_gigabytes" quota value. Default=None.')
@utils.arg('--volume-type',
           metavar='<volume_type_name>',
           default=None,
           help='Volume type. Default=None.')
@utils.arg('--per-volume-gigabytes',
           metavar='<per_volume_gigabytes>',
           type=int, default=None,
           help='Set max volume size limit. Default=None.')
def do_quota_class_update(cs, args):
    """Updates quotas for a quota class."""

    shell_utils.quota_update(cs.quota_classes, args.class_name, args)


@utils.arg('tenant',
           metavar='<tenant_id>',
           nargs='?',
           default=None,
           help='Display information for a single tenant (Admin only).')
def do_absolute_limits(cs, args):
    """Lists absolute limits for a user."""
    limits = cs.limits.get(args.tenant).absolute
    columns = ['Name', 'Value']
    utils.print_list(limits, columns)


@utils.arg('tenant',
           metavar='<tenant_id>',
           nargs='?',
           default=None,
           help='Display information for a single tenant (Admin only).')
def do_rate_limits(cs, args):
    """Lists rate limits for a user."""
    limits = cs.limits.get(args.tenant).rate
    columns = ['Verb', 'URI', 'Value', 'Remain', 'Unit', 'Next_Available']
    utils.print_list(limits, columns)


@utils.arg('volume',
           metavar='<volume>',
           help='Name or ID of volume to snapshot.')
@utils.arg('--force',
           metavar='<True|False>',
           const=True,
           nargs='?',
           default=False,
           help='Enables or disables upload of '
           'a volume that is attached to an instance. '
           'Default=False. '
           'This option may not be supported by your cloud.')
@utils.arg('--container-format',
           metavar='<container-format>',
           default='bare',
           help='Container format type. '
                'Default is bare.')
@utils.arg('--container_format',
           help=argparse.SUPPRESS)
@utils.arg('--disk-format',
           metavar='<disk-format>',
           default='raw',
           help='Disk format type. '
                'Default is raw.')
@utils.arg('--disk_format',
           help=argparse.SUPPRESS)
@utils.arg('image_name',
           metavar='<image-name>',
           help='The new image name.')
@utils.arg('--image_name',
           help=argparse.SUPPRESS)
def do_upload_to_image(cs, args):
    """Uploads volume to Image Service as an image."""
    volume = utils.find_volume(cs, args.volume)
    shell_utils.print_volume_image(
        volume.upload_to_image(args.force,
                               args.image_name,
                               args.container_format,
                               args.disk_format))


@utils.arg('volume', metavar='<volume>', help='ID of volume to migrate.')
@utils.arg('host', metavar='<host>', help='Destination host. Takes the form: '
                                          'host@backend-name#pool')
@utils.arg('--force-host-copy', metavar='<True|False>',
           choices=['True', 'False'],
           required=False,
           const=True,
           nargs='?',
           default=False,
           help='Enables or disables generic host-based '
           'force-migration, which bypasses driver '
           'optimizations. Default=False.')
@utils.arg('--lock-volume', metavar='<True|False>',
           choices=['True', 'False'],
           required=False,
           const=True,
           nargs='?',
           default=False,
           help='Enables or disables the termination of volume migration '
           'caused by other commands. This option applies to the '
           'available volume. True means it locks the volume '
           'state and does not allow the migration to be aborted. The '
           'volume status will be in maintenance during the '
           'migration. False means it allows the volume migration '
           'to be aborted. The volume status is still in the original '
           'status. Default=False.')
def do_migrate(cs, args):
    """Migrates volume to a new host."""
    volume = utils.find_volume(cs, args.volume)
    try:
        volume.migrate_volume(args.host, args.force_host_copy,
                              args.lock_volume)
        print("Request to migrate volume %s has been accepted." % (volume.id))
    except Exception as e:
        print("Migration for volume %s failed: %s." % (volume.id,
                                                       six.text_type(e)))


@utils.arg('volume', metavar='<volume>',
           help='Name or ID of volume for which to modify type.')
@utils.arg('new_type', metavar='<volume-type>', help='New volume type.')
@utils.arg('--migration-policy', metavar='<never|on-demand>', required=False,
           choices=['never', 'on-demand'], default='never',
           help='Migration policy during retype of volume.')
def do_retype(cs, args):
    """Changes the volume type for a volume."""
    volume = utils.find_volume(cs, args.volume)
    volume.retype(args.new_type, args.migration_policy)


@utils.arg('volume', metavar='<volume>',
           help='Name or ID of volume to backup.')
@utils.arg('--container', metavar='<container>',
           default=None,
           help='Backup container name. Default=None.')
@utils.arg('--display-name',
           help=argparse.SUPPRESS)
@utils.arg('--name', metavar='<name>',
           default=None,
           help='Backup name. Default=None.')
@utils.arg('--display-description',
           help=argparse.SUPPRESS)
@utils.arg('--description',
           metavar='<description>',
           default=None,
           help='Backup description. Default=None.')
@utils.arg('--incremental',
           action='store_true',
           help='Incremental backup. Default=False.',
           default=False)
@utils.arg('--force',
           action='store_true',
           help='Allows or disallows backup of a volume '
           'when the volume is attached to an instance. '
           'If set to True, backs up the volume whether '
           'its status is "available" or "in-use". The backup '
           'of an "in-use" volume means your data is crash '
           'consistent. Default=False.',
           default=False)
@utils.arg('--snapshot-id',
           metavar='<snapshot-id>',
           default=None,
           help='ID of snapshot to backup. Default=None.')
def do_backup_create(cs, args):
    """Creates a volume backup."""
    if args.display_name is not None:
        args.name = args.display_name

    if args.display_description is not None:
        args.description = args.display_description

    volume = utils.find_volume(cs, args.volume)
    backup = cs.backups.create(volume.id,
                               args.container,
                               args.name,
                               args.description,
                               args.incremental,
                               args.force,
                               args.snapshot_id)

    info = {"volume_id": volume.id}
    info.update(backup._info)

    if 'links' in info:
        info.pop('links')

    utils.print_dict(info)


@utils.arg('backup', metavar='<backup>', help='Name or ID of backup.')
def do_backup_show(cs, args):
    """Shows backup details."""
    backup = shell_utils.find_backup(cs, args.backup)
    info = dict()
    info.update(backup._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('--all-tenants',
           metavar='<all_tenants>',
           nargs='?',
           type=int,
           const=1,
           default=0,
           help='Shows details for all tenants. Admin only.')
@utils.arg('--all_tenants',
           nargs='?',
           type=int,
           const=1,
           help=argparse.SUPPRESS)
@utils.arg('--name',
           metavar='<name>',
           default=None,
           help='Filters results by a name. Default=None.')
@utils.arg('--status',
           metavar='<status>',
           default=None,
           help='Filters results by a status. Default=None.')
@utils.arg('--volume-id',
           metavar='<volume-id>',
           default=None,
           help='Filters results by a volume ID. Default=None.')
@utils.arg('--volume_id',
           help=argparse.SUPPRESS)
@utils.arg('--marker',
           metavar='<marker>',
           default=None,
           help='Begin returning backups that appear later in the backup '
                'list than that represented by this id. '
                'Default=None.')
@utils.arg('--limit',
           metavar='<limit>',
           default=None,
           help='Maximum number of backups to return. Default=None.')
@utils.arg('--sort',
           metavar='<key>[:<direction>]',
           default=None,
           help=(('Comma-separated list of sort keys and directions in the '
                  'form of <key>[:<asc|desc>]. '
                  'Valid keys: %s. '
                  'Default=None.') % ', '.join(base.SORT_KEY_VALUES)))
def do_backup_list(cs, args):
    """Lists all backups."""

    search_opts = {
        'all_tenants': args.all_tenants,
        'name': args.name,
        'status': args.status,
        'volume_id': args.volume_id,
    }

    backups = cs.backups.list(search_opts=search_opts,
                              marker=args.marker,
                              limit=args.limit,
                              sort=args.sort)
    shell_utils.translate_volume_snapshot_keys(backups)
    columns = ['ID', 'Volume ID', 'Status', 'Name', 'Size', 'Object Count',
               'Container']
    if args.sort:
        sortby_index = None
    else:
        sortby_index = 0
    utils.print_list(backups, columns, sortby_index=sortby_index)


@utils.arg('--force',
           action="store_true",
           help='Allows deleting backup of a volume '
           'when its status is other than "available" or "error". '
           'Default=False.')
@utils.arg('backup', metavar='<backup>', nargs='+',
           help='Name or ID of backup(s) to delete.')
def do_backup_delete(cs, args):
    """Removes one or more backups."""
    failure_count = 0
    for backup in args.backup:
        try:
            shell_utils.find_backup(cs, backup).delete(args.force)
            print("Request to delete backup %s has been accepted." % (backup))
        except Exception as e:
            failure_count += 1
            print("Delete for backup %s failed: %s" % (backup, e))
    if failure_count == len(args.backup):
        raise exceptions.CommandError("Unable to delete any of the specified "
                                      "backups.")


@utils.arg('backup', metavar='<backup>',
           help='Name or ID of backup to restore.')
@utils.arg('--volume-id', metavar='<volume>',
           default=None,
           help=argparse.SUPPRESS)
@utils.arg('--volume', metavar='<volume>',
           default=None,
           help='Name or ID of existing volume to which to restore. '
           'This is mutually exclusive with --name and takes priority. '
           'Default=None.')
@utils.arg('--name', metavar='<name>',
           default=None,
           help='Use the name for new volume creation to restore. '
           'This is mutually exclusive with --volume (or the deprecated '
           '--volume-id) and --volume (or --volume-id) takes priority. '
           'Default=None.')
def do_backup_restore(cs, args):
    """Restores a backup."""
    vol = args.volume or args.volume_id
    if vol:
        volume_id = utils.find_volume(cs, vol).id
        if args.name:
            args.name = None
            print('Mutually exclusive options are specified simultaneously: '
                  '"--volume (or the deprecated --volume-id) and --name". '
                  'The --volume (or --volume-id) option takes priority.')
    else:
        volume_id = None

    backup = shell_utils.find_backup(cs, args.backup)
    restore = cs.restores.restore(backup.id, volume_id, args.name)

    info = {"backup_id": backup.id}
    info.update(restore._info)

    info.pop('links', None)

    utils.print_dict(info)


@utils.arg('backup', metavar='<backup>',
           help='ID of the backup to export.')
def do_backup_export(cs, args):
    """Export backup metadata record."""
    info = cs.backups.export_record(args.backup)
    utils.print_dict(info)


@utils.arg('backup_service', metavar='<backup_service>',
           help='Backup service to use for importing the backup.')
@utils.arg('backup_url', metavar='<backup_url>',
           help='Backup URL for importing the backup metadata.')
def do_backup_import(cs, args):
    """Import backup metadata record."""
    info = cs.backups.import_record(args.backup_service, args.backup_url)
    info.pop('links', None)

    utils.print_dict(info)


@utils.arg('backup', metavar='<backup>', nargs='+',
           help='Name or ID of the backup to modify.')
@utils.arg('--state', metavar='<state>',
           default='available',
           help='The state to assign to the backup. Valid values are '
                '"available", "error". Default=available.')
def do_backup_reset_state(cs, args):
    """Explicitly updates the backup state."""
    failure_count = 0

    single = (len(args.backup) == 1)

    for backup in args.backup:
        try:
            shell_utils.find_backup(cs, backup).reset_state(args.state)
            print("Request to update backup '%s' has been accepted." % backup)
        except Exception as e:
            failure_count += 1
            msg = "Reset state for backup %s failed: %s" % (backup, e)
            if not single:
                print(msg)

    if failure_count == len(args.backup):
        if not single:
            msg = ("Unable to reset the state for any of the specified "
                   "backups.")
        raise exceptions.CommandError(msg)


@utils.arg('volume', metavar='<volume>',
           help='Name or ID of volume to transfer.')
@utils.arg('--name',
           metavar='<name>',
           default=None,
           help='Transfer name. Default=None.')
@utils.arg('--display-name',
           help=argparse.SUPPRESS)
def do_transfer_create(cs, args):
    """Creates a volume transfer."""
    if args.display_name is not None:
        args.name = args.display_name

    volume = utils.find_volume(cs, args.volume)
    transfer = cs.transfers.create(volume.id,
                                   args.name)
    info = dict()
    info.update(transfer._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('transfer', metavar='<transfer>',
           help='Name or ID of transfer to delete.')
def do_transfer_delete(cs, args):
    """Undoes a transfer."""
    transfer = shell_utils.find_transfer(cs, args.transfer)
    transfer.delete()


@utils.arg('transfer', metavar='<transfer>',
           help='ID of transfer to accept.')
@utils.arg('auth_key', metavar='<auth_key>',
           help='Authentication key of transfer to accept.')
def do_transfer_accept(cs, args):
    """Accepts a volume transfer."""
    transfer = cs.transfers.accept(args.transfer, args.auth_key)
    info = dict()
    info.update(transfer._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('--all-tenants',
           dest='all_tenants',
           metavar='<0|1>',
           nargs='?',
           type=int,
           const=1,
           default=0,
           help='Shows details for all tenants. Admin only.')
@utils.arg('--all_tenants',
           nargs='?',
           type=int,
           const=1,
           help=argparse.SUPPRESS)
def do_transfer_list(cs, args):
    """Lists all transfers."""
    all_tenants = int(os.environ.get("ALL_TENANTS", args.all_tenants))
    search_opts = {
        'all_tenants': all_tenants,
    }
    transfers = cs.transfers.list(search_opts=search_opts)
    columns = ['ID', 'Volume ID', 'Name']
    utils.print_list(transfers, columns)


@utils.arg('transfer', metavar='<transfer>',
           help='Name or ID of transfer to accept.')
def do_transfer_show(cs, args):
    """Shows transfer details."""
    transfer = shell_utils.find_transfer(cs, args.transfer)
    info = dict()
    info.update(transfer._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('volume', metavar='<volume>',
           help='Name or ID of volume to extend.')
@utils.arg('new_size',
           metavar='<new_size>',
           type=int,
           help='New size of volume, in GiBs.')
def do_extend(cs, args):
    """Attempts to extend size of an existing volume."""
    volume = utils.find_volume(cs, args.volume)
    cs.volumes.extend(volume, args.new_size)


@utils.arg('--host', metavar='<hostname>', default=None,
           help='Host name. Default=None.')
@utils.arg('--binary', metavar='<binary>', default=None,
           help='Service binary. Default=None.')
@utils.arg('--withreplication',
           metavar='<True|False>',
           const=True,
           nargs='?',
           default=False,
           help='Enables or disables display of '
                'Replication info for c-vol services. Default=False.')
def do_service_list(cs, args):
    """Lists all services. Filter by host and service binary."""
    replication = strutils.bool_from_string(args.withreplication,
                                            strict=True)
    result = cs.services.list(host=args.host, binary=args.binary)
    columns = ["Binary", "Host", "Zone", "Status", "State", "Updated_at"]
    if replication:
        columns.extend(["Replication Status", "Active Backend ID", "Frozen"])
    # NOTE(jay-lau-513): we check if the response has disabled_reason
    # so as not to add the column when the extended ext is not enabled.
    if result and hasattr(result[0], 'disabled_reason'):
        columns.append("Disabled Reason")
    utils.print_list(result, columns)


@utils.arg('host', metavar='<hostname>', help='Host name.')
@utils.arg('binary', metavar='<binary>', help='Service binary.')
def do_service_enable(cs, args):
    """Enables the service."""
    result = cs.services.enable(args.host, args.binary)
    columns = ["Host", "Binary", "Status"]
    utils.print_list([result], columns)


@utils.arg('host', metavar='<hostname>', help='Host name.')
@utils.arg('binary', metavar='<binary>', help='Service binary.')
@utils.arg('--reason', metavar='<reason>',
           help='Reason for disabling service.')
def do_service_disable(cs, args):
    """Disables the service."""
    columns = ["Host", "Binary", "Status"]
    if args.reason:
        columns.append('Disabled Reason')
        result = cs.services.disable_log_reason(args.host, args.binary,
                                                args.reason)
    else:
        result = cs.services.disable(args.host, args.binary)
    utils.print_list([result], columns)


def treeizeAvailabilityZone(zone):
    """Builds a tree view for availability zones."""
    AvailabilityZone = availability_zones.AvailabilityZone

    az = AvailabilityZone(zone.manager,
                          copy.deepcopy(zone._info), zone._loaded)
    result = []

    # Zone tree view item
    az.zoneName = zone.zoneName
    az.zoneState = ('available'
                    if zone.zoneState['available'] else 'not available')
    az._info['zoneName'] = az.zoneName
    az._info['zoneState'] = az.zoneState
    result.append(az)

    if getattr(zone, "hosts", None) and zone.hosts is not None:
        for (host, services) in zone.hosts.items():
            # Host tree view item
            az = AvailabilityZone(zone.manager,
                                  copy.deepcopy(zone._info), zone._loaded)
            az.zoneName = '|- %s' % host
            az.zoneState = ''
            az._info['zoneName'] = az.zoneName
            az._info['zoneState'] = az.zoneState
            result.append(az)

            for (svc, state) in services.items():
                # Service tree view item
                az = AvailabilityZone(zone.manager,
                                      copy.deepcopy(zone._info), zone._loaded)
                az.zoneName = '| |- %s' % svc
                az.zoneState = '%s %s %s' % (
                               'enabled' if state['active'] else 'disabled',
                               ':-)' if state['available'] else 'XXX',
                               state['updated_at'])
                az._info['zoneName'] = az.zoneName
                az._info['zoneState'] = az.zoneState
                result.append(az)
    return result


def do_availability_zone_list(cs, _args):
    """Lists all availability zones."""
    try:
        availability_zones = cs.availability_zones.list()
    except exceptions.Forbidden:  # policy doesn't allow probably
        try:
            availability_zones = cs.availability_zones.list(detailed=False)
        except Exception:
            raise

    result = []
    for zone in availability_zones:
        result += treeizeAvailabilityZone(zone)
    shell_utils.translate_availability_zone_keys(result)
    utils.print_list(result, ['Name', 'Status'])


def do_encryption_type_list(cs, args):
    """Shows encryption type details for volume types. Admin only."""
    result = cs.volume_encryption_types.list()
    utils.print_list(result, ['Volume Type ID', 'Provider', 'Cipher',
                              'Key Size', 'Control Location'])


@utils.arg('volume_type',
           metavar='<volume_type>',
           type=str,
           help='Name or ID of volume type.')
def do_encryption_type_show(cs, args):
    """Shows encryption type details for a volume type. Admin only."""
    volume_type = shell_utils.find_volume_type(cs, args.volume_type)

    result = cs.volume_encryption_types.get(volume_type)

    # Display result or an empty table if no result
    if hasattr(result, 'volume_type_id'):
        shell_utils.print_volume_encryption_type_list([result])
    else:
        shell_utils.print_volume_encryption_type_list([])


@utils.arg('volume_type',
           metavar='<volume_type>',
           type=str,
           help='Name or ID of volume type.')
@utils.arg('provider',
           metavar='<provider>',
           type=str,
           help='The encryption provider format. '
                'For example, "luks" or "plain".')
@utils.arg('--cipher',
           metavar='<cipher>',
           type=str,
           required=False,
           default=None,
           help='The encryption algorithm or mode. '
                'For example, aes-xts-plain64. Default=None.')
@utils.arg('--key-size',
           metavar='<key_size>',
           type=int,
           required=False,
           default=None,
           help='Size of encryption key, in bits. '
                'For example, 128 or 256. Default=None.')
@utils.arg('--key_size',
           type=int,
           required=False,
           default=None,
           help=argparse.SUPPRESS)
@utils.arg('--control-location',
           metavar='<control_location>',
           choices=['front-end', 'back-end'],
           type=str,
           required=False,
           default='front-end',
           help='Notional service where encryption is performed. '
                'Valid values are "front-end" or "back-end". '
                'For example, front-end=Nova. Default is "front-end".')
@utils.arg('--control_location',
           type=str,
           required=False,
           default='front-end',
           help=argparse.SUPPRESS)
def do_encryption_type_create(cs, args):
    """Creates encryption type for a volume type. Admin only."""
    volume_type = shell_utils.find_volume_type(cs, args.volume_type)

    body = {
        'provider': args.provider,
        'cipher': args.cipher,
        'key_size': args.key_size,
        'control_location': args.control_location
    }

    result = cs.volume_encryption_types.create(volume_type, body)
    shell_utils.print_volume_encryption_type_list([result])


@utils.arg('volume_type',
           metavar='<volume-type>',
           type=str,
           help="Name or ID of the volume type")
@utils.arg('--provider',
           metavar='<provider>',
           type=str,
           required=False,
           default=argparse.SUPPRESS,
           help="Encryption provider format (e.g. 'luks' or 'plain').")
@utils.arg('--cipher',
           metavar='<cipher>',
           type=str,
           nargs='?',
           required=False,
           default=argparse.SUPPRESS,
           const=None,
           help="Encryption algorithm/mode to use (e.g., aes-xts-plain64). "
           "Provide parameter without value to set to provider default.")
@utils.arg('--key-size',
           dest='key_size',
           metavar='<key-size>',
           type=int,
           nargs='?',
           required=False,
           default=argparse.SUPPRESS,
           const=None,
           help="Size of the encryption key, in bits (e.g., 128, 256). "
           "Provide parameter without value to set to provider default. ")
@utils.arg('--control-location',
           dest='control_location',
           metavar='<control-location>',
           choices=['front-end', 'back-end'],
           type=str,
           required=False,
           default=argparse.SUPPRESS,
           help="Notional service where encryption is performed (e.g., "
           "front-end=Nova). Values: 'front-end', 'back-end'")
def do_encryption_type_update(cs, args):
    """Update encryption type information for a volume type (Admin Only)."""
    volume_type = shell_utils.find_volume_type(cs, args.volume_type)

    # An argument should only be pulled if the user specified the parameter.
    body = {}
    for attr in ['provider', 'cipher', 'key_size', 'control_location']:
        if hasattr(args, attr):
            body[attr] = getattr(args, attr)

    cs.volume_encryption_types.update(volume_type, body)
    result = cs.volume_encryption_types.get(volume_type)
    shell_utils.print_volume_encryption_type_list([result])


@utils.arg('volume_type',
           metavar='<volume_type>',
           type=str,
           help='Name or ID of volume type.')
def do_encryption_type_delete(cs, args):
    """Deletes encryption type for a volume type. Admin only."""
    volume_type = shell_utils.find_volume_type(cs, args.volume_type)
    cs.volume_encryption_types.delete(volume_type)


@utils.arg('name',
           metavar='<name>',
           help='Name of new QoS specifications.')
@utils.arg('metadata',
           metavar='<key=value>',
           nargs='+',
           default=[],
           help='QoS specifications.')
def do_qos_create(cs, args):
    """Creates a qos specs."""
    keypair = None
    if args.metadata is not None:
        keypair = shell_utils.extract_metadata(args)
    qos_specs = cs.qos_specs.create(args.name, keypair)
    shell_utils.print_qos_specs(qos_specs)


def do_qos_list(cs, args):
    """Lists qos specs."""
    qos_specs = cs.qos_specs.list()
    shell_utils.print_qos_specs_list(qos_specs)


@utils.arg('qos_specs', metavar='<qos_specs>',
           help='ID of QoS specifications to show.')
def do_qos_show(cs, args):
    """Shows qos specs details."""
    qos_specs = shell_utils.find_qos_specs(cs, args.qos_specs)
    shell_utils.print_qos_specs(qos_specs)


@utils.arg('qos_specs', metavar='<qos_specs>',
           help='ID of QoS specifications to delete.')
@utils.arg('--force',
           metavar='<True|False>',
           const=True,
           nargs='?',
           default=False,
           help='Enables or disables deletion of in-use '
                'QoS specifications. Default=False.')
def do_qos_delete(cs, args):
    """Deletes a specified qos specs."""
    force = strutils.bool_from_string(args.force,
                                      strict=True)
    qos_specs = shell_utils.find_qos_specs(cs, args.qos_specs)
    cs.qos_specs.delete(qos_specs, force)


@utils.arg('qos_specs', metavar='<qos_specs>',
           help='ID of QoS specifications.')
@utils.arg('vol_type_id', metavar='<volume_type_id>',
           help='ID of volume type with which to associate '
                'QoS specifications.')
def do_qos_associate(cs, args):
    """Associates qos specs with specified volume type."""
    cs.qos_specs.associate(args.qos_specs, args.vol_type_id)


@utils.arg('qos_specs', metavar='<qos_specs>',
           help='ID of QoS specifications.')
@utils.arg('vol_type_id', metavar='<volume_type_id>',
           help='ID of volume type with which to associate '
                'QoS specifications.')
def do_qos_disassociate(cs, args):
    """Disassociates qos specs from specified volume type."""
    cs.qos_specs.disassociate(args.qos_specs, args.vol_type_id)


@utils.arg('qos_specs', metavar='<qos_specs>',
           help='ID of QoS specifications on which to operate.')
def do_qos_disassociate_all(cs, args):
    """Disassociates qos specs from all its associations."""
    cs.qos_specs.disassociate_all(args.qos_specs)


@utils.arg('qos_specs', metavar='<qos_specs>',
           help='ID of QoS specifications.')
@utils.arg('action',
           metavar='<action>',
           choices=['set', 'unset'],
           help='The action. Valid values are "set" or "unset."')
@utils.arg('metadata', metavar='key=value',
           nargs='+',
           default=[],
           help='Metadata key and value pair to set or unset. '
                'For unset, specify only the key.')
def do_qos_key(cs, args):
    """Sets or unsets specifications for a qos spec."""
    keypair = shell_utils.extract_metadata(args)

    if args.action == 'set':
        cs.qos_specs.set_keys(args.qos_specs, keypair)
    elif args.action == 'unset':
        cs.qos_specs.unset_keys(args.qos_specs, list(keypair))


@utils.arg('qos_specs', metavar='<qos_specs>',
           help='ID of QoS specifications.')
def do_qos_get_association(cs, args):
    """Lists all associations for specified qos specs."""
    associations = cs.qos_specs.get_associations(args.qos_specs)
    shell_utils.print_associations_list(associations)


@utils.arg('snapshot',
           metavar='<snapshot>',
           help='ID of snapshot for which to update metadata.')
@utils.arg('action',
           metavar='<action>',
           choices=['set', 'unset'],
           help='The action. Valid values are "set" or "unset."')
@utils.arg('metadata',
           metavar='<key=value>',
           nargs='+',
           default=[],
           help='Metadata key and value pair to set or unset. '
                'For unset, specify only the key.')
def do_snapshot_metadata(cs, args):
    """Sets or deletes snapshot metadata."""
    snapshot = shell_utils.find_volume_snapshot(cs, args.snapshot)
    metadata = shell_utils.extract_metadata(args)

    if args.action == 'set':
        metadata = snapshot.set_metadata(metadata)
        utils.print_dict(metadata._info)
    elif args.action == 'unset':
        snapshot.delete_metadata(list(metadata.keys()))


@utils.arg('snapshot', metavar='<snapshot>',
           help='ID of snapshot.')
def do_snapshot_metadata_show(cs, args):
    """Shows snapshot metadata."""
    snapshot = shell_utils.find_volume_snapshot(cs, args.snapshot)
    utils.print_dict(snapshot._info['metadata'], 'Metadata-property')


@utils.arg('volume', metavar='<volume>',
           help='ID of volume.')
def do_metadata_show(cs, args):
    """Shows volume metadata."""
    volume = utils.find_volume(cs, args.volume)
    utils.print_dict(volume._info['metadata'], 'Metadata-property')


@utils.arg('volume', metavar='<volume>',
           help='ID of volume.')
def do_image_metadata_show(cs, args):
    """Shows volume image metadata."""
    volume = utils.find_volume(cs, args.volume)
    resp, body = volume.show_image_metadata(volume)
    utils.print_dict(body['metadata'], 'Metadata-property')


@utils.arg('volume',
           metavar='<volume>',
           help='ID of volume for which to update metadata.')
@utils.arg('metadata',
           metavar='<key=value>',
           nargs='+',
           default=[],
           help='Metadata key and value pair or pairs to update.')
def do_metadata_update_all(cs, args):
    """Updates volume metadata."""
    volume = utils.find_volume(cs, args.volume)
    metadata = shell_utils.extract_metadata(args)
    metadata = volume.update_all_metadata(metadata)
    utils.print_dict(metadata['metadata'], 'Metadata-property')


@utils.arg('snapshot',
           metavar='<snapshot>',
           help='ID of snapshot for which to update metadata.')
@utils.arg('metadata',
           metavar='<key=value>',
           nargs='+',
           default=[],
           help='Metadata key and value pair to update.')
def do_snapshot_metadata_update_all(cs, args):
    """Updates snapshot metadata."""
    snapshot = shell_utils.find_volume_snapshot(cs, args.snapshot)
    metadata = shell_utils.extract_metadata(args)
    metadata = snapshot.update_all_metadata(metadata)
    utils.print_dict(metadata)


@utils.arg('volume', metavar='<volume>', help='ID of volume to update.')
@utils.arg('read_only',
           metavar='<True|true|False|false>',
           choices=['True', 'true', 'False', 'false'],
           help='Enables or disables update of volume to '
                'read-only access mode.')
def do_readonly_mode_update(cs, args):
    """Updates volume read-only access-mode flag."""
    volume = utils.find_volume(cs, args.volume)
    cs.volumes.update_readonly_flag(volume,
                                    strutils.bool_from_string(args.read_only,
                                                              strict=True))


@utils.arg('volume', metavar='<volume>', help='ID of the volume to update.')
@utils.arg('bootable',
           metavar='<True|true|False|false>',
           choices=['True', 'true', 'False', 'false'],
           help='Flag to indicate whether volume is bootable.')
def do_set_bootable(cs, args):
    """Update bootable status of a volume."""
    volume = utils.find_volume(cs, args.volume)
    cs.volumes.set_bootable(volume,
                            strutils.bool_from_string(args.bootable,
                                                      strict=True))


@utils.arg('host',
           metavar='<host>',
           help='Cinder host on which the existing volume resides; '
                'takes the form: host@backend-name#pool')
@utils.arg('identifier',
           metavar='<identifier>',
           help='Name or other Identifier for existing volume')
@utils.arg('--id-type',
           metavar='<id-type>',
           default='source-name',
           help='Type of backend device identifier provided, '
                'typically source-name or source-id (Default=source-name)')
@utils.arg('--name',
           metavar='<name>',
           help='Volume name (Default=None)')
@utils.arg('--description',
           metavar='<description>',
           help='Volume description (Default=None)')
@utils.arg('--volume-type',
           metavar='<volume-type>',
           help='Volume type (Default=None)')
@utils.arg('--availability-zone',
           metavar='<availability-zone>',
           help='Availability zone for volume (Default=None)')
@utils.arg('--metadata',
           nargs='*',
           metavar='<key=value>',
           help='Metadata key=value pairs (Default=None)')
@utils.arg('--bootable',
           action='store_true',
           help='Specifies that the newly created volume should be'
                ' marked as bootable')
def do_manage(cs, args):
    """Manage an existing volume."""
    volume_metadata = None
    if args.metadata is not None:
        volume_metadata = shell_utils.extract_metadata(args)

    # Build a dictionary of key/value pairs to pass to the API.
    ref_dict = {args.id_type: args.identifier}

    # The recommended way to specify an existing volume is by ID or name, and
    # have the Cinder driver look for 'source-name' or 'source-id' elements in
    # the ref structure.  To make things easier for the user, we have special
    # --source-name and --source-id CLI options that add the appropriate
    # element to the ref structure.
    #
    # Note how argparse converts hyphens to underscores.  We use hyphens in the
    # dictionary so that it is consistent with what the user specified on the
    # CLI.

    if hasattr(args, 'source_name') and args.source_name is not None:
        ref_dict['source-name'] = args.source_name
    if hasattr(args, 'source_id') and args.source_id is not None:
        ref_dict['source-id'] = args.source_id

    volume = cs.volumes.manage(host=args.host,
                               ref=ref_dict,
                               name=args.name,
                               description=args.description,
                               volume_type=args.volume_type,
                               availability_zone=args.availability_zone,
                               metadata=volume_metadata,
                               bootable=args.bootable)

    info = {}
    volume = cs.volumes.get(volume.id)
    info.update(volume._info)
    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('volume', metavar='<volume>',
           help='Name or ID of the volume to unmanage.')
def do_unmanage(cs, args):
    """Stop managing a volume."""
    volume = utils.find_volume(cs, args.volume)
    cs.volumes.unmanage(volume.id)


@utils.arg('--all-tenants',
           dest='all_tenants',
           metavar='<0|1>',
           nargs='?',
           type=int,
           const=1,
           default=0,
           help='Shows details for all tenants. Admin only.')
def do_consisgroup_list(cs, args):
    """Lists all consistency groups."""
    consistencygroups = cs.consistencygroups.list()

    columns = ['ID', 'Status', 'Name']
    utils.print_list(consistencygroups, columns)


@utils.arg('consistencygroup',
           metavar='<consistencygroup>',
           help='Name or ID of a consistency group.')
def do_consisgroup_show(cs, args):
    """Shows details of a consistency group."""
    info = dict()
    consistencygroup = shell_utils.find_consistencygroup(cs,
                                                         args.consistencygroup)
    info.update(consistencygroup._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('volumetypes',
           metavar='<volume-types>',
           help='Volume types.')
@utils.arg('--name',
           metavar='<name>',
           help='Name of a consistency group.')
@utils.arg('--description',
           metavar='<description>',
           default=None,
           help='Description of a consistency group. Default=None.')
@utils.arg('--availability-zone',
           metavar='<availability-zone>',
           default=None,
           help='Availability zone for volume. Default=None.')
def do_consisgroup_create(cs, args):
    """Creates a consistency group."""

    consistencygroup = cs.consistencygroups.create(
        args.volumetypes,
        args.name,
        args.description,
        availability_zone=args.availability_zone)

    info = dict()
    consistencygroup = cs.consistencygroups.get(consistencygroup.id)
    info.update(consistencygroup._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('--cgsnapshot',
           metavar='<cgsnapshot>',
           help='Name or ID of a cgsnapshot. Default=None.')
@utils.arg('--source-cg',
           metavar='<source-cg>',
           help='Name or ID of a source CG. Default=None.')
@utils.arg('--name',
           metavar='<name>',
           help='Name of a consistency group. Default=None.')
@utils.arg('--description',
           metavar='<description>',
           help='Description of a consistency group. Default=None.')
def do_consisgroup_create_from_src(cs, args):
    """Creates a consistency group from a cgsnapshot or a source CG."""
    if not args.cgsnapshot and not args.source_cg:
        msg = ('Cannot create consistency group because neither '
               'cgsnapshot nor source CG is provided.')
        raise exceptions.ClientException(code=1, message=msg)
    if args.cgsnapshot and args.source_cg:
        msg = ('Cannot create consistency group because both '
               'cgsnapshot and source CG are provided.')
        raise exceptions.ClientException(code=1, message=msg)
    cgsnapshot = None
    if args.cgsnapshot:
        cgsnapshot = shell_utils.find_cgsnapshot(cs, args.cgsnapshot)
    source_cg = None
    if args.source_cg:
        source_cg = shell_utils.find_consistencygroup(cs, args.source_cg)
    info = cs.consistencygroups.create_from_src(
        cgsnapshot.id if cgsnapshot else None,
        source_cg.id if source_cg else None,
        args.name,
        args.description)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('consistencygroup',
           metavar='<consistencygroup>', nargs='+',
           help='Name or ID of one or more consistency groups '
                'to be deleted.')
@utils.arg('--force',
           action='store_true',
           default=False,
           help='Allows or disallows consistency groups '
                'to be deleted. If the consistency group is empty, '
                'it can be deleted without the force flag. '
                'If the consistency group is not empty, the force '
                'flag is required for it to be deleted.')
def do_consisgroup_delete(cs, args):
    """Removes one or more consistency groups."""
    failure_count = 0
    for consistencygroup in args.consistencygroup:
        try:
            shell_utils.find_consistencygroup(
                cs, consistencygroup).delete(args.force)
        except Exception as e:
            failure_count += 1
            print("Delete for consistency group %s failed: %s" %
                  (consistencygroup, e))
    if failure_count == len(args.consistencygroup):
        raise exceptions.CommandError("Unable to delete any of the specified "
                                      "consistency groups.")


@utils.arg('consistencygroup',
           metavar='<consistencygroup>',
           help='Name or ID of a consistency group.')
@utils.arg('--name', metavar='<name>',
           help='New name for consistency group. Default=None.')
@utils.arg('--description', metavar='<description>',
           help='New description for consistency group. Default=None.')
@utils.arg('--add-volumes',
           metavar='<uuid1,uuid2,......>',
           help='UUID of one or more volumes '
                'to be added to the consistency group, '
                'separated by commas. Default=None.')
@utils.arg('--remove-volumes',
           metavar='<uuid3,uuid4,......>',
           help='UUID of one or more volumes '
                'to be removed from the consistency group, '
                'separated by commas. Default=None.')
def do_consisgroup_update(cs, args):
    """Updates a consistency group."""
    kwargs = {}

    if args.name is not None:
        kwargs['name'] = args.name

    if args.description is not None:
        kwargs['description'] = args.description

    if args.add_volumes is not None:
        kwargs['add_volumes'] = args.add_volumes

    if args.remove_volumes is not None:
        kwargs['remove_volumes'] = args.remove_volumes

    if not kwargs:
        msg = ('At least one of the following args must be supplied: '
               'name, description, add-volumes, remove-volumes.')
        raise exceptions.ClientException(code=1, message=msg)

    shell_utils.find_consistencygroup(
        cs, args.consistencygroup).update(**kwargs)
    print("Request to update consistency group '%s' has been accepted." % (
        args.consistencygroup))


@utils.arg('--all-tenants',
           dest='all_tenants',
           metavar='<0|1>',
           nargs='?',
           type=int,
           const=1,
           default=0,
           help='Shows details for all tenants. Admin only.')
@utils.arg('--status',
           metavar='<status>',
           default=None,
           help='Filters results by a status. Default=None.')
@utils.arg('--consistencygroup-id',
           metavar='<consistencygroup_id>',
           default=None,
           help='Filters results by a consistency group ID. Default=None.')
def do_cgsnapshot_list(cs, args):
    """Lists all cgsnapshots."""

    all_tenants = int(os.environ.get("ALL_TENANTS", args.all_tenants))

    search_opts = {
        'all_tenants': all_tenants,
        'status': args.status,
        'consistencygroup_id': args.consistencygroup_id,
    }

    cgsnapshots = cs.cgsnapshots.list(search_opts=search_opts)

    columns = ['ID', 'Status', 'Name']
    utils.print_list(cgsnapshots, columns)


@utils.arg('cgsnapshot',
           metavar='<cgsnapshot>',
           help='Name or ID of cgsnapshot.')
def do_cgsnapshot_show(cs, args):
    """Shows cgsnapshot details."""
    info = dict()
    cgsnapshot = shell_utils.find_cgsnapshot(cs, args.cgsnapshot)
    info.update(cgsnapshot._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('consistencygroup',
           metavar='<consistencygroup>',
           help='Name or ID of a consistency group.')
@utils.arg('--name',
           metavar='<name>',
           default=None,
           help='Cgsnapshot name. Default=None.')
@utils.arg('--description',
           metavar='<description>',
           default=None,
           help='Cgsnapshot description. Default=None.')
def do_cgsnapshot_create(cs, args):
    """Creates a cgsnapshot."""
    consistencygroup = shell_utils.find_consistencygroup(cs,
                                                         args.consistencygroup)
    cgsnapshot = cs.cgsnapshots.create(
        consistencygroup.id,
        args.name,
        args.description)

    info = dict()
    cgsnapshot = cs.cgsnapshots.get(cgsnapshot.id)
    info.update(cgsnapshot._info)

    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('cgsnapshot',
           metavar='<cgsnapshot>', nargs='+',
           help='Name or ID of one or more cgsnapshots to be deleted.')
def do_cgsnapshot_delete(cs, args):
    """Removes one or more cgsnapshots."""
    failure_count = 0
    for cgsnapshot in args.cgsnapshot:
        try:
            shell_utils.find_cgsnapshot(cs, cgsnapshot).delete()
        except Exception as e:
            failure_count += 1
            print("Delete for cgsnapshot %s failed: %s" % (cgsnapshot, e))
    if failure_count == len(args.cgsnapshot):
        raise exceptions.CommandError("Unable to delete any of the specified "
                                      "cgsnapshots.")


@utils.arg('--detail',
           action='store_true',
           help='Show detailed information about pools.')
def do_get_pools(cs, args):
    """Show pool information for backends. Admin only."""
    pools = cs.volumes.get_pools(args.detail)
    infos = dict()
    infos.update(pools._info)

    for info in infos['pools']:
        backend = dict()
        backend['name'] = info['name']
        if args.detail:
            backend.update(info['capabilities'])
        utils.print_dict(backend)


@utils.arg('host',
           metavar='<host>',
           help='Cinder host to show backend volume stats and properties; '
                'takes the form: host@backend-name')
def do_get_capabilities(cs, args):
    """Show backend volume stats and properties. Admin only."""

    capabilities = cs.capabilities.get(args.host)
    infos = dict()
    infos.update(capabilities._info)

    prop = infos.pop('properties', None)
    utils.print_dict(infos, "Volume stats")
    utils.print_dict(prop, "Backend properties",
                     formatters=sorted(prop.keys()))


@utils.arg('volume',
           metavar='<volume>',
           help='Cinder volume that already exists in the volume backend.')
@utils.arg('identifier',
           metavar='<identifier>',
           help='Name or other identifier for existing snapshot. This is '
                'backend specific.')
@utils.arg('--id-type',
           metavar='<id-type>',
           default='source-name',
           help='Type of backend device identifier provided, '
                'typically source-name or source-id (Default=source-name).')
@utils.arg('--name',
           metavar='<name>',
           help='Snapshot name (Default=None).')
@utils.arg('--description',
           metavar='<description>',
           help='Snapshot description (Default=None).')
@utils.arg('--metadata',
           nargs='*',
           metavar='<key=value>',
           help='Metadata key=value pairs (Default=None).')
def do_snapshot_manage(cs, args):
    """Manage an existing snapshot."""
    snapshot_metadata = None
    if args.metadata is not None:
        snapshot_metadata = shell_utils.extract_metadata(args)

    # Build a dictionary of key/value pairs to pass to the API.
    ref_dict = {args.id_type: args.identifier}

    if hasattr(args, 'source_name') and args.source_name is not None:
        ref_dict['source-name'] = args.source_name
    if hasattr(args, 'source_id') and args.source_id is not None:
        ref_dict['source-id'] = args.source_id

    volume = utils.find_volume(cs, args.volume)
    snapshot = cs.volume_snapshots.manage(volume_id=volume.id,
                                          ref=ref_dict,
                                          name=args.name,
                                          description=args.description,
                                          metadata=snapshot_metadata)

    info = {}
    snapshot = cs.volume_snapshots.get(snapshot.id)
    info.update(snapshot._info)
    info.pop('links', None)
    utils.print_dict(info)


@utils.arg('snapshot', metavar='<snapshot>',
           help='Name or ID of the snapshot to unmanage.')
def do_snapshot_unmanage(cs, args):
    """Stop managing a snapshot."""
    snapshot = shell_utils.find_volume_snapshot(cs, args.snapshot)
    cs.volume_snapshots.unmanage(snapshot.id)


@utils.arg('host', metavar='<hostname>', help='Host name.')
def do_freeze_host(cs, args):
    """Freeze and disable the specified cinder-volume host."""
    cs.services.freeze_host(args.host)


@utils.arg('host', metavar='<hostname>', help='Host name.')
def do_thaw_host(cs, args):
    """Thaw and enable the specified cinder-volume host."""
    cs.services.thaw_host(args.host)


@utils.arg('host', metavar='<hostname>', help='Host name.')
@utils.arg('--backend_id',
           metavar='<backend-id>',
           help='ID of backend to failover to (Default=None)')
def do_failover_host(cs, args):
    """Failover a replicating cinder-volume host."""
    cs.services.failover_host(args.host, args.backend_id)


@utils.arg('host',
           metavar='<host>',
           help='Cinder host on which to list manageable volumes; '
                'takes the form: host@backend-name#pool')
@utils.arg('--detailed',
           metavar='<detailed>',
           default=True,
           help='Returned detailed information (default true).')
@utils.arg('--marker',
           metavar='<marker>',
           default=None,
           help='Begin returning volumes that appear later in the volume '
                'list than that represented by this volume id. '
                'Default=None.')
@utils.arg('--limit',
           metavar='<limit>',
           default=None,
           help='Maximum number of volumes to return. Default=None.')
@utils.arg('--offset',
           metavar='<offset>',
           default=None,
           help='Number of volumes to skip after marker. Default=None.')
@utils.arg('--sort',
           metavar='<key>[:<direction>]',
           default=None,
           help=(('Comma-separated list of sort keys and directions in the '
                  'form of <key>[:<asc|desc>]. '
                  'Valid keys: %s. '
                  'Default=None.') % ', '.join(base.SORT_KEY_VALUES)))
def do_manageable_list(cs, args):
    """Lists all manageable volumes."""
    detailed = strutils.bool_from_string(args.detailed)
    volumes = cs.volumes.list_manageable(host=args.host, detailed=detailed,
                                         marker=args.marker, limit=args.limit,
                                         offset=args.offset, sort=args.sort)
    columns = ['reference', 'size', 'safe_to_manage']
    if detailed:
        columns.extend(['reason_not_safe', 'cinder_id', 'extra_info'])
    utils.print_list(volumes, columns, sortby_index=None)


@utils.arg('host',
           metavar='<host>',
           help='Cinder host on which to list manageable snapshots; '
                'takes the form: host@backend-name#pool')
@utils.arg('--detailed',
           metavar='<detailed>',
           default=True,
           help='Returned detailed information (default true).')
@utils.arg('--marker',
           metavar='<marker>',
           default=None,
           help='Begin returning snapshots that appear later in the snapshot '
                'list than that represented by this snapshot id. '
                'Default=None.')
@utils.arg('--limit',
           metavar='<limit>',
           default=None,
           help='Maximum number of snapshots to return. Default=None.')
@utils.arg('--offset',
           metavar='<offset>',
           default=None,
           help='Number of snapshots to skip after marker. Default=None.')
@utils.arg('--sort',
           metavar='<key>[:<direction>]',
           default=None,
           help=(('Comma-separated list of sort keys and directions in the '
                  'form of <key>[:<asc|desc>]. '
                  'Valid keys: %s. '
                  'Default=None.') % ', '.join(base.SORT_KEY_VALUES)))
def do_snapshot_manageable_list(cs, args):
    """Lists all manageable snapshots."""
    detailed = strutils.bool_from_string(args.detailed)
    snapshots = cs.volume_snapshots.list_manageable(host=args.host,
                                                    detailed=detailed,
                                                    marker=args.marker,
                                                    limit=args.limit,
                                                    offset=args.offset,
                                                    sort=args.sort)
    columns = ['reference', 'size', 'safe_to_manage', 'source_reference']
    if detailed:
        columns.extend(['reason_not_safe', 'cinder_id', 'extra_info'])
    utils.print_list(snapshots, columns, sortby_index=None)
