Return UnsupportedOptionError() on loadbalancer failover

The core OVN code for Loadbalancers does not support a
manual failover from one gateway node to another. But
running the command with the OVN provider driver seems
to succeed:

$ openstack loadbalancer failover $ID
(no output)

The code actually does nothing and just returns the
provisioning status as ACTIVE.

Since it's unsupported by the underlying technology,
have the provider driver return an UnsupportedOptionError().

Change-Id: I6b41b59919494cb428e7429dea8160b4c958fa76
Closes-bug: #1901936

ovn_octavia_provider/common/constants.py

@@ -46,7 +46,6 @@ SERVICE_AUTH = 'service_auth'
 # Request type constants
 REQ_TYPE_LB_CREATE = 'lb_create'
 REQ_TYPE_LB_DELETE = 'lb_delete'
-REQ_TYPE_LB_FAILOVER = 'lb_failover'
 REQ_TYPE_LB_UPDATE = 'lb_update'
 REQ_TYPE_LISTENER_CREATE = 'listener_create'
 REQ_TYPE_LISTENER_DELETE = 'listener_delete'

ovn_octavia_provider/driver.py

@@ -89,10 +89,10 @@ class OvnProviderDriver(driver_base.ProviderDriver):
         self._ovn_helper.add_request(request)
 
     def loadbalancer_failover(self, loadbalancer_id):
-        request_info = {'id': loadbalancer_id}
-        request = {'type': ovn_const.REQ_TYPE_LB_FAILOVER,
-                   'info': request_info}
-        self._ovn_helper.add_request(request)
+        msg = _('OVN provider does not support loadbalancer failover')
+        raise driver_exceptions.UnsupportedOptionError(
+            user_fault_string=msg,
+            operator_fault_string=msg)
 
     def loadbalancer_update(self, old_loadbalancer, new_loadbalancer):
         request_info = {'id': new_loadbalancer.loadbalancer_id}

ovn_octavia_provider/helper.py

@@ -66,7 +66,6 @@ class OvnProviderHelper(object):
             ovn_const.REQ_TYPE_LB_CREATE: self.lb_create,
             ovn_const.REQ_TYPE_LB_DELETE: self.lb_delete,
             ovn_const.REQ_TYPE_LB_UPDATE: self.lb_update,
-            ovn_const.REQ_TYPE_LB_FAILOVER: self.lb_failover,
             ovn_const.REQ_TYPE_LISTENER_CREATE: self.listener_create,
             ovn_const.REQ_TYPE_LISTENER_DELETE: self.listener_delete,
             ovn_const.REQ_TYPE_LISTENER_UPDATE: self.listener_update,
@@ -974,13 +973,6 @@ class OvnProviderHelper(object):
         self._execute_commands(commands)
         return status
 
-    def lb_failover(self, loadbalancer):
-        status = {
-            constants.LOADBALANCERS: [
-                {constants.ID: loadbalancer[constants.ID],
-                 constants.PROVISIONING_STATUS: constants.ACTIVE}]}
-        return status
-
     def lb_update(self, loadbalancer):
         lb_status = {constants.ID: loadbalancer[constants.ID],
                      constants.PROVISIONING_STATUS: constants.ACTIVE}

ovn_octavia_provider/tests/functional/test_driver.py

@@ -268,6 +268,10 @@ class TestOvnOctaviaProviderDriver(ovn_base.TestOvnOctaviaBase):
         self.assertRaises(o_exceptions.UnsupportedOptionError,
                           self.ovn_driver.pool_create, m_pool)
 
+        self.assertRaises(o_exceptions.UnsupportedOptionError,
+                          self.ovn_driver.loadbalancer_failover,
+                          lb_data['model'].loadbalancer_id)
+
         m_listener = self._create_listener_model(
             lb_data['model'].loadbalancer_id, m_pool.pool_id, 80)
         m_listener.protocol = o_constants.PROTOCOL_HTTP

ovn_octavia_provider/tests/unit/test_driver.py

@@ -456,11 +456,9 @@ class TestOvnProviderDriver(ovn_base.TestOvnOctaviaBase):
         self.mock_add_request.assert_called_once_with(expected_dict)
 
     def test_loadbalancer_failover(self):
-        info = {'id': self.ref_lb0.loadbalancer_id}
-        expected_dict = {'type': ovn_const.REQ_TYPE_LB_FAILOVER,
-                         'info': info}
-        self.driver.loadbalancer_failover(info['id'])
-        self.mock_add_request.assert_called_once_with(expected_dict)
+        self.assertRaises(exceptions.UnsupportedOptionError,
+                          self.driver.loadbalancer_failover,
+                          self.ref_lb0.loadbalancer_id)
 
     def test_pool_create_unsupported_protocol(self):
         self.ref_pool.protocol = 'HTTP'

ovn_octavia_provider/tests/unit/test_helper.py

@@ -528,11 +528,6 @@ class TestOvnProviderHelper(ovn_base.TestOvnOctaviaBase):
             mock.call(self.ovn_lb.uuid),
             mock.call(udp_lb.uuid)])
 
-    def test_lb_failover(self):
-        status = self.helper.lb_failover(self.lb)
-        self.assertEqual(status['loadbalancers'][0]['provisioning_status'],
-                         constants.ACTIVE)
-
     @mock.patch.object(ovn_helper.OvnProviderHelper, '_refresh_lb_vips')
     def test_lb_update_disabled(self, refresh_vips):
         self.lb['admin_state_up'] = False