WIP: Half working cbt and partial rollback

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

Author: klmp200

drivers/FileSR.py

@@ -16,10 +16,12 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #
 # FileSR: local-file storage repository
+import contextlib
 from contextlib import contextmanager
 
 from sm_typing import Dict, Optional, List, override, Tuple
 
+import cbtutil
 import SR
 import VDI
 import SRCommand
@@ -768,7 +770,10 @@ def _tap_pause(self, secondary=None):
             blktap2.VDI.tap_unpause(self.session, self.sr.uuid, self.uuid, secondary)
 
     @override
-    def _do_revert(self, dest: "FileVDI", cbtlog: Optional[str] = None):
+    def _do_revert(self,
+            dest: "FileVDI", # type: ignore # self and dest are the same type
+            cbtlog: Optional[str] = None
+        ):
         # Sanity checks
         if not self._checkpath(self.path):
             raise xs_errors.XenError(f"Could not find {self.path}")
@@ -778,20 +783,29 @@ def _do_revert(self, dest: "FileVDI", cbtlog: Optional[str] = None):
 
         self._ensure_not_max_depth()
 
-        # Get first common parent
+        cbt_consistency_state = False
+        if cbtlog:
+            cbt_consistency_state = blktap2.VDI.tap_status(self.session, self.uuid)
+            util.SMlog("Saving log consistency state of %s for vdi: %s" %
+                       (cbt_consistency_state, self.uuid))
+
+        util.SMlog(f"---------------------------------------------> {self.parent}")
+        # Get downward child
         if self.parent == dest.parent:
             downward_child = None
         else:
             children = [child for child in self.sr.get_children_of(self.parent) if child != self.uuid]
             if not children:
                 downward_child = None
+            elif len(children) > 1:
+                raise xs_errors.SRException(f"Too many children for {self.parent}. Expected 1, found {len(children) + 1}")
             else:
                 downward_child = VDI.VDI.from_uuid(self.sr.session, children[0])
 
         with self._tap_pause(), dest._tap_pause():
-            self._revert(dest, downward_child, cbtlog)
+            self._revert(dest, downward_child, cbtlog, cbt_consistency_state)
 
-    def _revert(self, dest: "FileVDI", downward_child: Optional["FileVDI"], cbtlog: Optional[str]):
+    def _revert(self, dest: "FileVDI", downward_child: Optional["FileVDI"], cbtlog: Optional[str], cbt_consistency_state: bool):
         """This assumes that self and dest VDIs has been paused"""
         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]))
@@ -807,13 +821,6 @@ def update_vdi_from_file(vdi, path):
             if vdi.parent:
                 vdi.sm_config['vhd-parent'] = vdi.parent
 
-        # 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, False)
-
         if downward_child:
             # Create a new parent VDI based on src parent and attach the rest of the snapshoot tree to it
             src_parent_clone_uuid = util.gen_uuid()
@@ -824,56 +831,118 @@ def update_vdi_from_file(vdi, path):
 
             downward_child.sm_config = downward_child.session.xenapi.VDI.get_sm_config(downward_child.sr.srcmd.params['vdi_ref'])
 
-            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)
-
+            # Used both for snapshot and cleanup
             is_raw = self.VDI_TYPE == VdiType.RAW
-            self.cowutil.setParent(src_parent_clone_path, src_parent.path, is_raw)
-            self.cowutil.setParent(downward_child.path, src_parent_clone_path, is_raw)
-            self.cowutil.setParent(self.path, src_parent_clone_path, is_raw)
+            downward_child_old_parent, _ = downward_child._get_path_and_type(downward_child.parent)
+            src_old_parent = src_parent.path
+            if not downward_child_old_parent:
+                raise xs_errors.SRException(f"Error getting parent path of {downward_child.uuid}")
 
-            # Introduce new readonly vdi to db
-            src_parent_clone = VDI.VDI(self.sr, src_parent_clone_uuid)
+            try:
+                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)
 
-            # 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
+                self.cowutil.setParent(src_parent_clone_path, src_parent.path, is_raw)
+                self.cowutil.setParent(downward_child.path, src_parent_clone_path, is_raw)
+                self.cowutil.setParent(self.path, src_parent_clone_path, is_raw)
 
-            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 downward_child.sm_config:
-                src_parent_clone.sm_config['key_hash'] = downward_child.sm_config['key_hash']
-            update_vdi_from_file(src_parent_clone, src_parent_clone_uuid)
+                # Introduce new readonly vdi to db
+                src_parent_clone = FileVDI(self.sr, 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)
+                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 downward_child.sm_config:
+                    src_parent_clone.sm_config['key_hash'] = downward_child.sm_config['key_hash']
+                src_parent_clone.cbt_enabled = bool(cbtlog)
 
-            update_vdi_from_file(downward_child, downward_child.path)
+                update_vdi_from_file(src_parent_clone, src_parent_clone_uuid)
 
-            src_parent_clone._db_introduce()
+                self.sm_config = self.session.xenapi.VDI.get_sm_config(self.sr.srcmd.params['vdi_ref'])
+                update_vdi_from_file(self, self.path)
 
-            downward_child._db_update()
+                update_vdi_from_file(downward_child, downward_child.path)
 
-            self._db_update()
+                src_parent_clone._db_introduce()
 
-            self.cowutil.setHidden(src_parent_clone_path, True)
+                if cbtlog:
+                    # Set downward_child's parent as src_parent_clone
+                    downward_child_cbt_path = downward_child._get_cbt_logpath(downward_child.uuid)
+                    if util.pathexists(downward_child_cbt_path):
+                        downward_child._cbt_op(
+                            downward_child.uuid,
+                            cbtutil.set_cbt_parent,
+                            downward_child_cbt_path,
+                            src_parent_clone.uuid,
+                        )
+                    # Set self's parent as src_parent_clone
+                    self._cbt_op(
+                        self.uuid,
+                        cbtutil.set_cbt_parent,
+                        self._get_cbt_logpath(self.uuid),
+                        src_parent_clone.uuid,
+                    )
+
+                downward_child._db_update()
+
+                self._db_update()
+
+                self.cowutil.setHidden(src_parent_clone.path, True)
+            except Exception as e:
+                # Restore parents
+                util.SMlog(f"Error during revert of {self.uuid}, rolling back and cleaning up")
+                self.cowutil.setParent(downward_child.path, downward_child_old_parent, is_raw)
+                self.cowutil.setParent(self.path, src_old_parent, is_raw)
 
-        util.ioretry(lambda: self._rename(dest_tmp_path, dest.path),
-                     errlist=[errno.EIO, errno.EACCES])
+                update_vdi_from_file(downward_child, downward_child.path)
+                update_vdi_from_file(self, self.path)
+
+                util.SMlog(f"Deleting {src_parent_clone_uuid}")
+                with contextlib.suppress(Exception):
+                    src_parent_clone = FileVDI(self.sr, src_parent_clone_uuid)
+                    src_parent_clone.delete(src_parent_clone.sr, src_parent_clone.uuid)
+                if util.ioretry(lambda: util.pathexists(src_parent_clone_path)):
+                    self._unlink(src_parent_clone_path)
+
+                downward_child._db_update()
+                self._db_update()
+                raise e
+
+        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, False)
+        except Exception as e:
+            if util.ioretry(lambda: util.pathexists(dest_tmp_path)):
+                self._unlink(dest_tmp_path)
+            raise e
 
         dest.sm_config = dest.session.xenapi.VDI.get_sm_config(dest.sr.srcmd.params['vdi_ref'])
+        if cbtlog:
+            dest.cbt_enabled = True
+            try:
+                # copy self -> dest
+                # set consistency
+                # set dest as child
+                dest._cbt_snapshot(self.uuid, cbt_consistency_state) # Broken part
+            except:
+                # CBT operation failed.
+                util.end_log_entry(dest.sr.path, dest.path, ["error"])
+                raise
+
+        util.ioretry(lambda: self._rename(dest_tmp_path, dest.path),
+                     errlist=[errno.EIO, errno.EACCES])
         update_vdi_from_file(dest, dest.path)
 
         dest._db_update()
-        # except:
         #cleanup
 
     @override

drivers/VDI.py

@@ -217,7 +217,7 @@ def _do_snapshot(self, sr_uuid, vdi_uuid, snapType,
                      cloneOp=False, secondary=None, cbtlog=None, is_mirror_destination=False) -> str:
         raise xs_errors.XenError('Unimplemented')
 
-    def _do_revert(self, dest, cbtlog: Optional[str] = None) -> None:
+    def _do_revert(self, dest: "VDI", cbtlog: Optional[str] = None) -> None:
         raise xs_errors.XenError('Unimplemented')
 
     def _delete_cbt_log(self) -> None: