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

openstackclient/network/common.py

@@ -11,12 +11,12 @@
 #   under the License.
 #
 
-import abc
+import argparse
+from collections.abc import Generator
 import contextlib
 import logging
-import typing as ty
+from typing import Any
 
-from cliff import _argparse
 import openstack.exceptions
 from osc_lib.cli import parseractions
 from osc_lib import exceptions
@@ -37,13 +37,11 @@ _required_opt_extensions_map = {
     'security_groups': 'security-groups',
 }
 
-_NET_TYPE_NEUTRON = 'neutron'
-_NET_TYPE_COMPUTE = 'nova-network'
-_QUALIFIER_FMT = "%s\n\n*%s*"
-
 
 @contextlib.contextmanager
-def check_missing_extension_if_error(client_manager, attrs):
+def check_missing_extension_if_error(
+    client_manager: Any, attrs: dict[str, Any]
+) -> Generator[None, None, None]:
     # If specified option requires extension, then try to
     # find out if it exists. If it does not exist,
     # then an exception with the appropriate message
@@ -57,233 +55,6 @@ def check_missing_extension_if_error(client_manager, attrs):
         raise
 
 
-class NetDetectionMixin(metaclass=abc.ABCMeta):
-    """Convenience methods for nova-network vs. neutron decisions.
-
-    A live environment detects which network type it is running and creates its
-    parser with only the options relevant to that network type.
-
-    But the command classes are used for docs builds as well, and docs must
-    present the options for both network types, often qualified accordingly.
-    """
-
-    @property
-    def _network_type(self):
-        """Discover whether the running cloud is using neutron or nova-network.
-
-        :return:
-            * ``NET_TYPE_NEUTRON`` if neutron is detected
-            * ``NET_TYPE_COMPUTE`` if running in a cloud but neutron is not
-              detected.
-            * ``None`` if not running in a cloud, which hopefully means we're
-              building docs.
-        """
-        # Have we set it up yet for this command?
-        if not hasattr(self, '_net_type'):
-            try:
-                if self.app.client_manager.is_network_endpoint_enabled():  # type: ignore
-                    net_type = _NET_TYPE_NEUTRON
-                else:
-                    net_type = _NET_TYPE_COMPUTE
-            except AttributeError:
-                LOG.warning(
-                    "%s: Could not detect a network type. Assuming we are "
-                    "building docs.",
-                    self.__class__.__name__,
-                )
-                net_type = None
-            self._net_type = net_type
-        return self._net_type
-
-    @property
-    def is_neutron(self):
-        return self._network_type is _NET_TYPE_NEUTRON
-
-    @property
-    def is_nova_network(self):
-        return self._network_type is _NET_TYPE_COMPUTE
-
-    @property
-    def is_docs_build(self):
-        return self._network_type is None
-
-    def enhance_help_neutron(self, _help):
-        if self.is_docs_build:
-            # Why can't we say 'neutron'?
-            return _QUALIFIER_FMT % (_help, _("Network version 2 only"))
-        return _help
-
-    def enhance_help_nova_network(self, _help):
-        if self.is_docs_build:
-            # Why can't we say 'nova-network'?
-            return _QUALIFIER_FMT % (_help, _("Compute version 2 only"))
-        return _help
-
-    @staticmethod
-    def split_help(network_help, compute_help):
-        return (
-            "*{network_qualifier}:*\n  {network_help}\n\n"
-            "*{compute_qualifier}:*\n  {compute_help}".format(
-                **dict(
-                    network_qualifier=_("Network version 2"),
-                    network_help=network_help,
-                    compute_qualifier=_("Compute version 2"),
-                    compute_help=compute_help,
-                )
-            )
-        )
-
-    def get_parser(self, prog_name: str) -> _argparse.ArgumentParser:
-        LOG.debug('get_parser(%s)', prog_name)
-        parser = super().get_parser(prog_name)  # type: ignore
-        parser = self.update_parser_common(parser)
-        LOG.debug('common parser: %s', parser)
-        if self.is_neutron or self.is_docs_build:
-            parser = self.update_parser_network(parser)
-        if self.is_nova_network or self.is_docs_build:
-            # Add nova-net options if running nova-network or building docs
-            parser = self.update_parser_compute(parser)
-        return parser
-
-    def update_parser_common(self, parser):
-        """Default is no updates to parser."""
-        return parser
-
-    def update_parser_network(self, parser):
-        """Default is no updates to parser."""
-        return parser
-
-    def update_parser_compute(self, parser):
-        """Default is no updates to parser."""
-        return parser
-
-    def take_action(self, parsed_args):
-        if self.is_neutron:
-            return self.take_action_network(
-                self.app.client_manager.network,  # type: ignore
-                parsed_args,
-            )
-        elif self.is_nova_network:
-            return self.take_action_compute(
-                self.app.client_manager.compute,  # type: ignore
-                parsed_args,
-            )
-
-    def take_action_network(self, client, parsed_args):
-        """Override to do something useful."""
-        pass
-
-    def take_action_compute(self, client, parsed_args):
-        """Override to do something useful."""
-        pass
-
-
-class NetworkAndComputeCommand(
-    NetDetectionMixin, command.Command, metaclass=abc.ABCMeta
-):
-    """Network and Compute Command
-
-    Command class for commands that support implementation via
-    the network or compute endpoint. Such commands have different
-    implementations for take_action() and may even have different
-    arguments.
-    """
-
-    pass
-
-
-class NetworkAndComputeDelete(NetworkAndComputeCommand, metaclass=abc.ABCMeta):
-    """Network and Compute Delete
-
-    Delete class for commands that support implementation via
-    the network or compute endpoint. Such commands have different
-    implementations for take_action() and may even have different
-    arguments. This class supports bulk deletion, and error handling
-    following the rules in doc/source/command-errors.rst.
-    """
-
-    resource: str
-
-    def take_action(self, parsed_args):
-        ret = 0
-        resources = getattr(parsed_args, self.resource, [])
-
-        for r in resources:
-            self.r = r
-            try:
-                if self.app.client_manager.is_network_endpoint_enabled():
-                    self.take_action_network(
-                        self.app.client_manager.network, parsed_args
-                    )
-                else:
-                    self.take_action_compute(
-                        self.app.client_manager.compute,
-                        parsed_args,
-                    )
-            except Exception as e:
-                msg = _(
-                    "Failed to delete %(resource)s with name or ID "
-                    "'%(name_or_id)s': %(e)s"
-                ) % {
-                    "resource": self.resource,
-                    "name_or_id": r,
-                    "e": e,
-                }
-                LOG.error(msg)
-                ret += 1
-
-        if ret:
-            total = len(resources)
-            msg = _("%(num)s of %(total)s %(resource)ss failed to delete.") % {
-                "num": ret,
-                "total": total,
-                "resource": self.resource,
-            }
-            raise exceptions.CommandError(msg)
-
-
-class NetworkAndComputeLister(
-    NetDetectionMixin, command.Lister, metaclass=abc.ABCMeta
-):
-    """Network and Compute Lister
-
-    Lister class for commands that support implementation via
-    the network or compute endpoint. Such commands have different
-    implementations for take_action() and may even have different
-    arguments.
-    """
-
-    pass
-
-
-class NetworkAndComputeShowOne(
-    NetDetectionMixin, command.ShowOne, metaclass=abc.ABCMeta
-):
-    """Network and Compute ShowOne
-
-    ShowOne class for commands that support implementation via
-    the network or compute endpoint. Such commands have different
-    implementations for take_action() and may even have different
-    arguments.
-    """
-
-    def take_action(self, parsed_args):
-        try:
-            if self.app.client_manager.is_network_endpoint_enabled():
-                return self.take_action_network(
-                    self.app.client_manager.network, parsed_args
-                )
-            else:
-                return self.take_action_compute(
-                    self.app.client_manager.compute, parsed_args
-                )
-        except openstack.exceptions.HttpException as exc:
-            msg = _("Error while executing command: %s") % exc.message
-            if exc.details:
-                msg += ", " + str(exc.details)
-            raise exceptions.CommandError(msg)
-
-
 class NeutronCommandWithExtraArgs(command.Command):
     """Create and Update commands with additional extra properties.
 
@@ -300,7 +71,7 @@ class NeutronCommandWithExtraArgs(command.Command):
         'str': str,
     }
 
-    def _get_property_converter(self, _property):
+    def _get_property_converter(self, _property: dict[str, Any]) -> Any:
         if 'type' in _property:
             converter = self._allowed_types_dict.get(_property['type'])
         else:
@@ -316,15 +87,17 @@ class NeutronCommandWithExtraArgs(command.Command):
             )
         return converter
 
-    def _parse_extra_properties(self, extra_properties):
-        result: dict[str, ty.Any] = {}
+    def _parse_extra_properties(
+        self, extra_properties: list[dict[str, Any]] | None
+    ) -> dict[str, Any]:
+        result: dict[str, Any] = {}
         if extra_properties:
             for _property in extra_properties:
                 converter = self._get_property_converter(_property)
                 result[_property['name']] = converter(_property['value'])
         return result
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             '--extra-property',
@@ -349,8 +122,10 @@ class NeutronCommandWithExtraArgs(command.Command):
 
 
 class NeutronUnsetCommandWithExtraArgs(NeutronCommandWithExtraArgs):
-    def _parse_extra_properties(self, extra_properties):
-        result: dict[str, ty.Any] = {}
+    def _parse_extra_properties(
+        self, extra_properties: list[dict[str, Any]] | None
+    ) -> dict[str, Any]:
+        result: dict[str, Any] = {}
         if extra_properties:
             for _property in extra_properties:
                 result[_property['name']] = None

openstackclient/network/utils.py

@@ -9,50 +9,22 @@
 #   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 typing import Any, cast
 
 from osc_lib import exceptions
 
 from openstackclient.i18n import _
 
 
-# Transform compute security group rule for display.
-def transform_compute_security_group_rule(sg_rule):
-    info = {}
-    info.update(sg_rule)
-    from_port = info.pop('from_port')
-    to_port = info.pop('to_port')
-    if isinstance(from_port, int) and isinstance(to_port, int):
-        port_range = {'port_range': f"{from_port}:{to_port}"}
-    elif from_port is None and to_port is None:
-        port_range = {'port_range': ""}
-    else:
-        port_range = {'port_range': f"{from_port}:{to_port}"}
-    info.update(port_range)
-    if 'cidr' in info['ip_range']:
-        info['ip_range'] = info['ip_range']['cidr']
-    else:
-        info['ip_range'] = ''
-    if info['ip_protocol'] is None:
-        info['ip_protocol'] = ''
-    elif info['ip_protocol'].lower() == 'icmp':
-        info['port_range'] = ''
-    group = info.pop('group')
-    if 'name' in group:
-        info['remote_security_group'] = group['name']
-    else:
-        info['remote_security_group'] = ''
-    return info
-
-
-def str2bool(strbool):
+def str2bool(strbool: str | None) -> bool | None:
     if strbool is None:
         return None
     return strbool.lower() == 'true'
 
 
-def str2list(strlist):
-    result = []
+def str2list(strlist: str | None) -> list[str]:
+    result: list[str] = []
     if strlist:
         result = strlist.split(';')
     return result
@@ -78,17 +50,12 @@ def str2dict(strdict: str) -> dict[str, str]:
         else:
             kvlist[i - 1] = f"{kvlist[i - 1]};{kv}"
     for kv in kvlist:
-        key, sep, value = kv.partition(':')
+        key, value = kv.split(':', 1)
         result[key] = value
     return result
 
 
-def format_security_group_rule_show(obj):
-    data = transform_compute_security_group_rule(obj)
-    return zip(*sorted(data.items()))
-
-
-def format_network_port_range(rule):
+def format_network_port_range(rule: dict[str, Any]) -> str:
     # Display port range or ICMP type and code. For example:
     # - ICMP type: 'type=3'
     # - ICMP type and code: 'type=3:code=0'
@@ -114,8 +81,8 @@ def format_network_port_range(rule):
     return port_range
 
 
-def format_remote_ip_prefix(rule):
-    remote_ip_prefix = rule['remote_ip_prefix']
+def format_remote_ip_prefix(rule: dict[str, Any]) -> str | None:
+    remote_ip_prefix = cast(str | None, rule['remote_ip_prefix'])
     if remote_ip_prefix is None:
         ethertype = rule['ether_type']
         if ethertype == 'IPv4':
@@ -125,7 +92,7 @@ def format_remote_ip_prefix(rule):
     return remote_ip_prefix
 
 
-def convert_ipvx_case(string):
+def convert_ipvx_case(string: str) -> str:
     if string.lower() == 'ipv4':
         return 'IPv4'
     if string.lower() == 'ipv6':
@@ -133,7 +100,7 @@ def convert_ipvx_case(string):
     return string
 
 
-def is_icmp_protocol(protocol):
+def is_icmp_protocol(protocol: str | None) -> bool:
     # NOTE(rtheis): Neutron has deprecated protocol icmpv6.
     # However, while the OSC CLI doesn't document the protocol,
     # the code must still handle it. In addition, handle both
@@ -144,12 +111,14 @@ def is_icmp_protocol(protocol):
         return False
 
 
-def convert_to_lowercase(string):
+def convert_to_lowercase(string: str) -> str:
     return string.lower()
 
 
-def get_protocol(parsed_args, default_protocol='any'):
-    protocol = default_protocol
+def get_protocol(
+    parsed_args: Any, default_protocol: str = 'any'
+) -> str | None:
+    protocol: str | None = default_protocol
     if parsed_args.protocol is not None:
         protocol = parsed_args.protocol
     if hasattr(parsed_args, "proto") and parsed_args.proto is not None:
@@ -159,7 +128,7 @@ def get_protocol(parsed_args, default_protocol='any'):
     return protocol
 
 
-def get_ethertype(parsed_args, protocol):
+def get_ethertype(parsed_args: Any, protocol: str | None) -> str:
     ethertype = 'IPv4'
     if parsed_args.ethertype is not None:
         ethertype = parsed_args.ethertype
@@ -168,16 +137,20 @@ def get_ethertype(parsed_args, protocol):
     return ethertype
 
 
-def is_ipv6_protocol(protocol):
+def is_ipv6_protocol(protocol: str | None) -> bool:
     # NOTE(rtheis): Neutron has deprecated protocol icmpv6.
     # However, while the OSC CLI doesn't document the protocol,
     # the code must still handle it. In addition, handle both
     # protocol names and numbers.
-    if (
-        protocol is not None
-        and protocol.startswith('ipv6-')
-        or protocol in ['icmpv6', '41', '43', '44', '58', '59', '60']
-    ):
+    if (protocol is not None and protocol.startswith('ipv6-')) or protocol in [
+        'icmpv6',
+        '41',
+        '43',
+        '44',
+        '58',
+        '59',
+        '60',
+    ]:
         return True
     else:
         return False

openstackclient/network/v2/address_group.py

@@ -13,13 +13,18 @@
 
 """Address group action implementations"""
 
+import argparse
 import logging
+from collections.abc import Iterable, Sequence
+from typing import Any
 
 import netaddr
+from openstack.network.v2 import address_group as _address_group
 from osc_lib import exceptions
 from osc_lib import utils
 
 from openstackclient import command
+from openstackclient.common import pagination
 from openstackclient.i18n import _
 from openstackclient.identity import common as identity_common
 from openstackclient.network import common
@@ -27,19 +32,23 @@ from openstackclient.network import common
 LOG = logging.getLogger(__name__)
 
 
-def _get_columns(item):
+def _get_columns(
+    item: _address_group.AddressGroup,
+) -> tuple[tuple[str, ...], tuple[str, ...]]:
     hidden_columns = ['location', 'tenant_id']
     return utils.get_osc_show_columns_for_sdk_resource(
         item, {}, hidden_columns
     )
 
 
-def _format_addresses(addresses):
+def _format_addresses(addresses: list[str]) -> list[str]:
     return [str(netaddr.IPNetwork(addr)) for addr in addresses]
 
 
-def _get_attrs(client_manager, parsed_args):
-    attrs = {}
+def _get_attrs(
+    client_manager: Any, parsed_args: argparse.Namespace
+) -> dict[str, Any]:
+    attrs: dict[str, Any] = {}
     attrs['name'] = parsed_args.name
     if parsed_args.description:
         attrs['description'] = parsed_args.description
@@ -59,7 +68,7 @@ def _get_attrs(client_manager, parsed_args):
 class CreateAddressGroup(command.ShowOne, common.NeutronCommandWithExtraArgs):
     _description = _("Create a new Address Group")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'name', metavar="<name>", help=_("New address group name")
@@ -87,7 +96,9 @@ class CreateAddressGroup(command.ShowOne, common.NeutronCommandWithExtraArgs):
 
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
         client = self.app.client_manager.network
         attrs = _get_attrs(self.app.client_manager, parsed_args)
 
@@ -105,7 +116,7 @@ class CreateAddressGroup(command.ShowOne, common.NeutronCommandWithExtraArgs):
 class DeleteAddressGroup(command.Command):
     _description = _("Delete address group(s)")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'address_group',
@@ -116,7 +127,7 @@ class DeleteAddressGroup(command.Command):
 
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         client = self.app.client_manager.network
         result = 0
 
@@ -145,7 +156,7 @@ class DeleteAddressGroup(command.Command):
 class ListAddressGroup(command.Lister):
     _description = _("List address groups")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
 
         parser.add_argument(
@@ -162,10 +173,13 @@ class ListAddressGroup(command.Lister):
             ),
         )
         identity_common.add_project_domain_option_to_parser(parser)
+        pagination.add_marker_pagination_option_to_parser(parser)
 
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[tuple[str, ...], Iterable[tuple[Any, ...]]]:
         client = self.app.client_manager.network
         columns = (
             'id',
@@ -192,6 +206,13 @@ class ListAddressGroup(command.Lister):
                 parsed_args.project_domain,
             ).id
             attrs['project_id'] = project_id
+        if parsed_args.marker is not None:
+            attrs['marker'] = parsed_args.marker
+        if parsed_args.limit is not None:
+            attrs['limit'] = parsed_args.limit
+        if parsed_args.max_items is not None:
+            attrs['max_items'] = parsed_args.max_items
+
         data = client.address_groups(**attrs)
 
         return (
@@ -210,7 +231,7 @@ class ListAddressGroup(command.Lister):
 class SetAddressGroup(common.NeutronCommandWithExtraArgs):
     _description = _("Set address group 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(
             'address_group',
@@ -236,7 +257,7 @@ class SetAddressGroup(common.NeutronCommandWithExtraArgs):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         client = self.app.client_manager.network
         obj = client.find_address_group(
             parsed_args.address_group, ignore_missing=False
@@ -261,7 +282,7 @@ class SetAddressGroup(common.NeutronCommandWithExtraArgs):
 class ShowAddressGroup(command.ShowOne):
     _description = _("Display address group details")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'address_group',
@@ -271,7 +292,9 @@ class ShowAddressGroup(command.ShowOne):
 
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
         client = self.app.client_manager.network
         obj = client.find_address_group(
             parsed_args.address_group, ignore_missing=False
@@ -285,7 +308,7 @@ class ShowAddressGroup(command.ShowOne):
 class UnsetAddressGroup(command.Command):
     _description = _("Unset address group 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(
             'address_group',
@@ -304,7 +327,7 @@ class UnsetAddressGroup(command.Command):
         )
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         client = self.app.client_manager.network
         obj = client.find_address_group(
             parsed_args.address_group, ignore_missing=False