linbstor to squasht

Author: Wescoeur

drivers/FileSR.py

@@ -278,25 +278,32 @@ def replay(self, uuid) -> None:
         except:
             raise xs_errors.XenError('SRLog')
 
-    def _load_vdis_from_type(self, vdi_type: str) -> List[CowImageInfo]:
-        extension = VDI_TYPE_TO_EXTENSION[vdi_type]
+    def _loadvdis(self):
+        if self.vdis:
+            return
 
-        pattern = os.path.join(self.path, "*%s" % extension)
-        info: List[CowImageInfo] = []
+        self.image_info = {}
+        for vdi_type in VDI_COW_TYPES:
+            extension = VDI_TYPE_TO_EXTENSION[vdi_type]
 
-        cowutil = getCowUtil(vdi_type)
-        try:
-            info = cowutil.getAllInfoFromVG(pattern, FileVDI.extractUuid)
-        except util.CommandException as inst:
-            raise xs_errors.XenError('SRScan', opterr="error VDI-scanning " \
-                    "path %s (%s)" % (self.path, inst))
-        try:
-            vdi_uuids = [FileVDI.extractUuid(v) for v in util.ioretry(lambda: glob.glob(pattern))]
-            if len(info) != len(vdi_uuids):
-                util.SMlog("VDI scan of %s returns %d VDIs: %s" % (extension, len(info), sorted(info)))
-                util.SMlog("VDI list of %s returns %d VDIs: %s" % (extension, len(vdi_uuids), sorted(vdi_uuids)))
-        except:
-            pass
+            pattern = os.path.join(self.path, "*%s" % extension)
+            info = {}
+
+            cowutil = getCowUtil(vdi_type)
+            try:
+                info = cowutil.getAllInfoFromVG(pattern, FileVDI.extractUuid)
+            except util.CommandException as inst:
+                raise xs_errors.XenError('SRScan', opterr="error VDI-scanning " \
+                        "path %s (%s)" % (self.path, inst))
+            try:
+                vdi_uuids = [FileVDI.extractUuid(v) for v in util.ioretry(lambda: glob.glob(pattern))]
+                if len(info) != len(vdi_uuids):
+                    util.SMlog("VDI scan of %s returns %d VDIs: %s" % (extension, len(info), sorted(info)))
+                    util.SMlog("VDI list of %s returns %d VDIs: %s" % (extension, len(vdi_uuids), sorted(vdi_uuids)))
+            except:
+                pass
+
+            self.image_info.update(info)
 
         for uuid in info.keys():
             if info[uuid].error:
@@ -311,16 +318,6 @@ def _load_vdis_from_type(self, vdi_type: str) -> List[CowImageInfo]:
             key_hash = cowutil.getKeyHash(vdi_path)
             self.vdis[uuid].sm_config_override['key_hash'] = key_hash
 
-        return info
-
-    def _loadvdis(self):
-        if self.vdis:
-            return
-
-        self.image_info = {}
-        for vdi_type in VDI_COW_TYPES:
-            self.image_info.update(self._load_vdis_from_type(vdi_type))
-
         # raw VDIs and CBT log files
         files = util.ioretry(lambda: util.listdir(self.path))
         for fn in files:
@@ -499,7 +496,6 @@ def load(self, vdi_uuid) -> None:
         self.sr.srcmd.params['o_direct'] = self.sr.o_direct
 
         if self.sr.srcmd.cmd == "vdi_create":
-            self.vdi_type = getVdiTypeFromImageFormat(self.sr.preferred_image_formats[0])
             self.key_hash = None
             if "vdi_sm_config" in self.sr.srcmd.params:
                 if "key_hash" in self.sr.srcmd.params["vdi_sm_config"]:
@@ -511,6 +507,10 @@ def load(self, vdi_uuid) -> None:
                         raise xs_errors.XenError('VDIType',
                                 opterr='Invalid VDI type %s' % vdi_type)
                     self.vdi_type = self.VDI_TYPE[vdi_type]
+
+            if not self.vdi_type:
+                self.vdi_type = getVdiTypeFromImageFormat(self.sr.preferred_image_formats[0])
+            self.cowutil = getCowUtil(self.vdi_type)
             self.path = os.path.join(self.sr.path, "%s%s" %
                 (vdi_uuid, VDI_TYPE_TO_EXTENSION[self.vdi_type]))
         else:
@@ -609,7 +609,6 @@ def create(self, sr_uuid, vdi_uuid, size) -> str:
         if util.ioretry(lambda: util.pathexists(self.path)):
             raise xs_errors.XenError('VDIExists')
 
-        self.cowutil = getCowUtil(self.vdi_type)
         if VdiType.isCowImage(self.vdi_type):
             try:
                 size = self.cowutil.validateAndRoundImageSize(int(size))
@@ -815,9 +814,10 @@ def _snapshot(self, snap_type, cbtlog=None, cbt_consistency=None):
 
         dest = None
         dst = None
+        extension = VDI_TYPE_TO_EXTENSION[self.vdi_type]
         if snap_type == VDI.SNAPSHOT_DOUBLE:
             dest = util.gen_uuid()
