Merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0

[dobey]

[Rodney Dawes]

    Start the control panel, not the old installer which no longer exists.
    Disable the session inhibitor to prevent bug #737620 from happening.

[Mike McCracken]

    - Fix dummy sync menu implementation for windows and darwin. (LP: #1055840)
    - Make fsevents root daemon the default fs monitor for darwin, leave other platforms alone.
    - Send 'darwin' to server as platform name in auth. (LP: #1037435)

[Diego Sarmentero]

    - Sort items based on the written value, to prioritize the files being transferred (LP: #1052956).
    - Using a timer event that doesn't fire continuously if another update timer is in progress (LP: #1052922).

[Roberto Alsina (ralsina)]

review: Approve

=== modified file 'tests/platform/messaging/test_linux.py'
--- tests/platform/messaging/test_linux.py	2012-05-02 20:14:50 +0000
+++ tests/platform/messaging/test_linux.py	2012-10-02 20:28:28 +0000
@@ -39,7 +39,7 @@
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
 from ubuntuone.devtools.testcases import skipIf
-
+from ubuntuone.platform.messaging import linux
 from ubuntuone.platform.messaging.linux import (
     Messaging,
     _server_callback,
@@ -160,3 +160,11 @@
         actual_callback = messaging.create_callback()
         actual_callback(messaging.indicators[-1])
         self.assertEquals(0, len(messaging.indicators))
+
+    def test_open_u1(self):
+        """Check that the proper action is executed."""
+        data = []
+
+        self.patch(linux.glib, "spawn_command_line_async", data.append)
+        _server_callback(None)
+        self.assertEqual(data, ['ubuntuone-control-panel-qt'])

=== 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-10-02 20:28:28 +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-21 14:09:05 +0000
+++ tests/platform/sync_menu/test_linux.py	2012-10-02 20:28:28 +0000
@@ -28,6 +28,7 @@
 # files in the program, then also delete it here.
 """Test the Sync Menu."""
 
+import time
 from collections import Callable
 
 from twisted.internet import defer
@@ -57,18 +58,20 @@
         return self.uploading_data
 
 
-class FakeStatusListener(object):
-    """Fake StatusListener."""
-
-    def __init__(self):
-        self.status_frontend = FakeStatusFrontend()
-
-
-class FakeMain(object):
-    """Fake Main."""
-
-    def __init__(self):
-        self.status_listener = FakeStatusListener()
+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):
@@ -101,10 +104,10 @@
         dummy = linux.DummySyncMenu('random', 'args')
         self.assertIsInstance(dummy, linux.DummySyncMenu)
 
-    def test_dummy_has_start_timer(self):
+    def test_dummy_has_update_transfers(self):
         """Check that the dummy has the proper methods required by the API."""
         dummy = linux.DummySyncMenu('random', 'args')
-        self.assertIsInstance(dummy.start_timer, Callable)
+        self.assertIsInstance(dummy.update_transfers, Callable)
 
 
 class SyncMenuTestCase(TestCase):
@@ -117,12 +120,13 @@
         yield super(SyncMenuTestCase, self).setUp()
         self.patch(linux.SyncMenu, "App", FakeSyncMenuApp)
         FakeSyncMenuApp.clean()
-        self.main = FakeMain()
-        self.status_frontend = self.main.status_listener.status_frontend
+        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.main)
+        self.sync_menu = sync_menu.UbuntuOneSyncMenu(self.status_frontend,
+            self.syncdaemon_service)
 
     def _change_sync_status(self, *args):
         """Fake change_sync_status."""
@@ -170,7 +174,7 @@
 
         self.patch(linux.glib, "spawn_command_line_async", data.append)
         self.sync_menu.open_control_panel()
-        self.assertEqual(data, ['ubuntuone-installer'])
+        self.assertEqual(data, ['ubuntuone-control-panel-qt'])
 
     def test_go_to_web(self):
         """Check that the proper action is executed."""
@@ -330,3 +334,44 @@
             self.assertEqual(item.property_get_int(
                 linux.SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE),
                 percentage)
+
+    def test_transfers_order(self):
+        """Check that the proper transfers are shown first."""
+        data_current = [
+            ('file0', 1200, 610),
+            ('file1', 3000, 400),
+            ('file2', 2000, 100),
+            ('file3', 2500, 150),
+            ('file4', 2500, 950),
+            ('file5', 3500, 550),
+            ('file6', 1000, 600),
+            ('file7', 5000, 4600)]
+        expected = [
+            ('file7', 5000, 4600),
+            ('file4', 2500, 950),
+            ('file0', 1200, 610),
+            ('file6', 1000, 600),
+            ('file5', 3500, 550)]
+        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), 5)
+        for i, item in enumerate(children):
+            text = item.property_get(linux.Dbusmenu.MENUITEM_PROP_LABEL)
+            percentage = item.property_get_int(
+                linux.SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE)
+            name, size, written = expected[i]
+            percentage_expected = written * 100 / size
+            self.assertEqual(text, name)
+            self.assertEqual(percentage, percentage_expected)
+
+    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()
+        self.sync_menu.update_transfers()
+        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, 3)

=== 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-10-02 20:28:28 +0000
@@ -39,6 +39,7 @@
 
 from contrib.testing.testcase import BaseTwistedTestCase
 from ubuntuone.devtools.handlers import MementoHandler
+from ubuntuone.devtools.testcases import skipTest
 from ubuntuone.status import aggregator
 from ubuntuone.status.notification import AbstractNotification
 from ubuntuone.status.messaging import AbstractMessaging
@@ -576,7 +577,6 @@
         """Initialize this test instance."""
         yield super(ProgressBarTestCase, self).setUp()
         self.patch(aggregator, "UbuntuOneLauncher", FakeLauncher)
-        self.patch(aggregator.session, "Inhibitor", FakeInhibitor)
         self.clock = PatchedClock()
         self.bar = aggregator.ProgressBar(clock=self.clock)
         self.addCleanup(self.bar.cleanup)
@@ -662,6 +662,7 @@
         self.assertFalse(self.bar.visible)
         self.assertFalse(self.bar.launcher.progress_visible)
 
+    @skipTest('Inhibitor is disabled to prevent bug #737620')
     @defer.inlineCallbacks
     def test_progress_made_inhibits_logout_suspend(self):
         """Suspend and logout are inhibited when the progressbar is shown."""
@@ -670,6 +671,7 @@
         inhibitor = yield self.bar.inhibitor_defer
         self.assertEqual(inhibitor.flags, expected)
 
+    @skipTest('Inhibitor is disabled to prevent bug #737620')
     @defer.inlineCallbacks
     def test_completed_uninhibits_logout_suspend(self):
         """Suspend and logout are uninhibited when all has completed."""
@@ -1291,7 +1293,6 @@
         self.patch(aggregator, "ToggleableNotification",
                    FakeNotificationSingleton())
         self.patch(aggregator, "UbuntuOneLauncher", FakeLauncher)
-        self.patch(aggregator.session, "Inhibitor", FakeInhibitor)
         clock = PatchedClock()
         self.status_frontend = aggregator.StatusFrontend(clock=clock)
         self.aggregator = self.status_frontend.aggregator
@@ -1314,6 +1315,21 @@
         self.assertEqual({}, self.aggregator.to_do)
         self.assertIdentical(None, self.aggregator.queue_done_timer)
 
+    def test_register_progress_listener(self):
+        """Check that register listener handles properly additions."""
+
+        def fake_callback():
+            """Do nothing."""
+
+        self.aggregator.register_progress_listener(fake_callback)
+        self.assertEqual(len(self.aggregator.progress_listeners), 1)
+
+    def test_register_progress_listener_fail(self):
+        """Check that register listener fails with not Callable objects."""
+        self.assertRaises(TypeError,
+            self.aggregator.register_progress_listener, [])
+        self.assertEqual(len(self.aggregator.progress_listeners), 0)
+
     def assertMiscCommandQueued(self, fc):
         """Assert that some command was queued."""
         self.assertEqual(len(self.aggregator.to_do), 1)

=== modified file 'tests/syncdaemon/test_main.py'
--- tests/syncdaemon/test_main.py	2012-09-19 17:23:02 +0000
+++ tests/syncdaemon/test_main.py	2012-10-02 20:28:28 +0000
@@ -70,19 +70,6 @@
         return defer.succeed(None)
 
 
-class FakedSyncMenu(object):
-    """Do nothing."""
-
-    def __init__(self, *args, **kwargs):
-        self.arguments = (args, kwargs)
-
-    def update_progress(self):
-        """Do nothing."""
-
-    def start_timer(self):
-        """Do nothing."""
-
-
 class MainTests(BaseTwistedTestCase):
     """ Basic tests to check main.Main """
 
@@ -100,7 +87,6 @@
         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)
-        self.patch(main_mod.sync_menu, "UbuntuOneSyncMenu", FakedSyncMenu)
 
         self.handler = MementoHandler()
         self.handler.setLevel(logging.DEBUG)

=== 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-10-02 20:28:28 +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/__init__.py'
--- ubuntuone/platform/__init__.py	2012-08-06 19:18:57 +0000
+++ ubuntuone/platform/__init__.py	2012-10-02 20:28:28 +0000
@@ -33,11 +33,12 @@
 
 from dirspec.utils import user_home
 
-# very hackish way to avoid "import *" to satisfy pyflakes
-# and to avoid import ubuntuone.platform.X as source (it wont work)
-
+# define a platform string separate from sys.platform to be sent to
+# the server for metrics in ActionQueue.authenticate().
 if sys.platform == "win32":
     platform = "win32"
+elif sys.platform == "darwin":
+    platform = "darwin"
 else:
     platform = "linux"
 

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/__init__.py'
--- ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-08-28 07:58:50 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-10-02 20:28:28 +0000
@@ -60,8 +60,8 @@
     )
 
     FILEMONITOR_IDS = {
-        DEFAULT_MONITOR: common.FilesystemMonitor,
-        'daemon': darwin.fsevents_daemon.FilesystemMonitor,
+        DEFAULT_MONITOR: darwin.fsevents_daemon.FilesystemMonitor,
+        'macfsevents': common.FilesystemMonitor,
     }
     ACTIONS = darwin.fsevents_client.ACTIONS
 else:

=== modified file 'ubuntuone/platform/messaging/linux.py'
--- ubuntuone/platform/messaging/linux.py	2012-04-30 17:33:18 +0000
+++ ubuntuone/platform/messaging/linux.py	2012-10-02 20:28:28 +0000
@@ -34,6 +34,7 @@
 # of them are available, we should fall back to silently discarding
 # messages.
 
+import logging
 import sys
 
 indicate = None
@@ -61,6 +62,8 @@
 
 from ubuntuone.status.messaging import AbstractMessaging
 
+logger = logging.getLogger("ubuntuone.platform.Messaging")
+
 
 def open_volumes():
     """Open the control panel to the shares tab."""
@@ -69,8 +72,10 @@
 
 def _server_callback(the_indicator, message_time=None):
     """Open the control panel to the shares tab."""
-    glib.spawn_command_line_async('ubuntuone-installer')
-# pylint: enable=W0613
+    try:
+        glib.spawn_command_line_async('ubuntuone-control-panel-qt')
+    except glib.GError as e:
+        logger.warning('Failed to open the control panel: %s' % e)
 
 
 class Messaging(AbstractMessaging):

=== 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-10-02 20:28:28 +0000
@@ -26,18 +26,13 @@
 # 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."""
+"""Dummy implementation of sync_menu lib for win32 and darwin."""
 
 
 class UbuntuOneSyncMenu(object):
     """Integrate U1 with the Ubuntu Sync Menu."""
-
-    def __init__(self, *args):
-        self.transfers = DummyTransfersMenu()
-
-
-class DummyTransfersMenu(object):
-    """Dummy Transfers Menu."""
-
-    def start_timer(self):
-        """Empty start timer, this is not needed on windows."""
+    def __init__(self, status, syncdaemon_service):
+        """Match #args of linux syncmenu and do nothing."""
+
+    def update_transfers(self):
+        """Do nothing."""

=== modified file 'ubuntuone/platform/sync_menu/linux.py'
--- ubuntuone/platform/sync_menu/linux.py	2012-09-21 12:39:52 +0000
+++ ubuntuone/platform/sync_menu/linux.py	2012-10-02 20:28:28 +0000
@@ -29,8 +29,12 @@
 """Use SyncMenu lib to integrate U1 with the Systray Sync Icon."""
 
 import gettext
+import logging
+import time
 import sys
 import webbrowser
+from collections import OrderedDict
+from operator import itemgetter
 
 glib = None
 try:
@@ -50,10 +54,12 @@
     use_syncmenu = True
 except:
     use_syncmenu = False
-from twisted.internet import reactor
 
 from ubuntuone.clientdefs import GETTEXT_PACKAGE
-
+from ubuntuone import status
+
+
+logger = logging.getLogger("ubuntuone.platform.SyncMenu")
 
 Q_ = lambda string: gettext.dgettext(GETTEXT_PACKAGE, string)
 
@@ -63,6 +69,7 @@
 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/'
@@ -72,11 +79,12 @@
 class UbuntuOneSyncMenuLinux(object):
     """Integrate U1 with the Ubuntu Sync Menu."""
 
-    def __init__(self, main):
+    def __init__(self, status, syncdaemon_service):
         """Initialize menu."""
-        self._main = main
-        self.status_listener = main.status_listener
+        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()
@@ -86,7 +94,7 @@
         self.go_to_web.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
             GO_TO_WEB)
 
-        self.transfers = TransfersMenu(self.status_listener)
+        self.transfers = TransfersMenu(status)
         self.transfers.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
             TRANSFERS)
 
@@ -121,22 +129,21 @@
         self.app.set_menu(self.server)
         self.app.connect("notify::paused", self.change_sync_status)
 
-    def start_timer(self):
-        """Start the transfers timer."""
-        self.transfers.start_timer()
-
     def change_sync_status(self, *args):
         """Triggered when the sync status is changed fromm the menu."""
         if self._paused:
-            self._main.external.connect()
+            self._syncdaemon_service.connect()
             self._paused = False
         else:
-            self._main.external.disconnect()
+            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')
+        try:
+            glib.spawn_command_line_async('ubuntuone-control-panel-qt')
+        except glib.GError as e:
+            logger.warning('Failed to open the control panel: %s.' % e)
 
     def open_go_to_web(self, *args):
         """Open the Ubunto One Help Page"""
@@ -150,36 +157,49 @@
         """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, listener):
+    def __init__(self, status_frontend):
         super(TransfersMenu, self).__init__()
-        self.listener = listener
+        self.status_frontend = status_frontend
         self.uploading = {}
         self.previous_transfers = []
         self._transfers_items = {}
         self._uploading_items = {}
 
-    def start_timer(self):
-        """Trigger an update in one second."""
-        self.update_progress()
-        reactor.callLater(3, self.start_timer)
-
     def update_progress(self):
         """Update the list of recent transfers and current transfers."""
-        current_transfers = self.listener.status_frontend.recent_transfers()
-        uploading_data = {}
-        for filename, size, written in \
-            self.listener.status_frontend.files_uploading():
+        recent_transfers = self.status_frontend.recent_transfers()
+        current_transfers = self.status_frontend.files_uploading()
+        current_transfers.sort(key=itemgetter(2))
+        current_transfers.reverse()
+        uploading_data = OrderedDict()
+        for filename, size, written in current_transfers:
             uploading_data[filename] = (size, written)
 
         temp_transfers = {}
-        if current_transfers != self.previous_transfers:
+        if recent_transfers != self.previous_transfers:
+            logger.debug("Update recent transfers with: %r", recent_transfers)
             for item_transfer in self._transfers_items:
                 self.child_delete(self._transfers_items[item_transfer])
-            for item in current_transfers:
+            for item in recent_transfers:
                 recent_file = Dbusmenu.Menuitem()
                 recent_file.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
                     item)
@@ -197,6 +217,8 @@
                 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])
@@ -216,6 +238,7 @@
                     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
@@ -227,8 +250,7 @@
     def __init__(self, *args, **kwargs):
         """Initialize menu."""
 
-    def start_timer(self):
+    def update_transfers(self):
         """Do nothing."""
 
-
 UbuntuOneSyncMenu = UbuntuOneSyncMenuLinux if use_syncmenu else DummySyncMenu

=== modified file 'ubuntuone/status/aggregator.py'
--- ubuntuone/status/aggregator.py	2012-08-16 12:00:12 +0000
+++ ubuntuone/status/aggregator.py	2012-10-02 20:28:28 +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,10 @@
 
 from ubuntuone.clientdefs import GETTEXT_PACKAGE
 from ubuntuone.status.logger import logger
-from ubuntuone.platform import session, notification
+from ubuntuone.platform import (
+    notification,
+    sync_menu
+)
 from ubuntuone.platform.messaging import Messaging
 from ubuntuone.platform.launcher import UbuntuOneLauncher, DummyLauncher
 
@@ -529,7 +532,6 @@
     progress = 0.0
     updates_delay = 0.1
     timer = None
-    inhibitor_defer = None
 
     def __init__(self, clock=reactor):
         """Initialize this instance."""
@@ -559,9 +561,6 @@
             self.visible = True
             self.launcher.show_progressbar()
             logger.debug("progressbar shown")
-            if self.inhibitor_defer is None:
-                self.inhibitor_defer = session.inhibit_logout_suspend(
-                                                         FILE_SYNC_IN_PROGRESS)
         if not self.timer:
             self.timer = Timer(self.updates_delay, clock=self.clock)
             self.timer.addCallback(self._timeout)
@@ -572,14 +571,6 @@
         self.visible = False
         self.launcher.hide_progressbar()
         logger.debug("progressbar hidden")
-        if self.inhibitor_defer is not None:
-
-            def inhibitor_callback(inhibitor):
-                """The inhibitor was found, so cancel it."""
-                self.inhibitor_defer = None
-                return inhibitor.cancel()
-
-            self.inhibitor_defer.addCallback(inhibitor_callback)
 
 
 class FinalStatusBubble(object):
@@ -625,6 +616,7 @@
         self.progress = {}
         self.to_do = {}
         self.recent_transfers = deque(maxlen=5)
+        self.progress_listeners = []
 
     def get_notification(self):
         """Create a new toggleable notification object."""
@@ -655,6 +647,13 @@
         self.to_do = {}
     # pylint: enable=W0201
 
+    def register_progress_listener(self, listener):
+        """Register a callable object to be notified."""
+        if isinstance(listener, Callable):
+            self.progress_listeners.append(listener)
+        else:
+            raise TypeError("Callable object expected.")
+
     def get_discovery_message(self):
         """Get the text for the discovery bubble."""
         lines = []
@@ -716,6 +715,8 @@
             progress = float(
                 sum(self.progress.values())) / sum(self.to_do.values())
             self.progress_bar.set_progress(progress)
+        for listener in self.progress_listeners:
+            listener()
 
     def download_started(self, command):
         """A download just started."""
@@ -801,13 +802,25 @@
 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 register the progress listener."""
+        if self.syncdaemon_service is not None:
+            self.sync_menu = sync_menu.UbuntuOneSyncMenu(self,
+                self.syncdaemon_service)
+            self.aggregator.register_progress_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-10-02 20:28:28 +0000
@@ -48,10 +48,7 @@
     volume_manager,
 )
 from ubuntuone import syncdaemon, clientdefs
-from ubuntuone.platform import (
-    event_logging,
-    sync_menu,
-)
+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
@@ -159,14 +156,6 @@
         self.mark = task.LoopingCall(self.log_mark)
         self.mark.start(mark_interval)
 
-        self.sync_menu = None
-        self.start_sync_menu()
-
-    def start_sync_menu(self):
-        """Create the sync menu and run the loop."""
-        self.sync_menu = sync_menu.UbuntuOneSyncMenu(self)
-        self.sync_menu.start_timer()
-
     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)
@@ -176,7 +165,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-10-02 20:28:28 +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