def make_env(self,
              storage_type,
              src_fmt,
              dst_fmt,
              chain_length=1,
              size=DEFAULT_SIZE,
              sd_version=3,
              src_qcow2_compat='0.10'):
     with fake_env(storage_type, sd_version=sd_version) as env:
         rm = FakeResourceManager()
         with MonkeyPatchScope([
             (guarded, 'context', fake_guarded_context()),
             (storage.sdm.api.copy_data, 'sdCache', env.sdcache),
             (blockVolume, 'rm', rm),
         ]):
             # Create existing volume - may use compat 0.10 or 1.1.
             src_vols = make_qemu_chain(env,
                                        size,
                                        src_fmt,
                                        chain_length,
                                        qcow2_compat=src_qcow2_compat)
             # New volumes are always created using the domain
             # prefered format.
             sd_compat = env.sd_manifest.qcow2_compat()
             dst_vols = make_qemu_chain(env,
                                        size,
                                        dst_fmt,
                                        chain_length,
                                        qcow2_compat=sd_compat)
             env.src_chain = src_vols
             env.dst_chain = dst_vols
             yield env
 def get_vols(self, storage_type, src_fmt, dst_fmt, chain_length=1):
     with fake_env(storage_type) as env:
         rm = FakeResourceManager()
         with MonkeyPatchScope([
             (storage.sdm.api.copy_data, 'sdCache', env.sdcache),
             (blockVolume, 'rmanager', rm),
         ]):
             src_vols = make_qemu_chain(env, self.SIZE, src_fmt,
                                        chain_length)
             dst_vols = make_qemu_chain(env, self.SIZE, dst_fmt,
                                        chain_length)
             yield (src_vols, dst_vols)
Beispiel #3
0
 def get_vols(self, storage_type, src_fmt, dst_fmt, chain_length=1):
     with fake_env(storage_type) as env:
         rm = FakeResourceManager()
         with MonkeyPatchScope([
             (storage.sdm.api.copy_data, 'sdCache', env.sdcache),
             (blockVolume, 'rmanager', rm),
         ]):
             src_vols = make_qemu_chain(env, self.SIZE, src_fmt,
                                        chain_length)
             dst_vols = make_qemu_chain(env, self.SIZE, dst_fmt,
                                        chain_length)
             yield (src_vols, dst_vols)
 def get_vols(self,
              storage_type,
              src_fmt,
              dst_fmt,
              chain_length=1,
              size=DEFAULT_SIZE):
     with fake_env(storage_type) as env:
         rm = FakeResourceManager()
         with MonkeyPatchScope([
             (guarded, 'context', fake_guarded_context()),
             (storage.sdm.api.copy_data, 'sdCache', env.sdcache),
             (blockVolume, 'rm', rm),
         ]):
             src_vols = make_qemu_chain(env, size, src_fmt, chain_length)
             dst_vols = make_qemu_chain(env, size, dst_fmt, chain_length)
             yield (src_vols, dst_vols)
Beispiel #5
0
 def get_vol(self, storage_type):
     with fake_env(storage_type) as env:
         with MonkeyPatchScope([
             (guarded, 'context', fake_guarded_context()),
             (storage.sdm.api.copy_data, 'sdCache', env.sdcache),
         ]):
             vols = make_qemu_chain(env, self.SIZE, sc.RAW_FORMAT, 1)
             yield vols[0]
Beispiel #6
0
    def test_pattern_written_to_base_raises(self, storage_type):
        with fake_env(storage_type) as env:
            vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 3)

            # Writes the entire pattern into the base volume
            bad_list = vol_list[:1] * 3
            write_qemu_chain(bad_list)
            self.assertRaises(ChainVerificationError,
                              verify_qemu_chain, vol_list)
Beispiel #7
0
    def test_pattern_written_to_base_raises(self, storage_type):
        with fake_env(storage_type) as env:
            vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 3)

            # Writes the entire pattern into the base volume
            bad_list = vol_list[:1] * 3
            write_qemu_chain(bad_list)
            self.assertRaises(ChainVerificationError, verify_qemu_chain,
                              vol_list)
Beispiel #8
0
 def test_make_qemu_chain(self, storage_type):
     with fake_env(storage_type) as env:
         vol_list = make_qemu_chain(env, 0, sc.RAW_FORMAT, 2)
         self.assertTrue(vol_list[0].isInternal(),
                         "Internal volume has wrong type: %s"
                         % vol_list[0].getVolType())
         self.assertTrue(vol_list[1].isLeaf(),
                         "Leaf volume has wrong type: %s"
                         % vol_list[1].getVolType())
Beispiel #9
0
 def test_make_qemu_chain(self, storage_type):
     with fake_env(storage_type) as env:
         vol_list = make_qemu_chain(env, 0, sc.RAW_FORMAT, 2)
         self.assertTrue(
             vol_list[0].isInternal(),
             "Internal volume has wrong type: %s" %
             vol_list[0].getVolType())
         self.assertTrue(
             vol_list[1].isLeaf(),
             "Leaf volume has wrong type: %s" % vol_list[1].getVolType())
Beispiel #10
0
    def test_optimal_size_cow_internal(self, actual_size, optimal_size):
        def fake_check(path, format):
            return {'offset': actual_size}

        with fake_env('block') as env:
            # In order to test edge cases, mainly of volumes with big data, we
            # fake qemuimg check to return big volumes size, instead of writing
            # big data to volumes, an operation that takes long time.
            with MonkeyPatchScope([(qemuimg, 'check', fake_check)]):
                env.chain = make_qemu_chain(env, actual_size, sc.COW_FORMAT, 3)
                self.assertEqual(env.chain[1].optimal_size(), optimal_size)
 def make_env(self, storage_type, src_fmt, dst_fmt, chain_length=1,
              size=DEFAULT_SIZE, sd_version=3, src_qcow2_compat='0.10'):
     with fake_env(storage_type, sd_version=sd_version) as env:
         rm = FakeResourceManager()
         with MonkeyPatchScope([
             (guarded, 'context', fake_guarded_context()),
             (storage.sdm.api.copy_data, 'sdCache', env.sdcache),
             (blockVolume, 'rm', rm),
         ]):
             # Create existing volume - may use compat 0.10 or 1.1.
             src_vols = make_qemu_chain(env, size, src_fmt, chain_length,
                                        qcow2_compat=src_qcow2_compat)
             # New volumes are always created using the domain
             # prefered format.
             sd_compat = env.sd_manifest.qcow2_compat()
             dst_vols = make_qemu_chain(env, size, dst_fmt, chain_length,
                                        qcow2_compat=sd_compat)
             env.src_chain = src_vols
             env.dst_chain = dst_vols
             yield env
Beispiel #12
0
    def test_optimal_size_cow_internal(self, actual_size, optimal_size):
        def fake_check(path, format):
            return {'offset': actual_size}

        with fake_env('block') as env:
            # In order to test edge cases, mainly of volumes with big data, we
            # fake qemuimg check to return big volumes size, instead of writing
            # big data to volumes, an operation that takes long time.
            with MonkeyPatchScope([(qemuimg, 'check', fake_check)]):
                env.chain = make_qemu_chain(env, actual_size, sc.COW_FORMAT, 3)
                self.assertEqual(env.chain[1].optimal_size(), optimal_size)
 def make_env(self, storage_type, fmt=sc.name2type('cow'), chain_length=1,
              size=DEFAULT_SIZE, qcow2_compat='0.10'):
     with fake_env(storage_type, sd_version=4) as env:
         rm = FakeResourceManager()
         with MonkeyPatchScope([
             (guarded, 'context', fake_guarded_context()),
             (copy_data, 'sdCache', env.sdcache),
             (blockVolume, 'rm', rm),
         ]):
             env.chain = make_qemu_chain(env, size, fmt, chain_length,
                                         qcow2_compat=qcow2_compat)
             yield env
