octavia 13.0.0.0rc1__py3-none-any.whl → 14.0.0__py3-none-any.whl

octavia/tests/unit/controller/worker/v2/flows/test_load_balancer_flows.py

@@ -96,6 +96,32 @@ class TestLoadBalancerFlows(base.TestCase):
                           self.LBFlow.get_create_load_balancer_flow,
                           'BOGUS')
 
+    @mock.patch('octavia.common.rpc.NOTIFIER',
+                new_callable=MockNOTIFIER)
+    def test_get_create_load_balancer_flow_SRIOV(self, mock_get_net_driver,
+                                                 mock_notifier):
+        amp_flow = self.LBFlow.get_create_load_balancer_flow(
+            constants.TOPOLOGY_SINGLE, flavor_dict={constants.SRIOV_VIP: True})
+        self.assertIsInstance(amp_flow, flow.Flow)
+        self.assertIn(constants.AVAILABILITY_ZONE, amp_flow.requires)
+        self.assertIn(constants.BUILD_TYPE_PRIORITY, amp_flow.requires)
+        self.assertIn(constants.FLAVOR, amp_flow.requires)
+        self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
+        self.assertIn(constants.SERVER_GROUP_ID, amp_flow.requires)
+        self.assertIn(constants.UPDATE_DICT, amp_flow.requires)
+        self.assertIn(constants.ADDITIONAL_VIPS, amp_flow.provides)
+        self.assertIn(constants.AMP_DATA, amp_flow.provides)
+        self.assertIn(constants.AMPHORA, amp_flow.provides)
+        self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
+        self.assertIn(constants.AMPHORA_NETWORK_CONFIG, amp_flow.provides)
+        self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
+        self.assertIn(constants.COMPUTE_OBJ, amp_flow.provides)
+        self.assertIn(constants.LOADBALANCER, amp_flow.provides)
+        self.assertIn(constants.PORT_DATA, amp_flow.provides)
+        self.assertIn(constants.SERVER_PEM, amp_flow.provides)
+        self.assertIn(constants.SUBNET, amp_flow.provides)
+        self.assertIn(constants.VIP, amp_flow.provides)
+
     @mock.patch('octavia.common.rpc.NOTIFIER',
                 new_callable=MockNOTIFIER)
     def test_get_delete_load_balancer_flow(self, mock_get_net_driver,
@@ -199,14 +225,16 @@ class TestLoadBalancerFlows(base.TestCase):
 
         self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
         self.assertIn(constants.UPDATE_DICT, amp_flow.requires)
+        self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
 
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMP_VRRP_INT, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.LOADBALANCER, amp_flow.provides)
 
-        self.assertEqual(2, len(amp_flow.requires), amp_flow.requires)
-        self.assertEqual(4, len(amp_flow.provides), amp_flow.provides)
+        self.assertEqual(3, len(amp_flow.requires), amp_flow.requires)
+        self.assertEqual(5, len(amp_flow.provides), amp_flow.provides)
 
         amp_flow = self.LBFlow.get_post_lb_amp_association_flow(
             '123', constants.TOPOLOGY_ACTIVE_STANDBY)
@@ -215,14 +243,16 @@ class TestLoadBalancerFlows(base.TestCase):
 
         self.assertIn(constants.LOADBALANCER_ID, amp_flow.requires)
         self.assertIn(constants.UPDATE_DICT, amp_flow.requires)
+        self.assertIn(constants.AMPHORA_ID, amp_flow.requires)
 
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.AMP_VRRP_INT, amp_flow.provides)
         self.assertIn(constants.LOADBALANCER, amp_flow.provides)
 
-        self.assertEqual(2, len(amp_flow.requires), amp_flow.requires)
-        self.assertEqual(4, len(amp_flow.provides), amp_flow.provides)
+        self.assertEqual(3, len(amp_flow.requires), amp_flow.requires)
+        self.assertEqual(5, len(amp_flow.provides), amp_flow.provides)
 
     @mock.patch('octavia.common.rpc.NOTIFIER',
                 new_callable=MockNOTIFIER)
@@ -285,6 +315,7 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.AMPHORA_ID, create_flow.provides)
         self.assertIn(constants.AMPHORA_NETWORK_CONFIG, create_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, create_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, create_flow.provides)
         self.assertIn(constants.COMPUTE_ID, create_flow.provides)
         self.assertIn(constants.COMPUTE_OBJ, create_flow.provides)
         self.assertIn(constants.DELTAS, create_flow.provides)
@@ -296,7 +327,7 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.ADDITIONAL_VIPS, create_flow.provides)
 
         self.assertEqual(6, len(create_flow.requires), create_flow.requires)
-        self.assertEqual(17, len(create_flow.provides),
+        self.assertEqual(18, len(create_flow.provides),
                          create_flow.provides)
 
     def _test_get_failover_LB_flow_single(self, amphorae):
@@ -313,6 +344,7 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.FLAVOR, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, failover_flow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, failover_flow.requires)
 
         self.assertIn(constants.UPDATED_PORTS, failover_flow.provides)
         self.assertIn(constants.AMPHORA, failover_flow.provides)
@@ -328,10 +360,13 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.VIP, failover_flow.provides)
         self.assertIn(constants.ADDITIONAL_VIPS, failover_flow.provides)
         self.assertIn(constants.VIP_SG_ID, failover_flow.provides)
+        self.assertIn(constants.AMPHORA_FIREWALL_RULES, failover_flow.provides)
+        self.assertIn(constants.SUBNET, failover_flow.provides)
+        self.assertIn(constants.NEW_AMPHORAE, failover_flow.provides)
 
-        self.assertEqual(6, len(failover_flow.requires),
+        self.assertEqual(7, len(failover_flow.requires),
                          failover_flow.requires)
-        self.assertEqual(13, len(failover_flow.provides),
+        self.assertEqual(16, len(failover_flow.provides),
                          failover_flow.provides)
 
     @mock.patch('octavia.common.rpc.NOTIFIER',
@@ -389,6 +424,7 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.FLAVOR, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER, failover_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, failover_flow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, failover_flow.requires)
 
         self.assertIn(constants.UPDATED_PORTS, failover_flow.provides)
         self.assertIn(constants.AMPHORA, failover_flow.provides)
@@ -404,10 +440,14 @@ class TestLoadBalancerFlows(base.TestCase):
         self.assertIn(constants.VIP, failover_flow.provides)
         self.assertIn(constants.ADDITIONAL_VIPS, failover_flow.provides)
         self.assertIn(constants.VIP_SG_ID, failover_flow.provides)
+        self.assertIn(constants.SUBNET, failover_flow.provides)
+        self.assertIn(constants.AMPHORA_FIREWALL_RULES, failover_flow.provides)
+        self.assertIn(constants.SUBNET, failover_flow.provides)
+        self.assertIn(constants.NEW_AMPHORAE, failover_flow.provides)
 
-        self.assertEqual(6, len(failover_flow.requires),
+        self.assertEqual(7, len(failover_flow.requires),
                          failover_flow.requires)
-        self.assertEqual(13, len(failover_flow.provides),
+        self.assertEqual(16, len(failover_flow.provides),
                          failover_flow.provides)
 
     @mock.patch('octavia.common.rpc.NOTIFIER',

octavia/tests/unit/controller/worker/v2/tasks/test_amphora_driver_tasks.py

@@ -132,21 +132,54 @@ class TestAmphoraDriverTasks(base.TestCase):
 
         mock_amphora_repo_get.return_value = _db_amphora_mock
         mock_lb_get.return_value = _db_load_balancer_mock
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+
         amp_list_update_obj = amphora_driver_tasks.AmphoraIndexListenerUpdate()
         amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock],
+                                    amphorae_status,
+                                    _amphora_mock[constants.ID],
                                     self.timeout_dict)
 
         mock_driver.update_amphora_listeners.assert_called_once_with(
             _db_load_balancer_mock, _db_amphora_mock, self.timeout_dict)
 
+        # Unreachable amp
+        mock_driver.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock],
+                                    amphorae_status,
+                                    _amphora_mock[constants.ID],
+                                    self.timeout_dict)
+        mock_driver.update_amphora_listeners.assert_not_called()
+
+        # Test exception
         mock_driver.update_amphora_listeners.side_effect = Exception('boom')
 
-        amp_list_update_obj.execute(_LB_mock, 0,
-                                    [_amphora_mock], self.timeout_dict)
+        amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock], {},
+                                    _amphora_mock[constants.ID],
+                                    self.timeout_dict)
 
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, AMP_ID, status=constants.ERROR)
 
+        # Test exception, secondary amp
+        mock_amphora_repo_update.reset_mock()
+        mock_driver.update_amphora_listeners.side_effect = Exception('boom')
+
+        amp_list_update_obj.execute(_LB_mock, 0, [_amphora_mock], {},
+                                    '1234',
+                                    self.timeout_dict)
+
+        mock_amphora_repo_update.assert_not_called()
+
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
     @mock.patch('octavia.db.api.session')
     def test_listeners_update(self,
@@ -198,39 +231,70 @@ class TestAmphoraDriverTasks(base.TestCase):
             mock_driver, mock_generate_uuid, mock_log, mock_get_session,
             mock_listener_repo_get, mock_listener_repo_update,
             mock_amphora_repo_get, mock_amphora_repo_update):
-        amphora_mock = mock.MagicMock()
         listeners_reload_obj = (
             amphora_driver_tasks.AmphoraIndexListenersReload())
         mock_lb = mock.MagicMock()
         mock_listener = mock.MagicMock()
         mock_listener.id = '12345'
-        mock_amphora_repo_get.return_value = amphora_mock
+        mock_amphora_repo_get.return_value = _amphora_mock
         mock_lb_repo_get.return_value = mock_lb
         mock_driver.reload.side_effect = [mock.DEFAULT, Exception('boom')]
 
         # Test no listeners
         mock_lb.listeners = None
-        listeners_reload_obj.execute(mock_lb, 0, None)
+        listeners_reload_obj.execute(mock_lb, 0, None, {},
+                                     _amphora_mock[constants.ID])
         mock_driver.reload.assert_not_called()
 
         # Test with listeners
-        mock_driver.start.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+        mock_driver.reload.reset_mock()
         mock_lb.listeners = [mock_listener]
-        listeners_reload_obj.execute(mock_lb, 0, [amphora_mock],
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock],
+                                     amphorae_status,
+                                     _amphora_mock[constants.ID],
                                      timeout_dict=self.timeout_dict)
-        mock_driver.reload.assert_called_once_with(mock_lb, amphora_mock,
+        mock_driver.reload.assert_called_once_with(mock_lb, _amphora_mock,
                                                    self.timeout_dict)
 
+        # Unreachable amp
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        mock_driver.reload.reset_mock()
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock],
+                                     amphorae_status,
+                                     _amphora_mock[constants.ID],
+                                     timeout_dict=self.timeout_dict)
+        mock_driver.reload.assert_not_called()
+
         # Test with reload exception
         mock_driver.reload.reset_mock()
-        listeners_reload_obj.execute(mock_lb, 0, [amphora_mock],
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock], {},
+                                     _amphora_mock[constants.ID],
                                      timeout_dict=self.timeout_dict)
-        mock_driver.reload.assert_called_once_with(mock_lb, amphora_mock,
+        mock_driver.reload.assert_called_once_with(mock_lb, _amphora_mock,
                                                    self.timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
-            _session_mock, amphora_mock[constants.ID],
+            _session_mock, _amphora_mock[constants.ID],
             status=constants.ERROR)
 
+        # Test with reload exception, secondary amp
+        mock_driver.reload.reset_mock()
+        mock_amphora_repo_update.reset_mock()
+        listeners_reload_obj.execute(mock_lb, 0, [_amphora_mock], {},
+                                     '1234',
+                                     timeout_dict=self.timeout_dict)
+        mock_driver.reload.assert_called_once_with(mock_lb, _amphora_mock,
+                                                   self.timeout_dict)
+        mock_amphora_repo_update.assert_not_called()
+
     @mock.patch('octavia.controller.worker.task_utils.TaskUtils.'
                 'mark_listener_prov_status_error')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
@@ -827,6 +891,11 @@ class TestAmphoraDriverTasks(base.TestCase):
         FAKE_INTERFACE = 'fake0'
         mock_driver.get_interface_from_ip.side_effect = [FAKE_INTERFACE,
                                                          Exception('boom')]
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
 
         timeout_dict = {constants.CONN_MAX_RETRIES: CONN_MAX_RETRIES,
                         constants.CONN_RETRY_INTERVAL: CONN_RETRY_INTERVAL}
@@ -834,20 +903,39 @@ class TestAmphoraDriverTasks(base.TestCase):
         amphora_update_vrrp_interface_obj = (
             amphora_driver_tasks.AmphoraIndexUpdateVRRPInterface())
         amphora_update_vrrp_interface_obj.execute(
-            0, [_amphora_mock], timeout_dict)
+            0, [_amphora_mock], amphorae_status, _amphora_mock[constants.ID],
+            timeout_dict)
         mock_driver.get_interface_from_ip.assert_called_once_with(
             _db_amphora_mock, _db_amphora_mock.vrrp_ip,
             timeout_dict=timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, vrrp_interface=FAKE_INTERFACE)
 
+        # Unreachable amp
+        mock_driver.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        amphora_update_vrrp_interface_obj.execute(
+            0, [_amphora_mock], amphorae_status, _amphora_mock[constants.ID],
+            timeout_dict)
+        mock_driver.get_interface_from_ip.assert_not_called()
+
         # Test with an exception
         mock_amphora_repo_update.reset_mock()
         amphora_update_vrrp_interface_obj.execute(
-            0, [_amphora_mock], timeout_dict)
+            0, [_amphora_mock], {}, _amphora_mock[constants.ID], timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, status=constants.ERROR)
 
+        # Test with an exception, secondary amp
+        mock_amphora_repo_update.reset_mock()
+        amphora_update_vrrp_interface_obj.execute(
+            0, [_amphora_mock], {}, '1234', timeout_dict)
+        mock_amphora_repo_update.assert_not_called()
+
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.get')
     def test_amphora_vrrp_update(self,
                                  mock_lb_get,
@@ -895,23 +983,52 @@ class TestAmphoraDriverTasks(base.TestCase):
                                                     Exception('boom')]
         mock_lb_get.return_value = _db_load_balancer_mock
         mock_amphora_repo_get.return_value = _db_amphora_mock
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+
         amphora_vrrp_update_obj = (
             amphora_driver_tasks.AmphoraIndexVRRPUpdate())
 
         amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
-                                        0, [_amphora_mock], 'fakeint0',
+                                        0, [_amphora_mock], amphorae_status,
+                                        'fakeint0',
+                                        _amphora_mock[constants.ID],
                                         timeout_dict=self.timeout_dict)
         mock_driver.update_vrrp_conf.assert_called_once_with(
             _db_load_balancer_mock, amphorae_network_config, _db_amphora_mock,
             self.timeout_dict)
 
+        # Unreachable amp
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        mock_amphora_repo_update.reset_mock()
+        mock_driver.update_vrrp_conf.reset_mock()
+        amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
+                                        0, [_amphora_mock], amphorae_status,
+                                        None, _amphora_mock[constants.ID])
+        mock_driver.update_vrrp_conf.assert_not_called()
+
         # Test with an exception
         mock_amphora_repo_update.reset_mock()
         amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
-                                        0, [_amphora_mock], 'fakeint0')
+                                        0, [_amphora_mock], {}, 'fakeint0',
+                                        _amphora_mock[constants.ID])
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, status=constants.ERROR)
 
+        # Test with an exception, secondary amp
+        mock_amphora_repo_update.reset_mock()
+        amphora_vrrp_update_obj.execute(LB_ID, amphorae_network_config,
+                                        0, [_amphora_mock], {}, 'fakeint0',
+                                        '1234')
+        mock_amphora_repo_update.assert_not_called()
+
     def test_amphora_vrrp_start(self,
                                 mock_driver,
                                 mock_generate_uuid,
@@ -939,25 +1056,54 @@ class TestAmphoraDriverTasks(base.TestCase):
                                       mock_amphora_repo_get,
                                       mock_amphora_repo_update):
         mock_amphora_repo_get.return_value = _db_amphora_mock
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: False
+            }
+        }
+
         amphora_vrrp_start_obj = (
             amphora_driver_tasks.AmphoraIndexVRRPStart())
         mock_driver.start_vrrp_service.side_effect = [mock.DEFAULT,
                                                       Exception('boom')]
 
-        amphora_vrrp_start_obj.execute(0, [_amphora_mock],
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], amphorae_status,
+                                       _amphora_mock[constants.ID],
                                        timeout_dict=self.timeout_dict)
         mock_driver.start_vrrp_service.assert_called_once_with(
             _db_amphora_mock, self.timeout_dict)
 
+        # Unreachable amp
+        mock_driver.start_vrrp_service.reset_mock()
+        amphorae_status = {
+            _amphora_mock[constants.ID]: {
+                constants.UNREACHABLE: True
+            }
+        }
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], amphorae_status,
+                                       _amphora_mock[constants.ID],
+                                       timeout_dict=self.timeout_dict)
+        mock_driver.start_vrrp_service.assert_not_called()
+
         # Test with a start exception
         mock_driver.start_vrrp_service.reset_mock()
-        amphora_vrrp_start_obj.execute(0, [_amphora_mock],
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], {},
+                                       _amphora_mock[constants.ID],
                                        timeout_dict=self.timeout_dict)
         mock_driver.start_vrrp_service.assert_called_once_with(
             _db_amphora_mock, self.timeout_dict)
         mock_amphora_repo_update.assert_called_once_with(
             _session_mock, _db_amphora_mock.id, status=constants.ERROR)
 
+        # Test with a start exception, secondary amp
+        mock_driver.start_vrrp_service.reset_mock()
+        mock_amphora_repo_update.reset_mock()
+        amphora_vrrp_start_obj.execute(0, [_amphora_mock], {}, '1234',
+                                       timeout_dict=self.timeout_dict)
+        mock_driver.start_vrrp_service.assert_called_once_with(
+            _db_amphora_mock, self.timeout_dict)
+        mock_amphora_repo_update.assert_not_called()
+
     def test_amphora_compute_connectivity_wait(self,
                                                mock_driver,
                                                mock_generate_uuid,
@@ -1029,3 +1175,105 @@ class TestAmphoraDriverTasks(base.TestCase):
         self.assertRaises(driver_except.TimeOutException,
                           amp_config_update_obj.execute,
                           _amphora_mock, flavor)
+
+    def test_amphorae_get_connectivity_status(self,
+                                              mock_driver,
+                                              mock_generate_uuid,
+                                              mock_log,
+                                              mock_get_session,
+                                              mock_listener_repo_get,
+                                              mock_listener_repo_update,
+                                              mock_amphora_repo_get,
+                                              mock_amphora_repo_update):
+        amphora1_mock = mock.MagicMock()
+        amphora1_mock[constants.ID] = 'id1'
+        amphora2_mock = mock.MagicMock()
+        amphora2_mock[constants.ID] = 'id2'
+        db_amphora1_mock = mock.Mock()
+        db_amphora2_mock = mock.Mock()
+
+        amp_get_connectivity_status = (
+            amphora_driver_tasks.AmphoraeGetConnectivityStatus())
+
+        # All amphorae reachable
+        mock_amphora_repo_get.side_effect = [
+            db_amphora1_mock,
+            db_amphora2_mock]
+        mock_driver.check.return_value = None
+
+        ret = amp_get_connectivity_status.execute(
+            [amphora1_mock, amphora2_mock],
+            amphora1_mock[constants.ID],
+            timeout_dict=self.timeout_dict)
+        mock_driver.check.assert_has_calls(
+            [mock.call(db_amphora1_mock, timeout_dict=self.timeout_dict),
+             mock.call(db_amphora2_mock, timeout_dict=self.timeout_dict)])
+        self.assertFalse(
+            ret[amphora1_mock[constants.ID]][constants.UNREACHABLE])
+        self.assertFalse(
+            ret[amphora2_mock[constants.ID]][constants.UNREACHABLE])
+
+        # amphora1 unreachable
+        mock_driver.check.reset_mock()
+        mock_amphora_repo_get.side_effect = [
+            db_amphora1_mock,
+            db_amphora2_mock]
+        mock_driver.check.side_effect = [
+            driver_except.TimeOutException, None]
+        self.assertRaises(driver_except.TimeOutException,
+                          amp_get_connectivity_status.execute,
+                          [amphora1_mock, amphora2_mock],
+                          amphora1_mock[constants.ID],
+                          timeout_dict=self.timeout_dict)
+        mock_driver.check.assert_called_with(
+            db_amphora1_mock, timeout_dict=self.timeout_dict)
+
+        # amphora2 unreachable
+        mock_driver.check.reset_mock()
+        mock_amphora_repo_get.side_effect = [
+            db_amphora1_mock,
+            db_amphora2_mock]
+        mock_driver.check.side_effect = [
+            None, driver_except.TimeOutException]
+        ret = amp_get_connectivity_status.execute(
+            [amphora1_mock, amphora2_mock],
+            amphora1_mock[constants.ID],
+            timeout_dict=self.timeout_dict)
+        mock_driver.check.assert_has_calls(
+            [mock.call(db_amphora1_mock, timeout_dict=self.timeout_dict),
+             mock.call(db_amphora2_mock, timeout_dict=self.timeout_dict)])
+        self.assertFalse(
+            ret[amphora1_mock[constants.ID]][constants.UNREACHABLE])
+        self.assertTrue(
+            ret[amphora2_mock[constants.ID]][constants.UNREACHABLE])
+
+    def test_set_amphora_firewall_rules(self,
+                                        mock_driver,
+                                        mock_generate_uuid,
+                                        mock_log,
+                                        mock_get_session,
+                                        mock_listener_repo_get,
+                                        mock_listener_repo_update,
+                                        mock_amphora_repo_get,
+                                        mock_amphora_repo_update):
+        amphora = {constants.ID: AMP_ID, constants.VRRP_IP: '192.0.2.88'}
+        mock_amphora_repo_get.return_value = _db_amphora_mock
+
+        set_amp_fw_rules = amphora_driver_tasks.SetAmphoraFirewallRules()
+
+        # Test non-SRIOV VIP path
+        set_amp_fw_rules.execute([amphora], 0, [{'non-sriov-vip': True}], {},
+                                 timeout_dict=None)
+
+        mock_get_session.assert_not_called()
+        mock_driver.set_interface_rules.assert_not_called()
+
+        # Test SRIOV VIP path
+        set_amp_fw_rules.execute([amphora], 0, [{'fake_rule': True}], {},
+                                 timeout_dict=None)
+
+        mock_amphora_repo_get.assert_called_once_with(_session_mock, id=AMP_ID)
+
+        mock_driver.set_interface_rules.assert_called_once_with(
+            _db_amphora_mock, '192.0.2.88', [{'fake_rule': True}],
+            timeout_dict=None)

octavia/tests/unit/controller/worker/v2/tasks/test_database_tasks.py

@@ -12,6 +12,7 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 #
+import copy
 import random
 from unittest import mock
 
@@ -24,6 +25,7 @@ from taskflow.types import failure
 from octavia.api.drivers import utils as provider_utils
 from octavia.common import constants
 from octavia.common import data_models
+from octavia.common import exceptions
 from octavia.common import utils
 from octavia.controller.worker.v2.tasks import database_tasks
 from octavia.db import repositories as repo
@@ -31,6 +33,7 @@ import octavia.tests.unit.base as base
 
 
 AMP_ID = uuidutils.generate_uuid()
+AMP2_ID = uuidutils.generate_uuid()
 COMPUTE_ID = uuidutils.generate_uuid()
 LB_ID = uuidutils.generate_uuid()
 SERVER_GROUP_ID = uuidutils.generate_uuid()
@@ -1424,7 +1427,7 @@ class TestDatabaseTasks(base.TestCase):
                        provisioning_status=constants.ERROR)
              ])
         self.assertEqual(2, repo.HealthMonitorRepository.update.call_count)
-        repo.HealthMonitorRepository.update.has_calls(
+        repo.HealthMonitorRepository.update.assert_has_calls(
             [mock.call(mock_session, health_monitor.id,
                        provisioning_status=constants.ERROR)])
         self.assertEqual(1, repo.L7PolicyRepository.update.call_count)
@@ -2987,3 +2990,100 @@ class TestDatabaseTasks(base.TestCase):
             mock_session,
             POOL_ID,
             operating_status=constants.ONLINE)
+
+    @mock.patch('octavia.common.utils.ip_version')
+    @mock.patch('octavia.db.api.get_session')
+    @mock.patch('octavia.db.repositories.ListenerRepository.'
+                'get_port_protocol_cidr_for_lb')
+    def test_get_amphora_firewall_rules(self,
+                                        mock_get_port_for_lb,
+                                        mock_db_get_session,
+                                        mock_ip_version,
+                                        mock_generate_uuid,
+                                        mock_LOG,
+                                        mock_get_session,
+                                        mock_loadbalancer_repo_update,
+                                        mock_listener_repo_update,
+                                        mock_amphora_repo_update,
+                                        mock_amphora_repo_delete):
+
+        amphora_dict = {constants.ID: AMP_ID}
+        rules = [{'protocol': 'TCP', 'cidr': '192.0.2.0/24', 'port': 80},
+                 {'protocol': 'TCP', 'cidr': '198.51.100.0/24', 'port': 80}]
+        vrrp_rules = [
+            {'protocol': 'TCP', 'cidr': '192.0.2.0/24', 'port': 80},
+            {'protocol': 'TCP', 'cidr': '198.51.100.0/24', 'port': 80},
+            {'cidr': '203.0.113.5/32', 'port': 112, 'protocol': 'vrrp'}]
+        mock_get_port_for_lb.side_effect = [
+            copy.deepcopy(rules), copy.deepcopy(rules), copy.deepcopy(rules),
+            copy.deepcopy(rules)]
+        mock_ip_version.side_effect = [4, 6, 55]
+
+        get_amp_fw_rules = database_tasks.GetAmphoraFirewallRules()
+
+        # Test non-SRIOV VIP
+        amphora_net_cfg_dict = {
+            AMP_ID: {constants.AMPHORA: {
+                     'load_balancer': {constants.VIP: {
+                         constants.VNIC_TYPE: constants.VNIC_TYPE_NORMAL}}}}}
+        result = get_amp_fw_rules.execute([amphora_dict], 0,
+                                          amphora_net_cfg_dict)
+        self.assertEqual([{'non-sriov-vip': True}], result)
+
+        # Test SRIOV VIP - Single
+        amphora_net_cfg_dict = {
+            AMP_ID: {constants.AMPHORA: {
+                'load_balancer': {constants.VIP: {
+                    constants.VNIC_TYPE: constants.VNIC_TYPE_DIRECT},
+                    constants.TOPOLOGY: constants.TOPOLOGY_SINGLE},
+                constants.LOAD_BALANCER_ID: LB_ID}}}
+        result = get_amp_fw_rules.execute([amphora_dict], 0,
+                                          amphora_net_cfg_dict)
+        mock_get_port_for_lb.assert_called_once_with(mock_db_get_session(),
+                                                     LB_ID)
+        self.assertEqual(rules, result)
+
+        mock_get_port_for_lb.reset_mock()
+
+        # Test SRIOV VIP - Active/Standby
+        amphora_net_cfg_dict = {
+            AMP_ID: {constants.AMPHORA: {
+                'load_balancer': {constants.VIP: {
+                    constants.VNIC_TYPE: constants.VNIC_TYPE_DIRECT},
+                    constants.TOPOLOGY: constants.TOPOLOGY_ACTIVE_STANDBY,
+                    constants.AMPHORAE: [{
+                        constants.ID: AMP_ID,
+                        constants.STATUS: constants.AMPHORA_ALLOCATED},
+                        {constants.ID: AMP2_ID,
+                         constants.STATUS: constants.AMPHORA_ALLOCATED,
+                         constants.VRRP_IP: '203.0.113.5'}]},
+                constants.LOAD_BALANCER_ID: LB_ID}}}
+
+        # IPv4 path
+        mock_get_port_for_lb.reset_mock()
+        vrrp_rules = [
+            {'protocol': 'TCP', 'cidr': '192.0.2.0/24', 'port': 80},
+            {'protocol': 'TCP', 'cidr': '198.51.100.0/24', 'port': 80},
+            {'cidr': '203.0.113.5/32', 'port': 112, 'protocol': 'vrrp'}]
+        result = get_amp_fw_rules.execute([amphora_dict], 0,
+                                          amphora_net_cfg_dict)
+        mock_get_port_for_lb.assert_called_once_with(mock_db_get_session(),
+                                                     LB_ID)
+        self.assertEqual(vrrp_rules, result)
+
+        # IPv6 path
+        mock_get_port_for_lb.reset_mock()
+        vrrp_rules = [
+            {'protocol': 'TCP', 'cidr': '192.0.2.0/24', 'port': 80},
+            {'protocol': 'TCP', 'cidr': '198.51.100.0/24', 'port': 80},
+            {'cidr': '203.0.113.5/128', 'port': 112, 'protocol': 'vrrp'}]
+        result = get_amp_fw_rules.execute([amphora_dict], 0,
+                                          amphora_net_cfg_dict)
+        mock_get_port_for_lb.assert_called_once_with(mock_db_get_session(),
+                                                     LB_ID)
+        self.assertEqual(vrrp_rules, result)
+
+        # Bogus IP version path
+        self.assertRaises(exceptions.InvalidIPAddress,
+                          get_amp_fw_rules.execute, [amphora_dict], 0,
+                          amphora_net_cfg_dict)