Merge lp:~nataliabidart/ubuntuone-client/stable-3-0-update-2.99.92 into lp:ubuntuone-client/stable-3-0

[Natalia Bidart]

- Updating from trunk up to revno 1222:

[ Alejandro J. Cura <email address hidden> ]
  - Do not use the Qt Dbus mainloop on Windows (LP: #969150).
  - Force using the system proxy on Windows (LP: #969157).

[ Diego Sarmentero <email address hidden> ]
  - Converting abspath to unicode (LP: #917222).

[ Natalia B. Bidart <email address hidden> ]
  - Fixed typo and added a missing test for validate_path in
    SyncDaemonTool (LP: #968637).

[ Natalia B. Bidart <email address hidden>,
  Brian Curtin <email address hidden> ]
  - Emit a notification when volumes are ready after a server rescan,
    allowing clients to follow and update their information accordingly
    (LP: #851810).

[ Rodney Dawes <email address hidden> ]
  - Use set_hint_int32 for the boolean transient hint instead of set_hint
    (LP: #961342).

[Alejandro J. Cura (alecu)]

+1

review: Approve

=== modified file 'bin/u1sdtool'
--- bin/u1sdtool	2012-03-13 16:56:05 +0000
+++ bin/u1sdtool	2012-04-03 13:00:34 +0000
@@ -155,7 +155,13 @@
         d.addCallback(lambda info: show_public_file_info(info, out))
         d.addErrback(lambda failure: show_error(failure, out))
     elif options.path_info:
-        path = os.path.abspath(options.path_info)
+        try:
+            path = options.path_info.decode(sys.getfilesystemencoding())
+        except (UnicodeDecodeError, UnicodeEncodeError):
+            parser.error('PATH %r could not be decoded using the filesystem '
+                         'encoding %r.' % (
+                             options.path_info, sys.getfilesystemencoding()))
+        path = os.path.abspath(path)
         if not os.path.exists(path):
             parser.error("PATH: '%s' don't exists" % path)
         d = sync_daemon_tool.get_metadata(path)
 
=== modified file 'tests/platform/linux/test_notification.py'
--- tests/platform/linux/test_notification.py	2012-03-09 19:27:03 +0000
+++ tests/platform/linux/test_notification.py	2012-04-03 13:00:34 +0000
@@ -73,7 +73,7 @@
         self._set_up_mock_notify(FAKE_TITLE, FAKE_MESSAGE, ICON_NAME)
         mock_notification = self.mocker.mock()
         self.mocker.result(mock_notification)
-        mock_notification.set_hint('transient', True)
+        mock_notification.set_hint_int32('transient', int(True))
         mock_notification.show()
         self.mocker.replay()
         Notification(FAKE_APP_NAME).send_notification(FAKE_TITLE, FAKE_MESSAGE)
@@ -83,11 +83,11 @@
         self._set_up_mock_notify(FAKE_TITLE, FAKE_MESSAGE, ICON_NAME)
         mock_notification = self.mocker.mock()
         self.mocker.result(mock_notification)
-        mock_notification.set_hint('transient', True)
+        mock_notification.set_hint_int32('transient', int(True))
         mock_notification.show()
         mock_notification.update(
             FAKE_TITLE + '2', FAKE_MESSAGE + '2', ICON_NAME)
-        mock_notification.set_hint('transient', True)
+        mock_notification.set_hint_int32('transient', int(True))
         mock_notification.show()
         self.mocker.replay()
         notifier = Notification(FAKE_APP_NAME)
@@ -99,7 +99,7 @@
         self._set_up_mock_notify(FAKE_TITLE, FAKE_MESSAGE, FAKE_ICON)
         mock_notification = self.mocker.mock()
         self.mocker.result(mock_notification)
-        mock_notification.set_hint('transient', True)
+        mock_notification.set_hint_int32('transient', int(True))
         mock_notification.show()
         self.mocker.replay()
         Notification(FAKE_APP_NAME).send_notification(
@@ -111,11 +111,11 @@
         mock_notification = self.mocker.mock()
         self.mocker.result(mock_notification)
         mock_notification.set_hint_string('x-canonical-append', '')
-        mock_notification.set_hint('transient', True)
+        mock_notification.set_hint_int32('transient', int(True))
         mock_notification.show()
         mock_notification.update(FAKE_TITLE, FAKE_APPENDAGE, ICON_NAME)
         mock_notification.set_hint_string('x-canonical-append', '')
-        mock_notification.set_hint('transient', True)
+        mock_notification.set_hint_int32('transient', int(True))
         mock_notification.show()
         self.mocker.replay()
         notifier = Notification(FAKE_APP_NAME)
 
=== modified file 'tests/platform/test_external_interface.py'
--- tests/platform/test_external_interface.py	2012-02-03 14:29:52 +0000
+++ tests/platform/test_external_interface.py	2012-04-03 13:00:34 +0000
@@ -31,6 +31,7 @@
 
 STR = 'something'
 STR_STR_DICT = {'foo': 'bar'}
+STR_LST_DICT = [STR_STR_DICT]
 
 
 class StatusTests(StatusTestCase):
@@ -146,6 +147,7 @@
     signal_mapping = [
         ('RootMismatch', (STR, STR)),
         ('QuotaExceeded', (STR_STR_DICT,)),
+        ('VolumesChanged', (STR_LST_DICT,)),
     ]
 
     @defer.inlineCallbacks
 
=== modified file 'tests/platform/test_tools.py'
--- tests/platform/test_tools.py	2012-01-17 20:00:44 +0000
+++ tests/platform/test_tools.py	2012-04-03 13:00:34 +0000
@@ -624,6 +624,12 @@
                          "UDF %s is subscribed" % udf.id)
 
     @defer.inlineCallbacks
+    def test_validate_path(self):
+        """Test for Folders.validate_path."""
+        result = yield self.tool.validate_path(self.root_dir)
+        self.assertFalse(result)
+
+    @defer.inlineCallbacks
     def test_subscribe_share(self):
         """Test for Shares.subscribe."""
         share = self._create_share(accepted=True, subscribed=False)
@@ -898,11 +904,29 @@
     @defer.inlineCallbacks
     def test_refresh_volumes(self):
         """Test for refresh_volumes method."""
-        d = defer.Deferred()
-        self.patch(self.main.action_q, 'list_volumes',
-                   lambda: d.callback(True))
-        yield self.tool.refresh_volumes()
-        yield d
+        udf = self._create_udf()
+        yield self.main.vm.add_udf(udf)
+
+        share = self._create_share()
+        yield self.main.vm.add_share(share)
+
+        volumes = list(self.main.vm.get_volumes(all_volumes=True))
+
+        def volumes_changed():
+            """Fake volumes_changed."""
+            self.main.event_q.push('VM_VOLUMES_CHANGED', volumes=volumes)
+
+        self.patch(self.main.vm, 'refresh_volumes', volumes_changed)
+        result = yield self.tool.refresh_volumes()
+
+        str_volumes = []
+        for volume in volumes:
+            if isinstance(volume, volume_manager.UDF):
+                str_vol = interaction_interfaces.get_udf_dict(volume)
+            else:
+                str_vol = interaction_interfaces.get_share_dict(volume)
+            str_volumes.append(str_vol)
+        self.assertEqual(result, str_volumes)
 
     @defer.inlineCallbacks
     def test_rescan_from_scratch(self):
 
=== modified file 'tests/proxy/test_tunnel_server.py'
--- tests/proxy/test_tunnel_server.py	2012-03-24 00:10:25 +0000
+++ tests/proxy/test_tunnel_server.py	2012-04-03 13:00:34 +0000
@@ -549,6 +549,7 @@
 class FakeNetworkProxyFactoryClass(object):
     """A fake QNetworkProxyFactory."""
     last_query = None
+    use_system = False
 
     def __init__(self, enabled):
         """Initialize this fake instance."""
@@ -561,6 +562,16 @@
         """Return the proxy type configured."""
         return self.proxy_type
 
+    @classmethod
+    def setUseSystemConfiguration(cls, new_value):
+        """Save the system configuration requested."""
+        cls.use_system = new_value
+
+    @classmethod
+    def useSystemConfiguration(cls):
+        """Is the system configured for proxies?"""
+        return cls.use_system
+
     def systemProxyForQuery(self, query):
         """A list of proxies, but only type() will be called on the first."""
         return [self]
@@ -610,6 +621,7 @@
         self.patch(tunnel_server, "QNetworkProxyFactory", fake_netproxfact)
         self._assert_proxy_enabled("windows 1.0")
         self.assertEqual(len(self.app_proxy), 0)
+        self.assertTrue(fake_netproxfact.useSystemConfiguration())
 
     def test_platform_other_disabled(self):
         """Tests for any other platform with proxies disabled."""
@@ -617,6 +629,7 @@
         self.patch(tunnel_server, "QNetworkProxyFactory", fake_netproxfact)
         self._assert_proxy_disabled("windows 1.0")
         self.assertEqual(len(self.app_proxy), 0)
+        self.assertTrue(fake_netproxfact.useSystemConfiguration())
 
 
 class FakeQCoreApp(object):
@@ -683,3 +696,23 @@
         tunnel_server.main(["example.com", "443"])
         self.assertIn("Proxy not enabled.", self.fake_stdout.getvalue())
         self.assertEqual(FakeQCoreApp.fake_instance, None)
+
+    def test_qtdbus_installed_on_linux(self):
+        """The QtDbus mainloop is installed."""
+        self.patch(tunnel_server.sys, "platform", "linux123")
+        installed = []
+        self.patch(tunnel_server, "install_qt_dbus",
+                  lambda: installed.append(None))
+        self.proxies_enabled = True
+        tunnel_server.main(["example.com", "443"])
+        self.assertEqual(len(installed), 1)
+
+    def test_qtdbus_not_installed_on_windows(self):
+        """The QtDbus mainloop is installed."""
+        self.patch(tunnel_server.sys, "platform", "win98")
+        installed = []
+        self.patch(tunnel_server, "install_qt_dbus",
+                  lambda: installed.append(None))
+        self.proxies_enabled = True
+        tunnel_server.main(["example.com", "443"])
+        self.assertEqual(len(installed), 0)
 
=== modified file 'tests/syncdaemon/test_interaction_interfaces.py'
--- tests/syncdaemon/test_interaction_interfaces.py	2012-03-01 19:08:12 +0000
+++ tests/syncdaemon/test_interaction_interfaces.py	2012-04-03 13:00:34 +0000
@@ -1750,6 +1750,24 @@
         self.assertEqual(error, error_msg)
 
     @defer.inlineCallbacks
+    def test_handle_VM_VOLUMES_CHANGED(self):
+        """Test the handle_VM_VOLUMES_CHANGED method."""
+        share = self._create_share(accepted=True)
+        udf = self._create_udf()
+        volumes = [share, udf, self.main.vm.root]
+        d = defer.Deferred()
+        self.patch(self.sd_obj.interface.sync_daemon, 'VolumesChanged',
+                   d.callback)
+
+        self.main.event_q.push('VM_VOLUMES_CHANGED', volumes=volumes)
+
+        info = yield d
+
+        str_volumes = sorted((get_share_dict(share), get_udf_dict(udf),
+                              get_share_dict(self.main.vm.root)))
+        self.assertEqual(str_volumes, sorted(info))
+
+    @defer.inlineCallbacks
     def test_handle_VM_VOLUME_DELETED_folder(self):
         """Test the handle_VM_VOLUME_DELETED method for a folder."""
         udf = self._create_udf()
 
=== modified file 'tests/syncdaemon/test_tunnel_runner.py'
--- tests/syncdaemon/test_tunnel_runner.py	2012-03-27 03:41:06 +0000
+++ tests/syncdaemon/test_tunnel_runner.py	2012-04-03 13:00:34 +0000
@@ -179,3 +179,12 @@
         self.addCleanup(delattr, sys, "frozen")
         self.assertEqual(os.path.dirname(self.tr.get_process_path()),
             os.path.dirname(sys.executable))
+
+    def test_start_process_win_devel(self):
+        """Test the windows devel case."""
+        fake_python = r"c:\python99\python.exe"
+        self.patch(sys, "platform", "win98")
+        self.patch(tunnel_runner.procutils, "which", lambda _: [fake_python])
+        tunnel_runner.TunnelRunner("fs-1.one.ubuntu.com", 443)
+        args, kwargs = self.spawned[1]
+        self.assertEqual(args[1], fake_python)
 
=== modified file 'tests/syncdaemon/test_vm.py'
--- tests/syncdaemon/test_vm.py	2012-02-09 23:32:10 +0000
+++ tests/syncdaemon/test_vm.py	2012-04-03 13:00:34 +0000
@@ -1893,6 +1893,27 @@
         """Test handle_AQ_LIST_VOLUMES event with an inactive udf."""
         yield self._test_handle_AQ_LIST_VOLUMES_udf(False)
 
+    @defer.inlineCallbacks
+    def test_handle_AQ_LIST_VOLUMES_emits_volumes_changed(self):
+        """When handling a new volume list, VM_VOLUMES_CHANGED is pushed."""
+        share = self._create_share_volume()
+        udf = self._create_udf_volume()
+        root_volume = volumes.RootVolume(uuid.uuid4(), 17, 10)
+        response = [share, udf, root_volume]
+
+        udf_created_d = defer.Deferred()
+        self._listen_for('VM_UDF_CREATED', udf_created_d.callback)
+
+        volumes_changed_d = defer.Deferred()
+        self._listen_for('VM_VOLUMES_CHANGED', volumes_changed_d.callback)
+
+        self.vm.handle_AQ_LIST_VOLUMES(response)
+
+        yield udf_created_d
+        actual = yield volumes_changed_d
+        expected = {'volumes': list(self.vm.get_volumes(all_volumes=True))}
+        self.assertEqual(expected, actual)
+
 
 class VolumeManagerOperationsTests(BaseVolumeManagerTests):
     """Test UDF/Volumes operations."""
@@ -3104,12 +3125,18 @@
                          vol_rescan_d.callback)  # autosubscribe is False
         server_rescan_d = defer.Deferred()
         self._listen_for('SYS_SERVER_RESCAN_DONE', server_rescan_d.callback)
+        volumes_changed_d = defer.Deferred()
+        self._listen_for('VM_VOLUMES_CHANGED', volumes_changed_d.callback)
         yield self.vm.server_rescan()
         yield server_rescan_d
         events = yield vol_rescan_d
+        vols = yield volumes_changed_d
 
         self.assertEqual({'generation': 1, 'volume_id': ''}, events)
 
+        expected = list(self.vm.get_volumes(all_volumes=True))
+        self.assertEqual({'volumes' : expected}, vols)
+
     @defer.inlineCallbacks
     def test_server_rescan_with_share_autosubscribe(self):
         """Test the server_rescan method."""
 
=== modified file 'ubuntuone/platform/linux/dbus_interface.py'
--- ubuntuone/platform/linux/dbus_interface.py	2012-02-18 16:13:04 +0000
+++ ubuntuone/platform/linux/dbus_interface.py	2012-04-03 13:00:34 +0000
@@ -326,6 +326,10 @@
     def QuotaExceeded(self, volume_dict):
         """QuotaExceeded signal, the user ran out of space."""
 
+    @dbus.service.signal(DBUS_IFACE_SYNC_NAME, signature='aa{ss}')
+    def VolumesChanged(self, volumes):
+        """Volumes list changed."""
+
 
 class FileSystem(DBusExposedObject):
     """An interface to the FileSystem Manager."""
 
=== modified file 'ubuntuone/platform/linux/notification.py'
--- ubuntuone/platform/linux/notification.py	2012-03-09 19:27:03 +0000
+++ ubuntuone/platform/linux/notification.py	2012-04-03 13:00:34 +0000
@@ -72,5 +72,5 @@
         if append:
             self.notification.set_hint_string('x-canonical-append', '')
 
-        self.notification.set_hint('transient', True)
+        self.notification.set_hint_int32('transient', int(True))
         self.notification.show()
 
=== modified file 'ubuntuone/platform/tools/__init__.py'
--- ubuntuone/platform/tools/__init__.py	2012-02-03 14:29:52 +0000
+++ ubuntuone/platform/tools/__init__.py	2012-04-03 13:00:34 +0000
@@ -1,9 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Authors: Guillermo Gonzalez <[e-mail]>
-#          Natalia B. Bidart <[e-mail]>
-#
-# Copyright 2009-2011 Canonical Ltd.
+# Copyright 2009-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
@@ -64,7 +61,7 @@
         """Converts a dict returned by the IPC client to a dict of strings."""
         str_dict = {}
         for key in a_dict:
-            str_dict[key] = unicode(a_dict[key])
+            str_dict[unicode(key)] = unicode(a_dict[key])
         return str_dict
 
     def shutdown(self):
@@ -443,7 +440,7 @@
     @log_call(logger.debug)
     def validate_path(self, path):
         """Return True if the path is valid for a folder."""
-        result = yield self.proxy.call_method('folders', 'validate', path)
+        result = yield self.proxy.call_method('folders', 'validate_path', path)
         self.log.debug('valid: %r', result)
         defer.returnValue(result)
 
@@ -642,10 +639,17 @@
         """Enable/disable udf_autosubscribe."""
         return self.enable_setting('udf_autosubscribe', enabled)
 
+    @defer.inlineCallbacks
     @log_call(logger.debug)
     def refresh_volumes(self):
         """Request the volumes list to the server."""
-        return self.proxy.call_method('folders', 'refresh_volumes')
+        d = self.wait_for_signals('VolumesChanged')
+        self.proxy.call_method('folders', 'refresh_volumes')
+
+        (results,) = yield d
+
+        volumes_info = [self._get_dict(r) for r in results]
+        defer.returnValue(volumes_info)
 
     @log_call(logger.debug)
     def rescan_from_scratch(self, volume_id):
 
=== modified file 'ubuntuone/platform/tools/windows.py'
--- ubuntuone/platform/tools/windows.py	2011-11-30 14:53:56 +0000
+++ ubuntuone/platform/tools/windows.py	2012-04-03 13:00:34 +0000
@@ -88,6 +88,7 @@
         'ShareUnSubscribed': ('shares', 'on_share_unsubscribed_cb'),
         'ShareUnSubscribeError': ('shares', 'on_share_unsubscribe_error_cb'),
         'StatusChanged': ('status', 'on_status_changed_cb'),
+        'VolumesChanged': ('sync_daemon', 'on_volumes_changed_cb'),
     }
 
     # All methods and instance variables that should not be handled by
 
=== modified file 'ubuntuone/platform/windows/ipc.py'
--- ubuntuone/platform/windows/ipc.py	2012-02-18 16:13:04 +0000
+++ ubuntuone/platform/windows/ipc.py	2012-04-03 13:00:34 +0000
@@ -382,6 +382,7 @@
     signal_mapping = {
         'RootMismatch': 'on_root_mismatch',
         'QuotaExceeded': 'on_quota_exceeded',
+        'VolumesChanged': 'on_volumes_changed',
     }
 
     def connect(self):
@@ -439,6 +440,10 @@
     def QuotaExceeded(self, volume_dict):
         """QuotaExceeded signal, the user ran out of space."""
 
+    @signal
+    def VolumesChanged(self, volumes):
+        """Volumes list has changed."""
+
 
 class FileSystem(IPCExposedObject):
     """An interface to the FileSystem Manager."""
 
=== modified file 'ubuntuone/platform/windows/ipc_client.py'
--- ubuntuone/platform/windows/ipc_client.py	2012-02-03 14:29:52 +0000
+++ ubuntuone/platform/windows/ipc_client.py	2012-04-03 13:00:34 +0000
@@ -253,7 +253,11 @@
     __metaclass__ = RemoteMeta
 
     # calls that will be accessible remotely
-    signal_handlers = ['on_root_mismatch', 'on_quota_exceeded']
+    signal_handlers = [
+        'on_root_mismatch',
+        'on_quota_exceeded',
+        'on_volumes_changed',
+    ]
 
     @remote
     def connect(self):
@@ -301,6 +305,10 @@
     def on_quota_exceeded(self, volume_dict):
         """Emit QuotaExceeded signal."""
 
+    @signal
+    def on_volumes_changed(self, volumes):
+        """Emit VolumesChanged signal."""
+
 
 class FileSystemClient(RemoteClient):
     """An ipc interface to the FileSystem Manager."""
 
=== modified file 'ubuntuone/proxy/tunnel_server.py'
--- ubuntuone/proxy/tunnel_server.py	2012-03-24 00:10:25 +0000
+++ ubuntuone/proxy/tunnel_server.py	2012-04-03 13:00:34 +0000
@@ -353,19 +353,27 @@
             logger.info("Proxy is disabled.")
         return enabled
     else:
+        QNetworkProxyFactory.setUseSystemConfiguration(True)
         query = QNetworkProxyQuery(host, port)
         proxies = QNetworkProxyFactory.systemProxyForQuery(query)
         return len(proxies) and proxies[0].type() != QNetworkProxy.DefaultProxy
 
 
+def install_qt_dbus():
+    """Import and install the qt+dbus integration."""
+    from dbus.mainloop.qt import DBusQtMainLoop
+    DBusQtMainLoop(set_as_default=True)
+
+
 def main(argv):
     """The main function for the tunnel server."""
     if not check_proxy_enabled(*argv[1:]):
         sys.stdout.write("Proxy not enabled.")
         sys.stdout.flush()
     else:
-        from dbus.mainloop.qt import DBusQtMainLoop
-        DBusQtMainLoop(set_as_default=True)
+        if sys.platform.startswith("linux"):
+            install_qt_dbus()
+
         app = QCoreApplication(argv)
         cookie = str(uuid.uuid4())
         tunnel_server = TunnelServer(cookie)
 
=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2011-10-14 20:02:23 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2012-04-03 13:00:34 +0000
@@ -160,7 +160,7 @@
     'VM_VOLUME_DELETED': ('volume',),
     'VM_VOLUME_DELETE_ERROR': ('volume_id', 'error'),
     'VM_SHARE_CHANGED': ('share_id',),
-
+    'VM_VOLUMES_CHANGED': ('volumes',),
 }
 
 DEFAULT_HANDLER = "handle_default"  # receives (event_name, **kwargs)
 
=== modified file 'ubuntuone/syncdaemon/interaction_interfaces.py'
--- ubuntuone/syncdaemon/interaction_interfaces.py	2012-03-19 13:20:36 +0000
+++ ubuntuone/syncdaemon/interaction_interfaces.py	2012-04-03 13:00:34 +0000
@@ -1039,6 +1039,17 @@
         self.interface.shares.ShareChanged(get_share_dict(share))
 
     @log_call(logger.debug)
+    def handle_VM_VOLUMES_CHANGED(self, volumes):
+        """Handle VM_VOLUMES_CHANGED event, emit VolumeChanged signal."""
+        str_volumes = []
+        for volume in volumes:
+            if isinstance(volume, UDF):
+                str_volumes.append(get_udf_dict(volume))
+            else:
+                str_volumes.append(get_share_dict(volume))
+        self.interface.sync_daemon.VolumesChanged(str_volumes)
+
+    @log_call(logger.debug)
     def handle_AQ_CHANGE_PUBLIC_ACCESS_OK(self, share_id, node_id,
                                           is_public, public_url):
         """Handle the AQ_CHANGE_PUBLIC_ACCESS_OK event."""
 
=== modified file 'ubuntuone/syncdaemon/tunnel_runner.py'
--- ubuntuone/syncdaemon/tunnel_runner.py	2012-03-27 03:41:06 +0000
+++ ubuntuone/syncdaemon/tunnel_runner.py	2012-04-03 13:00:34 +0000
@@ -21,6 +21,7 @@
 from os import path
 
 from twisted.internet import defer, reactor
+from twisted.python import procutils
 
 from ubuntuone.platform.constants import TUNNEL_EXECUTABLE
 
@@ -48,8 +49,12 @@
         from ubuntuone.proxy.tunnel_client import TunnelProcessProtocol
         protocol = TunnelProcessProtocol(self.client_d)
         process_path = self.get_process_path()
-        args = [TUNNEL_EXECUTABLE, host, str(port)]
-        self.process_transport = reactor.spawnProcess(protocol, process_path,
+        args = [process_path, host, str(port)]
+        if sys.platform.startswith("win") and not process_path.endswith("exe"):
+            python_exe = procutils.which("python.exe")
+            if python_exe:
+                args.insert(0, python_exe[0])
+        self.process_transport = reactor.spawnProcess(protocol, args[0],
                                                       env=None, args=args)
         reactor.addSystemEventTrigger("before", "shutdown", self.stop)
 
 
=== modified file 'ubuntuone/syncdaemon/volume_manager.py'
--- ubuntuone/syncdaemon/volume_manager.py	2012-02-09 23:32:10 +0000
+++ ubuntuone/syncdaemon/volume_manager.py	2012-04-03 13:00:34 +0000
@@ -636,6 +636,9 @@
             # update the free_bytes on the volume
             self.update_free_space(volume_id, new_volume.free_bytes)
 
+        volumes = list(self.get_volumes(all_volumes=True))
+        events.append(("VM_VOLUMES_CHANGED", dict(volumes=volumes)))
+
         # push the collected events
         for event in events:
             self.m.event_q.push(event[0], **event[1])