WIP: one directional vdi revert

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

Author: klmp200

drivers/FileSR.py

@@ -18,7 +18,7 @@
 # FileSR: local-file storage repository
 from contextlib import contextmanager
 
-from sm_typing import Dict, Optional, List, override, Tuple, Union
+from sm_typing import Dict, Optional, List, override, Tuple
 
 import SR
 import VDI
@@ -777,44 +777,111 @@ def revert(self, sr_uuid, src_uuid, dest_uuid):
         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")
+        def get_child_of(start: FileVDI, parent_uuid: str) -> Optional[str]:
+            util.SMlog(f"Looking for common parent: {parent_uuid}")
+            current = start.uuid
+            while current is not None:
+                path, _ = start._get_path_and_type(current)
+                util.SMlog(f"Testing path {path}")
+                if not path:
+                    return None
+
+                parent = start.cowutil.getParent(path, FileVDI.extractUuid)
+                util.SMlog(f"Testing {parent} == {parent_uuid}")
+                if parent == parent_uuid:
+                    util.SMlog(f"Found {current} with next parent {parent}")
+                    return current
+                current = parent
+
+            return None
+
+        common_parent_uuid = get_child_of(dest, self.parent)
+        if not common_parent_uuid:
+            raise xs_errors.XenError(f"{self.uuid} and {dest.uuid} aren't on the same snapshot tree")
 
         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}")
+        src_parent = VDI.VDI.from_uuid(self.sr.session, self.parent)
 
+        def update_vdi_from_file(vdi: FileVDI, path: str):
+            image_info = vdi.cowutil.getInfo(vdi.path, FileVDI.extractUuid)
+            vdi.utilisation = image_info.sizePhys
+            vdi.size = image_info.sizeVirt
+            vdi.parent = image_info.parentUuid
+            vdi.hidden = image_info.hidden
+            if vdi.parent:
+                vdi.sm_config['vhd-parent'] = vdi.parent
 
         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)
+            util.ioretry(lambda: self._snap(dest_tmp_path, src_parent.path, False))
+            self.cowutil.setHidden(dest_tmp_path, False)
+
+            if common_parent_uuid != dest.parent:
+                # Create a new parent VDI based on src parent
+                src_parent_clone_uuid = util.gen_uuid()
+                src_parent_clone_path = os.path.join(
+                    dest.sr.path,
+                    "%s%s" % (src_parent_clone_uuid, VDI_TYPE_TO_EXTENSION[dest.vdi_type])
+                )
 
-            if self.parent != dest.parent:
-                pass # Do more operation
+                common_parent = VDI.VDI.from_uuid(self.sr.session, common_parent_uuid)
+                common_parent.sm_config = common_parent.session.xenapi.VDI.get_sm_config(common_parent.sr.srcmd.params['vdi_ref'])
 
-            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}")
+                util.fistpoint.activate_custom_fn(
+                    "FileSR_fail_snap2",
+                    self.__fist_enospace)
+                util.ioretry(lambda: self._snap(src_parent_clone_path, src_parent.path, False))
+                self.cowutil.setHidden(src_parent_clone_path, False)
+
+                is_raw = self.VDI_TYPE == VdiType.RAW
+                self.cowutil.setParent(src_parent_clone_path, src_parent.path, is_raw)
+                self.cowutil.setParent(common_parent.path, src_parent_clone_path, is_raw)
+                self.cowutil.setParent(self.path, src_parent_clone_path, is_raw)
+
+                # Introduce new readonly vdi to db
+                src_parent_clone = VDI.VDI(self.sr, src_parent_clone_uuid)
+
+                # FileVDI emulation for update_vdi_from_file
+                src_parent_clone.path = src_parent_clone_path
+                src_parent_clone.parent = src_parent.uuid
+                src_parent_clone.cowutil = self.cowutil
+
+                src_parent_clone.label = "base copy"
+                src_parent_clone.read_only = True
+                src_parent_clone.location = src_parent_clone_uuid
+                src_parent_clone.sm_config = {}
+                # TODO: fix the raw snapshot case 
+                src_parent_clone.sm_config["image-format"] = getImageStringFromVdiType(self.vdi_type)
+                if "key_hash" in common_parent.sm_config:
+                    src_parent_clone.sm_config['key_hash'] = common_parent.sm_config['key_hash']
+                update_vdi_from_file(src_parent_clone, src_parent_clone_uuid)
+
+                self.sm_config = self.session.xenapi.VDI.get_sm_config(self.sr.srcmd.params['vdi_ref'])
+                update_vdi_from_file(self, self.path)
+
+                update_vdi_from_file(common_parent, common_parent.path)
+
+                src_parent_clone._db_introduce()
+
+                common_parent._db_update()
+
+                self._db_update()
+
+                self.cowutil.setHidden(src_parent_clone_path, True)
+
+            util.ioretry(lambda: self._rename(dest_tmp_path, dest.path),
+                         errlist=[errno.EIO, errno.EACCES])
 
-            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.sm_config = dest.session.xenapi.VDI.get_sm_config(dest.sr.srcmd.params['vdi_ref'])
+            update_vdi_from_file(dest, dest.path)
 
-            dest.cowutil.setHidden(dest.path, False)
             dest._db_update()
 
         return dest.get_params()