Merge lp:~thisfred/ubuntuone-client/reset-filenames into lp:ubuntuone-client

[Eric Casteleijn]

No longer forgets connection status after completed uploads/downloads.

No longer forgets connection status after completed uploads/downloads.

[lp:~thisfred/ubuntuone-client/reset-filenames]

1053. By Eric Casteleijn on 2011-07-08

forgot to save tests

[Facundo Batista (facundo)]

I still have the problem using this branch, see attached logs in the bug.

review: Needs Fixing

[Eric Casteleijn (thisfred)]

Facundo: It's a shame this bug does not solve the bug in question, but I'd still like to land it, as it improves the code and solves similar issues. If we land this I will not mark the bug as fixed, but as you can see from the commit message, it does not promise to.

[Eric Casteleijn (thisfred)]

s/bug does not solve/branch does not solve/

[Facundo Batista (facundo)]

review: Abstain

Unmerged revisions

1053. By Eric Casteleijn on 2011-07-08

forgot to save tests

1052. By Eric Casteleijn on 2011-07-08

think I've fixed it

1051. By Eric Casteleijn on 2011-07-08

fixed reset not to set connected to False

1050. By Eric Casteleijn on 2011-07-08

fixed logging issues

1049. By Eric Casteleijn on 2011-07-08

added extensive debug logging

1048. By Eric Casteleijn on 2011-07-07

minor refactorings and cleanup

1047. By Eric Casteleijn on 2011-07-07

minor refactorings and cleanup

1046. By Eric Casteleijn on 2011-07-07

unchanged: attach bug

=== modified file 'tests/status/test_aggregator.py'
--- tests/status/test_aggregator.py	2011-07-01 19:02:13 +0000
+++ tests/status/test_aggregator.py	2011-07-08 20:38:00 +0000
@@ -257,8 +257,8 @@
         self.assertNotIn(notification,
                          self.toggleable.notification.notifications_shown)
 
-    def test_send_notification_passes_thru(self):
-        """The send_notification method passes thru."""
+    def test_send_notification_passes_through(self):
+        """The send_notification method passes through."""
         args = (1, 2, 3, 4)
         self.toggleable.send_notification(*args)
         self.assertShown(args)
@@ -339,7 +339,7 @@
         """The popup callback shows notifications."""
         self.bubble.connection_made()
         self.bubble.new_file_found()
-        self.bubble._popup()
+        self.bubble.popup()
         message = self.aggregator.build_discovery_message()
         notification = (aggregator.UBUNTUONE_TITLE, message, None, False)
         self.assertIn(notification, self.get_notifications_shown())
@@ -355,7 +355,7 @@
     def test_popup_shows_no_notification_before_connection_made(self):
         """The popup callback shows notifications."""
         self.bubble.new_file_found()
-        self.bubble._popup()
+        self.bubble.popup()
         message = self.aggregator.build_discovery_message()
         notification = (aggregator.UBUNTUONE_TITLE, message, None, False)
         self.assertNotIn(notification, self.get_notifications_shown())
@@ -365,7 +365,7 @@
         self.bubble.connection_made()
         self.bubble.connection_lost()
         self.bubble.new_file_found()
-        self.bubble._popup()
+        self.bubble.popup()
         message = self.aggregator.build_discovery_message()
         notification = (aggregator.UBUNTUONE_TITLE, message, None, False)
         self.assertNotIn(notification, self.get_notifications_shown())
@@ -374,7 +374,7 @@
         """The notification is printed in the debug log."""
         self.bubble.connection_made()
         self.bubble.new_file_found()
-        self.bubble._popup()
+        self.bubble.popup()
         msg = "notification shown: %s" % self.get_notifications_shown()[0][1]
         self.assertTrue(self.handler.check_debug(msg))
 
@@ -466,9 +466,9 @@
         """The update callback updates notifications."""
         self.bubble.connection_made()
         self.bubble.new_file_found()
-        self.bubble._popup()
+        self.bubble.popup()
         self.bubble.new_file_found()
-        self.bubble._update()
+        self.bubble.update()
         message = self.aggregator.build_discovery_message()
         notification = (aggregator.UBUNTUONE_TITLE, message, None, False)
         self.assertIn(notification, self.get_notifications_shown())
@@ -477,9 +477,9 @@
         """The notification is logged when _update is called."""
         self.bubble.connection_made()
         self.bubble.new_file_found()
-        self.bubble._popup()
+        self.bubble.popup()
         self.bubble.new_file_found()
-        self.bubble._update()
+        self.bubble.update()
         msg = "notification updated: %s" % self.get_notifications_shown()[1][1]
         self.assertTrue(self.handler.check_debug(msg))
 
@@ -494,7 +494,6 @@
         self.clock = PatchedClock()
         self.aggregator = FakeStatusAggregator(clock=self.clock)
         self.bubble = aggregator.FinalStatusBubble(self.aggregator)
-        self.addCleanup(self.bubble.cleanup)
 
     def test_notification_not_shown_initially(self):
         """The notification is not shown initially."""
@@ -1181,6 +1180,9 @@
     def connection_lost(self):
         """Connection lost."""
 
+    def set_idle(self):
+        """Reset this bubble to the initial state."""
+
 
 class FakeFinalBubble(object):
     """A fake FinalStatusBubble."""
@@ -1229,15 +1231,17 @@
         self.assertEqual(0, self.aggregator.download_done)
         self.assertEqual(0, self.aggregator.upload_done)
         self.assertEqual(0, len(self.aggregator.files_uploading))
+        self.assertEqual('', self.aggregator.uploading_filename)
         self.assertEqual(0, len(self.aggregator.files_downloading))
+        self.assertEqual('', self.aggregator.downloading_filename)
+        self.assertIdentical(None, self.aggregator.queue_done_timer)
         self.assertEqual({}, self.aggregator.progress)
         self.assertEqual({}, self.aggregator.to_do)
-        self.assertIdentical(None, self.aggregator.queue_done_timer)
 
     def assertMiscCommandQueued(self, fc):
         """Assert that some command was queued."""
         self.assertEqual(len(self.aggregator.to_do), 1)
-        message = "queueing command (total: 1): %s" % fc.__class__.__name__
+        message = "command %s started (total: 0/1)" % fc.__class__.__name__
         self.assertEqual(fc.deflated_size, sum(self.aggregator.to_do.values()))
         self.assertTrue(self.handler.check_debug(message))
         self.assertTrue(self.aggregator.progress_bar.visible)
@@ -1246,7 +1250,7 @@
         """Assert that some command was unqueued."""
         self.assertEqual(
             1, self.aggregator.download_done + self.aggregator.upload_done)
-        message = "unqueueing command: %s" % fc.__class__.__name__
+        message = "command %s done (total: 1/1)" % fc.__class__.__name__
         self.assertTrue(self.handler.check_debug(message))
 
     def test_counters_start_at_zero(self):
@@ -1565,3 +1569,69 @@
         self.assertEqual(0, len(notifications_shown))
         sf.queue_done()
         self.assertEqual(0, len(notifications_shown))
+
+    def test_queue_done_resets_filename(self):
+        """Bug LP: #807005"""
+        self.patch(aggregator, "ToggleableNotification",
+                   FakeNotificationSingleton())
+        self.patch(aggregator, "UbuntuOneLauncher", FakeLauncher)
+        self.patch(aggregator.session, "Inhibitor", FakeInhibitor)
+        clock = PatchedClock()
+        upload = FakeCommand(path='upload.foo')
+        sf = aggregator.StatusFrontend(clock=clock)
+        sf.server_connection_made()
+        sf.set_show_all_notifications(True)
+        sf.upload_started(upload)
+        notifications_shown = (
+            sf.aggregator.file_discovery_bubble.
+            notification.notifications_shown)
+        # no notifications shown yet
+        self.assertEqual(0, len(notifications_shown))
+        clock.advance(aggregator.FileDiscoveryGatheringState.initial_timeout)
+        # files found notification
+        self.assertEqual(1, len(notifications_shown))
+        sf.upload_finished(upload)
+        sf.queue_done()
+        clock.advance(sf.aggregator.finished_delay * 2)
+        self.assertEqual(2, len(notifications_shown))
+        final_text = notifications_shown[-1][1]
+        upload2 = FakeCommand(path='upload.bar')
+        sf.upload_started(upload2)
+        # no notifications shown yet
+        self.assertEqual(2, len(notifications_shown))
+        clock.advance(aggregator.FileDiscoveryGatheringState.initial_timeout)
+        # files found notification
+        self.assertEqual(3, len(notifications_shown))
+        sf.upload_finished(upload2)
+        sf.queue_done()
+        clock.advance(sf.aggregator.finished_delay * 2)
+        self.assertEqual(4, len(notifications_shown))
+        self.assertNotEqual(final_text, notifications_shown[-1][1])
+
+    def test_queue_done_resets_filename2(self):
+        """Bug LP: #807005"""
+        self.patch(aggregator, "ToggleableNotification",
+                   FakeNotificationSingleton())
+        self.patch(aggregator, "UbuntuOneLauncher", FakeLauncher)
+        self.patch(aggregator.session, "Inhibitor", FakeInhibitor)
+        clock = PatchedClock()
+        upload = FakeCommand(path='upload.foo')
+        sf = aggregator.StatusFrontend(clock=clock)
+        sf.server_connection_made()
+        sf.set_show_all_notifications(True)
+        sf.upload_started(upload)
+        sf.upload_started(upload)
+        sf.upload_started(upload)
+        notifications_shown = (
+            sf.aggregator.file_discovery_bubble.
+            notification.notifications_shown)
+        # no notifications shown yet
+        self.assertEqual(0, len(notifications_shown))
+        clock.advance(
+            aggregator.FileDiscoveryGatheringState.initial_timeout)
+        # files found notification
+        self.assertEqual(1, len(notifications_shown))
+        sf.upload_finished(upload)
+        sf.queue_done()
+        clock.advance(sf.aggregator.finished_delay * 2)
+        self.assertEqual(2, len(notifications_shown))

