Try with sm-config entry

Signed-off-by: Damien Thenot <[email protected]>

Author: Nambrok

drivers/blktap2.py

@@ -1531,7 +1531,9 @@ def _add_tag(self, vdi_uuid, writable):
         self._session.xenapi.VDI.add_to_sm_config(vdi_ref, host_key,
                                                   attach_mode)
         sm_config = self._session.xenapi.VDI.get_sm_config(vdi_ref)
-        if 'paused' in sm_config or 'relinking' in sm_config:
+        if "coalesceing" in sm_config:
+            time.sleep(2) #TODO: Is it needed to ensure that the abortTest of the coalesce see the key "activating"?
+        if 'paused' in sm_config or 'relinking' in sm_config or 'coalesceing' in sm_config:
             util.SMlog("Found %s key, aborting" % (
                 'paused' if 'paused' in sm_config else 'relinking'))
             self._session.xenapi.VDI.remove_from_sm_config(vdi_ref, host_key)

drivers/cleanup.py

@@ -527,6 +527,8 @@ class VDI(object):
     ONBOOT_RESET = "reset"
     DB_ALLOW_CACHING = "allow_caching"
 
+    DB_COALESCEING = "coalesceing"
+
     CONFIG_TYPE = {
             DB_VDI_PARENT: XAPI.CONFIG_SM,
             DB_VDI_TYPE: XAPI.CONFIG_SM,
@@ -539,7 +541,8 @@ class VDI(object):
             DB_LEAFCLSC: XAPI.CONFIG_OTHER,
             DB_ONBOOT: XAPI.CONFIG_ON_BOOT,
             DB_ALLOW_CACHING: XAPI.CONFIG_ALLOW_CACHING,
-            DB_GC_NO_SPACE: XAPI.CONFIG_SM
+            DB_GC_NO_SPACE: XAPI.CONFIG_SM,
+            DB_COALESCEING: XAPI.CONFIG_SM
     }
 
     LIVE_LEAF_COALESCE_MAX_SIZE = 20 * 1024 * 1024  # bytes
@@ -838,7 +841,7 @@ def _call_plugin_coalesce(self, hostRef):
         self.sr.xapi.session.xenapi.host.call_plugin( \
                     hostRef, XAPI.PLUGIN_ON_SLAVE, "commit_tapdisk", args)
 
-    def _doCoalesceOnHost(self, hostRef):
+    def _doCoalesceOnHost(self, leaves: List["VDI"], hostRef: str):
         self.validate()
         self.parent.validate(True)
         self.parent._increaseSizeVirt(self.sizeVirt)
@@ -847,18 +850,15 @@ def _doCoalesceOnHost(self, hostRef):
         # Children and parent need to be RW for QCOW2 coalesce, otherwise tapdisk(libqcow) will crash trying to access them
 
         def abortTest():
-            file = self.sr._gc_running_file(self)
             try:
-                with open(file, "r") as f:
-                    if not f.read():
-                        #TODO: Need to call commit cancel on the hostRef if we stop
-                        self._call_plug_cancel(hostRef)
-                        return True
-            except OSError as e:
-                if e.errno == errno.ENOENT:
-                    util.SMlog("File {} does not exist".format(file))
-                else:
-                    util.SMlog("IOError: {}".format(e))
+                for leaf in leaves:
+                    if leaf.getConfig(VDI.DB_VDI_ACTIVATING, default=False):
+                        isActivating = True
+                        break
+                if isActivating:
+                    self._call_plug_cancel(hostRef)
+                    return True
+            except Exception as e: #TODO: Correct exception here
                 return True
             return False
 
@@ -879,7 +879,7 @@ def _isOpenOnHosts(self) -> Optional[str]:
                 return hostRef
         return None
 
