python-openstackclient 10.0.0__py3-none-any.whl → 10.1.0__py3-none-any.whl

openstackclient/volume/v3/qos_specs.py

@@ -0,0 +1,389 @@
+#   Copyright 2015 iWeb Technologies Inc.
+#
+#   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.
+
+"""Volume v3 QoS action implementations"""
+
+import argparse
+import logging
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+from osc_lib.cli import format_columns
+from osc_lib.cli import parseractions
+from osc_lib import exceptions
+from osc_lib import utils
+
+from openstackclient import command
+from openstackclient.i18n import _
+
+
+LOG = logging.getLogger(__name__)
+
+
+class AssociateQos(command.Command):
+    _description = _("Associate a QoS specification to a volume type")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'qos_spec',
+            metavar='<qos-spec>',
+            help=_('QoS specification to modify (name or ID)'),
+        )
+        parser.add_argument(
+            'volume_type',
+            metavar='<volume-type>',
+            help=_('Volume type to associate the QoS (name or ID)'),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        qos_spec = utils.find_resource(
+            volume_client.qos_specs, parsed_args.qos_spec
+        )
+        volume_type = utils.find_resource(
+            volume_client.volume_types, parsed_args.volume_type
+        )
+
+        volume_client.qos_specs.associate(qos_spec.id, volume_type.id)
+
+
+class CreateQos(command.ShowOne):
+    _description = _("Create new QoS specification")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'name',
+            metavar='<name>',
+            help=_('New QoS specification name'),
+        )
+        consumer_choices = ['front-end', 'back-end', 'both']
+        parser.add_argument(
+            '--consumer',
+            metavar='<consumer>',
+            choices=consumer_choices,
+            default='both',
+            help=(
+                _(
+                    'Consumer of the QoS. Valid consumers: %s '
+                    "(defaults to 'both')"
+                )
+                % utils.format_list(consumer_choices)
+            ),
+        )
+        parser.add_argument(
+            '--property',
+            metavar='<key=value>',
+            action=parseractions.KeyValueAction,
+            help=_(
+                'Set a QoS specification property '
+                '(repeat option to set multiple properties)'
+            ),
+        )
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        volume_client = self.app.client_manager.volume
+        specs = {}
+        specs.update({'consumer': parsed_args.consumer})
+
+        if parsed_args.property:
+            specs.update(parsed_args.property)
+
+        qos_spec = volume_client.qos_specs.create(parsed_args.name, specs)
+
+        qos_spec._info.update(
+            {
+                'properties': format_columns.DictColumn(
+                    qos_spec._info.pop('specs')
+                )
+            }
+        )
+        col_headers, col_data = zip(*sorted(qos_spec._info.items()))
+        return col_headers, col_data
+
+
+class DeleteQos(command.Command):
+    _description = _("Delete QoS specification")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'qos_specs',
+            metavar='<qos-spec>',
+            nargs="+",
+            help=_('QoS specification(s) to delete (name or ID)'),
+        )
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            default=False,
+            help=_("Allow to delete in-use QoS specification(s)"),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        result = 0
+
+        for i in parsed_args.qos_specs:
+            try:
+                qos_spec = utils.find_resource(volume_client.qos_specs, i)
+                volume_client.qos_specs.delete(qos_spec.id, parsed_args.force)
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete QoS specification with "
+                        "name or ID '%(qos)s': %(e)s"
+                    ),
+                    {'qos': i, 'e': e},
+                )
+
+        if result > 0:
+            total = len(parsed_args.qos_specs)
+            msg = _(
+                "%(result)s of %(total)s QoS specifications failed to delete."
+            ) % {'result': result, 'total': total}
+            raise exceptions.CommandError(msg)
+
+
+class DisassociateQos(command.Command):
+    _description = _("Disassociate a QoS specification from a volume type")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'qos_spec',
+            metavar='<qos-spec>',
+            help=_('QoS specification to modify (name or ID)'),
+        )
+        volume_type_group = parser.add_mutually_exclusive_group()
+        volume_type_group.add_argument(
+            '--volume-type',
+            metavar='<volume-type>',
+            help=_('Volume type to disassociate the QoS from (name or ID)'),
+        )
+        volume_type_group.add_argument(
+            '--all',
+            action='store_true',
+            default=False,
+            help=_('Disassociate the QoS from every volume type'),
+        )
+
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        qos_spec = utils.find_resource(
+            volume_client.qos_specs, parsed_args.qos_spec
+        )
+
+        if parsed_args.volume_type:
+            volume_type = utils.find_resource(
+                volume_client.volume_types, parsed_args.volume_type
+            )
+            volume_client.qos_specs.disassociate(qos_spec.id, volume_type.id)
+        elif parsed_args.all:
+            volume_client.qos_specs.disassociate_all(qos_spec.id)
+
+
+class ListQos(command.Lister):
+    _description = _("List QoS specifications")
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[tuple[Any, ...]]]:
+        volume_client = self.app.client_manager.volume
+        qos_specs_list = volume_client.qos_specs.list()
+
+        for qos in qos_specs_list:
+            try:
+                qos_associations = volume_client.qos_specs.get_associations(
+                    qos,
+                )
+                if qos_associations:
+                    associations = [
+                        association.name for association in qos_associations
+                    ]
+                    qos._info.update({'associations': associations})
+            except Exception as ex:
+                if type(ex).__name__ == 'NotFound':
+                    qos._info.update({'associations': None})
+                else:
+                    raise
+
+        display_columns = (
+            'ID',
+            'Name',
+            'Consumer',
+            'Associations',
+            'Properties',
+        )
+
+        columns = ('ID', 'Name', 'Consumer', 'Associations', 'Specs')
+        return (
+            display_columns,
+            (
+                utils.get_dict_properties(
+                    s._info,
+                    columns,
+                    formatters={
+                        'Specs': format_columns.DictColumn,
+                        'Associations': format_columns.ListColumn,
+                    },
+                )
+                for s in qos_specs_list
+            ),
+        )
+
+
+class SetQos(command.Command):
+    _description = _("Set QoS specification properties")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'qos_spec',
+            metavar='<qos-spec>',
+            help=_('QoS specification to modify (name or ID)'),
+        )
+        parser.add_argument(
+            '--no-property',
+            dest='no_property',
+            action='store_true',
+            help=_(
+                'Remove all properties from <qos-spec> '
+                '(specify both --no-property and --property to remove the '
+                'current properties before setting new properties)'
+            ),
+        )
+        parser.add_argument(
+            '--property',
+            metavar='<key=value>',
+            action=parseractions.KeyValueAction,
+            help=_(
+                'Property to add or modify for this QoS specification '
+                '(repeat option to set multiple properties)'
+            ),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        qos_spec = utils.find_resource(
+            volume_client.qos_specs, parsed_args.qos_spec
+        )
+
+        result = 0
+        if parsed_args.no_property:
+            try:
+                key_list = list(qos_spec._info['specs'].keys())
+                volume_client.qos_specs.unset_keys(qos_spec.id, key_list)
+            except Exception as e:
+                LOG.error(_("Failed to clean qos properties: %s"), e)
+                result += 1
+
+        if parsed_args.property:
+            try:
+                volume_client.qos_specs.set_keys(
+                    qos_spec.id,
+                    parsed_args.property,
+                )
+            except Exception as e:
+                LOG.error(_("Failed to set qos property: %s"), e)
+                result += 1
+
+        if result > 0:
+            raise exceptions.CommandError(
+                _("One or more of the set operations failed")
+            )
+
+
+class ShowQos(command.ShowOne):
+    _description = _("Display QoS specification details")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'qos_spec',
+            metavar='<qos-spec>',
+            help=_('QoS specification to display (name or ID)'),
+        )
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        volume_client = self.app.client_manager.volume
+        qos_spec = utils.find_resource(
+            volume_client.qos_specs, parsed_args.qos_spec
+        )
+
+        qos_associations = volume_client.qos_specs.get_associations(qos_spec)
+        if qos_associations:
+            associations = [
+                association.name for association in qos_associations
+            ]
+            qos_spec._info.update(
+                {'associations': format_columns.ListColumn(associations)}
+            )
+        qos_spec._info.update(
+            {
+                'properties': format_columns.DictColumn(
+                    qos_spec._info.pop('specs')
+                )
+            }
+        )
+
+        col_headers, col_data = zip(*sorted(qos_spec._info.items()))
+        return col_headers, col_data
+
+
+class UnsetQos(command.Command):
+    _description = _("Unset QoS specification properties")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'qos_spec',
+            metavar='<qos-spec>',
+            help=_('QoS specification to modify (name or ID)'),
+        )
+        parser.add_argument(
+            '--property',
+            metavar='<key>',
+            action='append',
+            default=[],
+            help=_(
+                'Property to remove from the QoS specification. '
+                '(repeat option to unset multiple properties)'
+            ),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        qos_spec = utils.find_resource(
+            volume_client.qos_specs, parsed_args.qos_spec
+        )
+
+        if parsed_args.property:
+            volume_client.qos_specs.unset_keys(
+                qos_spec.id, parsed_args.property
+            )

openstackclient/volume/v3/volume.py

@@ -102,7 +102,7 @@ class AttachmentsColumn(cliff_columns.FormattableColumn[list[Any]]):
         return msg
 
 
-def _format_volume(volume: _volume.Volume) -> dict[str, Any]:
+def _format_volume(volume: _volume.Volume) -> dict[str, object]:
     # Some columns returned by openstacksdk should not be shown because they're
     # either irrelevant or duplicates
     ignored_columns = {
@@ -644,7 +644,9 @@ class ListVolume(command.Lister):
             default=False,
             help=_('List additional fields in output'),
         )
-        pagination.add_marker_pagination_option_to_parser(parser)
+        pagination.add_marker_pagination_option_to_parser(
+            parser, include_max_items=False
+        )
         return parser
 
     def take_action(

openstackclient/volume/v3/volume_attachment.py

@@ -15,6 +15,7 @@ from collections.abc import Iterable, Sequence
 import logging
 from typing import Any
 
+from openstack.block_storage.v3 import attachment as _attachment
 from openstack import utils as sdk_utils
 from osc_lib.cli import format_columns
 from osc_lib import exceptions
@@ -34,7 +35,9 @@ _FILTER_DEPRECATED = _(
 )
 
 
-def _format_attachment(attachment: Any) -> tuple[tuple[str, ...], Any]:
+def _format_attachment(
+    attachment: _attachment.Attachment,
+) -> tuple[tuple[str, ...], Iterable[Any]]:
     columns = (
         'id',
         'volume_id',
@@ -484,6 +487,7 @@ class ListVolumeAttachment(command.Lister):
             search_opts=search_opts,
             marker=parsed_args.marker,
             limit=parsed_args.limit,
+            max_items=parsed_args.max_items,
         )
 
         column_headers = (

openstackclient/volume/v3/volume_backend.py

@@ -0,0 +1,130 @@
+#
+#   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.
+#
+
+"""Storage backend action implementations"""
+
+import argparse
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+from openstack import utils as sdk_utils
+from osc_lib.cli import format_columns
+from osc_lib import utils
+
+from openstackclient import command
+from openstackclient.i18n import _
+
+
+class ShowCapability(command.Lister):
+    _description = _("Show capability command")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "host",
+            metavar="<host>",
+            help=_("List capabilities of specified host (host@backend-name)"),
+        )
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[tuple[Any, ...]]]:
+        volume_client = sdk_utils.ensure_service_version(
+            self.app.client_manager.sdk_connection.volume, '3'
+        )
+
+        columns = [
+            'Title',
+            'Key',
+            'Type',
+            'Description',
+        ]
+
+        data = volume_client.get_capabilities(parsed_args.host)
+
+        # The get capabilities API is... interesting. We only want the names of
+        # the capabilities that can set for a backend through extra specs, so
+        # we need to extract out that part of the mess that is returned.
+        print_data = []
+        keys = data.properties
+        for key in keys:
+            # Stuff the key into the details to make it easier to output
+            capability_data = data.properties[key]
+            capability_data['key'] = key
+            print_data.append(capability_data)
+
+        return (
+            columns,
+            (
+                utils.get_dict_properties(
+                    s,
+                    columns,
+                )
+                for s in print_data
+            ),
+        )
+
+
+class ListPool(command.Lister):
+    _description = _("List pool command")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "--long",
+            action="store_true",
+            default=False,
+            help=_("Show detailed information about pools."),
+        )
+        # TODO(smcginnis): Starting with Cinder microversion 3.33, user is also
+        # able to pass in --filters with a <key>=<value> pair to filter on.
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[tuple[Any, ...]]]:
+        volume_client = sdk_utils.ensure_service_version(
+            self.app.client_manager.sdk_connection.volume, '3'
+        )
+
+        if parsed_args.long:
+            columns = [
+                'name',
+                'capabilities',
+            ]
+
+            headers = [
+                'Name',
+                'Capabilities',
+            ]
+        else:
+            columns = [
+                'Name',
+            ]
+            headers = columns
+
+        data = volume_client.backend_pools(detailed=parsed_args.long)
+        formatters = {'capabilities': format_columns.DictColumn}
+        return (
+            headers,
+            (
+                utils.get_item_properties(
+                    s,
+                    columns,
+                    formatters=formatters,
+                )
+                for s in data
+            ),
+        )

