Revert "Backport Gateway_Chassis to HA_Chassis_Group migration"

Author: mnasiadka

neutron/common/ovn/utils.py

@@ -68,8 +68,6 @@
     'HAChassisGroupInfo', ['group_name', 'chassis_list', 'az_hints',
                            'ignore_chassis', 'external_ids'])
 
-_OVS_PERSIST_UUID = _SENTINEL = object()
-
 
 class OvsdbClientCommand:
     _CONNECTION = 0
@@ -905,16 +903,6 @@ def get_chassis_without_azs(chassis_list):
             get_chassis_availability_zones(ch)}
 
 
-def get_chassis_priority(chassis_list):
-    """Given a chassis list, returns a dictionary with chassis name and prio
-
-    The chassis list is ordered according to the priority: the first one is the
-    highest priority chassis, the last one is the least priority chassis.
-    """
-    return {chassis: prio + 1 for prio, chassis
-            in enumerate(reversed(chassis_list))}
-
-
 def parse_ovn_lb_port_forwarding(ovn_rtr_lb_pfs):
     """Return a dictionary compatible with port forwarding from OVN lb."""
     result = {}
@@ -1389,41 +1377,3 @@ def validate_port_forwarding_configuration():
     if any(net_type in provider_network_types
            for net_type in cfg.CONF.ml2.tenant_network_types):
         raise ovn_exc.InvalidPortForwardingConfiguration()
-
-
-def ovs_persist_uuid_supported(nb_idl):
-    # OVS 3.1+ contain the persist_uuid feature that allows choosing the UUID
-    # that will be stored in the DB. It was broken prior to 3.1.5/3.2.3/3.3.1
-    # so this will return True only for the fixed version. As actually testing
-    # the fix requires committing a transaction, an implementation detail is
-    # tested. This can be removed once a fixed version is required.
-    global _OVS_PERSIST_UUID
-    if _OVS_PERSIST_UUID is _SENTINEL:
-        _OVS_PERSIST_UUID = isinstance(
-            next(iter(nb_idl.tables["NB_Global"].rows.data.values())), list)
-        LOG.debug(f"OVS persist_uuid supported={_OVS_PERSIST_UUID}")
-    return _OVS_PERSIST_UUID
-
-
-def get_logical_router_port_ha_chassis(nb_idl, lrp, priorities=None):
-    """Get the list of chassis hosting this Logical_Router_Port.
-
-    :param nb_idl: (``OvsdbNbOvnIdl``) OVN Northbound IDL
-    :param lrp: Logical_Router_Port
-    :param priorities: (list of int) a list of HA_Chassis chassis priorities
-           to search for
-    :return: List of tuples (chassis_name, priority) sorted by priority. If
-             ``priorities`` is set then only chassis matching of these
-             priorities are returned.
-    """
-    chassis = []
-    lrp = nb_idl.lookup('Logical_Router_Port', lrp.name, default=None)
-    if not lrp or not lrp.ha_chassis_group:
-        return chassis
-
-    for hc in lrp.ha_chassis_group[0].ha_chassis:
-        if priorities and hc.priority not in priorities:
-            continue
-        chassis.append((hc.chassis_name, hc.priority))
-
-    return chassis

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

@@ -70,7 +70,6 @@
 from neutron.plugins.ml2.drivers.ovn.mech_driver.ovsdb import maintenance
 from neutron.plugins.ml2.drivers.ovn.mech_driver.ovsdb import ovn_client
 from neutron.plugins.ml2.drivers.ovn.mech_driver.ovsdb import ovn_db_sync
-from neutron.plugins.ml2.drivers.ovn.mech_driver.ovsdb import ovs_fixes
 from neutron.plugins.ml2.drivers.ovn.mech_driver.ovsdb import worker
 from neutron import service
 from neutron.services.logapi.drivers.ovn import driver as log_driver
@@ -420,9 +419,6 @@ def post_fork_initialize(self, resource, event, trigger, payload=None):
         self._post_fork_event.clear()
         self._ovn_client_inst = None
 
-        # Patch python-ovs for fixes not yet released
-        ovs_fixes.apply_ovs_fixes()
-
         if worker_class == wsgi.WorkerService:
             self._setup_hash_ring()
 

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

@@ -13,14 +13,10 @@
 #    under the License.
 
 import abc
-import copy
-import uuid
 
 from oslo_utils import timeutils
-from ovs.db import idl as ovs_idl
 from ovsdbapp.backend.ovs_idl import command
 from ovsdbapp.backend.ovs_idl import idlutils
-from ovsdbapp.backend.ovs_idl import rowview
 from ovsdbapp.schema.ovn_northbound import commands as ovn_nb_commands
 from ovsdbapp import utils as ovsdbapp_utils
 
@@ -104,49 +100,6 @@ def _add_gateway_chassis(api, txn, lrp_name, val):
     return 'gateway_chassis', uuid_list
 
 
-def _sync_ha_chassis_group(txn, nb_api, name, chassis_priority,
-                           may_exist=False, table_name='HA_Chassis_Group',
-                           **columns):
-    result = None
-    hcg = nb_api.lookup(table_name, name, default=None)
-    if hcg:
-        if not may_exist:
-            raise RuntimeError(_('HA_Chassis_Group %s exists' % name))
-    else:
-        hcg = txn.insert(nb_api._tables[table_name])
-        hcg.name = name
-        command.BaseCommand.set_columns(hcg, **columns)
-        result = hcg.uuid
-
-    # HA_Chassis registers handling.
-    # Remove the non-existing chassis in ``self.chassis_priority``
-    hc_to_remove = []
-    for hc in getattr(hcg, 'ha_chassis', []):
-        if hc.chassis_name not in chassis_priority:
-            hc_to_remove.append(hc)
-
-    for hc in hc_to_remove:
-        hcg.delvalue('ha_chassis', hc)
-        hc.delete()
-
-    # Update the priority of the existing chassis.
-    for hc in getattr(hcg, 'ha_chassis', []):
-        hc_priority = chassis_priority.pop(hc.chassis_name)
-        hc.priority = hc_priority
-
-    # Add the non-existing HA_Chassis registers.
-    for hc_name, priority in chassis_priority.items():
-        hc = txn.insert(nb_api.tables['HA_Chassis'])
-        hc.chassis_name = hc_name
-        hc.priority = priority
-        hcg.addvalue('ha_chassis', hc)
-
-    if not result:
-        result = rowview.RowView(hcg)
-
-    return result
-
-
 class CheckLivenessCommand(command.BaseCommand):
     def run_idl(self, txn):
         # txn.pre_commit responsible for updating nb_global.nb_cfg, but
@@ -157,64 +110,21 @@ def run_idl(self, txn):
         self.result = self.api.nb_global.nb_cfg
 
 
-class AddNetworkCommand(command.AddCommand):
-    table_name = 'Logical_Switch'
-
-    def __init__(self, api, network_id, may_exist=False, **columns):
-        super().__init__(api)
-        self.network_uuid = uuid.UUID(str(network_id))
-        self.may_exist = may_exist
-        self.columns = columns
-
-    def run_idl(self, txn):
-        table = self.api.tables[self.table_name]
-        try:
-            ls = table.rows[self.network_uuid]
-            if self.may_exist:
-                self.result = rowview.RowView(ls)
-                return
-            msg = _("Switch %s already exists") % self.network_uuid
-            raise RuntimeError(msg)
-        except KeyError:
-            # Adding a new LS
-            if utils.ovs_persist_uuid_supported(txn.idl):
-                ls = txn.insert(table, new_uuid=self.network_uuid,
-                                persist_uuid=True)
-            else:
-                ls = txn.insert(table)
-        self.set_columns(ls, **self.columns)
-        ls.name = utils.ovn_name(self.network_uuid)
-        self.result = ls.uuid
-
-
 class AddLSwitchPortCommand(command.BaseCommand):
-    def __init__(self, api, lport, lswitch, may_exist, network_id=None,
-                 **columns):
+    def __init__(self, api, lport, lswitch, may_exist, **columns):
         super().__init__(api)
         self.lport = lport
         self.lswitch = lswitch
         self.may_exist = may_exist
-        self.network_uuid = uuid.UUID(str(network_id)) if network_id else None
         self.columns = columns
 
     def run_idl(self, txn):
         try:
-            # We must look in the local cache first, because the LS may have
-            # been created as part of the current transaction. or in the case
-            # of adding an LSP to a LS that was created before persist_uuid
             lswitch = idlutils.row_by_value(self.api.idl, 'Logical_Switch',
                                             'name', self.lswitch)
         except idlutils.RowNotFound:
-            if self.network_uuid and utils.ovs_persist_uuid_supported(txn.idl):
-                # Create a "fake" row with the right UUID so python-ovs creates
-                # a transaction referencing the Row, even though we might not
-                # have received the update for the row ourselves.
-                lswitch = ovs_idl.Row(self.api.idl,
-                                      self.api.tables['Logical_Switch'],
-                                      uuid=self.network_uuid, data={})
-            else:
-                msg = _("Logical Switch %s does not exist") % self.lswitch
-                raise RuntimeError(msg)
+            msg = _("Logical Switch %s does not exist") % self.lswitch
+            raise RuntimeError(msg)
         if self.may_exist:
             port = idlutils.row_by_value(self.api.idl,
                                          'Logical_Switch_Port', 'name',
@@ -300,8 +210,8 @@ def run_idl(self, txn):
         else:
             new_port_dhcp_opts.add(dhcpv6_options.result)
             port.dhcpv6_options = [dhcpv6_options.result]
-        for uuid_ in cur_port_dhcp_opts - new_port_dhcp_opts:
-            self.api._tables['DHCP_Options'].rows[uuid_].delete()
+        for uuid in cur_port_dhcp_opts - new_port_dhcp_opts:
+            self.api._tables['DHCP_Options'].rows[uuid].delete()
 
         external_ids_update = self.external_ids_update or {}
         external_ids = getattr(port, 'external_ids', {})
@@ -383,8 +293,8 @@ def run_idl(self, txn):
         # Delete DHCP_Options records no longer referred by this port.
         cur_port_dhcp_opts = get_lsp_dhcp_options_uuids(
             lport, self.lport)
-        for uuid_ in cur_port_dhcp_opts:
-            self.api._tables['DHCP_Options'].rows[uuid_].delete()
+        for uuid in cur_port_dhcp_opts:
+            self.api._tables['DHCP_Options'].rows[uuid].delete()
 
         _delvalue_from_list(lswitch, 'ports', lport)
         self.api._tables['Logical_Switch_Port'].rows[lport.uuid].delete()
@@ -437,7 +347,8 @@ def run_idl(self, txn):
         az_hints = self.api.get_gateway_chassis_az_hints(self.g_name)
         filtered_existing_chassis = (
             self.scheduler.filter_existing_chassis(
-                gw_chassis=self.all_gw_chassis, physnet=physnet,
+                nb_idl=self.api, gw_chassis=self.all_gw_chassis,
+                physnet=physnet,
                 chassis_physnets=self.chassis_with_physnets,
                 existing_chassis=existing_chassis, az_hints=az_hints,
                 chassis_with_azs=self.chassis_with_azs))
@@ -477,12 +388,9 @@ def run_idl(self, txn):
                 # the top.
                 index = chassis.index(primary)
                 chassis[0], chassis[index] = chassis[index], chassis[0]
-        chassis_priority = utils.get_chassis_priority(chassis)
-        lrouter_name = lrouter_port.external_ids[
-            ovn_const.OVN_ROUTER_NAME_EXT_ID_KEY]
-        hcg = _sync_ha_chassis_group(txn, self.api, lrouter_name,
-                                     chassis_priority, may_exist=True)
-        setattr(lrouter_port, 'ha_chassis_group', ovsdbapp_utils.get_uuid(hcg))
+        setattr(
+            lrouter_port,
+            *_add_gateway_chassis(self.api, txn, self.g_name, chassis))
 
 
 class ScheduleNewGatewayCommand(command.BaseCommand):
@@ -507,11 +415,8 @@ def run_idl(self, txn):
             self.api, self.sb_api, self.g_name, candidates=candidates,
             target_lrouter=lrouter)
         if chassis:
