def test_upgrade_None_to_last_phantom_share_path(self):
"""Upgrade from version 'None' (possibly a clean start) with a root
with missing path.
"""
old_root = os.path.join(self.root_dir, 'My Files')
old_shares = os.path.join(self.root_dir, 'Shared With Me')
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.main.shutdown()
self.rmtree(self.vm_data_dir)
os.makedirs(self.vm_data_dir)
self.set_md_version('')
shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir)
root_share.access_level = ACCESS_LEVEL_RW
# set None to the share path
root_share.path = None
shares[request.ROOT] = root_share
if self.md_version_None:
self.set_md_version('')
# check that it's all OK
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.assertFalse(os.path.exists(old_root))
self.assertTrue(os.path.exists(self.root_dir))
self.assertTrue(os.path.exists(self.shares_dir))
self.assertTrue(os.path.islink(old_shares))
self.assertEqual(old_shares, self.main.shares_dir_link)
self.check_version()
def test_broken_symlink_latest_metadata(self):
"""Test vm startup with latest metadata and a broken symlink."""
self._build_layout_version_4()
os.unlink(self.shares_dir_link)
# create a broken link
os.symlink('foo', self.shares_dir_link)
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.check_version()
def test_upgrade_None_to_last(self):
"""Upgrade from version 'None' (possibly a clean start)."""
old_root = os.path.join(self.root_dir, 'My Files')
old_shares = os.path.join(self.root_dir, 'Shared With Me')
# start and check that everything is ok
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.assertFalse(os.path.exists(old_root))
self.assertTrue(os.path.exists(self.root_dir))
self.assertTrue(os.path.exists(old_shares))
self.assertTrue(os.path.islink(old_shares))
self.assertEqual(old_shares, self.main.shares_dir_link)
self.check_version()
def test_upgrade_4(self):
"""Test migration from 4 to 5 (broken symlink in the root)."""
self._build_layout_version_4()
self.set_md_version('4')
# break the symlink
if os.path.exists(self.shares_dir_link):
os.unlink(self.shares_dir_link)
os.symlink(self.shares_dir_link, self.shares_dir_link)
if self.md_version_None:
self.set_md_version('')
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.assertEqual(
self.main.shares_dir, os.readlink(self.main.shares_dir_link))
self.check_version()
def test_upgrade_6(self):
"""Test the migration from version 6."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('6')
self.udfs_md_dir = os.path.join(self.vm_data_dir, 'udfs')
# create some old shares and shared metadata
legacy_shares = VMFileShelf(self.share_md_dir)
root = Root(path=self.root_dir)
legacy_shares[request.ROOT] = root
for idx, name in enumerate(['share'] * 10):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = Share(
path=os.path.join(self.shares_dir, share_name),
volume_id=sid, name=share_name, node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
# create shared shares
legacy_shared = VMFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 5):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = Shared(path=os.path.join(self.root_dir, share_name),
volume_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shared[sid] = share
# create some udfs
legacy_udfs = VMFileShelf(self.udfs_md_dir)
for idx, name in enumerate(['dir'] * 5):
udf_id = str(uuid.uuid4())
udf_name = name + '_' + str(idx)
udf = UDF(
udf_id, str(uuid.uuid4()), u'~/' + udf_name.decode('utf-8'),
os.path.join(self.home_dir, udf_name))
if idx % 2:
udf.subscribed = True
else:
udf.subscribed = False
legacy_udfs[sid] = udf
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
legacy_udfs = dict(legacy_udfs.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
vm = self.main.vm
for sid in vm.shares:
old_share = legacy_shares[sid]
share = vm.shares[sid]
self.assertTrue(
isinstance(share, Share) or isinstance(share, Root))
self.assertEqual(share.__dict__, old_share.__dict__)
for sid in vm.shared:
old_share = legacy_shared[sid]
share = vm.shared[sid]
self.assertTrue(isinstance(share, Shared))
self.assertEqual(share.__dict__, old_share.__dict__)
for udf_id in vm.udfs:
old_udf = legacy_udfs[udf_id]
udf = vm.udfs[udf_id]
self.assertTrue(isinstance(udf, UDF))
self.assertEqual(udf.__dict__, old_udf.__dict__)
def test_upgrade_5_partial_upgrade(self):
"""Test migration from version 5 with upgrade to 6 unfinished."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('5')
self.udfs_md_dir = os.path.join(self.vm_data_dir, 'udfs')
# create some old shares and shared metadata
legacy_shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir, share_id=request.ROOT,
access_level=ACCESS_LEVEL_RW, node_id=str(
uuid.uuid4()))
legacy_shares[request.ROOT] = root_share
for idx, name in enumerate(['share'] * 3):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.shares_dir, share_name),
share_id=sid, name=share_name,
node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx == 0:
share.access_level = ACCESS_LEVEL_RW
legacy_shares[sid] = share
elif idx == 1:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
else:
# add a 'new' Share dict to the shelf
share.access_level = ACCESS_LEVEL_RW
share = Share(
path=share.path, volume_id=share.id, name=share.name,
access_level=share.access_level,
other_username=share.other_username,
other_visible_name=share.other_visible_name,
node_id=share.subtree)
legacy_shares[sid] = share.__dict__
# create shared shares
legacy_shared = LegacyShareFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 3):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.root_dir, share_name),
share_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx == 0:
share.access_level = ACCESS_LEVEL_RW
legacy_shares[sid] = share
elif idx == 1:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
else:
# add a 'new' Shared dict to the shelf
share.access_level = ACCESS_LEVEL_RW
share = Shared(path=share.path,
volume_id=share.id, name=share.name,
access_level=share.access_level,
other_username=share.other_username,
other_visible_name=share.other_visible_name,
node_id=share.subtree)
legacy_shares[sid] = share.__dict__
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
vm = self.main.vm
def compare_share(share, old_share):
"""Compare two shares, new and old"""
old_id = getattr(old_share, 'id', None)
if old_id is None:
old_id = old_share['volume_id']
self.assertEqual(share.volume_id, old_id)
self.assertEqual(
share.path,
getattr(old_share, 'path', None) or old_share['path'])
self.assertEqual(
share.node_id,
getattr(old_share, 'subtree', None) or old_share['node_id'])
if not isinstance(share, Root):
self.assertEqual(
share.name,
getattr(old_share, 'name', None) or old_share['name'])
username = (getattr(old_share, 'other_username', None) or
old_share['other_username'])
self.assertEqual(share.other_username, username)
name = (getattr(old_share, 'other_visible_name', None) or
old_share['other_visible_name'])
self.assertEqual(share.other_visible_name, name)
level = (getattr(old_share, 'access_level', None) or
old_share['access_level'])
self.assertEqual(share.access_level, level)
for sid in vm.shares:
old_share = legacy_shares[sid]
share = vm.shares[sid]
self.assertTrue(
isinstance(share, Share) or isinstance(share, Root))
compare_share(share, old_share)
for sid in vm.shared:
old_share = legacy_shared[sid]
share = vm.shared[sid]
self.assertTrue(isinstance(share, Shared))
compare_share(share, old_share)
def test_upgrade_5_with_udfs(self):
"""Test the migration from version 5 with old UDFs."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('5')
self.udfs_md_dir = os.path.join(self.vm_data_dir, 'udfs')
# create some old shares and shared metadata
legacy_shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir, share_id=request.ROOT,
access_level=ACCESS_LEVEL_RW)
legacy_shares[request.ROOT] = root_share
for idx, name in enumerate(['share'] * 10):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.shares_dir, share_name),
share_id=sid, name=share_name,
node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
# create shared shares
legacy_shared = LegacyShareFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 5):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.root_dir, share_name),
share_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shared[sid] = share
# create some udfs
legacy_udfs = LegacyShareFileShelf(self.udfs_md_dir)
for idx, name in enumerate(['dir'] * 5):
udf_id = str(uuid.uuid4())
udf_name = name + '_' + str(idx)
udf = _UDF(
udf_id, str(uuid.uuid4()), u'~/' + udf_name.decode('utf-8'),
os.path.join(self.home_dir, udf_name))
if idx % 2:
udf.subscribed = True
else:
udf.subscribed = False
legacy_udfs[sid] = udf
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
legacy_udfs = dict(legacy_udfs.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
vm = self.main.vm
def compare_share(share, old_share):
"""Compare two shares, new and old"""
self.assertEqual(share.volume_id, old_share.id)
self.assertEqual(share.path, old_share.path)
self.assertEqual(share.node_id, old_share.subtree)
if not isinstance(share, Root):
self.assertEqual(share.name, old_share.name)
self.assertEqual(
share.other_username, old_share.other_username)
self.assertEqual(
share.other_visible_name, old_share.other_visible_name)
self.assertEqual(share.access_level, old_share.access_level)
for sid in vm.shares:
old_share = legacy_shares[sid]
share = vm.shares[sid]
self.assertTrue(
isinstance(share, Share) or isinstance(share, Root))
compare_share(share, old_share)
for sid in vm.shared:
old_share = legacy_shared[sid]
share = vm.shared[sid]
self.assertTrue(isinstance(share, Shared))
compare_share(share, old_share)
for udf_id in vm.udfs:
old_udf = legacy_udfs[udf_id]
udf = vm.udfs[udf_id]
self.assertTrue(isinstance(udf, UDF))
self.assertEqual(udf.volume_id, old_udf.id)
self.assertEqual(udf.path, old_udf.path)
self.assertEqual(udf.node_id, old_udf.node_id)
self.assertEqual(udf.suggested_path, old_udf.suggested_path)
self.assertEqual(
type(udf.suggested_path), type(old_udf.suggested_path))
self.assertEqual(udf.subscribed, old_udf.subscribed)
class MetadataNewLayoutTests(MetadataTestCase):
"""Test for 'new' layout and metadata upgrade."""
@defer.inlineCallbacks
def setUp(self):
yield super(MetadataNewLayoutTests, self).setUp()
# We need to define home_dir here to add 'home' to the path
# and avoid crashes between existing paths.
self.home_dir = os.path.join(self.tmpdir, 'home', 'ubuntuonehacker')
self.share_md_dir = os.path.join(self.vm_data_dir, 'shares')
self.shared_md_dir = os.path.join(self.vm_data_dir, 'shared')
self.u1_dir = os.path.join(
self.home_dir, os.path.split(self.u1_dir)[1])
self.root_dir = self.u1_dir
self.shares_dir = os.path.join(self.tmpdir, 'shares')
self.shares_dir_link = os.path.join(self.u1_dir, 'Shared With Me')
def _build_layout_version_4(self):
"""Build the directory structure to mimic md v.4/5."""
os.makedirs(self.share_md_dir)
os.makedirs(self.shared_md_dir)
os.makedirs(self.root_dir)
os.makedirs(self.shares_dir)
os.symlink(self.shares_dir, self.shares_dir_link)
def _fix_permissions(self):
"""Fix shares dir permissions, making it read-only."""
os.chmod(self.shares_dir, 0500)
def test_upgrade_None_to_last(self):
"""Upgrade from version 'None' (possibly a clean start)."""
old_root = os.path.join(self.root_dir, 'My Files')
old_shares = os.path.join(self.root_dir, 'Shared With Me')
# start and check that everything is ok
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.assertFalse(os.path.exists(old_root))
self.assertTrue(os.path.exists(self.root_dir))
self.assertTrue(os.path.exists(old_shares))
self.assertTrue(os.path.islink(old_shares))
self.assertEqual(old_shares, self.main.shares_dir_link)
self.check_version()
def test_upgrade_None_to_last_phantom_share_path(self):
"""Upgrade from version 'None' (possibly a clean start) with a root
with missing path.
"""
old_root = os.path.join(self.root_dir, 'My Files')
old_shares = os.path.join(self.root_dir, 'Shared With Me')
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.main.shutdown()
self.rmtree(self.vm_data_dir)
os.makedirs(self.vm_data_dir)
self.set_md_version('')
shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir)
root_share.access_level = ACCESS_LEVEL_RW
# set None to the share path
root_share.path = None
shares[request.ROOT] = root_share
if self.md_version_None:
self.set_md_version('')
# check that it's all OK
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.assertFalse(os.path.exists(old_root))
self.assertTrue(os.path.exists(self.root_dir))
self.assertTrue(os.path.exists(self.shares_dir))
self.assertTrue(os.path.islink(old_shares))
self.assertEqual(old_shares, self.main.shares_dir_link)
self.check_version()
def test_upgrade_4(self):
"""Test migration from 4 to 5 (broken symlink in the root)."""
self._build_layout_version_4()
self.set_md_version('4')
# break the symlink
if os.path.exists(self.shares_dir_link):
os.unlink(self.shares_dir_link)
os.symlink(self.shares_dir_link, self.shares_dir_link)
if self.md_version_None:
self.set_md_version('')
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.assertEqual(
self.main.shares_dir, os.readlink(self.main.shares_dir_link))
self.check_version()
def test_upgrade_5(self):
"""Test the migration from version 5."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('5')
# create some old shares and shared metadata
legacy_shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir, share_id=request.ROOT,
access_level=ACCESS_LEVEL_RW)
legacy_shares[request.ROOT] = root_share
for idx, name in enumerate(['share'] * 10):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.shares_dir, share_name),
share_id=sid, name=share_name,
node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
# create shared shares
legacy_shared = LegacyShareFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 5):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.root_dir, share_name),
share_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shared[sid] = share
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
vm = self.main.vm
def compare_share(share, old_share):
"""Compare two shares, new and old"""
self.assertEqual(share.volume_id, old_share.id)
self.assertEqual(share.path, old_share.path)
self.assertEqual(share.node_id, old_share.subtree)
if not isinstance(share, Root):
self.assertEqual(share.name, old_share.name)
self.assertEqual(
share.other_username, old_share.other_username)
self.assertEqual(
share.other_visible_name, old_share.other_visible_name)
self.assertEqual(share.access_level, old_share.access_level)
for sid in vm.shares:
old_share = legacy_shares[sid]
share = vm.shares[sid]
self.assertTrue(
isinstance(share, Share) or isinstance(share, Root))
compare_share(share, old_share)
for sid in vm.shared:
old_share = legacy_shared[sid]
share = vm.shared[sid]
self.assertTrue(isinstance(share, Shared))
compare_share(share, old_share)
def test_upgrade_5_with_udfs(self):
"""Test the migration from version 5 with old UDFs."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('5')
self.udfs_md_dir = os.path.join(self.vm_data_dir, 'udfs')
# create some old shares and shared metadata
legacy_shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir, share_id=request.ROOT,
access_level=ACCESS_LEVEL_RW)
legacy_shares[request.ROOT] = root_share
for idx, name in enumerate(['share'] * 10):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.shares_dir, share_name),
share_id=sid, name=share_name,
node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
# create shared shares
legacy_shared = LegacyShareFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 5):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.root_dir, share_name),
share_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shared[sid] = share
# create some udfs
legacy_udfs = LegacyShareFileShelf(self.udfs_md_dir)
for idx, name in enumerate(['dir'] * 5):
udf_id = str(uuid.uuid4())
udf_name = name + '_' + str(idx)
udf = _UDF(
udf_id, str(uuid.uuid4()), u'~/' + udf_name.decode('utf-8'),
os.path.join(self.home_dir, udf_name))
if idx % 2:
udf.subscribed = True
else:
udf.subscribed = False
legacy_udfs[sid] = udf
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
legacy_udfs = dict(legacy_udfs.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
vm = self.main.vm
def compare_share(share, old_share):
"""Compare two shares, new and old"""
self.assertEqual(share.volume_id, old_share.id)
self.assertEqual(share.path, old_share.path)
self.assertEqual(share.node_id, old_share.subtree)
if not isinstance(share, Root):
self.assertEqual(share.name, old_share.name)
self.assertEqual(
share.other_username, old_share.other_username)
self.assertEqual(
share.other_visible_name, old_share.other_visible_name)
self.assertEqual(share.access_level, old_share.access_level)
for sid in vm.shares:
old_share = legacy_shares[sid]
share = vm.shares[sid]
self.assertTrue(
isinstance(share, Share) or isinstance(share, Root))
compare_share(share, old_share)
for sid in vm.shared:
old_share = legacy_shared[sid]
share = vm.shared[sid]
self.assertTrue(isinstance(share, Shared))
compare_share(share, old_share)
for udf_id in vm.udfs:
old_udf = legacy_udfs[udf_id]
udf = vm.udfs[udf_id]
self.assertTrue(isinstance(udf, UDF))
self.assertEqual(udf.volume_id, old_udf.id)
self.assertEqual(udf.path, old_udf.path)
self.assertEqual(udf.node_id, old_udf.node_id)
self.assertEqual(udf.suggested_path, old_udf.suggested_path)
self.assertEqual(
type(udf.suggested_path), type(old_udf.suggested_path))
self.assertEqual(udf.subscribed, old_udf.subscribed)
def test_upgrade_5_partial_upgrade(self):
"""Test migration from version 5 with upgrade to 6 unfinished."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('5')
self.udfs_md_dir = os.path.join(self.vm_data_dir, 'udfs')
# create some old shares and shared metadata
legacy_shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir, share_id=request.ROOT,
access_level=ACCESS_LEVEL_RW, node_id=str(
uuid.uuid4()))
legacy_shares[request.ROOT] = root_share
for idx, name in enumerate(['share'] * 3):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.shares_dir, share_name),
share_id=sid, name=share_name,
node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx == 0:
share.access_level = ACCESS_LEVEL_RW
legacy_shares[sid] = share
elif idx == 1:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
else:
# add a 'new' Share dict to the shelf
share.access_level = ACCESS_LEVEL_RW
share = Share(
path=share.path, volume_id=share.id, name=share.name,
access_level=share.access_level,
other_username=share.other_username,
other_visible_name=share.other_visible_name,
node_id=share.subtree)
legacy_shares[sid] = share.__dict__
# create shared shares
legacy_shared = LegacyShareFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 3):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.root_dir, share_name),
share_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx == 0:
share.access_level = ACCESS_LEVEL_RW
legacy_shares[sid] = share
elif idx == 1:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
else:
# add a 'new' Shared dict to the shelf
share.access_level = ACCESS_LEVEL_RW
share = Shared(path=share.path,
volume_id=share.id, name=share.name,
access_level=share.access_level,
other_username=share.other_username,
other_visible_name=share.other_visible_name,
node_id=share.subtree)
legacy_shares[sid] = share.__dict__
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
vm = self.main.vm
def compare_share(share, old_share):
"""Compare two shares, new and old"""
old_id = getattr(old_share, 'id', None)
if old_id is None:
old_id = old_share['volume_id']
self.assertEqual(share.volume_id, old_id)
self.assertEqual(
share.path,
getattr(old_share, 'path', None) or old_share['path'])
self.assertEqual(
share.node_id,
getattr(old_share, 'subtree', None) or old_share['node_id'])
if not isinstance(share, Root):
self.assertEqual(
share.name,
getattr(old_share, 'name', None) or old_share['name'])
username = (getattr(old_share, 'other_username', None) or
old_share['other_username'])
self.assertEqual(share.other_username, username)
name = (getattr(old_share, 'other_visible_name', None) or
old_share['other_visible_name'])
self.assertEqual(share.other_visible_name, name)
level = (getattr(old_share, 'access_level', None) or
old_share['access_level'])
self.assertEqual(share.access_level, level)
for sid in vm.shares:
old_share = legacy_shares[sid]
share = vm.shares[sid]
self.assertTrue(
isinstance(share, Share) or isinstance(share, Root))
compare_share(share, old_share)
for sid in vm.shared:
old_share = legacy_shared[sid]
share = vm.shared[sid]
self.assertTrue(isinstance(share, Shared))
compare_share(share, old_share)
def test_upgrade_5_critical_error(self):
"""Test the migration from version 5 with a critical error."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('5')
# create some old shares and shared metadata
legacy_shares = LegacyShareFileShelf(self.share_md_dir)
root_share = _Share(path=self.root_dir, share_id=request.ROOT,
access_level=ACCESS_LEVEL_RW)
legacy_shares[request.ROOT] = root_share
for idx, name in enumerate(['share'] * 10):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.shares_dir, share_name),
share_id=sid, name=share_name,
node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
# create shared shares
legacy_shared = LegacyShareFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 5):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = _Share(path=os.path.join(self.root_dir, share_name),
share_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shared[sid] = share
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
old_upgrade_share_to_volume = MetadataUpgrader._upgrade_share_to_volume
def upgrade_share_to_volume(share, shared=False):
raise ValueError('FAIL!')
MetadataUpgrader._upgrade_share_to_volume = upgrade_share_to_volume
try:
self.assertRaises(ValueError, FakeMain, self.root_dir,
self.shares_dir, self.data_dir,
self.partials_dir)
finally:
MetadataUpgrader._upgrade_share_to_volume = \
old_upgrade_share_to_volume
shares = LegacyShareFileShelf(self.share_md_dir)
self.assertEqual(len(list(shares.keys())), len(legacy_shares.keys()))
for sid, share in shares.iteritems():
old_share = legacy_shares[sid]
self.assertTrue(isinstance(share, _Share))
self.assertTrue(isinstance(old_share, _Share))
shared = LegacyShareFileShelf(self.shared_md_dir)
self.assertEqual(len(list(shared.keys())), len(legacy_shared.keys()))
for sid, share in shared.iteritems():
old_share = legacy_shared[sid]
self.assertTrue(isinstance(share, _Share))
self.assertTrue(isinstance(old_share, _Share))
def test_broken_symlink_latest_metadata(self):
"""Test vm startup with latest metadata and a broken symlink."""
self._build_layout_version_4()
os.unlink(self.shares_dir_link)
# create a broken link
os.symlink('foo', self.shares_dir_link)
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
self.check_version()
def test_upgrade_6(self):
"""Test the migration from version 6."""
# build a fake version 5 state
self._build_layout_version_4()
self.set_md_version('6')
self.udfs_md_dir = os.path.join(self.vm_data_dir, 'udfs')
# create some old shares and shared metadata
legacy_shares = VMFileShelf(self.share_md_dir)
root = Root(path=self.root_dir)
legacy_shares[request.ROOT] = root
for idx, name in enumerate(['share'] * 10):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = Share(
path=os.path.join(self.shares_dir, share_name),
volume_id=sid, name=share_name, node_id=str(uuid.uuid4()),
other_username='******' + str(idx),
other_visible_name='visible name ' + str(idx))
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shares[sid] = share
# create shared shares
legacy_shared = VMFileShelf(self.shared_md_dir)
for idx, name in enumerate(['dir'] * 5):
sid = str(uuid.uuid4())
share_name = name + '_' + str(idx)
share = Shared(path=os.path.join(self.root_dir, share_name),
volume_id=sid, node_id=str(uuid.uuid4()),
name=share_name, other_username='******',
other_visible_name='hola')
if idx % 2:
share.access_level = ACCESS_LEVEL_RW
else:
share.access_level = ACCESS_LEVEL_RO
legacy_shared[sid] = share
# create some udfs
legacy_udfs = VMFileShelf(self.udfs_md_dir)
for idx, name in enumerate(['dir'] * 5):
udf_id = str(uuid.uuid4())
udf_name = name + '_' + str(idx)
udf = UDF(
udf_id, str(uuid.uuid4()), u'~/' + udf_name.decode('utf-8'),
os.path.join(self.home_dir, udf_name))
if idx % 2:
udf.subscribed = True
else:
udf.subscribed = False
legacy_udfs[sid] = udf
# keep a copy of the current shares and shared metadata to check
# the upgrade went ok
legacy_shares = dict(legacy_shares.items())
legacy_shared = dict(legacy_shared.items())
legacy_udfs = dict(legacy_udfs.items())
if self.md_version_None:
self.set_md_version('')
# upgrade it!
self.main = FakeMain(self.root_dir, self.shares_dir,
self.data_dir, self.partials_dir)
vm = self.main.vm
for sid in vm.shares:
old_share = legacy_shares[sid]
share = vm.shares[sid]
self.assertTrue(
isinstance(share, Share) or isinstance(share, Root))
self.assertEqual(share.__dict__, old_share.__dict__)
for sid in vm.shared:
old_share = legacy_shared[sid]
share = vm.shared[sid]
self.assertTrue(isinstance(share, Shared))
self.assertEqual(share.__dict__, old_share.__dict__)
for udf_id in vm.udfs:
old_udf = legacy_udfs[udf_id]
udf = vm.udfs[udf_id]
self.assertTrue(isinstance(udf, UDF))
self.assertEqual(udf.__dict__, old_udf.__dict__)