=== modified file 'ubuntuone/eventlog/zg_listener.py'
--- ubuntuone/eventlog/zg_listener.py	2011-03-22 20:01:59 +0000
+++ ubuntuone/eventlog/zg_listener.py	2011-07-08 20:38:00 +0000
@@ -59,7 +59,7 @@
         self.newly_created_local_files = set()
 
     def handle_AQ_CREATE_SHARE_OK(self, share_id, marker):
-        """Log the 'directory shared thru the server' event."""
+        """Log the 'directory shared through the server' event."""
         share_id = str(share_id)
         share = self.vm.shared.get(share_id)
         if not share:
@@ -68,7 +68,7 @@
         self.log_folder_shared(share, share_id)
 
     def handle_AQ_SHARE_INVITATION_SENT(self, marker):
-        """Log the 'directory shared thru http' event."""
+        """Log the 'directory shared through http' event."""
         share = self.vm.marker_share_map[marker]
         mdo = self.fsm.get_by_mdid(marker)
         self.log_folder_shared(share, mdo.share_id)

=== modified file 'ubuntuone/platform/linux/session.py'
--- ubuntuone/platform/linux/session.py	2011-02-22 23:57:51 +0000
+++ ubuntuone/platform/linux/session.py	2011-07-08 20:38:00 +0000
@@ -15,7 +15,7 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Inhibit session logout when busy thru the Gnome Session DBus service."""
+"""Inhibit session logout when busy through the Gnome Session DBus service."""
 
 import dbus
 

=== modified file 'ubuntuone/status/aggregator.py'
--- ubuntuone/status/aggregator.py	2011-07-07 13:10:02 +0000
+++ ubuntuone/status/aggregator.py	2011-07-08 20:38:00 +0000
@@ -51,6 +51,7 @@
     """Set the launcher to urgent to alert the user."""
     launcher = UbuntuOneLauncher()
     launcher.set_urgent()
+    logger.debug("Launcher set to urgent.")
 
 
 def files_being_uploaded(filename, files_uploading):
@@ -130,9 +131,14 @@
         self.notification = Notification()
 
     def send_notification(self, *args):
-        """Passthru the notification."""
+        """Pass through the notification."""
         if self.notification_switch.enabled:
+            logger.debug(
+                "Displayed notification with arguments %r.", args)
             return self.notification.send_notification(*args)
+        logger.debug(
+            "Asked to display notification with arguments %r, but "
+            "notifications switched off.", args)
 
 
 class NotificationSwitch(object):
@@ -150,10 +156,12 @@
     def enable_notifications(self):
         """Turn the switch on."""
         self.enabled = True
+        logger.debug("Notifications enabled.")
 
     def disable_notifications(self):
         """Turn the switch off."""
         self.enabled = False
+        logger.debug("Notifications disabled.")
 
 
 class StatusEvent(object):
@@ -187,7 +195,7 @@
     def many(self, events):
         """Show the number of files if many event of this type."""
         no_of_files = len(events)
-        gettext.dngettext(
+        return gettext.dngettext(
             GETTEXT_PACKAGE,
             "%(event_count)d file was just made public.",
             "%(event_count)d files were just made public.",
@@ -203,7 +211,7 @@
     def many(self, events):
         """Show the number of files if many event of this type."""
         no_of_files = len(events)
-        gettext.dngettext(
+        return gettext.dngettext(
             GETTEXT_PACKAGE,
             "%(event_count)d file is no longer published.",
             "%(event_count)d files are no longer published.",
@@ -218,7 +226,7 @@
     def many(self, events):
         """Show the number of files if many event of this type."""
         no_of_files = len(events)
-        gettext.dngettext(
+        return gettext.dngettext(
             GETTEXT_PACKAGE,
             "Found %(event_count)d new cloud folder.",
             "Found %(event_count)d new cloud folders.",
@@ -288,21 +296,30 @@
     def cancel_if_active(self, call):
         """Cancel a call if it is active."""
         if call.active():
+            logger.debug('callback %r cancelled.', call.func)
             call.cancel()
 
     def cleanup(self):
         """Cancel all active calls."""
         self.cancel_if_active(self.delay_call)
+        logger.debug('%r cleaned up.', self)
 
     def callback(self, result=None):
         """Make sure the timers are stopped when firing the callback."""
         self.cleanup()
         defer.Deferred.callback(self, result)
 
+    def errback(self, failure=None):
+        """Log the failure."""
+        logger.error('Failure in %s %r: %r', self.__class__, self, failure)
+        defer.Deferred.errback(self, failure)
+
     def reset(self):
         """Reset the delay."""
         if not self.called:
             self.delay_call.reset(self.delay)
+            logger.debug(
+                '%s %r delay reset to %.2f.', self.__class__, self, self.delay)
 
     @property
     def active(self):
@@ -345,7 +362,7 @@
 
     def new_file_found(self):
         """New files found."""
-        self.bubble._start()
+        self.bubble.start()
 
 
 class FileDiscoveryGatheringState(FileDiscoveryBaseState):
@@ -365,7 +382,7 @@
     def _timeout(self, result):
         """Show the notification bubble."""
         self.cleanup()
-        self.bubble._popup()
+        self.bubble.popup()
 
     def new_file_found(self):
         """New files found."""
@@ -396,7 +413,7 @@
 
     def _update(self, result):
         """The bubble should be updated."""
-        self.bubble._update()
+        self.bubble.update()
 
     def new_file_found(self):
         """New files found."""
@@ -424,7 +441,7 @@
 
     def _timeout(self, result):
         """Move the notification to the idle state."""
-        self.bubble._set_idle()
+        self.bubble.set_idle()
 
     def cleanup(self):
         """Clean up the timers."""
@@ -449,25 +466,29 @@
         self.files_found = False
         self.clock = clock
         self.status_aggregator = status_aggregator
-        self._set_idle()
+        self.set_idle()
         self.notification = None
 
     def _change_state(self, new_state_class):
         """Change to a new state."""
         if self.state:
             self.state.cleanup()
+        old_state = self.state.__class__
         self.state = new_state_class(self)
+        logger.debug(
+            "FileDiscoveryBubble state changed from %s to %s",
+            old_state, new_state_class)
 
-    def _set_idle(self):
+    def set_idle(self):
         """Reset this bubble to the initial state."""
         self._change_state(FileDiscoveryIdleState)
 
-    def _start(self):
+    def start(self):
         """The first file was found, so start gathering."""
         self.notification = self.status_aggregator.get_notification()
         self._change_state(FileDiscoveryGatheringState)
 
-    def _popup(self):
+    def popup(self):
         """Display the notification."""
         if not self.connected:
             return
@@ -477,7 +498,7 @@
             logger.debug("notification shown: %s", text)
         self._change_state(FileDiscoveryUpdateState)
 
-    def _update(self):
+    def update(self):
         """Update the notification."""
         if not self.connected:
             return
@@ -498,7 +519,7 @@
         """Connection made."""
         self.connected = True
         if self.files_found:
-            self._popup()
+            self.popup()
 
     def connection_lost(self):
         """Connection lost."""
@@ -512,6 +533,7 @@
 
 class ProgressBar(object):
     """Update a progressbar no more than 10 times a second."""
+
     pulsating = True
     visible = False
     progress = 0.0
@@ -534,11 +556,11 @@
             self.timer.cleanup()
             self.timer = None
 
-    def _timeout(self, result):
+    def _timeout(self, _):
         """The aggregating timer has expired, so update the UI."""
         self.timer = None
         self.launcher.set_progress(self.progress)
-        logger.debug("progressbar updated: %f", self.progress)
+        logger.debug("progressbar set to: %.2f", self.progress)
 
     def set_progress(self, progress):
         """Steps amount changed. Set up a timer if there isn't one ticking."""
@@ -579,9 +601,6 @@
         """Initialize this instance."""
         self.status_aggregator = status_aggregator
 
-    def cleanup(self):
-        """Clean up this instance."""
-
     def show(self):
         """Show the final status notification."""
         self.notification = self.status_aggregator.get_notification()
@@ -601,17 +620,15 @@
 
     file_discovery_bubble = None
     final_status_bubble = None
+    queue_done_timer = None
+    finished_delay = 10
 
     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
-        self.progress = {}
-        self.to_do = {}
+        self.reset()
 
     def get_notification(self):
         """Create a new toggleable notification object."""
@@ -629,17 +646,17 @@
         if self.queue_done_timer is not None:
             self.queue_done_timer.cleanup()
             self.queue_done_timer = None
-
         if self.file_discovery_bubble:
             self.file_discovery_bubble.cleanup()
-        self.file_discovery_bubble = FileDiscoveryBubble(self,
-                                                         clock=self.clock)
-
-        if self.final_status_bubble:
-            self.final_status_bubble.cleanup()
+            self.file_discovery_bubble.set_idle()
+        else:
+            self.file_discovery_bubble = FileDiscoveryBubble(
+                self, clock=self.clock)
         self.final_status_bubble = FinalStatusBubble(self)
         self.progress = {}
         self.to_do = {}
