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

openstackclient/network/v2/network.py

@@ -12,25 +12,32 @@
 
 """Network action implementations"""
 
+import argparse
+from collections.abc import Iterable, Sequence
+import logging
+from typing import Any
+
 from cliff import columns as cliff_columns
 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__)
+
 
 class AdminStateColumn(cliff_columns.FormattableColumn[bool]):
-    def human_readable(self):
+    def human_readable(self) -> str:
         return 'UP' if self._value else 'DOWN'
 
 
 class RouterExternalColumn(cliff_columns.FormattableColumn[bool]):
-    def human_readable(self):
+    def human_readable(self) -> str:
         return 'External' if self._value else 'Internal'
 
 
@@ -47,7 +54,7 @@ _formatters = {
 }
 
 
-def _get_columns_network(item):
+def _get_columns_network(item: Any) -> tuple[tuple[str, ...], tuple[str, ...]]:
     column_map = {
         'subnet_ids': 'subnets',
         'is_admin_state_up': 'admin_state_up',
@@ -67,11 +74,13 @@ def _get_columns_network(item):
     )
 
 
-def _get_columns_compute(item):
+def _get_columns_compute(item: Any) -> tuple[tuple[str, ...], tuple[str, ...]]:
     return utils.get_osc_show_columns_for_sdk_resource(item, {})
 
 
-def _get_attrs_network(client_manager, parsed_args):
+def _get_attrs_network(
+    client_manager: Any, parsed_args: argparse.Namespace
+) -> dict[str, Any]:
     attrs = {}
     if parsed_args.name is not None:
         attrs['name'] = parsed_args.name
@@ -143,7 +152,9 @@ def _get_attrs_network(client_manager, parsed_args):
     return attrs
 
 
-def _get_attrs_compute(client_manager, parsed_args):
+def _get_attrs_compute(
+    client_manager: Any, parsed_args: argparse.Namespace
+) -> dict[str, Any]:
     attrs = {}
     if parsed_args.name is not None:
         attrs['name'] = parsed_args.name
@@ -156,7 +167,7 @@ def _get_attrs_compute(client_manager, parsed_args):
     return attrs
 
 
-def _add_additional_network_options(parser):
+def _add_additional_network_options(parser: argparse.ArgumentParser) -> None:
     # Add additional network options
 
     parser.add_argument(
@@ -199,12 +210,11 @@ def _add_additional_network_options(parser):
 
 # TODO(sindhu): Use the SDK resource mapped attribute names once the
 # OSC minimum requirements include SDK 1.0.
-class CreateNetwork(
-    common.NetworkAndComputeShowOne, common.NeutronCommandWithExtraArgs
-):
+class CreateNetwork(command.ShowOne, common.NeutronCommandWithExtraArgs):
     _description = _("Create new network")
 
-    def update_parser_common(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             'name', metavar='<name>', help=_("New network name")
         )
@@ -220,35 +230,32 @@ class CreateNetwork(
             action='store_true',
             help=_("Do not share the network between projects"),
         )
-        return parser
-
-    def update_parser_network(self, parser):
         admin_group = parser.add_mutually_exclusive_group()
         admin_group.add_argument(
             '--enable',
             action='store_true',
             default=True,
-            help=self.enhance_help_neutron(_("Enable network (default)")),
+            help=_("Enable network (default)"),
         )
         admin_group.add_argument(
             '--disable',
             action='store_true',
-            help=self.enhance_help_neutron(_("Disable network")),
+            help=_("Disable network"),
         )
         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(
             '--description',
             metavar='<description>',
-            help=self.enhance_help_neutron(_("Set network description")),
+            help=_("Set network description"),
         )
         parser.add_argument(
             '--mtu',
             metavar='<mtu>',
-            help=self.enhance_help_neutron(_("Set network mtu")),
+            help=_("Set network mtu"),
         )
         identity_common.add_project_domain_option_to_parser(parser)
         parser.add_argument(
@@ -256,133 +263,99 @@ class CreateNetwork(
             action='append',
             dest='availability_zone_hints',
             metavar='<availability-zone>',
-            help=self.enhance_help_neutron(
-                _(
-                    "Availability Zone in which to create this network "
-                    "(Network Availability Zone extension required, "
-                    "repeat option to set multiple availability zones)"
-                )
+            help=_(
+                "Availability Zone in which to create this network "
+                "(Network Availability Zone extension required, "
+                "repeat option to set multiple availability zones)"
             ),
         )
         port_security_group = parser.add_mutually_exclusive_group()
         port_security_group.add_argument(
             '--enable-port-security',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Enable port security by default for ports created on "
-                    "this network (default)"
-                )
+            help=_(
+                "Enable port security by default for ports created on "
+                "this network (default)"
             ),
         )
         port_security_group.add_argument(
             '--disable-port-security',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Disable port security by default for ports created on "
-                    "this network"
-                )
+            help=_(
+                "Disable port security by default for ports created on "
+                "this network"
             ),
         )
         external_router_grp = parser.add_mutually_exclusive_group()
         external_router_grp.add_argument(
             '--external',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "The network has an external routing facility that is not "
-                    "managed by Neutron and can be used. For example: "
-                    "openstack router set --external-gateway NETWORK "
-                    "(external-net extension required)"
-                )
+            help=_(
+                "The network has an external routing facility that is not "
+                "managed by Neutron and can be used. For example: "
+                "openstack router set --external-gateway NETWORK "
+                "(external-net extension required)"
             ),
         )
         external_router_grp.add_argument(
             '--internal',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Opposite of '--external' (default)")
-            ),
+            help=_("Opposite of '--external' (default)"),
         )
         default_router_grp = parser.add_mutually_exclusive_group()
         default_router_grp.add_argument(
             '--default',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Specify if this network should be used as the default "
-                    "external network"
-                )
+            help=_(
+                "Specify if this network should be used as the default "
+                "external network"
             ),
         )
         default_router_grp.add_argument(
             '--no-default',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Do not use the network as the default external network "
-                    "(default)"
-                )
+            help=_(
+                "Do not use the network as the default external network "
+                "(default)"
             ),
         )
         parser.add_argument(
             '--qos-policy',
             metavar='<qos-policy>',
-            help=self.enhance_help_neutron(
-                _("QoS policy to attach to this network (name or ID)")
-            ),
+            help=_("QoS policy to attach to this network (name or ID)"),
         )
         vlan_transparent_grp = parser.add_mutually_exclusive_group()
         vlan_transparent_grp.add_argument(
             '--transparent-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Make the network VLAN transparent")
-            ),
+            help=_("Make the network VLAN transparent"),
         )
         vlan_transparent_grp.add_argument(
             '--no-transparent-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Do not make the network VLAN transparent")
-            ),
+            help=_("Do not make the network VLAN transparent"),
         )
 
         vlan_qinq_grp = parser.add_mutually_exclusive_group()
         vlan_qinq_grp.add_argument(
             '--qinq-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Enable VLAN QinQ (S-Tag ethtype 0x8a88) for the network")
-            ),
+            help=_("Enable VLAN QinQ (S-Tag ethtype 0x8a88) for the network"),
         )
         vlan_qinq_grp.add_argument(
             '--no-qinq-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Disable VLAN QinQ (S-Tag ethtype 0x8a88) for the network")
-            ),
+            help=_("Disable VLAN QinQ (S-Tag ethtype 0x8a88) for the network"),
         )
 
         _add_additional_network_options(parser)
-        _tag.add_tag_option_to_parser_for_create(
-            parser, _('network'), enhance_help=self.enhance_help_neutron
-        )
+        _tag.add_tag_option_to_parser_for_create(parser, _('network'))
         return parser
 
-    def update_parser_compute(self, parser):
-        parser.add_argument(
-            '--subnet',
-            metavar='<subnet>',
-            required=True,
-            help=self.enhance_help_nova_network(
-                _("IPv4 subnet for fixed IPs (in CIDR notation)")
-            ),
-        )
-        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_network(self.app.client_manager, parsed_args)
         if parsed_args.transparent_vlan:
             attrs['vlan_transparent'] = True
@@ -425,81 +398,85 @@ class CreateNetwork(
         data = utils.get_item_properties(obj, columns, formatters=_formatters)
         return (display_columns, data)
 
-    def take_action_compute(self, client, parsed_args):
-        attrs = _get_attrs_compute(self.app.client_manager, parsed_args)
-        obj = compute_v2.create_network(client, **attrs)
-        display_columns, columns = _get_columns_compute(obj)
-        data = utils.get_dict_properties(obj, columns)
-        return (display_columns, data)
-
 
-class DeleteNetwork(common.NetworkAndComputeDelete):
+class DeleteNetwork(command.Command):
     _description = _("Delete network(s)")
 
-    # Used by base class to find resources in parsed_args.
-    resource = 'network'
-    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(
             'network',
             metavar="<network>",
             nargs="+",
             help=_("Network(s) to delete (name or ID)"),
         )
-
         return parser
 
-    def take_action_network(self, client, parsed_args):
-        obj = client.find_network(self.r, ignore_missing=False)
-        client.delete_network(obj)
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        client = self.app.client_manager.network
+        result = 0
+
+        for net in parsed_args.network:
+            try:
+                obj = client.find_network(net, ignore_missing=False)
+                client.delete_network(obj)
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete network with "
+                        "name or ID '%(network)s': %(e)s"
+                    ),
+                    {'network': net, 'e': e},
+                )
 
-    def take_action_compute(self, client, parsed_args):
-        network = compute_v2.find_network(client, self.r)
-        compute_v2.delete_network(client, network['id'])
+        if result > 0:
+            total = len(parsed_args.network)
+            msg = _("%(result)s of %(total)s networks failed to delete.") % {
+                'result': result,
+                'total': total,
+            }
+            raise exceptions.CommandError(msg)
 
 
 # TODO(sindhu): Use the SDK resource mapped attribute names once the
 # OSC minimum requirements include SDK 1.0.
-class ListNetwork(common.NetworkAndComputeLister):
+class ListNetwork(command.Lister):
     _description = _("List networks")
 
-    def update_parser_network(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         router_ext_group = parser.add_mutually_exclusive_group()
         router_ext_group.add_argument(
             '--external',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only external networks")),
+            help=_("List only external networks"),
         )
         router_ext_group.add_argument(
             '--internal',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only internal networks")),
+            help=_("List only internal networks"),
         )
         parser.add_argument(
             '--long',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("List additional fields in output")
-            ),
+            help=_("List additional fields in output"),
         )
         parser.add_argument(
             '--name',
             metavar='<name>',
-            help=self.enhance_help_neutron(
-                _("List only networks with the specified name")
-            ),
+            help=_("List only networks with the specified name"),
         )
         admin_state_group = parser.add_mutually_exclusive_group()
         admin_state_group.add_argument(
             '--enable',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only enabled networks")),
+            help=_("List only enabled networks"),
         )
         admin_state_group.add_argument(
             '--disable',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only disabled networks")),
+            help=_("List only disabled networks"),
         )
         parser.add_argument(
             '--project',
@@ -508,85 +485,69 @@ class ListNetwork(common.NetworkAndComputeLister):
                 "List only networks with the specified project (name or ID)"
             ),
         )
-        identity_common.add_project_domain_option_to_parser(
-            parser, enhance_help=self.enhance_help_neutron
-        )
+        identity_common.add_project_domain_option_to_parser(parser)
         shared_group = parser.add_mutually_exclusive_group()
         shared_group.add_argument(
             '--share',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("List only networks shared between projects")
-            ),
+            help=_("List only networks shared between projects"),
         )
         shared_group.add_argument(
             '--no-share',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("List only networks not shared between projects")
-            ),
+            help=_("List only networks not shared between projects"),
         )
         parser.add_argument(
             '--status',
             metavar='<status>',
             choices=['ACTIVE', 'BUILD', 'DOWN', 'ERROR'],
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified status "
-                    "('ACTIVE', 'BUILD', 'DOWN', 'ERROR')"
-                )
+            help=_(
+                "List only networks with the specified status "
+                "('ACTIVE', 'BUILD', 'DOWN', 'ERROR')"
             ),
         )
         parser.add_argument(
             '--provider-network-type',
             metavar='<provider-network-type>',
             choices=['flat', 'geneve', 'gre', 'local', 'vlan', 'vxlan'],
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified physical "
-                    "mechanisms. "
-                    "The supported options are: flat, geneve, gre, local, "
-                    "vlan and vxlan."
-                )
+            help=_(
+                "List only networks with the specified physical "
+                "mechanisms. "
+                "The supported options are: flat, geneve, gre, local, "
+                "vlan and vxlan."
             ),
         )
         parser.add_argument(
             '--provider-physical-network',
             metavar='<provider-physical-network>',
             dest='physical_network',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified physical network "
-                    "name"
-                )
+            help=_(
+                "List only networks with the specified physical network name"
             ),
         )
         parser.add_argument(
             '--provider-segment',
             metavar='<provider-segment>',
             dest='segmentation_id',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified provider segment "
-                    "ID (VLAN ID for VLAN networks or "
-                    "Tunnel ID for GENEVE/GRE/VXLAN networks)"
-                )
+            help=_(
+                "List only networks with the specified provider segment "
+                "ID (VLAN ID for VLAN networks or "
+                "Tunnel ID for GENEVE/GRE/VXLAN networks)"
             ),
         )
         parser.add_argument(
             '--agent',
             metavar='<agent-id>',
             dest='agent_id',
-            help=self.enhance_help_neutron(
-                _('List only networks hosted the specified agent (ID only)')
-            ),
-        )
-        _tag.add_tag_filtering_option_to_parser(
-            parser, _('networks'), enhance_help=self.enhance_help_neutron
+            help=_('List only networks hosted the specified agent (ID only)'),
         )
+        _tag.add_tag_filtering_option_to_parser(parser, _('networks'))
         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
         identity_client = self.app.client_manager.identity
         if parsed_args.long:
             columns: tuple[str, ...] = (
@@ -708,39 +669,13 @@ class ListNetwork(common.NetworkAndComputeLister):
             ),
         )
 
-    def take_action_compute(self, client, parsed_args):
-        columns = (
-            'id',
-            'label',
-            'cidr',
-        )
-        column_headers = (
-            'ID',
-            'Name',
-            'Subnet',
-        )
-
-        data = compute_v2.list_networks(client)
-
-        return (
-            column_headers,
-            (
-                utils.get_dict_properties(
-                    s,
-                    columns,
-                    formatters=_formatters,
-                )
-                for s in data
-            ),
-        )
-
 
 # TODO(sindhu): Use the SDK resource mapped attribute names once the
 # OSC minimum requirements include SDK 1.0.
 class SetNetwork(common.NeutronCommandWithExtraArgs):
     _description = _("Set network 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(
             'network',
@@ -839,7 +774,7 @@ class SetNetwork(common.NeutronCommandWithExtraArgs):
         _add_additional_network_options(parser)
         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_network(parsed_args.network, ignore_missing=False)
 
@@ -857,10 +792,11 @@ class SetNetwork(common.NeutronCommandWithExtraArgs):
         _tag.update_tags_for_set(client, obj, parsed_args)
 
 
-class ShowNetwork(common.NetworkAndComputeShowOne):
+class ShowNetwork(command.ShowOne):
     _description = _("Show network 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(
             'network',
             metavar="<network>",
@@ -868,23 +804,20 @@ class ShowNetwork(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_network(parsed_args.network, ignore_missing=False)
         display_columns, columns = _get_columns_network(obj)
         data = utils.get_item_properties(obj, columns, formatters=_formatters)
         return (display_columns, data)
 
-    def take_action_compute(self, client, parsed_args):
-        obj = compute_v2.find_network(client, parsed_args.network)
-        display_columns, columns = _get_columns_compute(obj)
-        data = utils.get_dict_properties(obj, columns)
-        return (display_columns, data)
-
 
 class UnsetNetwork(common.NeutronUnsetCommandWithExtraArgs):
     _description = _("Unset network 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(
             'network',
@@ -894,7 +827,7 @@ class UnsetNetwork(common.NeutronUnsetCommandWithExtraArgs):
         _tag.add_tag_option_to_parser_for_unset(parser, _('network'))
         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_network(parsed_args.network, ignore_missing=False)