Merge lp:~facundo/ubuntuone-client/fix-path-retrieval into lp:ubuntuone-client

[Facundo Batista]

Path is not sent directly anymore to AQ ops, it's retrieved later (LP: #988534).

Path is not sent directly anymore to AQ ops, it's retrieved later.

For this, instead passing paths, the mdid is sent to the operation. This is to solve the situation where the node is renamed between the path is passed to the operation and that the operation is run.

Tests adjusted.

[Roberto Alsina (ralsina)]

Looks good to me!

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~facundo/ubuntuone-client/fix-path-retrieval into lp:ubuntuone-client failed. Below is the output from the failed tests.

/usr/bin/gnome-autogen.sh
checking for autoconf >= 2.53...
  testing autoconf2.50... not found.
  testing autoconf... found 2.69
checking for automake >= 1.10...
  testing automake-1.12... not found.
  testing automake-1.11... found 1.11.6
checking for libtool >= 1.5...
  testing libtoolize... found 2.4.2
checking for intltool >= 0.30...
  testing intltoolize... found 0.50.2
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.26
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.18
Checking for required M4 macros...
Checking for forbidden M4 macros...
Processing ./configure.ac
Running libtoolize...
libtoolize: putting auxiliary files in `.'.
libtoolize: copying file `./ltmain.sh'
libtoolize: putting macros in AC_CONFIG_MACRO_DIR, `m4'.
libtoolize: copying file `m4/libtool.m4'
libtoolize: copying file `m4/ltoptions.m4'
libtoolize: copying file `m4/ltsugar.m4'
libtoolize: copying file `m4/ltversion.m4'
libtoolize: copying file `m4/lt~obsolete.m4'
Running intltoolize...
Running gtkdocize...
Running aclocal-1.11...
Running autoconf...
Running autoheader...
Running automake-1.11...
Running ./configure --enable-gtk-doc --enable-debug ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking how to create a ustar tar archive... gnutar
checking whether make supports nested variables... yes
checking for style of include used by make... GNU
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for library containing strerror... none required
checking for gcc... (cached) gcc
checking whether we are using the GNU C compiler... (cached) yes
checking whether gcc accepts -g... (cached) yes
checking for gcc option to accept ISO C89... (cached) none needed
checking dependency style of gcc... (cached) gcc3
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking how to print strings... printf
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the she...

[lp:~facundo/ubuntuone-client/fix-path-retrieval]

1261. By Facundo Batista on 2012-10-03

Make lint happy

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2012-09-14 21:03:24 +0000
+++ contrib/testing/testcase.py	2012-10-03 19:37:22 +0000
@@ -146,7 +146,7 @@
         self.eq = self.event_queue = eq
         self.uuid_map = action_queue.DeferredMap()
         self.queue = action_queue.RequestQueue(self)
-        self.pathlock = action_queue.PathLockingTree()
+        self.pathlock = FakedObject()
 
         # throttling attributes
         self.readLimit = None
 
=== modified file 'tests/platform/linux/eventlog/test_zg_listener.py'
--- tests/platform/linux/eventlog/test_zg_listener.py	2012-04-09 20:07:05 +0000
+++ tests/platform/linux/eventlog/test_zg_listener.py	2012-10-03 19:37:22 +0000
@@ -574,7 +574,7 @@
         self.share_id = ""
         self.command = MyUpload(request_queue, share_id=self.share_id,
                                 node_id='a_node_id', previous_hash='prev_hash',
-                                hash='yadda', crc32=0, size=0, path='path')
+                                hash='yadda', crc32=0, size=0, mdid='mdid')
         self.command.make_logger()
         self.command.tempfile = FakeTempFile(self.mktemp('tmpdir'))
         self.fsm = self.action_queue.main.fs
 
=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2012-09-07 19:32:21 +0000
+++ tests/syncdaemon/test_action_queue.py	2012-10-03 19:37:22 +0000
@@ -2778,7 +2778,7 @@
         self.rq = request_queue = RequestQueue(action_queue=self.action_queue)
         self.command = Download(request_queue, share_id='a_share_id',
                                node_id='a_node_id', server_hash='server_hash',
-                               path='path')
+                               mdid='mdid')
         self.command.make_logger()
 
     def test_progress_information_setup(self):
