Merge lp:~ubuntuone-control-tower/ubuntu/lucid/ubuntuone-client/trunk into lp:ubuntu/lucid/ubuntuone-client

[dobey]

[lp:~ubuntuone-control-tower/ubuntu/lucid/ubuntuone-client/trunk]

23. By Elliot Murphy on 2010-03-11

* New upstream release.
  - Bring in UI for public files handling in Nautilus. (LP: #525803)
  - Bring in UI for managing devices. (LP: #525803)
* Add dependency on python-httplib2 to packaging. (LP: #535207)

=== modified file 'bin/u1sdtool'
--- bin/u1sdtool	2010-03-04 16:47:43 +0000
+++ bin/u1sdtool	2010-03-10 23:53:15 +0000
@@ -42,6 +42,7 @@
     show_error,
     show_state,
     show_waiting_content,
+    show_waiting_metadata,
     show_public_file_info,
     is_running,
 )
@@ -161,6 +162,9 @@
     elif options.status:
         d = sync_daemon_tool.get_status()
         d.addCallback(lambda r: show_state(r, out))
+    elif options.waiting_metadata:
+        d = sync_daemon_tool.waiting_metadata()
+        d.addCallback(lambda r: show_waiting_metadata(r, out))
     elif options.waiting_content:
         d = sync_daemon_tool.waiting_content()
         d.addCallback(lambda r: show_waiting_content(r, out))
@@ -237,6 +241,8 @@
                       help="Get the current status of syncdaemon")
     parser.add_option("", "--waiting-content", dest="waiting_content", 
                       action='store_true', help="Get the waiting content list")
+    parser.add_option("", "--waiting-metadata", dest="waiting_metadata", 
+                      action='store_true', help="Get the waiting metadata list")
     parser.add_option("", "--schedule-next", dest="schedule_next", 
                       metavar="SHARE_ID NODE_ID", nargs=2, type='string',
                       help="Move the node to be the next in the queue of "

=== modified file 'bin/ubuntuone-preferences'
--- bin/ubuntuone-preferences	2010-03-04 16:47:43 +0000
+++ bin/ubuntuone-preferences	2010-03-10 23:53:15 +0000
@@ -23,6 +23,7 @@
 import pygtk
 pygtk.require('2.0')
 import gobject
+import glib
 import gtk
 import os
 import gettext
@@ -32,6 +33,11 @@
 from oauth import oauth
 from ubuntuone import clientdefs
 from ubuntuone.syncdaemon.tools import SyncDaemonTool
+from ubuntuone.syncdaemon.logger import LOGFOLDER
+
+import logging
+import sys
+import httplib, urlparse, socket
 
 import dbus.service
 from ConfigParser import ConfigParser
@@ -39,6 +45,11 @@
 from dbus.mainloop.glib import DBusGMainLoop
 from xdg.BaseDirectory import xdg_config_home
 
+logging.basicConfig(
+    filename=os.path.join(LOGFOLDER, 'u1-prefs.log'),
+    level=logging.DEBUG,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("ubuntuone-preferences")
 DBusGMainLoop(set_as_default=True)
 
 _ = gettext.gettext
@@ -65,10 +76,363 @@
       pass
 
 
+def get_access_token(keyring):
+      items = []
+      items = keyring.find_items_sync(
+            keyring.ITEM_GENERIC_SECRET,
+            {'ubuntuone-realm': "https://ubuntuone.com",
+             'oauth-consumer-key': 'ubuntuone'})
+      secret = items[0].secret
+      return oauth.OAuthToken.from_string(secret)
+
+
+class DevicesWidget(gtk.Table):
+    """
+    the Devices tab.
+    """
+    def __init__(self,
+                 bus,
+                 keyring=gnomekeyring,
+                 realm='https://ubuntuone.com',
+                 consumer_key='ubuntuone',
+                 url='https://one.ubuntu.com/api/1.0/devices/'):
+        super(DevicesWidget, self).__init__(rows=2, columns=3)
+        self.bus = bus
+        self.keyring = keyring
+        self.sdtool = SyncDaemonTool(bus)
+        self.set_border_width(6)
+        self.set_row_spacings(6)
+        self.set_col_spacings(6)
+        self.devices = None
+        self.realm = realm
+        self.consumer_key = consumer_key
+        self.base_url = url
+        self.conn = None
+        self.consumer = None
+        self.table_widgets = []
+
+        self.connected = None  # i.e. unknown
+        self.conn_btn = None
+        self.up_spin = None
+        self.dn_spin = None
+        self.bw_chk = None
+        self.bw_limited = False
+        self.up_limit = 2097152
+        self.dn_limit = 2097152
+
+        self._update_id = 0
+
+        self.status_label = gtk.Label("")
+        self.attach(self.status_label, 0, 3, 2, 3)
+
+        self.description = gtk.Label(_("The devices connected to with your"
+                                       " personal cloud network"
+                                       " are listed below"))
+        self.description.set_alignment(0., .5)
+        self.description.set_line_wrap(True)
+        self.attach(self.description, 0, 3, 0, 1, xpadding=12, ypadding=12)
+
+    def update_bw_settings(self):
+        """
+        Push the bandwidth settings at syncdaemon.
+        """
+        try:
+            client = self.bus.get_object(DBUS_IFACE_NAME, "/config",
+                                         follow_name_owner_changes=True)
+            iface = dbus.Interface(client, DBUS_IFACE_CONFIG_NAME)
+            iface.set_throttling_limits(self.dn_limit, self.up_limit,
+                                        reply_handler=dbus_async,
+                                        error_handler=self.error)
+            if self.bw_limited:
+                iface.enable_bandwidth_throttling(reply_handler=dbus_async,
+                                                  error_handler=self.error)
+            else:
+                iface.disable_bandwidth_throttling(reply_handler=dbus_async,
+                                                   error_handler=self.error)
+        except DBusException, e:
+            self.error(str(e))
+
+    def handle_bw_controls_changed(self, *a):
+        """
+        Sync the bandwidth throttling model with the view.
+
+        Start a timer to sync with syncdaemon too.
+        """
+        # Remove the timeout ...
+        if self._update_id != 0:
+            gobject.source_remove(self._update_id)
+
+        # sync the model ...
+        self.bw_limited = self.bw_chk.get_active()
+        self.up_limit = self.up_spin.get_value_as_int() * 1024
+        self.dn_limit = self.dn_spin.get_value_as_int() * 1024
+
+        # ... and add the timeout back
+        self._update_id = gobject.timeout_add_seconds(
+              1, self.update_bw_settings)
+
+    def handle_bw_checkbox_toggled(self, checkbox, *widgets):
+        """
+        Callback for the bandwidth togglebutton.
+        """
+        active = checkbox.get_active()
+        for widget in widgets:
+            widget.set_sensitive(active)
+        self.handle_bw_controls_changed()
+
+    def handle_limits(self, limits):
+        """
+        Callback for when syncdaemon tells us its throttling limits.
+        """
+        self.up_limit = int(limits['upload'])
+        self.dn_limit = int(limits['download'])
+        if self.up_spin is not None and self.dn_spin is not None:
+            self.up_spin.set_value(self.up_limit / 1024)
+            self.dn_spin.set_value(self.dn_limit / 1024)
+
+    def handle_throttling_enabled(self, enabled):
+        """
+        Callback for when syncdaemon tells us whether throttling is enabled.
+        """
+        self.bw_limited = enabled
+        if self.bw_chk is not None:
+            self.bw_chk.set_active(enabled)
+
+    def handle_state_change(self, new_state):
+        """
+        Callback for when syncdaemon's state changes.
+        """
+        if new_state['is_error']:
+            # this syncdaemon isn't going to connect no more
+            self.connected = None
+        else:
+            self.connected = new_state['is_connected']
+        if self.conn_btn is not None:
+            if self.connected:
+                self.conn_btn.set_label(_("Disconnect"))
+            else:
+                self.conn_btn.set_label(_("Connect"))
+            if self.connected is None:
+                self.conn_btn.set_sensitive(False)
+            else:
+                self.conn_btn.set_sensitive(True)
+
+    def error(self, msg):
+        """
+        Clear the table and show the error message in its place.
+
+        This might be better as an error dialog.
+        """
+        self.clear_devices_view()
+        self.status_label.set_markup("<b>Error:</b> %s" % msg)
+        logger.error(msg)
+
+    def request(self, path='', method='GET'):
+        """
+        Helper that makes an oauth-wrapped rest request.
+
+        XXX duplication with request_REST_info (but this one should be async).
+        """
+        url = self.base_url + path
+
+        token = get_access_token(self.keyring)
+
+        oauth_request = oauth.OAuthRequest.from_consumer_and_token(
+            http_url=url,
+            http_method=method,
+            oauth_consumer=self.consumer,
+            token=token,
+            parameters='')
+        oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
+                                   self.consumer, token)
+
+        scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
+
+        conn = httplib.HTTPSConnection(netloc)
+        try:
+            conn.request(method, path, headers=oauth_request.to_header())
+        except socket.error:
+            return None
+        return conn
+
+    def get_devices(self):
+        """
+        Ask the server for a list of devices
+
+        Hook up parse_devices to run on the result (when it gets here).
+        """
+        try:
+            token = get_access_token(self.keyring)
+        except gnomekeyring.NoMatchError:
+            self.error("No token in the keyring")
+            self.devices = []
+        else:
+            self.consumer = oauth.OAuthConsumer("ubuntuone", "hammertime")
+
+            self.conn = self.request()
+            if self.conn is None:
+                self.clear_devices_view()
+                self.error('Unable to connect')
+            else:
+                glib.io_add_watch(
+                    self.conn.sock,
+                    glib.IO_IN | glib.IO_PRI | glib.IO_ERR | glib.IO_HUP,
+                    self.parse_devices)
+
+    def parse_devices(self, *a):
+        """
+        Parse the list of devices, and hook up list_devices if it worked.
+        """
+        response = self.conn.getresponse() # shouldn't block
+        if response.status == 200:
+            response = response.read() # neither should this
+            self.devices = simplejson.loads(response)
+            gobject.idle_add(self.list_devices)
+        else:
+            self.clear_devices_view()
+            self.error(response.reason)
+        return False
+
+    def clear_devices_view(self):
+        """
+        Clear out almost all the widgets.
+
+        All except from the table, the description and the
+        status_label get destroyed.
+        """
+        for i in self.get_children():
+            if i not in (self.description, self.status_label):
+                i.destroy()
+        self.conn_btn = None
+        self.up_spin = None
+        self.dn_spin = None
+        self.bw_chk = None
+
+    def list_devices(self):
+        """
+        Populate the table with the list of devices.
+
+        If the list of devices is empty, make a fake one that refers
+        to the local machine (to get the connect/restart buttons).
+        """
+        self.resize(len(self.devices)+1, 3)
+
+        self.clear_devices_view()
+
+        token = get_access_token(self.keyring)
+
+        if not self.devices:
+            # a stopgap device so you can at least try to connect
+            self.devices = [{'kind': 'Computer',
+                             'description': _("<LOCAL MACHINE>"),
+                             'token': token.key,
+                             'FAKE': 'YES'}]
+
+        self.status_label.set_label("")
+
+        i = 0
+        for row in self.devices:
+            i += 1
+            img = gtk.Image()
+            img.set_from_icon_name(row['kind'].lower(), gtk.ICON_SIZE_DND)
+            desc = gtk.Label(row['description'])
+            desc.set_alignment(0., .5)
+            self.attach(img, 0, 1, i, i+1)
+            self.attach(desc, 1, 2, i, i+1)
+            if 'FAKE' not in row:
+                  # we don't include the "Remove" button for the fake entry :)
+                  butn = gtk.Button(_('Remove'))
+                  butn.connect('clicked', self.remove,
+                               row['kind'], row.get('token'))
+                  self.attach(butn, 2, 3, i, i+1, xoptions=0, yoptions=0)
+            if row.get('token') == token.key:
+                self.bw_chk = ck_btn = gtk.CheckButton(
+                      _("_Limit Bandwidth Usage"))
+                ck_btn.set_active(self.bw_limited)
+                up_lbl = gtk.Label(_("Maximum _upload speed (KB/s):"))
+                up_lbl.set_alignment(0., .5)
+                adj = gtk.Adjustment(value=self.up_limit/1024.,
+                                     lower=0.0, upper=4096.0,
+                                     step_incr=1.0, page_incr=16.0)
+                self.up_spin = up_btn = gtk.SpinButton(adj)
+                up_btn.connect("value-changed", self.handle_bw_controls_changed)
+                up_lbl.set_mnemonic_widget(up_btn)
+                dn_lbl = gtk.Label(_("Maximum _download speed (KB/s):"))
+                dn_lbl.set_alignment(0., .5)
+                adj = gtk.Adjustment(value=self.dn_limit/1024.,
+                                     lower=0.0, upper=4096.0,
+                                     step_incr=1.0, page_incr=16.0)
+                self.dn_spin = dn_btn = gtk.SpinButton(adj)
+                dn_btn.connect("value-changed", self.handle_bw_controls_changed)
+                dn_lbl.set_mnemonic_widget(dn_btn)
+                ck_btn.connect('toggled', self.handle_bw_checkbox_toggled,
+                               up_lbl, up_btn, dn_lbl, dn_btn)
+                self.handle_bw_checkbox_toggled(ck_btn,
+                                                up_lbl, up_btn, dn_lbl, dn_btn)
+
+                self.conn_btn = gtk.Button(_('Connect'))
+                if self.connected is None:
+                    self.conn_btn.set_sensitive(False)
+                elif self.connected:
+                    self.conn_btn.set_label(_('Disconnect'))
+                self.conn_btn.connect('clicked', self.handle_connect_button)
+                restart_btn = gtk.Button(_('Restart'))
+                restart_btn.connect('clicked', self.handle_restart_button)
+                btn_box = gtk.HButtonBox()
+                btn_box.add(self.conn_btn)
+                btn_box.add(restart_btn)
+
+                i += 1
+                self.attach(ck_btn, 1, 3, i, i+1)
+                i += 1
+                self.attach(up_lbl, 1, 2, i, i+1)
+                self.attach(up_btn, 2, 3, i, i+1)
+                i += 1
+                self.attach(dn_lbl, 1, 2, i, i+1)
+                self.attach(dn_btn, 2, 3, i, i+1)
+                i += 1
+                self.attach(btn_box, 1, 3, i, i+1)
+            i += 2
+        self.show_all()
+
+    def handle_connect_button(self, *a):
+        """
+        Callback for the Connect/Disconnect button.
+        """
+        self.conn_btn.set_sensitive(False)
+        if self.connected:
+            d = self.sdtool.disconnect()
+        else:
+            d = self.sdtool.connect()
+
+    def handle_restart_button(self, *a):
+        """
+        Callback for the Restart button.
+        """
+        self.sdtool.quit().addCallbacks(lambda _: self.sdtool.start())
+
+    def remove(self, button, kind, token):
+        """
+        Callback for the Remove button.
+
+        Starts an async request to remove a device.
+        """
+        self.conn = self.request('remove/%s/%s' % (kind.lower(), token))
+        if self.conn is None:
+            self.clear_devices_view()
+            self.error('Unable to connect')
+        else:
+            glib.io_add_watch(
+                self.conn.sock,
+                glib.IO_IN | glib.IO_PRI | glib.IO_ERR | glib.IO_HUP,
+                self.parse_devices)
+
+
+
 class UbuntuOneDialog(gtk.Dialog):
       """Preferences dialog."""
 
-      def __init__(self, config=None, *args, **kw):
+      def __init__(self, config=None, keyring=gnomekeyring, *args, **kw):
             """Initializes our config dialog."""
             super(UbuntuOneDialog, self).__init__(*args, **kw)
             self.set_title(_("Ubuntu One Preferences"))
@@ -80,12 +444,8 @@
             self.connect("close", self.__handle_response, gtk.RESPONSE_CLOSE)
             self.connect("response", self.__handle_response)
 
-            self.bw_enabled = False
-            self.up_limit = 2097152
-            self.dn_limit = 2097152
-
             self.__bus = dbus.SessionBus()
-            self.keyring = gnomekeyring
+            self.keyring = keyring
 
             self.__bus.add_signal_receiver(
                   handler_function=self.__got_state,
@@ -108,15 +468,13 @@
             # Timeout ID to avoid spamming DBus from spinbutton changes
             self.__update_id = 0
 
-            # Connectivity status
-            self.connected = False
-
             # SD Tool object
             self.sdtool = SyncDaemonTool(self.__bus)
             self.sdtool.get_status().addCallbacks(lambda _: self.__got_state,
                                                   self.__sd_error)
             # Build the dialog
             self.__construct()
+            logger.debug("starting")
 
       def quit(self):
             """Exit the main loop."""
@@ -132,97 +490,23 @@
 
       def __got_state(self, state):
             """Got the state of syncdaemon."""
-            self.connected = bool(state['is_connected'])
-            if self.connected:
-                  self.conn_btn.set_label(_("Disconnect"))
-            else:
-                  self.conn_btn.set_label(_("Connect"))
-            self.conn_btn.set_sensitive(True)
+            self.devices.handle_state_change(state)
 
       def __got_limits(self, limits):
             """Got the throttling limits."""
-            self.up_limit = int(limits['upload'])
-            self.dn_limit = int(limits['download'])
-            self.up_spin.set_value(self.up_limit / 1024)
-            self.dn_spin.set_value(self.dn_limit / 1024)
+            logger.debug("got limits: %s" % (limits,))
+            self.devices.handle_limits(limits)
 
       def __got_enabled(self, enabled):
             """Got the throttling enabled config."""
-            self.bw_enabled = bool(enabled)
-            self.limit_check.set_active(self.bw_enabled)
-
-      def __update_bw_settings(self):
-            """Update the bandwidth throttling config in syncdaemon."""
-            self.bw_enabled = self.limit_check.get_active()
-            self.up_limit = self.up_spin.get_value_as_int() * 1024
-            self.dn_limit = self.dn_spin.get_value_as_int() * 1024
-
-            try:
-                  client = self.__bus.get_object(DBUS_IFACE_NAME, "/config",
-                                                 follow_name_owner_changes=True)
-                  iface = dbus.Interface(client, DBUS_IFACE_CONFIG_NAME)
-                  iface.set_throttling_limits(self.dn_limit, self.up_limit,
-                        reply_handler=dbus_async,
-                        error_handler=self.__dbus_error)
-                  if self.bw_enabled:
-                        iface.enable_bandwidth_throttling(
-                              reply_handler=dbus_async,
-                              error_handler=self.__dbus_error)
-                  else:
-                        iface.disable_bandwidth_throttling(
-                              reply_handler=dbus_async,
-                              error_handler=self.__dbus_error)
-            except DBusException, e:
-                  self.__dbus_error(e)
+            self.devices.handle_throttling_enabled(enabled)
 
       def __handle_response(self, dialog, response):
             """Handle the dialog's response."""
             self.hide()
-            self.__update_bw_settings()
+            self.devices.update_bw_settings()
             gtk.main_quit()
 
-      def __bw_limit_toggled(self, button, data=None):
-            """Toggle the bw limit panel."""
-            self.bw_enabled = self.limit_check.get_active()
-            self.bw_table.set_sensitive(self.bw_enabled)
-            try:
-                  client = self.__bus.get_object(DBUS_IFACE_NAME, "/config",
-                                                 follow_name_owner_changes=True)
-                  iface = dbus.Interface(client, DBUS_IFACE_CONFIG_NAME)
-                  iface.set_throttling_limits(self.dn_limit, self.up_limit,
-                        reply_handler=dbus_async,
-                        error_handler=self.__dbus_error)
-                  if self.bw_enabled:
-                        iface.enable_bandwidth_throttling(
-                              reply_handler=dbus_async,
-                              error_handler=self.__dbus_error)
-                  else:
-                        iface.disable_bandwidth_throttling(
-                              reply_handler=dbus_async,
-                              error_handler=self.__dbus_error)
-            except DBusException, e:
-                  self.__dbus_error(e)
-
-      def __spinner_changed(self, button, data=None):
-            """Remove timeout and add anew."""
-            if self.__update_id != 0:
-                  gobject.source_remove(self.__update_id)
-
-            self.__update_id = gobject.timeout_add_seconds(
-                  1, self.__update_bw_settings)
-
-      def __connect_toggled(self, button, data=None):
-            """Toggle the connection state..."""
-            self.conn_btn.set_sensitive(False)
-            if self.connected:
-                  self.sdtool.start().addCallbacks(
-                        lambda _: self.sdtool.disconnect(),
-                        self.__sd_error)
-            else:
-                  self.sdtool.start().addCallbacks(
-                        lambda _: self.sdtool.connect(),
-                        self.__sd_error)
-
       def _format_for_gb_display(self, bytes):
             """Format bytes into reasonable gb display."""
             gb = bytes / 1024 / 1024 / 1024
@@ -247,12 +531,7 @@
       def request_REST_info(self, url, method):
             """Make a REST request and return the resulting dict, or None."""
             consumer = oauth.OAuthConsumer("ubuntuone", "hammertime")
-            items = []
-            items = self.keyring.find_items_sync(
-                  gnomekeyring.ITEM_GENERIC_SECRET,
-                  {'ubuntuone-realm': "https://ubuntuone.com",
-                   'oauth-consumer-key': consumer.key})
-            token = oauth.OAuthToken.from_string(items[0].secret)
+            token = get_access_token(self.keyring)
             request = oauth.OAuthRequest.from_consumer_and_token(
                   http_url=url, http_method=method, oauth_consumer=consumer,
                   token=token)
@@ -403,75 +682,11 @@
             self.mail_label.show()
 
             # Devices tab
-            devices = gtk.VBox(spacing=12)
-            devices.set_border_width(6)
-            self.notebook.append_page(devices)
-            self.notebook.set_tab_label_text(devices, _("Devices"))
-            devices.show()
-
-            # Bandwidth limiting
-            self.limit_check = gtk.CheckButton(_("_Limit Bandwidth Usage"))
-            self.limit_check.connect("toggled", self.__bw_limit_toggled)
-            devices.pack_start(self.limit_check, False, False)
-            self.limit_check.show()
-
-            hbox = gtk.HBox(spacing=12)
-            devices.pack_start(hbox, False, False)
-            hbox.show()
-
-            label = gtk.Label()
-            hbox.pack_start(label, False, False)
-            label.show()
-
-            rbox = gtk.VBox(spacing=12)
-            hbox.pack_start(rbox, False, False)
-            rbox.show()
-
-            # Now put the bw limit bits in a table too
-            self.bw_table = gtk.Table(rows=2, columns=2)
-            self.bw_table.set_row_spacings(6)
-            self.bw_table.set_col_spacings(6)
-            self.bw_table.set_sensitive(False)
-            rbox.pack_start(self.bw_table, False, False)
-            self.bw_table.show()
-
-            # Upload speed
-            label = gtk.Label(_("Maximum _upload speed (KB/s):"))
-            label.set_use_underline(True)
-            label.set_alignment(0, 0.5)
-            self.bw_table.attach(label, 0, 1, 0, 1)
-            label.show()
-
-            adjustment = gtk.Adjustment(value=2048.0, lower=0.0, upper=4096.0,
-                                        step_incr=64.0, page_incr=128.0)
-            self.up_spin = gtk.SpinButton(adjustment)
-            self.up_spin.connect("value-changed", self.__spinner_changed)
-            label.set_mnemonic_widget(self.up_spin)
-            self.bw_table.attach(self.up_spin, 1, 2, 0, 1)
-            self.up_spin.show()
-
-            # Download speed
-            label = gtk.Label(_("Maximum _download speed (KB/s):"))
-            label.set_use_underline(True)
-            label.set_alignment(0, 0.5)
-            self.bw_table.attach(label, 0, 1, 1, 2)
-            label.show()
-            adjustment = gtk.Adjustment(value=2048.0, lower=64.0, upper=8192.0,
-                                        step_incr=64.0, page_incr=128.0)
-            self.dn_spin = gtk.SpinButton(adjustment)
-            self.dn_spin.connect("value-changed", self.__spinner_changed)
-            label.set_mnemonic_widget(self.dn_spin)
-            self.bw_table.attach(self.dn_spin, 1, 2, 1, 2)
-            self.dn_spin.show()
-
-            alignment = gtk.Alignment(1.0, 0.5)
-            rbox.pack_end(alignment, False, False)
-            alignment.show()
-
-            self.conn_btn = gtk.Button(_("Connect"))
-            self.conn_btn.connect('clicked', self.__connect_toggled)
-            alignment.add(self.conn_btn)
-            self.conn_btn.show()
+            self.devices = DevicesWidget(self.__bus, self.keyring)
+            self.notebook.append_page(self.devices)
+            self.notebook.set_tab_label_text(self.devices, _("Devices"))
+            self.devices.show_all()
+            self.devices.get_devices()
 
             # Services tab
             services = gtk.VBox(spacing=12)

=== modified file 'configure'
--- configure	2010-03-04 16:47:43 +0000
+++ configure	2010-03-10 23:53:15 +0000
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.65 for ubuntuone-client 1.1.3.
+# Generated by GNU Autoconf 2.65 for ubuntuone-client 1.1.4.
 #
 #
 # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
@@ -698,8 +698,8 @@
 # Identity of this package.
 PACKAGE_NAME='ubuntuone-client'
 PACKAGE_TARNAME='ubuntuone-client'
-PACKAGE_VERSION='1.1.3'
-PACKAGE_STRING='ubuntuone-client 1.1.3'
+PACKAGE_VERSION='1.1.4'
+PACKAGE_STRING='ubuntuone-client 1.1.4'
 PACKAGE_BUGREPORT=''
 PACKAGE_URL=''
 
@@ -1476,7 +1476,7 @@
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures ubuntuone-client 1.1.3 to adapt to many kinds of systems.
+\`configure' configures ubuntuone-client 1.1.4 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1547,7 +1547,7 @@
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of ubuntuone-client 1.1.3:";;
+     short | recursive ) echo "Configuration of ubuntuone-client 1.1.4:";;
    esac
   cat <<\_ACEOF
 
@@ -1660,7 +1660,7 @@
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-ubuntuone-client configure 1.1.3
+ubuntuone-client configure 1.1.4
 generated by GNU Autoconf 2.65
 
 Copyright (C) 2009 Free Software Foundation, Inc.
@@ -1938,7 +1938,7 @@
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by ubuntuone-client $as_me 1.1.3, which was
+It was created by ubuntuone-client $as_me 1.1.4, which was
 generated by GNU Autoconf 2.65.  Invocation command line was
 
   $ $0 $@
@@ -2748,7 +2748,7 @@
 
 # Define the identity of the package.
  PACKAGE='ubuntuone-client'
- VERSION='1.1.3'
+ VERSION='1.1.4'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -12972,7 +12972,7 @@
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by ubuntuone-client $as_me 1.1.3, which was
+This file was extended by ubuntuone-client $as_me 1.1.4, which was
 generated by GNU Autoconf 2.65.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -13038,7 +13038,7 @@
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-ubuntuone-client config.status 1.1.3
+ubuntuone-client config.status 1.1.4
 configured by $0, generated by GNU Autoconf 2.65,
   with options \\"\$ac_cs_config\\"
 

=== modified file 'configure.ac'
--- configure.ac	2010-03-04 16:47:43 +0000
+++ configure.ac	2010-03-10 23:53:15 +0000
@@ -1,7 +1,7 @@
 dnl Process this file with autoconf to produce a configure script.
 AC_PREREQ(2.53)
 
-AC_INIT([ubuntuone-client], [1.1.3])
+AC_INIT([ubuntuone-client], [1.1.4])
 AC_CONFIG_SRCDIR([config.h.in])
 
 AM_INIT_AUTOMAKE([1.10 foreign])

=== modified file 'contrib/__init__.pyc'
Binary files contrib/__init__.pyc	2010-03-04 16:47:43 +0000 and contrib/__init__.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'contrib/dbus_util.pyc'
Binary files contrib/dbus_util.pyc	2010-03-04 16:47:43 +0000 and contrib/dbus_util.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'contrib/mocker.pyc'
Binary files contrib/mocker.pyc	2010-03-04 16:47:43 +0000 and contrib/mocker.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'contrib/testing/__init__.pyc'
Binary files contrib/testing/__init__.pyc	2010-03-04 16:47:43 +0000 and contrib/testing/__init__.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-03-04 16:47:43 +0000
+++ contrib/testing/testcase.py	2010-03-10 23:53:15 +0000
@@ -348,8 +348,6 @@
     def __init__(self, eq, *args, **kwargs):
         """ Creates the instance """
         self.eq = self.event_queue = eq
-        self.client = action_queue.ActionQueue.protocol()
-        self.client.disconnect = lambda: None
         self.uploading = {}
         self.downloading = {}
         # pylint: disable-msg=C0103

=== modified file 'contrib/testing/testcase.pyc'
Binary files contrib/testing/testcase.pyc	2010-03-04 16:47:43 +0000 and contrib/testing/testcase.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'debian/changelog'
--- debian/changelog	2010-03-05 15:47:48 +0000
+++ debian/changelog	2010-03-10 23:53:15 +0000
@@ -1,3 +1,12 @@
+ubuntuone-client (1.1.4-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release.
+    - Bring in UI for public files handling in Nautilus. (LP: #525803)
+    - Bring in UI for managing devices. (LP: #525803)
+  * Add dependency on python-httplib2 to packaging. (LP: #535207)
+
+ -- Rodney Dawes <[e-mail]>  Wed, 10 Mar 2010 18:36:57 -0500
+
 ubuntuone-client (1.1.3-0ubuntu1) lucid; urgency=low
 
   * New upstream release.

=== modified file 'debian/control'
--- debian/control	2010-03-04 16:52:43 +0000
+++ debian/control	2010-03-10 23:53:15 +0000
@@ -41,6 +41,7 @@
 Depends: ${shlibs:Depends}, ${misc:Depends}, ${python:Depends},
  ubuntuone-client (= ${source:Version}),
  python-gtk2 (>= 2.10),
+ python-httplib2,
  python-simplejson
 Replaces: ubuntuone-client (<= 1.1.1)
 Conflicts: ubuntuone-client (<= 1.1.1)

=== modified file 'docs/man/u1sdtool.1'
--- docs/man/u1sdtool.1	2010-02-17 23:51:29 +0000
+++ docs/man/u1sdtool.1	2010-03-10 23:53:15 +0000
@@ -63,6 +63,9 @@
 \-\-status
 .br
 .B u1sdtool
+\-\-waiting-metadata
+.br
+.B u1sdtool
 \-\-waiting-content
 .br
 .B u1sdtool
@@ -192,6 +195,9 @@
 \fB\-\-status\fR
 Get the current status of syncdaemon
 .TP
+\fB\-\-waiting-metadata\fR
+Get the waiting metadata list
+.TP
 \fB\-\-waiting-content\fR
 Get the waiting content list
 .TP

=== modified file 'docs/syncdaemon_dbus_api.txt'
--- docs/syncdaemon_dbus_api.txt	2010-02-17 23:51:29 +0000
+++ docs/syncdaemon_dbus_api.txt	2010-03-10 23:53:15 +0000
@@ -19,20 +19,15 @@
 Object path: /status
   Interface: com.ubuntuone.SyncDaemon.Status
     Methods:
-      waiting_content()
-        
-        returns a list of files that are waiting to be up- or downloaded
-        
-
-      current_downloads()
-         return list of files with a download in progress. 
-
       schedule_next(share_id=s,node_id=s)
         
         Make the command on the given share and node be next in the
         queue of waiting commands.
         
 
+      waiting_metadata()
+        Return a list of the operations in the meta-queue.
+
       current_status()
          return the current status of the system, one of: local_rescan,
         offline, trying_to_connect, server_rescan or online.
@@ -41,6 +36,14 @@
       current_uploads()
          return a list of files with a upload in progress 
 
+      current_downloads()
+         return list of files with a download in progress. 
+
+      waiting_content()
+        
+        returns a list of files that are waiting to be up- or downloaded
+        
+
     Signals:
       UploadFinished(path=s,info=a{ss})
          Fire a D-BUS signal, notifying an upload has finished.  
@@ -115,6 +118,9 @@
          Returns the root dir/mount point. 
 
     Signals:
+      RootMismatch(root_id=s,new_root_id=s)
+        RootMismatch signal, the user connected with a different account.
+
       SignalError(signal=s,extra_args=a{ss})
          An error ocurred while trying to emit a signal. 
 
@@ -170,8 +176,14 @@
       reject_share(share_id=s)
          Rejects a share. 
 
-      refresh_shares()
-         Refresh the share list, requesting it to the server. 
+      create_shares(path=s,usernames=as,name=s,access_level=s)
+        Share a subtree with several users at once.
+
+        @param path: that path to share (the root of the subtree)
+        @param usernames: the user names to offer the share to
+        @param name: the name of the share
+        @param access_level: 'View' or 'Modify'
+        
 
       create_share(path=s,username=s,name=s,access_level=s)
          Share a subtree to the user identified by username.
@@ -193,6 +205,9 @@
         future as a success/failure indicator.
         
 
+      refresh_shares()
+         Refresh the share list, requesting it to the server. 
+
     Signals:
       ShareAnswerResponse(answer_info=a{ss})
         The answer to share was succesfull

=== modified file 'nautilus/ubuntuone-nautilus.c'
--- nautilus/ubuntuone-nautilus.c	2010-03-04 16:47:43 +0000
+++ nautilus/ubuntuone-nautilus.c	2010-03-10 23:53:15 +0000
@@ -52,7 +52,7 @@
 #define UBUNTUONE_TYPE_NAUTILUS  (ubuntuone_nautilus_get_type ())
 #define UBUNTUONE_NAUTILUS(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), UBUNTUONE_TYPE_NAUTILUS, UbuntuOneNautilus))
 
-typedef struct _ShareCBData ShareCBData;
+typedef struct _CBData CBData;
 
 typedef struct {
   GObject parent_slot;
@@ -92,7 +92,7 @@
   GHashTable * observed;
 
   /* Extra data we need to free on finalization */
-  ShareCBData * share_cb_data;
+  CBData * cb_data;
 } UbuntuOneNautilus;
 
 typedef struct {
@@ -149,6 +149,13 @@
 static void ubuntuone_nautilus_udf_deleted (DBusGProxy * proxy,
 					    GHashTable * hash,
 					    gpointer user_data);
+static void ubuntuone_nautilus_file_published (DBusGProxy * proxy,
+					       GHashTable * hash,
+					       gpointer user_data);
+static void ubuntuone_nautilus_publish_error (DBusGProxy * proxy,
+					      GHashTable * hash,
+					      gchar * error,
+					      gpointer user_data);
 static void ubuntuone_nautilus_share_created (DBusGProxy * proxy,
 					      GHashTable * hash,
 					      gpointer user_data);
@@ -289,10 +296,14 @@
   } else if (g_hash_table_lookup (uon->needsupdating, path)) {
     nautilus_file_info_add_emblem (file, "ubuntuone-unsynchronized");
     ubuntuone_nautilus_add_observed (uon, path, file);
-  } else if (g_hash_table_lookup (uon->udfs, path)) {
+  }
+
+  if (g_hash_table_lookup (uon->udfs, path)) {
     nautilus_file_info_add_emblem (file, "ubuntuone-enabled");
     ubuntuone_nautilus_add_observed (uon, path, file);
-  } else if (g_hash_table_lookup (uon->public, path)) {
+  }
+
+  if (g_hash_table_lookup (uon->public, path)) {
     nautilus_file_info_add_emblem (file, "ubuntuone-public");
     ubuntuone_nautilus_add_observed (uon, path, file);
   }
@@ -354,8 +365,9 @@
   iface->get_widget = ubuntuone_nautilus_get_location_widget;
 }
 
-/* Magical struct for passing data in sharing callbacks */
-struct _ShareCBData {
+
+/* Magical struct for passing data in callbacks */
+struct _CBData {
   UbuntuOneNautilus * uon;
   gchar * path;
   GtkWidget * parent;
@@ -364,9 +376,12 @@
   GtkWidget * user_picker;
   GtkWidget * name_entry;
   GtkWidget * allow_mods;
+
+  /* Whether to make a file public or private */
+  gboolean make_public;
 };
 
-static void __share_cb_data_free (struct _ShareCBData * data) {
+static void __cb_data_free (struct _CBData * data) {
   if (!data)
     return;
 
@@ -388,7 +403,7 @@
 }
 
 /* Share on Ubuntu One dialog constructor */
-static GtkWidget * ubuntuone_nautilus_share_dialog_construct (struct _ShareCBData * data) {
+static GtkWidget * ubuntuone_nautilus_share_dialog_construct (struct _CBData * data) {
   GtkWidget * dialog;
   GtkWidget * area, * table, * label;
 
@@ -445,6 +460,8 @@
   gtk_table_attach (GTK_TABLE (table), data->allow_mods, 0, 2, 3, 4, GTK_FILL, GTK_FILL, 3, 3);
   gtk_widget_show (data->allow_mods);
 
+  gtk_widget_set_size_request (dialog, 500, 450);
+
   return dialog;
 }
 
@@ -452,12 +469,14 @@
 static void ubuntuone_nautilus_share_dialog_response (GtkDialog * dialog,
 						      gint response,
 						      gpointer user_data) {
-  struct _ShareCBData * data = (struct _ShareCBData *) user_data;
+  struct _CBData * data = (struct _CBData *) user_data;
 
   switch (response) {
   case GTK_RESPONSE_ACCEPT: {
     gchar * name, * modify;
-    GSList *emails;
+    GSList *emails, *l;
+    gchar **emails_array;
+    gint i;
     gboolean allow_mods = FALSE;
 
     emails = u1_contacts_picker_get_selected_emails (U1_CONTACTS_PICKER (data->user_picker));
@@ -465,8 +484,7 @@
       GtkWidget *error_dialog;
 
       error_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
-					     GTK_DIALOG_DESTROY_WITH_PARENT |
-					     GTK_DIALOG_NO_SEPARATOR,
+					     GTK_DIALOG_DESTROY_WITH_PARENT,
 					     GTK_MESSAGE_ERROR,
 					     GTK_BUTTONS_CLOSE,
 					     _("You need to select at least one contact to share this folder with"));
@@ -475,18 +493,25 @@
 
       return;
     }
+
+    emails_array = g_new0 (gchar *, g_slist_length (emails));
+    for (l = emails, i = 0; l != NULL; l = l->next, i++)
+       emails_array[i] = g_strdup (l->data);
+
     name = g_strdup (gtk_entry_get_text (GTK_ENTRY (data->name_entry)));
     allow_mods = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->allow_mods));
     modify = g_strdup_printf ("%d", allow_mods);
 
-    dbus_g_proxy_begin_call (data->uon->u1_shares, "create_share",
+    dbus_g_proxy_begin_call (data->uon->u1_shares, "create_shares",
 			     ubuntuone_nautilus_end_dbus_call, NULL,
 			     NULL,
 			     G_TYPE_STRING, data->path,
-			     G_TYPE_STRING, emails->data, /* FIXME: need to support more than 1 email */
+			     G_TYPE_STRV, emails_array,
 			     G_TYPE_STRING, name,
 			     G_TYPE_STRING, modify,
 			     G_TYPE_INVALID);
+ 
+    g_strfreev (emails_array);
     u1_contacts_picker_free_selection_list (emails);
     g_free (name);
     g_free (modify);
@@ -503,9 +528,63 @@
 					    user_data);
 }
 
+static void ubuntuone_nautilus_public_meta (DBusGProxy * proxy,
+					    DBusGProxyCall * call_id,
+					    gpointer user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+  GHashTable * metadata;
+  GError * error = NULL;
+  gchar * share_id, * node_id;
+
+  g_return_if_fail (proxy != NULL);
+
+  if (!dbus_g_proxy_end_call (proxy, call_id, &error,
+			      dbus_g_type_get_map ("GHashTable",
+						   G_TYPE_STRING,
+						   G_TYPE_STRING),
+			      &metadata,
+			      G_TYPE_INVALID)) {
+    g_warning ("ERROR: %s", error->message);
+    return;
+  }
+
+  share_id = g_hash_table_lookup (metadata, "share_id");
+  node_id = g_hash_table_lookup (metadata, "node_id");
+
+  dbus_g_proxy_begin_call (data->uon->u1_public, "change_public_access",
+			   ubuntuone_nautilus_end_dbus_call, NULL,
+			   NULL,
+			   G_TYPE_STRING, share_id,
+			   G_TYPE_STRING, node_id,
+			   G_TYPE_BOOLEAN, data->make_public,
+			   G_TYPE_INVALID);
+}
+
+static void ubuntuone_nautilus_copy_public_url (NautilusMenuItem * item,
+						gpointer user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+  gchar * url;
+
+  url = g_hash_table_lookup (data->uon->public, data->path);
+  gtk_clipboard_set_text (gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
+			  url, strlen (url));
+  gtk_clipboard_store (gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
+}
+
+static void ubuntuone_nautilus_toggle_publicity (NautilusMenuItem * item,
+						 gpointer user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+
+  dbus_g_proxy_begin_call (data->uon->u1_fs, "get_metadata",
+			   ubuntuone_nautilus_public_meta, data,
+			   NULL,
+			   G_TYPE_STRING, data->path,
+			   G_TYPE_INVALID);
+}
+
 static void ubuntuone_nautilus_share_folder (NautilusMenuItem * item,
 					     gpointer * user_data) {
-  struct _ShareCBData * data = (struct _ShareCBData *) user_data;
+  struct _CBData * data = (struct _CBData *) user_data;
   GtkWidget * dialog;
 
   dialog = ubuntuone_nautilus_share_dialog_construct (data);
@@ -517,10 +596,22 @@
   gtk_widget_show (dialog);
 }
 
+static void ubuntuone_nautilus_unshare_folder (NautilusMenuItem * item,
+					       gpointer * user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+  gchar * share_id;
+
+  share_id = g_hash_table_lookup (data->uon->shares, data->path);
+  dbus_g_proxy_begin_call (data->uon->u1_shares, "delete_share",
+			   ubuntuone_nautilus_end_dbus_call, NULL,
+			   NULL,
+			   G_TYPE_STRING, share_id,
+			   G_TYPE_INVALID);
+}
 
 static void ubuntuone_nautilus_synchronize_folder (NautilusMenuItem * item,
 						   gpointer * user_data) {
-  struct _ShareCBData * data = (struct _ShareCBData *) user_data;
+  struct _CBData * data = (struct _CBData *) user_data;
 
   dbus_g_proxy_begin_call (data->uon->u1_folders, "create",
 			   ubuntuone_nautilus_end_dbus_call,
@@ -531,7 +622,7 @@
 
 static void ubuntuone_nautilus_delete_folder (NautilusMenuItem * item,
 						   gpointer * user_data) {
-  struct _ShareCBData * data = (struct _ShareCBData *) user_data;
+  struct _CBData * data = (struct _CBData *) user_data;
   gchar * udf_id;
 
   udf_id = g_hash_table_lookup (data->uon->udfs, data->path);
@@ -551,10 +642,10 @@
   NautilusFileInfo * file;
   GList * items = NULL;
   gchar * path;
-  gboolean is_managed, is_root, is_udf, is_public;
-  struct _ShareCBData * share_cb_data;
+  gboolean is_managed, is_root, is_udf, is_public, is_shared;
+  struct _CBData * cb_data;
 
-  is_managed = is_root = is_udf = is_public = FALSE;
+  is_managed = is_root = is_udf = is_public = is_shared = FALSE;
 
   if (g_list_length (files) != 1)
     return NULL;
@@ -576,15 +667,21 @@
   if (g_hash_table_lookup (uon->udfs, path) != NULL)
     is_udf = TRUE;
 
-  if (uon->share_cb_data)
-    __share_cb_data_free (uon->share_cb_data);
-
-  share_cb_data = g_new0 (struct _ShareCBData, 1);
-  share_cb_data->uon = uon;
-  share_cb_data->parent = window;
-  share_cb_data->path = g_strdup (path);
-
-  uon->share_cb_data = share_cb_data;
+  if (g_hash_table_lookup (uon->public, path) != NULL)
+    is_public = TRUE;
+
+  if (g_hash_table_lookup (uon->shares, path) != NULL)
+    is_shared = TRUE;
+
+  if (uon->cb_data)
+    __cb_data_free (uon->cb_data);
+
+  cb_data = g_new0 (struct _CBData, 1);
+  cb_data->uon = uon;
+  cb_data->parent = window;
+  cb_data->path = g_strdup (path);
+
+  uon->cb_data = cb_data;
 
   if ((is_managed || is_udf) && !is_root && nautilus_file_info_is_directory (file)) {
     NautilusMenuItem * item;
@@ -595,7 +692,20 @@
 				   "ubuntuone");
     g_signal_connect (item, "activate",
 		      G_CALLBACK (ubuntuone_nautilus_share_folder),
-		      share_cb_data);
+		      cb_data);
+    items = g_list_prepend (items, item);
+  }
+
+  if ((is_managed && is_shared) && !is_root &&  nautilus_file_info_is_directory (file)) {
+    NautilusMenuItem * item;
+
+    item = nautilus_menu_item_new ("ubuntuone-unshare",
+				   _("Stop sharing on Ubuntu One..."),
+				   _("Stop sharing this folder on Ubuntu One"),
+				   "ubuntuone");
+    g_signal_connect (item, "activate",
+		      G_CALLBACK (ubuntuone_nautilus_unshare_folder),
+		      cb_data);
     items = g_list_prepend (items, item);
   }
 
@@ -604,27 +714,55 @@
 
     item = nautilus_menu_item_new ("ubuntuone-udf-delete",
 				   _("Stop synchronizing on Ubuntu One"),
-				   _("Stop synchronizing this folder with Ubuntu One"),
-				   "");
+				   _("Stop synchronizing this folder with Ubuntu One."),
+				   "ubuntuone");
     g_signal_connect (item, "activate",
 		      G_CALLBACK (ubuntuone_nautilus_delete_folder),
-		      share_cb_data);
+		      cb_data);
     items = g_list_append (items, item);
   }
 
-  if (!is_managed && !is_udf && nautilus_file_info_is_directory (file)) {
+  if (!is_managed && !is_udf && nautilus_file_info_is_directory (file) && (nautilus_file_info_get_file_type (file) != G_FILE_TYPE_SYMBOLIC_LINK)) {
     NautilusMenuItem * item;
 
     item = nautilus_menu_item_new ("ubuntuone-udf-create",
 				   _("Synchronize on Ubuntu One"),
-				   _("Synchronize this folder with Ubuntu One"),
-				   "");
+				   _("Synchronize this folder with Ubuntu One."),
+				   "ubuntuone");
     g_signal_connect (item, "activate",
 		      G_CALLBACK (ubuntuone_nautilus_synchronize_folder),
-		      share_cb_data);
+		      cb_data);
     items = g_list_append (items, item);
-  } else if (is_udf) {
+  }
     
+  if (is_managed && (nautilus_file_info_get_file_type (file) == G_FILE_TYPE_REGULAR)) {
+    NautilusMenuItem * item, * urlitem;
+
+    if (is_public) {
+      urlitem = nautilus_menu_item_new ("ubuntuone-geturl",
+					_("Copy Ubuntu One public URL"),
+					_("Copy the Ubuntu One public URL for this file to the clipboard."),
+					"ubuntuone");
+      g_signal_connect (urlitem, "activate",
+			G_CALLBACK (ubuntuone_nautilus_copy_public_url),
+			cb_data);
+      items = g_list_append (items, urlitem);
+      item = nautilus_menu_item_new ("ubuntuone-unpublish",
+                                     _("Stop publishing via Ubuntu One"),
+                                     _("No longer share this file with everyone."),
+                                     "ubuntuone");
+      cb_data->make_public = FALSE;
+    } else {
+      item = nautilus_menu_item_new ("ubuntuone-publish",
+                                     _("Publish via Ubuntu One"),
+                                     _("Make this file available to anyone."),
+                                     "ubuntuone");
+      cb_data->make_public = TRUE;
+    }
+    g_signal_connect (item, "activate",
+                      G_CALLBACK (ubuntuone_nautilus_toggle_publicity),
+                      cb_data);
+    items = g_list_append (items, item);
   }
 
  done:
@@ -818,6 +956,25 @@
   dbus_g_proxy_connect_signal (uon->u1_folders, "FolderUnSubscribed",
 			       G_CALLBACK (ubuntuone_nautilus_udf_deleted),
 			       uon, NULL);
+
+
+  dbus_g_proxy_add_signal (uon->u1_public, "PublicAccessChanged",
+			   dbus_g_type_get_map ("GHashTable",
+						G_TYPE_STRING,
+						G_TYPE_STRING),
+			   G_TYPE_INVALID);
+  dbus_g_proxy_connect_signal (uon->u1_public, "PublicAccessChanged",
+			       G_CALLBACK (ubuntuone_nautilus_file_published),
+			       uon, NULL);
+  dbus_g_proxy_add_signal (uon->u1_public, "PublicAccessChangeError",
+			   dbus_g_type_get_map ("GHashTable",
+						G_TYPE_STRING,
+						G_TYPE_STRING),
+			   G_TYPE_STRING,
+			   G_TYPE_INVALID);
+  dbus_g_proxy_connect_signal (uon->u1_public, "PublicAccessChangeError",
+			       G_CALLBACK (ubuntuone_nautilus_publish_error),
+			       uon, NULL);
 }
 
 static void ubuntuone_nautilus_class_init (UbuntuOneNautilusClass * klass) {
@@ -829,7 +986,7 @@
 static void ubuntuone_nautilus_finalize(GObject * object) {
   UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS(object);
 
-  __share_cb_data_free (uon->share_cb_data);
+  __cb_data_free (uon->cb_data);
 
   if (uon->u1_proxy)
     g_object_unref (uon->u1_proxy);
@@ -1185,17 +1342,51 @@
   ubuntuone_nautilus_reset_emblem (uon, path);
 }
 
+static void ubuntuone_nautilus_file_published (DBusGProxy * proxy,
+					       GHashTable * hash,
+					       gpointer user_data) {
+  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
+  gchar * path, * url, * public;
+  gboolean is_public;
+
+  path = g_hash_table_lookup (hash, "path");
+  url = g_hash_table_lookup (hash, "public_url");
+  public = g_hash_table_lookup (hash, "is_public");
+  is_public = (public != NULL && strlen (public) != 0);
+
+  if (!is_public && g_hash_table_lookup (uon->public, path))
+    g_hash_table_remove (uon->public, path);
+
+  if (is_public)
+    g_hash_table_replace (uon->public, g_strdup (path), g_strdup (url));
+
+  ubuntuone_nautilus_reset_emblem (uon, path);
+}
+
+static void ubuntuone_nautilus_publish_error (DBusGProxy * proxy,
+					      GHashTable * hash,
+					      gchar * error,
+					      gpointer user_data) {
+  UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
+  gchar * path;
+
+  path = g_hash_table_lookup (hash, "path");
+  g_hash_table_remove (uon->public, path);
+  ubuntuone_nautilus_reset_emblem (uon, path);
+}
+
 static void ubuntuone_nautilus_share_created (DBusGProxy * proxy,
 					      GHashTable * hash,
 					      gpointer user_data) {
   UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS (user_data);
-  gchar * path;
+  gchar * path, * id;
 
   path = g_hash_table_lookup (hash, "path");
+  id = g_hash_table_lookup (hash, "volume_id");
+
   if (!g_hash_table_lookup (uon->shares, path)) {
-    gchar *new_share = g_strdup (path);
-    g_hash_table_insert (uon->shares, new_share, new_share);
-    ubuntuone_nautilus_reset_emblem (uon, new_share);
+    g_hash_table_insert (uon->shares, g_strdup (path), g_strdup (id));
+    ubuntuone_nautilus_reset_emblem (uon, path);
   }
 }
 
@@ -1209,9 +1400,8 @@
 
   path = g_hash_table_lookup (hash, "path");
 
-  dialog = gtk_message_dialog_new (GTK_WINDOW (uon->share_cb_data->parent),
-				   GTK_DIALOG_DESTROY_WITH_PARENT |
-				   GTK_DIALOG_NO_SEPARATOR,
+  dialog = gtk_message_dialog_new (GTK_WINDOW (uon->cb_data->parent),
+				   GTK_DIALOG_DESTROY_WITH_PARENT,
 				   GTK_MESSAGE_ERROR,
 				   GTK_BUTTONS_CLOSE,
 				   _("Error creating share."));

=== modified file 'tests/__init__.pyc'
Binary files tests/__init__.pyc	2010-03-04 16:47:43 +0000 and tests/__init__.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/oauthdesktop/__init__.pyc'
Binary files tests/oauthdesktop/__init__.pyc	2010-03-04 16:47:43 +0000 and tests/oauthdesktop/__init__.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/oauthdesktop/test_auth.pyc'
Binary files tests/oauthdesktop/test_auth.pyc	2010-03-04 16:47:43 +0000 and tests/oauthdesktop/test_auth.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/oauthdesktop/test_config.pyc'
Binary files tests/oauthdesktop/test_config.pyc	2010-03-04 16:47:43 +0000 and tests/oauthdesktop/test_config.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/oauthdesktop/test_key_acls.pyc'
Binary files tests/oauthdesktop/test_key_acls.pyc	2010-03-04 16:47:43 +0000 and tests/oauthdesktop/test_key_acls.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/oauthdesktop/test_main.pyc'
Binary files tests/oauthdesktop/test_main.pyc	2010-03-04 16:47:43 +0000 and tests/oauthdesktop/test_main.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/__init__.pyc'
Binary files tests/syncdaemon/__init__.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/__init__.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/fsm/__init__.pyc'
Binary files tests/syncdaemon/fsm/__init__.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/fsm/__init__.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/fsm/test_fsm.pyc'
Binary files tests/syncdaemon/fsm/test_fsm.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/fsm/test_fsm.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/fsm/test_fsm_run.pyc'
Binary files tests/syncdaemon/fsm/test_fsm_run.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/fsm/test_fsm_run.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/fsm/test_run_hello.pyc'
Binary files tests/syncdaemon/fsm/test_run_hello.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/fsm/test_run_hello.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_action_predicates.pyc'
Binary files tests/syncdaemon/test_action_predicates.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_action_predicates.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2010-03-04 16:47:43 +0000
+++ tests/syncdaemon/test_action_queue.py	2010-03-10 23:53:15 +0000
@@ -24,29 +24,30 @@
 import logging
 import os
 import shutil
-from StringIO import StringIO
 import unittest
 import urllib2
 import uuid
 
 import dbus
 from dbus.mainloop.glib import DBusGMainLoop
+from functools import wraps
+from StringIO import StringIO
 from twisted.internet import defer, threads, reactor
 from twisted.python.failure import DefaultException, Failure
-from twisted.trial.unittest import TestCase as TwistedTestCase
 from twisted.web import server
 
 from contrib.testing.testcase import (
-    BaseTwistedTestCase, FakeMain,
-    MementoHandler, DummyClass
+    BaseTwistedTestCase, MementoHandler
 )
 
 from ubuntuone.storageprotocol import client, volumes
+from ubuntuone.syncdaemon import states
 from ubuntuone.syncdaemon.dbus_interface import DBusInterface
 from ubuntuone.syncdaemon.main import Main
 from ubuntuone.syncdaemon.action_queue import (
     ActionQueue, ActionQueueCommand, ChangePublicAccess, CreateUDF,
-    DeleteVolume, ListDir, ListVolumes, NoisyRequestQueue, RequestQueue
+    DeleteVolume, ListDir, ListVolumes, NoisyRequestQueue, RequestQueue,
+    Upload
 )
 from ubuntuone.syncdaemon.event_queue import EventQueue, EVENTS
 from ubuntuone.syncdaemon.volume_manager import UDF
@@ -60,6 +61,19 @@
 NODE = uuid.UUID('FEDCBA98-7654-3211-2345-6789ABCDEF12')
 USER = u'Dude'
 
+def fire_and_check(f, deferred, check):
+    """Callback a deferred."""
+    @wraps(f)
+    def inner(*args, **kwargs):
+        """Execute f and fire the deferred."""
+        result = f(*args, **kwargs)
+        error = check()
+        if not error:
+            deferred.callback(True)
+        else:
+            deferred.errback(error)
+        return result
+    return inner
 
 class FakeCommand(object):
     """Yet another fake action queue command."""
@@ -73,31 +87,83 @@
         return True
 
 
+class FakedEventQueue(EventQueue):
+    """Faked event queue."""
+
+    def __init__(self, fs=None):
+        """Initialize a faked event queue."""
+        super(FakedEventQueue, self).__init__(fs=fs)
+        self.events = []
+
+    def push(self, event_name, *args, **kwargs):
+        """Faked event pushing."""
+        self.events.append((event_name, args, kwargs))
+        super(FakedEventQueue, self).push(event_name, *args, **kwargs)
+
+
+class FakedVolume(object):
+    """Faked volume."""
+
+
+class TestingProtocol(ActionQueue.protocol):
+    """Protocol for testing."""
+
+    def connectionMade(self):
+        """connectionMade."""
+        ActionQueue.protocol.connectionMade(self)
+        # proper event is pushed
+        expected = [('SYS_CONNECTION_MADE', (), {})]
+        actual = self.factory.event_queue.events
+        assert expected == actual, \
+               'events must be %s not %s' % (expected, actual)
+
+        self.factory.event_queue.events = [] # reset events
+        self.testing_deferred.callback(True)
+
+
 class BasicTestCase(BaseTwistedTestCase):
     """Basic tests to check ActionQueue."""
 
     def setUp(self):
-        """
-        prepare to run the test
-        """
+        """Init."""
         BaseTwistedTestCase.setUp(self)
+
         self.root = self.mktemp('root')
+        self.home = self.mktemp('home')
+        self.data = self.mktemp('data')
         self.shares = self.mktemp('shares')
-        self.data = self.mktemp('data')
         self.partials = self.mktemp('partials')
-        self.handler = MementoHandler()
-        self.handler.setLevel(logging.ERROR)
+
         self.main = Main(root_dir=self.root,
                          shares_dir=self.shares,
                          data_dir=self.data,
                          partials_dir=self.partials,
-                         host='localhost', port=0,
+                         host='127.0.0.1', port=55555,
                          dns_srv=False, ssl=False,
                          disable_ssl_verify=True,
                          realm='fake.realm',
                          mark_interval=60,
                          handshake_timeout=2,
                          glib_loop=DBusGMainLoop(set_as_default=True))
+
+        self.action_queue = self.main.action_q
+        self.action_queue.connection_timeout=3
+        self.action_queue.event_queue.events = []
+
+        def keep_a_copy(f):
+            """Keep a copy of the pushed events."""
+            @wraps(f)
+            def recording(event_name, *args, **kwargs):
+                """Keep a copy of the pushed events."""
+                value = (event_name, args, kwargs)
+                self.action_queue.event_queue.events.append(value)
+                return f(event_name, *args, **kwargs)
+            return recording
+
+        self.main.event_q.push = keep_a_copy(self.main.event_q.push)
+
+        self.handler = MementoHandler()
+        self.handler.setLevel(logging.ERROR)
         logging.getLogger('ubuntuone.SyncDaemon').addHandler(self.handler)
 
         # fake local rescan call to not be executed
@@ -106,25 +172,24 @@
         dbus.service.BusName.__del__ = lambda _: None
 
     def tearDown(self):
-        """
-        cleanup after the test
-        """
+        """Cleanup."""
         self.main.shutdown()
+
         shutil.rmtree(self.root)
         shutil.rmtree(self.shares)
         shutil.rmtree(self.data)
         shutil.rmtree(self.partials)
+
         for record in self.handler.records:
             exc_info = getattr(record, 'exc_info', None)
             if exc_info is not None:
                 raise exc_info[0], exc_info[1], exc_info[2]
+
         BaseTwistedTestCase.tearDown(self)
 
     def test_creation_requires_main(self):
         """Main instance is needed at creation time."""
-        aq = ActionQueue(event_queue=FakedEventQueue(), main=self.main,
-                         host='localhost', port=0, dns_srv=False)
-        self.assertEquals(self.main, aq.main)
+        self.assertEquals(self.main, self.action_queue.main)
 
     def test_content_queue_has_only_one_op_per_node(self):
         """
@@ -198,82 +263,32 @@
                                 ])
 
 
-class FactoryBaseTestCase(unittest.TestCase):
-    """Helper for by-pass Twisted."""
-
-    def setUp(self):
-        """Init."""
-        self.factory = ActionQueue(event_queue=FakedEventQueue(), main=None,
-                                   host='localhost', port=0, dns_srv=False)
-        self.factory.connector = DummyClass()
-
-        self.client = self.factory.protocol()
-        self.client.factory = self.factory
-        self.client.transport = DummyClass()
-        self.client.connectionMade() # simulate connection
-
-        self.factory.event_queue.events = [] # reset events
-
-    def tearDown(self):
-        """Clean up."""
-        self.factory = None
-
-
-class FakedEventQueue(EventQueue):
-    """Faked event queue."""
-
-    def __init__(self):
-        """Initialize a faked event queue."""
-        # pylint: disable-msg=W0231
-        self._listeners = []
-        self.events = []
-
-    def push(self, event_name, *args, **kwargs):
-        """Faked event pushing."""
-        self.events.append((event_name, args, kwargs))
-
-
-class FakedVolume(object):
-    """Faked volume."""
-
-
-class TestingProtocol(ActionQueue.protocol):
-    """Protocol for testing."""
-
-    def connectionMade(self):
-        """connectionMade."""
-        ActionQueue.protocol.connectionMade(self)
-        # proper event is pushed
-        assert [('SYS_CONNECTION_MADE', (), {})] == \
-               self.factory.event_queue.events
-
-        self.factory.event_queue.events = [] # reset events
-        self.testing_deferred.callback(True)
-
-    def connectionLost(self, reason):
-        """Handle to avoid Failures as test results."""
-
-
-class FactoryBaseTestCase(TwistedTestCase): #unittest.TestCase):
-    """Helper for by-pass Twisted."""
-
-    timeout = 2
+class FactoryBaseTestCase(BaseTwistedTestCase):
+    """Helper for by-pass Twisted."""
+
+    timeout = 5
 
     def _start_sample_webserver(self):
         """Start a web server serving content at its root"""
         website = server.Site(None)
         webport = reactor.listenTCP(55555, website)
+
+        transport_class = webport.transport
+        def save_an_instance(skt, protocol, addr, sself, s, sreactor):
+            self.server_transport = transport_class(skt, protocol, addr, sself,
+                                                    s, sreactor)
+            return self.server_transport
+        webport.transport = save_an_instance
+
         self.addCleanup(webport.stopListening)
-        ##server_str = "http://localhost:%d/" % (webport.getHost().port)
-        ##print '\n===== (fake) server listening at %s' % server_str
         return webport
 
     def _connect_factory(self):
         """Connect the instance factory."""
         self.server = self._start_sample_webserver()
 
-        self.factory.protocol = TestingProtocol
-        orig = self.factory.buildProtocol
+        self.action_queue.protocol = TestingProtocol
+        orig = self.action_queue.buildProtocol
 
         d = defer.Deferred()
         def faked_buildProtocol(*args, **kwargs):
@@ -282,15 +297,15 @@
             protocol.testing_deferred = d
             return protocol
 
-        self.factory.buildProtocol = faked_buildProtocol
-        self.factory.connect()
+        self.action_queue.buildProtocol = faked_buildProtocol
+        self.action_queue.connect()
 
         return d
 
     def _disconnect_factory(self):
         """Disconnect the instance factory."""
-        if self.factory.client is not None:
-            orig = self.factory.client.connectionLost
+        if self.action_queue.client is not None:
+            orig = self.action_queue.client.connectionLost
 
             d = defer.Deferred()
             def faked_connectionLost(reason):
@@ -298,39 +313,39 @@
                 orig(reason)
                 d.callback(True)
 
-            self.factory.client.connectionLost = faked_connectionLost
+            self.action_queue.client.connectionLost = faked_connectionLost
         else:
             d = defer.succeed(True)
 
-        if self.factory.connect_in_progress:
-            self.factory.disconnect()
+        if self.action_queue.connect_in_progress:
+            self.action_queue.disconnect()
 
         return d
 
     def setUp(self):
         """Init."""
-        TwistedTestCase.setUp(self)
+        BaseTwistedTestCase.setUp(self)
 
         kwargs = dict(event_queue=FakedEventQueue(), main=None,
-                      host='127.0.0.1', port=55555, dns_srv=False)
-        self.factory = ActionQueue(**kwargs)
+                      host='127.0.0.1', port=55555, dns_srv=False,
+                      connection_timeout=3)
+        self.action_queue = ActionQueue(**kwargs)
 
     def tearDown(self):
         """Clean up."""
-        self.factory = None
-        TwistedTestCase.tearDown(self)
+        self.action_queue.event_queue.shutdown()
+        self.action_queue = None
+        BaseTwistedTestCase.tearDown(self)
 
 
 class ConnectionTestCase(FactoryBaseTestCase):
     """Test TCP/SSL connection mechanism for ActionQueue."""
 
-    timeout = 3
-
     def assert_connection_state_reset(self):
         """Test connection state is properly reset."""
-        self.assertTrue(self.factory.client is None)
-        self.assertTrue(self.factory.connector is None)
-        self.assertEquals(False, self.factory.connect_in_progress)
+        self.assertTrue(self.action_queue.client is None)
+        self.assertTrue(self.action_queue.connector is None)
+        self.assertEquals(False, self.action_queue.connect_in_progress)
 
     def test_init(self):
         """Test connection init state."""
@@ -341,25 +356,25 @@
         """Test that double connections are avoided."""
         yield self._connect_factory()
 
-        assert self.factory.connector is not None
-        assert self.factory.connect_in_progress == True
+        assert self.action_queue.connector is not None
+        assert self.action_queue.connect_in_progress == True
         # double connect, it returns None instead of a Deferred
-        result = self.factory.connect()
+        result = self.action_queue.connect()
         self.assertTrue(result is None, 'not connecting again')
 
         yield self._disconnect_factory()
 
     @defer.inlineCallbacks
     def test_disconnect_if_connected(self):
-        """self.factory.connector.disconnect was called."""
+        """self.action_queue.connector.disconnect was called."""
         yield self._connect_factory()
 
-        self.factory.event_queue.events = [] # cleanup events
-        assert self.factory.connector.state == 'connected'
-        self.factory.disconnect()
+        self.action_queue.event_queue.events = [] # cleanup events
+        assert self.action_queue.connector.state == 'connected'
+        self.action_queue.disconnect()
 
         self.assert_connection_state_reset()
-        self.assertEquals([], self.factory.event_queue.events)
+        self.assertEquals([], self.action_queue.event_queue.events)
 
         yield self._disconnect_factory()
 
@@ -368,32 +383,31 @@
         """Test clientConnectionFailed.
 
         The connection will not be completed since the server will be down.
-        So, self.factory.connector will never leave the 'connecting' state.
+        So, self.action_queue.connector will never leave the 'connecting' state.
         When interrupting the connection attempt, twisted automatically calls
-        self.factory.clientConnectionFailed.
+        self.action_queue.clientConnectionFailed.
 
         """
-
-        self.factory.event_queue.events = []
-        orig = self.factory.clientConnectionFailed
+        self.action_queue.event_queue.events = []
+        orig = self.action_queue.clientConnectionFailed
 
         d = defer.Deferred()
         def faked_clientConnectionFailed(connector, reason):
             """Receive connection failed and check."""
-            self.factory.deferred.errback = lambda _: None
+            self.action_queue.deferred.errback = lambda _: None
             orig(connector, reason)
             self.assert_connection_state_reset()
             self.assertEquals([('SYS_CONNECTION_FAILED', (), {})],
-                              self.factory.event_queue.events)
-            self.factory.clientConnectionFailed = orig
+                              self.action_queue.event_queue.events)
+            self.action_queue.clientConnectionFailed = orig
             d.callback(True)
 
-        self.factory.clientConnectionFailed = faked_clientConnectionFailed
+        self.action_queue.clientConnectionFailed = faked_clientConnectionFailed
         # factory will never finish the connection, server was never started
-        self.factory.connect()
+        self.action_queue.connect()
         # stopConnecting() will be called since the connection is in progress
-        assert self.factory.connector.state == 'connecting'
-        self.factory.connector.disconnect()
+        assert self.action_queue.connector.state == 'connecting'
+        self.action_queue.connector.disconnect()
 
         yield d
 
@@ -402,16 +416,15 @@
         """Test clientConnectionLost
 
         The connection will be completed successfully.
-        So, self.factory.connector will be in the 'connected' state.
+        So, self.action_queue.connector will be in the 'connected' state.
         When disconnecting the connector, twisted automatically calls
-        self.factory.clientConnectionLost.
+        self.action_queue.clientConnectionLost.
 
         """
-
         yield self._connect_factory()
 
-        self.factory.event_queue.events = []
-        orig = self.factory.clientConnectionLost
+        self.action_queue.event_queue.events = []
+        orig = self.action_queue.clientConnectionLost
 
         d = defer.Deferred()
         def faked_clientConnectionLost(connector, reason):
@@ -419,65 +432,231 @@
             orig(connector, reason)
             self.assert_connection_state_reset()
             self.assertEquals([('SYS_CONNECTION_LOST', (), {})],
-                              self.factory.event_queue.events)
-            self.factory.clientConnectionLost = orig
+                              self.action_queue.event_queue.events)
+            self.action_queue.clientConnectionLost = orig
             d.callback(True)
 
-        self.factory.clientConnectionLost = faked_clientConnectionLost
+        self.action_queue.clientConnectionLost = faked_clientConnectionLost
         # loseConnection() will be called since the connection was completed
-        assert self.factory.connector.state == 'connected'
-        self.factory.connector.disconnect()
-        yield d
-
+        assert self.action_queue.connector.state == 'connected'
+        self.action_queue.connector.disconnect()
+        yield d
+
+        yield self._disconnect_factory()
+
+    @defer.inlineCallbacks
+    def test_server_disconnect(self):
+        """Test factory's connection when the server goes down."""
+
+        yield self._connect_factory()
+
+        self.action_queue.event_queue.events = []
+        orig = self.action_queue.clientConnectionLost
+
+        d = defer.Deferred()
+        def faked_connectionLost(*args, **kwargs):
+            """Receive connection lost and check."""
+            orig(*args, **kwargs)
+            self.assert_connection_state_reset()
+            self.assertEquals([('SYS_CONNECTION_LOST', (), {})],
+                              self.action_queue.event_queue.events)
+            self.action_queue.clientConnectionLost = orig
+            d.callback(True)
+
+        self.action_queue.clientConnectionLost = faked_connectionLost
+        # simulate a server failure!
+        yield self.server_transport.loseConnection()
+        yield d
         yield self._disconnect_factory()
 
     def test_buildProtocol(self):
         """Test buildProtocol."""
-        protocol = self.factory.buildProtocol(addr=None)
-        self.assertTrue(protocol is self.factory.client)
-        self.assertTrue(self.factory is self.factory.client.factory)
+        protocol = self.action_queue.buildProtocol(addr=None)
+        self.assertTrue(protocol is self.action_queue.client)
+        self.assertTrue(self.action_queue is self.action_queue.client.factory)
 
         # callbacks are connected
         # pylint: disable-msg=W0212
-        self.assertEquals(self.factory.client._node_state_callback,
-                          self.factory._node_state_callback)
-        self.assertEquals(self.factory.client._share_change_callback,
-                          self.factory._share_change_callback)
-        self.assertEquals(self.factory.client._share_answer_callback,
-                          self.factory._share_answer_callback)
-        self.assertEquals(self.factory.client._free_space_callback,
-                          self.factory._free_space_callback)
-        self.assertEquals(self.factory.client._account_info_callback,
-                          self.factory._account_info_callback)
-        self.assertEquals(self.factory.client._volume_created_callback,
-                          self.factory._volume_created_callback)
-        self.assertEquals(self.factory.client._volume_deleted_callback,
-                          self.factory._volume_deleted_callback)
+        self.assertEquals(self.action_queue.client._node_state_callback,
+                          self.action_queue._node_state_callback)
+        self.assertEquals(self.action_queue.client._share_change_callback,
+                          self.action_queue._share_change_callback)
+        self.assertEquals(self.action_queue.client._share_answer_callback,
+                          self.action_queue._share_answer_callback)
+        self.assertEquals(self.action_queue.client._free_space_callback,
+                          self.action_queue._free_space_callback)
+        self.assertEquals(self.action_queue.client._account_info_callback,
+                          self.action_queue._account_info_callback)
+        self.assertEquals(self.action_queue.client._volume_created_callback,
+                          self.action_queue._volume_created_callback)
+        self.assertEquals(self.action_queue.client._volume_deleted_callback,
+                          self.action_queue._volume_deleted_callback)
 
     @defer.inlineCallbacks
     def test_connector_gets_assigned_on_connect(self):
         """Test factory's connector gets assigned on connect."""
         yield self._connect_factory()
 
-        self.assertTrue(self.factory.connector is not None)
-
-        yield self._disconnect_factory()
+        self.assertTrue(self.action_queue.connector is not None)
+
+        yield self._disconnect_factory()
+
+    @defer.inlineCallbacks
+    def test_cleanup_doesnt_disconnect(self):
+        """cleanup() doesn't disconnect the factory."""
+        yield self._connect_factory()
+
+        self.action_queue.cleanup()
+        self.assertTrue(self.action_queue.connector is not None)
+        self.assertEquals(self.action_queue.connector.state, 'connected')
+
+        yield self._disconnect_factory()
+
+
+class NetworkmanagerTestCase(BasicTestCase, FactoryBaseTestCase):
+    """Base test case generating a connected factory."""
+
+    timeout = 15
+
+    def fake_answer(self, answer):
+        """Push an event faking a server answer."""
+        return (lambda *_: self.action_queue.event_queue.push(answer))
+
+    def setUp(self):
+        """Init."""
+        BasicTestCase.setUp(self)
+
+        self.action_queue.local_rescan = \
+            self.fake_answer('SYS_LOCAL_RESCAN_DONE')
+        self.action_queue.check_version = \
+            self.fake_answer('SYS_PROTOCOL_VERSION_OK')
+        self.action_queue.set_capabilities = \
+            self.fake_answer('SYS_SET_CAPABILITIES_OK')
+        self.action_queue.authenticate = \
+            self.fake_answer('SYS_AUTH_OK')
+        self.action_queue.server_rescan = \
+            self.fake_answer('SYS_SERVER_RESCAN_DONE')
+
+        self.main.start()
+
+    def tearDown(self):
+        """Clean up."""
+        BasicTestCase.tearDown(self)
+
+    @defer.inlineCallbacks
+    def test_wrong_disconnect(self):
+        """Test factory's connection when SYS_NET_DISCONNECTED."""
+
+        d1 = self.main.wait_for('SYS_CONNECTION_MADE')
+        d2 = self.main.wait_for('SYS_CONNECTION_LOST')
+
+        self.server = self._start_sample_webserver()
+        self.action_queue.event_queue.push('SYS_USER_CONNECT',
+                                            access_token='ble')
+        yield d1
+
+        self.action_queue.event_queue.push('SYS_NET_DISCONNECTED')
+        yield d2
+
+    @defer.inlineCallbacks
+    def test_disconnect_twice(self):
+        """Test connection when SYS_NET_DISCONNECTED is received twice."""
+
+        d1 = self.main.wait_for('SYS_CONNECTION_MADE')
+        d2 = self.main.wait_for('SYS_CONNECTION_LOST')
+
+        self.server = self._start_sample_webserver()
+
+        self.action_queue.event_queue.push('SYS_USER_CONNECT',
+                                           access_token='ble')
+        yield d1
+
+        self.action_queue.event_queue.push('SYS_NET_DISCONNECTED')
+        yield d2
+
+        self.action_queue.event_queue.events = []
+        self.action_queue.event_queue.push('SYS_NET_DISCONNECTED')
+        self.assertEquals([('SYS_NET_DISCONNECTED', (), {})],
+                          self.action_queue.event_queue.events,
+                       'No new events after a missplaced SYS_NET_DISCONNECTED')
+
+
+    @defer.inlineCallbacks
+    def test_net_connected_if_already_connected(self):
+        """Test connection when SYS_NET_CONNECTED is received twice."""
+
+        d1 = self.main.wait_for('SYS_CONNECTION_MADE')
+
+        self.server = self._start_sample_webserver()
+
+        self.action_queue.event_queue.push('SYS_USER_CONNECT',
+                                           access_token='ble')
+        yield d1
+
+        self.action_queue.event_queue.events = []
+        self.action_queue.event_queue.push('SYS_NET_CONNECTED')
+        self.assertEquals([('SYS_NET_CONNECTED', (), {})],
+                          self.action_queue.event_queue.events,
+                          'No new events after a missplaced SYS_NET_CONNECTED')
+
+    @defer.inlineCallbacks
+    def test_messy_mix(self):
+        """Test connection when a messy mix of events is received."""
+        orig_waiting = states.MAX_WAITING
+        states.MAX_WAITING = 1
+
+        self.action_queue.event_queue.events = []
+        self.server = self._start_sample_webserver()
+
+        conn_made = self.main.wait_for('SYS_CONNECTION_MADE')
+        self.action_queue.event_queue.push('SYS_USER_CONNECT',
+                                           access_token='ble')
+        yield conn_made
+
+        events = ['SYS_NET_CONNECTED', 'SYS_NET_DISCONNECTED',
+                  'SYS_NET_CONNECTED', 'SYS_NET_CONNECTED',
+                  'SYS_NET_DISCONNECTED', 'SYS_NET_DISCONNECTED',
+                  'SYS_NET_CONNECTED']
+
+        for i in events:
+            self.action_queue.event_queue.push(i)
+
+        yield self.main.wait_for_nirvana()
+
+        expected = ['SYS_NET_CONNECTED', # from the DBus fake NetworkManager
+                    'SYS_USER_CONNECT', 'SYS_CONNECTION_MADE',
+                    'SYS_NET_CONNECTED', 'SYS_NET_DISCONNECTED',
+                    'SYS_CONNECTION_LOST', 'SYS_CONNECTION_RETRY',
+                    'SYS_NET_CONNECTED', 'SYS_NET_CONNECTED',
+                    'SYS_CONNECTION_MADE', 'SYS_NET_DISCONNECTED',
+                    'SYS_NET_DISCONNECTED']
+
+        avoid = ('SYS_STATE_CHANGED', 'SYS_LOCAL_RESCAN_DONE',
+                 'SYS_PROTOCOL_VERSION_OK', 'SYS_SET_CAPABILITIES_OK',
+                 'SYS_AUTH_OK', 'SYS_SERVER_RESCAN_DONE')
+        actual = [event for (event, args, kwargs) in
+                  self.action_queue.event_queue.events
+                  if event not in avoid]
+        self.assertEquals(sorted(expected), sorted(actual))
+
+        states.MAX_WAITING = orig_waiting
 
 
 class ConnectedBaseTestCase(FactoryBaseTestCase):
     """Base test case generating a connected factory."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Init."""
         FactoryBaseTestCase.setUp(self)
-        d = self._connect_factory()
-        return d
+        yield self._connect_factory()
+        assert self.action_queue.connector.state == 'connected'
 
+    @defer.inlineCallbacks
     def tearDown(self):
         """Clean up."""
-        d = self._disconnect_factory()
+        yield self._disconnect_factory()
         FactoryBaseTestCase.tearDown(self)
-        return d
 
 
 class VolumeManagementTestCase(ConnectedBaseTestCase):
@@ -486,16 +665,16 @@
     def test_volume_created_push_event(self):
         """Volume created callback push proper event."""
         volume = FakedVolume()
-        self.factory._volume_created_callback(volume)
+        self.action_queue._volume_created_callback(volume)
         self.assertEquals([('SV_VOLUME_CREATED', (), {'volume': volume})],
-                          self.factory.event_queue.events)
+                          self.action_queue.event_queue.events)
 
     def test_volume_deleted_push_event(self):
         """Volume deleted callback push proper event."""
         volume_id = VOLUME
-        self.factory._volume_deleted_callback(volume_id)
+        self.action_queue._volume_deleted_callback(volume_id)
         self.assertEquals([('SV_VOLUME_DELETED', (), {'volume_id': volume_id})],
-                          self.factory.event_queue.events)
+                          self.action_queue.event_queue.events)
 
     def test_valid_events(self):
         """Volume events are valid in EventQueue."""
@@ -520,18 +699,18 @@
         """Test volume creation."""
         path = PATH
         name = NAME
-        res = self.factory.create_udf(path, name, marker=None)
+        res = self.action_queue.create_udf(path, name, marker=None)
         self.assertTrue(res is None) # this is what start returns
 
     def test_list_volumes(self):
         """Test volume listing."""
-        res = self.factory.list_volumes()
+        res = self.action_queue.list_volumes()
         self.assertTrue(res is None) # this is what start returns
 
     def test_delete_volume(self):
         """Test volume deletion."""
         volume_id = VOLUME
-        res = self.factory.delete_volume(volume_id)
+        res = self.action_queue.delete_volume(volume_id)
         self.assertTrue(res is None) # this is what start returns
 
 
@@ -542,7 +721,7 @@
         """Init."""
         res = super(CreateUDFTestCase, self).setUp()
 
-        request_queue = RequestQueue(name='foo', action_queue=self.factory)
+        request_queue = RequestQueue(name='foo', action_queue=self.action_queue)
         self.marker = VOLUME
         self.command = CreateUDF(request_queue, PATH, NAME, marker=self.marker)
 
@@ -584,7 +763,7 @@
 
     def test_handle_success_push_event(self):
         """Test AQ_CREATE_UDF_OK is pushed on success."""
-        request = client.CreateUDF(self.factory.client, PATH, NAME)
+        request = client.CreateUDF(self.action_queue.client, PATH, NAME)
         request.volume_id = VOLUME
         request.node_id = NODE
         res = self.command.handle_success(success=request)
@@ -612,7 +791,7 @@
         """Init."""
         res = super(ListVolumesTestCase, self).setUp()
 
-        request_queue = RequestQueue(name='foo', action_queue=self.factory)
+        request_queue = RequestQueue(name='foo', action_queue=self.action_queue)
         self.command = ListVolumes(request_queue)
 
         return res
@@ -645,7 +824,7 @@
 
     def test_handle_success_push_event(self):
         """Test AQ_LIST_VOLUMES is pushed on success."""
-        request = client.ListVolumes(self.factory.client)
+        request = client.ListVolumes(self.action_queue.client)
         request.volumes = [FakedVolume(), FakedVolume()]
         res = self.command.handle_success(success=request)
         events = [('AQ_LIST_VOLUMES', (), {'volumes': request.volumes})]
@@ -669,7 +848,7 @@
         """Init."""
         res = super(DeleteVolumeTestCase, self).setUp()
 
-        request_queue = RequestQueue(name='foo', action_queue=self.factory)
+        request_queue = RequestQueue(name='foo', action_queue=self.action_queue)
         self.command = DeleteVolume(request_queue, VOLUME)
 
         return res
@@ -707,7 +886,7 @@
 
     def test_handle_success_push_event(self):
         """Test AQ_DELETE_VOLUME_OK is pushed on success."""
-        request = client.DeleteVolume(self.factory.client, volume_id=VOLUME)
+        request = client.DeleteVolume(self.action_queue.client, volume_id=VOLUME)
         res = self.command.handle_success(success=request)
         events = [('AQ_DELETE_VOLUME_OK', (), {'volume_id': VOLUME})]
         self.assertEquals(events, self.command.action_queue.event_queue.events)
@@ -723,47 +902,24 @@
         self.assertTrue(res is None)
 
 
-class FilterEventsTestCase(BaseTwistedTestCase):
+class FilterEventsTestCase(BasicTestCase):
     """Tests for event filtering when a volume is not of our interest."""
 
     def setUp(self):
         """Init."""
-        BaseTwistedTestCase.setUp(self)
-        self.log = logging.getLogger("ubuntuone.SyncDaemon.TEST")
-        self.log.info("starting test %s.%s", self.__class__.__name__,
-                      self._testMethodName)
-        self.root_dir = self.mktemp('root_dir')
-        self.home_dir = self.mktemp('home_dir')
-        self.data_dir = self.mktemp('data_dir')
-        self.shares_dir = self.mktemp('shares_dir')
-        self.partials_dir = self.mktemp('partials_dir')
-        self.main = FakeMain(self.root_dir, self.shares_dir,
-                             self.data_dir, self.partials_dir)
+        BasicTestCase.setUp(self)
         self.vm = self.main.vm
-
-        self.action_queue = ActionQueue(FakedEventQueue(), self.main,
-                                        host='localhost', port=0,
-                                        dns_srv=False)
         self.old_home = os.environ.get('HOME', None)
-        os.environ['HOME'] = self.home_dir
-
+        os.environ['HOME'] = self.home
 
     def tearDown(self):
         """Clean up."""
-        self.action_queue = None
-
-        self.main.shutdown()
-        self.rmtree(self.root_dir)
-        self.rmtree(self.data_dir)
-        self.rmtree(self.shares_dir)
-        self.log.info("finished test %s.%s", self.__class__.__name__,
-                      self._testMethodName)
         if self.old_home is None:
             os.environ.pop('HOME')
         else:
             os.environ['HOME'] = self.old_home
 
-        return BaseTwistedTestCase.tearDown(self)
+        BasicTestCase.tearDown(self)
 
     @defer.inlineCallbacks
     def test_SV_HASH_NEW_is_pushed_for_subscrined_volume(self):
@@ -776,8 +932,9 @@
         yield self.vm.add_udf(udf)
         yield self.vm.subscribe_udf(udf_id)
         assert self.vm.udfs[udf_id].subscribed
+        self.action_queue.event_queue.events = [] # reset events
 
-        kwargs = dict(share_id=udf_id, node_id=None, hash=None)
+        kwargs = dict(share_id=udf_id, node_id=NODE, hash=None)
         self.action_queue._node_state_callback(**kwargs)
         self.assertEquals([('SV_HASH_NEW', (), kwargs)],
                            self.action_queue.event_queue.events)
@@ -794,6 +951,7 @@
         yield self.vm.add_udf(udf)
         yield self.vm.unsubscribe_udf(udf_id)
         assert not self.vm.udfs[udf_id].subscribed
+        self.action_queue.event_queue.events = [] # reset events
 
         self.action_queue._node_state_callback(share_id=udf_id,
                                                node_id=None, hash=None)
@@ -803,8 +961,9 @@
         """SV_HASH_NEW keeps working like before for non-udfs."""
         other_id = 'not in udfs'
         assert other_id not in self.vm.udfs
+        self.action_queue.event_queue.events = [] # reset events
 
-        kwargs = dict(share_id=other_id, node_id=None, hash=None)
+        kwargs = dict(share_id=other_id, node_id=NODE, hash=None)
         self.action_queue._node_state_callback(**kwargs)
         self.assertEquals([('SV_HASH_NEW', (), kwargs)],
                           self.action_queue.event_queue.events)
@@ -815,12 +974,12 @@
 
     def setUp(self):
         super(ChangePublicAccessTests, self).setUp()
-        request_queue = RequestQueue(name='foo', action_queue=self.factory)
+        request_queue = RequestQueue(name='foo', action_queue=self.action_queue)
         self.command = ChangePublicAccess(request_queue, VOLUME, NODE, True)
 
     def test_change_public_access(self):
         """Test the change_public_access method.."""
-        res = self.factory.change_public_access(VOLUME, NODE, True)
+        res = self.action_queue.change_public_access(VOLUME, NODE, True)
         self.assertTrue(res is None) # this is what start returns
 
     def test_is_action_queue_command(self):
@@ -905,11 +1064,11 @@
         """Init."""
         res = super(ListDirTestCase, self).setUp()
 
-        request_queue = RequestQueue(name='FOO', action_queue=self.factory)
+        request_queue = RequestQueue(name='FOO', action_queue=self.action_queue)
         self.command = ListDir(request_queue, share_id='a_share_id',
                                node_id='a_node_id', server_hash='a_server_hash',
                                fileobj_factory=lambda: None)
-        self.command.start_unqueued()
+        self.command.start_unqueued() # create the logger
 
         return res
 
@@ -963,18 +1122,79 @@
         self.assertEquals(('share_id', 'node_id'), EVENTS[event])
 
 
+class UploadTestCase(ConnectedBaseTestCase):
+    """Test for Upload ActionQueueCommand."""
+
+    def setUp(self):
+        """Init."""
+        res = super(UploadTestCase, self).setUp()
+
+        request_queue = RequestQueue(name='FOO', action_queue=self.action_queue)
+        self.command = Upload(request_queue, share_id='a_share_id',
+                              node_id='a_node_id', previous_hash='prev_hash',
+                              hash='yadda', crc32=0, size=0,
+                              fileobj_factory=lambda: None,
+                              tempfile_factory=lambda: None)
+        self.command.start_unqueued() # create the logger
+
+        return res
+
+    def test_handle_success_push_event(self):
+        """Test AQ_UPLOAD_FINISHED is pushed on success."""
+        self.command.handle_success(None)
+        kwargs = dict(share_id='a_share_id', node_id='a_node_id', hash='yadda')
+        events = [('AQ_UPLOAD_FINISHED', (), kwargs)]
+        self.assertEquals(events, self.command.action_queue.event_queue.events)
+
+    def test_handle_failure_push_event(self):
+        """Test AQ_UPLOAD_ERROR is pushed on failure."""
+        msg = 'Something went wrong'
+        failure = Failure(DefaultException(msg))
+        res = self.command.handle_failure(failure=failure)
+        kwargs = dict(share_id='a_share_id', node_id='a_node_id',
+                      hash='yadda', error=msg)
+        events = [('AQ_UPLOAD_ERROR', (), kwargs)]
+        self.assertEquals(events, self.command.action_queue.event_queue.events)
+        self.assertTrue(res is None)
+
+    def test_handle_failure_removes_temp_file(self):
+        """Test temp file is removed on failure."""
+        class TempFile(object): pass
+        self.command.tempfile = TempFile()
+        self.command.tempfile.name = os.path.join(self.tmpdir, 'remove-me.zip')
+        open(self.command.tempfile.name, 'w').close()
+        assert os.path.exists(self.command.tempfile.name)
+
+        msg = 'Something went wrong'
+        failure = Failure(DefaultException(msg))
+        self.command.handle_failure(failure=failure)
+
+        self.assertFalse(os.path.exists(self.command.tempfile.name))
+
+    @defer.inlineCallbacks
+    def test_compress_failed_pushes_upload_error(self):
+        msg = 'Zip can not be accomplished.'
+        error = DefaultException(msg)
+        self.action_queue.zip_queue.zip = lambda upload: defer.fail(error)
+        yield self.command.run()
+        kwargs = dict(share_id='a_share_id', node_id='a_node_id',
+                      hash='yadda', error=msg)
+        events = [('AQ_UPLOAD_ERROR', (), kwargs)]
+        self.assertEquals(events, self.command.action_queue.event_queue.events)
+
+
 class RequestQueueManager(FactoryBaseTestCase):
     """Test how RequestQueue manages the queues."""
 
     def setUp(self):
         FactoryBaseTestCase.setUp(self)
 
-        self.queue = self.factory.meta_queue
+        self.queue = self.action_queue.meta_queue
         self.cmd = FakeCommand()
 
     def _events(self):
         """Helper method to see only the events."""
-        return [x[0] for x in self.factory.event_queue.events]
+        return [x[0] for x in self.action_queue.event_queue.events]
 
     def test_empty_gets_one(self):
         """Queue and get the event."""
@@ -1050,3 +1270,29 @@
         self.assertEqual(len(self.queue), 1)
         yield self.queue.run()
         self.assertEqual(len(self.queue), 0)
+
+
+class SimpleAQTestCase(BasicTestCase):
+    """Simple tests for AQ API."""
+
+    def test_aq_server_rescan(self):
+        """Check the API of AQ.server_rescan."""
+        self.main.start()
+        d = defer.Deferred()
+        def get_root(mdid):
+            """Fake get_root."""
+            d.callback(mdid)
+
+        class FakeClient(object):
+            """Fake Client"""
+            def __getattribute__(self, attr):
+                """Return a noop."""
+                return lambda *args, **kwargs: None
+
+        self.action_queue.client = FakeClient()
+        self.action_queue.get_root = get_root
+        self.action_queue.server_rescan('foo', lambda: list())
+        def check(result):
+            self.assertEquals('foo', result)
+        d.addCallback(check)
+        return d

=== modified file 'tests/syncdaemon/test_action_queue.pyc'
Binary files tests/syncdaemon/test_action_queue.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_action_queue.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_config.pyc'
Binary files tests/syncdaemon/test_config.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_config.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_dbus.py'
--- tests/syncdaemon/test_dbus.py	2010-03-04 16:47:43 +0000
+++ tests/syncdaemon/test_dbus.py	2010-03-10 23:53:15 +0000
@@ -63,6 +63,12 @@
         """Just succeed."""
         return defer.succeed(None)
 
+    def __str__(self):
+        name = self.__class__.__name__
+        tmpl = name + "(" + "share_id=%s, node_id=%s" + ")"
+        return tmpl % (self.share_id,
+                       self.node_id)
+
 
 class DBusInterfaceTests(DBusTwistedTestCase):
     """ Basic tests to the objects exposed with D-Bus"""
@@ -253,6 +259,31 @@
                            error_handler=self.error_handler)
         return d
 
+    def test_waiting_metadata(self):
+        """Test Status.waiting_metadata with fake data in the AQ."""
+        # inject the fake data
+        self.action_q.meta_queue.waiting.extend([
+                FakeCommand("node_a_foo", "node_a_bar"),
+                FakeCommand("node_b_foo", "node_b_bar")])
+        # OK, testing time
+        client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
+        d = defer.Deferred()
+        def waiting_handler(result):
+            """waiting_metadata reply handler."""
+            self.assertEquals(2, len(result))
+            # the second time we're called, the result should be reversed
+            node_a, node_b = result
+            self.assertEquals(str(FakeCommand("node_a_foo", "node_a_bar")),
+                              node_a)
+            self.assertEquals(str(FakeCommand("node_b_foo", "node_b_bar")),
+                              node_b)
+            d.callback(True)
+        client.call_method('waiting_metadata',
+                           reply_handler=waiting_handler,
+                           error_handler=self.error_handler)
+        return d
+
+
     def test_contq_changed(self):
         """Test the Status.ContentQueueChanged signal."""
         # prepare the VM so it lies for us
@@ -608,6 +639,37 @@
                            error_handler=self.error_handler)
         return d
 
+    def test_create_shares(self):
+        """Test share offering to multiple users at once"""
+        a_dir = os.path.join(self.root_dir, "a_dir")
+        self.fs_manager.create(a_dir, "", is_dir=True)
+        self.fs_manager.set_node_id(a_dir, "node_id")
+        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
+        d = defer.Deferred()
+        # helper functions, pylint: disable-msg=C0111
+        def fake_create_share(*result):
+            # pylint: disable-msg=W0612
+            node_id, username, name, access_level, marker = result
+            self.assertEquals('node_id', node_id)
+            mdobj = self.fs_manager.get_by_path(a_dir)
+            self.assertEquals(self.fs_manager.get_abspath("", mdobj.path),
+                              os.path.join(self.main.root_dir, a_dir))
+            self.assertEquals(u'test_user', username[:-1])
+            self.assertEquals(u'share_a_dir', name)
+            self.assertEquals('View', access_level)
+
+        self.action_q.create_share = fake_create_share
+
+        def reply_handler(result):
+            d.callback(result)
+
+        client.call_method('create_shares',
+                           a_dir, ['test_user1', 'test_user2', 'test_user3'],
+                           'share_a_dir', 'View',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
     def test_query_by_path(self):
         """ test that query_by_path method work as expected. """
         a_dir = os.path.join(self.root_dir, "a_dir")
@@ -1249,16 +1311,24 @@
                                              signal_name='PublicAccessChanged')
         self.signal_receivers.add(match)
 
-        share_id = uuid.uuid4()
-        node_id = uuid.uuid4()
+        share_id = "share"
+        node_id = "node_id"
         is_public = True
         public_url = 'http://example.com'
+
+        share_path = os.path.join(self.shares_dir, 'share')
+        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        path = os.path.join(share_path, "foo")
+        self.fs_manager.create(path, str(share_id))
+        self.fs_manager.set_node_id(path, str(node_id))
+
         def check(file_info):
             """Check the result."""
             expected_dict = dict(share_id=str(share_id),
                                  node_id=str(node_id),
                                  is_public=str(is_public),
-                                 public_url=public_url)
+                                 public_url=public_url,
+                                 path=path)
             self.assertEquals(expected_dict, file_info)
         d.addCallback(check)
         self.event_q.push('AQ_CHANGE_PUBLIC_ACCESS_OK',
@@ -1277,13 +1347,21 @@
             access_change_error_handler, signal_name='PublicAccessChangeError')
         self.signal_receivers.add(match)
 
-        share_id = uuid.uuid4()
-        node_id = uuid.uuid4()
+        share_id = "share"
+        node_id = "node_id"
         expected_error = 'error message'
+
+        share_path = os.path.join(self.shares_dir, 'share')
+        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        path = os.path.join(share_path, "foo")
+        self.fs_manager.create(path, str(share_id))
+        self.fs_manager.set_node_id(path, str(node_id))
+
         def check((file_info, error)):
             """Check the result."""
             expected_dict = dict(share_id=str(share_id),
-                                 node_id=str(node_id))
+                                 node_id=str(node_id),
+                                 path=path)
             self.assertEquals(expected_dict, file_info)
             self.assertEquals(expected_error, error)
         d.addCallback(check)
@@ -1292,6 +1370,26 @@
                           error=expected_error)
         return d
 
+    def test_root_mismatch(self):
+        """Test RootMismatch signal."""
+        d = defer.Deferred()
+        def root_mismatch_handler(root_id, new_root_id):
+            """Handler for RootMismatch signal."""
+            d.callback((root_id, new_root_id))
+
+        match = self.bus.add_signal_receiver(root_mismatch_handler,
+                                             signal_name='RootMismatch')
+        self.signal_receivers.add(match)
+
+        def check((root_id, new_root_id)):
+            """Check the result."""
+            self.assertEquals('root_id', root_id)
+            self.assertEquals('another_root_id', new_root_id)
+        d.addCallback(check)
+        self.event_q.push('SYS_ROOT_RECEIVED', 'root_id')
+        self.event_q.push('SYS_ROOT_RECEIVED', 'another_root_id')
+        return d
+
 
 class TestDBusRestart(DBusTwistedTestCase):
     """

=== modified file 'tests/syncdaemon/test_dbus.pyc'
Binary files tests/syncdaemon/test_dbus.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_dbus.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_eq_inotify.pyc'
Binary files tests/syncdaemon/test_eq_inotify.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_eq_inotify.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_eventqueue.pyc'
Binary files tests/syncdaemon/test_eventqueue.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_eventqueue.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_eventsnanny.pyc'
Binary files tests/syncdaemon/test_eventsnanny.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_eventsnanny.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_fileshelf.pyc'
Binary files tests/syncdaemon/test_fileshelf.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_fileshelf.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_fsm.pyc'
Binary files tests/syncdaemon/test_fsm.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_fsm.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_hashqueue.pyc'
Binary files tests/syncdaemon/test_hashqueue.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_hashqueue.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_localrescan.pyc'
Binary files tests/syncdaemon/test_localrescan.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_localrescan.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_logger.pyc'
Binary files tests/syncdaemon/test_logger.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_logger.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_main.pyc'
Binary files tests/syncdaemon/test_main.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_main.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_states.pyc'
Binary files tests/syncdaemon/test_states.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_states.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_sync.pyc'
Binary files tests/syncdaemon/test_sync.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_sync.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_tools.py'
--- tests/syncdaemon/test_tools.py	2010-03-04 16:47:43 +0000
+++ tests/syncdaemon/test_tools.py	2010-03-10 23:53:15 +0000
@@ -26,6 +26,7 @@
     volume_manager,
     states,
 )
+from tests.syncdaemon.test_dbus import FakeCommand
 from contrib.testing.testcase import (
     DBusTwistedTestCase,
 )
@@ -298,17 +299,26 @@
         d.addCallbacks(handler, self.fail)
         return d
 
+    def test_waiting_metadata(self):
+        """Test SyncDaemonTool.waiting_metadata."""
+        # inject the fake data
+        self.action_q.meta_queue.waiting.extend([
+                FakeCommand("node_a_foo", "node_a_bar"),
+                FakeCommand("node_b_foo", "node_b_bar")])
+        d = self.tool.waiting_metadata()
+        def check(result):
+            """waiting_metadata reply handler."""
+            self.assertEquals(2, len(result))
+            # the second time we're called, the result should be reversed
+            node_a, node_b = result
+            self.assertEquals(str(FakeCommand("node_a_foo", "node_a_bar")),
+                              node_a)
+            self.assertEquals(str(FakeCommand("node_b_foo", "node_b_bar")),
+                              node_b)
+        return d
+
     def test_waiting_content_schedule_next(self):
         """Test waiting_content and schedule_next"""
-        class FakeCommand(object):
-            """A fake command"""
-            def __init__(self, share_id, node_id):
-                """create it"""
-                self.share_id = share_id
-                self.node_id = node_id
-            def is_runnable(self):
-                """is runnable"""
-                return True
         path = os.path.join(self.root_dir, "foo")
         self.fs_manager.create(path, "")
         self.fs_manager.set_node_id(path, "node_id")

=== modified file 'tests/syncdaemon/test_tools.pyc'
Binary files tests/syncdaemon/test_tools.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_tools.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_u1fsfsm.pyc'
Binary files tests/syncdaemon/test_u1fsfsm.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_u1fsfsm.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_u1sdtool.py'
--- tests/syncdaemon/test_u1sdtool.py	2010-03-04 16:47:43 +0000
+++ tests/syncdaemon/test_u1sdtool.py	2010-03-10 23:53:15 +0000
@@ -29,7 +29,9 @@
     show_folders,
     show_state,
     show_waiting_content,
+    show_waiting_metadata,
 )
+from tests.syncdaemon.test_dbus import FakeCommand
 from twisted.internet import defer
 
 
@@ -216,17 +218,24 @@
         d.addCallback(check)
         return d
 
+    def test_show_waiting_metadata(self):
+        """Test the output of --waiting-metadata"""
+        # inject the fake data
+        cmd = FakeCommand("share_id", "node_id")
+        cmd1 = FakeCommand("share_id_1", "node_id_1")
+        self.action_q.meta_queue.waiting.extend([cmd, cmd1])
+        out = StringIO()
+        expected = " " + str(cmd) + "\n "+ str(cmd1) + "\n"
+        d = self.tool.waiting_metadata()
+        d.addCallback(lambda result: show_waiting_metadata(result, out))
+        def check(result):
+            """check the output"""
+            self.assertEquals(out.getvalue(), expected)
+        d.addCallback(check)
+        return d
+
     def test_show_waiting_content(self):
         """Test the output of --waiting-content"""
-        class FakeCommand(object):
-            """A fake command"""
-            def __init__(self, share_id, node_id):
-                """create it"""
-                self.share_id = share_id
-                self.node_id = node_id
-            def is_runnable(self):
-                """is runnable"""
-                return True
         class FakeCommand2(FakeCommand):
             pass
         path = os.path.join(self.root_dir, "foo")

=== modified file 'tests/syncdaemon/test_u1sdtool.pyc'
Binary files tests/syncdaemon/test_u1sdtool.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_u1sdtool.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/syncdaemon/test_vm.pyc'
Binary files tests/syncdaemon/test_vm.pyc	2010-03-04 16:47:43 +0000 and tests/syncdaemon/test_vm.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/test_login.pyc'
Binary files tests/test_login.pyc	2010-03-04 16:47:43 +0000 and tests/test_login.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/test_preferences.py'
--- tests/test_preferences.py	2010-03-04 16:47:43 +0000
+++ tests/test_preferences.py	2010-03-10 23:53:15 +0000
@@ -53,26 +53,24 @@
 
         self.item_id = 999
 
-        ex = self.expect(self.item.item_id)
-        ex.result(self.item_id)
-        ex.count(0, None)
-
-        ex = self.expect(self.item.secret)
-        ex.result('oauth_token=access_key&oauth_token_secret=access_secret')
-        ex.count(0, None)
-
-    def expect_token_query(self):
-        """Expects the keyring to be queried for a token."""
-        return self.expect(
-            self.keyring.find_items_sync(
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {'ubuntuone-realm': 'https://ubuntuone.com',
-                 'oauth-consumer-key': 'ubuntuone'})
-            )
-
-    def mock_has_token(self):
-        """Mocks a cached token in the keyring."""
-        self.expect_token_query().result([self.item])
+        self.item.item_id
+        self.mocker.result(self.item_id)
+        self.mocker.count(0, None)
+
+        self.item.secret
+        self.mocker.result('oauth_token=access_key'
+                           '&oauth_token_secret=access_secret')
+        self.mocker.count(0, None)
+
+        self.keyring.find_items_sync(
+            None,
+            {'ubuntuone-realm': 'https://ubuntuone.com',
+             'oauth-consumer-key': 'ubuntuone'})
+        self.mocker.count(0, None)
+        self.mocker.result([self.item])
+        self.keyring.ITEM_GENERIC_SECRET
+        self.mocker.count(0, None)
+        self.mocker.result(None)
 
     def tearDown(self):
         # collect all signal receivers registered during the test
@@ -93,18 +91,110 @@
     def test_bw_throttling(self):
         """Test that toggling bw throttling works correctly."""
         self.mocker.replay()
-        dialog = self.u1prefs.UbuntuOneDialog()
-        self.assertTrue(dialog is not None)
-        dialog.notebook.set_current_page(1)
-        self.assertFalse(dialog.bw_table.get_property('sensitive'))
-        dialog.limit_check.set_active(True)
-        self.assertTrue(dialog.bw_table.get_property('sensitive'))
-        dialog.destroy()
+        widget = self.u1prefs.DevicesWidget(None, keyring=self.keyring)
+        try:
+            widget.devices = []
+            widget.list_devices()
+            self.assertFalse(widget.bw_limited,
+                             "the bandwidth should start out not limited")
+            self.assertTrue(widget.bw_chk,
+                            "the checkbox should be present")
+            self.assertFalse(widget.bw_chk.get_active(),
+                             "the checkbox should start out unchecked")
+            self.assertFalse(widget.up_spin.get_property('sensitive') or
+                             widget.dn_spin.get_property('sensitive'),
+                             "the spinbuttons should start out unsensitive")
+            widget.bw_chk.set_active(True)
+            self.assertTrue(widget.bw_chk.get_active(),
+                            "the checkbox should now be checked")
+            self.assertTrue(widget.up_spin.get_property('sensitive') and
+                            widget.dn_spin.get_property('sensitive'),
+                            "the spinbuttons should now be sensitive")
+        finally:
+            widget.destroy()
+
+    def test_list_devices_fills_devices_list_with_fake_result_when_empty(self):
+        self.mocker.replay()
+        widget = self.u1prefs.DevicesWidget(None, keyring=self.keyring)
+        try:
+            widget.devices = []
+            widget.list_devices()
+            # the devices list is no longer empty
+            self.assertTrue(widget.devices)
+            # it has 'fake' data (referring to the local machine)
+            self.assertTrue('FAKE' in widget.devices[0])
+        finally:
+            widget.destroy()
+
+    def test_list_devices_shows_devices_list(self):
+        self.mocker.replay()
+        widget = self.u1prefs.DevicesWidget(None, keyring=self.keyring)
+        try:
+            widget.devices = []
+            widget.list_devices()
+            # fake data now in devices
+            interesting = []
+            for i in widget.get_children():
+                clsname = i.__class__.__name__
+                if clsname == 'Image':
+                    interesting.append((clsname, i.get_icon_name()[0]))
+                if clsname in ('Label', 'Button', 'CheckButton'):
+                    interesting.append((clsname, i.get_label()))
+            # check there is an image of a computer in there
+            self.assertTrue(('Image', 'computer') in interesting)
+            # check a placeholder for the local machine description is there
+            self.assertTrue(('Label', '<LOCAL MACHINE>') in interesting)
+            # check the bw limitation stuff is there
+            self.assertTrue(('CheckButton', '_Limit Bandwidth Usage')
+                            in interesting)
+            self.assertTrue(('Label', 'Maximum _download speed (KB/s):')
+                            in interesting)
+            self.assertTrue(('Label', 'Maximum _upload speed (KB/s):')
+                            in interesting)
+            # check the 'Remove' button is *not* there
+            self.assertTrue(('Button', 'Remove') not in interesting)
+        finally:
+            widget.destroy()
+
+    def test_list_devices_shows_real_devices_list(self):
+        self.mocker.replay()
+        widget = self.u1prefs.DevicesWidget(None, keyring=self.keyring)
+        try:
+            widget.devices = [{'kind': 'Computer',
+                               'description': 'xyzzy',
+                               'token': 'blah'},
+                              {'kind': 'Phone',
+                               'description': 'quux',
+                               'token': '1234'}]
+            widget.list_devices()
+            # fake data now in devices
+            interesting = []
+            for i in widget.get_children():
+                clsname = i.__class__.__name__
+                if clsname == 'Image':
+                    interesting.append((clsname, i.get_icon_name()[0]))
+                if clsname in ('Label', 'Button', 'CheckButton'):
+                    interesting.append((clsname, i.get_label()))
+            # check there is an image of a computer in there
+            self.assertTrue(('Image', 'computer') in interesting)
+            # and of a phone
+            self.assertTrue(('Image', 'phone') in interesting)
+            # check a label of the local machine description is there
+            self.assertTrue(('Label', 'xyzzy') in interesting)
+            # check the bw limitation stuff is not there (no local machine)
+            self.assertTrue(('CheckButton', '_Limit Bandwidth Usage')
+                            not in interesting)
+            self.assertTrue(('Label', 'Download (kB/s):') not in interesting)
+            self.assertTrue(('Label', 'Upload (kB/s):') not in interesting)
+            # check the 'Remove' button is there
+            self.assertTrue(('Button', 'Remove') in interesting)
+        finally:
+            widget.destroy()
 
     def test_quota_display(self):
         """Test that quota display works correctly."""
         self.mocker.replay()
-        dialog = self.u1prefs.UbuntuOneDialog()
+        dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
         self.assertTrue(dialog is not None)
         self.assertEqual(dialog.usage_graph.get_fraction(), 0.0)
         dialog.update_quota_display(1024, 2048)
@@ -113,11 +203,6 @@
 
     def test_request_quota_info(self):
         """Test that we can request the quota info properly."""
-        self.mock_has_token()
-        dialog = self.u1prefs.UbuntuOneDialog()
-        self.assertTrue(dialog is not None)
-        dialog.keyring = self.keyring
-        self.assertEqual(dialog.usage_graph.get_fraction(), 0.0)
         response = { 'status' : '200' }
         content = '{"total":2048, "used":1024}'
         client = self.mocker.mock()
@@ -125,16 +210,15 @@
         self.expect(client.request('https://one.ubuntu.com/api/quota/',
                                    'GET', KWARGS)).result((response, content))
         self.mocker.replay()
+        dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
+        self.assertTrue(dialog is not None)
+        self.assertEqual(dialog.usage_graph.get_fraction(), 0.0)
         dialog.request_quota_info()
         self.assertEqual(dialog.usage_graph.get_fraction(), 0.5)
         dialog.destroy()
 
     def test_request_account_info(self):
         """Test that we can request the account info properly."""
-        self.mock_has_token()
-        dialog = self.u1prefs.UbuntuOneDialog()
-        self.assertTrue(dialog is not None)
-        dialog.keyring = self.keyring
         response = { 'status' : '200' }
         content = '''{"username": "ubuntuone", "nickname": "Ubuntu One",
                      "email": "[e-mail]"}
@@ -144,6 +228,8 @@
         self.expect(client.request('https://one.ubuntu.com/api/account/',
                                    'GET', KWARGS)).result((response, content))
         self.mocker.replay()
+        dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
+        self.assertTrue(dialog is not None)
         dialog.request_account_info()
         self.assertEqual(dialog.name_label.get_text(), 'Ubuntu One')
         self.assertEqual(dialog.user_label.get_text(), 'ubuntuone')
@@ -152,13 +238,14 @@
 
     def test_toggle_bookmarks(self):
         """Test toggling the bookmarks service on/off."""
-        dialog = self.u1prefs.UbuntuOneDialog()
+        toggle_db_sync = self.mocker.mock()
+        self.expect(toggle_db_sync('bookmarks', False))
+        self.expect(toggle_db_sync('bookmarks', True))
+        self.expect(toggle_db_sync('bookmarks', False))
+        self.mocker.replay()
+        dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
         self.assertTrue(dialog is not None)
-        dialog.toggle_db_sync = self.mocker.mock()
-        self.expect(dialog.toggle_db_sync('bookmarks', False))
-        self.expect(dialog.toggle_db_sync('bookmarks', True))
-        self.expect(dialog.toggle_db_sync('bookmarks', False))
-        self.mocker.replay()
+        dialog.toggle_db_sync = toggle_db_sync
         dialog.bookmarks_check.set_active(True)
         self.assertTrue(dialog.bookmarks_check.get_active())
         dialog.bookmarks_check.set_active(False)
@@ -168,13 +255,14 @@
 
     def test_toggle_contacts(self):
         """Test toggling the contacts service on/off."""
-        dialog = self.u1prefs.UbuntuOneDialog()
+        toggle_db_sync = self.mocker.mock()
+        self.expect(toggle_db_sync('contacts', False))
+        self.expect(toggle_db_sync('contacts', True))
+        self.expect(toggle_db_sync('contacts', False))
+        self.mocker.replay()
+        dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
         self.assertTrue(dialog is not None)
-        dialog.toggle_db_sync = self.mocker.mock()
-        self.expect(dialog.toggle_db_sync('contacts', False))
-        self.expect(dialog.toggle_db_sync('contacts', True))
-        self.expect(dialog.toggle_db_sync('contacts', False))
-        self.mocker.replay()
+        dialog.toggle_db_sync = toggle_db_sync
         dialog.abook_check.set_active(True)
         self.assertTrue(dialog.abook_check.get_active())
         dialog.abook_check.set_active(False)
@@ -184,9 +272,9 @@
 
     def test_toggle_files(self):
         """Test toggling the files service on/off."""
-        dialog = self.u1prefs.UbuntuOneDialog()
+        self.mocker.replay()
+        dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
         self.assertTrue(dialog is not None)
-        self.mocker.replay()
         dialog.files_check.set_active(True)
         self.assertTrue(dialog.files_check.get_active())
         dialog.files_check.set_active(False)
@@ -196,9 +284,9 @@
 
     def test_toggle_files_and_music(self):
         """Test toggling the files and music services on/off."""
-        dialog = self.u1prefs.UbuntuOneDialog()
+        self.mocker.replay()
+        dialog = self.u1prefs.UbuntuOneDialog(keyring=self.keyring)
         self.assertTrue(dialog is not None)
-        self.mocker.replay()
         dialog.files_check.set_active(False)
         self.assertFalse(dialog.files_check.get_active())
         self.assertFalse(dialog.music_check.props.sensitive)

=== modified file 'tests/test_preferences.pyc'
Binary files tests/test_preferences.pyc	2010-03-04 16:47:43 +0000 and tests/test_preferences.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/u1sync/__init__.pyc'
Binary files tests/u1sync/__init__.pyc	2010-03-04 16:47:43 +0000 and tests/u1sync/__init__.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/u1sync/test_init.pyc'
Binary files tests/u1sync/test_init.pyc	2010-03-04 16:47:43 +0000 and tests/u1sync/test_init.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'tests/u1sync/test_merge.pyc'
Binary files tests/u1sync/test_merge.pyc	2010-03-04 16:47:43 +0000 and tests/u1sync/test_merge.pyc	2010-03-10 23:53:15 +0000 differ
=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2010-03-04 16:47:43 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2010-03-10 23:53:15 +0000
@@ -187,13 +187,13 @@
     factory = None
 
     def connectionMade(self):
-        """Called when a new connection is made."""
+        """A new connection was made."""
+        self.log.info('Connection made.')
         self.factory.event_queue.push('SYS_CONNECTION_MADE')
 
-    def disconnect(self):
-        """Close down the sockets."""
-        if self.transport is not None:
-            self.transport.loseConnection()
+    def connectionLost(self, reason):
+        """The connection was lost."""
+        self.log.info('Connection lost, reason: %s.', reason)
 
 
 class Marker(str):
@@ -694,11 +694,7 @@
         self.token = access_token
 
     def cleanup(self):
-        """
-        Cancel, clean up, and reschedule things that were in progress
-        when a disconnection happened
-        """
-        self.disconnect()
+        """Cancel, clean up, and reschedule things that were in progress."""
         self.meta_queue.cleanup_and_retry()
         self.content_queue.cleanup_and_retry()
 
@@ -848,7 +844,8 @@
 
     def startedConnecting(self, connector):
         """Called when a connection has been started."""
-        logger.info('Connection started.')
+        logger.info('Connection started to host %s, port %s.',
+                    self.host, self.port)
 
     def disconnect(self):
         """Disconnect the client.
@@ -986,10 +983,10 @@
             self.deferred.callback(client)
 
     @defer.inlineCallbacks
-    def server_rescan(self, data_gen):
+    def server_rescan(self, root_mdid, data_gen):
         """Do the server rescan."""
         client = self.client
-        yield self.get_root(object())
+        yield self.get_root(root_mdid)
         if client is not self.client:
             return
         data = data_gen()
@@ -1422,6 +1419,17 @@
         """Returns the action queue."""
         return self._queue.action_queue
 
+    def __str__(self, str_attrs=None):
+        """Return a str representation of the instance."""
+        if str_attrs is None:
+            str_attrs = self.logged_attrs
+        name = self.__class__.__name__
+        if len(str_attrs) == 0:
+            return name
+        attrs = [str(attr) + '=' + str(getattr(self, attr, None) or 'None') \
+                 for attr in str_attrs]
+        return ''.join([name, '(', ', '.join([attr for attr in attrs]), ')'])
+
 
 class WaitForCondition(ActionQueueCommand):
     """A command which waits for some condition to be satisfied."""
@@ -2260,6 +2268,11 @@
 
     is_dir = True
 
+    def __str__(self):
+        """Return a str representation of the instance."""
+        to_show = ('share_id', 'node_id', 'server_hash')
+        return super(ListDir, self).__str__(str_attrs=to_show)
+
 
 class Download(GetContentMixin, ActionQueueCommand):
     """Get the contents of a file."""

=== modified file 'ubuntuone/syncdaemon/dbus_interface.py'
--- ubuntuone/syncdaemon/dbus_interface.py	2010-03-04 16:47:43 +0000
+++ ubuntuone/syncdaemon/dbus_interface.py	2010-03-10 23:53:15 +0000
@@ -191,6 +191,15 @@
             current_downloads.append(entry)
         return current_downloads
 
+    @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='as')
+    def waiting_metadata(self):
+        """Return a list of the operations in the meta-queue."""
+        logger.debug('called waiting_metadata')
+        waiting_metadata = []
+        for cmd in self.action_queue.meta_queue.waiting:
+            waiting_metadata.append(str(cmd))
+        return waiting_metadata
+
     @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='aa{ss}')
     def waiting_content(self):
         """
@@ -327,7 +336,7 @@
     def emit_status_changed(self, state):
         """Emits the signal."""
         state_dict = {'name':state.name,
-                      'description':self.bool_str(state.description),
+                      'description':state.description,
                       'is_error':self.bool_str(state.is_error),
                       'is_connected':self.bool_str(state.is_connected),
                       'is_online':self.bool_str(state.is_online)}
@@ -678,6 +687,11 @@
         self.dbus_iface.public_files.emit_public_access_change_error(
             share_id, node_id, error)
 
+    def handle_SYS_ROOT_MISMATCH(self, root_id, new_root_id):
+        """Handle the SYS_ROOT_MISMATCH event."""
+        self.handle_default('SYS_ROOT_MISMATCH', root_id, new_root_id)
+        self.dbus_iface.sync.emit_root_mismatch(root_id, new_root_id)
+
 
 class SyncDaemon(DBusExposedObject):
     """ The Daemon dbus interface. """
@@ -745,6 +759,16 @@
             reply_handler()
         self.dbus_iface.quit()
 
+    @dbus.service.signal(DBUS_IFACE_SYNC_NAME,
+                         signature='ss')
+    def RootMismatch(self, root_id, new_root_id):
+        """RootMismatch signal, the user connected with a different account."""
+        pass
+
+    def emit_root_mismatch(self, root_id, new_root_id):
+        """Emit RootMismatch signal."""
+        self.RootMismatch(root_id, new_root_id)
+
 
 class FileSystem(DBusExposedObject):
     """ A dbus interface to the FileSystem Manager. """
@@ -919,6 +943,21 @@
             raise ValueError("path '%r' does not exist" % path)
         self.vm.create_share(path, username, name, access_level)
 
+    @dbus.service.method(DBUS_IFACE_SHARES_NAME,
+                         in_signature='sasss', out_signature='')
+    def create_shares(self, path, usernames, name, access_level):
+        """Share a subtree with several users at once.
+
+        @param path: that path to share (the root of the subtree)
+        @param usernames: the user names to offer the share to
+        @param name: the name of the share
+        @param access_level: 'View' or 'Modify'
+        """
+        logger.debug('create shares: %r, %r, %r, %r',
+                     path, usernames, name, access_level)
+        for user in usernames:
+            self.create_share(path, user, name, access_level)
+
     @dbus.service.signal(DBUS_IFACE_SHARES_NAME,
                          signature='a{ss}')
     def ShareCreated(self, share_info):
@@ -1010,6 +1049,7 @@
         configured.
         The values are bytes/second
         """
+        logger.debug("called get_throttling_limits")
         try:
             aq = self.dbus_iface.action_queue
             download = -1
@@ -1037,6 +1077,7 @@
     def set_throttling_limits(self, download, upload,
                          reply_handler=None, error_handler=None):
         """Set the read and write limits. The expected values are bytes/sec."""
+        logger.debug("called set_throttling_limits")
         try:
             # modify and save the config file
             user_config = config.get_user_config()
@@ -1349,11 +1390,19 @@
         """Emit the PublicAccessChanged signal."""
         share_id = str(share_id) if share_id else ''
         node_id = str(node_id)
+        try:
+            relpath = self.fs.get_by_node_id(share_id,
+                                             node_id).path
+        except KeyError:
+            pass
+        else:
+            path=self.fs.get_abspath(share_id, relpath)
         self.PublicAccessChanged(dict(
                 share_id=str(share_id) if share_id else '',
                 node_id=str(node_id),
                 is_public=self.bool_str(is_public),
-                public_url=public_url if public_url else ''))
+                public_url=public_url if public_url else '',
+                path=path))
 
     @dbus.service.signal(DBUS_IFACE_PUBLIC_FILES_NAME,
                          signature='a{ss}')
@@ -1362,9 +1411,17 @@
 
     def emit_public_access_change_error(self, share_id, node_id, error):
         """Emit the PublicAccessChangeError signal."""
+        try:
+            relpath = self.fs.get_by_node_id(share_id,
+                                             node_id).path
+        except KeyError:
+            pass
+        else:
+            path=self.fs.get_abspath(share_id, relpath)
         self.PublicAccessChangeError(dict(
                 share_id=str(share_id) if share_id else '',
-                node_id=str(node_id)), str(error))
+                node_id=str(node_id),
+                path=path), str(error))
 
     @dbus.service.signal(DBUS_IFACE_PUBLIC_FILES_NAME,
                          signature='a{ss}s')

=== modified file 'ubuntuone/syncdaemon/local_rescan.py'
--- ubuntuone/syncdaemon/local_rescan.py	2010-03-04 16:47:43 +0000
+++ ubuntuone/syncdaemon/local_rescan.py	2010-03-10 23:53:15 +0000
@@ -129,7 +129,7 @@
         elif not stat.S_ISDIR(stat_result.st_mode):
             m = "The path is in disk but it's not a dir: %r" % direct
             log_error(m)
-            raise ValueError("m")
+            raise ValueError(m)
 
         # No, 'share' is surely defined; pylint: disable-msg=W0631
         self._queue.appendleft((share, direct, False, mdid, udfmode))

=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2010-03-04 16:47:43 +0000
+++ ubuntuone/syncdaemon/main.py	2010-03-10 23:53:15 +0000
@@ -232,7 +232,9 @@
 
     def server_rescan(self):
         """Do the server rescan."""
-        self.action_q.server_rescan(self.fs.get_data_for_server_rescan)
+        mdobj = self.fs.get_by_path(self.root_dir)
+        self.action_q.server_rescan(mdobj.mdid,
+                                    self.fs.get_data_for_server_rescan)
 
     def set_oauth_token(self, key, secret):
         """ Sets the oauth token """

=== modified file 'ubuntuone/syncdaemon/tools.py'
--- ubuntuone/syncdaemon/tools.py	2010-03-04 16:47:43 +0000
+++ ubuntuone/syncdaemon/tools.py	2010-03-10 23:53:15 +0000
@@ -593,6 +593,16 @@
                                   error_handler=d.errback)
         return d
 
+    def waiting_metadata(self):
+        """Return a description of the waiting metadata queue elements."""
+        d = defer.Deferred()
+        status_client = DBusClient(self.bus, '/status',
+                                   DBUS_IFACE_STATUS_NAME)
+        status_client.call_method('waiting_metadata',
+                                  reply_handler=d.callback,
+                                  error_handler=d.errback)
+        return d
+
     def waiting_content(self):
         """Returns the waiting content queue elements."""
         d = defer.Deferred()
@@ -777,6 +787,12 @@
     out.write("\n")
 
 
+def show_waiting_metadata(waiting_ops, out):
+    """Print the waiting_metadata result"""
+    for value in waiting_ops:
+        out.write(" %s\n" % value)
+
+
 def show_waiting_content(waiting_ops, out):
     """Print the waiting_content result"""
     value_tpl = "operation='%(operation)s' node_id='%(node)s' " + \
@@ -785,6 +801,7 @@
         str_value = value_tpl % value
         out.write("%s\n" % str_value)
 
+
 def show_public_file_info(file_info, out):
     """Print the public access information for a file."""
     if file_info['is_public']: