Merge lp:~chipaca/ubuntuone-client/devices-tab into lp:ubuntuone-client

[dobey]

Add other devices and management ui to Devices tab

[Eric Casteleijn (thisfred)]

Getting keyring errors

[Eric Casteleijn (thisfred)]

===============================================================================
[ERROR]: tests.test_preferences.PreferencesTests.test_bw_throttling

Traceback (most recent call last):
  File "/home/eric/canonical/ubuntuone-client/devices-tab/contrib/mocker.py", line 102, in test_method_wrapper
    result = test_method()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/tests/test_preferences.py", line 96, in test_bw_throttling
    dialog = self.u1prefs.UbuntuOneDialog()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 473, in __init__
    self.__construct()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 686, in __construct
    self.devices.get_devices()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 258, in get_devices
    token = get_access_token()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 84, in get_access_token
    'oauth-consumer-key': 'ubuntuone'})
gnomekeyring.IOError:
===============================================================================
[ERROR]: tests.test_preferences.PreferencesTests.test_quota_display

Traceback (most recent call last):
  File "/home/eric/canonical/ubuntuone-client/devices-tab/contrib/mocker.py", line 102, in test_method_wrapper
    result = test_method()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/tests/test_preferences.py", line 107, in test_quota_display
    dialog = self.u1prefs.UbuntuOneDialog()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 473, in __init__
    self.__construct()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 686, in __construct
    self.devices.get_devices()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 258, in get_devices
    token = get_access_token()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 84, in get_access_token
    'oauth-consumer-key': 'ubuntuone'})
gnomekeyring.IOError:
===============================================================================
[ERROR]: tests.test_preferences.PreferencesTests.test_request_account_info

Traceback (most recent call last):
  File "/home/eric/canonical/ubuntuone-client/devices-tab/contrib/mocker.py", line 102, in test_method_wrapper
    result = test_method()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/tests/test_preferences.py", line 135, in test_request_account_info
    dialog = self.u1prefs.UbuntuOneDialog()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 473, in __init__
    self.__construct()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 686, in __construct
    self.devices.get_devices()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 258, in get_devices
    token = get_access_token()
  File "/home/eric/canonical/ubuntuone-client/devices-tab/bin/ubuntuone-preferences", line 84, in get_access_token
    'oauth-consumer...

review: Needs Fixing

[lp:~chipaca/ubuntuone-client/devices-tab]

403. By John Lenton on 2010-03-04

merged with trunk

404. By John Lenton on 2010-03-05

merged with trunk (again)

405. By John Lenton on 2010-03-05

minor refactoring (to get tests working again) and tests. Still TODO: test the REST calls are done

406. By John Lenton on 2010-03-05

worked around a bug in the rest api

407. By John Lenton on 2010-03-08

fixed issues raised by dobey

408. By John Lenton on 2010-03-08

fixed issues raised by nessa

409. By John Lenton on 2010-03-08

more changed by dobey (and some older ones)

Unmerged revisions

=== modified file 'bin/ubuntuone-preferences'
--- bin/ubuntuone-preferences	2010-03-01 22:10:22 +0000
+++ bin/ubuntuone-preferences	2010-03-05 17:04:28 +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,358 @@
       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("Please wait...")
+        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 dialo.
+        """
+        self.clear_devices_view()
+        self.status_label.set_markup("<b>Error:</b> %s" % 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, and 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 shouold 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 all the widgets except from the table, the
+        description and the status_label
+        """
+        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'}]
+
+        name_label = gtk.Label()
+        name_label.set_markup("<b>Name</b>")
+        name_label.set_alignment(0., .5)
+        self.attach(name_label, 1, 2, 1, 2)
+        self.status_label.set_label("")
+
+        i = 1
+        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['token'])
+                  self.attach(butn, 2, 3, i, i+1, xoptions=0, yoptions=0)
+            if row['token'] == token.key:
+                self.bw_chk = ck_btn = gtk.CheckButton(
+                      _("_Limit Bandwidth Usage"))
+                ck_btn.set_active(self.bw_limited)
+                up_lbl = gtk.Label(_("Upload (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)
+                dn_lbl = gtk.Label(_("Download (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)
+                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 +439,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 +463,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 +485,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 +526,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 +677,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 'tests/test_preferences.py'
--- tests/test_preferences.py	2010-02-18 16:02:23 +0000
+++ tests/test_preferences.py	2010-03-05 17:04:28 +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,108 @@
     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', 'Download (kB/s):') in interesting)
+            self.assertTrue(('Label', 'Upload (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 +201,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 +208,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 +226,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 +236,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 +253,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 +270,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 +282,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 'ubuntuone/syncdaemon/dbus_interface.py'
--- ubuntuone/syncdaemon/dbus_interface.py	2010-03-03 15:04:02 +0000
+++ ubuntuone/syncdaemon/dbus_interface.py	2010-03-05 17:04:28 +0000
@@ -1010,6 +1010,7 @@
         configured.
         The values are bytes/second
         """
+        logger.debug("called get_throttling_limits")
         try:
             aq = self.dbus_iface.action_queue
             download = -1
@@ -1037,6 +1038,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()