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

openstackclient/network/v2/floating_ip.py

@@ -12,34 +12,48 @@
 
 """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 openstack.network.v2 import floating_ip as _floating_ip
 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.common import pagination
 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: _floating_ip.FloatingIP,
+) -> 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 +106,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 +191,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 +205,49 @@ 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_compute(self, client, parsed_args):
-        compute_v2.delete_floating_ip(client, self.r)
+    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},
+                )
 
+        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):
-    # TODO(songminglong): Use SDK resource mapped attribute names once
-    # the OSC minimum requirements include SDK 1.0
 
+class ListFloatingIP(command.Lister):
     _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 +255,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 +299,25 @@ 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"),
         )
-
+        pagination.add_marker_pagination_option_to_parser(parser)
         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
 
@@ -418,11 +400,17 @@ class ListFloatingIP(common.NetworkAndComputeLister):
                 ).id
                 router_ids.append(router_id)
             query['router_id'] = router_ids
+        if parsed_args.marker is not None:
+            query['marker'] = parsed_args.marker
+        if parsed_args.limit is not None:
+            query['limit'] = parsed_args.limit
+        if parsed_args.max_items is not None:
+            query['max_items'] = parsed_args.max_items
 
         _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 +426,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 +471,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 +509,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 +521,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 +533,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 +560,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,