Merge pull request #81 from stackhpc/upstream/master-2025-11-17

Synchronise master with upstream

Author: priteau

ovn_octavia_provider/helper.py

@@ -4039,6 +4039,24 @@ def sm_update_event_handler(self, row, sm_delete_event=False):
         self.add_request({'type': ovn_const.REQ_TYPE_HM_UPDATE_EVENT,
                           'info': request_info})
 
+    # NOTE(froyo) those methods are to get the admin_state_up of the pool or
+    # listener independently of the type, octavia_lib when is requested by full
+    # lb is returning listeners and pools as dicts, but if a pool or listener
+    # is requested by id is returning the object.
+    def _get_pool_admin_state(self, pool):
+        if hasattr(pool, 'admin_state_up'):
+            return pool.admin_state_up
+        elif isinstance(pool, dict):
+            return pool.get('admin_state_up', True)
+        return None
+
+    def _get_listener_admin_state(self, listener):
+        if hasattr(listener, 'admin_state_up'):
+            return listener.admin_state_up
+        elif isinstance(listener, dict):
+            return listener.get('admin_state_up', True)
+        return None
+
     def _get_current_operating_statuses(self, ovn_lb):
         # NOTE (froyo) We would base all logic in the external_ids field
         # 'neutron:member_status' that should include all LB member status
@@ -4080,6 +4098,17 @@ def _get_current_operating_statuses(self, ovn_lb):
                 constants.PROVISIONING_STATUS: constants.ACTIVE,
                 constants.OPERATING_STATUS: member_status})
 
+        _lb = self._octavia_driver_lib.get_loadbalancer(ovn_lb.name)
+
+        lb_pools = {}
+        if hasattr(_lb, "pools") and _lb.pools is not None:
+            lb_pools = {pool['pool_id']: pool for pool in _lb.pools}
+
+        lb_listeners = {}
+        if hasattr(_lb, "listeners") and _lb.listeners is not None:
+            lb_listeners = {listener['listener_id']: listener
+                            for listener in _lb.listeners}
+
         # get pool statuses
         for pool_id, members in pools.items():
             for i, member in enumerate(members):
@@ -4089,8 +4118,10 @@ def _get_current_operating_statuses(self, ovn_lb):
                     # if we don't have local info we assume best option
                     members[i] = constants.ONLINE
 
-            _pool = self._octavia_driver_lib.get_pool(pool_id)
-            if not _pool.admin_state_up or not member_statuses:
+            _pool = lb_pools.get(pool_id)
+            if not _pool:
+                _pool = self._octavia_driver_lib.get_pool(pool_id)
+            if not self._get_pool_admin_state(_pool) or not member_statuses:
                 pools[pool_id] = constants.OFFLINE
             elif pools[pool_id] and all(constants.ERROR == member_status
                                         for member_status in pools[pool_id]):
@@ -4115,8 +4146,10 @@ def _get_current_operating_statuses(self, ovn_lb):
                     # if we don't have local info we assume best option
                     listener_pools[i] = constants.ONLINE
 
-            _listener = self._octavia_driver_lib.get_listener(listener_id)
-            if not _listener.admin_state_up:
+            _listener = lb_listeners.get(listener_id)
+            if not _listener:
+                _listener = self._octavia_driver_lib.get_listener(listener_id)
+            if not self._get_listener_admin_state(_listener):
                 listeners[listener_id] = constants.OFFLINE
             elif any(constants.ERROR == pool_status
                      for pool_status in listeners[listener_id]):
@@ -4134,7 +4167,6 @@ def _get_current_operating_statuses(self, ovn_lb):
 
         # get LB status
         lb_status = constants.ONLINE
-        _lb = self._octavia_driver_lib.get_loadbalancer(ovn_lb.name)
         if not _lb.admin_state_up:
             lb_status = constants.OFFLINE
         elif any(constants.ERROR == status

ovn_octavia_provider/tests/functional/test_driver.py

@@ -249,6 +249,22 @@ def test_member_no_subnet(self):
         pool_TCP_id = lb_data['pools'][0].pool_id
 
         self._o_driver_lib.get_pool.return_value = lb_data['pools'][0]
+
+        if not hasattr(lb_data['model'], 'pools'):
+            lb_data['model'].pools = []
+        if not hasattr(lb_data['model'], 'listeners'):
+            lb_data['model'].listeners = []
+
+        lb_data['model'].pools = [{
+            'pool_id': pool.pool_id,
+            'admin_state_up': pool.admin_state_up
+        } for pool in lb_data['pools']]
+
+        lb_data['model'].listeners = [{
+            'listener_id': listener.listener_id,
+            'admin_state_up': listener.admin_state_up
+        } for listener in lb_data['listeners']]
+
         self._o_driver_lib.get_loadbalancer.return_value = lb_data['model']
 
         # Test deleting a member without subnet

ovn_octavia_provider/tests/unit/test_helper.py

@@ -8311,3 +8311,101 @@ def test__members_in_subnet_last_member_match(self):
         })
         result = self.helper._members_in_subnet(self.ovn_lb, 'subnet2')
         self.assertTrue(result)
