Member batch actions to increase performance

When a create or delete cascade request is made for a
medium or large-sized Load Balancer (including several
pools and members), the response time from the OVN
provider grows linearly with the number of members added.

This patch optimizes the creation process by handling
multiple members in batches.

Closes-Bug: #2080630
Change-Id: I94622420f631d8d3fb06b9c29a2066ff73d1cb0b
Signed-off-by: Fernando Royo <[email protected]>

Author: fernandoroyosanchez

ovn_octavia_provider/driver.py

@@ -203,10 +203,13 @@ def loadbalancer_create(self, loadbalancer):
         if not isinstance(loadbalancer.pools, o_datamodels.UnsetType):
             for pool in loadbalancer.pools:
                 self.pool_create(pool)
-                for member in pool.members:
-                    if not member.subnet_id:
-                        member.subnet_id = loadbalancer.vip_subnet_id
-                    self.member_create(member)
+                members = [
+                    member if member.subnet_id else setattr(
+                        member, "subnet_id", loadbalancer.vip_subnet_id) or
+                    member
+                    for member in pool.members
+                ]
+                self._members_create(members)
 
     def loadbalancer_delete(self, loadbalancer, cascade=False):
         request_info = {'id': loadbalancer.loadbalancer_id,
@@ -259,8 +262,8 @@ def pool_delete(self, pool):
         if pool.healthmonitor:
             self.health_monitor_delete(pool.healthmonitor)
 
-        for member in pool.members:
-            self.member_delete(member)
+        if pool.members:
+            self._members_delete(pool.members)
 
         request_info = {'id': pool.pool_id,
                         'protocol': pool.protocol,
@@ -373,88 +376,108 @@ def _ip_version_differs(self, member):
             return vip_version != (netaddr.IPNetwork(member.address).version)
 
     def member_create(self, member):
-        # Validate monitoring options if present
-        self._check_member_monitor_options(member)
-        if self._ip_version_differs(member):
-            raise ovn_exc.IPVersionsMixingNotSupportedError()
-        admin_state_up = member.admin_state_up
-        subnet_id = member.subnet_id
-        if (isinstance(subnet_id, o_datamodels.UnsetType) or not subnet_id):
-            subnet_id, subnet_cidr = self._ovn_helper._get_subnet_from_pool(
-                member.pool_id)
-            if not (subnet_id and
-                    self._ovn_helper._check_ip_in_subnet(member.address,
-                                                         subnet_cidr)):
-                msg = _('Subnet is required, or Loadbalancer associated with '
-                        'Pool must have a subnet, for Member creation '
-                        'with OVN Provider Driver if it is not the same as '
-                        'LB VIP subnet')
-                raise driver_exceptions.UnsupportedOptionError(
-                    user_fault_string=msg,
-                    operator_fault_string=msg)
+        self._members_create([member])
+
+    def _members_create(self, members):
+        request_info = []
+        request_info_dvr = []
+        for member in members:
+            # Validate monitoring options if present
+            self._check_member_monitor_options(member)
+            if self._ip_version_differs(member):
+                raise ovn_exc.IPVersionsMixingNotSupportedError()
+            admin_state_up = member.admin_state_up
+            subnt_id = member.subnet_id
+            if (isinstance(subnt_id, o_datamodels.UnsetType) or
+                    not subnt_id):
+                subnt_id, subnt_cidr = self._ovn_helper._get_subnet_from_pool(
+                    member.pool_id)
+
+                if not (subnt_id and
+                        self._ovn_helper._check_ip_in_subnet(member.address,
+                                                             subnt_cidr)):
+                    msg = _('Subnet is required, or Loadbalancer associated '
+                            'with Pool must have a subnet, for Member '
+                            'creation with OVN Provider Driver if it is not '
+                            'the same as LB VIP subnet')
+                    raise driver_exceptions.UnsupportedOptionError(
+                        user_fault_string=msg,
+                        operator_fault_string=msg)
+
+            if isinstance(admin_state_up, o_datamodels.UnsetType):
+                admin_state_up = True
+            request_info.append({'id': member.member_id,
+                                 'address': member.address,
+                                 'protocol_port': member.protocol_port,
+                                 'pool_id': member.pool_id,
+                                 'subnet_id': subnt_id,
+                                 'admin_state_up': admin_state_up})
+
+            # NOTE(mjozefcz): If LB has FIP on VIP
+            # and member has FIP we need to centralize
+            # traffic for member.
+            request_info_dvr.append({'id': member.member_id,
+                                     'address': member.address,
+                                     'pool_id': member.pool_id,
+                                     'subnet_id': subnt_id,
+                                     'action': ovn_const.REQ_INFO_MEMBER_ADDED}
+                                    )
 
-        if isinstance(admin_state_up, o_datamodels.UnsetType):
-            admin_state_up = True
-        request_info = {'id': member.member_id,
-                        'address': member.address,
-                        'protocol_port': member.protocol_port,
-                        'pool_id': member.pool_id,
-                        'subnet_id': subnet_id,
-                        'admin_state_up': admin_state_up}
         request = {'type': ovn_const.REQ_TYPE_MEMBER_CREATE,
                    'info': request_info}
         self._ovn_helper.add_request(request)
 
-        # NOTE(mjozefcz): If LB has FIP on VIP
-        # and member has FIP we need to centralize
-        # traffic for member.
-        request_info = {'id': member.member_id,
-                        'address': member.address,
-                        'pool_id': member.pool_id,
-                        'subnet_id': subnet_id,
-                        'action': ovn_const.REQ_INFO_MEMBER_ADDED}
         request = {'type': ovn_const.REQ_TYPE_HANDLE_MEMBER_DVR,
-                   'info': request_info}
+                   'info': request_info_dvr}
         self._ovn_helper.add_request(request)
 
     def member_delete(self, member):
+        self._members_delete([member])
+
+    def _members_delete(self, members):
         # NOTE(froyo): OVN provider allow to create member without param
         # subnet_id, in that case the driver search it according to the
         # pool_id, but it is not propagated to Octavia. In this case, if
         # the member is deleted, Octavia send the object without subnet_id.
-        subnet_id = member.subnet_id
-        if (isinstance(subnet_id, o_datamodels.UnsetType) or not subnet_id):
-            subnet_id, subnet_cidr = self._ovn_helper._get_subnet_from_pool(
-                member.pool_id)
-            if not (subnet_id and
-                    self._ovn_helper._check_ip_in_subnet(member.address,
-                                                         subnet_cidr)):
-                msg = _('Subnet is required, or Loadbalancer associated with '
-                        'Pool must have a subnet, for Member deletion if it is'
-                        'with OVN Provider Driver if it is not the same as '
-                        'LB VIP subnet')
-                raise driver_exceptions.UnsupportedOptionError(
-                    user_fault_string=msg,
-                    operator_fault_string=msg)
+        request_info = []
+        request_info_dvr = []
+        for member in members:
+            subnt_id = member.subnet_id
+            if (isinstance(subnt_id, o_datamodels.UnsetType) or not subnt_id):
+                subnt_id, subnt_cidr = self._ovn_helper._get_subnet_from_pool(
+                    member.pool_id)
+                if not (subnt_id and
+                        self._ovn_helper._check_ip_in_subnet(member.address,
+                                                             subnt_cidr)):
+                    msg = _('Subnet is required, or Loadbalancer associated '
+                            'with Pool must have a subnet, for Member '
+                            'deletion if it is with OVN Provider Driver if it '
+                            'is not the same as LB VIP subnet')
+                    raise driver_exceptions.UnsupportedOptionError(
+                        user_fault_string=msg,
+                        operator_fault_string=msg)
+
+            request_info.append({'id': member.member_id,
+                                 'address': member.address,
+                                 'protocol_port': member.protocol_port,
+                                 'pool_id': member.pool_id,
+                                 'subnet_id': subnt_id})
+            # NOTE(mjozefcz): If LB has FIP on VIP
+            # and member had FIP we can decentralize
+            # the traffic now.
+            request_info_dvr.append(
+                {'id': member.member_id,
+                 'address': member.address,
+                 'pool_id': member.pool_id,
+                 'subnet_id': subnt_id,
+                 'action': ovn_const.REQ_INFO_MEMBER_DELETED})
 
-        request_info = {'id': member.member_id,
-                        'address': member.address,
-                        'protocol_port': member.protocol_port,
-                        'pool_id': member.pool_id,
-                        'subnet_id': subnet_id}
         request = {'type': ovn_const.REQ_TYPE_MEMBER_DELETE,
                    'info': request_info}
         self._ovn_helper.add_request(request)
-        # NOTE(mjozefcz): If LB has FIP on VIP
-        # and member had FIP we can decentralize
-        # the traffic now.
-        request_info = {'id': member.member_id,
-                        'address': member.address,
-                        'pool_id': member.pool_id,
-                        'subnet_id': subnet_id,
-                        'action': ovn_const.REQ_INFO_MEMBER_DELETED}
+
         request = {'type': ovn_const.REQ_TYPE_HANDLE_MEMBER_DVR,
-                   'info': request_info}
+                   'info': request_info_dvr}
         self._ovn_helper.add_request(request)
 
     def member_update(self, old_member, new_member):
@@ -470,7 +493,7 @@ def member_update(self, old_member, new_member):
         if not isinstance(new_member.admin_state_up, o_datamodels.UnsetType):
             request_info['admin_state_up'] = new_member.admin_state_up
         request = {'type': ovn_const.REQ_TYPE_MEMBER_UPDATE,
-                   'info': request_info}
+                   'info': [request_info]}
         self._ovn_helper.add_request(request)
 
     def member_batch_update(self, pool_id, members):
@@ -482,6 +505,10 @@ def member_batch_update(self, pool_id, members):
         members_to_delete = copy.copy(existing_members)
         pool_subnet_id = None
         pool_subnet_cidr = None
+        request_info_create = []
+        request_info_update = []
+        request_info_delete = []
+        request_info_dvr_delete = []
         for member in members:
             # NOTE(froyo): in order to keep sync with Octavia DB, we raise
             # not supporting exceptions as soon as posible, considering the
@@ -520,49 +547,65 @@ def member_batch_update(self, pool_id, members):
                 admin_state_up = True
 
             member_info = self._ovn_helper._get_member_info(member)
+            request_info = {
+                'id': member.member_id,
+                'address': member.address,
+                'protocol_port': member.protocol_port,
+                'pool_id': member.pool_id,
+                'subnet_id': member.subnet_id,
+                'admin_state_up': admin_state_up}
+
             if member_info not in existing_members:
-                req_type = ovn_const.REQ_TYPE_MEMBER_CREATE
+                request_info_create.append(request_info)
             else:
                 # If member exists in pool, then Update
-                req_type = ovn_const.REQ_TYPE_MEMBER_UPDATE
+                request_info_update.append(request_info)
                 # Remove all updating members so only deleted ones are left
                 members_to_delete.remove(member_info)
 
-            request_info = {'id': member.member_id,
-                            'address': member.address,
-                            'protocol_port': member.protocol_port,
-                            'pool_id': member.pool_id,
-                            'subnet_id': member.subnet_id,
-                            'admin_state_up': admin_state_up}
-            request = {'type': req_type,
-                       'info': request_info}
-            request_list.append(request)
-
         for member in members_to_delete:
             member_info = member.split('_')
             member_ip, member_port, subnet_id, member_id = (
                 self._ovn_helper._extract_member_info(member)[0])
-            request_info = {'id': member_info[1],
-                            'address': member_ip,
-                            'protocol_port': member_port,
-                            'pool_id': pool_id}
+            request_info = {
+                'id': member_info[1],
+                'address': member_ip,
+                'protocol_port': member_port,
+                'pool_id': pool_id}
             if len(member_info) == 4:
                 request_info['subnet_id'] = subnet_id
-            request = {'type': ovn_const.REQ_TYPE_MEMBER_DELETE,
-                       'info': request_info}
-            request_list.append(request)
+            request_info_delete.append(request_info)
 
             # NOTE(mjozefcz): If LB has FIP on VIP
             # and member had FIP we can decentralize
             # the traffic now.
-            request_info = {'id': member_id,
-                            'address': member_ip,
-                            'pool_id': pool_id,
-                            'action': ovn_const.REQ_INFO_MEMBER_DELETED}
+            request_info = {
+                'id': member_id,
+                'address': member_ip,
+                'pool_id': pool_id,
+                'action': ovn_const.REQ_INFO_MEMBER_DELETED}
             if len(member_info) == 4:
                 request_info['subnet_id'] = subnet_id
+            request_info_dvr_delete.append(request_info)
+
+        if request_info_create:
+            request = {'type': ovn_const.REQ_TYPE_MEMBER_CREATE,
+                       'info': request_info_create}
+            request_list.append(request)
+
+        if request_info_update:
+            request = {'type': ovn_const.REQ_TYPE_MEMBER_UPDATE,
+                       'info': request_info_update}
+            request_list.append(request)
+
+        if request_info_delete:
+            request = {'type': ovn_const.REQ_TYPE_MEMBER_DELETE,
+                       'info': request_info_delete}
+            request_list.append(request)
+
+        if request_info_dvr_delete:
             request = {'type': ovn_const.REQ_TYPE_HANDLE_MEMBER_DVR,
-                       'info': request_info}
+                       'info': request_info_dvr_delete}
             request_list.append(request)
 
         for request in request_list: