Merge lp:~thisfred/ubuntuone-client/tune-notifications into lp:ubuntuone-client

[Eric Casteleijn]

* removed progress notifications
* don't show empty notifications
* only show queue_done notifications after a delay where no new events came in

* removed progress notifications
* don't show empty notifications
* only show queue_done notifications after a delay where no new events came in. (set to 5 seconds which seems to work well OMM)

To test:

  u1sdtool -q
  PYTHONPATH=. bin/ubuntuone-syncdaemon

now on a different machine, do a bzr checkout in your Ubuntu One folder. (Or do something else that adds a lot of small files relatively quickly.)

On the receiving machine, you should now no longer see many download finished messages popping up one after the other, but rather one at the end. If your connection is slow or the servers are having trouble, you *might* see more than one, but never more than one per 5 seconds. Let me know if we should tune that number further.

[Natalia Bidart (nataliabidart)]

review: Approve

[dobey (dobey)]

Looks sane to me. I might have picked 10s from past experience with this exact problem, but we'll see how 5s works. :)

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~thisfred/ubuntuone-client/tune-notifications into lp:ubuntuone-client failed. Below is the output from the failed tests.

/usr/bin/gnome-autogen.sh
checking for autoconf >= 2.53...
  testing autoconf2.50... not found.
  testing autoconf... found 2.67
checking for automake >= 1.10...
  testing automake-1.11... found 1.11.1
checking for libtool >= 1.5...
  testing libtoolize... found 2.2.6b
checking for intltool >= 0.30...
  testing intltoolize... found 0.41.1
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.25
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.16
Checking for required M4 macros...
Checking for forbidden M4 macros...
Processing ./configure.ac
Running libtoolize...
libtoolize: putting auxiliary files in `.'.
libtoolize: copying file `./ltmain.sh'
libtoolize: putting macros in AC_CONFIG_MACRO_DIR, `m4'.
libtoolize: copying file `m4/libtool.m4'
libtoolize: copying file `m4/ltoptions.m4'
libtoolize: copying file `m4/ltsugar.m4'
libtoolize: copying file `m4/ltversion.m4'
libtoolize: copying file `m4/lt~obsolete.m4'
Running intltoolize...
Running gtkdocize...
Running aclocal-1.11...
Running autoconf...
Running autoheader...
Running automake-1.11...
Running ./configure --enable-gtk-doc --enable-debug ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... gawk
checking whether make sets $(MAKE)... yes
checking for style of include used by make... GNU
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for library containing strerror... none required
checking for gcc... (cached) gcc
checking whether we are using the GNU C compiler... (cached) yes
checking whether gcc accepts -g... (cached) yes
checking for gcc option to accept ISO C89... (cached) none needed
checking dependency style of gcc... (cached) gcc3
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... yes
checking for /usr/bin/ld option to reload object files... -r
checking for objdump... objdump
checking how to recognize dependent ...

[lp:~thisfred/ubuntuone-client/tune-notifications]

935. By Eric Casteleijn on 2011-03-23

set the property before calling reset.

=== modified file 'tests/status/test_aggregator.py'
--- tests/status/test_aggregator.py	2011-03-22 16:59:19 +0000
+++ tests/status/test_aggregator.py	2011-03-23 20:01:28 +0000
@@ -200,7 +200,6 @@
         """Initialize this instance."""
         self.discovered = 0
         self.completed = 0
-        self.restart_progress_bubble_called = False
         self.notification_switch = aggregator.NotificationSwitch()
 
     def get_discovery_message(self):
@@ -226,10 +225,6 @@
         """Return the final status message."""
         return "a lot of files completed."""
 
-    def restart_progress_bubble(self):
-        """Reset the progress bubble."""
-        self.restart_progress_bubble_called = True
-
     def get_notification(self):
         """Create a new toggleable notification object."""
         return self.notification_switch.get_notification()
@@ -340,12 +335,6 @@
         notification = (aggregator.UBUNTUONE_TITLE, message, None, False)
         self.assertIn(notification, self.get_notifications_shown())
 
-    def test_popup_resets_progress_bubble(self):
-        """The popup callback resets the progress bubble."""
-        self.bubble.new_file_found()
-        self.bubble._popup()
-        self.assertTrue(self.aggregator.restart_progress_bubble_called)
-
     def test_notification_is_logged_in_debug(self):
         """The notification is printed in the debug log."""
         self.bubble.new_file_found()
