Regroup all session creation in util get_localAPI_session or APISession class.

New APISession class to handle lifecycle of the session, with context, or atexit handlers.
Use various originator for xapi session creation, to differentiate where they are being created.

Signed-off-by: Arnaud Garcia-Fernandez <arnaud.garcia-fernandez@vates.tech>

Author: Ythogtha

drivers/LinstorSR.py

@@ -2585,7 +2585,9 @@ def _start_persistent_http_server(volume_name):
                 # Use a timeout call because XAPI may be unusable on startup
                 # or if the host has been ejected. So in this case the call can
                 # block indefinitely.
-                session = util.timeout(5, util.get_localAPI_session)
+                apisession = util.timeout(
+                    5, util.APISession, "SM-LinstorSR-http")
+                session = apisession.session
                 host_ip = util.get_this_host_address(session)
             except:
                 # Fallback using the XHA file if session not available.
@@ -2669,7 +2671,9 @@ def _start_persistent_nbd_server(self, volume_name):
                 device_size = 256 * 1024 * 1024
 
             try:
-                session = util.timeout(5, util.get_localAPI_session)
+                apisession = util.timeout(
+                    5, util.APISession, "SM-LinstorSR-nbd")
+                session = apisession.session
                 ips = util.get_host_addresses(session)
             except Exception as e:
                 _, ips = get_ips_from_xha_config_file()

drivers/blktap2.py

@@ -1152,14 +1152,9 @@ def get_o_direct_capability(self, options):
 
     @classmethod
     def from_cli(cls, uuid):
-        session = XenAPI.xapi_local()
-        session.xenapi.login_with_password('root', '', '', 'SM')
-
-        target = sm.VDI.from_uuid(session, uuid)
-        driver_info = target.sr.srcmd.driver_info
-
-        session.xenapi.session.logout()
-
+        with util.APISession("SM-blktap2") as session:
+            target = sm.VDI.from_uuid(session, uuid)
+            driver_info = target.sr.srcmd.driver_info
         return cls(uuid, target, driver_info)
 
     @staticmethod

drivers/cleanup.py

@@ -299,18 +299,12 @@ class XAPI:
     class LookupError(util.SMException):
         pass
 
-    @staticmethod
-    def getSession():
-        session = XenAPI.xapi_local()
-        session.xenapi.login_with_password(XAPI.USER, '', '', 'SM')
-        return session
-
     def __init__(self, session, srUuid):
-        self.sessionPrivate = False
         self.session = session
+        self.apisession = None
         if self.session is None:
-            self.session = self.getSession()
-            self.sessionPrivate = True
+            self.apisession = util.APISession("SM-cleanup-XAPI")
+            self.session = self.apisession.session
         self._srRef = self.session.xenapi.SR.get_by_uuid(srUuid)
         self.srRecord = self.session.xenapi.SR.get_record(self._srRef)
         self.hostUuid = util.get_this_host()
@@ -319,8 +313,8 @@ def __init__(self, session, srUuid):
         self.task_progress = {"coalescable": 0, "done": 0}
 
     def __del__(self):
-        if self.sessionPrivate:
-            self.session.xenapi.session.logout()
+        if self.apisession:
+            self.apisession.logout()
 
     @property
     def srRef(self):
@@ -2127,32 +2121,31 @@ def msg_cleared(self, xapi_session, msg_ref):
         return msg is None
 
     def check_no_space_candidates(self):
-        xapi_session = self.xapi.getSession()
-
-        msg_id = self.xapi.srRecord["sm_config"].get(VDI.DB_GC_NO_SPACE)
-        if self.no_space_candidates:
-            if msg_id is None or self.msg_cleared(xapi_session, msg_id):
-                util.SMlog("Could not coalesce due to a lack of space "
-                           f"in SR {self.uuid}")
-                msg_body = ("Unable to perform data coalesce due to a lack "
-                            f"of space in SR {self.uuid}")
-                msg_id = xapi_session.xenapi.message.create(
-                    'SM_GC_NO_SPACE',
-                    3,
-                    "SR",
-                    self.uuid,
-                    msg_body)
-                xapi_session.xenapi.SR.remove_from_sm_config(
-                    self.xapi.srRef, VDI.DB_GC_NO_SPACE)
-                xapi_session.xenapi.SR.add_to_sm_config(
-                    self.xapi.srRef, VDI.DB_GC_NO_SPACE, msg_id)
-
-            for candidate in self.no_space_candidates.values():
-                candidate.setConfig(VDI.DB_GC_NO_SPACE, msg_id)
-        elif msg_id is not None:
-            # Everything was coalescable, remove the message
-            xapi_session.xenapi.SR.remove_from_sm_config(self.xapi.srRef, VDI.DB_GC_NO_SPACE)
-            xapi_session.xenapi.message.destroy(msg_id)
+        with util.APISession("SM-cleanup-SR-check_no_space_candidates") as xapi_session:
+            msg_id = self.xapi.srRecord["sm_config"].get(VDI.DB_GC_NO_SPACE)
+            if self.no_space_candidates:
+                if msg_id is None or self.msg_cleared(xapi_session, msg_id):
+                    util.SMlog("Could not coalesce due to a lack of space "
+                               f"in SR {self.uuid}")
+                    msg_body = ("Unable to perform data coalesce due to a lack "
+                                f"of space in SR {self.uuid}")
+                    msg_id = xapi_session.xenapi.message.create(
+                        'SM_GC_NO_SPACE',
+                        3,
+                        "SR",
+                        self.uuid,
+                        msg_body)
+                    xapi_session.xenapi.SR.remove_from_sm_config(
+                        self.xapi.srRef, VDI.DB_GC_NO_SPACE)
+                    xapi_session.xenapi.SR.add_to_sm_config(
+                        self.xapi.srRef, VDI.DB_GC_NO_SPACE, msg_id)
+
+                for candidate in self.no_space_candidates.values():
+                    candidate.setConfig(VDI.DB_GC_NO_SPACE, msg_id)
+            elif msg_id is not None:
+                # Everything was coalescable, remove the message
+                xapi_session.xenapi.SR.remove_from_sm_config(self.xapi.srRef, VDI.DB_GC_NO_SPACE)
+                xapi_session.xenapi.message.destroy(msg_id)
 
     def clear_no_space_msg(self, vdi):
         msg_id = None

drivers/coalesce-leaf

@@ -2,13 +2,13 @@
 #
 # Copyright (C) Citrix Systems Inc.
 #
-# This program is free software; you can redistribute it and/or modify 
-# it under the terms of the GNU Lesser General Public License as published 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
 # by the Free Software Foundation; version 2.1 only.
 #
-# This program is distributed in the hope that it will be useful, 
-# but WITHOUT ANY WARRANTY; without even the implied warranty of 
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 # GNU Lesser General Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
@@ -229,12 +229,9 @@ def main():
         print(USAGE_STRING % sys.argv[0])
         sys.exit(-1)
 
-    session = XenAPI.xapi_local()
-    session.xenapi.login_with_password('root', '', '', 'SM')
-    atexit.register(session.xenapi.session.logout)
-
-    ret, messages = vm_leaf_coalesce(session, uuid)
-    if len(messages):
+    with util.APISession("SM-coalesce-leaf") as session:
+        ret, messages = vm_leaf_coalesce(session, uuid)
+    if messages:
         print("\n".join(messages))
     sys.exit(ret)
 

drivers/lcache.py

@@ -221,12 +221,9 @@ def from_session(cls, session):
 
     @classmethod
     def from_cli(cls):
-        import XenAPI # pylint: disable=import-error
-
-        session = XenAPI.xapi_local()
-        session.xenapi.login_with_password('root', '', '', 'SM')
-
-        return cls.from_session(session)
+        import util
+        with util.APISession("SM-lcache-CacheFileSR") as session:
+            return cls.from_session(session)
 
     def statvfs(self):
         return os.statvfs(self.sr_path)

drivers/linstorcowutil.py

@@ -648,19 +648,10 @@ def clear(self):
             self.linstor = None
             self.vdi_type_to_cowutil = {}
 
-    class Load:
-        def __init__(self, session):
-            self.session = session
-
-        def cleanup(self):
-            if self.session:
-                self.session.xenapi.session.logout()
-                self.session = None
-
     def __init__(self, uri, group_name) -> None:
         self._uri = uri
         self._group_name = group_name
-        self._loads: List[MultiLinstorCowUtil.Load] = []
+        self._loads: List[util.APISession] = []
         self._executor_data = self.ExecutorData()
 
     def __del__(self):
@@ -687,8 +678,8 @@ def get_local_cowutil(self, vdi_type):
         return instance
 
     def _init_executor_thread(self):
-        session = util.get_localAPI_session()
-        load = self.Load(session)
+        apisession = util.APISession("SM-linstorvhdutil")
+        session = apisession.session
         try:
             linstor = LinstorVolumeManager(
                 self._uri,
@@ -700,15 +691,13 @@ def _init_executor_thread(self):
             self._executor_data.session = session
         except:
             self._executor_data.clear()
-            load.cleanup()
             raise
-
-        self._loads.append(load)
+        self._loads.append(apisession)
 
     def _cleanup(self):
         for load in self._loads:
             try:
-                load.cleanup()
+                load.logout()
             except Exception as e:
                 util.SMlog(f"Failed to clean load executor: {e}")
         self._loads.clear()

drivers/linstorvolumemanager.py

@@ -101,28 +101,27 @@ def get_all_volume_openers(resource_name, volume) -> LinstorVolumeOpeners:
     volume = str(volume)
     openers = {}
 
-    session = util.get_localAPI_session()
-
-    hosts = session.xenapi.host.get_all_records()
-    for host_ref, host_record in hosts.items():
-        node_name = host_record['hostname']
-        try:
-            if not session.xenapi.host_metrics.get_record(
-                host_record['metrics']
-            )['live']:
-                # Ensure we call plugin on online hosts only.
-                continue
+    with util.APISession("SM-linstorvolumemanager-get_all_volume_openers") as session:
+        hosts = session.xenapi.host.get_all_records()
+        for host_ref, host_record in hosts.items():
+            node_name = host_record['hostname']
+            try:
+                if not session.xenapi.host_metrics.get_record(
+                    host_record['metrics']
+                )['live']:
+                    # Ensure we call plugin on online hosts only.
+                    continue
 
-            openers[node_name] = json.loads(
-                session.xenapi.host.call_plugin(host_ref, PLUGIN, PLUGIN_CMD, {
-                    'resourceName': resource_name,
-                    'volume': volume
-                })
-            )
-        except Exception as e:
-            util.SMlog('Failed to get openers of `{}` on `{}`: {}'.format(
-                resource_name, node_name, e
-            ))
+                openers[node_name] = json.loads(
+                    session.xenapi.host.call_plugin(host_ref, PLUGIN, PLUGIN_CMD, {
+                        'resourceName': resource_name,
+                        'volume': volume
+                    })
+                )
+            except Exception as e:
+                util.SMlog('Failed to get openers of `{}` on `{}`: {}'.format(
+                    resource_name, node_name, e
+                ))
 
     return openers
 
@@ -191,7 +190,8 @@ def get_controller_node_name():
         if res:
             return res.groups()[0]
 
-    session = util.timeout(5, util.get_localAPI_session)
+    apisession = util.timeout(5, util.APISession, "SM-linstorvolumemanager-get_controller_node_name")
+    session = apisession.session
 
     for host_ref, host_record in session.xenapi.host.get_all_records().items():
         node_name = host_record['hostname']
@@ -214,7 +214,8 @@ def get_controller_node_name():
 def demote_drbd_resource(node_name, resource_name):
     PLUGIN_CMD = 'demoteDrbdResource'
 
-    session = util.timeout(5, util.get_localAPI_session)
+    apisession = util.timeout(5, util.APISession, "SM-linstorvolumemanager-demote_drbd_resource")
+    session = apisession.session
 
     for host_ref, host_record in session.xenapi.host.get_all_records().items():
         if host_record['hostname'] != node_name:
@@ -1417,7 +1418,8 @@ def destroy(self):
             # It needs to be done locally by each host so we go through the linstor-manager plugin.
             # If we don't do this sometimes, the destroy will fail when trying to destroy the resource groups with:
             # "linstor-manager:destroy error: Failed to destroy SP `xcp-sr-linstor_group_thin_device` on node `r620-s2`: The specified storage pool 'xcp-sr-linstor_group_thin_device' on node 'r620-s2' can not be deleted as volumes / snapshot-volumes are still using it."
-            session = util.timeout(5, util.get_localAPI_session)
+            apisession = util.timeout(5, util.APISession, "SM-linstorvolumemanager-destroy")
+            session = apisession.session
             for host_ref in session.xenapi.host.get_all():
                 try:
                     response = session.xenapi.host.call_plugin(

drivers/mpathcount.py

@@ -53,15 +53,6 @@ def get_dm_major():
     return cached_DM_maj
 
 
-def mpc_exit(session, code):
-    if session is not None:
-        try:
-            session.xenapi.session.logout()
-        except:
-            pass
-    sys.exit(code)
-
-
 def match_host_id(s):
     regex = re.compile("^INSTALLATION_UUID")
     return regex.search(s, 0)
@@ -231,9 +222,9 @@ def _run_command(command, timeout):
 
 if __name__ == '__main__':
     try:
-        session = util.get_localAPI_session()
-    except:
-        print("Unable to open local XAPI session")
+        apisession = util.APISession("SM-mpathcount")
+        session = apisession.session
+    except xs_errors.XenError:
         sys.exit(-1)
 
     localhost = session.xenapi.host.get_by_uuid(get_localhost_uuid())
@@ -252,7 +243,6 @@ def _run_command(command, timeout):
         def _remove(key):
             session.xenapi.host.remove_from_other_config(localhost, key)
 
-
         def _add(key, val):
             session.xenapi.host.add_to_other_config(localhost, key, val)
         config = session.xenapi.host.get_other_config(localhost)
@@ -261,20 +251,19 @@ def _add(key, val):
 
     except:
         util.SMlog("MPATH: Failure updating Host.other-config:mpath-boot db")
-        mpc_exit(session, -1)
+        sys.exit(-1)
 
     try:
         pbds = session.xenapi.PBD.get_all_records_where("field \"host\" = \"%s\"" % localhost)
     except:
-        mpc_exit(session, -1)
+        sys.exit(-1)
 
     try:
         mpath_status: Dict[str, str] = {}
         for pbd in pbds:
             def remove(key):
                 session.xenapi.PBD.remove_from_other_config(pbd, key)
 
-
             def add(key, val):
                 session.xenapi.PBD.add_to_other_config(pbd, key, val)
             record = pbds[pbd]
@@ -290,8 +279,8 @@ def add(key, val):
         os.chmod(MPATH_FILE_NAME, 0o0644)
     except:
         util.SMlog("MPATH: Failure updating db. %s" % str(sys.exc_info()))
-        mpc_exit(session, -1)
+        sys.exit(-1)
 
     util.SMlog("MPATH: Update done")
 
-    mpc_exit(session, 0)
+    sys.exit(0)