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

openstackclient/volume/v3/block_storage_cluster.py

@@ -10,6 +10,10 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+import argparse
+from collections.abc import Iterable, Sequence
+from typing import Any
+
 from cinderclient import api_versions
 from osc_lib import exceptions
 from osc_lib import utils
@@ -18,7 +22,9 @@ from openstackclient import command
 from openstackclient.i18n import _
 
 
-def _format_cluster(cluster, detailed=False):
+def _format_cluster(
+    cluster: Any, detailed: bool = False
+) -> tuple[Sequence[str], Iterable[Any]]:
     columns: tuple[str, ...] = (
         'name',
         'binary',
@@ -73,7 +79,7 @@ class ListBlockStorageCluster(command.Lister):
     This command requires ``--os-volume-api-version`` 3.7 or greater.
     """
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             '--cluster',
@@ -137,7 +143,9 @@ class ListBlockStorageCluster(command.Lister):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[tuple[str, ...], Iterable[tuple[Any, ...]]]:
         volume_client = self.app.client_manager.volume
 
         if volume_client.api_version < api_versions.APIVersion('3.7'):
@@ -180,7 +188,7 @@ class SetBlockStorageCluster(command.Command):
     This command requires ``--os-volume-api-version`` 3.7 or greater.
     """
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'cluster',
@@ -221,7 +229,9 @@ class SetBlockStorageCluster(command.Command):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
         volume_client = self.app.client_manager.volume
 
         if volume_client.api_version < api_versions.APIVersion('3.7'):
@@ -251,7 +261,7 @@ class ShowBlockStorageCluster(command.ShowOne):
     This command requires ``--os-volume-api-version`` 3.7 or greater.
     """
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'cluster',
@@ -265,7 +275,9 @@ class ShowBlockStorageCluster(command.ShowOne):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
         volume_client = self.app.client_manager.volume
 
         if volume_client.api_version < api_versions.APIVersion('3.7'):

openstackclient/volume/v3/block_storage_log_level.py

@@ -14,6 +14,9 @@
 
 """Block Storage Service action implementations"""
 
+import argparse
+from typing import Any
+
 from openstack import utils as sdk_utils
 from osc_lib import exceptions
 
@@ -27,7 +30,7 @@ class BlockStorageLogLevelList(command.Lister):
     Supported by --os-volume-api-version 3.32 or greater.
     """
 
-    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",
@@ -63,8 +66,12 @@ class BlockStorageLogLevelList(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[list[str], list[tuple[Any, ...]]]:
+        volume_client = sdk_utils.ensure_service_version(
+            self.app.client_manager.sdk_connection.volume, '3'
+        )
         columns = [
             "Binary",
             "Host",
@@ -98,7 +105,7 @@ class BlockStorageLogLevelSet(command.Command):
     Supported by --os-volume-api-version 3.32 or greater.
     """
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             "level",
@@ -141,8 +148,10 @@ class BlockStorageLogLevelSet(command.Command):
         )
         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) -> None:
+        volume_client = sdk_utils.ensure_service_version(
+            self.app.client_manager.sdk_connection.volume, '3'
+        )
 
         if not sdk_utils.supports_microversion(volume_client, '3.32'):
             msg = _(

openstackclient/volume/v3/block_storage_manage.py

@@ -14,6 +14,8 @@
 """Block Storage Volume/Snapshot Management implementations"""
 
 import argparse
+from collections.abc import Iterable
+from typing import Any
 
 from cinderclient import api_versions
 from osc_lib import exceptions
@@ -32,7 +34,7 @@ class BlockStorageManageVolumes(command.Lister):
     Supported by --os-volume-api-version 3.8 or greater.
     """
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         host_group = parser.add_mutually_exclusive_group()
         host_group.add_argument(
@@ -104,7 +106,9 @@ class BlockStorageManageVolumes(command.Lister):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[list[str], Iterable[tuple[Any, ...]]]:
         volume_client = self.app.client_manager.volume
 
         if parsed_args.host is None and parsed_args.cluster is None:
@@ -196,7 +200,7 @@ class BlockStorageManageSnapshots(command.Lister):
     Supported by --os-volume-api-version 3.8 or greater.
     """
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         host_group = parser.add_mutually_exclusive_group()
         host_group.add_argument(
@@ -268,7 +272,9 @@ class BlockStorageManageSnapshots(command.Lister):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[list[str], Iterable[tuple[Any, ...]]]:
         volume_client = self.app.client_manager.volume
 
         if parsed_args.host is None and parsed_args.cluster is None:

openstackclient/volume/v3/block_storage_resource_filter.py

@@ -12,6 +12,10 @@
 
 """Volume V3 Resource Filters 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 exceptions
@@ -24,8 +28,12 @@ from openstackclient.i18n import _
 class ListBlockStorageResourceFilter(command.Lister):
     _description = _('List block storage resource filters')
 
-    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'
+        )
 
         if not sdk_utils.supports_microversion(volume_client, '3.33'):
             msg = _(
@@ -58,7 +66,7 @@ class ListBlockStorageResourceFilter(command.Lister):
 class ShowBlockStorageResourceFilter(command.ShowOne):
     _description = _('Show filters for a block storage resource type')
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'resource',
@@ -68,8 +76,12 @@ class ShowBlockStorageResourceFilter(command.ShowOne):
 
         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[Sequence[str], Iterable[Any]]:
+        volume_client = sdk_utils.ensure_service_version(
+            self.app.client_manager.sdk_connection.volume, '3'
+        )
 
         if not sdk_utils.supports_microversion(volume_client, '3.33'):
             msg = _(

openstackclient/volume/v3/consistency_group.py

@@ -0,0 +1,400 @@
+#
+#   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 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 import exceptions
+from osc_lib import utils
+
+from openstackclient import command
+from openstackclient.i18n import _
+
+
+LOG = logging.getLogger(__name__)
+
+
+def _find_volumes(
+    parsed_args_volumes: list[str], volume_client: Any
+) -> tuple[int, str]:
+    result = 0
+    uuid = ''
+    for volume in parsed_args_volumes:
+        try:
+            volume_id = utils.find_resource(volume_client.volumes, volume).id
+            uuid += volume_id + ','
+        except Exception as e:
+            result += 1
+            LOG.error(
+                _("Failed to find volume with name or ID '%(volume)s':%(e)s"),
+                {'volume': volume, 'e': e},
+            )
+
+    return result, uuid
+
+
+class AddVolumeToConsistencyGroup(command.Command):
+    _description = _("Add volume(s) to consistency group")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'consistency_group',
+            metavar="<consistency-group>",
+            help=_('Consistency group to contain <volume> (name or ID)'),
+        )
+        parser.add_argument(
+            'volumes',
+            metavar='<volume>',
+            nargs='+',
+            help=_(
+                'Volume(s) to add to <consistency-group> (name or ID) '
+                '(repeat option to add multiple volumes)'
+            ),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        result, add_uuid = _find_volumes(parsed_args.volumes, volume_client)
+
+        if result > 0:
+            total = len(parsed_args.volumes)
+            LOG.error(
+                _("%(result)s of %(total)s volumes failed to add."),
+                {'result': result, 'total': total},
+            )
+
+        if add_uuid:
+            add_uuid = add_uuid.rstrip(',')
+            consistency_group_id = utils.find_resource(
+                volume_client.consistencygroups, parsed_args.consistency_group
+            ).id
+            volume_client.consistencygroups.update(
+                consistency_group_id, add_volumes=add_uuid
+            )
+
+
+class CreateConsistencyGroup(command.ShowOne):
+    _description = _("Create new consistency group.")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "name",
+            metavar="<name>",
+            nargs="?",
+            help=_("Name of new consistency group (default to None)"),
+        )
+        exclusive_group = parser.add_mutually_exclusive_group(required=True)
+        exclusive_group.add_argument(
+            "--volume-type",
+            metavar="<volume-type>",
+            help=_("Volume type of this consistency group (name or ID)"),
+        )
+        exclusive_group.add_argument(
+            "--source",
+            metavar="<consistency-group>",
+            help=_("Existing consistency group (name or ID)"),
+        )
+        # NOTE(stephenfin): Legacy alias
+        exclusive_group.add_argument(
+            "--consistency-group-source",
+            metavar="<consistency-group>",
+            dest='source',
+            help=argparse.SUPPRESS,
+        )
+        exclusive_group.add_argument(
+            "--snapshot",
+            metavar="<consistency-group-snapshot>",
+            help=_("Existing consistency group snapshot (name or ID)"),
+        )
+        # NOTE(stephenfin): Legacy alias
+        exclusive_group.add_argument(
+            "--consistency-group-snapshot",
+            metavar="<consistency-group-snapshot>",
+            dest='snapshot',
+            help=argparse.SUPPRESS,
+        )
+        parser.add_argument(
+            "--description",
+            metavar="<description>",
+            help=_("Description of this consistency group"),
+        )
+        parser.add_argument(
+            "--availability-zone",
+            metavar="<availability-zone>",
+            help=_(
+                "Availability zone for this consistency group "
+                "(not available if creating consistency group "
+                "from source)"
+            ),
+        )
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        volume_client = self.app.client_manager.volume
+        if parsed_args.volume_type:
+            volume_type_id = utils.find_resource(
+                volume_client.volume_types, parsed_args.volume_type
+            ).id
+            consistency_group = volume_client.consistencygroups.create(
+                volume_type_id,
+                name=parsed_args.name,
+                description=parsed_args.description,
+                availability_zone=parsed_args.availability_zone,
+            )
+        else:
+            if parsed_args.availability_zone:
+                msg = _(
+                    "'--availability-zone' option will not work "
+                    "if creating consistency group from source"
+                )
+                LOG.warning(msg)
+
+            consistency_group_id = None
+            consistency_group_snapshot = None
+            if parsed_args.source:
+                consistency_group_id = utils.find_resource(
+                    volume_client.consistencygroups,
+                    parsed_args.source,
+                ).id
+            elif parsed_args.snapshot:
+                consistency_group_snapshot = utils.find_resource(
+                    volume_client.cgsnapshots,
+                    parsed_args.snapshot,
+                ).id
+
+            consistency_group = (
+                volume_client.consistencygroups.create_from_src(
+                    consistency_group_snapshot,
+                    consistency_group_id,
+                    name=parsed_args.name,
+                    description=parsed_args.description,
+                )
+            )
+
+        col_headers, col_data = zip(*sorted(consistency_group._info.items()))
+        return col_headers, col_data
+
+
+class DeleteConsistencyGroup(command.Command):
+    _description = _("Delete consistency group(s).")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'consistency_groups',
+            metavar='<consistency-group>',
+            nargs="+",
+            help=_('Consistency group(s) to delete (name or ID)'),
+        )
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            default=False,
+            help=_("Allow delete in state other than error or available"),
+        )
+        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.consistency_groups:
+            try:
+                consistency_group_id = utils.find_resource(
+                    volume_client.consistencygroups, i
+                ).id
+                volume_client.consistencygroups.delete(
+                    consistency_group_id, parsed_args.force
+                )
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete consistency group with "
+                        "name or ID '%(consistency_group)s':%(e)s"
+                    ),
+                    {'consistency_group': i, 'e': e},
+                )
+
+        if result > 0:
+            total = len(parsed_args.consistency_groups)
+            msg = _(
+                "%(result)s of %(total)s consistency groups failed to delete."
+            ) % {'result': result, 'total': total}
+            raise exceptions.CommandError(msg)
+
+
+class ListConsistencyGroup(command.Lister):
+    _description = _("List consistency groups.")
+
+    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 details for all projects. Admin only. '
+                '(defaults to False)'
+            ),
+        )
+        parser.add_argument(
+            '--long',
+            action="store_true",
+            help=_('List additional fields in output'),
+        )
+        return parser
+
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[tuple[Any, ...]]]:
+        if parsed_args.long:
+            columns = [
+                'ID',
+                'Status',
+                'Availability Zone',
+                'Name',
+                'Description',
+                'Volume Types',
+            ]
+        else:
+            columns = ['ID', 'Status', 'Name']
+        volume_client = self.app.client_manager.volume
+        consistency_groups = volume_client.consistencygroups.list(
+            detailed=True,
+            search_opts={'all_tenants': parsed_args.all_projects},
+        )
+
+        return (
+            columns,
+            (
+                utils.get_item_properties(
+                    s,
+                    columns,
+                    formatters={'Volume Types': format_columns.ListColumn},
+                )
+                for s in consistency_groups
+            ),
+        )
+
+
+class RemoveVolumeFromConsistencyGroup(command.Command):
+    _description = _("Remove volume(s) from consistency group")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'consistency_group',
+            metavar="<consistency-group>",
+            help=_('Consistency group containing <volume> (name or ID)'),
+        )
+        parser.add_argument(
+            'volumes',
+            metavar='<volume>',
+            nargs='+',
+            help=_(
+                'Volume(s) to remove from <consistency-group> (name or ID) '
+                '(repeat option to remove multiple volumes)'
+            ),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        result, remove_uuid = _find_volumes(parsed_args.volumes, volume_client)
+
+        if result > 0:
+            total = len(parsed_args.volumes)
+            LOG.error(
+                _("%(result)s of %(total)s volumes failed to remove."),
+                {'result': result, 'total': total},
+            )
+
+        if remove_uuid:
+            remove_uuid = remove_uuid.rstrip(',')
+            consistency_group_id = utils.find_resource(
+                volume_client.consistencygroups, parsed_args.consistency_group
+            ).id
+            volume_client.consistencygroups.update(
+                consistency_group_id, remove_volumes=remove_uuid
+            )
+
+
+class SetConsistencyGroup(command.Command):
+    _description = _("Set consistency group properties")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            'consistency_group',
+            metavar='<consistency-group>',
+            help=_('Consistency group to modify (name or ID)'),
+        )
+        parser.add_argument(
+            '--name',
+            metavar='<name>',
+            help=_('New consistency group name'),
+        )
+        parser.add_argument(
+            '--description',
+            metavar='<description>',
+            help=_('New consistency group description'),
+        )
+        return parser
+
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        volume_client = self.app.client_manager.volume
+        kwargs = {}
+        if parsed_args.name:
+            kwargs['name'] = parsed_args.name
+        if parsed_args.description:
+            kwargs['description'] = parsed_args.description
+        if kwargs:
+            consistency_group_id = utils.find_resource(
+                volume_client.consistencygroups, parsed_args.consistency_group
+            ).id
+            volume_client.consistencygroups.update(
+                consistency_group_id, **kwargs
+            )
+
+
+class ShowConsistencyGroup(command.ShowOne):
+    _description = _("Display consistency group details.")
+
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "consistency_group",
+            metavar="<consistency-group>",
+            help=_("Consistency group 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 = utils.find_resource(
+            volume_client.consistencygroups, parsed_args.consistency_group
+        )
+        col_headers, col_data = zip(*sorted(consistency_group._info.items()))
+        return col_headers, col_data