@@ -430,14 +419,6 @@
         self.clock.advance(self.updates_delay)
         self.assertEqual(2, len(self.get_notifications_shown()))
 
-    def test_update_resets_progress_bubble(self):
-        """The update callback resets the progress bubble."""
-        self.bubble.new_file_found()
-        self.bubble._popup()
-        self.bubble.new_file_found()
-        self.bubble._update()
-        self.assertTrue(self.aggregator.restart_progress_bubble_called)
-
     def test_update_modifies_notification(self):
         """The update callback updates notifications."""
         self.bubble.new_file_found()
@@ -458,91 +439,6 @@
         self.assertTrue(self.handler.check_debug(msg))
 
 
-class ProgressBubbleTestCase(TestCase):
-    """Tests for the progress bubble."""
-
-    def setUp(self):
-        """Initialize this test instance."""
-        self.patch(aggregator, "ToggleableNotification",
-                   FakeNotificationSingleton())
-        self.clock = PatchedClock()
-        self.aggregator = FakeStatusAggregator(clock=self.clock)
-        self.bubble = aggregator.ProgressBubble(self.aggregator,
-                                                clock=self.clock)
-        self.addCleanup(self.bubble.cleanup)
-        self.smaller_delay = aggregator.ProgressBubble.sleep_delay * 0.8
-        self.right_delay = aggregator.ProgressBubble.sleep_delay
-        self.longer_delay = aggregator.ProgressBubble.sleep_delay * 1.2
-
-    def test_is_created_successfully(self):
-        """The progress bubble is created and idle."""
-        self.assertEqual(None, self.bubble.timer)
-
-    def test_restart_creates_timer(self):
-        """Restarting creates a timer."""
-        self.bubble.restart()
-        self.assertNotEqual(None, self.bubble.timer)
-
-    def test_not_shown_initially(self):
-        """The bubble is not shown initially."""
-        self.bubble.restart()
-        self.assertEqual(None, self.bubble.notification)
-
-    def test_not_shown_immediately(self):
-        """The bubble is not shown immediately."""
-        self.bubble.restart()
-        self.clock.advance(self.smaller_delay)
-        self.assertEqual(None, self.bubble.notification)
-
-    def test_shown_after_delay(self):
-        """The bubble is shown after the standard delay."""
-        self.bubble.restart()
-        self.clock.advance(self.longer_delay)
-        self.assertEqual(1, len(self.bubble.notification.notifications_shown))
-
-    def test_not_shown_if_restarted(self):
-        """The delay is adjusted when restarting."""
-        self.bubble.restart()
-        self.clock.advance(self.smaller_delay)
-        self.bubble.restart()
-        self.clock.advance(self.smaller_delay)
-        self.assertEqual(None, self.bubble.notification)
-
-    def test_delay_reached_after_restart(self):
-        """The timeout is still reached after a restart."""
-        self.bubble.restart()
-        self.clock.advance(self.smaller_delay)
-        self.bubble.restart()
-        self.clock.advance(self.longer_delay)
-        self.assertEqual(1, len(self.bubble.notification.notifications_shown))
-
-    def test_can_be_stopped(self):
-        """The timeout can be stopped."""
-        self.bubble.restart()
-        self.clock.advance(self.smaller_delay)
-        self.bubble.stop()
-        self.clock.advance(self.longer_delay)
-        self.assertEqual(None, self.bubble.notification)
-
-    def test_delay_reached_after_stopping_then_restarting(self):
-        """The timeout is still reached after a stop followed by a restart."""
-        self.bubble.restart()
-        self.clock.advance(self.smaller_delay)
-        self.bubble.stop()
-        self.clock.advance(self.longer_delay)
-        self.bubble.restart()
-        self.clock.advance(self.longer_delay)
-        self.assertEqual(1, len(self.bubble.notification.notifications_shown))
-
-    def test_restarts_automatically(self):
-        """The timer is restarted automatically."""
-        self.bubble.restart()
-        self.clock.advance(self.right_delay)
-        self.assertEqual(1, len(self.bubble.notification.notifications_shown))
-        self.clock.advance(self.right_delay)
-        self.assertEqual(2, len(self.bubble.notification.notifications_shown))
-
-
 class FinalBubbleTestCase(TestCase):
     """Test for the final status notification bubble."""
 
