Merge lp:~verterok/ubuntuone-client/fix-529666 into lp:ubuntuone-client

[Guillermo Gonzalez]

Fix metadata migration in the case of a failed/aborted volume manager migration from metadata v.5.

This branch fix metadata migration in the case of a failed/aborted migration from metadata v.5, e.g: recover for mixed metadata versions in the shares/d shelf.

[Tim Cole (tcole)]

review: Approve

[Rick McBride (rmcbride)]

Looks good! probably explains and fixes the issues I've been having with my client and metadata recently.

review: Approve

=== modified file 'tests/syncdaemon/test_vm.py'
--- tests/syncdaemon/test_vm.py	2010-03-04 02:55:09 +0000
+++ tests/syncdaemon/test_vm.py	2010-03-23 14:01:24 +0000
@@ -2420,6 +2420,114 @@
             self.assertEquals(udf.suggested_path, old_udf.suggested_path)
             self.assertEquals(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='',
+                            access_level='Modify', node_id=str(uuid.uuid4()))
+        legacy_shares[''] = 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='username'+str(idx),
+                           other_visible_name='visible name ' + str(idx))
+            if idx == 0:
+                share.access_level = 'Modify'
+                legacy_shares[sid] = share
+            elif idx == 1:
+                share.access_level = 'View'
+                legacy_shares[sid] = share
+            else:
+                # add a 'new' Share dict to the shelf
+                share.access_level = 'Modify'
+                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='hola',
+                           other_visible_name='hola')
+            if idx == 0:
+                share.access_level = 'Modify'
+                legacy_shares[sid] = share
+            elif idx == 1:
+                share.access_level = 'View'
+                legacy_shares[sid] = share
+            else:
+                # add a 'new' Shared dict to the shelf
+                share.access_level = 'Modify'
+                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.assertEquals(share.volume_id, old_id)
+            self.assertEquals(share.path,
+                getattr(old_share, 'path', None) or old_share['path'])
+            self.assertEquals(share.node_id,
+                getattr(old_share, 'subtree', None) or old_share['node_id'])
+            if not isinstance(share, Root):
+                self.assertEquals(share.name,
+                    getattr(old_share, 'name', None) or old_share['name'])
+                self.assertEquals(share.other_username,
+                    getattr(old_share, 'other_username', None) \
+                                  or old_share['other_username'])
+                self.assertEquals(share.other_visible_name,
+                    getattr(old_share, 'other_visible_name', None) \
+                                  or old_share['other_visible_name'])
+                self.assertEquals(share.access_level,
+                    getattr(old_share, 'access_level', None) \
+                                  or 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)
+
 
 class BrokenOldMDVersionUpgradeTests(MetadataOldLayoutTests):
     """MetadataOldLayoutTests with broken .version file."""
@@ -2520,3 +2628,11 @@
         version = self.md_upgrader._guess_metadata_version()
         self.assertEquals(version, '6')
 
+    def test_guess_mixed_metadata_5_and_6(self):
+        """Test _guess_metadata_version method for mixed version 5 and 6."""
+        # fake a version 6 layout and metadata
+        shelf = LegacyShareFileShelf(self.share_md_dir)
+        shelf['old_share'] = _Share(path='/foo/bar', share_id='old_share')
+        shelf['new_share'] = Share(path='/bar/foo', volume_id='new_share').__dict__
+        version = self.md_upgrader._guess_metadata_version()
+        self.assertEquals(version, '5')

=== modified file 'ubuntuone/syncdaemon/volume_manager.py'
--- ubuntuone/syncdaemon/volume_manager.py	2010-03-04 02:55:09 +0000
+++ ubuntuone/syncdaemon/volume_manager.py	2010-03-23 14:01:24 +0000
@@ -1083,7 +1083,7 @@
         and layout, fallbacks to md_version = None if can't guess it.
 
         """
-        #md_version = None
+        md_version = None
         if os.path.exists(self._shares_md_dir) \
            and os.path.exists(self._shared_md_dir):
             # we have shares and shared dirs
@@ -1115,13 +1115,18 @@
                     shelf = LegacyShareFileShelf(self._shares_md_dir)
                     # check a pickled value to check if it's in version
                     # 5 or 6
+                    md_version = '5'
+                    versions = {'5':0, '6':0}
                     for key in shelf:
                         share = shelf[key]
                         if isinstance(share, _Share):
-                            md_version = '5'
+                            versions['5'] += 1
                         else:
-                            md_version = '6'
-                        break
+                            versions['6'] += 1
+                    if versions['5'] > 0:
+                        md_version = '5'
+                    elif versions['6'] > 0:
+                        md_version = '6'
         else:
             # this is metadata 'None'
             md_version = None
@@ -1354,10 +1359,16 @@
             else:
                 share.free_bytes = None
             return share
-        # handle the root special case
-        if share.path == self._root_dir or share.id == '':
-            r = Root(share.subtree, share.path)
-            return r
+
+        if isinstance(share, dict):
+            # oops, we have mixed metadata. fix it!
+            clazz = VMFileShelf.classes[share[VMFileShelf.TYPE]]
+            share_dict = share.copy()
+            del share_dict[VMFileShelf.TYPE]
+            return clazz(**share_dict)
+        elif share.path == self._root_dir or share.id == '':
+            # handle the root special case
+            return Root(share.subtree, share.path)
         else:
             share = upgrade_share_dict(share)
             if shared: