Merge lp:~dobey/ubuntuone-client/rm-zeitgeist into lp:ubuntuone-client

[dobey]

Remove usage of zg to reduce complexity, as we aren't using the feature.

[Alejandro J. Cura (alecu)]

The code removal looks good. +1
We never ended up giving this any real usage, since we found better ways to do the status reporting. So I'm happy that all of this is finally gone.

review: Approve

[Mike McCracken (mikemc)]

review: Approve

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2013-01-22 20:03:12 +0000
+++ contrib/testing/testcase.py	2013-02-04 16:10:53 +0000
@@ -293,7 +293,6 @@
         self.lr = local_rescan.LocalRescan(self.vm, self.fs,
                                            self.event_q, self.action_q)
 
-        self.eventlog_listener = None
         self.status_listener = FakeStatusListener()
 
     def _connect_aq(self, _):
 
=== removed directory 'tests/platform/event_logging'
=== removed file 'tests/platform/event_logging/__init__.py'
--- tests/platform/event_logging/__init__.py	2012-05-02 22:09:13 +0000
+++ tests/platform/event_logging/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-# Copyright 2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Platform/event_logging test code."""
 
=== removed file 'tests/platform/event_logging/test_linux.py'
--- tests/platform/event_logging/test_linux.py	2012-05-02 22:09:13 +0000
+++ tests/platform/event_logging/test_linux.py	1970-01-01 00:00:00 +0000
@@ -1,92 +0,0 @@
-# tests.platform.event_logging.test_linux
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Test the event logging on linux."""
-
-import sys
-
-from twisted.trial.unittest import TestCase
-
-import ubuntuone.platform.event_logging.linux as event_logging
-
-
-class ZeitgeistDetectionTestCase(TestCase):
-    """Test the is_zeitgeist_installed function."""
-
-    def patch_module(self, module_name, fake_module):
-        """Monkey patch a module for the duration of the test."""
-        UNDEFINED = object()
-        real_module = sys.modules.get(module_name, UNDEFINED)
-
-        def restore():
-            """Restore the real_module."""
-            if real_module is UNDEFINED:
-                del(sys.modules[module_name])
-            else:
-                sys.modules[module_name] = real_module
-
-        self.addCleanup(restore)
-        sys.modules[module_name] = fake_module
-
-    def test_zg_installed_returns_true(self):
-        """When zg is installed, it returns true."""
-        self.patch_module("zeitgeist", object())
-        self.patch_module("zeitgeist.mimetypes", object())
-        result = event_logging.is_zeitgeist_installed()
-        self.assertEqual(result, True)
-
-    def test_zg_not_installed_returns_false(self):
-        """When zg is not installed, it returns false."""
-        self.patch_module("zeitgeist", None)
-        result = event_logging.is_zeitgeist_installed()
-        self.assertEqual(result, False)
-
-    def test_old_zg_installed_returns_false(self):
-        """When an old zg is installed, it returns false."""
-        self.patch_module("zeitgeist", object())
-        self.patch_module("zeitgeist.mimetypes", None)
-        result = event_logging.is_zeitgeist_installed()
-        self.assertEqual(result, False)
-
-
-class GetListenerTestCase(TestCase):
-    """The zg listener is created."""
-
-    def test_zeitgeist_installed_returns_listener(self):
-        """get_listener returns a listener if ZG installed."""
-        self.patch(event_logging, "is_zeitgeist_installed", lambda: True)
-        listener = event_logging.get_listener(None, None)
-        self.assertNotEqual(listener, None)
-
-    def test_zeitgeist_not_installed_returns_none(self):
-        """get_listener returns None if ZG not installed."""
-        self.patch(event_logging, "is_zeitgeist_installed", lambda: False)
-        listener = event_logging.get_listener(None, None)
-        self.assertEqual(listener, None)
 
=== removed file 'tests/platform/event_logging/test_windows.py'
--- tests/platform/event_logging/test_windows.py	2012-05-02 22:09:13 +0000
+++ tests/platform/event_logging/test_windows.py	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-# tests.platform.windows.test_event_logging
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Test the event logging on windows."""
-
-from twisted.trial import unittest
-
-class GetListenerTestCase(unittest.TestCase):
-    """Listener creation tests."""
-
-    def test_never_creates_a_listener(self):
-        """The listener is never created on windows."""
-        from ubuntuone.platform import event_logging
-        listener = event_logging.get_listener(None, None)
-        self.assertEqual(listener, None)
-
 
=== removed directory 'tests/platform/linux/eventlog'
=== removed file 'tests/platform/linux/eventlog/__init__.py'
--- tests/platform/linux/eventlog/__init__.py	2012-04-09 20:07:05 +0000
+++ tests/platform/linux/eventlog/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Tests module."""
 
=== removed file 'tests/platform/linux/eventlog/test_zg_listener.py'
--- tests/platform/linux/eventlog/test_zg_listener.py	2012-10-16 15:13:24 +0000
+++ tests/platform/linux/eventlog/test_zg_listener.py	1970-01-01 00:00:00 +0000
@@ -1,1216 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Test the event logging from SyncDaemon into Zeitgeist."""
-
-import logging
-import os
-import sys
-import uuid
-
-from os.path import basename
-from twisted.internet import defer
-from zeitgeist.datamodel import Interpretation, Manifestation
-
-# python-zeitgeist on lucid has no mimetypes module, and it's usually
-# disabled, but fake it for running tests on lucid
-try:
-    import zeitgeist.mimetypes
-    assert(zeitgeist.mimetypes is not None)  # make pyflakes happy
-except ImportError:
-
-    class FakeMimetypes(object):
-        """A fake zg.mimetypes module."""
-
-        def get_interpretation_for_mimetype(self, mimetype):
-            """This fake always returns AUDIO."""
-            return Interpretation.AUDIO
-
-    sys.modules["zeitgeist.mimetypes"] = FakeMimetypes()
-
-from contrib.testing.testcase import (
-        FakeMain, FakeMainTestCase, BaseTwistedTestCase)
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.platform import expand_user
-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.eventlog.zg_listener 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_DELETED, STORAGE_NETWORK, STORAGE_LOCAL)
-from ubuntuone.syncdaemon.sync import Sync
-from ubuntuone.syncdaemon.volume_manager import (
-    ACCESS_LEVEL_RO,
-    get_udf_path, Share, Shared, UDF,
-)
-from tests.syncdaemon.test_action_queue import (
-    ConnectedBaseTestCase,
-    FakeSemaphore,
-    FakeTempFile,
-    TestingProtocol,
-)
-
-VOLUME = uuid.UUID('12345678-1234-1234-1234-123456789abc')
-
-
-class MockLogger(object):
-    """A mock logger that stores whatever is logged into it."""
-
-    def __init__(self):
-        """Initialize this instance."""
-        self.events = []
-        self.deferreds = []
-
-    def log(self, event):
-        """Log the event."""
-        self.events.append(event)
-        if self.deferreds:
-            self.callback_next_deferred(event)
-
-    def callback_next_deferred(self, event):
-        """Pop the next deferred and callback it."""
-        d = self.deferreds.pop()
-        if d:
-            d.callback(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."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this instance."""
-        yield super(ZeitgeistListenerTestCase, self).setUp()
-        self.patch(zglog, "ZeitgeistLogger", MockLogger)
-        self.listener = ZeitgeistListener(self.fs, self.vm)
-        self.event_q.subscribe(self.listener)
-        self.patch(self.event_q, "ignored_base_exception", RuntimeError)
-
-    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."""
-
-    @defer.inlineCallbacks
-    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, path):
-            """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)
-
-        d = defer.Deferred()
-        self._listen_for('AQ_CREATE_SHARE_OK', d.callback, 1, collect=True)
-        self.patch(self.main.action_q, "create_share", fake_create_share)
-        self.vm.create_share(path, fake_username, 'shared_name',
-                             ACCESS_LEVEL_RO)
-
-        yield d
-
-        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, path):
-            """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',
-                             ACCESS_LEVEL_RO)
-
-        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.assertEqual(len(self.listener.zg.events), 1)
-        event = self.listener.zg.events[0]
-        foldername = basename(path)
-
-        self.assertEqual(event.interpretation,
-                          EVENT_INTERPRETATION_U1_FOLDER_SHARED)
-        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.text, foldername)
-        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(folder.storage, STORAGE_NETWORK)
-
-        other_user = event.subjects[1]
-        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)
-        self.assertEqual(other_user.text, fake_username)
-
-    @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"
-        folder_name = "shared_path"
-        path = os.path.join(self.vm.root.path, folder_name)
-        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)
-        yield 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=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.assertEqual(len(self.listener.zg.events), 1)
-        event = self.listener.zg.events[0]
-
-        self.assertEqual(event.interpretation,
-                          EVENT_INTERPRETATION_U1_FOLDER_UNSHARED)
-        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.text, folder_name)
-        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(folder.storage, STORAGE_NETWORK)
-
-        other_user = event.subjects[1]
-        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)
-        self.assertEqual(other_user.text, fake_username)
-
-    @defer.inlineCallbacks
-    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"
-        folder_name = "shared_path"
-        path = os.path.join(self.vm.root.path, folder_name)
-        self.main.fs.create(path, "")
-        share_path = os.path.join(self.shares_dir, folder_name)
-        share = Share(path=share_path, volume_id='volume_id', node_id="node_id",
-                      other_username=fake_username)
-        yield self.vm.add_share(share)
-
-        self.assertEqual(len(self.listener.zg.events), 1)
-        event = self.listener.zg.events[0]
-
-        self.assertEqual(event.interpretation,
-                          EVENT_INTERPRETATION_U1_SHARE_ACCEPTED)
-        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(share_path))
-        self.assertEqual(folder.text, folder_name)
-        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(folder.storage, STORAGE_NETWORK)
-
-        other_user = event.subjects[1]
-        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)
-        self.assertEqual(other_user.text, fake_username)
-
-    @defer.inlineCallbacks
-    def test_share_unaccepted_is_logged(self):
-        """Test that an unaccepted share event is logged."""
-        fake_username = "fake user"
-        folder_name = u"share"
-        d = defer.Deferred()
-
-        share_path = os.path.join(self.main.shares_dir, folder_name)
-        holder = NotifyShareHolder.from_params(uuid.uuid4(),
-                                                     uuid.uuid4(),
-                                                     u'fake_share',
-                                                     fake_username,
-                                                     u'visible_name', 'Read')
-
-        share = Share.from_notify_holder(holder, share_path)
-        yield self.main.vm.add_share(share)
-        self._listen_for('VM_VOLUME_DELETED', d.callback, 1, collect=True)
-        self.main.event_q.push('SV_SHARE_DELETED', share_id=holder.share_id)
-        yield d
-
-        self.assertEqual(len(self.listener.zg.events), 2)
-        event = self.listener.zg.events[1]
-
-        self.assertEqual(event.interpretation,
-                          EVENT_INTERPRETATION_U1_SHARE_UNACCEPTED)
-        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(share_path))
-        self.assertEqual(folder.text, folder_name)
-        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(folder.storage, STORAGE_NETWORK)
-
-        other_user = event.subjects[1]
-        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)
-        self.assertEqual(other_user.text, fake_username)
-
-
-class ZeitgeistUDFsTestCase(ZeitgeistListenerTestCase):
-    """Tests for all UDFs-related zeitgeist events."""
-
-    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."""
-        folder_name = u'ñoño'.encode('utf-8')
-        path = os.path.join(self.home_dir, folder_name)
-        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 = expand_user(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.listener.zg.deferreds.append(d)
-        self.vm.create_udf(path)
-        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.text, folder_name)
-        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()
-        folder_name = u'ñoño'.encode('utf-8')
-        path = os.path.join(self.home_dir, folder_name)
-
-        d = defer.Deferred()
-        self.listener.zg.deferreds.append(d)
-
-        def create_udf(path, name, marker):
-            """Fake create_udf."""
-            # check that the marker is the full path to the udf
-            expanded_path = expand_user(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)
-
-        self.vm.create_udf(path)
-        yield d
-
-        def delete_volume(volume_id, 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.assertEqual(len(self.listener.zg.events), 1)
-        event = self.listener.zg.events[0]
-
-        d2 = defer.Deferred()
-        self.listener.zg.deferreds.append(d2)
-        self.vm.delete_volume(str(id))
-        yield d2
-
-        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.text, folder_name)
-        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."""
-        folder_name = u"ñoño"
-        suggested_path = u'~/' + folder_name
-        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
-                               subscribed=False)
-        yield self.main.vm.add_udf(udf)
-        d = defer.Deferred()
-        self.listener.zg.deferreds.append(d)
-        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.text.decode('utf-8'), folder_name)
-        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)
-        folder_name = basename(udf.path)
-        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.text, folder_name)
-        self.assertEqual(folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(folder.storage, STORAGE_DELETED)
-
-
-class ZeitgeistRemoteFileSyncTestCase(ConnectedBaseTestCase):
-    """File sync events are logged into Zeitgeist."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this test instance."""
-        yield super(ZeitgeistRemoteFileSyncTestCase, self).setUp()
-        self.rq = request_queue = RequestQueue(action_queue=self.action_queue)
-        self.rq.transfers_semaphore = FakeSemaphore()
-
-        class MyUpload(Upload):
-            """Just to allow monkeypatching."""
-
-        self.share_id = ""
-        self.mdid = self.main.fs.create(os.path.join(self.root, 'file'), '')
-        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, mdid=self.mdid)
-        self.command.make_logger()
-        self.command.tempfile = FakeTempFile(self.mktemp('tmpdir'))
-        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 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', self.mdid)
-        cmd.handle_success(request)
-
-        # create a request and fill it with succesful information
-        aq_client = TestingProtocol()
-        request = client.PutContent(aq_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.text, 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', self.mdid)
-        cmd.handle_success(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_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.REMOTE_DATA_OBJECT)
-        self.assertTrue(remote_folder.origin.endswith(dirname))
-        self.assertEqual(remote_folder.text, dirname)
-        self.assertEqual(remote_folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(remote_folder.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
-        aq_client = TestingProtocol()
-        request = client.PutContent(aq_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.text, 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."""
-        file_name = "filename.mp3"
-        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.event_q.push("AQ_UNLINK_OK", share_id="",
-                               parent_id="parent_id",
-                               node_id="node_id", new_generation=13,
-                               was_dir=False, old_path=path)
-        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_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.DELETED_RESOURCE)
-        self.assertTrue(remote_file.origin.endswith(file_name))
-        self.assertEqual(remote_file.text, file_name)
-        self.assertEqual(remote_file.mimetype, "audio/mpeg")
-        self.assertEqual(remote_file.storage, STORAGE_DELETED)
-
-    @defer.inlineCallbacks
-    def test_syncdaemon_deletes_dir_on_server_is_logged(self):
-        """Directories deleted by SD on the server are logged."""
-        folder_name = "folder name"
-        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.event_q.push("AQ_UNLINK_OK", share_id="",
-                               parent_id="parent_id",
-                               node_id="node_id", new_generation=13,
-                               was_dir=True, old_path=path)
-        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.text, 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
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this instance."""
-        yield super(ZeitgeistLocalFileSyncTestCase, self).setUp()
-        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)
-
-    @defer.inlineCallbacks
-    def tearDown(self):
-        """Clean up this instance."""
-        self._logger.removeHandler(self.handler)
-        self.main.shutdown()
-        FakeMain._sync_class = None
-        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]
-        yield super(ZeitgeistLocalFileSyncTestCase, self).tearDown()
-
-    @defer.inlineCallbacks
-    def test_syncdaemon_creates_file_locally_is_logged(self):
-        """Files created locally by SyncDaemon are logged."""
-        file_name = self.filemp3delta.name.encode('utf8')
-        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, file_name)
-        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(file_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.text, file_name)
-        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."""
-        folder_name = self.dirdelta.name.encode('utf8')
-        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, folder_name)
-        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_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.FILE_DATA_OBJECT)
-        self.assertTrue(local_folder.origin.startswith(URI_PROTOCOL_U1))
-        self.assertEqual(local_folder.text, folder_name)
-        self.assertEqual(local_folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(local_folder.storage, STORAGE_LOCAL)
-
-    @defer.inlineCallbacks
-    def test_syncdaemon_modifies_locally_is_logged(self):
-        """Files modified locally by SyncDaemon are logged."""
-        file_name = self.filemp3delta.name.encode('utf8')
-        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, file_name)
-        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(file_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.text, file_name)
-        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."""
-        file_name = self.filemp3delta.name.encode("utf-8")
-        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.event_q.push("SV_FILE_DELETED", volume_id="",
-                               node_id="node_id", was_dir=False,
-                               old_path=path)
-        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(file_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.text, file_name)
-        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."""
-        folder_name = "folder name"
-        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.event_q.push("SV_FILE_DELETED", volume_id="",
-                               node_id="node_id", was_dir=True,
-                               old_path=path)
-
-        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.text, folder_name)
-        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."""
-        file_name = "sample.mp3"
-        d = defer.Deferred()
-        listen_for(self.main.event_q, 'FSM_FILE_CONFLICT', d.callback)
-
-        testfile = os.path.join(self.main.vm.root.path, file_name)
-        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.text,
-                         file_name + self.main.fs.CONFLICT_SUFFIX)
-        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."""
-        folder_name = "sampledir"
-        d = defer.Deferred()
-        listen_for(self.main.event_q, 'FSM_DIR_CONFLICT', d.callback)
-
-        testdir = os.path.join(self.main.vm.root.path, folder_name)
-        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_folder = event.subjects[0]
-        new_name = testdir + self.main.fs.CONFLICT_SUFFIX
-        self.assertTrue(local_folder.uri.endswith(new_name))
-        self.assertEqual(local_folder.interpretation, Interpretation.FOLDER)
-        self.assertEqual(local_folder.manifestation,
-                          Manifestation.FILE_DATA_OBJECT)
-        self.assertTrue(local_folder.origin.endswith(testdir))
-        self.assertEqual(local_folder.text,
-                         folder_name + self.main.fs.CONFLICT_SUFFIX)
-        self.assertEqual(local_folder.mimetype, DIRECTORY_MIMETYPE)
-        self.assertEqual(local_folder.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')
-        yield 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.text, public_url)
-        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')
-        yield 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.text, public_url)
-        self.assertEqual(public_file.mimetype, "audio/mpeg")
-        self.assertEqual(public_file.storage, STORAGE_DELETED)
 
=== removed file 'tests/platform/linux/eventlog/test_zglog.py'
--- tests/platform/linux/eventlog/test_zglog.py	2012-04-30 14:24:55 +0000
+++ tests/platform/linux/eventlog/test_zglog.py	1970-01-01 00:00:00 +0000
@@ -1,174 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Tests for the Zeitgeist logging."""
-
-import os
-import shutil
-import subprocess
-import tempfile
-import time
-
-from distutils.spawn import find_executable
-
-from twisted.internet import defer
-from zeitgeist.client import ZeitgeistClient
-from zeitgeist.datamodel import Event, Subject, Interpretation, Manifestation
-
-from tests.platform.ipc.test_linux import DBusTwistedTestCase
-from ubuntuone.eventlog.zglog import ZeitgeistLogger
-
-SRCDIR = os.environ.get('SRCDIR', os.getcwd())
-
-
-class NotFoundError(Exception):
-    """Not found error."""
-
-
-class ZeitgeistNotStartedTests(DBusTwistedTestCase):
-    """Tests for the zeitgeist logging module."""
-
-    def test_log_does_not_err_when_daemon_not_started(self):
-        """zeitgeist-daemon was not started."""
-        timestamp = int(time.time() * 1000)
-        subject = Subject.new_for_values(
-                uri="file:///tmp/folder1",
-                interpretation=Interpretation.FOLDER,
-                manifestation=Manifestation.FILE_DATA_OBJECT,
-                origin="ubuntuone:uuid",
-                mimetype="inode/directory",
-                text="sample folder"
-        )
-        sample_event = Event.new_for_values(
-            timestamp=timestamp,
-            interpretation=Interpretation.ACCESS_EVENT,
-            manifestation=Manifestation.USER_ACTIVITY,
-            actor="mailto:sample_subject",
-            subjects=[subject]
-        )
-
-        zg = ZeitgeistLogger()
-        d = zg.log(sample_event)
-        self.assertEqual(zg.client, None)
-
-        def verify(result):
-            """Stored result is the empty list, because zg not available."""
-            self.assertEqual(result, [])
-            return result
-
-        d.addCallback(verify)
-        return d
-
-
-def wait_zeitgeist_started(seconds=10):
-    """Wait a few seconds until zg is started, or fail if it can't."""
-    client = None
-    count = 0
-    while client is None:
-        count += 1
-        try:
-            client = ZeitgeistClient()
-            break
-        except RuntimeError:
-            if count > seconds * 10:
-                raise
-            time.sleep(0.1)
-
-
-class ZeitgeistTestCase(DBusTwistedTestCase):
-    """Tests for the zeitgeist logging module."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(ZeitgeistTestCase, self).setUp()
-        zgdaemon = find_executable("zeitgeist-daemon")
-        if not zgdaemon:
-            raise NotFoundError("zeitgeist-daemon was not found.")
-
-        tempfolder = tempfile.mkdtemp(prefix="test-u1-zeitgeist-")
-        tempstdout = tempfile.TemporaryFile(prefix="test-u1-stdout-")
-        tempstderr = tempfile.TemporaryFile(prefix="test-u1-stderr-")
-        os.environ["ZEITGEIST_DATA_PATH"] = tempfolder
-        p = subprocess.Popen([zgdaemon], bufsize=4096, stdout=tempstdout,
-                             stderr=tempstderr)
-
-        def cleanup():
-            """Wait for the process to finish."""
-            p.terminate()
-            p.wait()
-            del(os.environ["ZEITGEIST_DATA_PATH"])
-            shutil.rmtree(tempfolder)
-
-        wait_zeitgeist_started()
-        self.addCleanup(cleanup)
-
-    def test_log_records_the_event(self):
-        """The log method records the event in zg."""
-        timestamp = int(time.time() * 1000)
-        subject = Subject.new_for_values(
-                uri="file:///tmp/folder1",
-                interpretation=Interpretation.FOLDER,
-                manifestation=Manifestation.FILE_DATA_OBJECT,
-                origin="ubuntuone:uuid",
-                mimetype="inode/directory",
-                text="sample folder"
-        )
-        sample_event = Event.new_for_values(
-            timestamp=timestamp,
-            interpretation=Interpretation.ACCESS_EVENT,
-            manifestation=Manifestation.USER_ACTIVITY,
-            actor="mailto:sample_subject",
-            subjects=[subject]
-        )
-
-        sample_template = Event.new_for_values()
-
-        zg = ZeitgeistLogger()
-        self.assertNotEqual(zg.client, None)
-
-        d2 = defer.Deferred()
-
-        def logged(id_list):
-            """The event was logged to zeitgeist."""
-
-            def events_found(event_list):
-                """zg returned the list of events."""
-                self.assertEqual(event_list[0].id, id_list[0])
-                d2.callback("ok")
-
-            zg.client.find_events_for_template(sample_template, events_found)
-
-        d = zg.log(sample_event)
-        d.addCallbacks(logged, d2.errback)
-
-        return d2
-
-
-ZeitgeistTestCase.skip = 'Suite is hanging in nightlies build (LP: #929812).'
 
=== modified file 'tests/syncdaemon/test_main.py'
--- tests/syncdaemon/test_main.py	2013-01-16 23:57:30 +0000
+++ tests/syncdaemon/test_main.py	2013-02-04 16:10:53 +0000
@@ -83,8 +83,6 @@
         self.partials_dir = self.mktemp('partials_dir')
 
         self.patch(main_mod, 'SyncdaemonService', FakedExternalInterface)
-        # no event logger by default
-        self.patch(main_mod.event_logging, "get_listener", lambda *a: None)
         # no status listener by default
         self.patch(main_mod.status_listener, "get_listener", lambda *a: None)
 
@@ -257,18 +255,6 @@
                 s.add(x)
         return s
 
-    def test_event_logger_starts_if_available(self):
-        """The event logger is started if available."""
-        self.patch(main_mod.event_logging,
-                   "get_listener", lambda *a: FakeListener())
-        main = self.build_main()
-        self.assertIn(main.eventlog_listener, self._get_listeners(main))
-
-    def test_event_logger_not_started_if_not_available(self):
-        """The event logger is not started if it's not available."""
-        main = self.build_main()
-        self.assertNotIn(main.eventlog_listener, self._get_listeners(main))
-
     def test_status_listener_is_installed(self):
         """The status listener is installed if needed."""
         self.patch(main_mod.status_listener,
 
=== modified file 'tests/syncdaemon/test_status_listener.py'
--- tests/syncdaemon/test_status_listener.py	2012-09-20 18:04:58 +0000
+++ tests/syncdaemon/test_status_listener.py	2013-02-04 16:10:53 +0000
@@ -54,12 +54,6 @@
         self.assertEqual(listener.vm, vm)
         self.assertNotEqual(listener.status_frontend, None)
 
-    def test_zeitgeist_not_installed_returns_none(self):
-        """get_listener returns None if status reporting is disabled."""
-        self.patch(status_listener, "should_start_listener", lambda: False)
-        listener = status_listener.get_listener(None, None)
-        self.assertEqual(listener, None)
-
 
 def listen_for(event_q, event, callback, count=1, collect=False):
     """Setup a EQ listener for the specified event."""
 
=== removed directory 'ubuntuone/eventlog'
=== removed file 'ubuntuone/eventlog/__init__.py'
--- ubuntuone/eventlog/__init__.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/eventlog/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-# ubuntuone.eventlog - Ubuntu One event logging modules
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Event logging module."""
 
=== removed file 'ubuntuone/eventlog/zg_listener.py'
--- ubuntuone/eventlog/zg_listener.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/eventlog/zg_listener.py	1970-01-01 00:00:00 +0000
@@ -1,556 +0,0 @@
-# ubuntuone.eventlog.zg_listener - listen for SD events, log into ZG
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Event logging from SyncDaemon into Zeitgeist."""
-
-import mimetypes
-
-from os.path import basename
-
-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, 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."""
-
-    def __init__(self, fsm, vm):
-        """Initialize this instance."""
-        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, marker):
-        """Log the 'directory shared thru the server' event."""
-        share_id = str(share_id)
-        share = self.vm.shared.get(share_id)
-        if not share:
-            share = self.vm.marker_share_map[marker]
-            share_id = share.node_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 = share.path
-        folder_name = basename(fullpath)
-
-        folder = Subject.new_for_values(
-            uri=URI_PROTOCOL_U1 + str(share.node_id),
-            interpretation=Interpretation.FOLDER,
-            manifestation=Manifestation.REMOTE_DATA_OBJECT,
-            origin="file:///" + fullpath,
-            text=folder_name,
-            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,
-            text=other_username,
-            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,
-            text=basename(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,
-            text=other_username,
-            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,
-            text=basename(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,
-            text=other_username,
-            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,
-            text=basename(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,
-            text=other_username,
-            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 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,
-            text=basename(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,
-            text=basename(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),
-            text=basename(udf.path),
-            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),
-            text=basename(udf.path),
-            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,
-            text=basename(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,
-            text=basename(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),
-            text=basename(path),
-            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),
-            text=basename(path),
-            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, was_dir, old_path):
-        """A file or folder was deleted locally by Syncdaemon."""
-        if was_dir:
-            mime, interp = DIRECTORY_MIMETYPE, Interpretation.FOLDER
-        else:
-            mime, interp = self.get_mime_and_interpretation_for_filepath(
-                                                                    old_path)
-
-        file_subject = Subject.new_for_values(
-            uri="file:///" + old_path,
-            interpretation=interp,
-            manifestation=Manifestation.DELETED_RESOURCE,
-            origin=URI_PROTOCOL_U1 + str(node_id),
-            text=basename(old_path),
-            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, was_dir, old_path):
-        """A file or folder was deleted on the server by Syncdaemon,"""
-        if was_dir:
-            mime, interp = DIRECTORY_MIMETYPE, Interpretation.FOLDER
-        else:
-            mime, interp = self.get_mime_and_interpretation_for_filepath(
-                                                                    old_path)
-
-        file_subject = Subject.new_for_values(
-            uri=URI_PROTOCOL_U1 + str(node_id),
-            interpretation=interp,
-            manifestation=Manifestation.DELETED_RESOURCE,
-            origin="file:///" + old_path,
-            text=basename(old_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,
-            text=basename(new_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,
-            text=basename(new_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,
-            text=public_url,
-            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,
-            text=public_url,
-            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)
 
=== removed file 'ubuntuone/eventlog/zglog.py'
--- ubuntuone/eventlog/zglog.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/eventlog/zglog.py	1970-01-01 00:00:00 +0000
@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Log into the Zeitgeist daemon."""
-
-from twisted.internet.defer import Deferred
-
-from ubuntuone.logger import logging
-
-logger = logging.getLogger('ubuntuone.eventlog.zglog')
-
-
-class ZeitgeistLogger(object):
-    """A class that logs zeitgeist events."""
-    client = None
-
-    def __init__(self):
-        """Initialize this instance."""
-        try:
-            from zeitgeist.client import ZeitgeistClient
-            self.client = ZeitgeistClient()
-            logger.info("Zeitgeist support initialized.")
-        except Exception:
-            logger.exception("Zeitgeist support not started:")
-
-    def log(self, event):
-        """Log a zeitgeist event."""
-        d = Deferred()
-        if self.client:
-            logger.info("Logging Zeitgeist event: %r", event)
-            self.client.insert_event(event, d.callback, d.errback)
-        else:
-            d.callback([])
-        return d
 
=== removed directory 'ubuntuone/platform/event_logging'
=== removed file 'ubuntuone/platform/event_logging/__init__.py'
--- ubuntuone/platform/event_logging/__init__.py	2012-05-01 17:43:39 +0000
+++ ubuntuone/platform/event_logging/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-# -*- coding: utf-8 *-*
-#
-# Copyright 2011-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Builds a syncdaemon listener that logs events if ZG is installed."""
-
-import sys
-
-if sys.platform in ["win32", "darwin"]:
-    # Zeitgeist is not installed on these platforms
-    get_listener = lambda x, y: None
-else:
-    from ubuntuone.platform.event_logging import linux as source
-    get_listener = source.get_listener
-
 
=== removed file 'ubuntuone/platform/event_logging/linux.py'
--- ubuntuone/platform/event_logging/linux.py	2012-04-27 22:55:12 +0000
+++ ubuntuone/platform/event_logging/linux.py	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Builds a syncdaemon listener that logs events if ZG is installed."""
-
-
-def is_zeitgeist_installed():
-    """Return true if zeitgeist is installed."""
-    try:
-        import zeitgeist
-        import zeitgeist.mimetypes
-        # use the above module in some way so pylint does not complain
-        assert(zeitgeist is not None)
-        return True
-    except (ImportError, AttributeError):
-        return False
-
-
-def get_listener(fsm, vm):
-    """Build a listener if zg is installed."""
-    if is_zeitgeist_installed():
-        from ubuntuone.eventlog import zg_listener
-        return zg_listener.ZeitgeistListener(fsm, vm)
-    else:
-        return None
 
=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2013-01-22 20:03:12 +0000
+++ ubuntuone/syncdaemon/main.py	2013-02-04 16:10:53 +0000
@@ -48,7 +48,6 @@
     volume_manager,
 )
 from ubuntuone import syncdaemon, clientdefs
-from ubuntuone.platform import event_logging
 from ubuntuone.syncdaemon import status_listener
 from ubuntuone.syncdaemon.interaction_interfaces import SyncdaemonService
 from ubuntuone.syncdaemon.states import StateManager, QueueManager
@@ -147,22 +146,12 @@
         if user_config.get_autoconnect():
             self.external.connect(autoconnecting=True)
 
-        self.eventlog_listener = None
-        self.start_event_logger()
-
         self.status_listener = None
         self.start_status_listener()
 
         self.mark = task.LoopingCall(self.log_mark)
         self.mark.start(mark_interval)
 
-    def start_event_logger(self):
-        """Start the event logger if it's available for this platform."""
-        self.eventlog_listener = event_logging.get_listener(self.fs, self.vm)
-        # subscribe to EQ, to be unsubscribed in shutdown
-        if self.eventlog_listener:
-            self.event_q.subscribe(self.eventlog_listener)
-
     def start_status_listener(self):
         """Start the status listener if it is configured to start."""
         self.status_listener = status_listener.get_listener(self.fs, self.vm,
@@ -228,8 +217,6 @@
         self.event_q.push('SYS_QUIT')
 
         self.event_q.unsubscribe(self.vm)
-        if getattr(self, 'eventlog_listener', None) is not None:
-            self.event_q.unsubscribe(self.eventlog_listener)
         if getattr(self, 'status_listener', None) is not None:
             self.event_q.unsubscribe(self.status_listener)