@@ -788,14 +684,6 @@
         """The queue completed all operations."""
         self.queued_commands.clear()
 
-    def misc_command_queued(self, command):
-        """A new command was queued."""
-        self.queued_commands.add(command)
-
-    def misc_command_unqueued(self, command):
-        """A new command was unqueued."""
-        self.queued_commands.discard(command)
-
     def get_notification(self):
         """Create a new toggleable notification object."""
         return self.notification_switch.get_notification()
@@ -803,24 +691,24 @@
     def download_started(self, command):
         """A download just started."""
         self.files_downloading.append(command)
-        self.misc_command_queued(command)
+        self.queued_commands.add(command)
 
     def download_finished(self, command):
         """A download just finished."""
         if command in self.files_downloading:
             self.files_downloading.remove(command)
-        self.misc_command_unqueued(command)
+        self.queued_commands.discard(command)
 
     def upload_started(self, command):
         """An upload just started."""
         self.files_uploading.append(command)
-        self.misc_command_queued(command)
+        self.queued_commands.add(command)
 
     def upload_finished(self, command):
         """An upload just finished."""
         if command in self.files_uploading:
             self.files_uploading.remove(command)
-        self.misc_command_unqueued(command)
+        self.queued_commands.discard(command)
 
     def connection_made(self):
         """The client made the connection to the server."""
@@ -914,21 +802,6 @@
         qc = self.status_frontend.aggregator.queued_commands
         self.assertNotIn(fake_command, qc)
 
-    def test_queue_added(self):
-        """A command was added to the queue."""
-        fake_command = FakeCommand()
-        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
-        qc = self.status_frontend.aggregator.queued_commands
-        self.assertIn(fake_command, qc)
-
-    def test_queue_removed(self):
-        """A command has finished and is removed from the queue."""
-        fake_command = FakeCommand()
-        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
-        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
-        qc = self.status_frontend.aggregator.queued_commands
-        self.assertNotIn(fake_command, qc)
-
     def test_queue_done(self):
         """The queue is empty."""
         fake_command = FakeCommand()
@@ -1161,27 +1034,6 @@
         """Cleanup this instance."""
 
 
-class FakeProgressBubble(object):
-    """A fake ProgressBubble object."""
-
-    started = False
-    stopped = False
-
-    def __init__(self, status_aggregator, clock=None):
-        """Initialize this instance."""
-        self.status_aggregator = status_aggregator
-
-    def cleanup(self):
-        """Cleanup this instance."""
-
-    def restart(self):
-        """Start this bubble waiting."""
-        self.started = True
-
-    def stop(self):
-        """Make this bubble stop."""
-
-
 class FakeFinalBubble(object):
     """A fake FinalStatusBubble."""
 
@@ -1206,15 +1058,14 @@
         """Initialize this test instance."""
         self.patch(aggregator, "FileDiscoveryBubble",
                    FakeFileDiscoveryBubble)
-        self.patch(aggregator, "ProgressBubble",
-                   FakeProgressBubble)
         self.patch(aggregator, "FinalStatusBubble",
                    FakeFinalBubble)
         self.patch(aggregator, "ToggleableNotification",
                    FakeNotificationSingleton())
         self.patch(aggregator, "UbuntuOneLauncher", FakeLauncher)
         self.patch(aggregator.session, "Inhibitor", FakeInhibitor)
-        self.status_frontend = aggregator.StatusFrontend()
+        clock = PatchedClock()
+        self.status_frontend = aggregator.StatusFrontend(clock=clock)
         self.aggregator = self.status_frontend.aggregator
         self.fake_bubble = self.aggregator.file_discovery_bubble
 
@@ -1253,21 +1104,6 @@
         """Test that the counters start at zero."""
         self.assertStatusReset()
 
