|
@@ -24,15 +24,15 @@
|
|
|
'volume_group/thin_pool' combination. Pool variables without a prefix
|
|
|
represent a :py:class:`qubes.storage.lvm.ThinPool`.
|
|
|
'''
|
|
|
-
|
|
|
import os
|
|
|
import subprocess
|
|
|
import tempfile
|
|
|
import unittest
|
|
|
+import unittest.mock
|
|
|
|
|
|
import qubes.tests
|
|
|
import qubes.storage
|
|
|
-from qubes.storage.lvm import ThinPool, ThinVolume
|
|
|
+from qubes.storage.lvm import ThinPool, ThinVolume, qubes_lvm
|
|
|
|
|
|
if 'DEFAULT_LVM_POOL' in os.environ.keys():
|
|
|
DEFAULT_LVM_POOL = os.environ['DEFAULT_LVM_POOL']
|
|
@@ -84,7 +84,7 @@ class ThinPoolBase(qubes.tests.QubesTestCase):
|
|
|
''' Returns the pool matching the specified ``volume_group`` &
|
|
|
``thin_pool``, or None.
|
|
|
'''
|
|
|
- pools = [p for p in self.app.pools
|
|
|
+ pools = [p for p in self.app.pools.values()
|
|
|
if issubclass(p.__class__, ThinPool)]
|
|
|
for pool in pools:
|
|
|
if pool.volume_group == volume_group \
|
|
@@ -138,7 +138,7 @@ class TC_00_ThinPool(ThinPoolBase):
|
|
|
self.assertEqual(volume.size, qubes.config.defaults['root_img_size'])
|
|
|
volume.create()
|
|
|
path = "/dev/%s" % volume.vid
|
|
|
- self.assertTrue(os.path.exists(path))
|
|
|
+ self.assertTrue(os.path.exists(path), path)
|
|
|
volume.remove()
|
|
|
|
|
|
def test_003_read_write_volume(self):
|
|
@@ -158,7 +158,7 @@ class TC_00_ThinPool(ThinPoolBase):
|
|
|
self.assertEqual(volume.size, qubes.config.defaults['root_img_size'])
|
|
|
volume.create()
|
|
|
path = "/dev/%s" % volume.vid
|
|
|
- self.assertTrue(os.path.exists(path))
|
|
|
+ self.assertTrue(os.path.exists(path), path)
|
|
|
volume.remove()
|
|
|
|
|
|
def test_004_size(self):
|
|
@@ -240,6 +240,697 @@ class TC_00_ThinPool(ThinPoolBase):
|
|
|
self.assertEqual(self._get_size(path), new_size)
|
|
|
self.assertEqual(volume.size, new_size)
|
|
|
|
|
|
+ def _get_lv_uuid(self, lv):
|
|
|
+ sudo = [] if os.getuid() == 0 else ['sudo']
|
|
|
+ lvs_output = subprocess.check_output(
|
|
|
+ sudo + ['lvs', '--noheadings', '-o', 'lv_uuid', lv])
|
|
|
+ return lvs_output.strip()
|
|
|
+
|
|
|
+ def _get_lv_origin_uuid(self, lv):
|
|
|
+ sudo = [] if os.getuid() == 0 else ['sudo']
|
|
|
+ if qubes.storage.lvm.lvm_is_very_old:
|
|
|
+ # no support for origin_uuid directly
|
|
|
+ lvs_output = subprocess.check_output(
|
|
|
+ sudo + ['lvs', '--noheadings', '-o', 'origin', lv])
|
|
|
+ lvs_output = subprocess.check_output(
|
|
|
+ sudo + ['lvs', '--noheadings', '-o', 'lv_uuid',
|
|
|
+ lv.rsplit('/', 1)[0] + '/' + lvs_output.strip().decode()])
|
|
|
+ else:
|
|
|
+ lvs_output = subprocess.check_output(
|
|
|
+ sudo + ['lvs', '--noheadings', '-o', 'origin_uuid', lv])
|
|
|
+ return lvs_output.strip()
|
|
|
+
|
|
|
+ def test_008_commit(self):
|
|
|
+ ''' Test volume changes commit'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume.create()
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+ origin_uuid = self._get_lv_uuid(volume.path)
|
|
|
+ volume.start()
|
|
|
+ snap_uuid = self._get_lv_uuid(path_snap)
|
|
|
+ self.assertNotEqual(origin_uuid, snap_uuid)
|
|
|
+ path = volume.path
|
|
|
+ self.assertTrue(path.startswith('/dev/' + volume.vid),
|
|
|
+ '{} does not start with /dev/{}'.format(path, volume.vid))
|
|
|
+ self.assertTrue(os.path.exists(path), path)
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_009_interrupted_commit(self):
|
|
|
+ ''' Test volume changes commit'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ # mock logging, to not interfere with time.time() mock
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ # do not call volume.create(), do it manually to simulate
|
|
|
+ # interrupted commit
|
|
|
+ revisions = ['-1521065904-back', '-1521065905-back', '-snap']
|
|
|
+ orig_uuids = {}
|
|
|
+ for rev in revisions:
|
|
|
+ cmd = ['create', self.pool._pool_id,
|
|
|
+ volume.vid.split('/')[1] + rev, str(config['size'])]
|
|
|
+ qubes_lvm(cmd)
|
|
|
+ orig_uuids[rev] = self._get_lv_uuid(volume.vid + rev)
|
|
|
+ qubes.storage.lvm.reset_cache()
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertTrue(volume.is_dirty())
|
|
|
+ self.assertEqual(volume.path,
|
|
|
+ '/dev/' + volume.vid + revisions[1])
|
|
|
+ expected_revisions = {
|
|
|
+ revisions[0].lstrip('-'): '2018-03-14T22:18:24',
|
|
|
+ revisions[1].lstrip('-'): '2018-03-14T22:18:25',
|
|
|
+ }
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ volume.start()
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ snap_uuid = self._get_lv_uuid(path_snap)
|
|
|
+ self.assertEqual(orig_uuids['-snap'], snap_uuid)
|
|
|
+ self.assertTrue(volume.is_dirty())
|
|
|
+ self.assertEqual(volume.path,
|
|
|
+ '/dev/' + volume.vid + revisions[1])
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = [521065906]
|
|
|
+ volume.stop()
|
|
|
+ expected_revisions = {
|
|
|
+ revisions[0].lstrip('-'): '2018-03-14T22:18:24',
|
|
|
+ revisions[1].lstrip('-'): '2018-03-14T22:18:25',
|
|
|
+ }
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+ self.assertEqual(snap_uuid, self._get_lv_uuid(volume.path))
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_010_migration1(self):
|
|
|
+ '''Start with old revisions, then start interacting using new code'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ # mock logging, to not interfere with time.time() mock
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ # do not call volume.create(), do it manually to have old LV naming
|
|
|
+ revisions = ['', '-1521065904-back', '-1521065905-back']
|
|
|
+ orig_uuids = {}
|
|
|
+ for rev in revisions:
|
|
|
+ cmd = ['create', self.pool._pool_id,
|
|
|
+ volume.vid.split('/')[1] + rev, str(config['size'])]
|
|
|
+ qubes_lvm(cmd)
|
|
|
+ orig_uuids[rev] = self._get_lv_uuid(volume.vid + rev)
|
|
|
+ qubes.storage.lvm.reset_cache()
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+ expected_revisions = {
|
|
|
+ revisions[1].lstrip('-'): '2018-03-14T22:18:24',
|
|
|
+ revisions[2].lstrip('-'): '2018-03-14T22:18:25',
|
|
|
+ }
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+
|
|
|
+ volume.start()
|
|
|
+ snap_uuid = self._get_lv_uuid(path_snap)
|
|
|
+ self.assertNotEqual(orig_uuids[''], snap_uuid)
|
|
|
+ snap_origin_uuid = self._get_lv_origin_uuid(path_snap)
|
|
|
+ self.assertEqual(orig_uuids[''], snap_origin_uuid)
|
|
|
+ path = volume.path
|
|
|
+ self.assertEqual(path, '/dev/' + volume.vid)
|
|
|
+ self.assertTrue(os.path.exists(path), path)
|
|
|
+
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = ('1521065906', '1521065907')
|
|
|
+ volume.stop()
|
|
|
+ revisions.extend(['-1521065906-back'])
|
|
|
+ expected_revisions = {
|
|
|
+ revisions[2].lstrip('-'): '2018-03-14T22:18:25',
|
|
|
+ revisions[3].lstrip('-'): '2018-03-14T22:18:26',
|
|
|
+ }
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+ self.assertTrue(os.path.exists('/dev/' + volume.vid))
|
|
|
+ self.assertEqual(self._get_lv_uuid(volume.path), snap_uuid)
|
|
|
+ prev_path = '/dev/' + volume.vid + revisions[3]
|
|
|
+ self.assertEqual(self._get_lv_uuid(prev_path), orig_uuids[''])
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+ for rev in revisions:
|
|
|
+ path = '/dev/' + volume.vid + rev
|
|
|
+ self.assertFalse(os.path.exists(path), path)
|
|
|
+
|
|
|
+ def test_011_migration2(self):
|
|
|
+ '''VM started with old code, stopped with new'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 1,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ # mock logging, to not interfere with time.time() mock
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ # do not call volume.create(), do it manually to have old LV naming
|
|
|
+ revisions = ['', '-snap']
|
|
|
+ orig_uuids = {}
|
|
|
+ for rev in revisions:
|
|
|
+ cmd = ['create', self.pool._pool_id,
|
|
|
+ volume.vid.split('/')[1] + rev, str(config['size'])]
|
|
|
+ qubes_lvm(cmd)
|
|
|
+ orig_uuids[rev] = self._get_lv_uuid(volume.vid + rev)
|
|
|
+ qubes.storage.lvm.reset_cache()
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertTrue(os.path.exists(path_snap), path_snap)
|
|
|
+ expected_revisions = {}
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+ self.assertTrue(volume.is_dirty())
|
|
|
+
|
|
|
+ path = volume.path
|
|
|
+ self.assertEqual(path, '/dev/' + volume.vid)
|
|
|
+ self.assertTrue(os.path.exists(path), path)
|
|
|
+
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = ('1521065906', '1521065907')
|
|
|
+ volume.stop()
|
|
|
+ revisions.extend(['-1521065906-back'])
|
|
|
+ expected_revisions = {
|
|
|
+ revisions[2].lstrip('-'): '2018-03-14T22:18:26',
|
|
|
+ }
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+ self.assertTrue(os.path.exists('/dev/' + volume.vid))
|
|
|
+ self.assertEqual(self._get_lv_uuid(volume.path), orig_uuids['-snap'])
|
|
|
+ prev_path = '/dev/' + volume.vid + revisions[2]
|
|
|
+ self.assertEqual(self._get_lv_uuid(prev_path), orig_uuids[''])
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+ for rev in revisions:
|
|
|
+ path = '/dev/' + volume.vid + rev
|
|
|
+ self.assertFalse(os.path.exists(path), path)
|
|
|
+
|
|
|
+ def test_012_migration3(self):
|
|
|
+ '''VM started with old code, started again with new, stopped with new'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 1,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ # mock logging, to not interfere with time.time() mock
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ # do not call volume.create(), do it manually to have old LV naming
|
|
|
+ revisions = ['', '-snap']
|
|
|
+ orig_uuids = {}
|
|
|
+ for rev in revisions:
|
|
|
+ cmd = ['create', self.pool._pool_id,
|
|
|
+ volume.vid.split('/')[1] + rev, str(config['size'])]
|
|
|
+ qubes_lvm(cmd)
|
|
|
+ orig_uuids[rev] = self._get_lv_uuid(volume.vid + rev)
|
|
|
+ qubes.storage.lvm.reset_cache()
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertTrue(os.path.exists(path_snap), path_snap)
|
|
|
+ expected_revisions = {}
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertTrue(volume.path, '/dev/' + volume.vid)
|
|
|
+ self.assertTrue(volume.is_dirty())
|
|
|
+
|
|
|
+ volume.start()
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+ # -snap LV should be unchanged
|
|
|
+ self.assertEqual(self._get_lv_uuid(volume._vid_snap),
|
|
|
+ orig_uuids['-snap'])
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+ for rev in revisions:
|
|
|
+ path = '/dev/' + volume.vid + rev
|
|
|
+ self.assertFalse(os.path.exists(path), path)
|
|
|
+
|
|
|
+ def test_013_migration4(self):
|
|
|
+ '''revisions_to_keep=0, VM started with old code, stopped with new'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 0,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ # mock logging, to not interfere with time.time() mock
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ # do not call volume.create(), do it manually to have old LV naming
|
|
|
+ revisions = ['', '-snap']
|
|
|
+ orig_uuids = {}
|
|
|
+ for rev in revisions:
|
|
|
+ cmd = ['create', self.pool._pool_id,
|
|
|
+ volume.vid.split('/')[1] + rev, str(config['size'])]
|
|
|
+ qubes_lvm(cmd)
|
|
|
+ orig_uuids[rev] = self._get_lv_uuid(volume.vid + rev)
|
|
|
+ qubes.storage.lvm.reset_cache()
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertTrue(os.path.exists(path_snap), path_snap)
|
|
|
+ expected_revisions = {}
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+ self.assertTrue(volume.is_dirty())
|
|
|
+
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = ('1521065906', '1521065907')
|
|
|
+ volume.stop()
|
|
|
+ expected_revisions = {}
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+ for rev in revisions:
|
|
|
+ path = '/dev/' + volume.vid + rev
|
|
|
+ self.assertFalse(os.path.exists(path), path)
|
|
|
+
|
|
|
+ def test_014_commit_keep_0(self):
|
|
|
+ ''' Test volume changes commit, with revisions_to_keep=0'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 0,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ # mock logging, to not interfere with time.time() mock
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ volume.create()
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ path = volume.path
|
|
|
+ expected_revisions = {}
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+
|
|
|
+ volume.start()
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ snap_uuid = self._get_lv_uuid(path_snap)
|
|
|
+ self.assertTrue(volume.is_dirty())
|
|
|
+ self.assertEqual(volume.path, path)
|
|
|
+
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = [521065906]
|
|
|
+ volume.stop()
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ self.assertEqual(volume.revisions, {})
|
|
|
+ self.assertEqual(volume.path, '/dev/' + volume.vid)
|
|
|
+ self.assertEqual(snap_uuid, self._get_lv_uuid(volume.path))
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_020_revert_last(self):
|
|
|
+ ''' Test volume revert'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume.create()
|
|
|
+ volume.start()
|
|
|
+ volume.stop()
|
|
|
+ volume.start()
|
|
|
+ volume.stop()
|
|
|
+ self.assertEqual(len(volume.revisions), 2)
|
|
|
+ revisions = volume.revisions
|
|
|
+ revision_id = max(revisions.keys())
|
|
|
+ current_path = volume.path
|
|
|
+ current_uuid = self._get_lv_uuid(volume.path)
|
|
|
+ rev_uuid = self._get_lv_uuid(volume.vid + '-' + revision_id)
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ self.assertNotEqual(current_uuid, rev_uuid)
|
|
|
+ volume.revert()
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+ self.assertEqual(current_path, volume.path)
|
|
|
+ new_uuid = self._get_lv_origin_uuid(volume.path)
|
|
|
+ self.assertEqual(new_uuid, rev_uuid)
|
|
|
+ self.assertEqual(volume.revisions, revisions)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_021_revert_earlier(self):
|
|
|
+ ''' Test volume revert'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume.create()
|
|
|
+ volume.start()
|
|
|
+ volume.stop()
|
|
|
+ volume.start()
|
|
|
+ volume.stop()
|
|
|
+ self.assertEqual(len(volume.revisions), 2)
|
|
|
+ revisions = volume.revisions
|
|
|
+ revision_id = min(revisions.keys())
|
|
|
+ current_path = volume.path
|
|
|
+ current_uuid = self._get_lv_uuid(volume.path)
|
|
|
+ rev_uuid = self._get_lv_uuid(volume.vid + '-' + revision_id)
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ self.assertNotEqual(current_uuid, rev_uuid)
|
|
|
+ volume.revert(revision_id)
|
|
|
+ path_snap = '/dev/' + volume._vid_snap
|
|
|
+ self.assertFalse(os.path.exists(path_snap), path_snap)
|
|
|
+ self.assertEqual(current_path, volume.path)
|
|
|
+ new_uuid = self._get_lv_origin_uuid(volume.path)
|
|
|
+ self.assertEqual(new_uuid, rev_uuid)
|
|
|
+ self.assertEqual(volume.revisions, revisions)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_030_import_data(self):
|
|
|
+ ''' Test volume import'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume.create()
|
|
|
+ current_uuid = self._get_lv_uuid(volume.path)
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ import_path = volume.import_data()
|
|
|
+ import_uuid = self._get_lv_uuid(import_path)
|
|
|
+ self.assertNotEqual(current_uuid, import_uuid)
|
|
|
+ # success - commit data
|
|
|
+ volume.import_data_end(True)
|
|
|
+ new_current_uuid = self._get_lv_uuid(volume.path)
|
|
|
+ self.assertEqual(new_current_uuid, import_uuid)
|
|
|
+ revisions = volume.revisions
|
|
|
+ self.assertEqual(len(revisions), 1)
|
|
|
+ revision = revisions.popitem()[0]
|
|
|
+ self.assertEqual(current_uuid,
|
|
|
+ self._get_lv_uuid(volume.vid + '-' + revision))
|
|
|
+ self.assertFalse(os.path.exists(import_path), import_path)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_031_import_data_fail(self):
|
|
|
+ ''' Test volume import'''
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume.create()
|
|
|
+ current_uuid = self._get_lv_uuid(volume.path)
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ import_path = volume.import_data()
|
|
|
+ import_uuid = self._get_lv_uuid(import_path)
|
|
|
+ self.assertNotEqual(current_uuid, import_uuid)
|
|
|
+ # fail - discard data
|
|
|
+ volume.import_data_end(False)
|
|
|
+ new_current_uuid = self._get_lv_uuid(volume.path)
|
|
|
+ self.assertEqual(new_current_uuid, current_uuid)
|
|
|
+ revisions = volume.revisions
|
|
|
+ self.assertEqual(len(revisions), 0)
|
|
|
+ self.assertFalse(os.path.exists(import_path), import_path)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_032_import_volume_same_pool(self):
|
|
|
+ '''Import volume from the same pool'''
|
|
|
+ # source volume
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ source_volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ source_volume.create()
|
|
|
+
|
|
|
+ source_uuid = self._get_lv_uuid(source_volume.path)
|
|
|
+
|
|
|
+ # destination volume
|
|
|
+ config = {
|
|
|
+ 'name': 'root2',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = [1521065905]
|
|
|
+ volume.create()
|
|
|
+
|
|
|
+ self.assertEqual(volume.revisions, {})
|
|
|
+ uuid_before = self._get_lv_uuid(volume.path)
|
|
|
+
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = [1521065906]
|
|
|
+ self.loop.run_until_complete(
|
|
|
+ volume.import_volume(source_volume))
|
|
|
+
|
|
|
+ uuid_after = self._get_lv_uuid(volume.path)
|
|
|
+ self.assertNotEqual(uuid_after, uuid_before)
|
|
|
+
|
|
|
+ # also should be different than source volume (clone, not the same LV)
|
|
|
+ self.assertNotEqual(uuid_after, source_uuid)
|
|
|
+ self.assertEqual(self._get_lv_origin_uuid(volume.path), source_uuid)
|
|
|
+
|
|
|
+ expected_revisions = {
|
|
|
+ '1521065906-back': '2018-03-14T22:18:26',
|
|
|
+ }
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+ source_volume.remove()
|
|
|
+
|
|
|
+ def test_033_import_volume_different_pool(self):
|
|
|
+ '''Import volume from a different pool'''
|
|
|
+ source_volume = unittest.mock.Mock()
|
|
|
+ # destination volume
|
|
|
+ config = {
|
|
|
+ 'name': 'root2',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume.log = unittest.mock.Mock()
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = [1521065905]
|
|
|
+ volume.create()
|
|
|
+
|
|
|
+ self.assertEqual(volume.revisions, {})
|
|
|
+ uuid_before = self._get_lv_uuid(volume.path)
|
|
|
+
|
|
|
+ with tempfile.NamedTemporaryFile() as source_volume_file:
|
|
|
+ source_volume_file.write(b'test-content')
|
|
|
+ source_volume_file.flush()
|
|
|
+ source_volume.size = 16 * 1024 * 1024 # 16MiB
|
|
|
+ source_volume.export.return_value = source_volume_file.name
|
|
|
+ with unittest.mock.patch('time.time') as mock_time:
|
|
|
+ mock_time.side_effect = [1521065906]
|
|
|
+ self.loop.run_until_complete(
|
|
|
+ volume.import_volume(source_volume))
|
|
|
+
|
|
|
+ uuid_after = self._get_lv_uuid(volume.path)
|
|
|
+ self.assertNotEqual(uuid_after, uuid_before)
|
|
|
+ self.assertEqual(volume.size, 16 * 1024 * 1024)
|
|
|
+
|
|
|
+ volume_content = subprocess.check_output(['sudo', 'cat', volume.path])
|
|
|
+ self.assertEqual(volume_content.rstrip(b'\0'), b'test-content')
|
|
|
+
|
|
|
+ expected_revisions = {
|
|
|
+ '1521065906-back': '2018-03-14T22:18:26',
|
|
|
+ }
|
|
|
+ self.assertEqual(volume.revisions, expected_revisions)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+
|
|
|
+ def test_040_volatile(self):
|
|
|
+ '''Volatile volume test'''
|
|
|
+ config = {
|
|
|
+ 'name': 'volatile',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'rw': True,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ # volatile volume don't need any file, verify should succeed
|
|
|
+ self.assertTrue(volume.verify())
|
|
|
+ volume.create()
|
|
|
+ self.assertTrue(volume.verify())
|
|
|
+ self.assertFalse(volume.save_on_stop)
|
|
|
+ self.assertFalse(volume.snap_on_start)
|
|
|
+ path = volume.path
|
|
|
+ self.assertEqual(path, '/dev/' + volume.vid)
|
|
|
+ self.assertFalse(os.path.exists(path))
|
|
|
+ volume.start()
|
|
|
+ self.assertTrue(os.path.exists(path))
|
|
|
+ vol_uuid = self._get_lv_uuid(path)
|
|
|
+ volume.start()
|
|
|
+ self.assertTrue(os.path.exists(path))
|
|
|
+ vol_uuid2 = self._get_lv_uuid(path)
|
|
|
+ self.assertNotEqual(vol_uuid, vol_uuid2)
|
|
|
+ volume.stop()
|
|
|
+ self.assertFalse(os.path.exists(path))
|
|
|
+
|
|
|
+ def test_050_snapshot_volume(self):
|
|
|
+ ''' Test snapshot volume creation '''
|
|
|
+ config_origin = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume_origin = self.app.get_pool(self.pool.name).init_volume(
|
|
|
+ vm, config_origin)
|
|
|
+ volume_origin.create()
|
|
|
+ config_snapshot = {
|
|
|
+ 'name': 'root2',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'snap_on_start': True,
|
|
|
+ 'source': volume_origin,
|
|
|
+ 'rw': True,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ volume = self.app.get_pool(self.pool.name).init_volume(
|
|
|
+ vm, config_snapshot)
|
|
|
+ self.assertIsInstance(volume, ThinVolume)
|
|
|
+ self.assertEqual(volume.name, 'root2')
|
|
|
+ self.assertEqual(volume.pool, self.pool.name)
|
|
|
+ self.assertEqual(volume.size, qubes.config.defaults['root_img_size'])
|
|
|
+ # only origin volume really needs to exist, verify should succeed
|
|
|
+ # even before create
|
|
|
+ self.assertTrue(volume.verify())
|
|
|
+ volume.create()
|
|
|
+ path = volume.path
|
|
|
+ self.assertEqual(path, '/dev/' + volume.vid)
|
|
|
+ self.assertFalse(os.path.exists(path), path)
|
|
|
+ volume.start()
|
|
|
+ # snapshot volume isn't considered dirty at any time
|
|
|
+ self.assertFalse(volume.is_dirty())
|
|
|
+ # not outdated yet
|
|
|
+ self.assertFalse(volume.is_outdated())
|
|
|
+ origin_uuid = self._get_lv_uuid(volume_origin.path)
|
|
|
+ snap_origin_uuid = self._get_lv_origin_uuid(volume._vid_snap)
|
|
|
+ self.assertEqual(origin_uuid, snap_origin_uuid)
|
|
|
+
|
|
|
+ # now make it outdated
|
|
|
+ volume_origin.start()
|
|
|
+ volume_origin.stop()
|
|
|
+ self.assertTrue(volume.is_outdated())
|
|
|
+ origin_uuid = self._get_lv_uuid(volume_origin.path)
|
|
|
+ self.assertNotEqual(origin_uuid, snap_origin_uuid)
|
|
|
+
|
|
|
+ volume.stop()
|
|
|
+ # stopped volume is never outdated
|
|
|
+ self.assertFalse(volume.is_outdated())
|
|
|
+ path = volume.path
|
|
|
+ self.assertFalse(os.path.exists(path), path)
|
|
|
+ path = '/dev/' + volume._vid_snap
|
|
|
+ self.assertFalse(os.path.exists(path), path)
|
|
|
+
|
|
|
+ volume.remove()
|
|
|
+ volume_origin.remove()
|
|
|
+
|
|
|
+ def test_100_pool_list_volumes(self):
|
|
|
+ config = {
|
|
|
+ 'name': 'root',
|
|
|
+ 'pool': self.pool.name,
|
|
|
+ 'save_on_stop': True,
|
|
|
+ 'rw': True,
|
|
|
+ 'revisions_to_keep': 2,
|
|
|
+ 'size': qubes.config.defaults['root_img_size'],
|
|
|
+ }
|
|
|
+ config2 = config.copy()
|
|
|
+ vm = qubes.tests.storage.TestVM(self)
|
|
|
+ volume1 = self.app.get_pool(self.pool.name).init_volume(vm, config)
|
|
|
+ volume1.create()
|
|
|
+ config2['name'] = 'private'
|
|
|
+ volume2 = self.app.get_pool(self.pool.name).init_volume(vm, config2)
|
|
|
+ volume2.create()
|
|
|
+
|
|
|
+ # create some revisions
|
|
|
+ volume1.start()
|
|
|
+ volume1.stop()
|
|
|
+
|
|
|
+ # and have one in dirty state
|
|
|
+ volume2.start()
|
|
|
+
|
|
|
+ self.assertIn(volume1, list(self.pool.volumes))
|
|
|
+ self.assertIn(volume2, list(self.pool.volumes))
|
|
|
+ volume1.remove()
|
|
|
+ self.assertNotIn(volume1, list(self.pool.volumes))
|
|
|
+ self.assertIn(volume2, list(self.pool.volumes))
|
|
|
+ volume2.remove()
|
|
|
+ self.assertNotIn(volume1, list(self.pool.volumes))
|
|
|
+ self.assertNotIn(volume1, list(self.pool.volumes))
|
|
|
|
|
|
@skipUnlessLvmPoolExists
|
|
|
class TC_01_ThinPool(ThinPoolBase, qubes.tests.SystemTestCase):
|