openstackclient/volume/v3/volume_backup.py

@@ -394,6 +394,7 @@ class ListVolumeBackup(command.Lister):
             all_tenants=all_tenants,
             marker=marker_backup_id,
             limit=parsed_args.limit,
+            max_items=parsed_args.max_items,
             project_id=project_id,
         )
 
@@ -477,9 +478,7 @@ class RestoreVolumeBackup(command.ShowOne):
                 raise exceptions.CommandError(msg % parsed_args.volume)
 
         restore = volume_client.restore_backup(
-            backup.id,
-            volume_id=volume_id,
-            name=volume_name,
+            backup.id, volume=volume_id, name=volume_name
         )
 
         data = utils.get_dict_properties(restore, columns)

openstackclient/volume/v3/volume_group_snapshot.py

@@ -15,6 +15,7 @@ from collections.abc import Iterable, Sequence
 import logging
 from typing import Any
 
+from openstack.block_storage.v3 import group_snapshot as _group_snapshot
 from openstack import utils as sdk_utils
 from osc_lib import exceptions
 from osc_lib import utils
@@ -27,8 +28,8 @@ LOG = logging.getLogger(__name__)
 
 
 def _format_group_snapshot(
-    snapshot: Any,
-) -> tuple[Sequence[str], Iterable[Any]]:
+    snapshot: _group_snapshot.GroupSnapshot,
+) -> tuple[tuple[str, ...], Iterable[Any]]:
     columns = (
         'id',
         'status',
@@ -48,10 +49,7 @@ def _format_group_snapshot(
 
     return (
         column_headers,
-        utils.get_item_properties(
-            snapshot,
-            columns,
-        ),
+        utils.get_item_properties(snapshot, columns),
     )
 
 

openstackclient/volume/v3/volume_group_type.py

@@ -412,7 +412,7 @@ class ShowVolumeGroupType(command.ShowOne):
 
         group_type = utils.find_resource(
             volume_client.group_types,
-            parsed_args.group,
+            parsed_args.group_type,
         )
 
         return _format_group_type(group_type)

openstackclient/volume/v3/volume_host.py

@@ -0,0 +1,74 @@
+#
+#   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.
+
+"""Volume v3 host action implementations"""
+
+import argparse
+
+from openstackclient import command
+from openstackclient.i18n import _
+
+
+class FailoverVolumeHost(command.Command):
+    _description = _("Failover volume host to different backend")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "host", metavar="<host-name>", help=_("Name of volume host")
+        )
+        parser.add_argument(
+            "--volume-backend",
+            metavar="<backend-id>",
+            required=True,
+            help=_(
+                "The ID of the volume backend replication "
+                "target where the host will failover to (required)"
+            ),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        service_client = self.app.client_manager.volume
+        service_client.services.failover_host(
+            parsed_args.host, parsed_args.volume_backend
+        )
+
+
+class SetVolumeHost(command.Command):
+    _description = _("Set volume host properties")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "host", metavar="<host-name>", help=_("Name of volume host")
+        )
+        enabled_group = parser.add_mutually_exclusive_group()
+        enabled_group.add_argument(
+            "--disable",
+            action="store_true",
+            help=_("Freeze and disable the specified volume host"),
+        )
+        enabled_group.add_argument(
+            "--enable",
+            action="store_true",
+            help=_("Thaw and enable the specified volume host"),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        service_client = self.app.client_manager.volume
+        if parsed_args.enable:
+            service_client.services.thaw_host(parsed_args.host)
+        if parsed_args.disable:
+            service_client.services.freeze_host(parsed_args.host)