-    def test_misc_command_queue(self):
-        """Test that a misc command was queued."""
-        fc = FakeCommand()
-        self.status_frontend.queue_added(fc)
-        self.assertMiscCommandQueued(fc)
-        self.assertEqual(0, self.aggregator.progress_bar.progress)
-
-    def test_misc_command_unqueue(self):
-        """Test that a misc command was unqueued."""
-        fc = FakeCommand()
-        self.status_frontend.queue_added(fc)
-        self.status_frontend.queue_removed(fc)
-        self.assertMiscCommandUnqueued(fc)
-        self.assertEqual(1.0, self.aggregator.progress_bar.progress)
-
     def test_file_download_started(self):
         """Test that a file has started download."""
         fc = FakeCommand(path='testfile.txt')
@@ -1323,76 +1159,6 @@
         result = self.aggregator.get_discovery_message()
         self.assertEqual(expected, result)
 
-    def test_get_progress_message(self):
-        """Test the message that's shown on the progress bubble."""
-        self.aggregator.upload_done = 5
-        self.aggregator.upload_total = 10
-        self.aggregator.uploading_filename = FILENAME
-        self.aggregator.download_done = 3
-        self.aggregator.download_total = 8
-        self.aggregator.downloading_filename = FILENAME2
-        self.aggregator.done_counter = 9
-        self.aggregator.total_counter = 20
-        percentage = int(100.0 * self.aggregator.done_counter /
-                         self.aggregator.total_counter)
-
-        expected = (
-            aggregator.files_being_uploaded(
-                FILENAME, self.aggregator.upload_total) + "\n" +
-            aggregator.files_being_downloaded(
-                FILENAME2, self.aggregator.download_total) + "\n" +
-            aggregator.PROGRESS_COMPLETED) % {
-            'percentage_completed': percentage}
-
-        result = self.aggregator.get_progress_message()
-        self.assertEqual(expected, result)
-
-    def test_get_progress_message_no_uploads(self):
-        """The progress message when no uploads are going on."""
-
-        self.aggregator.upload_done = 0
-        self.aggregator.upload_total = 0
-        self.aggregator.downloading_filename = FILENAME
-        self.aggregator.download_done = 3
-        self.aggregator.download_total = 8
-        self.aggregator.done_counter = 9
-        self.aggregator.total_counter = 20
-        percentage = int(100.0 * self.aggregator.done_counter /
-                         self.aggregator.total_counter)
-        expected = (
-            aggregator.files_being_downloaded(
-                FILENAME, self.aggregator.download_total) + "\n" +
-            aggregator.PROGRESS_COMPLETED) % {
-            'percentage_completed': percentage}
-
-        result = self.aggregator.get_progress_message()
-        self.assertEqual(expected, result)
-
-    def test_get_progress_message_no_downloads(self):
-        """The progress message when no downloads are going on."""
-        self.aggregator.upload_done = 5
-        self.aggregator.upload_total = 10
-        self.aggregator.uploading_filename = FILENAME
-        self.aggregator.download_done = 0
-        self.aggregator.download_total = 0
-        self.aggregator.done_counter = 9
-        self.aggregator.total_counter = 20
-        percentage = int(100.0 * self.aggregator.done_counter /
-                         self.aggregator.total_counter)
-        expected = (
-            aggregator.files_being_uploaded(
-                FILENAME, self.aggregator.upload_total) +
-            "\n" + aggregator.PROGRESS_COMPLETED) % {
-            'percentage_completed': percentage}
-
-        result = self.aggregator.get_progress_message()
-        self.assertEqual(expected, result)
-
-    def test_get_progress_message_no_total(self):
-        """No progress message possible if total counter is zero."""
-        self.aggregator.total_counter = 0
-        self.assertRaises(AssertionError, self.aggregator.get_progress_message)
-
     def test_get_final_status_message(self):
         """The final status message."""
         done = (5, 10)
@@ -1438,11 +1204,6 @@
         result = self.aggregator.get_final_status_message()
         self.assertEqual(expected, result)
 
-    def test_started_progress_bubble(self):
-        """The progress bubble is started."""
-        self.aggregator.restart_progress_bubble()
-        self.assertTrue(self.aggregator.progress_bubble.started)
-
     def test_queue_done_shows_bubble_when_downloads_happened(self):
         """On queue done, show final bubble if downloads happened."""
         fc = FakeCommand()
@@ -1450,6 +1211,7 @@
         self.status_frontend.download_finished(fc)
         old_final_bubble = self.aggregator.final_status_bubble
         self.aggregator.queue_done()
+        self.aggregator.clock.advance(self.aggregator.finished_delay + 1)
         self.assertTrue(old_final_bubble.shown)
 
     def test_queue_done_shows_bubble_when_uploads_happened(self):
@@ -1459,6 +1221,24 @@
         self.status_frontend.upload_finished(fc)
         old_final_bubble = self.aggregator.final_status_bubble
         self.aggregator.queue_done()
+        self.aggregator.clock.advance(self.aggregator.finished_delay + 1)
+        self.assertTrue(old_final_bubble.shown)
+
+    def test_queue_done_shows_bubble_only_after_delay(self):
+        """On queue_done, show final bubble only after a delay."""
+        fc = FakeCommand()
+        self.status_frontend.upload_started(fc)
+        self.status_frontend.upload_finished(fc)
+        old_final_bubble = self.aggregator.final_status_bubble
+        self.aggregator.queue_done()
+        self.assertFalse(old_final_bubble.shown)
+        self.aggregator.clock.advance(self.aggregator.finished_delay - 1)
+        self.assertFalse(old_final_bubble.shown)
+        self.aggregator.queue_done()
+        self.assertFalse(old_final_bubble.shown)
+        self.aggregator.clock.advance(2)
+        self.assertFalse(old_final_bubble.shown)
+        self.aggregator.clock.advance(self.aggregator.finished_delay + 1)
         self.assertTrue(old_final_bubble.shown)
 
     def test_queue_done_does_not_show_bubble_when_no_transfers_happened(self):
@@ -1474,6 +1254,7 @@
         fc = FakeCommand()
         self.status_frontend.upload_started(fc)
         self.aggregator.queue_done()
+        self.aggregator.clock.advance(self.aggregator.finished_delay + 1)
         self.assertStatusReset()
         self.assertEqual(0.0, self.aggregator.progress_bar.progress)
         self.assertFalse(self.aggregator.progress_bar.visible)
@@ -1524,7 +1305,6 @@
         sf = aggregator.StatusFrontend(clock=clock)
         sf.set_show_all_notifications(True)
 
-        clock.advance(aggregator.ProgressBubble.sleep_delay)
         # the progress bar is not visible yet
         self.assertFalse(sf.aggregator.progress_bar.visible)
         sf.upload_started(upload)
@@ -1548,25 +1328,12 @@
         clock.advance(aggregator.FileDiscoveryUpdateState.updates_timeout -
                       aggregator.FileDiscoveryUpdateState.updates_delay)
         sf.upload_finished(upload)
-        # the progress bubble has no notifications yet
-        self.assertEqual(None, sf.aggregator.progress_bubble.notification)
-        clock.advance(aggregator.ProgressBubble.sleep_delay)
-        # the progress bubble is shown
-        self.assertEqual(3, len(notifications_shown))
         sf.upload_finished(download)
         # the progress still is now 100%
         self.assertEqual(1.0, sf.aggregator.progress_bar.progress)
-        # progress, but the progress bubble is not updated immediately
-        self.assertEqual(3, len(notifications_shown))
-        clock.advance(aggregator.ProgressBubble.sleep_delay)
-        # the progress bubble is updated after a delay
-        self.assertEqual(4, len(notifications_shown))
         sf.queue_done()
-        # the final bubble is shown immediately
-        self.assertEqual(5, len(notifications_shown))
-        clock.advance(aggregator.ProgressBubble.sleep_delay * 2)
-        # no more notifications are shown
-        self.assertEqual(5, len(notifications_shown))
+        clock.advance(sf.aggregator.finished_delay + 1)
+        self.assertEqual(3, len(notifications_shown))
 
     def test_all_together_now_off(self):
         """Make all parts work together, but with notifications off."""
@@ -1579,7 +1346,6 @@
         sf = aggregator.StatusFrontend(clock=clock)
         sf.set_show_all_notifications(False)
 
-        clock.advance(aggregator.ProgressBubble.sleep_delay)
         # the progress bar is not visible yet
         self.assertFalse(sf.aggregator.progress_bar.visible)
         sf.upload_started(upload)
@@ -1601,17 +1367,9 @@
         clock.advance(aggregator.FileDiscoveryUpdateState.updates_timeout -
                       aggregator.FileDiscoveryUpdateState.updates_delay)
         sf.upload_finished(upload)
-        # the progress bubble has no notifications yet
-        self.assertEqual(None, sf.aggregator.progress_bubble.notification)
-        clock.advance(aggregator.ProgressBubble.sleep_delay)
-        self.assertEqual(0, len(notifications_shown))
         sf.upload_finished(download)
         # the progress still is now 100%
         self.assertEqual(1.0, sf.aggregator.progress_bar.progress)
         self.assertEqual(0, len(notifications_shown))
-        clock.advance(aggregator.ProgressBubble.sleep_delay)
-        self.assertEqual(0, len(notifications_shown))
         sf.queue_done()
         self.assertEqual(0, len(notifications_shown))
-        clock.advance(aggregator.ProgressBubble.sleep_delay * 2)
-        self.assertEqual(0, len(notifications_shown))
 
=== modified file 'tests/syncdaemon/test_status_listener.py'
--- tests/syncdaemon/test_status_listener.py	2011-02-09 08:23:04 +0000
+++ tests/syncdaemon/test_status_listener.py	2011-03-23 20:01:28 +0000
@@ -250,32 +250,6 @@
         self.assertIn(call, self.status_frontend.call_log)
 
     @defer.inlineCallbacks
-    def test_queue_added_is_forwarded(self):
-        """A misc queue added event is forwarded."""
-        fake_command = object()
-
-        d = defer.Deferred()
-        self._listen_for('SYS_QUEUE_ADDED', d.callback)
-        self.main.event_q.push('SYS_QUEUE_ADDED', command=fake_command)
-        yield d
-
-        call = ("queue_added", (fake_command,), {})
-        self.assertIn(call, self.status_frontend.call_log)
-
-    @defer.inlineCallbacks
-    def test_queue_removed_is_forwarded(self):
-        """A queue removed event is forwarded."""
-        fake_command = object()
-
-        d = defer.Deferred()
-        self._listen_for('SYS_QUEUE_REMOVED', d.callback)
-        self.main.event_q.push('SYS_QUEUE_REMOVED', command=fake_command)
-        yield d
-
-        call = ("queue_removed", (fake_command,), {})
-        self.assertIn(call, self.status_frontend.call_log)
-
-    @defer.inlineCallbacks
     def test_queue_done_is_forwarded(self):
         """A queue done event is forwarded."""
         d = defer.Deferred()
 
=== modified file 'ubuntuone/status/aggregator.py'
--- ubuntuone/status/aggregator.py	2011-03-22 17:20:50 +0000
+++ ubuntuone/status/aggregator.py	2011-03-23 20:01:28 +0000
@@ -465,17 +465,17 @@
     def _popup(self):
         """Display the notification."""
         text = self.status_aggregator.get_discovery_message()
-        self.notification.send_notification(UBUNTUONE_TITLE, text)
-        self.status_aggregator.restart_progress_bubble()
-        logger.debug("notification shown: %s", text)
+        if text:
+            self.notification.send_notification(UBUNTUONE_TITLE, text)
+            logger.debug("notification shown: %s", text)
         self._change_state(FileDiscoveryUpdateState)
 
     def _update(self):
         """Update the notification."""
         text = self.status_aggregator.get_discovery_message()
-        logger.debug("notification updated: %s", text)
-        self.status_aggregator.restart_progress_bubble()
-        self.notification.send_notification(UBUNTUONE_TITLE, text)
+        if text:
+            logger.debug("notification updated: %s", text)
+            self.notification.send_notification(UBUNTUONE_TITLE, text)
 
     def start_sleeping(self):
         """Wait for 10 minutes before annoying again."""
@@ -490,39 +490,6 @@
         self.state.new_file_found()
 
 
-class ProgressBubble(object):
-    """Show a notification for transfer progress."""
-
-    sleep_delay = 600
-    notification = None
-    timer = None
-
-    def __init__(self, status_aggregator, clock=reactor):
-        """Initialize this instance."""
-        self.status_aggregator = status_aggregator
-        self.clock = clock
-
-    def restart(self):
-        """Start running the timer."""
-        self.cleanup()
-        self.timer = Timer(self.sleep_delay, clock=self.clock)
-        self.timer.addCallback(self._timeout)
-
-    def _timeout(self, _):
-        """Show the bubble."""
-        self.notification = self.status_aggregator.get_notification()
-        text = self.status_aggregator.get_progress_message()
-        self.notification.send_notification(UBUNTUONE_TITLE, text)
-        self.restart()
-
-    def cleanup(self):
-        """Cleanup this instance."""
-        if self.timer:
-            self.timer.cleanup()
-
-    stop = cleanup
-
-
 class ProgressBar(object):
     """Update a progressbar no more than 10 times a second."""
     pulsating = True
@@ -624,15 +591,16 @@
     """The status aggregator backend."""
 
     file_discovery_bubble = None
-    progress_bubble = None
     final_status_bubble = None
 
     def __init__(self, clock=reactor):
         """Initialize this instance."""
         self.clock = clock
         self.notification_switch = NotificationSwitch()
+        self.queue_done_timer = None
         self.reset()
         self.progress_bar = ProgressBar(clock=self.clock)
+        self.finished_delay = 10
 
     def get_notification(self):
         """Create a new toggleable notification object."""
@@ -651,16 +619,14 @@
         self.uploading_filename = ''
         self.files_downloading = []
         self.downloading_filename = ''
+        if self.queue_done_timer is not None:
+            self.queue_done_timer.cleanup()
 
         if self.file_discovery_bubble:
             self.file_discovery_bubble.cleanup()
         self.file_discovery_bubble = FileDiscoveryBubble(self,
                                                          clock=self.clock)
 
-        if self.progress_bubble:
-            self.progress_bubble.cleanup()
-        self.progress_bubble = ProgressBubble(self, clock=self.clock)
-
         if self.final_status_bubble:
             self.final_status_bubble.cleanup()
         self.final_status_bubble = FinalStatusBubble(self)
@@ -681,23 +647,6 @@
                 self.downloading_filename, files_downloading))
         return "\n".join(lines)
 
-    def get_progress_message(self):
-        """Get some lines describing the progress."""
-        assert self.total_counter > 0
-        parts = []
-        upload_total = self.upload_total
-        if upload_total:
-            parts.append(files_being_uploaded(
-                self.uploading_filename, upload_total))
-        download_total = self.download_total
-        if download_total:
-            parts.append(files_being_downloaded(
-                self.downloading_filename, download_total))
-        progress_percentage = 100.0 * self.done_counter / self.total_counter
-        format_args = {"percentage_completed": int(progress_percentage)}
-        parts.append(PROGRESS_COMPLETED % format_args)
-        return "\n".join(parts)
-
     def get_final_status_message(self):
         """Get some lines describing all we did."""
         parts = []
@@ -713,45 +662,48 @@
                 self.downloading_filename, download_done))
         return "\n".join(parts)
 
-    def restart_progress_bubble(self):
-        """Restart the progress bubble."""
-        self.progress_bubble.restart()
-
-    def queue_done(self):
+    def _queue_done(self, _):
         """Show final bubble and reset counters."""
+        self.queue_done_timer.cleanup()
+        self.queue_done_timer = None
+        logger.debug("queue done callback fired")
         if self.upload_done + self.download_done > 0:
             self.final_status_bubble.show()
         self.progress_bar.completed()
         self.reset()
 
-    def misc_command_queued(self, command):
-        """A miscellaneous command was queued."""
-        self.total_counter += 1
-        logger.debug("queueing command (%d/%d): %s", self.done_counter,
-                     self.total_counter, command.__class__.__name__)
-        self.update_progressbar()
+    def queue_done(self):
+        """Queue is finished."""
+        if not self.total_counter:
+            return
+        if self.queue_done_timer is None:
+            logger.debug("queue done callback added")
+            self.queue_done_timer = Timer(
+                self.finished_delay, clock=self.clock)
+            self.queue_done_timer.addCallback(self._queue_done)
+            return
+        logger.debug("queue done callback reset")
+        self.queue_done_timer.reset()
 
     def update_progressbar(self):
         """Update the counters of the progressbar."""
         self.progress_bar.progress_made(self.done_counter, self.total_counter)
 
-    def misc_command_unqueued(self, command):
-        """A miscellaneous command was unqueued."""
-        self.done_counter += 1
-        logger.debug("unqueueing command (%d/%d): %s", self.done_counter,
-                     self.total_counter, command.__class__.__name__)
-        self.update_progressbar()
-
     def download_started(self, command):
         """A download just started."""
+        if self.queue_done_timer is not None:
+            self.queue_done_timer.reset()
         self.files_downloading.append(command)
         self.download_total += 1
+        self.total_counter += 1
         # pylint: disable=W0201
         if not self.downloading_filename:
             self.downloading_filename = self.files_downloading[0].path.split(
                 os.path.sep)[-1]
         # pylint: enable=W0201
-        self.misc_command_queued(command)
+        self.update_progressbar()
+        logger.debug("queueing command (%d/%d): %s", self.done_counter,
+                     self.total_counter, command.__class__.__name__)
         self.file_discovery_bubble.new_file_found()
 
     def download_finished(self, command):
@@ -759,18 +711,26 @@
         if command in self.files_downloading:
             self.files_downloading.remove(command)
         self.download_done += 1
-        self.misc_command_unqueued(command)
+        self.done_counter += 1
+        logger.debug("unqueueing command (%d/%d): %s", self.done_counter,
+                     self.total_counter, command.__class__.__name__)
+        self.update_progressbar()
 
     def upload_started(self, command):
         """An upload just started."""
+        if self.queue_done_timer is not None:
+            self.queue_done_timer.reset()
         self.files_uploading.append(command)
         self.upload_total += 1
+        self.total_counter += 1
         # pylint: disable=W0201
         if not self.uploading_filename:
             self.uploading_filename = self.files_uploading[0].path.split(
                 os.path.sep)[-1]
         # pylint: enable=W0201
-        self.misc_command_queued(command)
+        self.update_progressbar()
+        logger.debug("queueing command (%d/%d): %s", self.done_counter,
+                     self.total_counter, command.__class__.__name__)
         self.file_discovery_bubble.new_file_found()
 
     def upload_finished(self, command):
@@ -778,7 +738,10 @@
         if command in self.files_uploading:
             self.files_uploading.remove(command)
         self.upload_done += 1
-        self.misc_command_unqueued(command)
+        self.done_counter += 1
+        logger.debug("unqueueing command (%d/%d): %s", self.done_counter,
+                     self.total_counter, command.__class__.__name__)
+        self.update_progressbar()
 
     def connection_lost(self):
         """The connection to the server was lost."""
@@ -826,14 +789,6 @@
         """A file upload was unqueued."""
         self.aggregator.upload_finished(command)
 
-    def queue_added(self, command):
-        """A command was added to the queue."""
-        self.aggregator.misc_command_queued(command)
-
-    def queue_removed(self, command):
-        """A command was removed from the queue."""
-        self.aggregator.misc_command_unqueued(command)
-
     def queue_done(self):
         """The queue is empty."""
         self.aggregator.queue_done()
 
=== modified file 'ubuntuone/syncdaemon/status_listener.py'
--- ubuntuone/syncdaemon/status_listener.py	2011-02-09 08:23:04 +0000
+++ ubuntuone/syncdaemon/status_listener.py	2011-03-23 20:01:28 +0000
@@ -60,7 +60,7 @@
                                       set_show_all_notifications)
 
     def handle_AQ_CHANGE_PUBLIC_ACCESS_OK(self, share_id, node_id, is_public,
-                                                  public_url):
+                                          public_url):
         """The status of a published resource changed."""
         if is_public:
             self.status_frontend.file_published(public_url)
@@ -73,8 +73,6 @@
             self.status_frontend.download_started(command)
         elif isinstance(command, action_queue.Upload):
             self.status_frontend.upload_started(command)
-        else:
-            self.status_frontend.queue_added(command)
 
     def handle_SYS_QUEUE_REMOVED(self, command):
         """A command has been removed from the queue."""
@@ -82,8 +80,6 @@
             self.status_frontend.download_finished(command)
         elif isinstance(command, action_queue.Upload):
             self.status_frontend.upload_finished(command)
-        else:
-            self.status_frontend.queue_removed(command)
 
     def handle_SYS_QUEUE_DONE(self):
         """The queue has finished processing everything."""