Decouple neutron-server and api-server services.

plugin specified in neutron.conf should not
try to connect to api-server, until it is
used/plugged-in when creating Loadbalancer
pool/vip/member/health monitors etc, thus
allowing neutron-server to start independently
without depending on api-server to be up and running.

Change-Id: I9a2a47b29ae2f1ba7e77f9f0574071760399ff02
Closes-Bug: 1586023

neutron_plugin_contrail/plugins/opencontrail/loadbalancer/loadbalancer_db.py

@@ -39,103 +39,142 @@
 class LoadBalancerPluginDb(LoadBalancerPluginBase):
 
     def __init__(self):
-        admin_user = cfg.CONF.keystone_authtoken.admin_user
-        admin_password = cfg.CONF.keystone_authtoken.admin_password
-        admin_tenant_name = cfg.CONF.keystone_authtoken.admin_tenant_name
-        api_srvr_ip = cfg.CONF.APISERVER.api_server_ip
-        api_srvr_port = cfg.CONF.APISERVER.api_server_port
-        api_srvr_use_ssl= cfg.CONF.APISERVER.use_ssl
+        self.admin_user = cfg.CONF.keystone_authtoken.admin_user
+        self.admin_password = cfg.CONF.keystone_authtoken.admin_password
+        self.admin_tenant_name = cfg.CONF.keystone_authtoken.admin_tenant_name
+        self.api_srvr_ip = cfg.CONF.APISERVER.api_server_ip
+        self.api_srvr_port = cfg.CONF.APISERVER.api_server_port
+        self.api_srvr_use_ssl= cfg.CONF.APISERVER.use_ssl
         try:
-            auth_host = cfg.CONF.keystone_authtoken.auth_host
+            self.auth_host = cfg.CONF.keystone_authtoken.auth_host
         except cfg.NoSuchOptError:
-            auth_host = "127.0.0.1"
+            self.auth_host = "127.0.0.1"
 
         try:
-            auth_protocol = cfg.CONF.keystone_authtoken.auth_protocol
+            self.auth_protocol = cfg.CONF.keystone_authtoken.auth_protocol
         except cfg.NoSuchOptError:
-            auth_protocol = "http"
+            self.auth_protocol = "http"
 
         try:
-            auth_port = cfg.CONF.keystone_authtoken.auth_port
+            self.auth_port = cfg.CONF.keystone_authtoken.auth_port
         except cfg.NoSuchOptError:
-            auth_port = "35357"
+            self.auth_port = "35357"
 
         try:
-            auth_url = cfg.CONF.keystone_authtoken.auth_url
+            self.auth_url = cfg.CONF.keystone_authtoken.auth_url
         except cfg.NoSuchOptError:
-            auth_url = "/v2.0/tokens"
+            self.auth_url = "/v2.0/tokens"
 
         try:
-            auth_type = cfg.CONF.keystone_authtoken.auth_type
+            self.auth_type = cfg.CONF.keystone_authtoken.auth_type
         except cfg.NoSuchOptError:
-            auth_type = "keystone"
+            self.auth_type = "keystone"
 
         try:
-            api_server_url = cfg.CONF.APISERVER.api_server_url
+            self.api_server_url = cfg.CONF.APISERVER.api_server_url
         except cfg.NoSuchOptError:
-            api_server_url = "/"
+            self.api_server_url = "/"
+
+    @property
+    def api(self):
+        if hasattr(self, '_api'):
+            return self._api
 
         # Retry till a api-server is up
         connected = False
         while not connected:
             try:
-                self._api = VncApi(admin_user, admin_password, admin_tenant_name,
-                                   api_srvr_ip, api_srvr_port, api_server_url,
-                                   auth_host=auth_host, auth_port=auth_port,
-                                   auth_protocol=auth_protocol, auth_url=auth_url,
-                                   auth_type=auth_type, wait_for_connect=True,
-                                   api_server_use_ssl=api_srvr_use_ssl)
+                self._api = VncApi(self.admin_user, self.admin_password,
+                        self.admin_tenant_name, self.api_srvr_ip,
+                        self.api_srvr_port, self.api_server_url,
+                        auth_host=self.auth_host, auth_port=self.auth_port,
+                        auth_protocol=self.auth_protocol,
+                        auth_url=self.auth_url, auth_type=self.auth_type,
+                        wait_for_connect=True,
+                        api_server_use_ssl=self.api_srvr_use_ssl)
                 connected = True
             except requests.exceptions.RequestException:
                 time.sleep(3)
+        return self._api
+
+    @property
+    def pool_manager(self):
+        if hasattr(self, '_pool_manager'):
+            return self._pool_manager
 
         self._pool_manager = \
-            loadbalancer_pool.LoadbalancerPoolManager(self._api)
-        self._vip_manager = virtual_ip.VirtualIpManager(self._api)
+            loadbalancer_pool.LoadbalancerPoolManager(self.api)
+
+        return self._pool_manager
+
+    @property
+    def vip_manager(self):
+        if hasattr(self, '_vip_manager'):
+            return self._vip_manager
+
+        self._vip_manager = virtual_ip.VirtualIpManager(self.api)
+
+        return self._vip_manager
+
+    @property
+    def member_manager(self):
+        if hasattr(self, '_member_manager'):
+            return self._member_manager
+
         self._member_manager = \
-            loadbalancer_member.LoadbalancerMemberManager(self._api)
+            loadbalancer_member.LoadbalancerMemberManager(self.api)
+
+        return self._member_manager
+
+    @property
+    def monitor_manager(self):
+        if hasattr(self, '_monitor_manager'):
+            return self._monitor_manager
+
         self._monitor_manager = \
             loadbalancer_healthmonitor.LoadbalancerHealthmonitorManager(
-                self._api)
+                self.api)
+
+        return self._monitor_manager
 
     def get_api_client(self):
-        return self._api
+        return self.api
 
     def get_vips(self, context, filters=None, fields=None):
-        return self._vip_manager.get_collection(context, filters, fields)
+        return self.vip_manager.get_collection(context, filters, fields)
 
     def get_vip(self, context, id, fields=None):
-        return self._vip_manager.get_resource(context, id, fields)
+        return self.vip_manager.get_resource(context, id, fields)
 
     def create_vip(self, context, vip):
         try:
-            return self._vip_manager.create(context, vip)
+            return self.vip_manager.create(context, vip)
         except vnc_exc.PermissionDenied as ex:
             raise n_exc.BadRequest(resource='vip', msg=str(ex))
 
     def update_vip(self, context, id, vip):
-        return self._vip_manager.update(context, id, vip)
+        return self.vip_manager.update(context, id, vip)
 
     def delete_vip(self, context, id):
-        return self._vip_manager.delete(context, id)
+        return self.vip_manager.delete(context, id)
 
     def get_pools(self, context, filters=None, fields=None):
-        return self._pool_manager.get_collection(context, filters, fields)
+        return self.pool_manager.get_collection(context, filters, fields)
 
     def get_pool(self, context, id, fields=None):
-        return self._pool_manager.get_resource(context, id, fields)
+        return self.pool_manager.get_resource(context, id, fields)
 
     def create_pool(self, context, pool):
         try:
-            return self._pool_manager.create(context, pool)
+            return self.pool_manager.create(context, pool)
         except vnc_exc.PermissionDenied as ex:
             raise n_exc.BadRequest(resource='pool', msg=str(ex))
 
     def update_pool(self, context, id, pool):
-        return self._pool_manager.update(context, id, pool)
+        return self.pool_manager.update(context, id, pool)
 
     def delete_pool(self, context, id):
-        return self._pool_manager.delete(context, id)
+        return self.pool_manager.delete(context, id)
 
     def stats(self, context, pool_id):
         stats = {
@@ -168,12 +207,12 @@ def create_pool_health_monitor(self, context, health_monitor, pool_id):
         """
         m = health_monitor['health_monitor']
         try:
-            pool = self._api.loadbalancer_pool_read(id=pool_id)
+            pool = self.api.loadbalancer_pool_read(id=pool_id)
         except vnc_exc.NoIdError:
             raise loadbalancer.PoolNotFound(pool_id=pool_id)
 
         try:
-            monitor = self._api.loadbalancer_healthmonitor_read(id=m['id'])
+            monitor = self.api.loadbalancer_healthmonitor_read(id=m['id'])
         except vnc_exc.NoIdError:
             raise loadbalancer.HealthMonitorNotFound(monitor_id=m['id'])
 
@@ -191,7 +230,7 @@ def create_pool_health_monitor(self, context, health_monitor, pool_id):
                         monitor_id=m['id'], pool_id=pool_id)
 
         pool.add_loadbalancer_healthmonitor(monitor)
-        self._api.loadbalancer_pool_update(pool)
+        self.api.loadbalancer_pool_update(pool)
 
         res = {
             'id': monitor.uuid,
@@ -203,7 +242,7 @@ def get_pool_health_monitor(self, context, id, pool_id, fields=None):
         """ Query a specific pool, health_monitor association.
         """
         try:
-            pool = self._api.loadbalancer_pool_read(id=pool_id)
+            pool = self.api.loadbalancer_pool_read(id=pool_id)
         except vnc_exc.NoIdError:
             raise loadbalancer.PoolNotFound(pool_id=id)
         tenant_id = str(uuid.UUID(context.tenant_id))
@@ -223,22 +262,22 @@ def get_pool_health_monitor(self, context, id, pool_id, fields=None):
         res = {
             'pool_id': pool_id,
             'monitor_id': id,
-            'status': self._pool_manager._get_object_status(pool),
+            'status': self.pool_manager._get_object_status(pool),
             'tenant_id': pool.parent_uuid.replace('-', '')
         }
-        return self._pool_manager._fields(res, fields)
+        return self.pool_manager._fields(res, fields)
 
     def delete_pool_health_monitor(self, context, id, pool_id):
         try:
-            pool = self._api.loadbalancer_pool_read(id=pool_id)
+            pool = self.api.loadbalancer_pool_read(id=pool_id)
         except vnc_exc.NoIdError:
             raise loadbalancer.PoolNotFound(pool_id=id)
         tenant_id = str(uuid.UUID(context.tenant_id))
         if not context.is_admin and tenant_id != pool.parent_uuid:
             raise loadbalancer.PoolNotFound(pool_id=id)
 
         try:
-            monitor = self._api.loadbalancer_healthmonitor_read(id=id)
+            monitor = self.api.loadbalancer_healthmonitor_read(id=id)
         except vnc_exc.NoIdError:
             raise loadbalancer.HealthMonitorNotFound(monitor_id=id)
 
@@ -253,40 +292,40 @@ def delete_pool_health_monitor(self, context, id, pool_id):
                 monitor_id=id, pool_id=pool_id)
 
         pool.del_loadbalancer_healthmonitor(monitor)
-        self._api.loadbalancer_pool_update(pool)
+        self.api.loadbalancer_pool_update(pool)
 
     def get_members(self, context, filters=None, fields=None):
-        return self._member_manager.get_collection(context, filters, fields)
+        return self.member_manager.get_collection(context, filters, fields)
 
     def get_member(self, context, id, fields=None):
-        return self._member_manager.get_resource(context, id, fields)
+        return self.member_manager.get_resource(context, id, fields)
 
     def create_member(self, context, member):
         try:
-            return self._member_manager.create(context, member)
+            return self.member_manager.create(context, member)
         except vnc_exc.PermissionDenied as ex:
             raise n_exc.BadRequest(resource='member', msg=str(ex))
 
     def update_member(self, context, id, member):
-        return self._member_manager.update(context, id, member)
+        return self.member_manager.update(context, id, member)
 
     def delete_member(self, context, id):
-        return self._member_manager.delete(context, id)
+        return self.member_manager.delete(context, id)
 
     def get_health_monitors(self, context, filters=None, fields=None):
-        return self._monitor_manager.get_collection(context, filters, fields)
+        return self.monitor_manager.get_collection(context, filters, fields)
 
     def get_health_monitor(self, context, id, fields=None):
-        return self._monitor_manager.get_resource(context, id, fields)
+        return self.monitor_manager.get_resource(context, id, fields)
 
     def create_health_monitor(self, context, health_monitor):
         try:
-            return self._monitor_manager.create(context, health_monitor)
+            return self.monitor_manager.create(context, health_monitor)
         except vnc_exc.PermissionDenied as ex:
             raise n_exc.BadRequest(resource='health_monitor', msg=str(ex))
 
     def update_health_monitor(self, context, id, health_monitor):
-        return self._monitor_manager.update(context, id, health_monitor)
+        return self.monitor_manager.update(context, id, health_monitor)
 
     def delete_health_monitor(self, context, id):
-        return self._monitor_manager.delete(context, id)
+        return self.monitor_manager.delete(context, id)

neutron_plugin_contrail/plugins/opencontrail/loadbalancer/plugin.py

@@ -29,7 +29,7 @@ def _get_default_provider(self):
             provider = (service_type_manager.
                         get_default_service_provider(None,
                                                      constants.LOADBALANCER))
-            self._pool_manager.check_provider_exists(provider['name'])
+            self.pool_manager.check_provider_exists(provider['name'])
             self.default_provider = provider['name']
         except:
             pass