+        logger.debug("All status aggregation information reset.")
+
     # pylint: enable=W0201
 
     def get_discovery_message(self):
@@ -674,9 +691,9 @@
 
     def _queue_done(self, _):
         """Show final bubble and reset counters."""
+        logger.debug("queue done callback fired")
         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()
@@ -685,15 +702,16 @@
     def queue_done(self):
         """Queue is finished."""
         if not self.to_do:
+            logger.debug("queue done but no events to process.")
             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)
+            logger.debug("queue done callback added")
             return
+        self.queue_done_timer.reset()
         logger.debug("queue done callback reset")
-        self.queue_done_timer.reset()
 
     def update_progressbar(self):
         """Update the counters of the progressbar."""
@@ -701,6 +719,9 @@
             progress = float(
                 sum(self.progress.values())) / sum(self.to_do.values())
             self.progress_bar.set_progress(progress)
+            return
+        logger.debug(
+            "Update progress bar called while we have zero todo items.")
 
     def download_started(self, command):
         """A download just started."""
@@ -711,15 +732,21 @@
         if command.deflated_size is not None:
             self.to_do[
                 (command.share_id, command.node_id)] = command.deflated_size
+            logger.debug(
+                'to_do[(%s, %s)] set to %i', command.share_id,
+                command.node_id, command.deflated_size)
         # pylint: disable=W0201
         if not self.downloading_filename:
             self.downloading_filename = self.files_downloading[0].path.split(
                 os.path.sep)[-1]
+            logger.debug(
+                'downloading_filename set to %s' % self.downloading_filename)
         # pylint: enable=W0201
         self.update_progressbar()
         logger.debug(
-            "queueing command (total: %d): %s",
-            len(self.to_do), command.__class__.__name__)
+            "command %s started (total: %d/%d)",
+            command.__class__.__name__, self.download_done + self.upload_done,
+            len(self.to_do))
         self.file_discovery_bubble.new_file_found()
 
     def download_finished(self, command):
@@ -730,7 +757,10 @@
         if command.deflated_size is not None:
             self.progress[
                 (command.share_id, command.node_id)] = command.deflated_size
-        logger.debug("unqueueing command: %s", command.__class__.__name__)
+        logger.debug(
+            "command %s done (total: %d/%d)",
+            command.__class__.__name__, self.download_done + self.upload_done,
+            len(self.to_do))
         self.update_progressbar()
 
     def upload_started(self, command):
@@ -742,15 +772,21 @@
         if command.deflated_size is not None:
             self.to_do[
                 (command.share_id, command.node_id)] = command.deflated_size
+            logger.debug(
+                'to_do[(%s, %s)] set to %i', command.share_id,
+                command.node_id, command.deflated_size)
         # pylint: disable=W0201
         if not self.uploading_filename:
             self.uploading_filename = self.files_uploading[0].path.split(
                 os.path.sep)[-1]
+            logger.debug(
+                'uploading_filename set to %s' % self.uploading_filename)
         # pylint: enable=W0201
         self.update_progressbar()
         logger.debug(
-            "queueing command (total: %d): %s", len(self.to_do),
-            command.__class__.__name__)
+            "command %s started (total: %d/%d)",
+            command.__class__.__name__, self.download_done + self.upload_done,
+            len(self.to_do))
         self.file_discovery_bubble.new_file_found()
 
     def upload_finished(self, command):
@@ -761,7 +797,10 @@
         if command.deflated_size is not None:
             self.progress[
                 (command.share_id, command.node_id)] = command.deflated_size
-        logger.debug("unqueueing command: %s", command.__class__.__name__)
+        logger.debug(
+            "command %s done (total: %d/%d)",
+            command.__class__.__name__, self.download_done + self.upload_done,
+            len(self.to_do))
         self.update_progressbar()
 
     def progress_made(self, share_id, node_id, n_bytes_written, deflated_size):
@@ -794,48 +833,61 @@
 
     def file_published(self, public_url):
         """A file was published."""
+        logger.debug('file published event received. url: %s', public_url)
         status_event = FilePublishingStatus(new_public_url=public_url)
         self.notification.send_notification(
             UBUNTUONE_TITLE, status_event.one())
 
     def file_unpublished(self, public_url):  # pylint: disable=W0613
         """A file was unpublished."""
+        logger.debug('file unpublished event received. url: %s', public_url)
         self.notification.send_notification(
             UBUNTUONE_TITLE, FileUnpublishingStatus().one())
 
     def download_started(self, command):
         """A file was queued for download."""
+        logger.debug('download started event received. command: %r', command)
         self.aggregator.download_started(command)
 
     def download_finished(self, command):
         """A file download was unqueued."""
+        logger.debug('download finished event received. command: %r', command)
         self.aggregator.download_finished(command)
 
     def upload_started(self, command):
         """A file was queued for upload."""
+        logger.debug('upload started event received. command: %r', command)
         self.aggregator.upload_started(command)
 
     def upload_finished(self, command):
         """A file upload was unqueued."""
+        logger.debug('upload finished event received. command: %r', command)
         self.aggregator.upload_finished(command)
 
     def progress_made(self, share_id, node_id, n_bytes_written, deflated_size):
         """Progress made on up- or download."""
+        logger.debug(
+            'progress made event received. share_id %s, node_id %s, '
+            'n_bytes_written %i, deflated_size %i',
+            share_id, node_id, n_bytes_written, deflated_size)
         self.aggregator.progress_made(
             share_id, node_id, n_bytes_written, deflated_size)
 
     def queue_done(self):
         """The queue is empty."""
+        logger.debug('queue done event received.')
         self.aggregator.queue_done()
 
     def new_share_available(self, share):
         """A new share is available for subscription."""
+        logger.debug('new share available event received. share: %r', share)
         self.messaging.show_message(share.other_visible_name)
         self.notification.send_notification(
             UBUNTUONE_TITLE, ShareAvailableStatus(share=share).one())
 
     def new_udf_available(self, udf):
         """A new udf is available for subscription."""
+        logger.debug('new udf available event received. udf: %r', udf)
         if udf.subscribed:
             return
         self.notification.send_notification(
@@ -843,22 +895,24 @@
 
     def server_connection_lost(self):
         """The client lost the connection to the server."""
-        logger.debug("server connection lost")
+        logger.debug("server connection lost event received.")
         self.aggregator.connection_lost()
 
     def server_connection_made(self):
         """The client made the connection to the server."""
-        logger.debug("server connection made")
+        logger.debug("server connection made event received.")
         self.aggregator.connection_made()
 
     def udf_quota_exceeded(self, volume_dict):
         """Quota exceeded in UDF."""
-        logger.debug("UDF quota exceeded for volume %r." % volume_dict)
+        logger.debug(
+            "UDF quota exceeded event received. volume: %r.", volume_dict)
         alert_user()
 
     def share_quota_exceeded(self, volume_dict):
         """Sharing user's quota exceeded in share."""
-        logger.debug("Share quota exceeded for volume %r." % volume_dict)
+        logger.debug(
+            "Share quota exceeded event received. volume: %r.", volume_dict)
         if self.quota_timer is not None:
             if self.quota_timer.active:
                 return
@@ -871,7 +925,8 @@
 
     def root_quota_exceeded(self, volume_dict):
         """Quota exceeded in root."""
-        logger.debug("Root quota exceeded for volume %r." % volume_dict)
+        logger.debug(
+            "Root quota exceeded event received. volume: %r.", volume_dict)
         alert_user()
 
     def set_show_all_notifications(self, value):