Merge lp:~mikemc/ubuntuone-client/fix-dummy-sync-menu into lp:ubuntuone-client

[Mike McCracken]

- Fix dummy sync menu implementation for windows and darwin. (LP: #1055840)

- Fix dummy sync menu implementation for windows and darwin. (LP: #1055840)

Added a test to check that the dummy class has the same API, fixed missing start_timer function.

Removed code in dummy that won't be called.

Tests pass on darwin and linux (precise).
(On darwin, I only ran the specific tests that changed, since trunk tests have never worked.)

With this fix, an app built from trunk runs correctly on darwin again.

[lp:~mikemc/ubuntuone-client/fix-dummy-sync-menu]

1322. By Mike McCracken on 2012-09-24

merge with default-fs-monitor-fix

1323. By Mike McCracken on 2012-09-25

merge with sync-menu-timer branch

1324. By Mike McCracken on 2012-09-25

change dummy to match new linux version

1325. By Mike McCracken on 2012-09-26

merge with trunk

1326. By Mike McCracken on 2012-09-26

change to reflect new API

1327. By Mike McCracken on 2012-09-27

merge with trunk

Unmerged revisions

=== added file 'tests/platform/sync_menu/test_common.py'
--- tests/platform/sync_menu/test_common.py	1970-01-01 00:00:00 +0000
+++ tests/platform/sync_menu/test_common.py	2012-09-26 18:35:23 +0000
@@ -0,0 +1,49 @@
+# -*- coding: utf-8 *-*
+#
+# 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.
+"""Test the common dummy Sync Menu implementation for win32/darwin."""
+
+from collections import Callable
+
+from twisted.trial.unittest import TestCase
+
+from ubuntuone.platform.sync_menu import common
+
+
+class SyncMenuDummyTestCase(TestCase):
+    """Test the SyncMenu."""
+
+    def test_dummy_support(self):
+        """Can we create a Dummy with the same #args as the real obj."""
+        dummy = common.UbuntuOneSyncMenu(1, 2)
+        self.assertIsInstance(dummy, common.UbuntuOneSyncMenu)
+
+    def test_dummy_has_update_transfers(self):
+        """Check that the dummy has the proper methods required by the API."""
+        dummy = common.UbuntuOneSyncMenu(1, 2)
+        self.assertIsInstance(dummy.update_transfers, Callable)

=== modified file 'tests/platform/sync_menu/test_linux.py'
--- tests/platform/sync_menu/test_linux.py	2012-09-24 13:09:52 +0000
+++ tests/platform/sync_menu/test_linux.py	2012-09-26 18:35:23 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # -*- coding: utf-8 *-*
 #
 # Copyright 2012 Canonical Ltd.
@@ -338,3 +339,352 @@
             self.assertEqual(item.property_get_int(
                 linux.SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE),
                 percentage)
+=======
+# -*- coding: utf-8 *-*
+#
+# 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.
+"""Test the Sync Menu."""
+
+import time
+from collections import Callable
+
+from twisted.internet import defer
+from twisted.trial.unittest import TestCase
+
+from ubuntuone.platform import sync_menu
+from ubuntuone.platform.sync_menu import linux
+
+
+def fake_call_later(*args):
+    """Fake reactor.callLater."""
+
+
+class FakeStatusFrontend(object):
+    """Fake StatusFrontend."""
+
+    def __init__(self):
+        self.recent_transfers_data = []
+        self.uploading_data = []
+
+    def recent_transfers(self):
+        """Return the fake recent transfers files."""
+        return self.recent_transfers_data
+
+    def files_uploading(self):
+        """Return the fake files being upload."""
+        return self.uploading_data
+
+
+class FakeTimer(object):
+    """Fake Timer."""
+
+    def __init__(self, delay):
+        self.delay = delay
+        self.callback = None
+
+    def addCallback(self, callback):
+        """Add callback."""
+        self.callback = callback
+
+
+class FakeSyncdaemonService(object):
+    """Fake SyncdaemonService."""
+
+
+class FakeSyncMenuApp(object):
+    """Fake SyncMenu."""
+
+    data = {}
+
+    @classmethod
+    def new(cls, *args):
+        return FakeSyncMenuApp()
+
+    @classmethod
+    def clean(cls):
+        """Clear the values stored in data."""
+
+    def set_menu(self, server):
+        """Set the menu for SyncMenu App."""
+        self.data['server'] = server
+
+    def connect(self, signal, callback):
+        """Fake connect."""
+        self.data['connect'] = (signal, callback)
+
+
+class SyncMenuDummyTestCase(TestCase):
+    """Test the SyncMenu."""
+
+    def test_dummy_support(self):
+        """Check that the Dummy object can be created properly."""
+        dummy = linux.DummySyncMenu('random', 'args')
+        self.assertIsInstance(dummy, linux.DummySyncMenu)
+
+    def test_dummy_has_start_timer(self):
+        """Check that the dummy has the proper methods required by the API."""
+        dummy = linux.DummySyncMenu('random', 'args')
+        self.assertIsInstance(dummy.start_timer, Callable)
+
+
+class SyncMenuTestCase(TestCase):
+    """Test the SyncMenu."""
+
+    skip = None if linux.use_syncmenu else "SyncMenu not installed."
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(SyncMenuTestCase, self).setUp()
+        self.patch(linux.SyncMenu, "App", FakeSyncMenuApp)
+        FakeSyncMenuApp.clean()
+        self.syncdaemon_service = FakeSyncdaemonService()
+        self.status_frontend = FakeStatusFrontend()
+        self._paused = False
+        self.patch(sync_menu.UbuntuOneSyncMenu, "change_sync_status",
+            self._change_sync_status)
+        self.sync_menu = sync_menu.UbuntuOneSyncMenu(self.status_frontend,
+            self.syncdaemon_service)
+
+    def _change_sync_status(self, *args):
+        """Fake change_sync_status."""
+        if self._paused:
+            self._paused = False
+        else:
+            self._paused = True
+
+    def test_init(self):
+        """Check that the menu is properly initialized."""
+        self.assertIsInstance(FakeSyncMenuApp.data['server'],
+            linux.Dbusmenu.Server)
+        self.assertEqual(self.sync_menu.open_u1.get_parent(),
+            self.sync_menu.root_menu)
+        self.assertEqual(self.sync_menu.go_to_web.get_parent(),
+            self.sync_menu.root_menu)
+        self.assertEqual(self.sync_menu.more_storage.get_parent(),
+            self.sync_menu.root_menu)
+        self.assertEqual(self.sync_menu.get_help.get_parent(),
+            self.sync_menu.root_menu)
+        self.assertEqual(self.sync_menu.transfers.get_parent(),
+            self.sync_menu.root_menu)
+
+        self.assertEqual(self.sync_menu.open_u1.property_get(
+            linux.Dbusmenu.MENUITEM_PROP_LABEL), linux.OPEN_U1)
+        self.assertEqual(self.sync_menu.go_to_web.property_get(
+            linux.Dbusmenu.MENUITEM_PROP_LABEL), linux.GO_TO_WEB)
+        self.assertEqual(self.sync_menu.transfers.property_get(
+            linux.Dbusmenu.MENUITEM_PROP_LABEL), linux.TRANSFERS)
+        self.assertEqual(self.sync_menu.more_storage.property_get(
+            linux.Dbusmenu.MENUITEM_PROP_LABEL), linux.MORE_STORAGE)
+        self.assertEqual(self.sync_menu.get_help.property_get(
+            linux.Dbusmenu.MENUITEM_PROP_LABEL), linux.GET_HELP)
+
+        self.assertEqual(self.sync_menu.app.data['connect'],
+            ("notify::paused", self.sync_menu.change_sync_status))
+        self.sync_menu.app.data['connect'][1]()
+        self.assertTrue(self._paused)
+        self.sync_menu.app.data['connect'][1]()
+        self.assertFalse(self._paused)
+
+    def test_open_u1(self):
+        """Check that the proper action is executed."""
+        data = []
+
+        self.patch(linux.glib, "spawn_command_line_async", data.append)
+        self.sync_menu.open_control_panel()
+        self.assertEqual(data, ['ubuntuone-installer'])
+
+    def test_go_to_web(self):
+        """Check that the proper action is executed."""
+        data = []
+
+        self.patch(linux.webbrowser, "open", data.append)
+        self.sync_menu.open_go_to_web()
+        self.assertEqual(data, [linux.DASHBOARD])
+
+    def test_get_help(self):
+        """Check that the proper action is executed."""
+        data = []
+
+        self.patch(linux.webbrowser, "open", data.append)
+        self.sync_menu.open_web_help()
+        self.assertEqual(data, [linux.HELP_LINK])
+
+    def test_more_storage(self):
+        """Check that the proper action is executed."""
+        data = []
+
+        self.patch(linux.webbrowser, "open", data.append)
+        self.sync_menu.open_get_more_storage()
+        self.assertEqual(data, [linux.GET_STORAGE_LINK])
+
+    def test_empty_transfers(self):
+        """Check that the Transfers menu is empty."""
+        self.assertEqual(self.sync_menu.transfers.get_children(), [])
+
+    def test_only_recent(self):
+        """Check that only recent transfers items are loaded."""
+        data = ['file1', 'file2', 'file3']
+        self.status_frontend.recent_transfers_data = data
+        self.sync_menu.transfers.update_progress()
+        children = self.sync_menu.transfers.get_children()
+        self.assertEqual(len(children), 3)
+        data.reverse()
+        for itemM, itemD in zip(children, data):
+            self.assertEqual(itemM.property_get(
+                linux.Dbusmenu.MENUITEM_PROP_LABEL), itemD)
+
+    def test_only_progress(self):
+        """Check that only progress items are loaded."""
+        data = [
+            ('file1', 3000, 400),
+            ('file2', 2000, 100),
+            ('file3', 5000, 4600)]
+        uploading_data = {}
+        for filename, size, written in data:
+            uploading_data[filename] = (size, written)
+        self.status_frontend.uploading_data = data
+        self.sync_menu.transfers.update_progress()
+        children = self.sync_menu.transfers.get_children()
+        self.assertEqual(len(children), 3)
+        data.reverse()
+        for item in children:
+            text = item.property_get(linux.Dbusmenu.MENUITEM_PROP_LABEL)
+            self.assertIn(text, uploading_data)
+            size, written = uploading_data[text]
+            percentage = written * 100 / size
+            self.assertEqual(item.property_get_int(
+                linux.SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE),
+                percentage)
+
+    def test_full_transfers(self):
+        """Check that the transfers menu contains the maximum transfers."""
+        # The api of recent transfers always returns a maximum of 5 items
+        data_recent = ['file1', 'file2', 'file3', 'file4', 'file5']
+        self.status_frontend.recent_transfers_data = \
+            data_recent
+        self.sync_menu.transfers.update_progress()
+        children = self.sync_menu.transfers.get_children()
+        self.assertEqual(len(children), 5)
+        data_recent.reverse()
+        for itemM, itemD in zip(children, data_recent):
+            self.assertEqual(itemM.property_get(
+                linux.Dbusmenu.MENUITEM_PROP_LABEL), itemD)
+
+        data_current = [
+            ('file0', 1200, 600),
+            ('file1', 3000, 400),
+            ('file2', 2000, 100),
+            ('file3', 2500, 150),
+            ('file4', 1000, 600),
+            ('file5', 5000, 4600)]
+        uploading_data = {}
+        for filename, size, written in data_current:
+            uploading_data[filename] = (size, written)
+        self.status_frontend.uploading_data = data_current
+        self.sync_menu.transfers.update_progress()
+        children = self.sync_menu.transfers.get_children()
+        # The menu should only show 5 current transfers.
+        self.assertEqual(len(children), 10)
+        data_current.reverse()
+        for item in children[5:]:
+            text = item.property_get(linux.Dbusmenu.MENUITEM_PROP_LABEL)
+            self.assertIn(text, uploading_data)
+            size, written = uploading_data[text]
+            percentage = written * 100 / size
+            self.assertEqual(item.property_get_int(
+                linux.SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE),
+                percentage)
+
+    def test_update_transfers(self):
+        """Check that everything is ok when updating the transfers value."""
+        data_current = [
+            ('file0', 1200, 600),
+            ('file1', 3000, 400),
+            ('file4', 1000, 600),
+            ('file5', 5000, 4600)]
+        uploading_data = {}
+        for filename, size, written in data_current:
+            uploading_data[filename] = (size, written)
+        self.status_frontend.uploading_data = data_current
+        self.sync_menu.transfers.update_progress()
+        children = self.sync_menu.transfers.get_children()
+        # The menu should only show 5 current transfers.
+        self.assertEqual(len(children), 4)
+        data_current.reverse()
+        for item in children:
+            text = item.property_get(linux.Dbusmenu.MENUITEM_PROP_LABEL)
+            self.assertIn(text, uploading_data)
+            size, written = uploading_data[text]
+            percentage = written * 100 / size
+            self.assertEqual(item.property_get_int(
+                linux.SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE),
+                percentage)
+
+        data_recent = ['file5']
+        self.status_frontend.recent_transfers_data = data_recent
+        self.sync_menu.transfers.update_progress()
+        children = self.sync_menu.transfers.get_children()
+        self.assertEqual(len(children), 5)
+        data_recent.reverse()
+        for itemM, itemD in zip(children, data_recent):
+            self.assertEqual(itemM.property_get(
+                linux.Dbusmenu.MENUITEM_PROP_LABEL), itemD)
+
+        data_current = [
+            ('file0', 1200, 700),
+            ('file1', 3000, 600),
+            ('file4', 1000, 800)]
+        uploading_data = {}
+        for filename, size, written in data_current:
+            uploading_data[filename] = (size, written)
+        self.status_frontend.uploading_data = data_current
+        self.sync_menu.transfers.update_progress()
+        children = self.sync_menu.transfers.get_children()
+        # The menu should only show 5 current transfers.
+        self.assertEqual(len(children), 4)
+        data_current.reverse()
+        for item in children[5:]:
+            text = item.property_get(linux.Dbusmenu.MENUITEM_PROP_LABEL)
+            self.assertIn(text, uploading_data)
+            size, written = uploading_data[text]
+            percentage = written * 100 / size
+            self.assertEqual(item.property_get_int(
+                linux.SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE),
+                percentage)
+
+    def test_update_transfers_delay(self):
+        """Check that the timer is being handle properly."""
+        self.patch(linux.status.aggregator, "Timer", FakeTimer)
+        self.sync_menu.next_update = time.time() + 3
+        self.sync_menu.update_transfers()
+        self.assertLess(self.sync_menu.timer.delay, 3)
+        self.sync_menu.timer = None
+        self.sync_menu.next_update = time.time() / 2
+        self.sync_menu.update_transfers()
+        self.assertEqual(self.sync_menu.timer.delay, 0)
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/status/test_aggregator.py'
--- tests/status/test_aggregator.py	2012-08-20 13:18:43 +0000
+++ tests/status/test_aggregator.py	2012-09-26 18:35:23 +0000
@@ -1314,6 +1314,20 @@
         self.assertEqual({}, self.aggregator.to_do)
         self.assertIdentical(None, self.aggregator.queue_done_timer)
 
+    def test_register_listener(self):
+        """Check that register_listener handles properly additions."""
+
+        def fake_callback():
+            """Do nothing."""
+
+        self.aggregator.register_listener(fake_callback)
+        self.assertEqual(len(self.aggregator.listeners_callbacks), 1)
+
+    def test_register_listener_fail(self):
+        """Check that register_listener handles properly additions."""
+        self.assertRaises(TypeError, self.aggregator.register_listener, [])
+        self.assertEqual(len(self.aggregator.listeners_callbacks), 0)
+
     def assertMiscCommandQueued(self, fc):
         """Assert that some command was queued."""
         self.assertEqual(len(self.aggregator.to_do), 1)

=== modified file 'tests/syncdaemon/test_status_listener.py'
--- tests/syncdaemon/test_status_listener.py	2012-04-09 20:07:05 +0000
+++ tests/syncdaemon/test_status_listener.py	2012-09-26 18:35:23 +0000
@@ -84,7 +84,7 @@
                     callback(args)
 
     listener = Listener()
-    setattr(listener, 'handle_'+event, listener._handle_event)
+    setattr(listener, 'handle_' + event, listener._handle_event)
     event_q.subscribe(listener)
     return listener
 
@@ -92,7 +92,7 @@
 class FakeStatusFrontend(object):
     """A fake status frontend."""
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
         """Initialize this instance."""
         self.call_log = []
 

=== modified file 'ubuntuone/platform/sync_menu/common.py'
--- ubuntuone/platform/sync_menu/common.py	2012-09-18 16:29:22 +0000
+++ ubuntuone/platform/sync_menu/common.py	2012-09-26 18:35:23 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # -*- coding: utf-8 *-*
 #
 # Copyright 2012 Canonical Ltd.
@@ -41,3 +42,43 @@
 
     def start_timer(self):
         """Empty start timer, this is not needed on windows."""
+=======
+# -*- coding: utf-8 *-*
+#
+# 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.
+"""Dummy implementation of sync_menu lib for win32 and darwin."""
+
+
+class UbuntuOneSyncMenu(object):
+    """Integrate U1 with the Ubuntu Sync Menu."""
+    def __init__(self, status, syncdaemon_service):
+        """Match #args of linux syncmenu and do nothing."""
+
+    def update_transfers(self):
+        """Do nothing."""
+>>>>>>> MERGE-SOURCE

=== modified file 'ubuntuone/platform/sync_menu/linux.py'
--- ubuntuone/platform/sync_menu/linux.py	2012-09-24 12:47:05 +0000
+++ ubuntuone/platform/sync_menu/linux.py	2012-09-26 18:35:23 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # -*- coding: utf-8 *-*
 #
 # Copyright 2012 Canonical Ltd.
@@ -239,3 +240,255 @@
 
 
 UbuntuOneSyncMenu = UbuntuOneSyncMenuLinux if use_syncmenu else DummySyncMenu
+=======
+# -*- coding: utf-8 *-*
+#
+# 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.
+"""Use SyncMenu lib to integrate U1 with the Systray Sync Icon."""
+
+import gettext
+import logging
+import time
+import sys
+import webbrowser
+
+glib = None
+try:
+    if 'gobject' in sys.modules and sys.modules['gobject'] is not None:
+        import glib as GLib
+        glib = GLib
+    else:
+        from gi.repository import GLib
+        glib = GLib
+except ImportError:
+    pass
+try:
+    from gi.repository import (
+        Dbusmenu,
+        SyncMenu,
+    )
+    use_syncmenu = True
+except:
+    use_syncmenu = False
+
+from ubuntuone.clientdefs import GETTEXT_PACKAGE
+from ubuntuone import status
+
+
+logger = logging.getLogger("ubuntuone.platform.SyncMenu")
+
+Q_ = lambda string: gettext.dgettext(GETTEXT_PACKAGE, string)
+
+OPEN_U1 = Q_("Open Ubuntu One")
+GO_TO_WEB = Q_("Go to the Ubuntu One Website")
+TRANSFERS = Q_("Current and Recent Transfers")
+MORE_STORAGE = Q_("Get More Space")
+GET_HELP = Q_("Get Help on the Web")
+
+DELAY_BETWEEN_UPDATES = 3
+UBUNTUONE_LINK = u'https://one.ubuntu.com/'
+DASHBOARD = UBUNTUONE_LINK + u'dashboard/'
+HELP_LINK = UBUNTUONE_LINK + u'support/'
+GET_STORAGE_LINK = UBUNTUONE_LINK + u'services/#storage_panel'
+
+
+class UbuntuOneSyncMenuLinux(object):
+    """Integrate U1 with the Ubuntu Sync Menu."""
+
+    def __init__(self, status, syncdaemon_service):
+        """Initialize menu."""
+        self._syncdaemon_service = syncdaemon_service
+        self._paused = False
+        self.timer = None
+        self.next_update = time.time()
+        self.root_menu = Dbusmenu.Menuitem()
+
+        self.open_u1 = Dbusmenu.Menuitem()
+        self.open_u1.property_set(Dbusmenu.MENUITEM_PROP_LABEL, OPEN_U1)
+
+        self.go_to_web = Dbusmenu.Menuitem()
+        self.go_to_web.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
+            GO_TO_WEB)
+
+        self.transfers = TransfersMenu(status)
+        self.transfers.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
+            TRANSFERS)
+
+        self.more_storage = Dbusmenu.Menuitem()
+        self.more_storage.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
+            MORE_STORAGE)
+
+        self.get_help = Dbusmenu.Menuitem()
+        self.get_help.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
+            GET_HELP)
+
+        # Connect signals
+        self.open_u1.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
+            self.open_control_panel)
+        self.go_to_web.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
+            self.open_go_to_web)
+        self.get_help.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
+            self.open_web_help)
+        self.more_storage.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
+            self.open_get_more_storage)
+
+        # Add items
+        self.root_menu.child_append(self.open_u1)
+        self.root_menu.child_append(self.go_to_web)
+        self.root_menu.child_append(self.transfers)
+        self.root_menu.child_append(self.more_storage)
+        self.root_menu.child_append(self.get_help)
+
+        self.server = Dbusmenu.Server()
+        self.server.set_root(self.root_menu)
+        self.app = SyncMenu.App.new("ubuntuone-installer.desktop")
+        self.app.set_menu(self.server)
+        self.app.connect("notify::paused", self.change_sync_status)
+
+    def change_sync_status(self, *args):
+        """Triggered when the sync status is changed fromm the menu."""
+        if self._paused:
+            self._syncdaemon_service.connect()
+            self._paused = False
+        else:
+            self._syncdaemon_service.disconnect()
+            self._paused = True
+
+    def open_control_panel(self, *args):
+        """Open the Ubuntu One Control Panel."""
+        glib.spawn_command_line_async('ubuntuone-installer')
+
+    def open_go_to_web(self, *args):
+        """Open the Ubunto One Help Page"""
+        webbrowser.open(DASHBOARD)
+
+    def open_web_help(self, *args):
+        """Open the Ubunto One Help Page"""
+        webbrowser.open(HELP_LINK)
+
+    def open_get_more_storage(self, *args):
+        """Open the Ubunto One Help Page"""
+        webbrowser.open(GET_STORAGE_LINK)
+
+    def _timeout(self, result):
+        """The aggregating timer has expired, so update the UI."""
+        self.next_update = int(time.time()) + DELAY_BETWEEN_UPDATES
+        self.transfers.update_progress()
+        self.timer = None
+
+    def update_transfers(self):
+        """Set up a timer if there isn't one ticking and update the ui."""
+        if not self.timer:
+            logger.debug("Updating Transfers.")
+            delay = int(max(0, min(DELAY_BETWEEN_UPDATES,
+                self.next_update - time.time())))
+            self.timer = status.aggregator.Timer(delay)
+            self.timer.addCallback(self._timeout)
+
+
+class TransfersMenu(Dbusmenu.Menuitem):
+    """Menu that handles the recent and current transfers."""
+
+    def __init__(self, status_frontend):
+        super(TransfersMenu, self).__init__()
+        self.status_frontend = status_frontend
+        self.uploading = {}
+        self.previous_transfers = []
+        self._transfers_items = {}
+        self._uploading_items = {}
+
+    def update_progress(self):
+        """Update the list of recent transfers and current transfers."""
+        current_transfers = self.status_frontend.recent_transfers()
+        uploading_data = {}
+        for filename, size, written in \
+            self.status_frontend.files_uploading():
+            uploading_data[filename] = (size, written)
+
+        temp_transfers = {}
+        if current_transfers != self.previous_transfers:
+            logger.debug("Update recent transfers with: %r", current_transfers)
+            for item_transfer in self._transfers_items:
+                self.child_delete(self._transfers_items[item_transfer])
+            for item in current_transfers:
+                recent_file = Dbusmenu.Menuitem()
+                recent_file.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
+                    item)
+                self.child_add_position(recent_file, 0)
+                temp_transfers[item] = recent_file
+            self._transfers_items = temp_transfers
+
+        items_added = 0
+        remove = []
+        for item in self._uploading_items:
+            if item in uploading_data:
+                size, written = uploading_data[item]
+                percentage = written * 100 / size
+                upload_item = self._uploading_items[item]
+                upload_item.property_set_int(
+                    SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE,
+                    percentage)
+                logger.debug("Current transfer %s progress update: %r",
+                    item, percentage)
+                items_added += 1
+            else:
+                self.child_delete(self._uploading_items[item])
+                remove.append(item)
+        for item in remove:
+            self._uploading_items.pop(item)
+        if items_added < 5:
+            for item in uploading_data:
+                if item not in self._uploading_items and items_added < 5:
+                    size, written = uploading_data[item]
+                    percentage = written * 100 / size
+                    uploading_file = Dbusmenu.Menuitem()
+                    uploading_file.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
+                        item)
+                    uploading_file.property_set(Dbusmenu.MENUITEM_PROP_TYPE,
+                        SyncMenu.PROGRESS_MENUITEM_TYPE)
+                    uploading_file.property_set_int(
+                        SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE,
+                        percentage)
+                    logger.debug("Current transfer %s created", item)
+                    self.child_append(uploading_file)
+                    self._uploading_items[item] = uploading_file
+                    items_added += 1
+
+
+class DummySyncMenu(object):
+    """Dummy SyncMenu"""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize menu."""
+
+    def start_timer(self):
+        """Do nothing."""
+
+
+UbuntuOneSyncMenu = UbuntuOneSyncMenuLinux if use_syncmenu else DummySyncMenu
+>>>>>>> MERGE-SOURCE

=== modified file 'ubuntuone/status/aggregator.py'
--- ubuntuone/status/aggregator.py	2012-08-16 12:00:12 +0000
+++ ubuntuone/status/aggregator.py	2012-09-26 18:35:23 +0000
@@ -33,7 +33,7 @@
 import itertools
 import operator
 import os
-from collections import deque
+from collections import deque, Callable
 
 import gettext
 
@@ -41,7 +41,11 @@
 
 from ubuntuone.clientdefs import GETTEXT_PACKAGE
 from ubuntuone.status.logger import logger
-from ubuntuone.platform import session, notification
+from ubuntuone.platform import (
+    notification,
+    session,
+    sync_menu
+)
 from ubuntuone.platform.messaging import Messaging
 from ubuntuone.platform.launcher import UbuntuOneLauncher, DummyLauncher
 
@@ -625,6 +629,7 @@
         self.progress = {}
         self.to_do = {}
         self.recent_transfers = deque(maxlen=5)
+        self.listeners_callbacks = []
 
     def get_notification(self):
         """Create a new toggleable notification object."""
@@ -655,6 +660,13 @@
         self.to_do = {}
     # pylint: enable=W0201
 
+    def register_listener(self, listener):
+        """Register a callable object to be notified."""
+        if isinstance(listener, Callable):
+            self.listeners_callbacks.append(listener)
+        else:
+            raise TypeError("Callable object expected.")
+
     def get_discovery_message(self):
         """Get the text for the discovery bubble."""
         lines = []
@@ -716,6 +728,8 @@
             progress = float(
                 sum(self.progress.values())) / sum(self.to_do.values())
             self.progress_bar.set_progress(progress)
+        for listener in self.listeners_callbacks:
+            listener()
 
     def download_started(self, command):
         """A download just started."""
@@ -801,13 +815,24 @@
 class StatusFrontend(object):
     """Frontend for the status aggregator, used by the StatusListener."""
 
-    def __init__(self, clock=reactor):
+    def __init__(self, clock=reactor, service=None):
         """Initialize this instance."""
         self.aggregator = StatusAggregator(clock=clock)
         self.notification = self.aggregator.get_notification()
         self.messaging = Messaging()
         self.quota_timer = None
 
+        self.syncdaemon_service = service
+        self.sync_menu = None
+        self.start_sync_menu()
+
+    def start_sync_menu(self):
+        """Create the sync menu and run the loop."""
+        if self.syncdaemon_service is not None:
+            self.sync_menu = sync_menu.UbuntuOneSyncMenu(self,
+                self.syncdaemon_service)
+            self.aggregator.register_listener(self.sync_menu.update_transfers)
+
     def recent_transfers(self):
         """Return a tuple with the recent transfers paths."""
         return list(self.aggregator.recent_transfers)

=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2012-09-19 17:23:02 +0000
+++ ubuntuone/syncdaemon/main.py	2012-09-26 18:35:23 +0000
@@ -176,7 +176,8 @@
 
     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)
+        self.status_listener = status_listener.get_listener(self.fs, self.vm,
+            self.external)
         # subscribe to EQ, to be unsubscribed in shutdown
         if self.status_listener:
             self.event_q.subscribe(self.status_listener)

=== modified file 'ubuntuone/syncdaemon/status_listener.py'
--- ubuntuone/syncdaemon/status_listener.py	2012-08-10 12:49:46 +0000
+++ ubuntuone/syncdaemon/status_listener.py	2012-09-26 18:35:23 +0000
@@ -48,10 +48,10 @@
     return True
 
 
-def get_listener(fsm, vm):
+def get_listener(fsm, vm, syncdaemon_service=None):
     """Return an instance of the status listener, or None if turned off."""
     if should_start_listener():
-        status_frontend = StatusFrontend()
+        status_frontend = StatusFrontend(service=syncdaemon_service)
         return StatusListener(fsm, vm, status_frontend)
     else:
         return None