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

openstackclient/network/v2/floating_ip.py

@@ -12,34 +12,44 @@
 
 """IP Floating action implementations"""
 
+import argparse
+from collections.abc import Iterable, Sequence
+import logging
+from typing import Any
+
 from openstack import exceptions as sdk_exceptions
 from osc_lib.cli import format_columns
+from osc_lib import exceptions
 from osc_lib import utils
 from osc_lib.utils import tags as _tag
 
-from openstackclient.api import compute_v2
+from openstackclient import command
 from openstackclient.i18n import _
 from openstackclient.identity import common as identity_common
 from openstackclient.network import common
 
+LOG = logging.getLogger(__name__)
+
 _formatters = {
     'port_details': format_columns.DictColumn,
 }
 
 
-def _get_network_columns(item):
+def _get_network_columns(item: Any) -> tuple[tuple[str, ...], tuple[str, ...]]:
     hidden_columns = ['location', 'tenant_id']
     return utils.get_osc_show_columns_for_sdk_resource(
         item, {}, hidden_columns
     )
 
 
-def _get_columns(item):
+def _get_columns(item: Any) -> tuple[str, ...]:
     columns = list(item.keys())
     return tuple(sorted(columns))
 
 
-def _get_attrs(client_manager, parsed_args):
+def _get_attrs(
+    client_manager: Any, parsed_args: argparse.Namespace
+) -> dict[str, Any]:
     attrs = {}
     network_client = client_manager.network
 
@@ -92,104 +102,82 @@ def _get_attrs(client_manager, parsed_args):
     return attrs
 
 
-class CreateFloatingIP(
-    common.NetworkAndComputeShowOne, common.NeutronCommandWithExtraArgs
-):
+class CreateFloatingIP(command.ShowOne, common.NeutronCommandWithExtraArgs):
     _description = _("Create floating IP")
 
-    def update_parser_common(self, parser):
-        # In Compute v2 network, floating IPs could be allocated from floating
-        # IP pools, which are actually external networks. So deprecate the
-        # parameter "pool", and use "network" instead.
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             'network',
             metavar='<network>',
             help=_("Network to allocate floating IP from (name or ID)"),
         )
-        return parser
-
-    def update_parser_network(self, parser):
         parser.add_argument(
             '--subnet',
             metavar='<subnet>',
-            help=self.enhance_help_neutron(
-                _(
-                    "Subnet on which you want to create the floating IP "
-                    "(name or ID)"
-                )
+            help=_(
+                "Subnet on which you want to create the floating IP "
+                "(name or ID)"
             ),
         )
         parser.add_argument(
             '--port',
             metavar='<port>',
-            help=self.enhance_help_neutron(
-                _("Port to be associated with the floating IP (name or ID)")
-            ),
+            help=_("Port to be associated with the floating IP (name or ID)"),
         )
         parser.add_argument(
             '--floating-ip-address',
             metavar='<ip-address>',
             dest='floating_ip_address',
-            help=self.enhance_help_neutron(_("Floating IP address")),
+            help=_("Floating IP address"),
         )
         parser.add_argument(
             '--fixed-ip-address',
             metavar='<ip-address>',
             dest='fixed_ip_address',
-            help=self.enhance_help_neutron(
-                _("Fixed IP address mapped to the floating IP")
-            ),
+            help=_("Fixed IP address mapped to the floating IP"),
         )
         parser.add_argument(
             '--qos-policy',
             metavar='<qos-policy>',
-            help=self.enhance_help_neutron(
-                _("Attach QoS policy to the floating IP (name or ID)")
-            ),
+            help=_("Attach QoS policy to the floating IP (name or ID)"),
         )
         parser.add_argument(
             '--description',
             metavar='<description>',
-            help=self.enhance_help_neutron(_('Set floating IP description')),
+            help=_('Set floating IP description'),
         )
         parser.add_argument(
             '--project',
             metavar='<project>',
-            help=self.enhance_help_neutron(_("Owner's project (name or ID)")),
+            help=_("Owner's project (name or ID)"),
         )
         parser.add_argument(
             '--dns-domain',
             metavar='<dns-domain>',
             dest='dns_domain',
-            help=self.enhance_help_neutron(
-                _("Set DNS domain for this floating IP")
-            ),
+            help=_("Set DNS domain for this floating IP"),
         )
         parser.add_argument(
             '--dns-name',
             metavar='<dns-name>',
             dest='dns_name',
-            help=self.enhance_help_neutron(
-                _("Set DNS name for this floating IP")
-            ),
+            help=_("Set DNS name for this floating IP"),
         )
 
-        identity_common.add_project_domain_option_to_parser(
-            parser, enhance_help=self.enhance_help_neutron
-        )
-        _tag.add_tag_option_to_parser_for_create(
-            parser, _('floating IP'), enhance_help=self.enhance_help_neutron
-        )
+        identity_common.add_project_domain_option_to_parser(parser)
+        _tag.add_tag_option_to_parser_for_create(parser, _('floating IP'))
         return parser
 
-    def take_action_network(self, client, 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)
         attrs.update(
             self._parse_extra_properties(parsed_args.extra_properties)
         )
-        with common.check_missing_extension_if_error(
-            self.app.client_manager.network, attrs
-        ):
+        with common.check_missing_extension_if_error(client, attrs):
             obj = client.create_ip(**attrs)
 
         # tags cannot be set when created, so tags need to be set later.
@@ -199,21 +187,12 @@ class CreateFloatingIP(
         data = utils.get_item_properties(obj, columns)
         return (display_columns, data)
 
-    def take_action_compute(self, client, parsed_args):
-        obj = compute_v2.create_floating_ip(client, parsed_args.network)
-        columns = _get_columns(obj)
-        data = utils.get_dict_properties(obj, columns)
-        return (columns, data)
-
 
-class DeleteFloatingIP(common.NetworkAndComputeDelete):
+class DeleteFloatingIP(command.Command):
     _description = _("Delete floating IP(s)")
 
-    # Used by base class to find resources in parsed_args.
-    resource = 'floating_ip'
-    r = None
-
-    def update_parser_common(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             'floating_ip',
             metavar="<floating-ip>",
@@ -222,35 +201,52 @@ class DeleteFloatingIP(common.NetworkAndComputeDelete):
         )
         return parser
 
-    def take_action_network(self, client, parsed_args):
-        obj = client.find_ip(
-            self.r,
-            ignore_missing=False,
-        )
-        client.delete_ip(obj)
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        client = self.app.client_manager.network
+        result = 0
+
+        for fip in parsed_args.floating_ip:
+            try:
+                obj = client.find_ip(fip, ignore_missing=False)
+                client.delete_ip(obj)
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete floating IP with "
+                        "name or ID '%(fip)s': %(e)s"
+                    ),
+                    {'fip': fip, 'e': e},
+                )
 
-    def take_action_compute(self, client, parsed_args):
-        compute_v2.delete_floating_ip(client, self.r)
+        if result > 0:
+            total = len(parsed_args.floating_ip)
+            msg = _(
+                "%(result)s of %(total)s floating IPs failed to delete."
+            ) % {
+                'result': result,
+                'total': total,
+            }
+            raise exceptions.CommandError(msg)
 
 
-class ListFloatingIP(common.NetworkAndComputeLister):
+class ListFloatingIP(command.Lister):
     # TODO(songminglong): Use SDK resource mapped attribute names once
     # the OSC minimum requirements include SDK 1.0
 
     _description = _("List floating IP(s)")
 
-    def update_parser_network(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             '--network',
             metavar='<network>',
             dest='networks',
             action='append',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only floating IP(s) with the specified network "
-                    "(name or ID) "
-                    "(repeat option to fiter on multiple networks)"
-                )
+            help=_(
+                "List only floating IP(s) with the specified network "
+                "(name or ID) "
+                "(repeat option to fiter on multiple networks)"
             ),
         )
         parser.add_argument(
@@ -258,53 +254,42 @@ class ListFloatingIP(common.NetworkAndComputeLister):
             metavar='<port>',
             dest='ports',
             action='append',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only floating IP(s) with the specified port "
-                    "(name or ID) "
-                    "(repeat option to fiter on multiple ports)"
-                )
+            help=_(
+                "List only floating IP(s) with the specified port "
+                "(name or ID) "
+                "(repeat option to fiter on multiple ports)"
             ),
         )
         parser.add_argument(
             '--fixed-ip-address',
             metavar='<ip-address>',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only floating IP(s) with the specified fixed IP "
-                    "address"
-                )
+            help=_(
+                "List only floating IP(s) with the specified fixed IP address"
             ),
         )
         parser.add_argument(
             '--floating-ip-address',
             metavar='<ip-address>',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only floating IP(s) with the specified floating IP "
-                    "address"
-                )
+            help=_(
+                "List only floating IP(s) with the specified floating IP "
+                "address"
             ),
         )
         parser.add_argument(
             '--status',
             metavar='<status>',
             choices=['ACTIVE', 'DOWN'],
-            help=self.enhance_help_neutron(
-                _(
-                    "List only floating IP(s) with the specified status "
-                    "('ACTIVE', 'DOWN')"
-                )
+            help=_(
+                "List only floating IP(s) with the specified status "
+                "('ACTIVE', 'DOWN')"
             ),
         )
         parser.add_argument(
             '--project',
             metavar='<project>',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only floating IP(s) with the specified project "
-                    "(name or ID)"
-                )
+            help=_(
+                "List only floating IP(s) with the specified project "
+                "(name or ID)"
             ),
         )
         identity_common.add_project_domain_option_to_parser(parser)