-    def _doCoalesce(self) -> None:
+    def _doCoalesce(self, leaves=None) -> None:
         """Coalesce self onto parent. Only perform the actual coalescing of
         an image, but not the subsequent relinking. We'll do that as the next step,
         after reloading the entire SR in case things have changed while we
@@ -888,7 +888,7 @@ def _doCoalesce(self) -> None:
         self.parent.validate(True)
         self.parent._increaseSizeVirt(self.sizeVirt)
         self.sr._updateSlavesOnResize(self.parent)
-        self._coalesceCowImage(0)
+        self._coalesceCowImage(0, leaves=leaves)
         self.parent.validate(True)
         #self._verifyContents(0)
         self.parent.updateBlockInfo()
@@ -992,20 +992,19 @@ def _vdi_is_raw(self, vdi_path):
         uuid = self.extractUuid(vdi_path)
         return self.sr.vdis[uuid].vdi_type == VdiType.RAW
 
-    def _coalesceCowImage(self, timeOut):
+    def _coalesceCowImage(self, timeOut, leaves: List["VDI"] = None):
         Util.log("  Running COW coalesce on %s" % self)
         def abortTest():
             if self.cowutil.isCoalesceableOnRemote():
-                file = self.sr._gc_running_file(self)
                 try:
-                    with open(file, "r") as f:
-                        if not f.read():
+                    if leaves is not None:
+                        for leaf in leaves:
+                            if leaf.getConfig(VDI.DB_VDI_ACTIVATING, default=False):
+                                isActivating = True
+                                break
+                        if isActivating:
                             return True
-                except OSError as e:
-                    if e.errno == errno.ENOENT:
-                        util.SMlog("File {} does not exist".format(file))
-                    else:
-                        util.SMlog("IOError: {}".format(e))
+                except Exception as e: #TODO: Correct exception here
                     return True
             return IPCFlag(self.sr.uuid).test(FLAG_TYPE_ABORT)
 
@@ -1490,7 +1489,7 @@ def _setChainRo(self, was_ro: List[str]) -> None:
             self.sr.lvmCache.setReadonly(lvName, True)
 
     @override
-    def _doCoalesce(self) -> None:
+    def _doCoalesce(self, leaves=None) -> None:
         """LVMVDI parents must first be activated, inflated, and made writable"""
         try:
             self._activateChain()
@@ -1794,7 +1793,7 @@ def _setParent(self, parent) -> None:
                      (self.uuid, self.parentUuid))
 
     @override
-    def _doCoalesce(self) -> None:
+    def _doCoalesce(self, leaves=None) -> None:
         try:
             self._activateChain()
             self.parent.validate()
@@ -2448,11 +2447,18 @@ def cleanupJournals(self, dryRun=False):
     def cleanupCache(self, maxAge=-1) -> int:
         return 0
 
-    def _hasLeavesAttachedOn(self, vdi: VDI):
-        leaves = vdi.getAllLeaves()
+    def _hasLeavesAttachedOn(self, leaves: List[VDI]):
         leaves_vdi = [leaf.uuid for leaf in leaves]
         return util.get_hosts_attached_on(self.xapi.session, leaves_vdi)
 
+    def _put_coalesce_flag_on_leaves(self, leaves: List[VDI]):
+        for leaf in leaves:
+            leaf.setConfig(VDI.DB_COALESCEING, "true")
+
+    def _remove_coalesce_flag_on_leaves(self, leaves: List[VDI]):
+        for leaf in leaves:
+            leaf.delConfig(VDI.DB_COALESCEING)
+
     def _gc_running_file(self, vdi):
         run_file = "gc_running_{}".format(vdi.uuid)
         return os.path.join(NON_PERSISTENT_DIR, str(self.uuid), run_file)
@@ -2470,14 +2476,16 @@ def _coalesce(self, vdi: VDI):
             # don't expect the rest of the process to take long
 
             #TODO: Create `gc_running` in `/run/nonpersistent/sm/<sr uuid>/`
-            if os.path.exists(self._gc_running_file(vdi)):
-                util.SMlog("gc_running already exist for {}. Ignoring...".format(self.uuid))
+            # if os.path.exists(self._gc_running_file(vdi)):
+            #     util.SMlog("gc_running already exist for {}. Ignoring...".format(self.uuid))
 
-            with open(self._gc_running_file(vdi), "w") as f:
-                f.write("1")
+            # with open(self._gc_running_file(vdi), "w") as f:
+            #     f.write("1")
 
             self.journaler.create(vdi.JRN_COALESCE, vdi.uuid, "1")
-            host_refs = self._hasLeavesAttachedOn(vdi)
+            leaves = vdi.getAllLeaves()
+            self._put_coalesce_flag_on_leaves(leaves)
+            host_refs = self._hasLeavesAttachedOn(leaves)
             #TODO: this check of multiple host_refs should be done earlier in `is_coalesceable` to avoid stopping this late every time
             if len(host_refs) > 1:
                 util.SMlog("Not coalesceable, chain activated more than once")
@@ -2486,12 +2494,13 @@ def _coalesce(self, vdi: VDI):
             try:
                 if host_refs and vdi.cowutil.isCoalesceableOnRemote:
                     #Leaf opened on another host, we need to call online coalesce
-                    vdi._doCoalesceOnHost(host_refs[0])
+                    vdi._doCoalesceOnHost(leaves, host_refs[0])
                     skipRelink = True
                 else:
-                    vdi._doCoalesce()
+                    vdi._doCoalesce(leaves=leaves)
             except:
-                os.unlink(self._gc_running_file(vdi))
+                self._remove_coalesce_flag_on_leaves(leaves)
+                # os.unlink(self._gc_running_file(vdi))
                 raise
             """
             vdi._doCoalesce will call vdi._coalesceCowImage (after doing other things).
@@ -2520,7 +2529,8 @@ def _coalesce(self, vdi: VDI):
                 vdi.parent._reloadChildren(vdi)
             self.journaler.remove(vdi.JRN_RELINK, vdi.uuid)
 
-        os.unlink(self._gc_running_file(vdi))
+        # os.unlink(self._gc_running_file(vdi))
+        self._remove_coalesce_flag_on_leaves(leaves)
         self.deleteVDI(vdi)
 
     class CoalesceTracker: