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

[Alejandro J. Cura]

Share invite, create, deleting and unsubscribe events are added to zeitgeist

Share invite, create, deleting and unsubscribe events are added to zeitgeist

[Guillermo Gonzalez (verterok)]

looks good.

review: Approve

[Facundo Batista (facundo)]

Like it

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

No proposals found for merge of lp:~alecu/ubuntuone-client/add-simple-zeitgeist into lp:ubuntuone-client.

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-11-30 17:53:14 +0000
+++ contrib/testing/testcase.py	2010-12-09 14:33:06 +0000
@@ -305,6 +305,40 @@
         return TwistedTestCase.tearDown(self)
 
 
+class FakeMainTestCase(BaseTwistedTestCase):
+    """A testcase that starts up a Main instance."""
+
+    def setUp(self):
+        """Setup the infrastructure for the test."""
+        BaseTwistedTestCase.setUp(self)
+        self.log = logging.getLogger("ubuntuone.SyncDaemon.TEST")
+        self.log.info("starting test %s.%s", self.__class__.__name__,
+                      self._testMethodName)
+        self.timeout = 2
+        self.data_dir = self.mktemp('data_dir')
+        self.partials_dir = self.mktemp('partials')
+        self.root_dir = self.mktemp('root_dir')
+        self.shares_dir = self.mktemp('shares_dir')
+        self.main = FakeMain(self.root_dir, self.shares_dir,
+                             self.data_dir, self.partials_dir)
+        self.vm = self.main.vm
+        self.fs = self.main.fs
+        self.event_q = self.main.event_q
+        self.action_q = self.main.action_q
+        self.event_q.push('SYS_INIT_DONE')
+
+    def tearDown(self):
+        """Shutdown this testcase."""
+        BaseTwistedTestCase.tearDown(self)
+        self.main.shutdown()
+        self.rmtree(self.shares_dir)
+        self.rmtree(self.root_dir)
+        self.rmtree(self.data_dir)
+        self.rmtree(self.partials_dir)
+        self.log.info("finished test %s.%s", self.__class__.__name__,
+                      self._testMethodName)
+
+
 class MementoHandler(logging.Handler):
     """ A handler class which store logging records in a list """
 

=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2010-12-06 15:01:06 +0000
+++ tests/syncdaemon/test_action_queue.py	2010-12-09 14:33:06 +0000
@@ -2958,6 +2958,27 @@
         res = [getattr(cmd, x) for x in cmd.possible_markers]
         self.assertEqual(res, ['node_id'])
 
+    def test_handle_success_sends_invitation(self):
+        """The success handler sends the AQ_SHARE_INVITATION_SENT event."""
+        marker_id = "marker"
+        share_name = "share name"
+        share_to = "[e-mail]"
+
+        class MockResult(object):
+            """A mock result."""
+            share_id = SHARE
+
+        mock_success = MockResult()
+        cmd = CreateShare(self.request_queue, NODE, share_to,
+                          share_name, 'View', marker_id)
+        cmd.log = cmd.make_logger()
+        cmd.use_http = True
+        cmd.handle_success(mock_success)
+
+        event_params = { 'marker': marker_id }
+        events = [('AQ_SHARE_INVITATION_SENT', (), event_params)]
+        self.assertEqual(events, cmd.action_queue.event_queue.events)
+
 
 class RequestQueueManagerTestCase(FactoryBaseTestCase):
     """Test how RequestQueue manages the queues."""

=== added file 'tests/syncdaemon/test_event_logging.py'
--- tests/syncdaemon/test_event_logging.py	1970-01-01 00:00:00 +0000
+++ tests/syncdaemon/test_event_logging.py	2010-12-09 14:33:06 +0000
@@ -0,0 +1,282 @@
+# tests.syncdaemon.test_event_logging - test logging ZG events
+#
+# Author: Alejandro J. Cura <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Test the event logging from SyncDaemon into Zeitgeist."""
+
+import os
+import uuid
+
+from twisted.internet import defer
+from zeitgeist.datamodel import Interpretation, Manifestation
+
+from contrib.testing.testcase import FakeMainTestCase
+from ubuntuone.storageprotocol.sharersp import NotifyShareHolder
+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,
+        MANIFESTATION_U1_CONTACT_DATA_OBJECT, DIRECTORY_MIMETYPE,
+        INTERPRETATION_U1_CONTACT, URI_PROTOCOL_U1, STORAGE_NETWORK)
+from ubuntuone.syncdaemon.volume_manager import Share, Shared
+
+
+class MockLogger(object):
+    """A mock logger that stores whatever is logged into it."""
+
+    def __init__(self):
+        """Initialize this instance."""
+        self.events = []
+
+    def log(self, event):
+        """Log the event."""
+        self.events.append(event)
+
+
+class ZeitgeistListenerTestCase(FakeMainTestCase):
+    """Tests for ZeitgeistListener."""
+
+    def setUp(self):
+        """Initialize this instance."""
+        super(ZeitgeistListenerTestCase, self).setUp()
+        self.patch(zglog, "ZeitgeistLogger", MockLogger)
+        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 test_share_created_with_username_is_logged(self):
+        """A ShareCreated event is logged."""
+        fake_username = "fake user"
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        sample_node_id = "node id"
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, sample_node_id)
+
+        def fake_create_share(node_id, user, name, access_level, marker):
+            """Fake the creation of the share on the server."""
+            self.assertIn(marker, self.vm.marker_share_map)
+            share_id = self.fs.get_by_mdid(marker).share_id
+            self.main.event_q.push('AQ_CREATE_SHARE_OK',
+                                   share_id=share_id,
+                                   marker=marker)
+
+        self.patch(self.main.action_q, "create_share", fake_create_share)
+        self.vm.create_share(path, fake_username, 'shared_name', 'View')
+
+        self.assert_folder_shared_is_logged(path, fake_username)
+
+    def test_share_created_with_email_is_logged(self):
+        """A ShareCreated event is logged."""
+        fake_username = "[e-mail]"
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        sample_node_id = "node id"
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, sample_node_id)
+
+        def fake_create_share(node_id, user, name, access_level, marker):
+            """Fake the creation of the share on the server."""
+            self.assertIn(marker, self.vm.marker_share_map)
+            self.main.event_q.push('AQ_SHARE_INVITATION_SENT',
+                                   marker=marker)
+
+        self.patch(self.main.action_q, "create_share", fake_create_share)
+        self.vm.create_share(path, fake_username, 'shared_name', 'View')
+
+        self.assert_folder_shared_is_logged(path, fake_username)
+
+    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)
+        event = self.listener.zg.events[0]
+
+        self.assertEquals(event.interpretation,
+                          EVENT_INTERPRETATION_U1_FOLDER_SHARED)
+        self.assertEquals(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEquals(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,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(folder.origin.endswith(path))
+        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEquals(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,
+                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+
+    @defer.inlineCallbacks
+    def test_share_deleted_is_logged(self):
+        """Test VolumeManager.delete_share."""
+        sample_share_id = "share id"
+        sample_node_id = "node id"
+        fake_username = "fake user"
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, sample_node_id)
+        share = Shared(path=path, volume_id=sample_share_id,
+                       node_id=sample_node_id, other_username=fake_username)
+        self.vm.add_shared(share)
+
+        def fake_delete_share(share_id):
+            """Fake delete_share."""
+            self.assertEqual(share_id, share.volume_id)
+            self.main.event_q.push('AQ_DELETE_SHARE_OK', share_id)
+
+        self.patch(self.main.action_q, 'delete_share', fake_delete_share)
+        d = defer.Deferred()
+        self._listen_for('VM_SHARE_DELETED', d.callback, 1, collect=True)
+        self.vm.delete_share(share.volume_id)
+        yield d
+
+        self.assertEquals(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEquals(event.interpretation,
+                          EVENT_INTERPRETATION_U1_FOLDER_UNSHARED)
+        self.assertEquals(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEquals(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,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(folder.origin.endswith(path))
+        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEquals(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,
+                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+    def test_share_accepted_is_logged(self):
+        """Test that an accepted share event is logged."""
+        # initialize the the root
+        self.vm._got_root('root_uuid')
+        fake_username = "fake user"
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        self.main.fs.create(path, "")
+        share_path = os.path.join(self.shares_dir, 'fake_share')
+        share = Share(path=share_path, volume_id='volume_id', node_id="node_id",
+                      other_username=fake_username)
+        self.vm.add_share(share)
+
+        self.assertEquals(len(self.listener.zg.events), 1)
+        event = self.listener.zg.events[0]
+
+        self.assertEquals(event.interpretation,
+                          EVENT_INTERPRETATION_U1_SHARE_ACCEPTED)
+        self.assertEquals(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEquals(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,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(folder.origin.endswith(share_path))
+        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEquals(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,
+                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+
+    @defer.inlineCallbacks
+    def test_share_unaccepted_is_logged(self):
+        """Test that an unaccepted share event is logged."""
+        fake_username = "fake user"
+        d = defer.Deferred()
+
+        share_path = os.path.join(self.main.shares_dir, 'share')
+        holder = NotifyShareHolder.from_params(uuid.uuid4(),
+                                                     uuid.uuid4(),
+                                                     u'fake_share',
+                                                     fake_username,
+                                                     u'visible_name', 'Read')
+
+        self.main.vm.add_share(Share.from_notify_holder(holder, share_path))
+        self._listen_for('VM_VOLUME_DELETED', d.callback, 1, collect=True)
+        self.main.event_q.push('SV_SHARE_DELETED', holder.share_id)
+        yield d
+
+        self.assertEquals(len(self.listener.zg.events), 2)
+        event = self.listener.zg.events[1]
+
+        self.assertEquals(event.interpretation,
+                          EVENT_INTERPRETATION_U1_SHARE_UNACCEPTED)
+        self.assertEquals(event.manifestation,
+                          Manifestation.USER_ACTIVITY)
+        self.assertEquals(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,
+                          Manifestation.REMOTE_DATA_OBJECT)
+        self.assertTrue(folder.origin.endswith(share_path))
+        self.assertEquals(folder.mimetype, DIRECTORY_MIMETYPE)
+        self.assertEquals(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,
+                          MANIFESTATION_U1_CONTACT_DATA_OBJECT)

=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2010-12-06 15:01:06 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2010-12-09 14:33:06 +0000
@@ -1718,14 +1718,12 @@
         """It worked! Push the event."""
         # We don't get a share_id back from the HTTP REST method
         if not self.use_http:
-            self.log.debug('Pushing AQ_CREATE_SHARE_OK (share_id: %s) because '
-                           'self.use_http is False.', success.share_id)
             self.action_queue.event_queue.push('AQ_CREATE_SHARE_OK',
                                                share_id=success.share_id,
                                                marker=self.marker)
         else:
-            self.log.warn('not pushing AQ_CREATE_SHARE_OK because '
-                          'self.use_http is True.')
+            self.action_queue.event_queue.push('AQ_SHARE_INVITATION_SENT',
+                                               marker=self.marker)
         return success
 
     def handle_failure(self, failure):

=== added file 'ubuntuone/syncdaemon/event_logging.py'
--- ubuntuone/syncdaemon/event_logging.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/syncdaemon/event_logging.py	2010-12-09 14:33:06 +0000
@@ -0,0 +1,159 @@
+# ubuntuone.syncdaemon.event_logging - listen for SD events, log into ZG
+#
+# Author: Alejandro J. Cura <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Event logging from SyncDaemon into Zeitgeist."""
+
+from zeitgeist.datamodel import Event, Interpretation, Manifestation, Subject
+
+from ubuntuone.eventlog import zglog
+from ubuntuone.syncdaemon.volume_manager import Share
+
+ACTOR_UBUNTUONE = "dbus://com.ubuntuone.SyncDaemon.service"
+DIRECTORY_MIMETYPE = "inode/directory"
+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"
+MANIFESTATION_U1_CONTACT_DATA_OBJECT = "u1://ContactDataObject"
+INTERPRETATION_U1_CONTACT = "u1://Contact"
+URI_PROTOCOL_U1 = "ubuntuone:"
+STORAGE_NETWORK = "net"
+
+class ZeitgeistListener(object):
+    """An Event Queue listener that logs into ZG."""
+
+    def __init__(self, fsm, vm):
+        """Initialize this instance."""
+        self.fsm = fsm
+        self.vm = vm
+        self.zg = zglog.ZeitgeistLogger()
+
+    def handle_AQ_CREATE_SHARE_OK(self, share_id=None, marker=None):
+        """Log the 'directory shared thru the server' event."""
+        share = self.vm.shared[share_id]
+        self.log_folder_shared(share, share_id)
+
+    def handle_AQ_SHARE_INVITATION_SENT(self, marker):
+        """Log the 'directory shared thru http' event."""
+        share = self.vm.marker_share_map[marker]
+        mdo = self.fsm.get_by_mdid(marker)
+        self.log_folder_shared(share, mdo.share_id)
+
+    def log_folder_shared(self, share, share_id):
+        """Log the 'directory shared' event."""
+        fullpath = self.fsm.get_abspath(share_id, share.path)
+
+        folder = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(share.node_id),
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin="file:///" + fullpath,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_NETWORK)
+
+        other_username = share.other_username
+        other_user = Subject.new_for_values(
+            uri="mailto:" + other_username,
+            interpretation=INTERPRETATION_U1_CONTACT,
+            manifestation=MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_FOLDER_SHARED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder, other_user])
+
+        self.zg.log(event)
+
+    def handle_VM_SHARE_DELETED(self, share):
+        """Log the share deleted event."""
+        folder = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(share.node_id),
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin="file:///" + share.path,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_NETWORK)
+
+        other_username = share.other_username
+        other_user = Subject.new_for_values(
+            uri="mailto:" + other_username,
+            interpretation=INTERPRETATION_U1_CONTACT,
+            manifestation=MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_FOLDER_UNSHARED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder, other_user])
+
+        self.zg.log(event)
+
+    def handle_VM_SHARE_CREATED(self, share_id):
+        """Log the share accepted event."""
+        share = self.vm.shares[share_id]
+
+        folder = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(share.node_id),
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin="file:///" + share.path,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_NETWORK)
+
+        other_username = share.other_username
+        other_user = Subject.new_for_values(
+            uri="mailto:" + other_username,
+            interpretation=INTERPRETATION_U1_CONTACT,
+            manifestation=MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_SHARE_ACCEPTED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder, other_user])
+
+        self.zg.log(event)
+
+    def log_share_unaccepted(self, share):
+        """Log the share unaccepted event."""
+        folder = Subject.new_for_values(
+            uri=URI_PROTOCOL_U1 + str(share.node_id),
+            interpretation=Interpretation.FOLDER,
+            manifestation=Manifestation.REMOTE_DATA_OBJECT,
+            origin="file:///" + share.path,
+            mimetype=DIRECTORY_MIMETYPE,
+            storage=STORAGE_NETWORK)
+
+        other_username = share.other_username
+        other_user = Subject.new_for_values(
+            uri="mailto:" + other_username,
+            interpretation=INTERPRETATION_U1_CONTACT,
+            manifestation=MANIFESTATION_U1_CONTACT_DATA_OBJECT)
+
+        event = Event.new_for_values(
+            interpretation=EVENT_INTERPRETATION_U1_SHARE_UNACCEPTED,
+            manifestation=Manifestation.USER_ACTIVITY,
+            actor=ACTOR_UBUNTUONE,
+            subjects=[folder, other_user])
+
+        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)

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2010-11-30 19:06:17 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2010-12-09 14:33:06 +0000
@@ -64,6 +64,7 @@
     'AQ_UPLOAD_ERROR': ('share_id', 'node_id', 'error', 'hash'),
     'AQ_SHARES_LIST': ('shares_list',),
     'AQ_LIST_SHARES_ERROR': ('error',),
+    'AQ_SHARE_INVITATION_SENT': ('marker',),
     'AQ_CREATE_SHARE_OK': ('share_id', 'marker'),
     'AQ_CREATE_SHARE_ERROR': ('marker', 'error'),
     'AQ_DELETE_SHARE_OK': ('share_id',),

=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2010-12-01 20:56:01 +0000
+++ ubuntuone/syncdaemon/main.py	2010-12-09 14:33:06 +0000
@@ -30,6 +30,7 @@
     event_queue,
     filesystem_manager,
     hash_queue,
+    event_logging,
     events_nanny,
     local_rescan,
     sync,
@@ -123,7 +124,8 @@
             self, glib_loop, broadcast_events)
         self.action_q.content_queue.set_change_notification_cb(
             self.external.change_notification)
-
+        self.zg_listener = event_logging.ZeitgeistListener(self.fs, self.vm)
+        self.event_q.subscribe(self.zg_listener)
         self.logger.info("Using %r as root dir", self.root_dir)
         self.logger.info("Using %r as data dir", self.data_dir)
         self.logger.info("Using %r as shares root dir", self.shares_dir)