@@ -313,29 +298,24 @@ class ListFloatingIP(common.NetworkAndComputeLister):
             metavar='<router>',
             dest='routers',
             action='append',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only floating IP(s) with the specified router "
-                    "(name or ID) "
-                    "(repeat option to fiter on multiple routers)"
-                )
+            help=_(
+                "List only floating IP(s) with the specified router "
+                "(name or ID) "
+                "(repeat option to fiter on multiple routers)"
             ),
         )
-        _tag.add_tag_filtering_option_to_parser(
-            parser, _('floating IP'), enhance_help=self.enhance_help_neutron
-        )
+        _tag.add_tag_filtering_option_to_parser(parser, _('floating IP'))
         parser.add_argument(
             '--long',
             action='store_true',
             default=False,
-            help=self.enhance_help_neutron(
-                _("List additional fields in output")
-            ),
+            help=_("List additional fields in output"),
         )
-
         return parser
 
-    def take_action_network(self, client, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
         network_client = self.app.client_manager.network
         identity_client = self.app.client_manager.identity
 
@@ -422,7 +402,7 @@ class ListFloatingIP(common.NetworkAndComputeLister):
         _tag.get_tag_filtering_args(parsed_args, query)
 
         try:
-            data = list(client.ips(**query))
+            data = list(network_client.ips(**query))
         except sdk_exceptions.NotFoundException:
             data = []
 
@@ -438,40 +418,11 @@ class ListFloatingIP(common.NetworkAndComputeLister):
             ),
         )
 
-    def take_action_compute(self, client, parsed_args):
-        columns: tuple[str, ...] = (
-            'ID',
-            'IP',
-            'Fixed IP',
-            'Instance ID',
-            'Pool',
-        )
-        headers: tuple[str, ...] = (
-            'ID',
-            'Floating IP Address',
-            'Fixed IP Address',
-            'Server',
-            'Pool',
-        )
-
-        objs = compute_v2.list_floating_ips(client)
-        return (
-            headers,
-            (
-                utils.get_dict_properties(
-                    s,
-                    columns,
-                    formatters={},
-                )
-                for s in objs
-            ),
-        )
-
 
 class SetFloatingIP(common.NeutronCommandWithExtraArgs):
     _description = _("Set floating IP 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(
             'floating_ip',
@@ -512,13 +463,15 @@ class SetFloatingIP(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
-        attrs = {}
         obj = client.find_ip(
             parsed_args.floating_ip,
             ignore_missing=False,
         )
+
+        attrs: dict[str, Any] = {}
+
         if parsed_args.port:
             port = client.find_port(parsed_args.port, ignore_missing=False)
             attrs['port_id'] = port.id
@@ -548,10 +501,11 @@ class SetFloatingIP(common.NeutronCommandWithExtraArgs):
         _tag.update_tags_for_set(client, obj, parsed_args)
 
 
-class ShowFloatingIP(common.NetworkAndComputeShowOne):
+class ShowFloatingIP(command.ShowOne):
     _description = _("Display floating IP details")
 
-    def update_parser_common(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             'floating_ip',
             metavar="<floating-ip>",
@@ -559,7 +513,10 @@ class ShowFloatingIP(common.NetworkAndComputeShowOne):
         )
         return parser
 
-    def take_action_network(self, client, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        client = self.app.client_manager.network
         obj = client.find_ip(
             parsed_args.floating_ip,
             ignore_missing=False,
@@ -568,17 +525,11 @@ class ShowFloatingIP(common.NetworkAndComputeShowOne):
         data = utils.get_item_properties(obj, columns, formatters=_formatters)
         return (display_columns, data)
 
-    def take_action_compute(self, client, parsed_args):
-        obj = compute_v2.get_floating_ip(client, parsed_args.floating_ip)
-        columns = _get_columns(obj)
-        data = utils.get_dict_properties(obj, columns)
-        return (columns, data)
-
 
 class UnsetFloatingIP(common.NeutronCommandWithExtraArgs):
     _description = _("Unset floating IP 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(
             'floating_ip',
@@ -601,7 +552,7 @@ class UnsetFloatingIP(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_ip(
             parsed_args.floating_ip,

openstackclient/network/v2/floating_ip_port_forwarding.py

@@ -13,8 +13,10 @@
 
 """Floating IP Port Forwarding action implementations"""
 
+import argparse
 import logging
-import typing as ty
+from collections.abc import Iterable, Sequence
+from typing import Any
 
 from osc_lib import exceptions
 from osc_lib import utils
@@ -26,7 +28,7 @@ from openstackclient.network import common
 LOG = logging.getLogger(__name__)
 
 
-def validate_ports_diff(ports):
+def validate_ports_diff(ports: list[int]) -> int:
     if len(ports) == 0:
         return 0
 
@@ -40,7 +42,9 @@ def validate_ports_diff(ports):
     return ports_diff
 
 
-def validate_ports_match(internal_ports, external_ports):
+def validate_ports_match(
+    internal_ports: list[int], external_ports: list[int]
+) -> None:
     internal_ports_diff = validate_ports_diff(internal_ports)
     external_ports_diff = validate_ports_diff(external_ports)
 
@@ -52,7 +56,9 @@ def validate_ports_match(internal_ports, external_ports):
         raise exceptions.CommandError(msg)
 
 
-def validate_and_assign_port_ranges(parsed_args, attrs):
+def validate_and_assign_port_ranges(
+    parsed_args: argparse.Namespace, attrs: dict[str, Any]
+) -> None:
     internal_port_range = parsed_args.internal_protocol_port
     external_port_range = parsed_args.external_protocol_port
     external_ports = internal_ports = []
@@ -79,13 +85,13 @@ def validate_and_assign_port_ranges(parsed_args, attrs):
             attrs['external_port'] = int(external_port_range)
 
 
-def validate_port(port):
+def validate_port(port: int) -> None:
     if port <= 0 or port > 65535:
         msg = _("The port number range is <1-65535>")
         raise exceptions.CommandError(msg)
 
 
-def _get_columns(item):
+def _get_columns(item: Any) -> tuple[tuple[str, ...], tuple[str, ...]]:
     hidden_columns = ['location', 'tenant_id']
     return utils.get_osc_show_columns_for_sdk_resource(
         item, {}, hidden_columns
@@ -97,7 +103,7 @@ class CreateFloatingIPPortForwarding(
 ):
     _description = _("Create floating IP port forwarding")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             '--internal-ip-address',
@@ -164,8 +170,10 @@ class CreateFloatingIPPortForwarding(
 
         return parser
 
-    def take_action(self, parsed_args):
-        attrs: dict[str, ty.Any] = {}
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        attrs: dict[str, Any] = {}
         client = self.app.client_manager.network
         floating_ip = client.find_ip(
             parsed_args.floating_ip,
@@ -198,7 +206,7 @@ class CreateFloatingIPPortForwarding(
 class DeleteFloatingIPPortForwarding(command.Command):
     _description = _("Delete floating IP port forwarding")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'floating_ip',
@@ -216,7 +224,7 @@ class DeleteFloatingIPPortForwarding(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
         floating_ip = client.find_ip(
             parsed_args.floating_ip,
@@ -251,7 +259,7 @@ class DeleteFloatingIPPortForwarding(command.Command):
 class ListFloatingIPPortForwarding(command.Lister):
     _description = _("List floating IP port forwarding")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'floating_ip',
@@ -289,7 +297,9 @@ class ListFloatingIPPortForwarding(command.Lister):
 
         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 = (
@@ -315,7 +325,7 @@ class ListFloatingIPPortForwarding(command.Lister):
             'Description',
         )
 
-        query = {}
+        query: dict[str, Any] = {}
 
         if parsed_args.port:
             port = client.find_port(parsed_args.port, ignore_missing=False)
@@ -354,7 +364,7 @@ class ListFloatingIPPortForwarding(command.Lister):
 class SetFloatingIPPortForwarding(common.NeutronCommandWithExtraArgs):
     _description = _("Set floating IP Port Forwarding 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(
             'floating_ip',
@@ -419,7 +429,7 @@ class SetFloatingIPPortForwarding(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
         floating_ip = client.find_ip(
             parsed_args.floating_ip,
@@ -454,7 +464,7 @@ class SetFloatingIPPortForwarding(common.NeutronCommandWithExtraArgs):
 class ShowFloatingIPPortForwarding(command.ShowOne):
     _description = _("Display floating IP Port Forwarding 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(
             'floating_ip',
@@ -471,7 +481,9 @@ class ShowFloatingIPPortForwarding(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
         floating_ip = client.find_ip(
             parsed_args.floating_ip,