octavia 15.0.0.0rc1__py3-none-any.whl → 16.0.0__py3-none-any.whl

octavia/tests/functional/db/test_models.py

@@ -289,7 +289,8 @@ class MemberModelTest(base.OctaviaDBTestBase, ModelTestMixin):
                          f"project_id={member.project_id!r}, "
                          f"provisioning_status='ACTIVE', "
                          f"ip_address='10.0.0.1', protocol_port=80, "
-                         f"operating_status='ONLINE', weight=None)",
+                         f"operating_status='ONLINE', weight=None, "
+                         f"vnic_type=None)",
                          str(member))
 
         self.assertIsNotNone(member.created_at)
@@ -1049,6 +1050,7 @@ class TestDataModelConversionTest(base.OctaviaDBTestBase, ModelTestMixin):
         # Generate equivalent graphs starting arbitrarily from different
         # nodes within it; Make sure the resulting graphs all contain the
         # same number of nodes.
+        # check the default value for recursion_depth=None
         lb_dm = self.session.query(models.LoadBalancer).filter_by(
             id=self.lb.id).first().to_data_model()
         lb_graph_count = self.count_graph_nodes(lb_dm)
@@ -1063,6 +1065,82 @@ class TestDataModelConversionTest(base.OctaviaDBTestBase, ModelTestMixin):
         self.assertEqual(lb_graph_count, p_graph_count)
         self.assertEqual(lb_graph_count, mem_graph_count)
 
+    def _get_dms_for_recursion_depth(self, recursion_depth):
+        lb_dm = self.session.query(models.LoadBalancer).filter_by(
+            id=self.lb.id).first().to_data_model(
+            recursion_depth=recursion_depth)
+        p_dm = self.session.query(models.Pool).filter_by(
+            id=self.pool.id).first().to_data_model(
+            recursion_depth=recursion_depth)
+        mem_dm = self.session.query(models.Member).filter_by(
+            id=self.member.id).first().to_data_model(
+            recursion_depth=recursion_depth)
+        return lb_dm, p_dm, mem_dm
+
+    def _get_nodes_count_for_dms(self, lb_dm, p_dm, mem_dm):
+        return (
+            self.count_graph_nodes(lb_dm),
+            self.count_graph_nodes(p_dm),
+            self.count_graph_nodes(mem_dm),
+        )
+
+    def test_graph_completeness_with_recursion_depth_equal_zero(self):
+        lb_dm, p_dm, mem_dm = self._get_dms_for_recursion_depth(
+            recursion_depth=0
+        )
+        lb_graph_count, p_graph_count, mem_graph_count = (
+            self._get_nodes_count_for_dms(lb_dm, p_dm, mem_dm)
+        )
+        self.assertNotEqual(0, lb_graph_count)
+        # recursion_depth equal to 0 means, that only current node will be
+        # handled. there is no recursion
+        self.assertEqual(1, lb_graph_count)
+        self.assertEqual(1, p_graph_count)
+        self.assertEqual(1, mem_graph_count)
+
+    def test_graph_completeness_with_recursion_depth_equal_one(self):
+        lb_dm, p_dm, mem_dm = self._get_dms_for_recursion_depth(
+            recursion_depth=1
+        )
+        lb_graph_count, p_graph_count, mem_graph_count = (
+            self._get_nodes_count_for_dms(lb_dm, p_dm, mem_dm)
+        )
+        self.assertNotEqual(0, lb_graph_count)
+        self.assertNotEqual(1, lb_graph_count)
+        self.assertNotEqual(1, p_graph_count)
+        self.assertNotEqual(1, mem_graph_count)
+        # the nodes count is different for each node type
+        # due to different number of related nodes
+        self.assertEqual(5, lb_graph_count)
+        self.assertEqual(7, p_graph_count)
+        self.assertEqual(2, mem_graph_count)
+
+    def test_graph_completeness_with_recursion_depth_huge(self):
+        lb_dm, p_dm, mem_dm = self._get_dms_for_recursion_depth(
+            recursion_depth=10
+        )
+        lb_graph_count, p_graph_count, mem_graph_count = (
+            self._get_nodes_count_for_dms(lb_dm, p_dm, mem_dm)
+        )
+        # recursion_depth=None is default value, so it's equal to run without
+        # limit on recursion
+        lb_dm_none, p_dm_none, mem_dm_none = self._get_dms_for_recursion_depth(
+            recursion_depth=None
+        )
+        lb_graph_count_none, p_graph_count_none, mem_graph_count_none = (
+            self._get_nodes_count_for_dms(lb_dm_none, p_dm_none, mem_dm_none)
+        )
+        self.assertNotEqual(0, lb_graph_count)
+        self.assertNotEqual(1, lb_graph_count)
+        self.assertEqual(lb_graph_count, p_graph_count)
+        self.assertEqual(lb_graph_count, mem_graph_count)
+
+        # huge recursion_depth is enough to iterate through all nodes in graph
+        self.assertEqual(
+            (lb_graph_count, p_graph_count, mem_graph_count),
+            (lb_graph_count_none, p_graph_count_none, mem_graph_count_none)
+        )
+
     def test_data_model_graph_traversal(self):
         lb_dm = self.session.query(models.LoadBalancer).filter_by(
             id=self.lb.id).first().to_data_model()
@@ -1085,6 +1163,51 @@ class TestDataModelConversionTest(base.OctaviaDBTestBase, ModelTestMixin):
                    load_balancer.pools[0].members[0].pool.load_balancer.id)
         self.assertEqual(lb_dm.id, m_lb_id)
 
+    def test_data_model_graph_traversal_with_recursion_depth_zero(self):
+        lb_dm, p_dm, mem_dm = self._get_dms_for_recursion_depth(
+            recursion_depth=0
+        )
+        # Traverse is not possible, because resources are not handled
+        # It happens, because there is no recursion
+        self.assertEqual([], lb_dm.listeners)
+        self.assertEqual([], lb_dm.pools)
+        self.assertIsNone(lb_dm.vip)
+        self.assertEqual([], lb_dm.amphorae)
+        # not inner objects for Pool
+        self.assertEqual([], p_dm.listeners)
+        self.assertIsNone(p_dm.load_balancer)
+        self.assertIsNone(p_dm.session_persistence)
+        self.assertIsNone(p_dm.health_monitor)
+        self.assertEqual([], p_dm.members)
+        self.assertEqual([], p_dm.l7policies)
+        # not inner objects for Member
+        self.assertIsNone(mem_dm.pool)
+
+    def test_data_model_graph_traversal_with_recursion_depth_one(self):
+        lb_dm, p_dm, mem_dm = self._get_dms_for_recursion_depth(
+            recursion_depth=1
+        )
+        # one hop resources are available for LB
+        self.assertEqual(1, len(lb_dm.listeners))
+        self.assertEqual(1, len(lb_dm.pools))
+        self.assertIsNotNone(lb_dm.vip)
+        self.assertEqual(1, len(lb_dm.amphorae))
+        # second hop resources are not available for LB
+        self.assertEqual([], lb_dm.pools[0].listeners)
+        # one hop resources are available for Pool
+        self.assertEqual(1, len(p_dm.listeners))
+        self.assertIsNotNone(p_dm.load_balancer)
+        self.assertIsNotNone(p_dm.session_persistence)
+        self.assertIsNotNone(p_dm.health_monitor)
+        self.assertEqual(1, len(p_dm.members))
+        self.assertEqual(1, len(p_dm.l7policies))
+        # second hop resources are not available for Pool
+        self.assertEqual([], p_dm.load_balancer.listeners)
+        # one hop resources are available for Member
+        self.assertIsNotNone(mem_dm.pool)
+        # second hop resources are not available for Member
+        self.assertEqual([], mem_dm.pool.listeners)
+
     def test_update_data_model_listener_default_pool_id(self):
         lb_dm = self.create_load_balancer(
             self.session, id=uuidutils.generate_uuid()).to_data_model()

octavia/tests/functional/db/test_repositories.py

@@ -67,6 +67,16 @@ class BaseRepositoryTest(base.OctaviaDBTestBase):
         self.flavor_repo = repo.FlavorRepository()
         self.flavor_profile_repo = repo.FlavorProfileRepository()
 
