Merge lp:~alecu/ubuntuone-client/fix-zg-deletions into lp:ubuntuone-client

[Alejandro J. Cura]

Zeitgeist listener now assumes nodes are already gone when handling delete events (LP: #693545 and LP: #692730)

Make the zeitgeist listener assume that the node is already gone when handling the AQ_UNLINK_OK and SV_FILE_DELETED events.

[Manuel de la Peña (mandel)]

Looks great. Just a small style comment, in test_zg_listener.py, test_action_queue.py and test_sync.py there is a mix of using ' and " for strings. I'm sure the reason is that you always use " and eric and others always use '. Is not a big thing at all so the branch is certainly approved \o/

review: Approve

[lp:~alecu/ubuntuone-client/fix-zg-deletions]

922. By Alejandro J. Cura on 2011-03-17

signals should have a fixed signature

[Lucio Torre (lucio.torre)]

review: Approve

=== modified file 'tests/platform/linux/eventlog/test_zg_listener.py'
--- tests/platform/linux/eventlog/test_zg_listener.py	2011-02-23 17:24:12 +0000
+++ tests/platform/linux/eventlog/test_zg_listener.py	2011-03-17 18:46:30 +0000
@@ -713,11 +713,10 @@
         listen_for(self.main.event_q, 'AQ_UNLINK_OK', d.callback)
 
         path = os.path.join(self.main.vm.root.path, "filename.mp3")
-        self.main.fs.create(path, "")
-        self.main.fs.set_node_id(path, "node_id")
         self.main.event_q.push("AQ_UNLINK_OK", share_id="",
                                parent_id="parent_id",
-                               node_id="node_id", new_generation=13)
+                               node_id="node_id", new_generation=13,
+                               was_dir=False, old_path=path)
         yield d
 
         self.assertEqual(len(self.listener.zg.events), 1)
@@ -745,11 +744,10 @@
         listen_for(self.main.event_q, 'AQ_UNLINK_OK', d.callback)
 
         path = os.path.join(self.main.vm.root.path, "folder name")
-        self.main.fs.create(path, "", is_dir=True)
-        self.main.fs.set_node_id(path, "node_id")
         self.main.event_q.push("AQ_UNLINK_OK", share_id="",
                                parent_id="parent_id",
-                               node_id="node_id", new_generation=13)
+                               node_id="node_id", new_generation=13,
+                               was_dir=True, old_path=path)
         yield d
 
         self.assertEqual(len(self.listener.zg.events), 1)
@@ -969,11 +967,9 @@
 
         filename = self.filemp3delta.name.encode("utf-8")
         path = os.path.join(self.main.vm.root.path, filename)
-        self.main.fs.create(path, "")
-        self.main.fs.set_node_id(path, "node_id")
         self.main.event_q.push("SV_FILE_DELETED", volume_id="",
-                               node_id="node_id", is_dir=False)
-
+                               node_id="node_id", was_dir=False,
+                               old_path=path)
         yield d
 
         self.assertEqual(len(self.listener.zg.events), 1)
@@ -1002,10 +998,9 @@
         listen_for(self.main.event_q, 'SV_FILE_DELETED', d.callback)
 
         path = os.path.join(self.main.vm.root.path, "folder name")
-        self.main.fs.create(path, "", is_dir=True)
-        self.main.fs.set_node_id(path, "node_id")
         self.main.event_q.push("SV_FILE_DELETED", volume_id="",
-                               node_id="node_id", is_dir=True)
+                               node_id="node_id", was_dir=True,
+                               old_path=path)
 
         yield d
 

=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2011-03-11 19:43:35 +0000
+++ tests/syncdaemon/test_action_queue.py	2011-03-17 18:46:30 +0000
@@ -4386,25 +4386,48 @@
         self.rq = RequestQueue(action_queue=self.action_queue)
         return d
 
-    def test_handle_success_push_event(self):
-        """Test AQ_UNLINK_OK is pushed on success."""
-        # create a request and fill it with succesful information
-        request = client.Unlink(self.action_queue.client, VOLUME, 'node_id')
-        request.new_generation = 13
-
-        # create a command and trigger it success
-        cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id', 'path')
-        cmd.handle_success(request)
-
-        # check for successful event
-        received = self.action_queue.event_queue.events[0]
-        info = dict(share_id=VOLUME, parent_id='parent_id',
-                    node_id='node_id', new_generation=13)
+    def test_handle_success_push_event_file(self):
+        """Test AQ_UNLINK_OK is pushed on success for a file."""
+        sample_path = "sample path"
+        # create a request and fill it with succesful information
+        request = client.Unlink(self.action_queue.client, VOLUME, 'node_id')
+        request.new_generation = 13
+
+        # create a command and trigger it success
+        cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id', sample_path,
+                     False)
+        cmd.handle_success(request)
+
+        # check for successful event
+        received = self.action_queue.event_queue.events[0]
+        info = dict(share_id=VOLUME, parent_id='parent_id',
+                    node_id='node_id', new_generation=13,
+                    was_dir=False, old_path=sample_path)
+        self.assertEqual(received, ('AQ_UNLINK_OK', info))
+
+    def test_handle_success_push_event_directory(self):
+        """Test AQ_UNLINK_OK is pushed on success for a directory."""
+        # create a request and fill it with succesful information
+        request = client.Unlink(self.action_queue.client, VOLUME, 'node_id')
+        request.new_generation = 13
+
+        # create a command and trigger it success
+        cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id', 'test_path',
+                     True)
+        cmd.handle_success(request)
+
+        full_path = "test_path"
+
+        # check for successful event
+        received = self.action_queue.event_queue.events[0]
+        info = dict(share_id=VOLUME, parent_id='parent_id',
+                    node_id='node_id', new_generation=13,
+                    was_dir=True, old_path=full_path)
         self.assertEqual(received, ('AQ_UNLINK_OK', info))
 
     def test_possible_markers(self):
         """Test that it returns the correct values."""
-        cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id', 'path')
+        cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id', 'path', False)
         res = [getattr(cmd, x) for x in cmd.possible_markers]
         self.assertEqual(res, ['node_id', 'parent_id'])
 
@@ -4413,7 +4436,7 @@
         t = []
         self.patch(PathLockingTree, 'acquire',
                    lambda s, *a, **k: t.extend((a, k)))
-        cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id', 'foo/bar')
+        cmd = Unlink(self.rq, VOLUME, 'parent_id', 'node_id', 'foo/bar', False)
         cmd._acquire_pathlock()
         self.assertEqual(t, [('foo', 'bar'), {'on_parent': True,
                                               'on_children': True,

=== modified file 'tests/syncdaemon/test_fsm.py'
--- tests/syncdaemon/test_fsm.py	2011-02-28 15:26:29 +0000
+++ tests/syncdaemon/test_fsm.py	2011-03-17 18:46:30 +0000
@@ -610,9 +610,10 @@
         self.assertEqual(newmdobj.generation, None)
         # check that the trash is the same:
         self.assertEqual(self.fsm.trash,
-                         {("share", "uuid_1"): (mdid_1, "parent", path_1)})
+                         {("share", "uuid_1"):
+                                (mdid_1, "parent", path_1, False)})
         self.assertEqual(list(self.fsm.get_iter_trash()),
-                         [("share", "uuid_1", "parent", path_1)])
+                         [("share", "uuid_1", "parent", path_1, False)])
         # check the move limbo
         expected = [(("share", "uuid_1"),
                     ("old_parent", "new_parent", "new_name", "pfrom", "pto"))]
@@ -669,9 +670,10 @@
         self.assertEqual(newmdobj.generation, None)
         # check that the trash is the same:
         self.assertEqual(self.fsm.trash,
-                         {("share", "uuid_1"): (mdid_1, "parent", path_1)})
+                         {("share", "uuid_1"):
+                                (mdid_1, "parent", path_1, False)})
         self.assertEqual(list(self.fsm.get_iter_trash()),
-                         [("share", "uuid_1", "parent", path_1)])
+                         [("share", "uuid_1", "parent", path_1, False)])
         # check the move limbo
         expected = [(("share", "uuid_1"),
                     ("old_parent", "new_parent", "new_name", "pfrom", "pto"))]
@@ -2096,7 +2098,7 @@
         # check that the info for the overwritten one is gone to trash
         self.assert_no_metadata(mdid2, testfile1, "share", "uuid2")
         self.assertEqual(self.fsm.trash[(self.share.id, "uuid2")],
-                         (mdid2, self.share.node_id, testfile2))
+                         (mdid2, self.share.node_id, testfile2, False))
 
     def test_move_file_withdir(self):
         """Test that a dir is moved from one point to the other."""
@@ -2420,9 +2422,10 @@
         self.fsm.delete_to_trash(mdid, "parent")
         self.assertFalse(self.fsm.has_metadata(mdid=mdid))
         self.assertEqual(self.fsm.trash,
-                         {("share", "uuid"): (mdid, "parent", testfile)})
+                         {("share", "uuid"):
+                                (mdid, "parent", testfile, False)})
         self.assertEqual(list(self.fsm.get_iter_trash()),
-                         [("share", "uuid", "parent", testfile)])
+                         [("share", "uuid", "parent", testfile, False)])
         self.assertTrue(self.fsm.node_in_trash("share", "uuid"))
 
         # remove from trash
@@ -2432,11 +2435,18 @@
         self.assertEqual(list(self.fsm.get_iter_trash()), [])
         self.assertFalse(self.fsm.node_in_trash("share", "uuid"))
 
-    def test_trash_old(self):
-        """Test that get_iter_trash supports old trash."""
+    def test_trash_older(self):
+        """get_iter_trash supports older trash (no is_dir)."""
+        self.fsm.trash  = {("share", "uuid"): ("mdid", "parent", "path1")}
+        self.assertEqual(list(self.fsm.get_iter_trash()),
+                         [("share", "uuid", "parent", "path1", False)])
+
+    def test_trash_oldest(self):
+        """get_iter_trash supports oldest trash (no is_dir nor path)."""
         self.fsm.trash  = {("share", "uuid"): ("mdid", "parent")}
         self.assertEqual(list(self.fsm.get_iter_trash()),
-                         [("share", "uuid", "parent", "fake_unblocking_path")])
+                         [("share", "uuid", "parent", "fake_unblocking_path",
+                           False)])
 
     def test_trash_with_node_in_none(self):
         """Test that in trash is saved the marker if node_id is None."""
@@ -2448,7 +2458,8 @@
         self.fsm.delete_to_trash(mdid, "parent")
         marker = MDMarker(mdid)
         self.assertEqual(self.fsm.trash,
-                         {("share", marker): (mdid, "parent", testfile)})
+                         {("share", marker):
+                                (mdid, "parent", testfile, False)})
 
     def test_dereference_ok_limbos_none(self):
         """Limbos' markers ok dereferencing is fine if no marker at all."""

=== modified file 'tests/syncdaemon/test_localrescan.py'
--- tests/syncdaemon/test_localrescan.py	2011-03-07 15:11:57 +0000
+++ tests/syncdaemon/test_localrescan.py	2011-03-17 18:46:30 +0000
@@ -2253,7 +2253,8 @@
             """Check."""
             self.assertEqual(self.aq.moved, [])
             self.assertEqual(self.aq.unlinked, [(self.share.volume_id,
-                                                 "parent_id", "uuid", path)])
+                                                 "parent_id", "uuid", path,
+                                                 True)])
             self.assertTrue(self.handler.check_info(
                             "generating Unlink from trash"))
 
@@ -2276,8 +2277,8 @@
             """Check."""
             self.assertEqual(self.aq.moved, [])
             self.assertEqual(sorted(self.aq.unlinked), [
-                (self.share.volume_id, "parent_id", "uuid1", path1),
-                (self.share.volume_id, "parent_id", "uuid2", path2),
+                (self.share.volume_id, "parent_id", "uuid1", path1, True),
+                (self.share.volume_id, "parent_id", "uuid2", path2, False),
             ])
 
         self.startTest(check)
@@ -2383,7 +2384,8 @@
                              [("share", "uuid", "old_parent", "new_parent",
                                "new_name", "p_from", "p_to")])
             self.assertEqual(self.aq.unlinked, [(self.share.volume_id,
-                                                 "parent_id", "uuid", path)])
+                                                 "parent_id", "uuid", path,
+                                                 True)])
 
         self.startTest(check)
         return self.deferred

=== modified file 'tests/syncdaemon/test_sync.py'
--- tests/syncdaemon/test_sync.py	2011-02-25 12:08:58 +0000
+++ tests/syncdaemon/test_sync.py	2011-03-17 18:46:30 +0000
@@ -824,6 +824,182 @@
         self.assertEqual(result, 'new_id')
         self.assertEqual(called, [('marker', 'new_id')])
 
+    def test_file_delete_on_server_sends_is_dir(self):
+        """delete_on_server sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=False)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.delete_on_server(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, False))
+
+    def test_folder_delete_on_server_sends_is_dir(self):
+        """delete_on_server sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=True)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.delete_on_server(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, True))
+
+    def test_file_deleted_dir_while_downloading_sends_is_dir(self):
+        """Deleted parent while file is downloading sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=False)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        self.patch(FSKey, "remove_partial", lambda o: None)
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "cancel_download",
+                   lambda share_id, node_id: None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.deleted_dir_while_downloading(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, False))
+
+    def test_folder_deleted_dir_while_downloading_sends_is_dir(self):
+        """Deleted parent while dir is downloading sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=True)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        self.patch(FSKey, "remove_partial", lambda o: None)
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "cancel_download",
+                   lambda share_id, node_id: None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.deleted_dir_while_downloading(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, True))
+
+    def test_file_cancel_download_and_delete_on_server_sends_is_dir(self):
+        """cancel_download_and_delete_on_server sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=False)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        self.patch(FSKey, "remove_partial", lambda o: None)
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "cancel_download",
+                   lambda share_id, node_id: None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.cancel_download_and_delete_on_server(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, False))
+
+    def test_folder_cancel_download_and_delete_on_server_sends_is_dir(self):
+        """cancel_download_and_delete_on_server sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=True)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        self.patch(FSKey, "remove_partial", lambda o: None)
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "cancel_download",
+                   lambda share_id, node_id: None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.cancel_download_and_delete_on_server(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, True))
+
+    def test_file_cancel_upload_and_delete_on_server_sends_is_dir(self):
+        """cancel_upload_and_delete_on_server sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=False)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "cancel_download",
+                   lambda share_id, node_id: None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.cancel_upload_and_delete_on_server(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, False))
+
+    def test_folder_cancel_upload_and_delete_on_server_sends_is_dir(self):
+        """cancel_upload_and_delete_on_server sends the is_dir flag."""
+        somepath = os.path.join(self.root, 'foo')
+        mdid = self.fsm.create(somepath, '', is_dir=True)
+
+        # patch to control the call to key
+        called = []
+
+        # create context and call
+        key = FSKey(self.main.fs, path=somepath)
+        ssmr = SyncStateMachineRunner(fsm=self.fsm, main=self.main,
+                                      key=key, logger=None)
+        self.patch(self.main.action_q, "cancel_download",
+                   lambda share_id, node_id: None)
+        self.patch(self.main.action_q, "unlink",
+                   lambda *args: called.append(args))
+
+        ssmr.cancel_upload_and_delete_on_server(None, None, somepath)
+
+        # check
+        self.assertEqual(called[0][-3:], (mdid, somepath, True))
+
     @defer.inlineCallbacks
     def test_filedir_error_in_creation(self):
         """Conflict and delete metada, and release the marker with error."""
@@ -1012,7 +1188,7 @@
                    lambda s, *a: called.append(a))
 
         d = dict(share_id='volume_id', node_id='node_id', parent_id='parent',
-                 new_generation=77)
+                 new_generation=77, was_dir=False, old_path="test path")
         self.sync.handle_AQ_UNLINK_OK(**d)
         self.assertEqual(called, [('volume_id', "node_id", 77)])
 
@@ -1643,7 +1819,7 @@
             (ROOT, self.dirdelta.node_id, True)])
 
 
-class TestSyncEvents(BaseSync):
+class TestSyncEvents(TestSyncDelta):
     """Testing sync stuff related to events."""
 
     def setUp(self):
@@ -1662,33 +1838,34 @@
     def test_server_new_file_sends_event(self):
         """When a new file is created on the server, an event is sent."""
         # create the fake file
-        self.main.vm._got_root("parent_id")
-        self.sync._handle_SV_FILE_NEW(ROOT, "node_id", "parent_id", "file")
+        parent_id = self.root_id
+        self.sync._handle_SV_FILE_NEW(ROOT, "node_id", parent_id, "file")
 
         # check event
-        kwargs = dict(volume_id=ROOT, node_id='node_id', parent_id="parent_id",
+        kwargs = dict(volume_id=ROOT, node_id='node_id', parent_id=parent_id,
                       name="file")
         self.assertIn(("SV_FILE_NEW", kwargs), self.listener.events)
 
     def test_server_new_dir_sends_event(self):
         """When a new directory is created on the server, an event is sent."""
-
         # create the fake dir
-        self.main.vm._got_root("parent_id")
-        self.sync._handle_SV_DIR_NEW(ROOT, "node_id", "parent_id", "file")
+        parent_id = self.root_id
+        self.sync._handle_SV_DIR_NEW(ROOT, "node_id", parent_id, "file")
 
         # check event
-        kwargs = dict(volume_id=ROOT, node_id='node_id', parent_id="parent_id",
+        kwargs = dict(volume_id=ROOT, node_id='node_id', parent_id=parent_id,
                       name="file")
         self.assertIn(("SV_DIR_NEW", kwargs), self.listener.events)
 
     def test_server_file_deleted_sends_event(self):
         """When a file is deleted, an event is sent."""
+        node = self.create_filetxt()
+        full_path = self.main.fs.get_abspath(node.share_id, node.path)
 
         # delete the fake file
-        self.main.vm._got_root("parent_id")
-        self.sync._handle_SV_FILE_DELETED(ROOT, "node_id", True)
+        self.sync._handle_SV_FILE_DELETED(ROOT, node.node_id, True)
 
         # check event
-        kwargs = dict(volume_id=ROOT, node_id='node_id', is_dir=True)
+        kwargs = dict(volume_id=ROOT, node_id=node.node_id, was_dir=True,
+                      old_path=full_path)
         self.assertIn(("SV_FILE_DELETED", kwargs), self.listener.events)

=== modified file 'ubuntuone/eventlog/zg_listener.py'
--- ubuntuone/eventlog/zg_listener.py	2010-12-15 18:36:41 +0000
+++ ubuntuone/eventlog/zg_listener.py	2011-03-17 18:46:30 +0000
@@ -56,7 +56,7 @@
         self.newly_created_server_files = set()
         self.newly_created_local_files = set()
 
-    def handle_AQ_CREATE_SHARE_OK(self, share_id=None, marker=None):
+    def handle_AQ_CREATE_SHARE_OK(self, share_id, marker):
         """Log the 'directory shared thru the server' event."""
         share = self.vm.shared[share_id]
         self.log_folder_shared(share, share_id)
@@ -371,18 +371,16 @@
 
         self.zg.log(event)
 
-    def handle_SV_FILE_DELETED(self, volume_id, node_id, is_dir):
+    def handle_SV_FILE_DELETED(self, volume_id, node_id, was_dir, old_path):
         """A file or folder was deleted locally by Syncdaemon."""
-        mdo = self.fsm.get_by_node_id(volume_id, node_id)
-        path = self.fsm.get_abspath(volume_id, mdo.path)
-
-        if is_dir:
+        if was_dir:
             mime, interp = DIRECTORY_MIMETYPE, Interpretation.FOLDER
         else:
-            mime, interp = self.get_mime_and_interpretation_for_filepath(path)
+            mime, interp = self.get_mime_and_interpretation_for_filepath(
+                                                                    old_path)
 
         file_subject = Subject.new_for_values(
-            uri="file:///" + path,
+            uri="file:///" + old_path,
             interpretation=interp,
             manifestation=Manifestation.DELETED_RESOURCE,
             origin=URI_PROTOCOL_U1 + str(node_id),
@@ -398,21 +396,19 @@
         self.zg.log(event)
 
     def handle_AQ_UNLINK_OK(self, share_id, parent_id, node_id,
-                            new_generation):
+                            new_generation, was_dir, old_path):
         """A file or folder was deleted on the server by Syncdaemon,"""
-        mdo = self.fsm.get_by_node_id(share_id, node_id)
-        path = self.fsm.get_abspath(share_id, mdo.path)
-
-        if mdo.is_dir:
+        if was_dir:
             mime, interp = DIRECTORY_MIMETYPE, Interpretation.FOLDER
         else:
-            mime, interp = self.get_mime_and_interpretation_for_filepath(path)
+            mime, interp = self.get_mime_and_interpretation_for_filepath(
+                                                                    old_path)
 
         file_subject = Subject.new_for_values(
             uri=URI_PROTOCOL_U1 + str(node_id),
             interpretation=interp,
             manifestation=Manifestation.DELETED_RESOURCE,
-            origin="file:///" + path,
+            origin="file:///" + old_path,
             mimetype=mime,
             storage=STORAGE_DELETED)
 

=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2011-03-11 19:28:58 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2011-03-17 18:46:30 +0000
@@ -1003,9 +1003,10 @@
         return Move(self.queue, share_id, node_id, old_parent_id,
                     new_parent_id, new_name, path_from, path_to).go()
 
-    def unlink(self, share_id, parent_id, node_id, path):
+    def unlink(self, share_id, parent_id, node_id, path, is_dir):
         """See .interfaces.IMetaQueue."""
-        return Unlink(self.queue, share_id, parent_id, node_id, path).go()
+        return Unlink(self.queue, share_id, parent_id, node_id, path,
+                      is_dir).go()
 
     def inquire_free_space(self, share_id):
         """See .interfaces.IMetaQueue."""
@@ -1509,16 +1510,18 @@
 
 class Unlink(ActionQueueCommand):
     """Unlink a file or dir."""
-    __slots__ = ('share_id', 'node_id', 'parent_id', 'path')
+    __slots__ = ('share_id', 'node_id', 'parent_id', 'path', 'is_dir')
     logged_attrs = ActionQueueCommand.logged_attrs + __slots__
     possible_markers = 'node_id', 'parent_id'
 
-    def __init__(self, request_queue, share_id, parent_id, node_id, path):
+    def __init__(self, request_queue, share_id, parent_id, node_id, path,
+                 is_dir):
         super(Unlink, self).__init__(request_queue)
         self.share_id = share_id
         self.node_id = node_id
         self.parent_id = parent_id
         self.path = path
+        self.is_dir = is_dir
 
     def _run(self):
         """Do the actual running."""
@@ -1527,7 +1530,8 @@
     def handle_success(self, request):
         """It worked! Push the event."""
         d = dict(share_id=self.share_id, parent_id=self.parent_id,
-                 node_id=self.node_id, new_generation=request.new_generation)
+                 node_id=self.node_id, new_generation=request.new_generation,
+                 was_dir=self.is_dir, old_path=self.path)
         self.action_queue.event_queue.push('AQ_UNLINK_OK', **d)
 
     def handle_failure(self, failure):

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2011-03-08 20:25:00 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2011-03-17 18:46:30 +0000
@@ -43,7 +43,8 @@
     'AQ_MOVE_OK': ('share_id', 'node_id', 'new_generation'),
     'AQ_MOVE_ERROR': ('share_id', 'node_id',
                       'old_parent_id', 'new_parent_id', 'new_name', 'error'),
-    'AQ_UNLINK_OK': ('share_id', 'parent_id', 'node_id', 'new_generation'),
+    'AQ_UNLINK_OK': ('share_id', 'parent_id', 'node_id', 'new_generation',
+                     'was_dir', 'old_path'),
     'AQ_UNLINK_ERROR': ('share_id', 'parent_id', 'node_id', 'error'),
     'AQ_DOWNLOAD_STARTED': ('share_id', 'node_id', 'server_hash'),
     'AQ_DOWNLOAD_FILE_PROGRESS': ('share_id', 'node_id',
@@ -98,7 +99,7 @@
     'SV_VOLUME_NEW_GENERATION': ('volume_id', 'generation'),
     'SV_FILE_NEW': ('volume_id', 'node_id', 'parent_id', 'name'),
     'SV_DIR_NEW': ('volume_id', 'node_id', 'parent_id', 'name'),
-    'SV_FILE_DELETED': ('volume_id', 'node_id', 'is_dir'),
+    'SV_FILE_DELETED': ('volume_id', 'node_id', 'was_dir', 'old_path'),
 
     'HQ_HASH_NEW': ('path', 'hash', 'crc32', 'size', 'stat'),
     'HQ_HASH_ERROR': ('mdid',),

=== modified file 'ubuntuone/syncdaemon/filesystem_manager.py'
--- ubuntuone/syncdaemon/filesystem_manager.py	2011-02-28 15:26:29 +0000
+++ ubuntuone/syncdaemon/filesystem_manager.py	2011-03-17 18:46:30 +0000
@@ -1314,10 +1314,12 @@
             node_id = MDMarker(mdid)
         share_id = mdobj["share_id"]
         path = self.get_abspath(mdobj['share_id'], mdobj['path'])
+        is_dir = mdobj["is_dir"]
         log_debug("delete_to_trash: mdid=%r, parent=%r, share=%r, node=%r, "
-                  "path=%r", mdid, parent_id, share_id, node_id, path)
+                  "path=%r is_dir=%r", mdid, parent_id, share_id, node_id,
+                  path, is_dir)
         self.delete_metadata(path)
-        self.trash[(share_id, node_id)] = (mdid, parent_id, path)
+        self.trash[(share_id, node_id)] = (mdid, parent_id, path, is_dir)
 
     def remove_from_trash(self, share_id, node_id):
         """Delete the node from the trash."""
@@ -1333,13 +1335,17 @@
         """Return the trash element by element."""
         for (share_id, node_id), node_info in self.trash.iteritems():
             parent_id = node_info[1]
-            if len(node_info) == 2:
+            if len(node_info) <= 2:
                 # old trash, use a fake path to not block the unlink
                 # that LR generates
                 path = "fake_unblocking_path"
             else:
                 path = node_info[2]
-            yield share_id, node_id, parent_id, path
+            if len(node_info) <= 3:
+                is_dir = False
+            else:
+                is_dir = node_info[3]
+            yield share_id, node_id, parent_id, path, is_dir
 
     def get_dirty_nodes(self):
         """Return the mdid of the dirty nodes, one by one."""
@@ -1402,14 +1408,15 @@
 
     def dereference_ok_limbos(self, marker, value):
         """Dereference markers in the limbos with a value."""
-        for (share, node), (mdid, parent, path) in self.trash.iteritems():
+        for (share, node), (mdid, parent, path, is_dir) in \
+                self.trash.iteritems():
             if node == marker:
                 del self.trash[(share, node)]
-                self.trash[(share, value)] = (mdid, parent, path)
+                self.trash[(share, value)] = (mdid, parent, path, is_dir)
                 log_debug("dereference ok trash: share=%r  marker=%r  "
                           "new node=%r", share, marker, value)
             elif parent == marker:
-                self.trash[(share, node)] = (mdid, value, path)
+                self.trash[(share, node)] = (mdid, value, path, is_dir)
                 log_debug("dereference ok trash: share=%r  node=%r  marker=%r"
                           "  new parent=%r", share, node, marker, value)
 
@@ -1440,7 +1447,7 @@
 
         As the dependency is not valid, we just remove the item.
         """
-        for (share, node), (_, parent, _) in self.trash.iteritems():
+        for (share, node), (_, parent, _, _) in self.trash.iteritems():
             if node == marker or parent == marker:
                 log_debug("dereference err trash: share=%r  node=%r  "
                           "marker=%r", share, node, marker)

=== modified file 'ubuntuone/syncdaemon/interfaces.py'
--- ubuntuone/syncdaemon/interfaces.py	2011-02-08 18:38:31 +0000
+++ ubuntuone/syncdaemon/interfaces.py	2011-03-17 18:46:30 +0000
@@ -86,7 +86,7 @@
         Ask the server to move a node to the given parent and name.
         """
 
-    def unlink(share_id, parent_id, node_id, path):
+    def unlink(share_id, parent_id, node_id, path, is_dir):
         """
         Unlink the given node.
         """

=== modified file 'ubuntuone/syncdaemon/local_rescan.py'
--- ubuntuone/syncdaemon/local_rescan.py	2011-03-07 15:11:57 +0000
+++ ubuntuone/syncdaemon/local_rescan.py	2011-03-17 18:46:30 +0000
@@ -124,7 +124,8 @@
         """Process the FSM limbos and send corresponding AQ orders."""
         log_info("processing trash")
         trash_log = "share_id=%r  parent_id=%r  node_id=%r  path=%r"
-        for share_id, node_id, parent_id, path in self.fsm.get_iter_trash():
+        for share_id, node_id, parent_id, path, is_dir in \
+                                                self.fsm.get_iter_trash():
             datalog = trash_log % (share_id, parent_id, node_id, path)
             if IMarker.providedBy(node_id) or IMarker.providedBy(parent_id):
                 # situation where the node is not in the server
@@ -132,7 +133,7 @@
                 self.fsm.remove_from_trash(share_id, node_id)
                 continue
             log_info("generating Unlink from trash: " + datalog)
-            self.aq.unlink(share_id, parent_id, node_id, path)
+            self.aq.unlink(share_id, parent_id, node_id, path, is_dir)
 
         log_info("processing move limbo")
         move_log = ("share_id=%r  node_id=%r  old_parent_id=%r  "

=== modified file 'ubuntuone/syncdaemon/sync.py'
--- ubuntuone/syncdaemon/sync.py	2011-03-08 20:25:00 +0000
+++ ubuntuone/syncdaemon/sync.py	2011-03-17 18:46:30 +0000
@@ -689,38 +689,42 @@
 
     def delete_on_server(self, event, params, path):
         """local file was deleted."""
+        is_dir = self.key.is_dir()
         self.m.action_q.unlink(self.key['share_id'],
                                self.key['parent_id'],
-                               self.key['node_id'], path)
+                               self.key['node_id'], path, is_dir)
         self.key.delete_to_trash()
 
     def deleted_dir_while_downloading(self, event, params, path):
         """kill it"""
+        is_dir = self.key.is_dir()
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
                                         node_id=self.key['node_id'])
         self.key.remove_partial()
         self.m.action_q.unlink(self.key['share_id'],
                                self.key['parent_id'],
-                               self.key['node_id'], path)
+                               self.key['node_id'], path, is_dir)
         self.key.delete_to_trash()
 
     def cancel_download_and_delete_on_server(self, event, params, path):
         """cancel_download_and_delete_on_server"""
+        is_dir = self.key.is_dir()
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
                                         node_id=self.key['node_id'])
         self.key.remove_partial()
         self.m.action_q.unlink(self.key['share_id'],
                                self.key['parent_id'],
-                               self.key['node_id'], path)
+                               self.key['node_id'], path, is_dir)
         self.key.delete_to_trash()
 
     def cancel_upload_and_delete_on_server(self, event, params, path):
         """cancel_download_and_delete_on_server"""
+        is_dir = self.key.is_dir()
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
                                       node_id=self.key['node_id'])
         self.m.action_q.unlink(self.key['share_id'],
                                self.key['parent_id'],
-                               self.key['node_id'], path)
+                               self.key['node_id'], path, is_dir)
         self.key.delete_to_trash()
 
     def remove_trash(self, event, params, share_id, node_id):
@@ -852,11 +856,13 @@
     def _handle_SV_FILE_DELETED(self, share_id, node_id, is_dir):
         """on SV_FILE_DELETED. Not called by EQ anymore."""
         key = FSKey(self.m.fs, share_id=share_id, node_id=node_id)
+        path = key["path"]
         log = FileLogger(self.logger, key)
         ssmr = SyncStateMachineRunner(self.fsm, self.m, key, log)
         ssmr.on_event("SV_FILE_DELETED", {})
         self.m.event_q.push('SV_FILE_DELETED', volume_id=share_id,
-                            node_id=node_id, is_dir=is_dir)
+                            node_id=node_id, was_dir=is_dir,
+                            old_path=path)
 
     def handle_AQ_DOWNLOAD_FINISHED(self, share_id, node_id, server_hash):
         """on AQ_DOWNLOAD_FINISHED"""
@@ -1016,7 +1022,7 @@
                       new_parent_id, new_name)
 
     def handle_AQ_UNLINK_OK(self, share_id, parent_id, node_id,
-                            new_generation):
+                            new_generation, was_dir, old_path):
         """On AQ_UNLINK_OK."""
         key = FSKey(self.m.fs, share_id=share_id, node_id=node_id)
         log = FileLogger(self.logger, key)