+
+    def test__get_pool_admin_state_with_object(self):
+        class MockPool:
+            def __init__(self, admin_state_up=True):
+                self.admin_state_up = admin_state_up
+
+        pool_obj = MockPool(admin_state_up=True)
+        result = self.helper._get_pool_admin_state(pool_obj)
+        self.assertTrue(result)
+
+        pool_obj_false = MockPool(admin_state_up=False)
+        result = self.helper._get_pool_admin_state(pool_obj_false)
+        self.assertFalse(result)
+
+    def test__get_pool_admin_state_with_dict(self):
+        pool_dict = {'admin_state_up': True}
+        result = self.helper._get_pool_admin_state(pool_dict)
+        self.assertTrue(result)
+
+        pool_dict_false = {'admin_state_up': False}
+        result = self.helper._get_pool_admin_state(pool_dict_false)
+        self.assertFalse(result)
+
+        pool_dict_no_key = {'other_key': 'value'}
+        result = self.helper._get_pool_admin_state(pool_dict_no_key)
+        self.assertTrue(result)
+
+    def test__get_pool_admin_state_with_other_type(self):
+        result = self.helper._get_pool_admin_state(None)
+        self.assertIsNone(result)
+
+        result = self.helper._get_pool_admin_state("some_string")
+        self.assertIsNone(result)
+
+        result = self.helper._get_pool_admin_state(123)
+        self.assertIsNone(result)
+
+    def test__get_listener_admin_state_with_object(self):
+        class MockListener:
+            def __init__(self, admin_state_up=True):
+                self.admin_state_up = admin_state_up
+
+        listener_obj = MockListener(admin_state_up=True)
+        result = self.helper._get_listener_admin_state(listener_obj)
+        self.assertTrue(result)
+
+        listener_obj_false = MockListener(admin_state_up=False)
+        result = self.helper._get_listener_admin_state(listener_obj_false)
+        self.assertFalse(result)
+
+    def test__get_listener_admin_state_with_dict(self):
+        listener_dict = {'admin_state_up': True}
+        result = self.helper._get_listener_admin_state(listener_dict)
+        self.assertTrue(result)
+
+        listener_dict_false = {'admin_state_up': False}
+        result = self.helper._get_listener_admin_state(listener_dict_false)
+        self.assertFalse(result)
+
+        listener_dict_no_key = {'other_key': 'value'}
+        result = self.helper._get_listener_admin_state(listener_dict_no_key)
+        self.assertTrue(result)
+
+    def test__get_listener_admin_state_with_other_type(self):
+        result = self.helper._get_listener_admin_state(None)
+        self.assertIsNone(result)
+
+        result = self.helper._get_listener_admin_state("some_string")
+        self.assertIsNone(result)
+
+        result = self.helper._get_listener_admin_state(456)
+        self.assertIsNone(result)
+
+    def test__get_pool_admin_state_edge_cases(self):
+        class MockPoolNone:
+            def __init__(self):
+                self.admin_state_up = None
+
+        pool_none = MockPoolNone()
+        result = self.helper._get_pool_admin_state(pool_none)
+        self.assertIsNone(result)
+
+        pool_dict_none = {'admin_state_up': None}
+        result = self.helper._get_pool_admin_state(pool_dict_none)
+        self.assertIsNone(result)
+
+    def test__get_listener_admin_state_edge_cases(self):
+        class MockListenerNone:
+            def __init__(self):
+                self.admin_state_up = None
+
+        listener_none = MockListenerNone()
+        result = self.helper._get_listener_admin_state(listener_none)
+        self.assertIsNone(result)
+
+        listener_dict_none = {'admin_state_up': None}
+        result = self.helper._get_listener_admin_state(listener_dict_none)
+        self.assertIsNone(result)

test-requirements.txt

@@ -5,9 +5,10 @@ coverage!=4.4,>=4.0 # Apache-2.0
 flake8-import-order>=0.18.0,<0.19.0 # LGPLv3
 oslotest>=3.2.0 # Apache-2.0
 stestr>=1.0.0 # Apache-2.0
-pylint>=2.6.0,!=4.0.0,!=4.0.1 # GPLv2
+pylint>=2.6.0,<4.0.0 # GPLv2
 testresources>=2.0.0 # Apache-2.0/BSD
 testscenarios>=0.4 # Apache-2.0/BSD
 WebTest>=2.0.27 # MIT
 testtools>=2.2.0 # MIT
+PyMySQL>=0.7.6 # MIT License
 neutron>=23.0.0.0b3 # Apache-2.0

tox.ini

@@ -60,8 +60,11 @@ commands = false
 setenv = {[testenv:functional]setenv}
          {[testenv:dsvm]setenv}
 deps = {[testenv:functional]deps}
+passenv =
+  {[testenv]passenv}
+  OS_TEST_DBAPI_ADMIN_CONNECTION
 commands =
-  stestr run --isolated {posargs}
+  stestr run {posargs}
 
 [testenv:cover]
 setenv =