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

openstackclient/volume/v3/consistency_group_snapshot.py

@@ -0,0 +1,225 @@
+#
+#   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 consistency group snapshot action implementations"""
+
+import argparse
+import logging
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+from osc_lib import exceptions
+from osc_lib import utils
+
+from openstackclient import command
+from openstackclient.i18n import _
+
+
+LOG = logging.getLogger(__name__)
+
+
+class CreateConsistencyGroupSnapshot(command.ShowOne):
+    _description = _("Create new consistency group snapshot.")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "snapshot_name",
+            metavar="<snapshot-name>",
+            nargs="?",
+            help=_("Name of new consistency group snapshot (default to None)"),
+        )
+        parser.add_argument(
+            "--consistency-group",
+            metavar="<consistency-group>",
+            help=_(
+                "Consistency group to snapshot (name or ID) "
+                "(default to be the same as <snapshot-name>)"
+            ),
+        )
+        parser.add_argument(
+            "--description",
+            metavar="<description>",
+            help=_("Description of this consistency group snapshot"),
+        )
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        volume_client = self.app.client_manager.volume
+        consistency_group = parsed_args.consistency_group
+        if not parsed_args.consistency_group:
+            # If "--consistency-group" not specified, then consistency_group
+            # will be the same as the new consistency group snapshot name
+            consistency_group = parsed_args.snapshot_name
+        consistency_group_id = utils.find_resource(
+            volume_client.consistencygroups, consistency_group
+        ).id
+        consistency_group_snapshot = volume_client.cgsnapshots.create(
+            consistency_group_id,
+            name=parsed_args.snapshot_name,
+            description=parsed_args.description,
+        )
+
+        col_headers, col_data = zip(
+            *sorted(consistency_group_snapshot._info.items())
+        )
+        return col_headers, col_data
+
+
+class DeleteConsistencyGroupSnapshot(command.Command):
+    _description = _("Delete consistency group snapshot(s).")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "consistency_group_snapshot",
+            metavar="<consistency-group-snapshot>",
+            nargs="+",
+            help=_("Consistency group snapshot(s) to delete (name or ID)"),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        result = 0
+
+        for snapshot in parsed_args.consistency_group_snapshot:
+            try:
+                snapshot_id = utils.find_resource(
+                    volume_client.cgsnapshots, snapshot
+                ).id
+
+                volume_client.cgsnapshots.delete(snapshot_id)
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete consistency group snapshot "
+                        "with name or ID '%(snapshot)s': %(e)s"
+                    ),
+                    {'snapshot': snapshot, 'e': e},
+                )
+
+        if result > 0:
+            total = len(parsed_args.consistency_group_snapshot)
+            msg = _(
+                "%(result)s of %(total)s consistency group snapshots "
+                "failed to delete."
+            ) % {'result': result, 'total': total}
+            raise exceptions.CommandError(msg)
+
+
+class ListConsistencyGroupSnapshot(command.Lister):
+    _description = _("List consistency group snapshots.")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            '--all-projects',
+            action="store_true",
+            help=_(
+                'Show detail for all projects (admin only) (defaults to False)'
+            ),
+        )
+        parser.add_argument(
+            '--long',
+            action="store_true",
+            help=_('List additional fields in output'),
+        )
+        parser.add_argument(
+            '--status',
+            metavar="<status>",
+            choices=[
+                'available',
+                'error',
+                'creating',
+                'deleting',
+                'error_deleting',
+            ],
+            help=_(
+                'Filters results by a status ("available", "error", '
+                '"creating", "deleting" or "error_deleting")'
+            ),
+        )
+        parser.add_argument(
+            '--consistency-group',
+            metavar="<consistency-group>",
+            help=_('Filters results by a consistency group (name or ID)'),
+        )
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[tuple[Any, ...]]]:
+        if parsed_args.long:
+            columns = [
+                'ID',
+                'Status',
+                'ConsistencyGroup ID',
+                'Name',
+                'Description',
+                'Created At',
+            ]
+        else:
+            columns = ['ID', 'Status', 'Name']
+        volume_client = self.app.client_manager.volume
+        consistency_group_id = None
+        if parsed_args.consistency_group:
+            consistency_group_id = utils.find_resource(
+                volume_client.consistencygroups,
+                parsed_args.consistency_group,
+            ).id
+        search_opts = {
+            'all_tenants': parsed_args.all_projects,
+            'status': parsed_args.status,
+            'consistencygroup_id': consistency_group_id,
+        }
+        consistency_group_snapshots = volume_client.cgsnapshots.list(
+            detailed=True,
+            search_opts=search_opts,
+        )
+
+        return (
+            columns,
+            (
+                utils.get_item_properties(s, columns)
+                for s in consistency_group_snapshots
+            ),
+        )
+
+
+class ShowConsistencyGroupSnapshot(command.ShowOne):
+    _description = _("Display consistency group snapshot details")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "consistency_group_snapshot",
+            metavar="<consistency-group-snapshot>",
+            help=_("Consistency group snapshot 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
+        consistency_group_snapshot = utils.find_resource(
+            volume_client.cgsnapshots, parsed_args.consistency_group_snapshot
+        )
+        col_headers, col_data = zip(
+            *sorted(consistency_group_snapshot._info.items())
+        )
+        return col_headers, col_data

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/service.py

@@ -14,6 +14,10 @@
 
 """Service action implementations"""
 
+import argparse
+from collections.abc import Iterable
+from typing import Any
+
 from openstack import utils as sdk_utils
 from osc_lib import exceptions
 from osc_lib import utils
@@ -25,7 +29,7 @@ from openstackclient.i18n import _
 class ListService(command.Lister):
     _description = _("List service command")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             "--host",
@@ -45,8 +49,12 @@ class ListService(command.Lister):
         )
         return parser
 
-    def take_action(self, parsed_args):
-        volume_client = self.app.client_manager.sdk_connection.volume
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[tuple[str, ...], Iterable[tuple[Any, ...]]]:
+        volume_client = sdk_utils.ensure_service_version(
+            self.app.client_manager.sdk_connection.volume, '3'
+        )
 
         columns: tuple[str, ...] = (
             "binary",
@@ -93,7 +101,7 @@ class ListService(command.Lister):
 class SetService(command.Command):
     _description = _("Set volume service properties")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             "host",
@@ -122,7 +130,7 @@ class SetService(command.Command):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         if parsed_args.disable_reason and not parsed_args.disable:
             msg = _(
                 "Cannot specify option --disable-reason without "
@@ -130,7 +138,9 @@ class SetService(command.Command):
             )
             raise exceptions.CommandError(msg)
 
-        volume_client = self.app.client_manager.sdk_connection.volume
+        volume_client = sdk_utils.ensure_service_version(
+            self.app.client_manager.sdk_connection.volume, '3'
+        )
 
         service = volume_client.find_service(
             parsed_args.service, ignore_missing=False, host=parsed_args.host