@@ -2809,14 +2809,15 @@
 
         self.rq = RequestQueue(action_queue=self.action_queue)
         self.rq.transfers_semaphore = FakeSemaphore()
+        self.test_path = os.path.join(self.root, 'file')
+        self.mdid = self.main.fs.create(self.test_path, '')
 
         class MyDownload(Download):
             """Just to allow monkeypatching."""
             sync = lambda s: None
         self.command = MyDownload(self.rq, share_id='a_share_id',
                                   node_id='a_node_id',
-                                  server_hash='server_hash',
-                                  path= os.path.join(os.path.sep, 'foo', 'bar'))
+                                  server_hash='server_hash', mdid=self.mdid)
         self.command.make_logger()
         self.rq.waiting.append(self.command)
 
@@ -2916,23 +2917,25 @@
         self.patch(PathLockingTree, 'acquire',
                    lambda s, *a, **k: t.extend((a, k)))
         self.command._acquire_pathlock()
-        self.assertEqual(t, [("", "foo", "bar"), {'logger': self.command.log}])
+        should = [tuple(self.test_path.split(os.path.sep)),
+                  {'logger': self.command.log}]
+        self.assertEqual(t, should)
 
     def test_upload_download_uniqueness(self):
         """There should be only one upload/download for a specific node."""
         # totally fake, we don't care: the messages are only validated on run
-        self.action_queue.download('foo', 'bar', 0, 'path')
+        self.action_queue.download('foo', 'bar', 0, self.mdid)
         first_cmd = self.action_queue.queue.waiting[0]
-        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, 'path')
+        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, self.mdid)
         self.assertTrue(first_cmd.cancelled)
 
     def test_uniqueness_upload(self):
         """There should be only one upload/download for a specific node."""
         # totally fake, we don't care: the messages are only validated on run
         self.patch(Upload, 'run', lambda self: defer.Deferred())
-        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, 'path')
+        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, self.mdid)
         first_cmd = self.action_queue.queue.waiting[0]
-        self.action_queue.download('foo', 'bar', 0, 'path')
+        self.action_queue.download('foo', 'bar', 0, self.mdid)
         self.assertTrue(first_cmd.cancelled)
         self.assertTrue(self.handler.check_debug("Previous command cancelled",
                                                  "Upload", "foo", "bar"))
@@ -2940,32 +2943,32 @@
     def test_uniqueness_download(self):
         """There should be only one upload/download for a specific node."""
         # totally fake, we don't care: the messages are only validated on run
-        self.action_queue.download('foo', 'bar', 0, 'path0')
+        self.action_queue.download('foo', 'bar', 0, self.mdid)
         first_cmd = self.action_queue.queue.waiting[0]
-        self.action_queue.download('foo', 'bar', 1, 'path1')
+        self.action_queue.download('foo', 'bar', 1, self.mdid)
         self.assertTrue(first_cmd.cancelled)
         self.assertTrue(self.handler.check_debug("Previous command cancelled",
                                                  "Download", "foo", "bar"))
 
     def test_uniqueness_even_with_markers(self):
         """Only one upload/download per node, even using markers."""
-        mdid = self.main.fs.create(os.path.join(self.root, 'file'), '')
+        mdid = self.main.fs.create(os.path.join(self.root, 'file2'), '')
         m = MDMarker(mdid)
-        self.action_queue.download('share', m, 0, 'path')
+        self.action_queue.download('share', m, 0, mdid)
         first_cmd = self.action_queue.queue.waiting[0]
         self.action_queue.uuid_map.set(mdid, 'bah')
-        self.action_queue.download('share', 'bah', 0, 'path')
+        self.action_queue.download('share', 'bah', 0, self.mdid)
         self.assertTrue(first_cmd.cancelled)
 
     def test_uniqueness_tried_to_cancel_but_no(self):
         """Previous command didn't cancel even if we tried it."""
         # the first command will refuse to cancel (patch the class because
         # the instance is not patchable)
-        self.action_queue.download('foo', 'bar', 0, 'path0')
+        self.action_queue.download('foo', 'bar', 0, self.mdid)
         self.action_queue.queue.waiting[0]
         self.patch(Download, 'cancel', lambda instance: False)
 
-        self.action_queue.download('foo', 'bar', 1, 'path1')
+        self.action_queue.download('foo', 'bar', 1, self.mdid)
         self.assertEqual(len(self.action_queue.queue.waiting), 2)
         self.assertTrue(self.handler.check_debug("Tried to cancel", "couldn't",
                                                  "Download", "foo", "bar"))
@@ -3093,7 +3096,7 @@
         self.rq = request_queue = RequestQueue(action_queue=self.action_queue)
         self.command = Upload(request_queue, share_id='a_share_id',
                               node_id='a_node_id', previous_hash='prev_hash',
-                              hash='yadda', crc32=0, size=0, path='path')
+                              hash='yadda', crc32=0, size=0, mdid='mdid')
         self.command.make_logger()
         self.command.magic_hash = FakeMagicHash()
         self.client = FakeClient()
@@ -3228,6 +3231,8 @@
         self.rq.transfers_semaphore = FakeSemaphore()
         self.rq.unqueue = lambda c: None
         self.rq.active = True
+        self.test_path = os.path.join(self.root, 'foo', 'bar')
+        self.mdid = self.main.fs.create(self.test_path, '')
 
         class MyUpload(Upload):
             """Just to allow monkeypatching."""
@@ -3235,8 +3240,7 @@
         self.share_id = str(uuid.uuid4())
         self.command = MyUpload(self.rq, share_id=self.share_id,
                                 node_id='a_node_id', previous_hash='prev_hash',
-                                hash='yadda', crc32=0, size=0,
-                                path=os.path.join(os.path.sep, 'foo', 'bar'))
+                                hash='yadda', crc32=0, size=0, mdid=self.mdid)
         self.command.make_logger()
 
     @defer.inlineCallbacks
@@ -3251,11 +3255,12 @@
         # mock fsm
         mocker = Mocker()
         mdobj = mocker.mock()
-        expect(mdobj.mdid).result('mdid')
+        expect(mdobj.share_id).result('share_id')
+        expect(mdobj.path).result('path')
         fsm = mocker.mock()
-        expect(fsm.get_by_node_id(self.command.share_id, self.command.node_id)
-               ).result(mdobj)
-        expect(fsm.open_file('mdid')).result(StringIO())
+        expect(fsm.get_by_mdid(self.mdid)).result(mdobj)
+        expect(fsm.get_abspath('share_id', 'path')).result('/abs/path')
+        expect(fsm.open_file(self.mdid)).result(StringIO())
         self.patch(self.main, 'fs', fsm)
 
         # first fails with UploadInProgress, then finishes ok
@@ -3494,15 +3499,17 @@
         self.patch(PathLockingTree, 'acquire',
                    lambda s, *a, **k: t.extend((a, k)))
         self.command._acquire_pathlock()
-        self.assertEqual(t, [("", "foo", "bar"), {'logger': self.command.log}])
+        should = [tuple(self.test_path.split(os.path.sep)),
+                  {'logger': self.command.log}]
+        self.assertEqual(t, should)
 
     def test_uniqueness_upload(self):
         """There should be only one upload/download for a specific node."""
         # totally fake, we don't care: the messages are only validated on run
         self.patch(Upload, 'run', lambda self: defer.Deferred())
-        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, 'path0')
+        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, self.mdid)
         first_cmd = self.action_queue.queue.waiting[0]
-        self.action_queue.upload('foo', 'bar', 1, 1, 1, 1, 'path1')
+        self.action_queue.upload('foo', 'bar', 1, 1, 1, 1, self.mdid)
         self.assertTrue(first_cmd.cancelled)
         self.assertTrue(self.handler.check_debug("Previous command cancelled",
                                                  "Upload", "foo", "bar"))
@@ -3510,9 +3517,9 @@
     def test_uniqueness_download(self):
         """There should be only one upload/download for a specific node."""
         # totally fake, we don't care: the messages are only validated on run
-        self.action_queue.download('foo', 'bar', 0, 'path')
+        self.action_queue.download('foo', 'bar', 0, self.mdid)
         first_cmd = self.action_queue.queue.waiting[0]
-        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, 'path')
+        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, self.mdid)
         self.assertTrue(first_cmd.cancelled)
         self.assertTrue(self.handler.check_debug("Previous command cancelled",
                                                  "Download", "foo", "bar"))
@@ -3521,21 +3528,21 @@
         """Only one upload/download per node, even using markers."""
         mdid = self.main.fs.create(os.path.join(self.root, 'file'), '')
         m = MDMarker(mdid)
-        self.action_queue.download('share', m, 0, 'path')
+        self.action_queue.download('share', m, 0, self.mdid)
         first_cmd = self.action_queue.queue.waiting[0]
         self.action_queue.uuid_map.set(mdid, 'bah')
-        self.action_queue.upload('share', 'bah', 0, 0, 0, 0, 'path')
+        self.action_queue.upload('share', 'bah', 0, 0, 0, 0, self.mdid)
         self.assertTrue(first_cmd.cancelled)
 
     def test_uniqueness_tried_to_cancel_but_no(self):
         """Previous command didn't cancel even if we tried it."""
         # the first command will refuse to cancel
         self.patch(Upload, 'run', lambda self: defer.Deferred())
-        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, 'path0', StringIO)
+        self.action_queue.upload('foo', 'bar', 0, 0, 0, 0, self.mdid, StringIO)
         self.action_queue.queue.waiting[0]
         self.patch(Upload, 'cancel', lambda instance: False)
 
-        self.action_queue.upload('foo', 'bar', 1, 1, 1, 1, 'path1', StringIO)
+        self.action_queue.upload('foo', 'bar', 1, 1, 1, 1, self.mdid, StringIO)
         self.assertEqual(len(self.action_queue.queue.waiting), 2)
         self.assertTrue(self.handler.check_debug("Tried to cancel", "couldn't",
                                                  "Upload", "foo", "bar"))
@@ -4866,11 +4873,13 @@
         t = []
         self.patch(PathLockingTree, 'acquire',
                    lambda s, *a, **k: t.extend((a, k)))
-        cmd = MakeFile(self.rq, VOLUME, 'parent', 'name', 'marker',
-                       os.path.join('foo','bar'))
+        path = os.path.join(self.root, 'file')
+        mdid = self.main.fs.create(path, '')
+        cmd = MakeFile(self.rq, VOLUME, 'parent', 'name', 'marker', mdid)
         cmd._acquire_pathlock()
-        self.assertEqual(t, [('foo', 'bar'), {'on_parent': True,
-                                              'logger': None}])
+        should = [tuple(path.split(os.path.sep)),
+                  {'on_parent': True, 'logger': None}]
+        self.assertEqual(t, should)
 
 
 class MakeDirTestCase(ConnectedBaseTestCase):
@@ -4929,11 +4938,13 @@
         t = []
         self.patch(PathLockingTree, 'acquire',
                    lambda s, *a, **k: t.extend((a, k)))
-        cmd = MakeDir(self.rq, VOLUME, 'parent', 'name', 'marker',
-                      os.path.join('foo','bar'))
+        path = os.path.join(self.root, 'file')
+        mdid = self.main.fs.create(path, '')
+        cmd = MakeDir(self.rq, VOLUME, 'parent', 'name', 'marker', mdid)
         cmd._acquire_pathlock()
-        self.assertEqual(t, [('foo', 'bar'), {'on_parent': True,
-                                              'logger': None}])
+        should = [tuple(path.split(os.path.sep)),
+                  {'on_parent': True, 'logger': None}]
+        self.assertEqual(t, should)
 
 
 class TestDeltaList(unittest.TestCase):
@@ -5491,9 +5502,10 @@
         The semaphore lock must be released! Of course, this test is on
         download/upload commands.
         """
+        mdid = self.main.fs.create(os.path.join(self.root, 'file'), '')
         cmd = Upload(self.queue, share_id='a_share_id', node_id='a_node_id',
                      previous_hash='prev_hash', hash='yadda', crc32=0, size=0,
-                     path='path')
+                     mdid=mdid)
         cmd.make_logger()
 
         # patch the command to simulate a request to an already full
 
=== modified file 'tests/syncdaemon/test_localrescan.py'
--- tests/syncdaemon/test_localrescan.py	2012-04-09 20:08:42 +0000
+++ tests/syncdaemon/test_localrescan.py	2012-10-03 19:37:22 +0000
@@ -1531,7 +1531,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         self.assertEqual(self.aq.uploaded[0][:7],
                          (mdobj.share_id, mdobj.node_id, mdobj.server_hash,
-                          mdobj.local_hash, mdobj.crc32, mdobj.size, path))
+                          mdobj.local_hash, mdobj.crc32, mdobj.size, mdid))
         self.assertEqual(self.aq.uploaded[1], {'upload_id':None})
         self.assertTrue(self.handler.check_debug("resuming upload",
                                                  "interrupted"))
@@ -1580,7 +1580,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         self.assertEqual(self.aq.uploaded[0][:7],
                          (mdobj.share_id, mdobj.node_id, mdobj.server_hash,
-                          mdobj.local_hash, mdobj.crc32, mdobj.size, path))
+                          mdobj.local_hash, mdobj.crc32, mdobj.size, mdid))
         self.assertEqual(self.aq.uploaded[1], {'upload_id':'hola'})
         self.assertTrue(self.handler.check_debug("resuming upload",
                                                  "interrupted"))
@@ -1608,7 +1608,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         self.assertEqual(self.aq.downloaded[:4],
                          (mdobj.share_id, mdobj.node_id,
-                          mdobj.server_hash, path))
+                          mdobj.server_hash, mdid))
         self.assertTrue(self.handler.check_debug("comp yield", "SERVER"))
 
     @defer.inlineCallbacks
@@ -1632,7 +1632,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         self.assertEqual(self.aq.downloaded[:4],
                          (mdobj.share_id, mdobj.node_id,
-                          mdobj.server_hash, path))
+                          mdobj.server_hash, mdid))
         self.assertTrue(self.handler.check_debug("comp yield", "SERVER"))
 
     @defer.inlineCallbacks
@@ -1958,7 +1958,7 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         self.assertEqual(self.aq.downloaded[:4],
                          (mdobj.share_id, mdobj.node_id,
-                          mdobj.server_hash, path))
+                          mdobj.server_hash, mdid))
         self.assertTrue(self.handler.check_debug("comp yield", "SERVER"))
 
     @defer.inlineCallbacks
 
=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2012-09-25 13:36:26 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2012-10-03 19:37:22 +0000
@@ -1206,13 +1206,13 @@
             command_class = self.commands[command_class_name]
             yield self._really_execute(command_class, *args, **kwargs)
 
-    def make_file(self, share_id, parent_id, name, marker, path):
+    def make_file(self, share_id, parent_id, name, marker, mdid):
         """See .interfaces.IMetaQueue."""
-        self.execute(MakeFile, share_id, parent_id, name, marker, path)
+        self.execute(MakeFile, share_id, parent_id, name, marker, mdid)
 
-    def make_dir(self, share_id, parent_id, name, marker, path):
+    def make_dir(self, share_id, parent_id, name, marker, mdid):
         """See .interfaces.IMetaQueue."""
-        self.execute(MakeDir, share_id, parent_id, name, marker, path)
+        self.execute(MakeDir, share_id, parent_id, name, marker, mdid)
 
     def move(self, share_id, node_id, old_parent_id, new_parent_id,
              new_name, path_from, path_to):
@@ -1270,15 +1270,15 @@
         """See .interfaces.IMetaQueue."""
         self.execute(GetPublicFiles)
 
-    def download(self, share_id, node_id, server_hash, path):
+    def download(self, share_id, node_id, server_hash, mdid):
         """See .interfaces.IContentQueue.download."""
-        self.execute(Download, share_id, node_id, server_hash, path)
+        self.execute(Download, share_id, node_id, server_hash, mdid)
 
     def upload(self, share_id, node_id, previous_hash, hash, crc32,
-               size, path, upload_id=None):
+               size, mdid, upload_id=None):
         """See .interfaces.IContentQueue."""
         self.execute(Upload, share_id, node_id, previous_hash, hash, crc32,
-                     size, path, upload_id=upload_id)
+                     size, mdid, upload_id=upload_id)
 
     def _cancel_op(self, share_id, node_id, cmdclass):
         """Generalized form of cancel_upload and cancel_download."""
@@ -1575,6 +1575,13 @@
         self.finish()
         return True
 
+    def _get_current_path(self, mdid):
+        """Get current path from FSM using the mdid."""
+        fsm = self.action_queue.main.fs
+        mdobj = fsm.get_by_mdid(self.mdid)
+        path = fsm.get_abspath(mdobj.share_id, mdobj.path)
+        return path
+
     def _acquire_pathlock(self):
         """Acquire pathlock; overwrite if needed."""
         return defer.succeed(None)
@@ -1603,11 +1610,11 @@
 class MakeThing(ActionQueueCommand):
     """Base of MakeFile and MakeDir."""
 
-    __slots__ = ('share_id', 'parent_id', 'name', 'marker', 'path')
+    __slots__ = ('share_id', 'parent_id', 'name', 'marker', 'mdid')
     logged_attrs = ActionQueueCommand.logged_attrs + __slots__
     possible_markers = 'parent_id',
 
-    def __init__(self, request_queue, share_id, parent_id, name, marker, path):
+    def __init__(self, request_queue, share_id, parent_id, name, marker, mdid):
         super(MakeThing, self).__init__(request_queue)
         self.share_id = share_id
         self.parent_id = parent_id
@@ -1615,7 +1622,7 @@
         # here we use bytes for paths
         self.name = name.decode("utf-8")
         self.marker = marker
-        self.path = path
+        self.mdid = mdid
 
     def _run(self):
         """Do the actual running."""
@@ -1640,8 +1647,9 @@
 
     def _acquire_pathlock(self):
         """Acquire pathlock."""
+        curr_path = self._get_current_path(self.mdid)
         pathlock = self.action_queue.pathlock
-        return pathlock.acquire(*self.path.split(os.path.sep), on_parent=True,
+        return pathlock.acquire(*curr_path.split(os.path.sep), on_parent=True,
                                                                logger=self.log)
 
 
@@ -1678,6 +1686,10 @@
         # Unicode boundary! the name is Unicode in protocol and server, but
         # here we use bytes for paths
         self.new_name = new_name.decode("utf-8")
+
+        # Move stores the paths and uses them to acquire the pathlock
+        # later, as it is responsible of the moves and nobody else
+        # will rename the files but it
         self.path_from = path_from
         self.path_to = path_to
 
@@ -1751,6 +1763,8 @@
         self.share_id = share_id
         self.node_id = node_id
         self.parent_id = parent_id
+        # Unlink stores the path here for the pathlock as it will not change
+        # in the future (nobody will rename a deleted file)
         self.path = path
         self.is_dir = is_dir
 
@@ -2348,20 +2362,20 @@
     """Get the contents of a file."""
 
     __slots__ = ('share_id', 'node_id', 'server_hash',
-                 'fileobj', 'gunzip', 'path', 'download_req', 'tx_semaphore',
+                 'fileobj', 'gunzip', 'mdid', 'download_req', 'tx_semaphore',
                  'deflated_size', 'n_bytes_read_last', 'n_bytes_read')
     logged_attrs = ActionQueueCommand.logged_attrs + (
-                    'share_id', 'node_id', 'server_hash', 'path')
+                    'share_id', 'node_id', 'server_hash', 'mdid')
     possible_markers = 'node_id',
 
-    def __init__(self, request_queue, share_id, node_id, server_hash, path):
+    def __init__(self, request_queue, share_id, node_id, server_hash, mdid):
         super(Download, self).__init__(request_queue)
         self.share_id = share_id
         self.node_id = node_id
         self.server_hash = server_hash
         self.fileobj = None
         self.gunzip = None
-        self.path = path
+        self.mdid = mdid
         self.download_req = None
         self.n_bytes_read = 0
         self.n_bytes_read_last = 0
@@ -2390,8 +2404,9 @@
 
     def _acquire_pathlock(self):
         """Acquire pathlock."""
+        curr_path = self._get_current_path(self.mdid)
         pathlock = self.action_queue.pathlock
-        return pathlock.acquire(*self.path.split(os.path.sep), logger=self.log)
+        return pathlock.acquire(*curr_path.split(os.path.sep), logger=self.log)
 
     def cancel(self):
         """Cancel the download."""
@@ -2514,18 +2529,18 @@
 
     __slots__ = ('share_id', 'node_id', 'previous_hash', 'hash', 'crc32',
                  'size', 'magic_hash', 'deflated_size', 'tempfile',
-                 'tx_semaphore', 'n_bytes_written_last', 'path', 'upload_req',
-                 'n_bytes_written', 'upload_id')
+                 'tx_semaphore', 'n_bytes_written_last', 'upload_req',
+                 'n_bytes_written', 'upload_id', 'mdid')
 
     logged_attrs = ActionQueueCommand.logged_attrs + (
                     'share_id', 'node_id', 'previous_hash', 'hash', 'crc32',
-                    'size', 'upload_id', 'path')
+                    'size', 'upload_id', 'mdid')
     retryable_errors = ActionQueueCommand.retryable_errors + (
                                         protocol_errors.UploadInProgressError,)
     possible_markers = 'node_id',
 
     def __init__(self, request_queue, share_id, node_id, previous_hash, hash,
-                 crc32, size, path, upload_id=None):
+                 crc32, size, mdid, upload_id=None):
         super(Upload, self).__init__(request_queue)
         self.share_id = share_id
         self.node_id = node_id
@@ -2535,7 +2550,7 @@
         self.size = size
         self.upload_id = upload_id
         self.tempfile = None
-        self.path = path
+        self.mdid = mdid
         self.upload_req = None
         self.n_bytes_written_last = 0
         self.n_bytes_written = 0
@@ -2579,8 +2594,9 @@
 
     def _acquire_pathlock(self):
         """Acquire pathlock."""
+        curr_path = self._get_current_path(self.mdid)
         pathlock = self.action_queue.pathlock
-        return pathlock.acquire(*self.path.split(os.path.sep), logger=self.log)
+        return pathlock.acquire(*curr_path.split(os.path.sep), logger=self.log)
 
     def cancel(self):
         """Cancel the upload."""
@@ -2614,8 +2630,7 @@
         self.log.debug('semaphore acquired')
 
         fsm = self.action_queue.main.fs
-        mdobj = fsm.get_by_node_id(self.share_id, self.node_id)
-        fileobj_factory = lambda: fsm.open_file(mdobj.mdid)
+        fileobj_factory = lambda: fsm.open_file(self.mdid)
         yield self.action_queue.zip_queue.zip(self, fileobj_factory)
 
     def finish(self):
 
=== modified file 'ubuntuone/syncdaemon/local_rescan.py'
--- ubuntuone/syncdaemon/local_rescan.py	2012-04-09 20:08:42 +0000
+++ ubuntuone/syncdaemon/local_rescan.py	2012-10-03 19:37:22 +0000
@@ -364,7 +364,7 @@
         """Resume an interrupted download."""
         mdobj = self.fsm.get_by_path(fullname)
         self.aq.download(mdobj.share_id, mdobj.node_id,
-                         mdobj.server_hash, fullname)
+                         mdobj.server_hash, mdobj.mdid)
 
     def _resume_upload(self, fullname):
         """Resume an interrupted upload."""
@@ -372,7 +372,7 @@
         upload_id = getattr(mdobj, 'upload_id', None)
         self.aq.upload(mdobj.share_id, mdobj.node_id, mdobj.server_hash,
                        mdobj.local_hash, mdobj.crc32, mdobj.size,
-                       fullname, upload_id=upload_id)
+                       mdobj.mdid, upload_id=upload_id)
 
     def check_stat(self, fullname, oldstat):
         """Check stat info and return if different.
 
=== modified file 'ubuntuone/syncdaemon/sync.py'
--- ubuntuone/syncdaemon/sync.py	2012-09-14 21:03:24 +0000
+++ ubuntuone/syncdaemon/sync.py	2012-10-03 19:37:22 +0000
@@ -467,16 +467,15 @@
         self.key.delete_metadata()
         self.new_file(event, params, share_id, node_id, parent_id, name)
 
-    def get_file(self, event, params, hash):
+    def get_file(self, event, params, server_hash):
         """Get the contents for the file."""
-        self.key.set(server_hash=hash)
+        self.key.set(server_hash=server_hash)
         self.key.sync()
         share_id = self.key['share_id']
         node_id = self.key['node_id']
-        path = self.key['path']
+        mdid = self.key['mdid']
         self.m.fs.create_partial(node_id=node_id, share_id=share_id)
-        self.m.action_q.download(share_id=share_id, node_id=node_id,
-                                 server_hash=hash, path=path)
+        self.m.action_q.download(share_id, node_id, server_hash, mdid)
 
     def reget_file(self, event, params, hash):
         """cancel and reget this download."""
@@ -545,8 +544,9 @@
         self.key.set(server_hash=empty_hash)
         self.key.sync()
         name = os.path.basename(path)
-        marker = MDMarker(self.key.get_mdid())
-        self.m.action_q.make_file(share_id, parent_id, name, marker, path)
+        mdid = self.key.get_mdid()
+        marker = MDMarker(mdid)
+        self.m.action_q.make_file(share_id, parent_id, name, marker, mdid)
 
     def release_marker_ok(self, event, parms, new_id, marker):
         """Release ok the received marker in AQ's DeferredMap."""
@@ -578,7 +578,7 @@
         name = os.path.basename(path)
         mdid = self.key.get_mdid()
         marker = MDMarker(mdid)
-        self.m.action_q.make_dir(share_id, parent_id, name, marker, path)
+        self.m.action_q.make_dir(share_id, parent_id, name, marker, mdid)
         self.m.lr.scan_dir(mdid, path)
 
     def new_local_dir_created(self, event, parms, new_id, marker):
@@ -599,29 +599,30 @@
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
                                       node_id=self.key['node_id'])
 
+        mdid = self.key.get_mdid()
         local_hash = self.key['local_hash']
         previous_hash = self.key['server_hash']
         crc32 = self.key['crc32']
         size = self.key['size']
         share_id = self.key['share_id']
         node_id = self.key['node_id']
-        path = self.key['path']
         upload_id = self.key.get('upload_id')
 
         self.m.action_q.upload(share_id, node_id, previous_hash, local_hash,
-                               crc32, size, path, upload_id=upload_id)
+                               crc32, size, mdid, upload_id=upload_id)
 
-    def put_file(self, event, params, hash, crc32, size, stat):
+    def put_file(self, event, params, current_hash, crc32, size, stat):
         """Upload the file to the server."""
+        mdid = self.key.get_mdid()
+        share_id = self.key['share_id']
+        node_id = self.key['node_id']
         previous_hash = self.key['server_hash']
