Merge pull request #19 from stackhpc/upstream/yoga-2022-12-26

Synchronise yoga with upstream

Author: mnasiadka

neutron/cmd/remove_duplicated_port_bindings.py

@@ -20,15 +20,14 @@
 from oslo_db import options as db_options
 from oslo_log import log as logging
 
-from neutron.common import config as common_config
+from neutron.common import config as common_config  # noqa
 from neutron.objects import ports as ports_obj
 
 
 LOG = logging.getLogger(__name__)
 
 
 def setup_conf(conf):
-    common_config.register_common_config_options()
     db_group, neutron_db_opts = db_options.list_opts()[0]
     conf.register_cli_opts(neutron_db_opts, db_group)
     conf()

neutron/common/ovn/constants.py

@@ -32,6 +32,8 @@
 OVN_GW_PORT_EXT_ID_KEY = 'neutron:gw_port_id'
 OVN_SUBNET_EXT_ID_KEY = 'neutron:subnet_id'
 OVN_SUBNET_EXT_IDS_KEY = 'neutron:subnet_ids'
+OVN_SUBNET_POOL_EXT_ADDR_SCOPE4_KEY = 'neutron:subnet_pool_addr_scope4'
+OVN_SUBNET_POOL_EXT_ADDR_SCOPE6_KEY = 'neutron:subnet_pool_addr_scope6'
 OVN_PHYSNET_EXT_ID_KEY = 'neutron:provnet-physical-network'
 OVN_NETTYPE_EXT_ID_KEY = 'neutron:provnet-network-type'
 OVN_SEGID_EXT_ID_KEY = 'neutron:provnet-segmentation-id'

neutron/plugins/ml2/drivers/ovn/mech_driver/ovsdb/maintenance.py

@@ -600,6 +600,47 @@ def check_for_igmp_snoop_support(self):
 
         raise periodics.NeverAgain()
 
+    # TODO(czesla): Remove this in the A+4 cycle
+    # A static spacing value is used here, but this method will only run
+    # once per lock due to the use of periodics.NeverAgain().
+    @periodics.periodic(spacing=600, run_immediately=True)
+    def check_port_has_address_scope(self):
+        if not self.has_lock:
+            return
+
+        ports = self._nb_idl.db_find_rows(
+            "Logical_Switch_Port", ("type", "!=", ovn_const.LSP_TYPE_LOCALNET)
+        ).execute(check_error=True)
+
+        context = n_context.get_admin_context()
+        with self._nb_idl.transaction(check_error=True) as txn:
+            for port in ports:
+                if (
+                    port.external_ids.get(
+                        ovn_const.OVN_SUBNET_POOL_EXT_ADDR_SCOPE4_KEY
+                    ) is None or
+                    port.external_ids.get(
+                        ovn_const.OVN_SUBNET_POOL_EXT_ADDR_SCOPE6_KEY
+                    ) is None
+                ):
+                    try:
+                        port_neutron = self._ovn_client._plugin.get_port(
+                            context, port.name
+                        )
+
+                        port_info, external_ids = (
+                            self._ovn_client.get_external_ids_from_port(
+                                port_neutron)
+                        )
+                        txn.add(self._nb_idl.set_lswitch_port(
+                            port.name, external_ids=external_ids))
+                    except n_exc.PortNotFound:
+                        # The sync function will fix this port
+                        pass
+                    except Exception:
+                        LOG.exception('Failed to update port %s', port.name)
+        raise periodics.NeverAgain()
+
     def _delete_default_ha_chassis_group(self, txn):
         # TODO(lucasgomes): Remove the deletion of the
         # HA_CHASSIS_GROUP_DEFAULT_NAME in the Y cycle. We no longer
@@ -828,7 +869,11 @@ def update_port_virtual_type(self):
             if lsp.type != '':
                 continue
 
-            port = self._ovn_client._plugin.get_port(context, lsp.name)
+            try:
+                port = self._ovn_client._plugin.get_port(context, lsp.name)
+            except n_exc.PortNotFound:
+                continue
+
             for ip in port.get('fixed_ips', []):
                 if utils.get_virtual_port_parents(
                         self._nb_idl, ip['ip_address'], port['network_id'],

neutron/plugins/ml2/drivers/ovn/mech_driver/ovsdb/ovn_client.py

@@ -58,9 +58,23 @@
 
 
 OvnPortInfo = collections.namedtuple(
-    'OvnPortInfo', ['type', 'options', 'addresses', 'port_security',
-                    'parent_name', 'tag', 'dhcpv4_options', 'dhcpv6_options',
-                    'cidrs', 'device_owner', 'security_group_ids'])
+    "OvnPortInfo",
+    [
+        "type",
+        "options",
+        "addresses",
+        "port_security",
+        "parent_name",
+        "tag",
+        "dhcpv4_options",
+        "dhcpv6_options",
+        "cidrs",
+        "device_owner",
+        "security_group_ids",
+        "address4_scope_id",
+        "address6_scope_id",
+    ],
+)
 
 
 GW_INFO = collections.namedtuple('GatewayInfo', ['network_id', 'subnet_id',
@@ -264,6 +278,8 @@ def _get_port_options(self, port):
 
         port_type = ''
         cidrs = ''
+        address4_scope_id = ""
+        address6_scope_id = ""
         dhcpv4_options = self._get_port_dhcp_options(port, const.IP_VERSION_4)
         dhcpv6_options = self._get_port_dhcp_options(port, const.IP_VERSION_6)
         if vtep_physical_switch:
@@ -306,6 +322,26 @@ def _get_port_options(self, port):
                                   ip_addr)
                         continue
 
+                    if subnet["subnetpool_id"]:
+                        try:
+                            subnet_pool = self._plugin.get_subnetpool(
+                                context, id=subnet["subnetpool_id"]
+                            )
+                            if subnet_pool["address_scope_id"]:
+                                ip_version = subnet_pool["ip_version"]
+                                if ip_version == const.IP_VERSION_4:
+                                    address4_scope_id = subnet_pool[
+                                        "address_scope_id"
+                                    ]
+                                elif ip_version == const.IP_VERSION_6:
+                                    address6_scope_id = subnet_pool[
+                                        "address_scope_id"
+                                    ]
+                        except n_exc.SubnetPoolNotFound:
+                            # swallow the exception and just continue if the
+                            # lookup failed
+                            pass
+
                     cidrs += ' {}/{}'.format(ip['ip_address'],
                                              subnet['cidr'].split('/')[1])
 
@@ -403,7 +439,9 @@ def _get_port_options(self, port):
         sg_ids = ' '.join(utils.get_lsp_security_groups(port))
         return OvnPortInfo(port_type, options, addresses, port_security,
                            parent_name, tag, dhcpv4_options, dhcpv6_options,
-                           cidrs.strip(), device_owner, sg_ids)
+                           cidrs.strip(), device_owner, sg_ids,
+                           address4_scope_id, address6_scope_id
+                           )
 
     def sync_ha_chassis_group(self, context, network_id, txn):
         """Return the UUID of the HA Chassis Group.
@@ -496,20 +534,32 @@ def create_port(self, context, port):
         if utils.is_lsp_ignored(port):
             return
 
+    def get_external_ids_from_port(self, port):
         port_info = self._get_port_options(port)
         external_ids = {ovn_const.OVN_PORT_NAME_EXT_ID_KEY: port['name'],
                         ovn_const.OVN_DEVID_EXT_ID_KEY: port['device_id'],
                         ovn_const.OVN_PROJID_EXT_ID_KEY: port['project_id'],
                         ovn_const.OVN_CIDRS_EXT_ID_KEY: port_info.cidrs,
                         ovn_const.OVN_DEVICE_OWNER_EXT_ID_KEY:
                             port_info.device_owner,
+                        ovn_const.OVN_SUBNET_POOL_EXT_ADDR_SCOPE4_KEY:
+                            port_info.address4_scope_id,
+                        ovn_const.OVN_SUBNET_POOL_EXT_ADDR_SCOPE6_KEY:
+                            port_info.address6_scope_id,
                         ovn_const.OVN_NETWORK_NAME_EXT_ID_KEY:
                             utils.ovn_name(port['network_id']),
                         ovn_const.OVN_SG_IDS_EXT_ID_KEY:
                             port_info.security_group_ids,
                         ovn_const.OVN_REV_NUM_EXT_ID_KEY: str(
                             utils.get_revision_number(
                                 port, ovn_const.TYPE_PORTS))}
+        return port_info, external_ids
+
+    def create_port(self, context, port):
+        if utils.is_lsp_ignored(port):
+            return
+
+        port_info, external_ids = self.get_external_ids_from_port(port)
         lswitch_name = utils.ovn_name(port['network_id'])
 
         # It's possible to have a network created on one controller and then a
@@ -615,20 +665,8 @@ def _set_unset_virtual_port_type(self, context, txn, parent_port,
     def update_port(self, context, port, port_object=None):
         if utils.is_lsp_ignored(port):
             return
-        port_info = self._get_port_options(port)
-        external_ids = {ovn_const.OVN_PORT_NAME_EXT_ID_KEY: port['name'],
-                        ovn_const.OVN_DEVID_EXT_ID_KEY: port['device_id'],
-                        ovn_const.OVN_PROJID_EXT_ID_KEY: port['project_id'],
-                        ovn_const.OVN_CIDRS_EXT_ID_KEY: port_info.cidrs,
-                        ovn_const.OVN_DEVICE_OWNER_EXT_ID_KEY:
-                            port_info.device_owner,
-                        ovn_const.OVN_NETWORK_NAME_EXT_ID_KEY:
-                            utils.ovn_name(port['network_id']),
-                        ovn_const.OVN_SG_IDS_EXT_ID_KEY:
-                            port_info.security_group_ids,
-                        ovn_const.OVN_REV_NUM_EXT_ID_KEY: str(
-                            utils.get_revision_number(
-                                port, ovn_const.TYPE_PORTS))}
+
+        port_info, external_ids = self.get_external_ids_from_port(port)
 
         check_rev_cmd = self._nb_idl.check_revision_number(
             port['id'], port, ovn_const.TYPE_PORTS)

neutron/plugins/ml2/drivers/ovn/mech_driver/ovsdb/ovsdb_monitor.py

@@ -336,7 +336,7 @@ def match_fn(self, event, row, old=None):
         # don't update the AgentCache. We use chassis_private.chassis to return
         # data about the agent.
         return event == self.ROW_CREATE or (
-            getattr(old, 'nb_cfg', False) and not
+            hasattr(old, 'nb_cfg') and not
             (self.table == 'Chassis_Private' and not row.chassis))
 
     def run(self, event, row, old):

neutron/plugins/ml2/plugin.py

@@ -20,6 +20,7 @@
 from netaddr.strategy import eui48
 from neutron_lib.agent import constants as agent_consts
 from neutron_lib.agent import topics
+from neutron_lib.api import converters
 from neutron_lib.api.definitions import address_group as addrgrp_def
 from neutron_lib.api.definitions import address_scope
 from neutron_lib.api.definitions import agent as agent_apidef
@@ -1563,11 +1564,36 @@ def _after_create_port(self, context, result, mech_context):
 
         return bound_context.current
 
-    def allocate_ips_for_ports(self, context, ports):
+    def allocate_macs_and_ips_for_ports(self, context, ports):
+        macs = self._generate_macs(len(ports))
+        network_cache = dict()
         for port in ports:
             port['port']['id'] = (
                 port['port'].get('id') or uuidutils.generate_uuid())
 
+            network_id = port['port'].get('network_id')
+            if network_id not in network_cache:
+                network = self.get_network(context, network_id)
+                network_cache[network_id] = network
+
+            raw_mac_address = port['port'].get('mac_address',
+                                               const.ATTR_NOT_SPECIFIED)
+            if raw_mac_address is const.ATTR_NOT_SPECIFIED:
+                raw_mac_address = macs.pop()
+            elif self._is_mac_in_use(context, network_id, raw_mac_address):
+                raise exc.MacAddressInUse(net_id=network_id,
+                                          mac=raw_mac_address)
+            eui_mac_address = converters.convert_to_sanitized_mac_address(
+                raw_mac_address)
+            # Create the Port object
+            # Note: netaddr has an issue with using the correct dialect when
+            # the input for EUI is another EUI object, see:
+            # https://github.com/netaddr/netaddr/issues/250
+            # TODO(lajoskatona): remove this once
+            # https://review.opendev.org/c/openstack/neutron-lib/+/865517 is
+            # released.
+            port['port']['mac_address'] = str(eui_mac_address)
+
             # Call IPAM to allocate IP addresses
             try:
                 port['ipams'] = self.ipam.allocate_ips_for_port(context, port)
@@ -1577,18 +1603,19 @@ def allocate_ips_for_ports(self, context, ports):
             except ipam_exc.DeferIpam:
                 port['ip_allocation'] = (ipalloc_apidef.
                                          IP_ALLOCATION_DEFERRED)
-        return ports
+        return ports, network_cache
 
     @utils.transaction_guard
     def create_port_bulk(self, context, ports):
         port_list = ports.get('ports')
         for port in port_list:
             self._before_create_port(context, port)
 
-        port_list = self.allocate_ips_for_ports(context, port_list)
+        port_list, net_cache = self.allocate_macs_and_ips_for_ports(
+            context, port_list)
 
         try:
-            return self._create_port_bulk(context, port_list)
+            return self._create_port_bulk(context, port_list, net_cache)
         except Exception:
             with excutils.save_and_reraise_exception():
                 # If any issue happened allocated IP addresses needs to be
@@ -1598,17 +1625,16 @@ def create_port_bulk(self, context, ports):
                         context, port, port['ipams'])
 
     @db_api.retry_if_session_inactive()
-    def _create_port_bulk(self, context, port_list):
+    def _create_port_bulk(self, context, port_list, network_cache):
         # TODO(njohnston): Break this up into smaller functions.
         port_data = []
-        network_cache = dict()
-        macs = self._generate_macs(len(port_list))
         with db_api.CONTEXT_WRITER.using(context):
             for port in port_list:
                 # Set up the port request dict
                 pdata = port.get('port')
                 project_id = pdata.get('project_id') or pdata.get('tenant_id')
                 security_group_ids = pdata.get('security_groups')
+                network_id = pdata.get('network_id')
                 if security_group_ids is const.ATTR_NOT_SPECIFIED:
                     security_group_ids = None
                 else:
@@ -1620,39 +1646,21 @@ def _create_port_bulk(self, context, port_list):
                 bulk_port_data = dict(
                     project_id=project_id,
                     name=pdata.get('name'),
-                    network_id=pdata.get('network_id'),
+                    network_id=network_id,
                     admin_state_up=pdata.get('admin_state_up'),
                     status=pdata.get('status',
                         const.PORT_STATUS_ACTIVE),
                     device_id=pdata.get('device_id'),
                     device_owner=pdata.get('device_owner'),
                     description=pdata.get('description'))
 
-                # Ensure that the networks exist.
-                network_id = pdata.get('network_id')
-                if network_id not in network_cache:
-                    network = self.get_network(context, network_id)
-                    network_cache[network_id] = network
-                else:
-                    network = network_cache[network_id]
-
-                # Determine the MAC address
-                raw_mac_address = pdata.get('mac_address',
-                    const.ATTR_NOT_SPECIFIED)
-                if raw_mac_address is const.ATTR_NOT_SPECIFIED:
-                    raw_mac_address = macs.pop()
-                elif self._is_mac_in_use(context, network_id, raw_mac_address):
-                    raise exc.MacAddressInUse(net_id=network_id,
-                                              mac=raw_mac_address)
-                eui_mac_address = netaddr.EUI(raw_mac_address,
-                                              dialect=eui48.mac_unix_expanded)
-                port['port']['mac_address'] = str(eui_mac_address)
-
-                # Create the Port object
-                db_port_obj = ports_obj.Port(context,
-                                            mac_address=eui_mac_address,
-                                            id=port['port']['id'],
-                                            **bulk_port_data)
+                network = network_cache[network_id]
+
+                db_port_obj = ports_obj.Port(
+                    context,
+                    mac_address=netaddr.EUI(port['port']['mac_address'],
+                                            dialect=eui48.mac_unix_expanded),
+                    id=port['port']['id'], **bulk_port_data)
                 db_port_obj.create()
 
                 # Call IPAM to store allocated IP addresses