Merge lp:~alecu/ubuntuone-client/ziggy-for-filesync into lp:ubuntuone-client

[Alejandro J. Cura]

Remaining SyncDaemon events to be logged into Zeitgeist.

Remaining SyncDaemon events to be logged into Zeitgeist.
https://wiki.ubuntu.com/UbuntuOne/Specs/ZeitgeistIntegration/EventsSpec

Directory and files synchronization and conflict, UDF creation/deletion/subscribing, file publishing.

[Natalia Bidart (nataliabidart)]

Great work. Really.

review: Approve

[Facundo Batista (facundo)]

Like it

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~alecu/ubuntuone-client/ziggy-for-filesync 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.67
checking for automake >= 1.10...
  testing automake-1.11... found 1.11.1
checking for libtool >= 1.5...
  testing libtoolize... found 2.2.6b
checking for intltool >= 0.30...
  testing intltoolize... found 0.41.1
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.25
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.15
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... gawk
checking whether make sets $(MAKE)... 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... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
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 shell understands some XSI constructs... yes
checking whether the shell understands "+="... yes
checking for /usr/bin/ld option to reload object files... -r
checking for objdump... objdump
checking how to recognize dependent lib...

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-12-02 17:50:57 +0000
+++ contrib/testing/testcase.py	2010-12-13 23:42:15 +0000
@@ -143,7 +143,7 @@
 
     cancel_download = cancel_upload = download = upload = make_dir = disconnect
     make_file = move = unlink = list_shares = disconnect
-    list_volumes = create_share = inquire_free_space =  disconnect
+    list_volumes = create_share = create_udf = inquire_free_space =  disconnect
     inquire_account_info = delete_volume = change_public_access = disconnect
     query_volumes = get_delta = rescan_from_scratch = disconnect
     node_is_with_queued_move = disconnect

=== modified file 'tests/syncdaemon/test_event_logging.py'
--- tests/syncdaemon/test_event_logging.py	2010-12-09 14:28:21 +0000
+++ tests/syncdaemon/test_event_logging.py	2010-12-13 23:42:15 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # tests.syncdaemon.test_event_logging - test logging ZG events
 #
 # Author: Alejandro J. Cura <[e-mail]>
@@ -17,23 +19,41 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Test the event logging from SyncDaemon into Zeitgeist."""
 
+import logging
 import os
+import shutil
 import uuid
 
 from twisted.internet import defer
 from zeitgeist.datamodel import Interpretation, Manifestation
 
-from contrib.testing.testcase import FakeMainTestCase
+from contrib.testing.testcase import (
+        FakeMain, FakeMainTestCase, BaseTwistedTestCase, MementoHandler)
+from ubuntuone.platform.linux import get_udf_path
+from ubuntuone.storageprotocol import client, delta
+from ubuntuone.storageprotocol.request import ROOT
 from ubuntuone.storageprotocol.sharersp import NotifyShareHolder
+from ubuntuone.syncdaemon.action_queue import (
+        RequestQueue, Upload, MakeFile, MakeDir)
 from ubuntuone.syncdaemon.event_logging import (
         zglog, ZeitgeistListener, ACTOR_UBUNTUONE,
         EVENT_INTERPRETATION_U1_FOLDER_SHARED,
         EVENT_INTERPRETATION_U1_FOLDER_UNSHARED,
         EVENT_INTERPRETATION_U1_SHARE_ACCEPTED,
         EVENT_INTERPRETATION_U1_SHARE_UNACCEPTED,
+        EVENT_INTERPRETATION_U1_CONFLICT_RENAME,
+        EVENT_INTERPRETATION_U1_UDF_CREATED,
+        EVENT_INTERPRETATION_U1_UDF_DELETED,
+        EVENT_INTERPRETATION_U1_UDF_SUBSCRIBED,
+        EVENT_INTERPRETATION_U1_UDF_UNSUBSCRIBED,
         MANIFESTATION_U1_CONTACT_DATA_OBJECT, DIRECTORY_MIMETYPE,
-        INTERPRETATION_U1_CONTACT, URI_PROTOCOL_U1, STORAGE_NETWORK)
-from ubuntuone.syncdaemon.volume_manager import Share, Shared
+        INTERPRETATION_U1_CONTACT, URI_PROTOCOL_U1,
+        STORAGE_DELETED, STORAGE_NETWORK, STORAGE_LOCAL)
+from ubuntuone.syncdaemon.sync import Sync
+from ubuntuone.syncdaemon.volume_manager import Share, Shared, UDF
+from test_action_queue import ConnectedBaseTestCase
+
+VOLUME = uuid.UUID('12345678-1234-1234-1234-123456789abc')
 
 
 class MockLogger(object):
@@ -47,6 +67,33 @@
         """Log the event."""
         self.events.append(event)
 
+def listen_for(event_q, event, callback, count=1, collect=False):
+    """Setup a EQ listener for the specified event."""
+    class Listener(object):
+        """A basic listener to handle the pushed event."""
+
+        def __init__(self):
+            self.hits = 0
+            self.events = []
+
+        def _handle_event(self, *args, **kwargs):
+            self.hits += 1
+            if collect:
+                self.events.append((args, kwargs))
+            if self.hits == count:
+                event_q.unsubscribe(self)
+                if collect:
+                    callback(self.events)
+                elif kwargs:
+                    callback((args, kwargs))
+                else:
+                    callback(args)
+
+    listener = Listener()
+    setattr(listener, 'handle_'+event, listener._handle_event)
+    event_q.subscribe(listener)
+    return listener
+
 
 class ZeitgeistListenerTestCase(FakeMainTestCase):
     """Tests for ZeitgeistListener."""
@@ -58,33 +105,12 @@
         self.listener = ZeitgeistListener(self.fs, self.vm)
         self.event_q.subscribe(self.listener)
 
-    def _listen_for(self, event, callback, count=1, collect=False):
-        """Setup a EQ listener for the specified event."""
-        event_q = self.main.event_q
-        class Listener(object):
-            """A basic listener to handle the pushed event."""
-
-            def __init__(self):
-                self.hits = 0
-                self.events = []
-
-            def _handle_event(self, *args, **kwargs):
-                self.hits += 1
-                if collect:
-                    self.events.append((args, kwargs))
-                if self.hits == count:
-                    event_q.unsubscribe(self)
-                    if collect:
-                        callback(self.events)
-                    elif kwargs:
-                        callback((args, kwargs))
-                    else:
-                        callback(args)
-
-        listener = Listener()
-        setattr(listener, 'handle_'+event, listener._handle_event)
-        event_q.subscribe(listener)
-        return listener
+    def _listen_for(self, *args, **kwargs):
+        return listen_for(self.main.event_q, *args, **kwargs)
+
+
+class ZeitgeistSharesTestCase(ZeitgeistListenerTestCase):
+    """Tests for all Share-related zeitgeist events."""
 
     def test_share_created_with_username_is_logged(self):
         """A ShareCreated event is logged."""
@@ -129,28 +155,28 @@
     def assert_folder_shared_is_logged(self, path, fake_username):
         """Assert that the FolderShared event was logged."""
 
-        self.assertEquals(len(self.listener.zg.events), 1)
+        self.assertEqual(len(self.listener.zg.events), 1)
         event = self.listener.zg.events[0]
 
-        self.assertEquals(event.interpretation,
+        self.assertEqual(event.interpretation,
                           EVENT_INTERPRETATION_U1_FOLDER_SHARED)
-        self.assertEquals(event.manifestation,
+        self.assertEqual(event.manifestation,
                           Manifestation.USER_ACTIVITY)
-        self.assertEquals(event.actor, ACTOR_UBUNTUONE)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
 
         folder = event.subjects[0]
         self.assertTrue(folder.uri.startswith(URI_PROTOCOL_U1))
-        self.assertEquals(folder.interpretation, Interpretation.FOLDER)
-        self.assertEquals(folder.manifestation,
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
                           Manifestation.REMOTE_DATA_OBJECT)
         self.assertTrue(folder.origin.endswith(path))
-        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEquals(folder.storage, STORAGE_NETWORK)
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_NETWORK)
 
         other_user = event.subjects[1]
-        self.assertEquals(other_user.uri, "mailto:" + fake_username)
-        self.assertEquals(other_user.interpretation, INTERPRETATION_U1_CONTACT)
-        self.assertEquals(other_user.manifestation,
+        self.assertEqual(other_user.uri, "mailto:" + fake_username)
+        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
+        self.assertEqual(other_user.manifestation,
                           MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
 
@@ -178,28 +204,28 @@
         self.vm.delete_share(share.volume_id)
         yield d
 
-        self.assertEquals(len(self.listener.zg.events), 1)
+        self.assertEqual(len(self.listener.zg.events), 1)
         event = self.listener.zg.events[0]
 
-        self.assertEquals(event.interpretation,
+        self.assertEqual(event.interpretation,
                           EVENT_INTERPRETATION_U1_FOLDER_UNSHARED)
-        self.assertEquals(event.manifestation,
+        self.assertEqual(event.manifestation,
                           Manifestation.USER_ACTIVITY)
-        self.assertEquals(event.actor, ACTOR_UBUNTUONE)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
 
         folder = event.subjects[0]
         self.assertTrue(folder.uri.startswith(URI_PROTOCOL_U1))
-        self.assertEquals(folder.interpretation, Interpretation.FOLDER)
-        self.assertEquals(folder.manifestation,
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
                           Manifestation.REMOTE_DATA_OBJECT)
         self.assertTrue(folder.origin.endswith(path))
-        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEquals(folder.storage, STORAGE_NETWORK)
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_NETWORK)
 
         other_user = event.subjects[1]
-        self.assertEquals(other_user.uri, "mailto:" + fake_username)
-        self.assertEquals(other_user.interpretation, INTERPRETATION_U1_CONTACT)
-        self.assertEquals(other_user.manifestation,
+        self.assertEqual(other_user.uri, "mailto:" + fake_username)
+        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
+        self.assertEqual(other_user.manifestation,
                           MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
     def test_share_accepted_is_logged(self):
@@ -214,28 +240,28 @@
                       other_username=fake_username)
         self.vm.add_share(share)
 
-        self.assertEquals(len(self.listener.zg.events), 1)
+        self.assertEqual(len(self.listener.zg.events), 1)
         event = self.listener.zg.events[0]
 
-        self.assertEquals(event.interpretation,
+        self.assertEqual(event.interpretation,
                           EVENT_INTERPRETATION_U1_SHARE_ACCEPTED)
-        self.assertEquals(event.manifestation,
+        self.assertEqual(event.manifestation,
                           Manifestation.USER_ACTIVITY)
-        self.assertEquals(event.actor, ACTOR_UBUNTUONE)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
 
         folder = event.subjects[0]
         self.assertTrue(folder.uri.startswith(URI_PROTOCOL_U1))
-        self.assertEquals(folder.interpretation, Interpretation.FOLDER)
-        self.assertEquals(folder.manifestation,
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
                           Manifestation.REMOTE_DATA_OBJECT)
         self.assertTrue(folder.origin.endswith(share_path))
-        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEquals(folder.storage, STORAGE_NETWORK)
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_NETWORK)
 
         other_user = event.subjects[1]
-        self.assertEquals(other_user.uri, "mailto:" + fake_username)
-        self.assertEquals(other_user.interpretation, INTERPRETATION_U1_CONTACT)
-        self.assertEquals(other_user.manifestation,
+        self.assertEqual(other_user.uri, "mailto:" + fake_username)
+        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
+        self.assertEqual(other_user.manifestation,
                           MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
 
@@ -257,26 +283,856 @@
         self.main.event_q.push('SV_SHARE_DELETED', holder.share_id)
         yield d
 
-        self.assertEquals(len(self.listener.zg.events), 2)
+        self.assertEqual(len(self.listener.zg.events), 2)
         event = self.listener.zg.events[1]
 
-        self.assertEquals(event.interpretation,
+        self.assertEqual(event.interpretation,
                           EVENT_INTERPRETATION_U1_SHARE_UNACCEPTED)
-        self.assertEquals(event.manifestation,
+        self.assertEqual(event.manifestation,
                           Manifestation.USER_ACTIVITY)
-        self.assertEquals(event.actor, ACTOR_UBUNTUONE)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
 
         folder = event.subjects[0]
         self.assertTrue(folder.uri.startswith(URI_PROTOCOL_U1))
-        self.assertEquals(folder.interpretation, Interpretation.FOLDER)
-        self.assertEquals(folder.manifestation,
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
                           Manifestation.REMOTE_DATA_OBJECT)
         self.assertTrue(folder.origin.endswith(share_path))
-        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEquals(folder.storage, STORAGE_NETWORK)
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_NETWORK)
 
         other_user = event.subjects[1]
-        self.assertEquals(other_user.uri, "mailto:" + fake_username)
-        self.assertEquals(other_user.interpretation, INTERPRETATION_U1_CONTACT)
-        self.assertEquals(other_user.manifestation,
+        self.assertEqual(other_user.uri, "mailto:" + fake_username)
+        self.assertEqual(other_user.interpretation, INTERPRETATION_U1_CONTACT)
+        self.assertEqual(other_user.manifestation,
                           MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+
+class ZeitgeistUDFsTestCase(ZeitgeistListenerTestCase):
+    """Tests for all UDFs-related zeitgeist events."""
+
+    def setUp(self):
+        """Initialize this test instance."""
+        super(ZeitgeistUDFsTestCase, self).setUp()
+        self.home_dir = self.mktemp('ubuntuonehacker')
+        self._old_home = os.environ['HOME']
+        os.environ['HOME'] = self.home_dir
+
+    def tearDown(self):
+        """Finalize this test instance."""
+        self.rmtree(self.home_dir)
+        os.environ['HOME'] = self._old_home
+        super(ZeitgeistUDFsTestCase, self).tearDown()
+
+    def _create_udf(self, id, node_id, suggested_path, subscribed=True):
+        """Create an UDF and returns it and the volume."""
+        path = get_udf_path(suggested_path)
+        # make sure suggested_path is unicode
+        if isinstance(suggested_path, str):
+            suggested_path = suggested_path.decode('utf-8')
+        udf = UDF(str(id), str(node_id), suggested_path, path, subscribed)
+        return udf
+
+    @defer.inlineCallbacks
+    def test_udf_create_is_logged(self):
+        """Test for Folders.create."""
+        path = os.path.join(self.home_dir, u'ñoño'.encode('utf-8'))
+        id = uuid.uuid4()
+        node_id = uuid.uuid4()
+
+        def create_udf(path, name, marker):
+            """Fake create_udf."""
+            # check that the marker is the full path to the udf
+            expanded_path = os.path.expanduser(path.encode('utf-8'))
+            udf_path = os.path.join(expanded_path, name.encode('utf-8'))
+            if str(marker) != udf_path:
+                d.errback(ValueError("marker != path - "
+                                   "marker: %r path: %r" % (marker, udf_path)))
+            self.main.event_q.push("AQ_CREATE_UDF_OK", **dict(volume_id=id,
+                                                       node_id=node_id,
+                                                       marker=marker))
+
+        self.patch(self.main.action_q, "create_udf", create_udf)
+
+        d = defer.Deferred()
+        self._listen_for('VM_UDF_CREATED', d.callback, 1, collect=True)
+        self.vm.create_udf(path.encode('utf-8'))
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          EVENT_INTERPRETATION_U1_UDF_CREATED)
+        self.assertEqual(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        folder = event.subjects[0]
+        self.assertTrue(folder.uri.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(folder.origin.endswith(path))
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_NETWORK)
+
+    @defer.inlineCallbacks
+    def test_udf_delete_is_logged(self):
+        """Test for Folders.delete."""
+        id = uuid.uuid4()
+        node_id = uuid.uuid4()
+        path = os.path.join(self.home_dir, u'ñoño'.encode('utf-8'))
+
+        def create_udf(path, name, marker):
+            """Fake create_udf."""
+            # check that the marker is the full path to the udf
+            expanded_path = os.path.expanduser(path.encode('utf-8'))
+            udf_path = os.path.join(expanded_path, name.encode('utf-8'))
+            if str(marker) != udf_path:
+                d.errback(ValueError("marker != path - "
+                                   "marker: %r path: %r" % (marker, udf_path)))
+            self.main.event_q.push("AQ_CREATE_UDF_OK", **dict(volume_id=id,
+                                                       node_id=node_id,
+                                                       marker=marker))
+
+        self.patch(self.main.action_q, "create_udf", create_udf)
+
+        d = defer.Deferred()
+        self._listen_for('VM_UDF_CREATED', d.callback, 1, collect=True)
+        self.vm.create_udf(path.encode('utf-8'))
+        yield d
+
+        def delete_volume(path):
+            """Fake delete_volume."""
+            self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=id)
+
+        self.patch(self.main.action_q, "delete_volume", delete_volume)
+
+        self.vm.delete_volume(str(id))
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        d = defer.Deferred()
+        self._listen_for('VM_VOLUME_DELETED', d.callback, 1, collect=True)
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 2)
+        event = self.listener.zg.events[1]
+
+        self.assertEqual(event.interpretation,
+                          EVENT_INTERPRETATION_U1_UDF_DELETED)
+        self.assertEqual(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        folder = event.subjects[0]
+        self.assertTrue(folder.uri.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
+                          Manifestation.DELETED_RESOURCE)
+        self.assertTrue(folder.origin.endswith(path))
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_DELETED)
+
+    @defer.inlineCallbacks
+    def test_udf_subscribe_is_logged(self):
+        """Test for Folders.subscribe."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
+                               subscribed=False)
+        yield self.main.vm.add_udf(udf)
+        d = defer.Deferred()
+        self._listen_for('VM_UDF_SUBSCRIBED', d.callback, 1, collect=True)
+        self.vm.subscribe_udf(udf.volume_id)
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 2)
+        event = self.listener.zg.events[1]
+
+        self.assertEqual(event.interpretation,
+                          EVENT_INTERPRETATION_U1_UDF_SUBSCRIBED)
+        self.assertEqual(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        folder = event.subjects[0]
+        self.assertTrue(folder.uri.endswith(udf.path))
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
+                          Manifestation.FILE_DATA_OBJECT)
+        self.assertTrue(folder.origin.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_LOCAL)
+
+    @defer.inlineCallbacks
+    def test_udf_unsubscribe_is_logged(self):
+        """Test for Folders.unsubscribe."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
+                               subscribed=True)
+        yield self.main.vm.add_udf(udf)
+        d = defer.Deferred()
+        self._listen_for('VM_UDF_UNSUBSCRIBED', d.callback, 1, collect=True)
+        self.vm.unsubscribe_udf(udf.volume_id)
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 2)
+        event = self.listener.zg.events[1]
+
+        self.assertEqual(event.interpretation,
+                          EVENT_INTERPRETATION_U1_UDF_UNSUBSCRIBED)
+        self.assertEqual(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        folder = event.subjects[0]
+        self.assertTrue(folder.uri.endswith(udf.path))
+        self.assertEqual(folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(folder.manifestation,
+                          Manifestation.DELETED_RESOURCE)
+        self.assertTrue(folder.origin.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(folder.storage, STORAGE_DELETED)
+
+
+class ZeitgeistRemoteFileSyncTestCase(ConnectedBaseTestCase):
+    """File sync events are logged into Zeitgeist."""
+
+    def setUp(self):
+        """Initialize this test instance."""
+        ConnectedBaseTestCase.setUp(self)
+        self.rq = request_queue = RequestQueue(name='FOO',
+                                               action_queue=self.action_queue)
+
+        class MyUpload(Upload):
+            """Just to allow monkeypatching."""
+
+        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,
+                                fileobj_factory=lambda: None,
+                                tempfile_factory=lambda: None)
+        self.command.pre_queue_setup() # create the logger
+        self.fsm = self.action_queue.main.fs
+        self.vm = self.action_queue.main.vm
+        self.patch(zglog, "ZeitgeistLogger", MockLogger)
+        self.listener = ZeitgeistListener(self.fsm, self.vm)
+        self.action_queue.event_queue.subscribe(self.listener)
+        self.root_id = "roootid"
+        self.sync = Sync(main=self.main)
+
+    def tearDown(self):
+        """Finalize this test instance."""
+        ConnectedBaseTestCase.tearDown(self)
+
+    def test_syncdaemon_creates_file_on_server_is_logged(self):
+        """Files created by SyncDaemon on the server are logged."""
+        filename = "filename.mp3"
+        path = os.path.join(self.vm.root.path, filename)
+        self.fsm.create(path, "")
+        self.fsm.set_node_id(path, "a_node_id")
+
+        request = client.MakeFile(self.action_queue.client, self.share_id,
+                                  'parent', filename)
+        request.new_id = 'a_node_id'
+        request.new_generation = 13
+
+        # create a command and trigger it success
+        cmd = MakeFile(self.rq, self.share_id, 'parent', filename, 'marker')
+        res = cmd.handle_success(request)
+        assert res is request
+
+        # create a request and fill it with succesful information
+        request = client.PutContent(self.action_queue.client, self.share_id,
+                                    'node', 'prvhash', 'newhash', 'crc32',
+                                    'size', 'deflated', 'fd')
+        request.new_generation = 13
+
+        # trigger success in the command
+        self.command.handle_success(request)
+
+        # check for successful event
+        kwargs = dict(share_id=self.command.share_id, node_id='a_node_id',
+                      hash='yadda', new_generation=13)
+
+        info = dict(marker='marker', new_id='a_node_id', new_generation=13,
+                    volume_id=self.share_id)
+        events = [
+            ('AQ_FILE_NEW_OK', (), info),
+            ('AQ_UPLOAD_FINISHED', (), kwargs)
+        ]
+        self.assertEqual(events, self.command.action_queue.event_queue.events)
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.CREATE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.SCHEDULED_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        remote_file = event.subjects[0]
+        self.assertTrue(remote_file.uri.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(remote_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(remote_file.manifestation,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(remote_file.origin.endswith(filename))
+        self.assertEqual(remote_file.mimetype, "audio/mpeg")
+        self.assertEqual(remote_file.storage, STORAGE_NETWORK)
+
+    def test_syncdaemon_creates_dir_on_server_is_logged(self):
+        """Dirs created by SyncDaemon on the server are logged."""
+        dirname = "dirname"
+        path = os.path.join(self.vm.root.path, dirname)
+        self.fsm.create(path, "")
+        self.fsm.set_node_id(path, "a_node_id")
+
+        request = client.MakeDir(self.action_queue.client, self.share_id,
+                                  'parent', dirname)
+        request.new_id = 'a_node_id'
+        request.new_generation = 13
+
+        # create a command and trigger it success
+        cmd = MakeDir(self.rq, self.share_id, 'parent', dirname, 'marker')
+        res = cmd.handle_success(request)
+        assert res is request
+
+        # check for successful event
+        info = dict(marker='marker', new_id='a_node_id', new_generation=13,
+                    volume_id=self.share_id)
+        events = [
+            ('AQ_DIR_NEW_OK', (), info),
+        ]
+        self.assertEqual(events, self.command.action_queue.event_queue.events)
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.CREATE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.SCHEDULED_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        remote_file = event.subjects[0]
+        self.assertTrue(remote_file.uri.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(remote_file.interpretation, Interpretation.FOLDER)
+        self.assertEqual(remote_file.manifestation,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(remote_file.origin.endswith(dirname))
+        self.assertEqual(remote_file.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(remote_file.storage, STORAGE_NETWORK)
+
+    def test_syncdaemon_modifies_on_server_is_logged(self):
+        """Files modified by SyncDaemon on the server are logged."""
+        filename = "filename.mp3"
+        path = os.path.join(self.vm.root.path, filename)
+        self.fsm.create(path, "")
+        self.fsm.set_node_id(path, "a_node_id")
+
+        # create a request and fill it with succesful information
+        request = client.PutContent(self.action_queue.client, self.share_id,
+                                    'node', 'prvhash', 'newhash', 'crc32',
+                                    'size', 'deflated', 'fd')
+        request.new_generation = 13
+
+        # trigger success in the command
+        self.command.handle_success(request)
+
+        # check for successful event
+        kwargs = dict(share_id=self.command.share_id, node_id='a_node_id',
+                      hash='yadda', new_generation=13)
+
+        events = [('AQ_UPLOAD_FINISHED', (), kwargs)]
+        self.assertEqual(events, self.command.action_queue.event_queue.events)
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.MODIFY_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.SCHEDULED_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        remote_file = event.subjects[0]
+        self.assertTrue(remote_file.uri.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(remote_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(remote_file.manifestation,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(remote_file.origin.endswith(filename))
+        self.assertEqual(remote_file.mimetype, "audio/mpeg")
+        self.assertEqual(remote_file.storage, STORAGE_NETWORK)
+
+    @defer.inlineCallbacks
+    def test_syncdaemon_deletes_file_on_server_is_logged(self):
+        """Files deleted by SD on the server are logged."""
+        d = defer.Deferred()
+        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)
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.DELETE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.SCHEDULED_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        remote_folder = event.subjects[0]
+        self.assertTrue(remote_folder.uri.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(remote_folder.interpretation, Interpretation.AUDIO)
+        self.assertEqual(remote_folder.manifestation,
+                          Manifestation.DELETED_RESOURCE)
+        self.assertTrue(remote_folder.origin.endswith("filename.mp3"))
+        self.assertEqual(remote_folder.mimetype, "audio/mpeg")
+        self.assertEqual(remote_folder.storage, STORAGE_DELETED)
+
+    @defer.inlineCallbacks
+    def test_syncdaemon_deletes_dir_on_server_is_logged(self):
+        """Files deleted by SD on the server are logged."""
+        d = defer.Deferred()
+        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)
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.DELETE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.SCHEDULED_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        remote_folder = event.subjects[0]
+        self.assertTrue(remote_folder.uri.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(remote_folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(remote_folder.manifestation,
+                          Manifestation.DELETED_RESOURCE)
+        self.assertTrue(remote_folder.origin.endswith("folder name"))
+        self.assertEqual(remote_folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(remote_folder.storage, STORAGE_DELETED)
+
+
+class ZeitgeistLocalFileSyncTestCase(BaseTwistedTestCase):
+    """Zeitgeist events coming from the server."""
+    timeout = 5
+
+    def setUp(self):
+        """Initialize this instance."""
+        BaseTwistedTestCase.setUp(self)
+        self.root = self.mktemp('root')
+        self.shares = self.mktemp('shares')
+        self.data = self.mktemp('data')
+        self.partials_dir = self.mktemp('partials_dir')
+        self.handler = MementoHandler()
+        self.handler.setLevel(logging.ERROR)
+        FakeMain._sync_class = Sync
+        self.main = FakeMain(root_dir=self.root, shares_dir=self.shares,
+                             data_dir=self.data,
+                             partials_dir=self.partials_dir)
+        self._logger = logging.getLogger('ubuntuone.SyncDaemon')
+        self._logger.addHandler(self.handler)
+
+        self.root_id = root_id = "roootid"
+        self.main.vm._got_root(root_id)
+        self.filemp3delta = delta.FileInfoDelta(
+            generation=5, is_live=True, file_type=delta.FILE,
+            parent_id=self.root_id, share_id=ROOT, node_id=uuid.uuid4(),
+            name=u"fileñ.mp3", is_public=False, content_hash="hash",
+            crc32=1, size=10, last_modified=0)
+
+        self.dirdelta = delta.FileInfoDelta(
+            generation=6, is_live=True, file_type=delta.DIRECTORY,
+            parent_id=root_id, share_id=ROOT, node_id=uuid.uuid4(),
+            name=u"directory_ñ", is_public=False, content_hash="hash",
+            crc32=1, size=10, last_modified=0)
+
+        self.patch(zglog, "ZeitgeistLogger", MockLogger)
+        self.listener = ZeitgeistListener(self.main.fs, self.main.vm)
+        self.main.event_q.subscribe(self.listener)
+
+    def tearDown(self):
+        """Clean up this instance."""
+        self._logger.removeHandler(self.handler)
+        self.main.shutdown()
+        FakeMain._sync_class = None
+        shutil.rmtree(self.root)
+        shutil.rmtree(self.shares)
+        shutil.rmtree(self.data)
+        for record in self.handler.records:
+            exc_info = getattr(record, 'exc_info', None)
+            if exc_info is not None:
+                raise exc_info[0], exc_info[1], exc_info[2]
+        BaseTwistedTestCase.tearDown(self)
+
+    @defer.inlineCallbacks
+    def test_syncdaemon_creates_file_locally_is_logged(self):
+        """Files created locally by SyncDaemon are logged."""
+        d = defer.Deferred()
+        d2 = defer.Deferred()
+        listen_for(self.main.event_q, 'SV_FILE_NEW', d.callback)
+        listen_for(self.main.event_q, 'AQ_DOWNLOAD_FINISHED', d2.callback)
+
+        deltas = [ self.filemp3delta ]
+        kwargs = dict(volume_id=ROOT, delta_content=deltas, end_generation=11,
+                      full=True, free_bytes=10)
+        self.main.sync.handle_AQ_DELTA_OK(**kwargs)
+
+        # check that the file is created
+        node = self.main.fs.get_by_node_id(ROOT, self.filemp3delta.node_id)
+        self.assertEqual(node.path, self.filemp3delta.name.encode('utf8'))
+        self.assertEqual(node.is_dir, False)
+        self.assertEqual(node.generation, self.filemp3delta.generation)
+
+        yield d # wait for SV_FILE_NEW
+
+        dlargs = dict(
+            share_id=self.filemp3delta.share_id,
+            node_id=self.filemp3delta.node_id,
+            server_hash="server hash")
+        self.main.event_q.push("AQ_DOWNLOAD_FINISHED", **dlargs)
+
+        yield d2 # wait for AQ_DOWNLOAD_FINISHED
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.CREATE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.WORLD_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        local_file = event.subjects[0]
+        self.assertTrue(local_file.uri.endswith(self.filemp3delta.name))
+        self.assertEqual(local_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(local_file.manifestation,
+                          Manifestation.FILE_DATA_OBJECT)
+        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(local_file.mimetype, "audio/mpeg")
+        self.assertEqual(local_file.storage, STORAGE_LOCAL)
+
+    @defer.inlineCallbacks
+    def test_syncdaemon_creates_dir_locally_is_logged(self):
+        """Dirs created locally by SyncDaemon are logged."""
+        d = defer.Deferred()
+        listen_for(self.main.event_q, 'SV_DIR_NEW', d.callback)
+
+        deltas = [ self.dirdelta ]
+        kwargs = dict(volume_id=ROOT, delta_content=deltas, end_generation=11,
+                      full=True, free_bytes=10)
+        self.main.sync.handle_AQ_DELTA_OK(**kwargs)
+
+        # check that the dir is created
+        node = self.main.fs.get_by_node_id(ROOT, self.dirdelta.node_id)
+        self.assertEqual(node.path, self.dirdelta.name.encode('utf8'))
+        self.assertEqual(node.is_dir, True)
+        self.assertEqual(node.generation, self.dirdelta.generation)
+
+        yield d # wait for SV_DIR_NEW
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.CREATE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.WORLD_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        local_file = event.subjects[0]
+        self.assertTrue(local_file.uri.endswith(self.dirdelta.name))
+        self.assertEqual(local_file.interpretation, Interpretation.FOLDER)
+        self.assertEqual(local_file.manifestation,
+                          Manifestation.FILE_DATA_OBJECT)
+        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(local_file.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(local_file.storage, STORAGE_LOCAL)
+
+    @defer.inlineCallbacks
+    def test_syncdaemon_modifies_locally_is_logged(self):
+        """Files modified locally by SyncDaemon are logged."""
+        d = defer.Deferred()
+        d2 = defer.Deferred()
+        listen_for(self.main.event_q, 'SV_FILE_NEW', d.callback)
+        listen_for(self.main.event_q, 'AQ_DOWNLOAD_FINISHED', d2.callback)
+
+        deltas = [ self.filemp3delta ]
+        kwargs = dict(volume_id=ROOT, delta_content=deltas, end_generation=11,
+                      full=True, free_bytes=10)
+        self.main.sync.handle_AQ_DELTA_OK(**kwargs)
+
+        # check that the file is modified
+        node = self.main.fs.get_by_node_id(ROOT, self.filemp3delta.node_id)
+        self.assertEqual(node.path, self.filemp3delta.name.encode('utf8'))
+        self.assertEqual(node.is_dir, False)
+        self.assertEqual(node.generation, self.filemp3delta.generation)
+
+        yield d # wait for SV_FILE_NEW
+
+        # remove from the recent list
+        local_file_id = (self.filemp3delta.share_id, self.filemp3delta.node_id)
+        self.listener.newly_created_local_files.remove(local_file_id)
+
+        dlargs = dict(
+            share_id=self.filemp3delta.share_id,
+            node_id=self.filemp3delta.node_id,
+            server_hash="server hash")
+        self.main.event_q.push("AQ_DOWNLOAD_FINISHED", **dlargs)
+
+        yield d2 # wait for AQ_DOWNLOAD_FINISHED
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.MODIFY_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.WORLD_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        local_file = event.subjects[0]
+        self.assertTrue(local_file.uri.endswith(self.filemp3delta.name))
+        self.assertEqual(local_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(local_file.manifestation,
+                          Manifestation.FILE_DATA_OBJECT)
+        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(local_file.mimetype, "audio/mpeg")
+        self.assertEqual(local_file.storage, STORAGE_LOCAL)
+
+    @defer.inlineCallbacks
+    def test_syncdaemon_deletes_file_locally_is_logged(self):
+        """Files deleted locally by SyncDaemon are logged."""
+        d = defer.Deferred()
+        listen_for(self.main.event_q, 'SV_FILE_DELETED', d.callback)
+
+        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)
+
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.DELETE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.WORLD_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        local_file = event.subjects[0]
+        self.assertTrue(local_file.uri.endswith(self.filemp3delta.name))
+        self.assertEqual(local_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(local_file.manifestation,
+                          Manifestation.DELETED_RESOURCE)
+        self.assertTrue(local_file.origin.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(local_file.mimetype, "audio/mpeg")
+        self.assertEqual(local_file.storage, STORAGE_DELETED)
+
+    @defer.inlineCallbacks
+    def test_syncdaemon_deletes_dir_locally_is_logged(self):
+        """Dirs deleted locally by SyncDaemon are logged."""
+        d = defer.Deferred()
+        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)
+
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.DELETE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.WORLD_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        local_folder = event.subjects[0]
+        self.assertTrue(local_folder.uri.endswith("folder name"))
+        self.assertEqual(local_folder.interpretation, Interpretation.FOLDER)
+        self.assertEqual(local_folder.manifestation,
+                          Manifestation.DELETED_RESOURCE)
+        self.assertTrue(local_folder.origin.startswith(URI_PROTOCOL_U1))
+        self.assertEqual(local_folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(local_folder.storage, STORAGE_DELETED)
+
+    @defer.inlineCallbacks
+    def test_file_sync_conflict_is_logged(self):
+        """Files renamed because of conflict are logged."""
+        d = defer.Deferred()
+        listen_for(self.main.event_q, 'FSM_FILE_CONFLICT', d.callback)
+
+        testfile = os.path.join(self.main.vm.root.path, 'sample.mp3')
+        mdid = self.main.fs.create(testfile, "")
+        self.main.fs.set_node_id(testfile, "uuid")
+        with open(testfile, "w") as fh:
+            fh.write("this is music!")
+
+        self.main.fs.move_to_conflict(mdid)
+
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          EVENT_INTERPRETATION_U1_CONFLICT_RENAME)
+        self.assertEqual(event.manifestation,
+                          Manifestation.WORLD_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        local_file = event.subjects[0]
+        new_name = testfile + self.main.fs.CONFLICT_SUFFIX
+        self.assertTrue(local_file.uri.endswith(new_name))
+        self.assertEqual(local_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(local_file.manifestation,
+                          Manifestation.FILE_DATA_OBJECT)
+        self.assertTrue(local_file.origin.endswith(testfile))
+        self.assertEqual(local_file.mimetype, "audio/mpeg")
+        self.assertEqual(local_file.storage, STORAGE_LOCAL)
+
+    @defer.inlineCallbacks
+    def test_dir_sync_conflict_is_logged(self):
+        """Dirs renamed because of conflict are logged."""
+        d = defer.Deferred()
+        listen_for(self.main.event_q, 'FSM_DIR_CONFLICT', d.callback)
+
+        testdir = os.path.join(self.main.vm.root.path, 'sampledir')
+        mdid = self.main.fs.create(testdir, "", is_dir=True)
+        self.main.fs.set_node_id(testdir, "uuid")
+        os.mkdir(testdir)
+
+        self.main.fs.move_to_conflict(mdid)
+
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEqual(event.interpretation,
+                          EVENT_INTERPRETATION_U1_CONFLICT_RENAME)
+        self.assertEqual(event.manifestation,
+                          Manifestation.WORLD_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        local_file = event.subjects[0]
+        new_name = testdir + self.main.fs.CONFLICT_SUFFIX
+        self.assertTrue(local_file.uri.endswith(new_name))
+        self.assertEqual(local_file.interpretation, Interpretation.FOLDER)
+        self.assertEqual(local_file.manifestation,
+                          Manifestation.FILE_DATA_OBJECT)
+        self.assertTrue(local_file.origin.endswith(testdir))
+        self.assertEqual(local_file.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEqual(local_file.storage, STORAGE_LOCAL)
+
+class ZeitgeistPublicFilesTestCase(ZeitgeistListenerTestCase):
+    """Public files events are logged into Zeitgeist."""
+
+    @defer.inlineCallbacks
+    def test_publish_url_is_logged(self):
+        """Publishing a file with a url is logged."""
+        share_id = "share"
+        node_id = "node_id"
+        is_public = True
+        public_url = 'http://example.com/foo.mp3'
+
+        share_path = os.path.join(self.shares_dir, 'share')
+        self.main.vm.add_share(Share(path=share_path, volume_id='share',
+                               other_username='other username'))
+        path = os.path.join(share_path, "foo.mp3")
+        self.main.fs.create(path, str(share_id))
+        self.main.fs.set_node_id(path, str(node_id))
+
+        d = defer.Deferred()
+        self._listen_for('AQ_CHANGE_PUBLIC_ACCESS_OK', d.callback)
+        self.main.event_q.push('AQ_CHANGE_PUBLIC_ACCESS_OK',
+                               share_id=share_id, node_id=node_id,
+                               is_public=is_public, public_url=public_url)
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 2)
+        event = self.listener.zg.events[1]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.CREATE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        public_file = event.subjects[0]
+        self.assertEqual(public_file.uri, public_url)
+        self.assertEqual(public_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(public_file.manifestation,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(public_file.origin.endswith(node_id))
+        self.assertEqual(public_file.mimetype, "audio/mpeg")
+        self.assertEqual(public_file.storage, STORAGE_NETWORK)
+
+    @defer.inlineCallbacks
+    def test_unpublish_url_is_logged(self):
+        """Unpublishing a file with a url is logged."""
+        share_id = "share"
+        node_id = "node_id"
+        is_public = False
+        public_url = 'http://example.com/foo.mp3'
+
+        share_path = os.path.join(self.shares_dir, 'share')
+        self.main.vm.add_share(Share(path=share_path, volume_id='share',
+                               other_username='other username'))
+        path = os.path.join(share_path, "foo.mp3")
+        self.main.fs.create(path, str(share_id))
+        self.main.fs.set_node_id(path, str(node_id))
+
+        d = defer.Deferred()
+        self._listen_for('AQ_CHANGE_PUBLIC_ACCESS_OK', d.callback)
+        self.main.event_q.push('AQ_CHANGE_PUBLIC_ACCESS_OK',
+                               share_id=share_id, node_id=node_id,
+                               is_public=is_public, public_url=public_url)
+        yield d
+
+        self.assertEqual(len(self.listener.zg.events), 2)
+        event = self.listener.zg.events[1]
+
+        self.assertEqual(event.interpretation,
+                          Interpretation.DELETE_EVENT)
+        self.assertEqual(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEqual(event.actor, ACTOR_UBUNTUONE)
+
+        public_file = event.subjects[0]
+        self.assertEqual(public_file.uri, public_url)
+        self.assertEqual(public_file.interpretation, Interpretation.AUDIO)
+        self.assertEqual(public_file.manifestation,
+                          Manifestation.DELETED_RESOURCE)
+        self.assertTrue(public_file.origin.endswith(node_id))
+        self.assertEqual(public_file.mimetype, "audio/mpeg")
+        self.assertEqual(public_file.storage, STORAGE_DELETED)

=== modified file 'tests/syncdaemon/test_fsm.py'
--- tests/syncdaemon/test_fsm.py	2010-11-30 19:06:17 +0000
+++ tests/syncdaemon/test_fsm.py	2010-12-13 23:42:15 +0000
@@ -29,6 +29,7 @@
 from contrib.testing.testcase import (
     FakeVolumeManager,
     FakeMain,
+    Listener,
     MementoHandler
 )
 
@@ -1874,6 +1875,41 @@
         # invalid uuid
         self.assertRaises(KeyError, self.fsm.move_to_conflict, "no-such-mdid")
 
+    def test_conflict_file_pushes_event(self):
+        """A conflict with a file pushes FSM_FILE_CONFLICT."""
+        listener = Listener()
+        self.eq.subscribe(listener)
+
+        testfile = os.path.join(self.share_path, "path")
+        mdid = self.fsm.create(testfile, "share")
+        self.fsm.set_node_id(testfile, "uuid")
+        with open(testfile, "w") as fh:
+            fh.write("test!")
+
+        self.fsm.move_to_conflict(mdid)
+
+        new_name = testfile + self.fsm.CONFLICT_SUFFIX
+        kwargs = dict(old_name=testfile, new_name=new_name)
+
+        self.assertTrue(("FSM_FILE_CONFLICT", (), kwargs) in listener.events)
+
+    def test_conflict_dir_pushes_event(self):
+        """A conflict with a dir pushes FSM_DIR_CONFLICT."""
+        listener = Listener()
+        self.eq.subscribe(listener)
+
+        testdir = os.path.join(self.share_path, "path")
+        mdid = self.fsm.create(testdir, "share", is_dir=True)
+        self.fsm.set_node_id(testdir, "uuid")
+        os.mkdir(testdir)
+
+        self.fsm.move_to_conflict(mdid)
+
+        new_name = testdir + self.fsm.CONFLICT_SUFFIX
+        kwargs = dict(old_name=testdir, new_name=new_name)
+
+        self.assertTrue(("FSM_DIR_CONFLICT", (), kwargs) in listener.events)
+
     def test_upload_finished(self):
         """Test upload finished."""
         path = os.path.join(self.share_path, "path")

=== modified file 'tests/syncdaemon/test_sync.py'
--- tests/syncdaemon/test_sync.py	2010-11-30 17:53:14 +0000
+++ tests/syncdaemon/test_sync.py	2010-12-13 23:42:15 +0000
@@ -1518,7 +1518,8 @@
         self.sync.handle_AQ_RESCAN_FROM_SCRATCH_OK(ROOT, [self.rootdt],
                                                    100, 100)
 
-        self.assertEqual(called, [((ROOT, self.filetxtdelta.node_id), {})])
+        args = (ROOT, self.filetxtdelta.node_id, False)
+        self.assertEqual(called, [(args, {})])
 
     def test_deletes_file_in_delta(self):
         """Files in delta should not be deleted."""
@@ -1569,5 +1570,56 @@
             [self.rootdt], 100, 100)
 
         self.assertEqual(called, [
-            (ROOT, dt.node_id),
-            (ROOT, self.dirdelta.node_id)])
+            (ROOT, dt.node_id, False),
+            (ROOT, self.dirdelta.node_id, True)])
+
+
+class TestSyncEvents(BaseSync):
+    """Testing sync stuff related to events."""
+
+    def setUp(self):
+        """Do the setUp."""
+        super(TestSyncEvents, self).setUp()
+        self.sync = Sync(main=self.main)
+        self.handler.setLevel(logging.DEBUG)
+
+        key = FSKey(self.main.fs, share_id='', node_id='node_id')
+        self.ssmr = SyncStateMachineRunner(fsm=self.main.fs, main=self.main,
+                                           key=key, logger=None)
+        self.vm = self.main.vm
+        self.listener = Listener()
+        self.main.event_q.subscribe(self.listener)
+
+    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")
+
+        # check event
+        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")
+
+        # check event
+        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."""
+
+        # delete the fake file
+        self.main.vm._got_root("parent_id")
+        self.sync._handle_SV_FILE_DELETED(ROOT, "node_id", True)
+
+        # check event
+        kwargs = dict(volume_id=ROOT, node_id='node_id', is_dir=True)
+        self.assertIn(("SV_FILE_DELETED", (), kwargs), self.listener.events)

=== modified file 'ubuntuone/syncdaemon/event_logging.py'
--- ubuntuone/syncdaemon/event_logging.py	2010-12-09 14:28:21 +0000
+++ ubuntuone/syncdaemon/event_logging.py	2010-12-13 23:42:15 +0000
@@ -17,21 +17,33 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Event logging from SyncDaemon into Zeitgeist."""
 
+import mimetypes
+
 from zeitgeist.datamodel import Event, Interpretation, Manifestation, Subject
+from zeitgeist.mimetypes import get_interpretation_for_mimetype
 
 from ubuntuone.eventlog import zglog
-from ubuntuone.syncdaemon.volume_manager import Share
+from ubuntuone.syncdaemon.volume_manager import Share, UDF
 
 ACTOR_UBUNTUONE = "dbus://com.ubuntuone.SyncDaemon.service"
 DIRECTORY_MIMETYPE = "inode/directory"
+DEFAULT_MIME = "application/octet-stream"
+DEFAULT_INTERPRETATION = Interpretation.DOCUMENT
 EVENT_INTERPRETATION_U1_FOLDER_SHARED = "u1://FolderShared"
 EVENT_INTERPRETATION_U1_FOLDER_UNSHARED = "u1://FolderUnshared"
 EVENT_INTERPRETATION_U1_SHARE_ACCEPTED = "u1://ShareAccepted"
 EVENT_INTERPRETATION_U1_SHARE_UNACCEPTED = "u1://ShareUnaccepted"
+EVENT_INTERPRETATION_U1_CONFLICT_RENAME = "u1://ConflictRename"
+EVENT_INTERPRETATION_U1_UDF_CREATED = "u1://UserFolderCreated"
+EVENT_INTERPRETATION_U1_UDF_DELETED = "u1://UserFolderDeleted"
+EVENT_INTERPRETATION_U1_UDF_SUBSCRIBED = "u1://UserFolderSubscribed"
+EVENT_INTERPRETATION_U1_UDF_UNSUBSCRIBED = "u1://UserFolderUnsubscribed"
 MANIFESTATION_U1_CONTACT_DATA_OBJECT = "u1://ContactDataObject"
 INTERPRETATION_U1_CONTACT = "u1://Contact"
 URI_PROTOCOL_U1 = "ubuntuone:"
+STORAGE_LOCAL = ""
 STORAGE_NETWORK = "net"
+STORAGE_DELETED = "deleted"
 
 class ZeitgeistListener(object):
     """An Event Queue listener that logs into ZG."""
@@ -41,6 +53,8 @@
         self.fsm = fsm
         self.vm = vm
         self.zg = zglog.ZeitgeistLogger()
+        self.newly_created_server_files = set()
+        self.newly_created_local_files = set()
 
     def handle_AQ_CREATE_SHARE_OK(self, share_id=None, marker=None):
         """Log the 'directory shared thru the server' event."""
@@ -153,7 +167,351 @@
 
         self.zg.log(event)
 
+    def log_udf_deleted(self, volume):
+        """Log the udf deleted event."""
+        folder = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(volume.node_id),
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.DELETED_RESOURCE,
+            origin="file:///" + volume.path,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_DELETED)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_UDF_DELETED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder])
+
+        self.zg.log(event)
+
     def handle_VM_VOLUME_DELETED(self, volume):
         """Log the share/UDF unaccepted event."""
         if isinstance(volume, Share):
             self.log_share_unaccepted(volume)
+        if isinstance(volume, UDF):
+            self.log_udf_deleted(volume)
+
+    def handle_VM_UDF_CREATED(self, udf):
+        """An udf was created. Log it into Zeitgeist."""
+        folder = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(udf.node_id),
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin="file:///" + udf.path,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_NETWORK)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_UDF_CREATED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder])
+
+        self.zg.log(event)
+
+    def handle_VM_UDF_SUBSCRIBED(self, udf):
+        """An udf was subscribed."""
+
+        folder = Subject.new_for_values(
+            uri="file:///" + udf.path,
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.FILE_DATA_OBJECT,
+            origin=URI_PROTOCOL_U1 + str(udf.node_id),
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_LOCAL)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_UDF_SUBSCRIBED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder])
+
+        self.zg.log(event)
+
+    def handle_VM_UDF_UNSUBSCRIBED(self, udf):
+        """An udf was unsubscribed."""
+
+        folder = Subject.new_for_values(
+            uri="file:///" + udf.path,
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.DELETED_RESOURCE,
+            origin=URI_PROTOCOL_U1 + str(udf.node_id),
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_DELETED)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_UDF_UNSUBSCRIBED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder])
+
+        self.zg.log(event)
+
+    def handle_AQ_FILE_NEW_OK(self, volume_id, marker, new_id, new_generation):
+        """A new file was created on server. Store and wait till it uploads."""
+        self.newly_created_server_files.add((volume_id, new_id))
+
+    def get_mime_and_interpretation_for_filepath(self, filepath):
+        """Try to guess the mime and the interpretation from the path."""
+        mime, encoding = mimetypes.guess_type(filepath)
+        if mime is None:
+            return DEFAULT_MIME, DEFAULT_INTERPRETATION
+        interpret = get_interpretation_for_mimetype(mime)
+        if interpret is None:
+            return DEFAULT_MIME, Interpretation.DOCUMENT
+        return mime, interpret
+
+    def handle_AQ_UPLOAD_FINISHED(self, share_id, node_id, hash,
+                                  new_generation):
+        """A file finished uploading to the server."""
+
+        mdo = self.fsm.get_by_node_id(share_id, node_id)
+        path = self.fsm.get_abspath(share_id, mdo.path)
+
+        if (share_id, node_id) in self.newly_created_server_files:
+            self.newly_created_server_files.remove((share_id, node_id))
+            event_interpretation = Interpretation.CREATE_EVENT
+        else:
+            event_interpretation = Interpretation.MODIFY_EVENT
+
+        mime, interp = self.get_mime_and_interpretation_for_filepath(path)
+
+        file_subject = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(node_id),
+            interpretation=interp,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin="file:///" + path,
+            mimetype=mime,
+            storage=STORAGE_NETWORK)
+
+        event = Event.new_for_values(
+            interpretation=event_interpretation,
+            manifestation=Manifestation.SCHEDULED_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[file_subject])
+
+        self.zg.log(event)
+
+    def handle_AQ_DIR_NEW_OK(self, volume_id, marker, new_id, new_generation):
+        """A dir was created on the server."""
+
+        mdo = self.fsm.get_by_node_id(volume_id, new_id)
+        path = self.fsm.get_abspath(volume_id, mdo.path)
+
+        file_subject = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(new_id),
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin="file:///" + path,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_NETWORK)
+
+        event = Event.new_for_values(
+            interpretation=Interpretation.CREATE_EVENT,
+            manifestation=Manifestation.SCHEDULED_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[file_subject])
+
+        self.zg.log(event)
+
+    def handle_SV_FILE_NEW(self, volume_id, node_id, parent_id, name):
+        """A file was created locally by Syncdaemon."""
+        self.newly_created_local_files.add((volume_id, node_id))
+
+    def handle_AQ_DOWNLOAD_FINISHED(self, share_id, node_id, server_hash):
+        """A file finished downloading from the server."""
+
+        mdo = self.fsm.get_by_node_id(share_id, node_id)
+        path = self.fsm.get_abspath(share_id, mdo.path)
+
+        if (share_id, node_id) in self.newly_created_local_files:
+            self.newly_created_local_files.remove((share_id, node_id))
+            event_interpretation = Interpretation.CREATE_EVENT
+        else:
+            event_interpretation = Interpretation.MODIFY_EVENT
+
+        mime, interp = self.get_mime_and_interpretation_for_filepath(path)
+
+        file_subject = Subject.new_for_values(
+            uri="file:///" + path,
+            interpretation=interp,
+            manifestation=Manifestation.FILE_DATA_OBJECT,
+            origin=URI_PROTOCOL_U1 + str(node_id),
+            mimetype=mime,
+            storage=STORAGE_LOCAL)
+
+        event = Event.new_for_values(
+            interpretation=event_interpretation,
+            manifestation=Manifestation.WORLD_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[file_subject])
+
+        self.zg.log(event)
+
+    def handle_SV_DIR_NEW(self, volume_id, node_id, parent_id, name):
+        """A file finished downloading from the server."""
+
+        mdo = self.fsm.get_by_node_id(volume_id, node_id)
+        path = self.fsm.get_abspath(volume_id, mdo.path)
+
+        file_subject = Subject.new_for_values(
+            uri="file:///" + path,
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.FILE_DATA_OBJECT,
+            origin=URI_PROTOCOL_U1 + str(node_id),
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_LOCAL)
+
+        event = Event.new_for_values(
+            interpretation=Interpretation.CREATE_EVENT,
+            manifestation=Manifestation.WORLD_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[file_subject])
+
+        self.zg.log(event)
+
+    def handle_SV_FILE_DELETED(self, volume_id, node_id, is_dir):
+        """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:
+            mime, interp = DIRECTORY_MIMETYPE, Interpretation.FOLDER
+        else:
+            mime, interp = self.get_mime_and_interpretation_for_filepath(path)
+
+        file_subject = Subject.new_for_values(
+            uri="file:///" + path,
+            interpretation=interp,
+            manifestation=Manifestation.DELETED_RESOURCE,
+            origin=URI_PROTOCOL_U1 + str(node_id),
+            mimetype=mime,
+            storage=STORAGE_DELETED)
+
+        event = Event.new_for_values(
+            interpretation=Interpretation.DELETE_EVENT,
+            manifestation=Manifestation.WORLD_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[file_subject])
+
+        self.zg.log(event)
+
+    def handle_AQ_UNLINK_OK(self, share_id, parent_id, node_id,
+                            new_generation):
+        """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:
+            mime, interp = DIRECTORY_MIMETYPE, Interpretation.FOLDER
+        else:
+            mime, interp = self.get_mime_and_interpretation_for_filepath(path)
+
+        file_subject = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(node_id),
+            interpretation=interp,
+            manifestation=Manifestation.DELETED_RESOURCE,
+            origin="file:///" + path,
+            mimetype=mime,
+            storage=STORAGE_DELETED)
+
+        event = Event.new_for_values(
+            interpretation=Interpretation.DELETE_EVENT,
+            manifestation=Manifestation.SCHEDULED_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[file_subject])
+
+        self.zg.log(event)
+
+    def handle_FSM_FILE_CONFLICT(self, old_name, new_name):
+        """A file was renamed because of conflict."""
+        mime, interp = self.get_mime_and_interpretation_for_filepath(old_name)
+
+        file_subject = Subject.new_for_values(
+            uri="file:///" + new_name,
+            interpretation=interp,
+            manifestation=Manifestation.FILE_DATA_OBJECT,
+            origin="file:///" + old_name,
+            mimetype=mime,
+            storage=STORAGE_LOCAL)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_CONFLICT_RENAME,
+            manifestation=Manifestation.WORLD_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[file_subject])
+
+        self.zg.log(event)
+
+    def handle_FSM_DIR_CONFLICT(self, old_name, new_name):
+        """A dir was renamed because of conflict."""
+        folder_subject = Subject.new_for_values(
+            uri="file:///" + new_name,
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.FILE_DATA_OBJECT,
+            origin="file:///" + old_name,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_LOCAL)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_CONFLICT_RENAME,
+            manifestation=Manifestation.WORLD_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder_subject])
+
+        self.zg.log(event)
+
+    def handle_AQ_CHANGE_PUBLIC_ACCESS_OK(self, share_id, node_id, is_public,
+                                          public_url):
+        """The status of a published resource changed. Log it!"""
+        if is_public:
+            self.log_publishing(share_id, node_id, is_public, public_url)
+        else:
+            self.log_unpublishing(share_id, node_id, is_public, public_url)
+
+    def log_publishing(self, share_id, node_id, is_public, public_url):
+        """Log the publishing of a resource."""
+        mime, interp = self.get_mime_and_interpretation_for_filepath(
+                                                                    public_url)
+
+        origin = "" if node_id is None else URI_PROTOCOL_U1 + str(node_id)
+
+        public_file = Subject.new_for_values(
+            uri=public_url,
+            interpretation=interp,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin=origin,
+            mimetype=mime,
+            storage=STORAGE_NETWORK)
+
+        event = Event.new_for_values(
+            interpretation=Interpretation.CREATE_EVENT,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[public_file])
+
+        self.zg.log(event)
+
+    def log_unpublishing(self, share_id, node_id, is_public, public_url):
+        """Log the unpublishing of a resource."""
+        mime, interp = self.get_mime_and_interpretation_for_filepath(
+                                                                    public_url)
+
+        origin = "" if node_id is None else URI_PROTOCOL_U1 + str(node_id)
+
+        public_file = Subject.new_for_values(
+            uri=public_url,
+            interpretation=interp,
+            manifestation=Manifestation.DELETED_RESOURCE,
+            origin=origin,
+            mimetype=mime,
+            storage=STORAGE_DELETED)
+
+        event = Event.new_for_values(
+            interpretation=Interpretation.DELETE_EVENT,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[public_file])
+
+        self.zg.log(event)

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2010-12-09 21:05:56 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2010-12-13 23:42:15 +0000
@@ -101,6 +101,9 @@
     'SV_VOLUME_CREATED': ('volume',),
     'SV_VOLUME_DELETED': ('volume_id',),
     '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'),
 
     'HQ_HASH_NEW': ('path', 'hash', 'crc32', 'size', 'stat'),
     'HQ_HASH_ERROR': ('mdid',),
@@ -138,6 +141,9 @@
     'SYS_QUOTA_EXCEEDED': ('volume_id', 'free_bytes'),
     'SYS_BROKEN_NODE': ('volume_id', 'node_id', 'path', 'mdid'),
 
+    'FSM_FILE_CONFLICT': ('old_name', 'new_name'),
+    'FSM_DIR_CONFLICT': ('old_name', 'new_name'),
+
     'VM_UDF_SUBSCRIBED': ('udf',),
     'VM_UDF_SUBSCRIBE_ERROR': ('udf_id', 'error'),
     'VM_UDF_UNSUBSCRIBED': ('udf',),

=== modified file 'ubuntuone/syncdaemon/filesystem_manager.py'
--- ubuntuone/syncdaemon/filesystem_manager.py	2010-12-02 21:27:56 +0000
+++ ubuntuone/syncdaemon/filesystem_manager.py	2010-12-13 23:42:15 +0000
@@ -840,7 +840,8 @@
         while path_exists(to_path):
             ind += 1
             to_path = base_to_path + "." + str(ind)
-        if mdobj["is_dir"]:
+        is_dir = mdobj["is_dir"]
+        if is_dir:
             expected_event = "FS_DIR_MOVE"
         else:
             expected_event = "FS_FILE_MOVE"
@@ -848,6 +849,8 @@
             try:
                 self.eq.add_to_mute_filter(expected_event, path, to_path)
                 rename(path, to_path)
+                event = "FSM_DIR_CONFLICT" if is_dir else "FSM_FILE_CONFLICT"
+                self.eq.push(event, old_name=path, new_name=to_path)
             except OSError, e:
                 self.eq.rm_from_mute_filter(expected_event, path, to_path)
                 if e.errno == errno.ENOENT:

=== modified file 'ubuntuone/syncdaemon/sync.py'
--- ubuntuone/syncdaemon/sync.py	2010-11-08 16:45:50 +0000
+++ ubuntuone/syncdaemon/sync.py	2010-12-13 23:42:15 +0000
@@ -830,6 +830,8 @@
         log = FileLogger(self.logger, key)
         ssmr = SyncStateMachineRunner(self.fsm, self.m, key, log)
         ssmr.on_event("SV_FILE_NEW", {}, share_id, node_id, parent_id, name)
+        self.m.event_q.push('SV_FILE_NEW', volume_id=share_id,
+                            node_id=node_id, parent_id=parent_id, name=name)
 
     def _handle_SV_DIR_NEW(self, share_id, node_id, parent_id, name):
         """on SV_DIR_NEW"""
@@ -839,13 +841,17 @@
         log = FileLogger(self.logger, key)
         ssmr = SyncStateMachineRunner(self.fsm, self.m, key, log)
         ssmr.on_event("SV_DIR_NEW", {}, share_id, node_id, parent_id, name)
+        self.m.event_q.push('SV_DIR_NEW', volume_id=share_id,
+                            node_id=node_id, parent_id=parent_id, name=name)
 
-    def _handle_SV_FILE_DELETED(self, share_id, node_id):
+    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)
         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)
 
     def handle_AQ_DOWNLOAD_FINISHED(self, share_id, node_id, server_hash):
         """on AQ_DOWNLOAD_FINISHED"""
@@ -1078,7 +1084,8 @@
                 # about it
                 if not dt.is_live:
                     to_delete.append(dt)
-                    self._handle_SV_FILE_DELETED(dt.share_id, dt.node_id)
+                    self._handle_SV_FILE_DELETED(dt.share_id, dt.node_id,
+                                                 is_dir)
                     # nothing else should happen with this
                     continue
 
@@ -1194,7 +1201,7 @@
                 continue
 
             if not node_id in live_nodes:
-                self._handle_SV_FILE_DELETED(volume_id, node_id)
+                self._handle_SV_FILE_DELETED(volume_id, node_id, node.is_dir)
                 deletes += 1
 
         self.logger.info(