-        path = self.key['path']
         upload_id = self.key.get('upload_id')
-        self.key.set(local_hash=hash, stat=stat, crc32=crc32, size=size)
+        self.key.set(local_hash=current_hash, stat=stat, crc32=crc32, size=size)
         self.key.sync()
 
-        self.m.action_q.upload(share_id=self.key['share_id'],
-            node_id=self.key['node_id'], previous_hash=previous_hash,
-            hash=hash, crc32=crc32, size=size, path=path, upload_id=upload_id)
+        self.m.action_q.upload(share_id, node_id, previous_hash, current_hash,
+                               crc32, size, mdid, upload_id=upload_id)
 
     def converges_to_server(self, event, params, hash, crc32, size, stat):
         """the local changes now match the server"""
@@ -640,19 +641,21 @@
         self.key.sync()
         self.m.hash_q.insert(self.key['path'], self.key['mdid'])
 
-    def reput_file(self, event, param, hash, crc32, size, stat):
+    def reput_file(self, event, param, current_hash, crc32, size, stat):
         """Put the file again."""
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
                             node_id=self.key['node_id'])
         previous_hash = self.key['server_hash']
 
-        path = self.key['path']
+        share_id = self.key['share_id']
+        node_id = self.key['node_id']
         upload_id = self.key.get('upload_id')
-        self.key.set(local_hash=hash, stat=stat, crc32=crc32, size=size)
+        self.key.set(local_hash=current_hash, stat=stat,
+                      crc32=crc32, size=size)
         self.key.sync()
-        self.m.action_q.upload(share_id=self.key['share_id'],
-            node_id=self.key['node_id'], previous_hash=previous_hash,
-            hash=hash, crc32=crc32, size=size, path=path, upload_id=upload_id)
+        mdid = self.key.get_mdid()
+        self.m.action_q.upload(share_id, node_id, previous_hash, current_hash,
+                               crc32, size, mdid, upload_id=upload_id)
 
     def server_file_now_matches(self, event, params, hash):
         """We got a server hash that matches local hash"""