-            dst = os.path.join(self.sr.path, "%s.%s" % (dest, self.vdi_type))
+            dst = os.path.join(self.sr.path, "%s.%s" % (dest, extension))
             args.append(dest)
 
         if self.hidden:
@@ -832,8 +832,8 @@ def _snapshot(self, snap_type, cbtlog=None, cbt_consistency=None):
 
         newuuid = util.gen_uuid()
         src = self.path
-        newsrc = os.path.join(self.sr.path, "%s%s" % (newuuid, VDI_TYPE_TO_EXTENSION[self.vdi_type]))
-        newsrcname = "%s.%s" % (newuuid, self.vdi_type)
+        newsrc = os.path.join(self.sr.path, "%s%s" % (newuuid, extension))
+        newsrcname = "%s.%s" % (newuuid, extension)
 
         if not self._checkpath(src):
             raise xs_errors.XenError('VDIUnavailable', \
@@ -881,8 +881,8 @@ def _snapshot(self, snap_type, cbtlog=None, cbt_consistency=None):
                         dstparent != newuuid):
                     util.ioretry(lambda: self._unlink(newsrc))
                     introduce_parent = False
-            except:
-                pass
+            except Exception as e:
+                raise
 
             # Introduce the new VDI records
             leaf_vdi = None

drivers/LVMSR.py

@@ -40,7 +40,7 @@
 from refcounter import RefCounter
 from ipc import IPCFlag
 from constants import NS_PREFIX_LVM, VG_LOCATION, VG_PREFIX
-from cowutil import getCowUtil, getVdiTypeFromImageFormat
+from cowutil import CowUtil, getCowUtil, getVdiTypeFromImageFormat
 from lvmcowutil import LV_PREFIX, LvmCowUtil
 from lvmanager import LVActivator
 from vditype import VdiType

drivers/LinstorSR.py

@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-from sm_typing import Optional, override
+from sm_typing import Any, Optional, override
 
 from constants import CBTLOG_TAG
 
@@ -381,6 +381,17 @@ def load(self, sr_uuid) -> None:
         self._linstor = None  # Ensure that LINSTOR attribute exists.
         self._journaler = None
 
+        # Used to handle reconnect calls on LINSTOR object attached to the SR.
+        class LinstorProxy:
+            def __init__(self, sr: LinstorSR) -> None:
+                self.sr = sr
+
+            def __getattr__(self, attr: str) -> Any:
+                assert self.sr, "Cannot use `LinstorProxy` without valid `LinstorVolumeManager` instance"
+                return getattr(self.sr._linstor, attr)
+
+        self._linstor_proxy = LinstorProxy(self)
+
         self._group_name = self.dconf['group-name']
 
         self._vdi_shared_time = 0
@@ -1151,7 +1162,7 @@ def _load_vdis_ex(self):
                 if not VdiType.isCowImage(vdi_type):
                     managed = not volume_metadata.get(HIDDEN_TAG)
                 else:
-                    image_info = self.cowutil.get_info(vdi_uuid)
+                    image_info = LinstorCowUtil(self.session, self._linstor, getCowUtil(vdi_type)).get_info(vdi_uuid)
                     managed = not image_info.hidden
                     if image_info.parentUuid:
                         sm_config['vhd-parent'] = image_info.parentUuid
@@ -1207,7 +1218,7 @@ def _load_vdis_ex(self):
                 # TODO: Replace pylint comment with this feature when possible:
                 # https://github.com/PyCQA/pylint/pull/2926
                 vdi.sm_config_override['key_hash'] = \
-                    self._vhdutil.get_key_hash(vdi_uuid)  # pylint: disable = E1120
+                    vdi.linstorcowutil.get_key_hash(vdi_uuid)  # pylint: disable = E1120
 
             # 4.c. Update CBT status of disks either just added
             # or already in XAPI.
@@ -1292,12 +1303,13 @@ def _get_vdi_path_and_parent(self, vdi_uuid, volume_name):
                 return (device_path, None)
 
             # Otherwise it's a COW and a parent can exist.
-            if self._cowutil.check(vdi_uuid) != cowutil.CheckResult.Success:
+            linstorcowutil = LinstorCowUtil(self.session, self._linstor, getCowUtil(vdi_type))
+            if linstorcowutil.check(vdi_uuid) != cowutil.CheckResult.Success:
                 return (None, None)
 
-            vhd_info = self._vhdutil.get_vhd_info(vdi_uuid)
-            if vhd_info:
-                return (device_path, vhd_info.parentUuid)
+            image_info = linstorcowutil.get_info(vdi_uuid)
+            if image_info:
+                return (device_path, image_info.parentUuid)
         except Exception as e:
             util.SMlog(
                 'Failed to get VDI path and parent, ignoring: {}'
@@ -1654,7 +1666,7 @@ def create(self, sr_uuid, vdi_uuid, size) -> str:
         assert self.vdi_type
 
         # 2. Compute size and check space available.
-        size = self.cowutil.validateAndRoundImageSize(int(size))
+        size = self.linstorcowutil.cowutil.validateAndRoundImageSize(int(size))
         volume_size = self.linstorcowutil.compute_volume_size(size, self.vdi_type)
         util.SMlog(
             'LinstorVDI.create: type={}, cow-size={}, volume-size={}'
@@ -1685,18 +1697,16 @@ def create(self, sr_uuid, vdi_uuid, size) -> str:
 
             self._update_device_name(volume_info.name)
 
-            self.cowutil = None # TODO
-
             if not VdiType.isCowImage(self.vdi_type):
                 self.size = volume_info.virtual_size
             else:
-                self.cowutil.create(
-                    self.path, size, False, self.cowutil.getDefaultPreallocationSizeVirt()
+                self.linstorcowutil.create(
+                    self.path, size, False, self.linstorcowutil.cowutil.getDefaultPreallocationSizeVirt()
                 )
-                self.size = self.cowutil.get_size_virt(self.uuid)
+                self.size = self.linstorcowutil.get_size_virt(self.uuid)
 
             if self._key_hash:
-                self.cowutil.set_key(self.path, self._key_hash)
+                self.linstorcowutil.set_key(self.path, self._key_hash)
 
             # Because cowutil commands modify the volume data,
             # we must retrieve a new time the utilization size.
@@ -1902,7 +1912,7 @@ def detach(self, sr_uuid, vdi_uuid) -> None:
         while vdi_uuid:
             try:
                 path = self._linstor.build_device_path(self._linstor.get_volume_name(vdi_uuid))
-                parent_vdi_uuid = self.sr.cowutil.get_info(vdi_uuid).parentUuid
+                parent_vdi_uuid = self.sr.linstorcowutil.get_info(vdi_uuid).parentUuid
             except Exception:
                 break
 
@@ -1928,7 +1938,7 @@ def resize(self, sr_uuid, vdi_uuid, size) -> str:
             raise xs_errors.XenError('VDIUnavailable', opterr='hidden VDI')
 
         # Compute the virtual COW and DRBD volume size.
-        size = self.cowutil.validateAndRoundImageSize(int(size))
+        size = self.linstorcowutil.cowutil.validateAndRoundImageSize(int(size))
         volume_size = self.linstorcowutil.compute_volume_size(size, self.vdi_type)
         util.SMlog(
             'LinstorVDI.resize: type={}, cow-size={}, volume-size={}'
@@ -2003,8 +2013,8 @@ def compose(self, sr_uuid, vdi1, vdi2) -> None:
         if not blktap2.VDI.tap_pause(self.session, self.sr.uuid, self.uuid):
             raise util.SMException('Failed to pause VDI {}'.format(self.uuid))
         try:
-            self.sr.cowutil.set_parent(self.path, parent_path, False)
-            self.sr.cowutil.set_hidden(parent_path)
+            self.sr.linstorcowutil.set_parent(self.path, parent_path, False)
+            self.sr.linstorcowutil.set_hidden(parent_path)
             self.sr.session.xenapi.VDI.set_managed(
                 self.sr.srcmd.params['args'][0], False
             )
@@ -2128,7 +2138,7 @@ def _load_this(self):
             self.size = volume_info.virtual_size
             self.parent = ''
         else:
-            image_info = self.sr.cowutil.get_info(self.uuid)
+            image_info = self.sr.linstorcowutil.get_info(self.uuid)
             self.hidden = image_info.hidden
             self.size = image_info.sizeVirt
             self.parent = image_info.parentUuid
@@ -2227,6 +2237,10 @@ def _prepare_thin(self, attach):
     # Generic helpers.
     # --------------------------------------------------------------------------
 
+    def _set_type(self, vdi_type: str) -> None:
+        self.vdi_type = vdi_type
+        self.linstorcowutil = LinstorCowUtil(self.session, self.sr._linstor_proxy, self.vdi_type)
+
     def _determine_type_and_path(self):
         """
         Determine whether this is a RAW or a COW VDI.
@@ -2281,12 +2295,12 @@ def _create_snapshot(self, snap_vdi_type, snap_uuid, snap_of_uuid=None):
 
         # 2. Write the snapshot content.
         is_raw = (self.vdi_type == VdiType.RAW)
-        self.cowutil.snapshot(
+        self.linstorcowutil.snapshot(
             snap_path, self.path, is_raw, max(self.size, cowutil.getDefaultPreallocationSizeVirt())
         )
 
         # 3. Get snapshot parent.
-        snap_parent = self.cowutil.get_parent(snap_uuid)
+        snap_parent = self.linstorcowutil.get_parent(snap_uuid)
 
         # 4. Update metadata.
         util.SMlog('Set VDI {} metadata of snapshot'.format(snap_uuid))
@@ -2381,7 +2395,7 @@ def _snapshot(self, snap_type, cbtlog=None, cbt_consistency=None):
                 'VDIUnavailable',
                 opterr='failed to get COW depth'
             )
-        elif depth >= self._cowutil.getMaxChainLength():
+        elif depth >= self.linstorcowutil.cowutil.getMaxChainLength():
             raise xs_errors.XenError('SnapshotChainTooLong')
 
         # Ensure we have a valid path if we don't have a local diskful.