-            chassis_priority = utils.get_chassis_priority(chassis)
-            hcg = _sync_ha_chassis_group(txn, self.api, self.lrouter_name,
-                                         chassis_priority, may_exist=True)
-            setattr(lrouter_port, 'ha_chassis_group',
-                    ovsdbapp_utils.get_uuid(hcg))
+            setattr(lrouter_port,
+                    *_add_gateway_chassis(self.api, txn, self.g_name, chassis))
 
 
 class LrDelCommand(ovn_nb_commands.LrDelCommand):
@@ -560,9 +465,8 @@ def run_idl(self, txn):
                 if col == 'gateway_chassis':
                     col, val = _add_gateway_chassis(self.api, txn, self.name,
                                                     val)
-                self.set_column(lrouter_port, col, val)
+                setattr(lrouter_port, col, val)
             _addvalue_to_list(lrouter, 'ports', lrouter_port)
-            self.result = lrouter_port.uuid
 
 
 class UpdateLRouterPortCommand(command.BaseCommand):
@@ -587,7 +491,7 @@ def run_idl(self, txn):
             if col == 'gateway_chassis':
                 col, val = _add_gateway_chassis(self.api, txn, self.name,
                                                 val)
-            self.set_column(lrouter_port, col, val)
+            setattr(lrouter_port, col, val)
 
 
 class DelLRouterPortCommand(command.BaseCommand):
@@ -1104,17 +1008,15 @@ def run_idl(self, txn):
         # Remove the router pinning to a chassis (if any).
         lrouter.delkey('options', 'chassis')
 
-        for gw_port in self.api.get_lrouter_gw_ports(lrouter.name):
-            gw_port.ha_chassis_group = []
-            lrouter.delvalue('ports', gw_port)
-
-        # Remove the HA_Chassis_Group of the router (if any), after
-        # removing it from the gateway Logical_Router_Ports.
+        # Remove the HA_Chassis_Group of the router (if any).
         hcg = self.api.lookup('HA_Chassis_Group',
                               lrouter.name, default=None)
         if hcg:
             hcg.delete()
 
+        for gw_port in self.api.get_lrouter_gw_ports(lrouter.name):
+            lrouter.delvalue('ports', gw_port)
+
 
 class SetLSwitchPortToVirtualTypeCommand(command.BaseCommand):
     def __init__(self, api, lport, vip, parent, if_exists):
@@ -1187,22 +1089,3 @@ def run_idl(self, txn):
                 virtual_parents)
 
         setattr(lsp, 'options', options)
-
-
-class HAChassisGroupWithHCAddCommand(command.AddCommand):
-    table_name = 'HA_Chassis_Group'
-
-    def __init__(self, api, name, chassis_priority, may_exist=False,
-                 **columns):
-        super().__init__(api)
-        self.name = name
-        self.chassis_priority = copy.deepcopy(chassis_priority)
-        self.may_exist = may_exist
-        self.columns = columns
-
-    def run_idl(self, txn):
-        # HA_Chassis_Group register creation.
-        self.result = _sync_ha_chassis_group(
-            txn, self.api, self.name, self.chassis_priority,
-            may_exist=self.may_exist, table_name=self.table_name,
-            **self.columns)