+    def create_loadbalancer(self, lb_id):
+        lb = self.lb_repo.create(self.session, id=lb_id,
+                                 project_id=self.FAKE_UUID_2, name="lb_name",
+                                 description="lb_description",
+                                 provisioning_status=constants.ACTIVE,
+                                 operating_status=constants.ONLINE,
+                                 enabled=True)
+        self.session.commit()
+        return lb
+
     def test_get_all_return_value(self):
         pool_list, _ = self.pool_repo.get_all(self.session,
                                               project_id=self.FAKE_UUID_2)
@@ -125,7 +135,7 @@ class AllRepositoriesTest(base.OctaviaDBTestBase):
                            'amp_build_slots', 'amp_build_req', 'quotas',
                            'flavor', 'flavor_profile', 'listener_cidr',
                            'availability_zone', 'availability_zone_profile',
-                           'additional_vip')
+                           'additional_vip', 'amphora_member_port')
         for repo_attr in repo_attr_names:
             single_repo = getattr(self.repos, repo_attr, None)
             message = (f"Class Repositories should have {repo_attr} instance "
@@ -163,7 +173,7 @@ class AllRepositoriesTest(base.OctaviaDBTestBase):
                'subnet_id': uuidutils.generate_uuid(),
                'network_id': uuidutils.generate_uuid(),
                'qos_policy_id': None, 'octavia_owned': True,
-               'vnic_type': None}
+               'vnic_type': None, 'sgs': []}
         additional_vips = [{'subnet_id': uuidutils.generate_uuid(),
                             'ip_address': '192.0.2.2'}]
         lb_dm = self.repos.create_load_balancer_and_vip(self.session, lb, vip,
@@ -182,8 +192,108 @@ class AllRepositoriesTest(base.OctaviaDBTestBase):
         vip_dm_dict = lb_dm.vip.to_dict()
         vip_dm_dict['load_balancer_id'] = lb_dm.id
         del vip_dm_dict['load_balancer']
+        vip['sg_ids'] = []
         self.assertEqual(vip, vip_dm_dict)
 
+        ret = self.repos.load_balancer.get(self.session, id=lb_dm.id)
+        print(ret.vip.port_id)
+        ret = self.repos.vip.get(self.session, load_balancer_id=lb_dm.id)
+        print(ret.port_id)
+
+    def test_create_load_balancer_and_update_vip(self):
+        lb = {'name': 'test1', 'description': 'desc1', 'enabled': True,
+              'provisioning_status': constants.PENDING_UPDATE,
+              'operating_status': constants.OFFLINE,
+              'topology': constants.TOPOLOGY_ACTIVE_STANDBY,
+              'vrrp_group': None,
+              'provider': 'amphora',
+              'server_group_id': uuidutils.generate_uuid(),
+              'project_id': uuidutils.generate_uuid(),
+              'id': uuidutils.generate_uuid(), 'flavor_id': None,
+              'tags': ['test_tag']}
+        vip = {'ip_address': '192.0.2.1',
+               'port_id': uuidutils.generate_uuid(),
+               'subnet_id': uuidutils.generate_uuid(),
+               'network_id': uuidutils.generate_uuid(),
+               'qos_policy_id': None, 'octavia_owned': True,
+               'vnic_type': None, 'sgs': []}
+        additional_vips = [{'subnet_id': uuidutils.generate_uuid(),
+                            'ip_address': '192.0.2.2'}]
+        lb_dm = self.repos.create_load_balancer_and_vip(self.session, lb, vip,
+                                                        additional_vips)
+        self.session.commit()
+
+        vip_dm_dict = lb_dm.vip.to_dict()
+        self.assertEqual(0, len(vip_dm_dict["sg_ids"]))
+
+        vip_update = {
+            'port_id': uuidutils.generate_uuid(),
+        }
+        self.repos.vip.update(self.session, lb_dm.id, **vip_update)
+        self.session.expire_all()
+        self.session.flush()
+        self.session.commit()
+
+        updated_vip_dm = self.repos.vip.get(self.session,
+                                            load_balancer_id=lb_dm.id)
+        self.assertEqual(vip_update['port_id'], updated_vip_dm.port_id)
+
+    def test_create_load_balancer_and_update_vip_sg_ids(self):
+        lb = {'name': 'test1', 'description': 'desc1', 'enabled': True,
+              'provisioning_status': constants.PENDING_UPDATE,
+              'operating_status': constants.OFFLINE,
+              'topology': constants.TOPOLOGY_ACTIVE_STANDBY,
+              'vrrp_group': None,
+              'provider': 'amphora',
+              'server_group_id': uuidutils.generate_uuid(),
+              'project_id': uuidutils.generate_uuid(),
+              'id': uuidutils.generate_uuid(), 'flavor_id': None,
+              'tags': ['test_tag']}
+        vip = {'ip_address': '192.0.2.1',
+               'port_id': uuidutils.generate_uuid(),
+               'subnet_id': uuidutils.generate_uuid(),
+               'network_id': uuidutils.generate_uuid(),
+               'qos_policy_id': None, 'octavia_owned': True,
+               'vnic_type': None, 'sgs': []}
+        additional_vips = [{'subnet_id': uuidutils.generate_uuid(),
+                            'ip_address': '192.0.2.2'}]
+        lb_dm = self.repos.create_load_balancer_and_vip(self.session, lb, vip,
+                                                        additional_vips)
+        self.session.commit()
+
+        vip_dm_dict = lb_dm.vip.to_dict()
+        self.assertEqual(0, len(vip_dm_dict["sg_ids"]))
+
+        vip_update = {
+            'sg_ids': [uuidutils.generate_uuid(),
+                       uuidutils.generate_uuid()],
+        }
+        self.repos.vip.update(self.session, lb_dm.id, **vip_update)
+        self.session.commit()
+
+        updated_vip_dm = self.repos.vip.get(self.session,
+                                            load_balancer_id=lb_dm.id)
+        self.assertEqual(2, len(vip_update['sg_ids']))
+        self.assertIn(vip_update['sg_ids'][0], updated_vip_dm.sg_ids)
+        self.assertIn(vip_update['sg_ids'][1], updated_vip_dm.sg_ids)
+
+        vip_update['sg_ids'] = [uuidutils.generate_uuid()]
+        self.repos.vip.update(self.session, lb_dm.id, **vip_update)
+        self.session.commit()
+
+        updated_vip_dm = self.repos.vip.get(self.session,
+                                            load_balancer_id=lb_dm.id)
+        self.assertEqual(1, len(vip_update['sg_ids']))
+        self.assertIn(vip_update['sg_ids'][0], updated_vip_dm.sg_ids)
+
+        vip_update['sg_ids'] = []
+        self.repos.vip.update(self.session, lb_dm.id, **vip_update)
+        self.session.commit()
+
+        updated_vip_dm = self.repos.vip.get(self.session,
+                                            load_balancer_id=lb_dm.id)
+        self.assertEqual(0, len(vip_update['sg_ids']))
+
     def test_create_pool_on_listener_without_sp(self):
         pool = {'protocol': constants.PROTOCOL_HTTP, 'name': 'pool1',
                 'description': 'desc1',
@@ -2086,6 +2196,31 @@ class PoolRepositoryTest(BaseRepositoryTest):
         self.assertEqual(pool.id, new_pool.id)
         self.assertEqual(pool.project_id, new_pool.project_id)
 
+    def test_get_limited_graph(self):
+        def check_pool_attrs(pool, new_pool, lb, limited_graph):
+            self.assertIsInstance(new_pool, data_models.Pool)
+            self.assertEqual(pool.id, new_pool.id)
+            self.assertEqual(pool.project_id, new_pool.project_id)
+            if limited_graph:
+                self.assertIsNone(new_pool.load_balancer)
+            else:
+                self.assertEqual(lb.id, new_pool.load_balancer.id)
+
+        pool = self.create_pool(pool_id=self.FAKE_UUID_1,
+                                project_id=self.FAKE_UUID_2)
+        # Create LB and attach pool to it.
+        # It means, that in graph pool node get new relationship to LB
+        lb = self.create_loadbalancer(self.FAKE_UUID_5)
+        self.pool_repo.update(self.session, id=pool.id, load_balancer_id=lb.id)
+        self.pool_repo.update(self.session, id=pool.id, load_balancer_id=lb.id)
+
+        new_pool = self.pool_repo.get(self.session, id=pool.id)
+        check_pool_attrs(pool, new_pool, lb, limited_graph=False)
+
+        new_pool2 = self.pool_repo.get(self.session, id=pool.id,
+                                       limited_graph=True)
+        check_pool_attrs(pool, new_pool2, lb, limited_graph=True)
+
     def test_get_all(self):
         pool_one = self.create_pool(pool_id=self.FAKE_UUID_1,
                                     project_id=self.FAKE_UUID_2)
@@ -2316,13 +2451,33 @@ class MemberRepositoryTest(BaseRepositoryTest):
         self.assertEqual(member.pool_id, new_member.pool_id)
         self.assertEqual(member.ip_address, new_member.ip_address)
 
-    def test_get_all(self):
-        member_one = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
-                                        self.pool.id, "192.0.2.1")
-        member_two = self.create_member(self.FAKE_UUID_3, self.FAKE_UUID_2,
-                                        self.pool.id, "192.0.2.2")
-        member_list, _ = self.member_repo.get_all(self.session,
-                                                  project_id=self.FAKE_UUID_2)
+    def test_get_limited_graph(self):
+        def check_member_attrs(member, new_member, lb, limited_graph):
+            self.assertIsInstance(new_member, data_models.Member)
+            self.assertEqual(member.id, new_member.id)
+            self.assertEqual(member.pool_id, new_member.pool_id)
+            self.assertEqual(member.ip_address, new_member.ip_address)
+            if limited_graph:
+                self.assertIsNone(new_member.pool)
+            else:
+                self.assertEqual(lb.id, new_member.pool.load_balancer.id)
+
+        member = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
+                                    self.pool.id, "192.0.2.1")
+        # Create LB and attach pool to it.
+        # It means, that in graph pool node get new relationship to LB
+        lb = self.create_loadbalancer(self.FAKE_UUID_5)
+        self.pool_repo.update(self.session, id=self.pool.id,
+                              load_balancer_id=lb.id)
+
+        new_member = self.member_repo.get(self.session, id=member.id)
+        check_member_attrs(member, new_member, lb, limited_graph=False)
+
+        new_member2 = self.member_repo.get(self.session, id=member.id,
+                                           limited_graph=True)
+        check_member_attrs(member, new_member2, lb, limited_graph=True)
+
+    def _validate_members_response(self, member_one, member_two, member_list):
         self.assertIsInstance(member_list, list)
         self.assertEqual(2, len(member_list))
         self.assertEqual(member_one.id, member_list[0].id)
@@ -2332,6 +2487,54 @@ class MemberRepositoryTest(BaseRepositoryTest):
         self.assertEqual(member_two.pool_id, member_list[1].pool_id)
         self.assertEqual(member_two.ip_address, member_list[1].ip_address)
 
+    def test_get_all(self):
+        member_one = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
+                                        self.pool.id, "192.0.2.1")
+        member_two = self.create_member(self.FAKE_UUID_3, self.FAKE_UUID_2,
+                                        self.pool.id, "192.0.2.2")
+        member_list, _ = self.member_repo.get_all(self.session,
+                                                  project_id=self.FAKE_UUID_2)
+        self._validate_members_response(member_one, member_two, member_list)
+
+    def test_get_all_with_loadbalancer(self):
+        member_one = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
+                                        self.pool.id, "192.0.2.1")
+        member_two = self.create_member(self.FAKE_UUID_3, self.FAKE_UUID_2,
+                                        self.pool.id, "192.0.2.2")
+        # Create LB and attach pool to it.
+        # It means, that in graph pool node get new relationship to LB
+        lb = self.create_loadbalancer(self.FAKE_UUID_5)
+        self.pool_repo.update(self.session, id=self.pool.id,
+                              load_balancer_id=lb.id)
+
+        member_list, _ = self.member_repo.get_all(self.session,
+                                                  project_id=self.FAKE_UUID_2)
+        self._validate_members_response(member_one, member_two, member_list)
+        # Without limit on recursion all nodes will be processed.
+        # As result load_balancer node will be available in response
+        self.assertEqual(self.pool.id, member_list[0].pool.id)
+        self.assertEqual(self.pool.id, member_list[1].pool.id)
+        self.assertEqual(lb.id, member_list[0].pool.load_balancer.id)
+        self.assertEqual(lb.id, member_list[1].pool.load_balancer.id)
+
+        # get the same list of members with enabled limit graph recursion
+        member_list_limit, _ = self.member_repo.get_all(
+            self.session,
+            project_id=self.FAKE_UUID_2,
+            limited_graph=True
+        )
+        self._validate_members_response(
+            member_one,
+            member_two,
+            member_list_limit
+        )
+        # With limit on recursion load_balancer node will not be processed.
+        # As result load_balancer node will not be available in response
+        self.assertEqual(self.pool.id, member_list_limit[0].pool.id)
+        self.assertEqual(self.pool.id, member_list_limit[1].pool.id)
+        self.assertIsNone(member_list_limit[0].pool.load_balancer)
+        self.assertIsNone(member_list_limit[1].pool.load_balancer)
+
     def test_create(self):
         member = self.create_member(self.FAKE_UUID_1, self.FAKE_UUID_2,
                                     self.pool.id, ip_address="192.0.2.1")
@@ -2466,16 +2669,6 @@ class TestListenerRepositoryTest(BaseRepositoryTest):
         self.session.commit()
         return amphora
 
-    def create_loadbalancer(self, lb_id):
-        lb = self.lb_repo.create(self.session, id=lb_id,
-                                 project_id=self.FAKE_UUID_2, name="lb_name",
-                                 description="lb_description",
-                                 provisioning_status=constants.ACTIVE,
-                                 operating_status=constants.ONLINE,
-                                 enabled=True)
-        self.session.commit()
-        return lb
-
     def test_get(self):
         listener = self.create_listener(self.FAKE_UUID_1, 80)
         new_listener = self.listener_repo.get(self.session, id=listener.id)
@@ -3491,6 +3684,31 @@ class VipRepositoryTest(BaseRepositoryTest):
                                     load_balancer_id=vip.load_balancer_id)
         self.assertEqual(address_change, new_vip.ip_address)
 
+    def test_update_sg_ids(self):
+        sg1_id = uuidutils.generate_uuid()
+        sg2_id = uuidutils.generate_uuid()
+        vip = self.create_vip(self.lb.id)
+        self.vip_repo.update(self.session, vip.load_balancer_id,
+                             sg_ids=[sg1_id, sg2_id])
+        new_vip = self.vip_repo.get(self.session,
+                                    load_balancer_id=vip.load_balancer_id)
+        self.assertIn(sg1_id, new_vip.sg_ids)
+        self.assertIn(sg2_id, new_vip.sg_ids)
+
+        self.vip_repo.update(self.session, vip.load_balancer_id,
+                             sg_ids=[sg1_id])
+        new_vip = self.vip_repo.get(self.session,
+                                    load_balancer_id=vip.load_balancer_id)
+        self.assertIn(sg1_id, new_vip.sg_ids)
+        self.assertNotIn(sg2_id, new_vip.sg_ids)
+
+        self.vip_repo.update(self.session, vip.load_balancer_id,
+                             sg_ids=[])
+        new_vip = self.vip_repo.get(self.session,
+                                    load_balancer_id=vip.load_balancer_id)
+        self.assertNotIn(sg1_id, new_vip.sg_ids)
+        self.assertNotIn(sg2_id, new_vip.sg_ids)
+
     def test_delete(self):
         vip = self.create_vip(self.lb.id)
         self.vip_repo.delete(self.session,

octavia/tests/unit/amphorae/backends/agent/api_server/test_util.py

@@ -356,13 +356,57 @@ class TestUtil(base.TestCase):
         self.assertEqual([], util.get_haproxy_vip_addresses(LB_ID1))
         mock_cfg_path.assert_called_once_with(LB_ID1)
 
+    @mock.patch('octavia.amphorae.backends.agent.api_server.util.'
+                'keepalived_lvs_cfg_path')
+    def test_get_lvs_vip_addresses(self, mock_cfg_path):
+        FAKE_PATH = 'fake_path'
+        mock_cfg_path.return_value = FAKE_PATH
+        self.useFixture(
+            test_utils.OpenFixture(FAKE_PATH, 'no match')).mock_open()
+
+        # Test with no matching lines in the config file
+        self.assertEqual([], util.get_lvs_vip_addresses(LB_ID1))
+        mock_cfg_path.assert_called_once_with(LB_ID1)
+
+        # Test with 2 matching lines
+        mock_cfg_path.reset_mock()
+        test_data = ('virtual_server_group ipv4-group {\n'
+                     '    203.0.113.43 1\n'
+                     '    203.0.113.44 1\n'
+                     '}\n')
+        self.useFixture(
+            test_utils.OpenFixture(FAKE_PATH, test_data)).mock_open()
+        expected_result = ['203.0.113.43', '203.0.113.44']
+        self.assertEqual(expected_result,
+                         util.get_lvs_vip_addresses(LB_ID1))
+        mock_cfg_path.assert_called_once_with(LB_ID1)
+
+        # Test with 2 groups
+        mock_cfg_path.reset_mock()
+        test_data = ('virtual_server_group ipv4-group {\n'
+                     '    203.0.113.43 1\n'
+                     '}\n'
+                     'virtual_server_group ipv6-group {\n'
+                     '    2d01:27::1 2\n'
+                     '    2d01:27::2 2\n'
+                     '}\n')
+        self.useFixture(
+            test_utils.OpenFixture(FAKE_PATH, test_data)).mock_open()
+        expected_result = ['203.0.113.43', '2d01:27::1', '2d01:27::2']
+        self.assertEqual(expected_result,
+                         util.get_lvs_vip_addresses(LB_ID1))
+        mock_cfg_path.assert_called_once_with(LB_ID1)
+
     @mock.patch('octavia.amphorae.backends.utils.ip_advertisement.'
                 'send_ip_advertisement')
     @mock.patch('octavia.amphorae.backends.utils.network_utils.'
                 'get_interface_name')
     @mock.patch('octavia.amphorae.backends.agent.api_server.util.'
                 'get_haproxy_vip_addresses')
-    def test_send_vip_advertisements(self, mock_get_vip_addrs,
+    @mock.patch('octavia.amphorae.backends.agent.api_server.util.'
+                'get_lvs_vip_addresses')
+    def test_send_vip_advertisements(self, mock_get_lvs_vip_addrs,
+                                     mock_get_vip_addrs,
                                      mock_get_int_name, mock_send_advert):
         mock_get_vip_addrs.side_effect = [[], ['203.0.113.46'],
                                           Exception('boom')]
@@ -371,6 +415,7 @@ class TestUtil(base.TestCase):
         # Test no VIPs
         util.send_vip_advertisements(LB_ID1)
         mock_get_vip_addrs.assert_called_once_with(LB_ID1)
+        mock_get_lvs_vip_addrs.assert_not_called()
         mock_get_int_name.assert_not_called()
         mock_send_advert.assert_not_called()
 
@@ -380,6 +425,7 @@ class TestUtil(base.TestCase):
         mock_send_advert.reset_mock()
         util.send_vip_advertisements(LB_ID1)
         mock_get_vip_addrs.assert_called_once_with(LB_ID1)
+        mock_get_lvs_vip_addrs.assert_not_called()
         mock_get_int_name.assert_called_once_with(
             '203.0.113.46', net_ns=consts.AMPHORA_NAMESPACE)
         mock_send_advert.assert_called_once_with(
@@ -393,6 +439,48 @@ class TestUtil(base.TestCase):
         mock_get_int_name.assert_not_called()
         mock_send_advert.assert_not_called()
 
+    @mock.patch('octavia.amphorae.backends.utils.ip_advertisement.'
+                'send_ip_advertisement')
+    @mock.patch('octavia.amphorae.backends.utils.network_utils.'
+                'get_interface_name')
+    @mock.patch('octavia.amphorae.backends.agent.api_server.util.'
+                'get_haproxy_vip_addresses')
+    @mock.patch('octavia.amphorae.backends.agent.api_server.util.'
+                'get_lvs_vip_addresses')
+    def test_send_vip_advertisements_udp(self, mock_get_lvs_vip_addrs,
+                                         mock_get_vip_addrs,
+                                         mock_get_int_name, mock_send_advert):
+        mock_get_lvs_vip_addrs.side_effect = [[], ['203.0.113.46'],
+                                              Exception('boom')]
+        mock_get_int_name.return_value = 'fake0'
+
+        # Test no VIPs
+        util.send_vip_advertisements(listener_id=LISTENER_ID1)
+        mock_get_lvs_vip_addrs.assert_called_once_with(LISTENER_ID1)
+        mock_get_vip_addrs.assert_not_called()
+        mock_get_int_name.assert_not_called()
+        mock_send_advert.assert_not_called()
+
+        # Test with a VIP
+        mock_get_lvs_vip_addrs.reset_mock()
+        mock_get_int_name.reset_mock()
+        mock_send_advert.reset_mock()
+        util.send_vip_advertisements(listener_id=LISTENER_ID1)
+        mock_get_lvs_vip_addrs.assert_called_once_with(LISTENER_ID1)
+        mock_get_vip_addrs.assert_not_called()
+        mock_get_int_name.assert_called_once_with(
+            '203.0.113.46', net_ns=consts.AMPHORA_NAMESPACE)
+        mock_send_advert.assert_called_once_with(
+            'fake0', '203.0.113.46', net_ns=consts.AMPHORA_NAMESPACE)
+
+        # Test with an exception (should not raise)
+        mock_get_lvs_vip_addrs.reset_mock()
+        mock_get_int_name.reset_mock()
+        mock_send_advert.reset_mock()
+        util.send_vip_advertisements(listener_id=LISTENER_ID1)
+        mock_get_int_name.assert_not_called()
+        mock_send_advert.assert_not_called()
+
     @mock.patch('octavia.amphorae.backends.utils.ip_advertisement.'
                 'send_ip_advertisement')
     @mock.patch('octavia.amphorae.backends.utils.network_utils.'

octavia/tests/unit/amphorae/drivers/haproxy/test_rest_api_driver_1_0.py

@@ -17,7 +17,6 @@ from unittest import mock
 
 from oslo_config import cfg
 from oslo_config import fixture as oslo_fixture
-from oslo_utils.secretutils import md5
 from oslo_utils import uuidutils
 import requests
 import requests_mock
@@ -354,7 +353,8 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
         mock_oslo.return_value = fake_context
         self.driver.cert_manager.get_secret.reset_mock()
         self.driver.cert_manager.get_secret.return_value = fake_secret
-        ref_md5 = md5(fake_secret, usedforsecurity=False).hexdigest()  # nosec
+        ref_md5 = hashlib.md5(
+            fake_secret, usedforsecurity=False).hexdigest()  # nosec
         ref_id = hashlib.sha1(fake_secret).hexdigest()  # nosec
         ref_name = f'{ref_id}.pem'
 
@@ -418,7 +418,8 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
         mock_load_certs.return_value = pool_data
         fake_pem = b'fake pem'
         mock_build_pem.return_value = fake_pem
-        ref_md5 = md5(fake_pem, usedforsecurity=False).hexdigest()  # nosec
+        ref_md5 = hashlib.md5(
+            fake_pem, usedforsecurity=False).hexdigest()  # nosec
         ref_name = f'{pool_cert.id}.pem'
         ref_path = (f'{fake_cert_dir}/{sample_listener.load_balancer.id}/'
                     f'{ref_name}')
@@ -779,7 +780,8 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
         self.driver.clients[API_VERSION].plug_network.assert_called_once_with(
             self.amp, dict(mac_address=FAKE_MAC_ADDRESS,
                            fixed_ips=[],
-                           mtu=FAKE_MTU))
+                           mtu=FAKE_MTU,
+                           is_sriov=False))
 
         self.driver.clients[API_VERSION].plug_network.reset_mock()
 
@@ -791,7 +793,7 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
                                            subnet_cidr='198.51.100.0/24',
                                            host_routes=[],
                                            gateway=FAKE_GATEWAY)],
-                           mtu=FAKE_MTU))
+                           mtu=FAKE_MTU, is_sriov=False))
 
         self.driver.clients[API_VERSION].plug_network.reset_mock()
 
@@ -818,7 +820,7 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
                                additional_vips=[],
                                mtu=FAKE_MTU,
                                is_sriov=False
-                           )))
+                           ), is_sriov=False))
 
     def test_post_network_plug_with_host_routes(self):
         SUBNET_ID = 'SUBNET_ID'
@@ -858,7 +860,8 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
         self.driver.clients[API_VERSION].plug_network.assert_called_once_with(
             self.amp, dict(mac_address=FAKE_MAC_ADDRESS,
                            fixed_ips=expected_fixed_ips,
-                           mtu=FAKE_MTU))
+                           mtu=FAKE_MTU,
+                           is_sriov=False))
 
     def test_get_haproxy_versions(self):
         ref_haproxy_versions = ['1', '6']