Beispiel #14
0
 def make_volume(self, size, storage_type='block', format=sc.RAW_FORMAT):
     img_id = make_uuid()
     vol_id = make_uuid()
     # TODO fix make_volume helper to create the qcow image when needed
     with fake_env(storage_type) as env:
         if format == sc.RAW_FORMAT:
             env.make_volume(size, img_id, vol_id, vol_format=format)
             vol = env.sd_manifest.produceVolume(img_id, vol_id)
             yield vol
         else:
             chain = make_qemu_chain(env, size, format, 1)
             yield chain[0]
Beispiel #15
0
 def make_volume(self, size, storage_type='block', format=sc.RAW_FORMAT):
     img_id = make_uuid()
     vol_id = make_uuid()
     # TODO fix make_volume helper to create the qcow image when needed
     with fake_env(storage_type) as env:
         if format == sc.RAW_FORMAT:
             env.make_volume(size, img_id, vol_id, vol_format=format)
             vol = env.sd_manifest.produceVolume(img_id, vol_id)
             yield vol
         else:
             chain = make_qemu_chain(env, size, format, 1)
             yield chain[0]
Beispiel #16
0
    def make_env(self, sd_type, chain_len=2):
        size = 1048576
        base_fmt = sc.RAW_FORMAT
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope([
                (guarded, 'context', fake_guarded_context()),
                (image, 'sdCache', env.sdcache),
                (merge, 'sdCache', env.sdcache),
                (blockVolume, 'rm', rm),
                (image, 'Image', FakeImage),
            ]):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                def fake_chain(sdUUID, imgUUID, volUUID=None):
                    return env.chain
                image.Image.getChain = fake_chain

                yield env
Beispiel #17
0
 def make_env(self,
              storage_type,
              fmt=sc.name2type('cow'),
              chain_length=1,
              size=DEFAULT_SIZE,
              qcow2_compat='0.10'):
     with fake_env(storage_type, sd_version=4) as env:
         rm = FakeResourceManager()
         with MonkeyPatchScope([
             (guarded, 'context', fake_guarded_context()),
             (copy_data, 'sdCache', env.sdcache),
             (blockVolume, 'rm', rm),
         ]):
             env.chain = make_qemu_chain(env,
                                         size,
                                         fmt,
                                         chain_length,
                                         qcow2_compat=qcow2_compat)
             yield env
Beispiel #18
0
    def make_env(self, sd_type='file', format='raw', chain_len=2,
                 shared=False):
        size = 1048576
        base_fmt = sc.name2type(format)
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope([
                (guarded, 'context', fake_guarded_context()),
                (merge, 'sdCache', env.sdcache),
                (blockVolume, 'rm', rm),
            ]):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                def fake_chain(self, sdUUID, imgUUID, volUUID=None):
                    return env.chain

                image.Image.getChain = fake_chain

                yield env
Beispiel #19
0
    def make_env(self, sd_type, chain_len=2):
        size = 1048576
        base_fmt = sc.RAW_FORMAT
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope([
                (guarded, 'context', fake_guarded_context()),
                (image, 'sdCache', env.sdcache),
                (merge, 'sdCache', env.sdcache),
                (blockVolume, 'rm', rm),
                (image, 'Image', FakeImage),
            ]):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                def fake_chain(sdUUID, imgUUID, volUUID=None):
                    return env.chain

                image.Image.getChain = fake_chain

                yield env
Beispiel #20
0
    def make_env(self, sd_type="file", format="raw", chain_len=2, shared=False):
        size = 1048576
        base_fmt = sc.name2type(format)
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope(
                [
                    (guarded, "context", fake_guarded_context()),
                    (merge, "sdCache", env.sdcache),
                    (blockVolume, "rm", rm),
                    (volume.VolumeManifest, "isShared", lambda self: shared),
                ]
            ):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                def fake_chain(self, sdUUID, imgUUID, volUUID=None):
                    return env.chain

                image.Image.getChain = fake_chain

                yield env
Beispiel #21
0
    def make_env(self,
                 sd_type='file',
                 format='raw',
                 chain_len=2,
                 shared=False):
        size = 1048576
        base_fmt = sc.name2type(format)
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope([
                (guarded, 'context', fake_guarded_context()),
                (merge, 'sdCache', env.sdcache),
                (blockVolume, 'rm', rm),
            ]):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                def fake_chain(self, sdUUID, imgUUID, volUUID=None):
                    return env.chain

                image.Image.getChain = fake_chain

                yield env
Beispiel #22
0
    def make_env(self, sd_type="block", format="raw", chain_len=2):
        size = 1048576
        base_fmt = sc.name2type(format)
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope(
                [
                    (guarded, "context", fake_guarded_context()),
                    (merge, "sdCache", env.sdcache),
                    (blockVolume, "rm", rm),
                    (image, "Image", FakeImage),
                ]
            ):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                def fake_chain(self, sdUUID, imgUUID, volUUID=None):
                    return env.chain

                image.Image.getChain = fake_chain
                image.Image.syncVolumeChain = FakeSyncVolumeChain()

                yield env
Beispiel #23
0
    def make_env(self, sd_type='block', format='raw', chain_len=2):
        size = 1048576
        base_fmt = sc.name2type(format)
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope([
                (guarded, 'context', fake_guarded_context()),
                (merge, 'sdCache', env.sdcache),
                (blockVolume, 'rm', rm),
                (image, 'Image', FakeImage),
            ]):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                volumes = {(vol.imgUUID, vol.volUUID): FakeVolume()
                           for vol in env.chain}
                env.sdcache.domains[env.sd_manifest.sdUUID].volumes = volumes

                def fake_chain(self, sdUUID, imgUUID, volUUID=None):
                    return env.chain

                image.Image.getChain = fake_chain
                image.Image.syncVolumeChain = FakeSyncVolumeChain()

                yield env
Beispiel #24
0
    def make_env(self, sd_type='block', format='raw', chain_len=2):
        size = 1048576
        base_fmt = sc.name2type(format)
        with fake_env(sd_type) as env:
            rm = FakeResourceManager()
            with MonkeyPatchScope([
                (guarded, 'context', fake_guarded_context()),
                (merge, 'sdCache', env.sdcache),
                (blockVolume, 'rm', rm),
                (image, 'Image', FakeImage),
            ]):
                env.chain = make_qemu_chain(env, size, base_fmt, chain_len)

                volumes = {(vol.imgUUID, vol.volUUID): FakeVolume()
                           for vol in env.chain}
                env.sdcache.domains[env.sd_manifest.sdUUID].volumes = volumes

                def fake_chain(self, sdUUID, imgUUID, volUUID=None):
                    return env.chain

                image.Image.getChain = fake_chain
                image.Image.syncVolumeChain = FakeSyncVolumeChain()

                yield env
Beispiel #25
0
 def test_verify_chain(self, storage_type):
     with fake_env(storage_type) as env:
         vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 2)
         write_qemu_chain(vol_list)
         verify_qemu_chain(vol_list)
Beispiel #26
0
 def test_reversed_chain_raises(self, storage_type):
     with fake_env(storage_type) as env:
         vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 2)
         write_qemu_chain(reversed(vol_list))
         self.assertRaises(ChainVerificationError, verify_qemu_chain,
                           vol_list)
Beispiel #27
0
 def test_verify_chain(self, storage_type):
     with fake_env(storage_type) as env:
         vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 2)
         write_qemu_chain(vol_list)
         verify_qemu_chain(vol_list)
Beispiel #28
0
 def test_reversed_chain_raises(self, storage_type):
     with fake_env(storage_type) as env:
         vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 2)
         write_qemu_chain(reversed(vol_list))
         self.assertRaises(ChainVerificationError,
                           verify_qemu_chain, vol_list)