Cosmetic, consistency, readability, and one better logout handling.

Reworked some APISession originator for better consistency.
Removed unuseful `session` intermediate variables.
Reworked restevdis to avoid a huge indentation caused by APISession, by using a function.
Adds a try/finally for session.logout() in util.py#sr_get_capability().

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

Author: Ythogtha

drivers/blktap2.py

@@ -882,18 +882,18 @@ def abort_linstor_gc(drbd_path: str) -> bool:
 
         openers = get_all_volume_openers(volume_name, "0")
 
-        api_session = util.timeout(5, util.APISession, "blktap-abort_linstor_gc")
-        session = api_session.session
+        api_session = util.timeout(5, util.APISession, "SM-blktap2-abort_linstor_gc")
         try:
-            srs = util.get_linstor_srs_uuid(session)
+            srs = util.get_linstor_srs_uuid(api_session.session)
             pbd_ref = util.find_pbd_ref_from_dconf_value(
-                session, srs, "group-name", group_name, LinstorVolumeManager.build_group_name
+                api_session.session, srs, "group-name", group_name,
+                LinstorVolumeManager.build_group_name,
             )
             if pbd_ref:
-                pbd_rec = session.xenapi.PBD.get_record(pbd_ref)
+                pbd_rec = api_session.session.xenapi.PBD.get_record(pbd_ref)
 
                 sr_ref = pbd_rec["SR"]
-                sr_uuid = session.xenapi.SR.get_uuid(sr_ref)
+                sr_uuid = api_session.session.xenapi.SR.get_uuid(sr_ref)
 
                 import cleanup # pylint: disable=C0415
                 if cleanup.LinstorSR.abort_gc_from_openers_sr(sr_uuid, openers):

drivers/cleanup.py

@@ -303,7 +303,7 @@ def __init__(self, session, srUuid):
         self.session = session
         self._api_session = None
         if self.session is None:
-            self._api_session = util.APISession("SM-cleanup-XAPI")
+            self._api_session = util.APISession("SM-GC")
             self.session = self._api_session.session
         self._srRef = self.session.xenapi.SR.get_by_uuid(srUuid)
         self.srRecord = self.session.xenapi.SR.get_record(self._srRef)
@@ -2121,7 +2121,7 @@ def msg_cleared(self, xapi_session, msg_ref):
         return msg is None
 
     def check_no_space_candidates(self):
-        with util.APISession("GC-check_no_space") as xapi_session:
+        with util.APISession("SM-GC-check_no_space") 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):
@@ -3928,7 +3928,7 @@ def _abort_gc_from_openers(uuid: str, is_vdi_uuid: bool, openers: "LinstorVolume
                 if node_name == hostname:
                     continue
 
-                with util.timeout(5), util.APISession("GC-coalescing") as session:
+                with util.timeout(5), util.APISession("SM-GC-coalescing") as session:
                     sr_uuid = util.get_sr_uuid_from_vdi_uuid(session, uuid) if is_vdi_uuid else uuid
                     util.SMlog(f"LINSTOR volume is coalescing on `{sr_uuid}`. We're going to interrupt the GC...")
                     return util.strtobool(session.xenapi.host.call_plugin(

drivers/linstorcowutil.py

@@ -679,7 +679,6 @@ def get_local_cowutil(self, vdi_type):
 
     def _init_executor_thread(self):
         api_session = util.APISession("SM-linstorvhdutil")
-        session = api_session.session
         try:
             linstor = LinstorVolumeManager(
                 self._uri,
@@ -688,7 +687,7 @@ def _init_executor_thread(self):
                 logger=util.SMlog
             )
             self._executor_data.linstor = linstor
-            self._executor_data.session = session
+            self._executor_data.session = api_session.session
         except:
             self._executor_data.clear()
             raise

drivers/mpathcount.py

@@ -282,6 +282,7 @@ def add(key, val):
     try:
         with util.APISession("SM-mpathcount") as api_session:
             main(api_session)
-    except xs_errors.XenError:
+    except xs_errors.XenError as e:
+        util.SMlog(f"MPATH: Failure `{e}`")
         sys.exit(-1)
     sys.exit(0)

drivers/resetvdis.py

@@ -139,43 +139,46 @@ def usage():
     sys.exit(1)
 
 
+def main(session):
+    mode = sys.argv[1]
+    if mode == "all":
+        if len(sys.argv) not in [4, 5]:
+            usage()
+        host_uuid = sys.argv[2]
+        sr_uuid = sys.argv[3]
+        is_master = False
+        if len(sys.argv) == 5:
+            if sys.argv[4] == "--master":
+                is_master = True
+            else:
+                usage()
+        reset_sr(session, host_uuid, sr_uuid, is_master)
+    elif mode == "single":
+        vdi_uuid = sys.argv[2]
+        force = False
+        if len(sys.argv) == 4 and sys.argv[3] == "--force":
+            force = True
+        reset_vdi(session, vdi_uuid, force)
+    elif len(sys.argv) in [3, 4]:
+        # backwards compatibility: the arguments for the "all" case used to be
+        # just host_uuid, sr_uuid, [is_master] (i.e., no "all" string, since it
+        # was the only mode available). To avoid having to change XAPI, accept
+        # the old format here as well.
+        host_uuid = sys.argv[1]
+        sr_uuid = sys.argv[2]
+        is_master = False
+        if len(sys.argv) == 4:
+            if sys.argv[3] == "--master":
+                is_master = True
+            else:
+                usage()
+        reset_sr(session, host_uuid, sr_uuid, is_master)
+    else:
+        usage()
+
 if __name__ == '__main__':
     if len(sys.argv) not in [3, 4, 5]:
         usage()
 
     with util.APISession("SM-resetvdis") as session:
-        mode = sys.argv[1]
-        if mode == "all":
-            if len(sys.argv) not in [4, 5]:
-                usage()
-            host_uuid = sys.argv[2]
-            sr_uuid = sys.argv[3]
-            is_master = False
-            if len(sys.argv) == 5:
-                if sys.argv[4] == "--master":
-                    is_master = True
-                else:
-                    usage()
-            reset_sr(session, host_uuid, sr_uuid, is_master)
-        elif mode == "single":
-            vdi_uuid = sys.argv[2]
-            force = False
-            if len(sys.argv) == 4 and sys.argv[3] == "--force":
-                force = True
-            reset_vdi(session, vdi_uuid, force)
-        elif len(sys.argv) in [3, 4]:
-            # backwards compatibility: the arguments for the "all" case used to be
-            # just host_uuid, sr_uuid, [is_master] (i.e., no "all" string, since it
-            # was the only mode available). To avoid having to change XAPI, accept
-            # the old format here as well.
-            host_uuid = sys.argv[1]
-            sr_uuid = sys.argv[2]
-            is_master = False
-            if len(sys.argv) == 4:
-                if sys.argv[3] == "--master":
-                    is_master = True
-                else:
-                    usage()
-            reset_sr(session, host_uuid, sr_uuid, is_master)
-        else:
-            usage()
+        main(session)

drivers/util.py

@@ -469,19 +469,21 @@ def ioretry_stat(path, maxretry=IORETRY_MAX):
 def sr_get_capability(sr_uuid, session=None):
     result = []
     api_session = None
-    if session is None:
-        api_session = APISession("SM-sr-get-capability")
-        session = api_session.session
-    sr_ref = session.xenapi.SR.get_by_uuid(sr_uuid)
-    sm_type = session.xenapi.SR.get_record(sr_ref)['type']
-    sm_rec = session.xenapi.SM.get_all_records_where(
-        "field \"type\" = \"%s\"" % sm_type)
-
-    # SM expects at least one entry of any SR type
-    if len(sm_rec) > 0:
-        result = list(sm_rec.values())[0]['capabilities']
-    if api_session:
-        session.logout()
+    try:
+        if session is None:
+            api_session = APISession("SM-sr-get-capability")
+            session = api_session.session
+        sr_ref = session.xenapi.SR.get_by_uuid(sr_uuid)
+        sm_type = session.xenapi.SR.get_record(sr_ref)['type']
+        sm_rec = session.xenapi.SM.get_all_records_where(
+            "field \"type\" = \"%s\"" % sm_type)
+
+        # SM expects at least one entry of any SR type
+        if len(sm_rec) > 0:
+            result = list(sm_rec.values())[0]['capabilities']
+    finally:
+        if api_session:
+            session.logout()
     return result
 
 def sr_get_driver_info(driver_info):