WIP: support vdi_revert on fileSR

Signed-off-by: Antoine Bartuccio <antoine.bartuccio@vates.tech>

Author: klmp200

drivers/FileSR.py

@@ -16,8 +16,9 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #
 # FileSR: local-file storage repository
+from contextlib import contextmanager
 
-from sm_typing import Dict, Optional, List, override
+from sm_typing import Dict, Optional, List, override, Tuple, Union
 
 import SR
 import VDI
@@ -41,11 +42,12 @@
 from constants import CBTLOG_TAG
 
 geneology: Dict[str, List[str]] = {}
-CAPABILITIES = ["SR_PROBE", "SR_UPDATE", \
-                "VDI_CREATE", "VDI_DELETE", "VDI_ATTACH", "VDI_DETACH", \
+CAPABILITIES = ["SR_PROBE", "SR_UPDATE",
+                "VDI_CREATE", "VDI_DELETE", "VDI_ATTACH", "VDI_DETACH",
                 "VDI_CLONE", "VDI_SNAPSHOT", "VDI_RESIZE", "VDI_MIRROR",
                 "VDI_GENERATE_CONFIG", "ATOMIC_PAUSE", "VDI_CONFIG_CBT",
-                "VDI_ACTIVATE", "VDI_DEACTIVATE", "THIN_PROVISIONING"]
+                "VDI_ACTIVATE", "VDI_DEACTIVATE", "THIN_PROVISIONING",
+                "VDI_REVERT"]
 
 CONFIGURATION = [
     ['location', 'local directory path (required)'],
@@ -68,7 +70,8 @@
 OPS_EXCLUSIVE = [
         "sr_create", "sr_delete", "sr_probe", "sr_attach", "sr_detach",
         "sr_scan", "vdi_init", "vdi_create", "vdi_delete", "vdi_attach",
-        "vdi_detach", "vdi_resize_online", "vdi_snapshot", "vdi_clone"]
+        "vdi_detach", "vdi_resize_online", "vdi_snapshot", "vdi_clone",
+        "vdi_revert"]
 
 DRIVER_CONFIG = {"ATTACH_FROM_CONFIG_WITH_TAPDISK": True}
 
@@ -447,7 +450,7 @@ class FileVDI(VDI.VDI):
             PARAM_QCOW2: VdiType.QCOW2
     }
 
-    def _find_path_with_retries(self, vdi_uuid, maxretry=5, period=2.0):
+    def _get_path_and_type(self, vdi_uuid, maxretry=5, period=2.0) -> Tuple[Optional[str], Optional[str]]:
         raw_path = os.path.join(self.sr.path, "%s.%s" % \
                                 (vdi_uuid, self.PARAM_RAW))
         vhd_path = os.path.join(self.sr.path, "%s.%s" % \
@@ -456,39 +459,43 @@ def _find_path_with_retries(self, vdi_uuid, maxretry=5, period=2.0):
                                 (vdi_uuid, self.PARAM_QCOW2))
         cbt_path = os.path.join(self.sr.path, "%s.%s" %
                                 (vdi_uuid, CBTLOG_TAG))
-        found = False
         tries = 0
-        while tries < maxretry and not found:
+        while tries < maxretry:
             tries += 1
             if util.ioretry(lambda: util.pathexists(vhd_path)):
-                self.vdi_type = VdiType.VHD
-                self.path = vhd_path
-                found = True
-            elif util.ioretry(lambda: util.pathexists(qcow2_path)):
-                self.vdi_type = VdiType.QCOW2
-                self.path = qcow2_path
-                found = True
-            elif util.ioretry(lambda: util.pathexists(raw_path)):
-                self.vdi_type = VdiType.RAW
-                self.path = raw_path
-                self.hidden = False
-                found = True
-            elif util.ioretry(lambda: util.pathexists(cbt_path)):
-                self.vdi_type = VdiType.CBTLOG
-                self.path = cbt_path
-                self.hidden = False
-                found = True
-
-            if found:
-                try:
-                    self.cowutil = getCowUtil(self.vdi_type)
-                except:
-                    pass
-            else:
-                util.SMlog("VDI %s not found, retry %s of %s" % (vdi_uuid, tries, maxretry))
-                time.sleep(period)
+                return vhd_path, VdiType.VHD
+
+            if util.ioretry(lambda: util.pathexists(qcow2_path)):
+                return qcow2_path, VdiType.QCOW2
+
+            if util.ioretry(lambda: util.pathexists(raw_path)):
+                return raw_path, VdiType.RAW
+
+            if util.ioretry(lambda: util.pathexists(cbt_path)):
+                return cbt_path, VdiType.CBTLOG
+
+            util.SMlog("VDI %s not found, retry %s of %s" % (vdi_uuid, tries, maxretry))
+            time.sleep(period)
+
+        return None, None
 
-        return found
+    def _find_path_with_retries(self, vdi_uuid, maxretry=5, period=2.0) -> bool:
+        path, vdi_type = self._get_path_and_type(vdi_uuid, maxretry, period)
+        if not path or not vdi_type:
+            return False
+
+        self.path = path
+        self.vdi_type = vdi_type
+
+        if vdi_type in [VdiType.RAW, VdiType.CBTLOG]:
+            self.hidden = False
+
+        try:
+            self.cowutil = getCowUtil(self.vdi_type)
+        except:
+            pass
+
+        return True
 
     @override
     def load(self, vdi_uuid) -> None:
@@ -739,6 +746,93 @@ def resize(self, sr_uuid, vdi_uuid, size) -> str:
     def clone(self, sr_uuid, vdi_uuid) -> str:
         return self._do_snapshot(sr_uuid, vdi_uuid, VDI.SNAPSHOT_DOUBLE)
 
+    @contextmanager
+    def _tap_pause(self, secondary=None):
+        if not blktap2.VDI.tap_pause(self.session, self.sr.uuid, self.uuid):
+            raise util.SMException(f"Could not pause disk {self.uuid} on sr {self.sr.uuid}")
+        try:
+            yield
+        finally:
+            blktap2.VDI.tap_unpause(self.session, self.sr.uuid, self.uuid, secondary)
+
+
+    @override
+    def revert(self, sr_uuid, src_uuid, dest_uuid):
+        util.SMlog("---------------------------------------------------------------->")
+        util.SMlog(f"in: {src_uuid} - {self.uuid}")
+
+        if self.label == "base copy":
+            raise xs_errors.XenError(f"{self.uuid} is a base copy.")
+
+        dest = VDI.VDI.from_uuid(self.sr.session, dest_uuid)
+        util.SMlog(f"out: {dest_uuid} - {dest.uuid}")
+
+        if self.vdi_type != dest.vdi_type:
+            raise xs_errors.XenError(f"{self.uuid} and {dest.uuid} has incompatible types {self.vdi_type} != {dest.vdi_type}")
+
+
+        if not self._checkpath(self.path):
+            raise xs_errors.XenError(f"Could not find {self.path}")
+
+        if not dest._checkpath(dest.path):
+            raise xs_errors.XenError(f"Could not find {dest.path}")
+
+        if self.parent != dest.parent:
+            raise xs_errors.XenError("Not implemented yet")
+
+        self._ensure_not_max_depth()
+
+        dest_tmp_uuid = util.gen_uuid() # Will be replaced by dest.uuid at the end
+        dest_tmp_path = os.path.join(dest.sr.path, "%s%s" % (dest_tmp_uuid, VDI_TYPE_TO_EXTENSION[dest.vdi_type]))
+
+        # snapshot = self._do_snapshot(sr_uuid, src_uuid, VDI.SNAPSHOT_SINGLE)
+        # util.SMlog(snapshot)
+        src_parent_path, _ = self._get_path_and_type(self.parent)
+        if not src_parent_path:
+            raise xs_errors.XenError(f"Could not find parent of {self.uuid}")
+
+
+        with self._tap_pause(), dest._tap_pause():
+            # try:
+            util.fistpoint.activate_custom_fn(
+                "FileSR_fail_snap1",
+                self.__fist_enospace)
+            util.ioretry(lambda: self._snap(dest_tmp_path, src_parent_path, False))
+            self.cowutil.setHidden(dest_tmp_path, True)
+
+            if self.parent != dest.parent:
+                pass # Do more operation
+
+            image_info = VdiType.isCowImage(self.vdi_type)
+            util.SMlog(f"J'ai écrittttttttttttt iciciiiiiii {dest_tmp_path}")
+            self._rename(dest_tmp_path, dest.path)
+            util.SMlog(f"J'ai renoméééééé iciciiiiiii {dest.path}")
+
+            image_info = dest.cowutil.getInfo(dest.path, FileVDI.extractUuid)
+            dest.utilisation = image_info.sizePhys
+            dest.size = image_info.sizeVirt
+            dest.hidden = False
+            dest.parent = image_info.parentUuid
+
+            dest.cowutil.setHidden(dest.path, False)
+            dest._db_update()
+
+        return dest.get_params()
+
+
+            # except util.CommandException as inst:
+            #     # TODO: cleanup
+            #     # XXX: it might be too late if the base disk has been marked as deleted!
+            #     # self._clonecleanup(src, dst, newsrc)
+            #     # util.end_log_entry(self.sr.path, self.path, ["error"])
+            #     # raise xs_errors.XenError('VDIClone',
+            #     #       opterr='VDI clone failed error %d' % inst.code)
+            #     pass
+
+        util.SMlog("<---------------------------------------------------------------")
+        raise xs_errors.XenError('Heloiastrnie')
+
+
     @override
     def compose(self, sr_uuid, vdi1, vdi2) -> None:
         if not VdiType.isCowImage(self.vdi_type):
@@ -812,6 +906,14 @@ def _create_new_parent(self, src, newsrc):
     def __fist_enospace(self):
         raise util.CommandException(28, "cowutil snapshot", reason="No space")
 
+    def _ensure_not_max_depth(self):
+        depth = self.cowutil.getDepth(self.path)
+        if depth == -1:
+            raise xs_errors.XenError('VDIUnavailable', \
+                  opterr='failed to get image depth')
+        elif depth >= self.cowutil.getMaxChainLength():
+            raise xs_errors.XenError('SnapshotChainTooLong')
+
     def _snapshot(self, snap_type, cbtlog=None, cbt_consistency=None, is_mirror_destination=False):
         util.SMlog("FileVDI._snapshot for %s (type %s)" % (self.uuid, snap_type))
 
@@ -831,12 +933,7 @@ def _snapshot(self, snap_type, cbtlog=None, cbt_consistency=None, is_mirror_dest
         if self.hidden:
             raise xs_errors.XenError('VDIClone', opterr='hidden VDI')
 
-        depth = self.cowutil.getDepth(self.path)
-        if depth == -1:
-            raise xs_errors.XenError('VDIUnavailable', \
-                  opterr='failed to get image depth')
-        elif depth >= self.cowutil.getMaxChainLength():
-            raise xs_errors.XenError('SnapshotChainTooLong')
+        self._ensure_not_max_depth()
 
         newuuid = util.gen_uuid()
         src = self.path

drivers/SRCommand.py

@@ -36,7 +36,7 @@
         "vdi_activate", "vdi_deactivate", "vdi_attach_from_config", "vdi_detach_from_config",
         "vdi_generate_config", "vdi_compose", "vdi_epoch_begin",
         "vdi_epoch_end", "vdi_enable_cbt", "vdi_disable_cbt", "vdi_data_destroy",
-        "vdi_list_changed_blocks"]
+        "vdi_list_changed_blocks", "vdi_revert"]
 
 # don't log the commands that spam the log file too much
 NO_LOGGING = {
@@ -56,7 +56,8 @@
         "vdi_resize": "VDIResize",
         "vdi_resize_online": "VDIResize",
         "vdi_snapshot": "VDISnapshot",
-        "vdi_clone": "VDIClone"
+        "vdi_clone": "VDIClone",
+        "vdi_revert": "VDIRevert",
 }
 
 
@@ -269,6 +270,13 @@ def _run(self, sr, target):
         elif self.cmd == 'vdi_clone':
             return target.clone(self.params['sr_uuid'], self.vdi_uuid)
 
+        elif self.cmd == 'vdi_revert':
+            return target.revert(
+                self.params['sr_uuid'],
+                self.vdi_uuid,
+                sr.session.xenapi.VDI.get_record(self.params['args'][0])["uuid"],
+            )
+
         elif self.cmd == 'vdi_resize':
             return target.resize(self.params['sr_uuid'], self.vdi_uuid, int(self.params['args'][0]))
 

drivers/VDI.py

@@ -249,6 +249,15 @@ def resize(self, sr_uuid, vdi_uuid, size) -> str:
         """
         raise xs_errors.XenError('Unimplemented')
 
+    def revert(self, sr_uuid, vdi_uuid, target_uuid):
+        """Replaces the contents of the target_uuid VDI with the contents of the vdi_uuid
+        without changing the identitity of the target (i.e. name-label, uuid and location
+        are guaranteed to remain the same)..
+
+        This operation IS idempotent and the vdi pointed by vdi_uuid is preserved.
+        """
+        raise xs_errors.XenError('Unimplemented')
+
     def resize_cbt(self, sr_uuid, vdi_uuid, size):
         """Resize the given VDI to size <size> MB. Size can
                 be any valid disk size greater than [or smaller than]