Merge lp:~nataliabidart/ubuntuone-client/extend-sdtool into lp:ubuntuone-client

[Natalia Bidart]

- Implemented methods to extend SyncDaemonTool and then provide settings management for autoconnect and share/udf autosubscribe (LP: #797411).

[lp:~nataliabidart/ubuntuone-client/extend-sdtool]

1006. By Natalia Bidart on 2011-06-15

Restore the cleanup of shares_dir.

1007. By Natalia Bidart on 2011-06-15

Removed print statements.

1008. By Natalia Bidart on 2011-06-15

Reverting test_zglog.py changes.

1009. By Natalia Bidart on 2011-06-15

Adding deprecation warnings to DBus deprecated methods/signals.

[Eric Casteleijn (thisfred)]

I like the the settings refactoring! Code looks good, tests pass.

review: Approve

[Tim Cole (tcole)]

Looks great!

review: Approve

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2011-06-15 14:46:04 +0000
+++ contrib/testing/testcase.py	2011-06-15 21:34:36 +0000
@@ -310,7 +310,7 @@
         os.makedirs(path)
 
     def setUp(self):
-        TwistedTestCase.setUp(self)
+        super(BaseTwistedTestCase, self).setUp()
         # use the config from the branch
         self.old_get_config_files = config.get_config_files
         config.get_config_files = lambda: [os.path.join(os.environ['ROOTDIR'],
@@ -336,7 +336,7 @@
         root_dir = getattr(self, '__root', None)
         if root_dir:
             self.rmtree(self.__root)
-        return TwistedTestCase.tearDown(self)
+        return super(BaseTwistedTestCase, self).tearDown()
 
 
 class FakeMainTestCase(BaseTwistedTestCase):

=== modified file 'tests/platform/linux/__init__.py'
--- tests/platform/linux/__init__.py	2011-02-08 12:04:21 +0000
+++ tests/platform/linux/__init__.py	2011-06-15 21:34:36 +0000
@@ -1,6 +1,21 @@
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 """Linux test code."""
 
 
+
 def _setup_service_busname(testcase):
     # monkeypatch __del__ to avoid issues with gc
     import dbus
@@ -10,6 +25,7 @@
 
 setup_main_test = _setup_service_busname
 
+
 def get_main_params(testcase, params):
     """Return the parameters used to create the main object for tests."""
     from dbus.mainloop.glib import DBusGMainLoop

=== modified file 'tests/platform/linux/eventlog/test_zg_listener.py'
--- tests/platform/linux/eventlog/test_zg_listener.py	2011-04-20 21:47:24 +0000
+++ tests/platform/linux/eventlog/test_zg_listener.py	2011-06-15 21:34:36 +0000
@@ -1133,6 +1133,7 @@
         self.assertEqual(local_folder.mimetype, DIRECTORY_MIMETYPE)
         self.assertEqual(local_folder.storage, STORAGE_LOCAL)
 
+
 class ZeitgeistPublicFilesTestCase(ZeitgeistListenerTestCase):
     """Public files events are logged into Zeitgeist."""
 

=== modified file 'tests/platform/linux/eventlog/test_zglog.py'
--- tests/platform/linux/eventlog/test_zglog.py	2010-12-02 14:53:38 +0000
+++ tests/platform/linux/eventlog/test_zglog.py	2011-06-15 21:34:36 +0000
@@ -73,6 +73,7 @@
         d.addCallback(verify)
         return d
 
+
 def wait_zeitgeist_started(seconds=10):
     """Wait a few seconds until zg is started, or fail if it can't."""
     client = None

=== modified file 'tests/platform/linux/test_config.py'
--- tests/platform/linux/test_config.py	2010-12-01 21:13:52 +0000
+++ tests/platform/linux/test_config.py	2011-06-15 21:34:36 +0000
@@ -1,8 +1,25 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2010-2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 from ConfigParser import ConfigParser
 
 from tests.platform.linux.test_dbus import DBusTwistedTestCase
 from ubuntuone.syncdaemon import config
 
+
 class TestDBusConfig(DBusTwistedTestCase):
 
     def test_get_throttling_limits(self):

=== modified file 'tests/platform/linux/test_credentials.py'
--- tests/platform/linux/test_credentials.py	2011-05-31 18:13:24 +0000
+++ tests/platform/linux/test_credentials.py	2011-06-15 21:34:36 +0000
@@ -21,7 +21,7 @@
 from functools import wraps
 
 from twisted.internet.defer import Deferred, inlineCallbacks
-from ubuntuone.devtools.testcase import DBusTestCase as TestCase
+from ubuntuone.devtools.testcase import DBusTestCase
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.credentials import logging, logger
@@ -172,15 +172,16 @@
         self.register(app_name, args)
 
 
-class BaseTestCase(TestCase):
+class BaseTestCase(DBusTestCase):
     """Base test case."""
 
     timeout = 8
     app_name = APP_NAME
     error_dict = None
 
+    @inlineCallbacks
     def setUp(self):
-        super(BaseTestCase, self).setUp()
+        yield super(BaseTestCase, self).setUp()
         FakedSSOService.app_name = self.app_name
         FakedSSOService.error_dict = self.error_dict
 
@@ -188,7 +189,6 @@
         self.memento.setLevel(logging.DEBUG)
         logger.addHandler(self.memento)
 
-        self.bus = dbus.SessionBus()
         self.sso_server = self.register_server(ubuntu_sso.DBUS_BUS_NAME,
                                 ubuntu_sso.DBUS_CREDENTIALS_PATH,
                                 FakedSSOService)  # faked SSO server
@@ -201,6 +201,7 @@
                             'Service %s should not be running.' % bus_name)
         mock = service_class(object_path=object_path, conn=self.bus)
         self.addCleanup(mock.remove_from_connection)
+        self.addCleanup(lambda: self.bus.release_name(bus_name))
 
         return mock
 
@@ -222,8 +223,9 @@
     signals = ('CredentialsFound', 'CredentialsNotFound', 'CredentialsCleared',
                'CredentialsStored', 'CredentialsError', 'AuthorizationDenied')
 
+    @inlineCallbacks
     def setUp(self):
-        super(CredentialsManagementTestCase, self).setUp()
+        yield super(CredentialsManagementTestCase, self).setUp()
         self.creds_server = self.register_server(DBUS_BUS_NAME,
                                 DBUS_CREDENTIALS_PATH,
                                 CredentialsManagement)  # real service
@@ -596,8 +598,9 @@
 class RefCountingTestCase(BaseTestCase):
     """Tests for the CredentialsManagement ref counting."""
 
+    @inlineCallbacks
     def setUp(self):
-        super(RefCountingTestCase, self).setUp()
+        yield super(RefCountingTestCase, self).setUp()
         self._called = False
         self.client = CredentialsManagement()
 
@@ -848,13 +851,13 @@
 class CredentialsTestCase(BaseTestCase):
     """Test suite for the Credentials class."""
 
+    @inlineCallbacks
     def setUp(self):
-        super(CredentialsTestCase, self).setUp()
+        yield super(CredentialsTestCase, self).setUp()
         FakedSSOService.error_dict = None
         self.creds_server = self.register_server(DBUS_BUS_NAME,
                                 DBUS_CREDENTIALS_PATH,
                                 CredentialsManagement)  # real service
-
         self.client = CredentialsManagementTool()
 
     @inlineCallbacks
@@ -982,4 +985,3 @@
             self.assertEqual(e[0], FakedSSOService.error_dict)
         else:
             self.fail('Must not succeed!')
-

=== modified file 'tests/platform/linux/test_dbus.py'
--- tests/platform/linux/test_dbus.py	2011-06-15 13:54:26 +0000
+++ tests/platform/linux/test_dbus.py	2011-06-15 21:34:36 +0000
@@ -23,7 +23,6 @@
 import logging
 
 import dbus
-from dbus.mainloop.glib import DBusGMainLoop
 from dbus import exceptions
 from mocker import MockerTestCase
 from twisted.internet import defer, reactor
@@ -105,12 +104,7 @@
         self.fs_manager = self.main.fs
         self.event_q = self.main.event_q
         self.action_q = self.main.action_q
-        self.loop = DBusGMainLoop(set_as_default=True)
-        self.bus = dbus.bus.BusConnection(mainloop=self.loop)
         self.nm = FakeNetworkManager(self.bus)
-        # monkeypatch busName.__del__ to avoid errors on gc
-        # we take care of releasing the name in shutdown
-        dbus.service.BusName.__del__ = lambda _: None
         self.dbus_iface = DBusInterface(self.bus, self.main,
                                         system_bus=self.bus)
         # expose the inner object so that other tests can access them
@@ -128,10 +122,8 @@
         self.main.external = ExternalInterface(self.main, False, False,
                                                dbus_iface=self.dbus_iface)
         self.busName = self.dbus_iface.busName
-        self.bus.set_exit_on_disconnect(False)
         self.dbus_iface.connect()
         self.event_q.push('SYS_INIT_DONE')
-        self.signal_receivers = set()
 
         self.handler = MementoHandler()
         self._logger = logging.getLogger("ubuntuone.SyncDaemon")
@@ -149,8 +141,6 @@
         self.main.shutdown()
         self.nm.shutdown()
         self.dbus_iface.bus.flush()
-        self.bus.flush()
-        self.bus.close()
         self.rmtree(self.shares_dir)
         self.rmtree(self.root_dir)
         self.rmtree(self.data_dir)
@@ -2550,8 +2540,48 @@
                            error_handler=self.error_handler)
         return d
 
+    def test_enable_autoconnect(self):
+        """Test for Config.enable_autoconnect."""
+        client = self.get_client()
+        d = defer.Deferred()
+        orig = config.get_user_config().get_autoconnect()
+        # restore autoconnect to original value
+        self.addCleanup(lambda: config.get_user_config().set_autoconnect(orig))
+
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertTrue(config.get_user_config().get_autoconnect())
+            d.callback(True)
+
+        client.call_method('enable_autoconnect',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_disable_autoconnect(self):
+        """Test for Config.disable_autoconnect."""
+        client = self.get_client()
+        d = defer.Deferred()
+        orig = config.get_user_config().get_autoconnect()
+        # restore autoconnect to original value
+        self.addCleanup(lambda: config.get_user_config().set_autoconnect(orig))
+
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertFalse(config.get_user_config().get_autoconnect())
+            d.callback(True)
+
+        client.call_method('disable_autoconnect',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
     def test_set_autoconnect_enabled(self):
-        """Test for Config.set_autoconnect_enabled."""
+        """Test for Config.set_autoconnect_enabled.
+
+        DEPRECATED.
+
+        """
         client = self.get_client()
         d = defer.Deferred()
         orig = config.get_user_config().get_autoconnect()
@@ -2657,6 +2687,7 @@
                                            self.events.append((name, kw))
         self.memento = MementoHandler()
         logger.addHandler(self.memento)
+        self.addCleanup(lambda: logger.removeHandler(self.memento))
 
     def tearDown(self, *args):
         """Shutdown."""

=== modified file 'tests/platform/linux/test_os_helper.py'
--- tests/platform/linux/test_os_helper.py	2011-04-01 19:48:38 +0000
+++ tests/platform/linux/test_os_helper.py	2011-06-15 21:34:36 +0000
@@ -45,6 +45,7 @@
     stat_path,
 )
 
+
 class FakeGIOFile(object):
     """Fake File for gio."""
 

=== modified file 'tests/platform/linux/test_session.py'
--- tests/platform/linux/test_session.py	2011-02-22 23:15:12 +0000
+++ tests/platform/linux/test_session.py	2011-06-15 21:34:36 +0000
@@ -31,6 +31,7 @@
                session.INHIBIT_SUSPENDING_COMPUTER |
                session.INHIBIT_SESSION_IDLE)
 
+
 class FakeGnomeSessionManagerInhibitor(dbus.service.Object):
     """A fake Gnome Session Manager (but only the inhibitor bits)."""
 
@@ -66,9 +67,10 @@
 
     timeout = 5
 
+    @inlineCallbacks
     def setUp(self):
         """Initialize this test case."""
-        DBusTestCase.setUp(self)
+        yield super(SessionDBusClientTestCase, self).setUp()
         DBusGMainLoop(set_as_default=True)
 
     def test_fake_inhibitor(self):
@@ -92,15 +94,16 @@
     def register_fakeserver(self, bus_name, object_path, object_class,
                             **kwargs):
         """The fake service is registered on the DBus."""
-        session_bus = dbus.SessionBus()
         flags = (dbus.bus.NAME_FLAG_REPLACE_EXISTING |
                  dbus.bus.NAME_FLAG_DO_NOT_QUEUE |
                  dbus.bus.NAME_FLAG_ALLOW_REPLACEMENT)
-        name = session_bus.request_name(bus_name, flags=flags)
+        name = self.bus.request_name(bus_name, flags=flags)
         self.assertNotEqual(name, dbus.bus.REQUEST_NAME_REPLY_EXISTS)
-        fake = object_class(object_path=object_path, conn=session_bus,
+        fake = object_class(object_path=object_path, conn=self.bus,
                                  **kwargs)
         self.addCleanup(fake.remove_from_connection)
+        self.addCleanup(lambda: self.bus.release_name(bus_name))
+
         return fake
 
     @inlineCallbacks

=== modified file 'tests/platform/linux/test_tools.py'
--- tests/platform/linux/test_tools.py	2011-06-15 13:54:26 +0000
+++ tests/platform/linux/test_tools.py	2011-06-15 21:34:36 +0000
@@ -45,19 +45,15 @@
         yield super(TestToolsBase, self).setUp()
         self.tool = tools.SyncDaemonTool(self.bus)
         self.home_dir = self.mktemp('ubuntuonehacker')
-        self._old_home = os.environ['HOME']
+        old_home = os.environ['HOME']
         os.environ['HOME'] = self.home_dir
+        self.addCleanup(lambda: os.environ.__setitem__('HOME', old_home))
+        self.addCleanup(lambda: self.rmtree(self.home_dir))
         self.handler = MementoHandler()
         self.tool.log.addHandler(self.handler)
         yield self.main.wait_for_nirvana()
 
     @defer.inlineCallbacks
-    def tearDown(self):
-        os.environ['HOME'] = self._old_home
-        self.rmtree(self.home_dir)
-        yield super(TestToolsBase, self).tearDown()
-
-    @defer.inlineCallbacks
     def create_file(self, path):
         """ creates a test file in fsm """
         share_path = os.path.join(self.shares_dir, 'share_tools')
@@ -69,7 +65,7 @@
 
 
 class TestToolsBasic(TestToolsBase):
-    """ Baic test of SyncDaemonTool """
+    """Basic test of SyncDaemonTool."""
 
     def _create_share(self, accepted=True, subscribed=True):
         """Return a newly created Share."""
@@ -586,6 +582,31 @@
         self.assertEqual(False, config.get_files_sync_enabled())
 
     @defer.inlineCallbacks
+    def test_is_autoconnect_enabled(self):
+        """Test for is_autoconnect_enabled."""
+        yield self.tool.enable_autoconnect(False)
+        enabled = yield self.tool.is_autoconnect_enabled()
+        self.assertFalse(enabled)
+
+        yield self.tool.enable_autoconnect(True)
+        enabled = yield self.tool.is_autoconnect_enabled()
+        self.assertTrue(enabled)
+
+    @defer.inlineCallbacks
+    def test_enable_autoconnect(self):
+        """Test for enable_autoconnect."""
+        yield self.tool.enable_autoconnect(True)
+        enabled = yield self.tool.is_autoconnect_enabled()
+        self.assertTrue(enabled)
+
+    @defer.inlineCallbacks
+    def test_disable_autoconnect(self):
+        """Test for disable_autoconnect."""
+        yield self.tool.enable_autoconnect(False)
+        enabled = yield self.tool.is_autoconnect_enabled()
+        self.assertFalse(enabled)
+
+    @defer.inlineCallbacks
     def test_is_show_all_notifications_enabled(self):
         """Test for is_show_all_notifications_enabled."""
         yield self.tool.enable_show_all_notifications(False)
@@ -611,6 +632,56 @@
         self.assertFalse(enabled)
 
     @defer.inlineCallbacks
+    def test_is_share_autosubscribe_enabled(self):
+        """Test for is_share_autosubscribe_enabled."""
+        yield self.tool.enable_share_autosubscribe(False)
+        enabled = yield self.tool.is_share_autosubscribe_enabled()
+        self.assertFalse(enabled)
+
+        yield self.tool.enable_share_autosubscribe(True)
+        enabled = yield self.tool.is_share_autosubscribe_enabled()
+        self.assertTrue(enabled)
+
+    @defer.inlineCallbacks
+    def test_enable_share_autosubscribe(self):
+        """Test for enable_share_autosubscribe."""
+        yield self.tool.enable_share_autosubscribe(True)
+        enabled = yield self.tool.is_share_autosubscribe_enabled()
+        self.assertTrue(enabled)
+
+    @defer.inlineCallbacks
+    def test_disable_share_autosubscribe(self):
+        """Test for disable_share_autosubscribe."""
+        yield self.tool.enable_share_autosubscribe(False)
+        enabled = yield self.tool.is_share_autosubscribe_enabled()
+        self.assertFalse(enabled)
+
+    @defer.inlineCallbacks
+    def test_is_udf_autosubscribe_enabled(self):
+        """Test for is_udf_autosubscribe_enabled."""
+        yield self.tool.enable_udf_autosubscribe(False)
+        enabled = yield self.tool.is_udf_autosubscribe_enabled()
+        self.assertFalse(enabled)
+
+        yield self.tool.enable_udf_autosubscribe(True)
+        enabled = yield self.tool.is_udf_autosubscribe_enabled()
+        self.assertTrue(enabled)
+
+    @defer.inlineCallbacks
+    def test_enable_udf_autosubscribe(self):
+        """Test for enable_udf_autosubscribe."""
+        yield self.tool.enable_udf_autosubscribe(True)
+        enabled = yield self.tool.is_udf_autosubscribe_enabled()
+        self.assertTrue(enabled)
+
+    @defer.inlineCallbacks
+    def test_disable_udf_autosubscribe(self):
+        """Test for disable_udf_autosubscribe."""
+        yield self.tool.enable_udf_autosubscribe(False)
+        enabled = yield self.tool.is_udf_autosubscribe_enabled()
+        self.assertFalse(enabled)
+
+    @defer.inlineCallbacks
     def test_refresh_volumes(self):
         """Test for refresh_volumes method."""
         d = defer.Deferred()

=== modified file 'ubuntuone/platform/linux/dbus_interface.py'
--- ubuntuone/platform/linux/dbus_interface.py	2011-06-09 10:08:57 +0000
+++ ubuntuone/platform/linux/dbus_interface.py	2011-06-15 21:34:36 +0000
@@ -17,8 +17,10 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """DBUS interface module."""
 
+import logging
+import warnings
+
 import dbus.service
-import logging
 
 from dbus import DBusException
 from xml.etree import ElementTree
@@ -192,9 +194,11 @@
     def waiting_metadata(self):
         """Return a list of the operations in the meta-queue.
 
-        As we don't have meta-queue anymore, this is faked.  This method
+        As we don't have meta-queue anymore, this is faked. This method
         is deprecated, and will go away in a near future.
+
         """
+        warnings.warn('Use "waiting" method instead.', DeprecationWarning)
         logger.debug('called waiting_metadata')
         commands = self.syncdaemon_status.waiting_metadata()
         for op, data  in commands:
@@ -207,7 +211,9 @@
 
         As we don't have content-queue anymore, this is faked.  This method
         is deprecated, and will go away in a near future.
+
         """
+        warnings.warn('Use "waiting" method instead.', DeprecationWarning)
         logger.debug('called waiting_content')
         commands = self.syncdaemon_status.waiting_content()
         for data in commands:
@@ -265,14 +271,20 @@
         """Fire a signal to notify that the content queue has changed.
 
         This signal is deprecated, and will go away in a near future.
+
         """
+        msg = 'Connect to RequestQueueAdded/RequestQueueRemoved instead.'
+        warnings.warn(msg, DeprecationWarning)
 
     @dbus.service.signal(DBUS_IFACE_STATUS_NAME)
     def MetaQueueChanged(self):
         """Fire a signal to notify that the meta queue has changed.
 
         This signal is deprecated, and will go away in a near future.
+
         """
+        msg = 'Connect to RequestQueueAdded/RequestQueueRemoved instead.'
+        warnings.warn(msg, DeprecationWarning)
 
     @dbus.service.signal(DBUS_IFACE_STATUS_NAME, signature='ssa{ss}')
     def RequestQueueAdded(self, op_name, op_id, data):
@@ -906,10 +918,26 @@
         """Return the autoconnect config value."""
         return self.syncdaemon_config.autoconnect_enabled()
 
+    @dbus.service.method(DBUS_IFACE_CONFIG_NAME)
+    def enable_autoconnect(self):
+        """Enable syncdaemon autoconnect."""
+        self.syncdaemon_config.set_autoconnect_enabled(True)
+
+    @dbus.service.method(DBUS_IFACE_CONFIG_NAME)
+    def disable_autoconnect(self):
+        """Disable syncdaemon autoconnect."""
+        self.syncdaemon_config.set_autoconnect_enabled(False)
+
     @dbus.service.method(DBUS_IFACE_CONFIG_NAME,
                          in_signature='b', out_signature='')
     def set_autoconnect_enabled(self, enabled):
-        """Enable syncdaemon autoconnect."""
+        """Enable syncdaemon autoconnect.
+
+        This method is deprecated.
+
+        """
+        msg = 'Use enable_autoconnect/disable_autoconnect instead.'
+        warnings.warn(msg, DeprecationWarning)
         self.syncdaemon_config.set_autoconnect_enabled(enabled)
 
     @dbus.service.method(DBUS_IFACE_CONFIG_NAME,

=== modified file 'ubuntuone/platform/linux/tools.py'
--- ubuntuone/platform/linux/tools.py	2011-06-15 18:09:09 +0000
+++ ubuntuone/platform/linux/tools.py	2011-06-15 21:34:36 +0000
@@ -714,30 +714,40 @@
                                   error_handler=d.errback)
         return d
 
+
+    def _is_setting_enabled(self, setting_name):
+        """Return whether 'setting_name' is enabled."""
+        d = defer.Deferred()
+        config_client = DBusClient(self.bus, '/config',
+                                   DBUS_IFACE_CONFIG_NAME)
+        config_client.call_method('%s_enabled' % setting_name,
+                                  reply_handler=d.callback,
+                                  error_handler=d.errback)
+        return d
+
+    def _enable_setting(self, setting_name, enabled, dbus_method=None):
+        """Enable/disable 'setting_name'."""
+        d = defer.Deferred()
+        config_client = DBusClient(self.bus, '/config',
+                                   DBUS_IFACE_CONFIG_NAME)
+        if dbus_method is not None:
+            meth = dbus_method
+        elif enabled:
+            meth = 'enable_%s'
+        else:
+            meth = 'disable_%s'
+        config_client.call_method(meth % setting_name,
+                                  reply_handler=d.callback,
+                                  error_handler=d.errback)
+        return d
+
     def is_throttling_enabled(self):
         """Check if throttling is enabled."""
-        d = defer.Deferred()
-        config_client = DBusClient(self.bus, '/config',
-                                   DBUS_IFACE_CONFIG_NAME)
-        config_client.call_method('bandwidth_throttling_enabled',
-                                  reply_handler=d.callback,
-                                  error_handler=d.errback)
-        return d
-
+        return self._is_setting_enabled('bandwidth_throttling')
 
     def enable_throttling(self, enabled):
         """Enable/disable throttling."""
-        d = defer.Deferred()
-        config_client = DBusClient(self.bus, '/config',
-                                   DBUS_IFACE_CONFIG_NAME)
-        if enabled:
-            meth = 'enable_bandwidth_throttling'
-        else:
-            meth = 'disable_bandwidth_throttling'
-        config_client.call_method(meth,
-                                  reply_handler=d.callback,
-                                  error_handler=d.errback)
-        return d
+        return self._enable_setting('bandwidth_throttling', enabled)
 
     def is_files_sync_enabled(self):
         """Check if files sync is enabled."""
@@ -770,30 +780,37 @@
                 config.save()
                 self.start()
 
+    def is_autoconnect_enabled(self):
+        """Check if autoconnect is enabled."""
+        return self._is_setting_enabled('autoconnect')
+
+    def enable_autoconnect(self, enabled):
+        """Enable/disable autoconnect."""
+        return self._enable_setting('autoconnect', enabled)
+
     def is_show_all_notifications_enabled(self):
         """Check if show_all_notifications is enabled."""
-        d = defer.Deferred()
-        config_client = DBusClient(self.bus, '/config',
-                                   DBUS_IFACE_CONFIG_NAME)
-        config_client.call_method('show_all_notifications_enabled',
-                                  reply_handler=d.callback,
-                                  error_handler=d.errback)
-        return d
-
+        return self._is_setting_enabled('show_all_notifications')
 
     def enable_show_all_notifications(self, enabled):
         """Enable/disable show_all_notifications."""
-        d = defer.Deferred()
-        config_client = DBusClient(self.bus, '/config',
-                                   DBUS_IFACE_CONFIG_NAME)
-        if enabled:
-            meth = 'enable_show_all_notifications'
-        else:
-            meth = 'disable_show_all_notifications'
-        config_client.call_method(meth,
-                                  reply_handler=d.callback,
-                                  error_handler=d.errback)
-        return d
+        return self._enable_setting('show_all_notifications', enabled)
+
+    def is_share_autosubscribe_enabled(self):
+        """Check if share_autosubscribe is enabled."""
+        return self._is_setting_enabled('share_autosubscribe')
+
+    def enable_share_autosubscribe(self, enabled):
+        """Enable/disable share_autosubscribe."""
+        return self._enable_setting('share_autosubscribe', enabled)
+
+    def is_udf_autosubscribe_enabled(self):
+        """Check if udf_autosubscribe is enabled."""
+        return self._is_setting_enabled('udf_autosubscribe')
+
+    def enable_udf_autosubscribe(self, enabled):
+        """Enable/disable udf_autosubscribe."""
+        return self._enable_setting('udf_autosubscribe', enabled)
 
     def refresh_volumes(self):
         """Call refresh_volumes method via DBus.

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2011-04-01 20:10:14 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2011-06-15 21:34:36 +0000
@@ -205,6 +205,11 @@
     def shutdown(self):
         """Make the monitor shutdown."""
         self.monitor.shutdown()
+        # clean up all registered listeners
+        if len(self.listener_map.items()) > 0:
+            for k, v in self.listener_map.items():
+                v.clear()
+                del self.listener_map[k]
 
     def rm_watch(self, dirpath):
         """Remove watch from a dir."""

=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2011-04-06 17:31:12 +0000
+++ ubuntuone/syncdaemon/main.py	2011-06-15 21:34:36 +0000
@@ -46,6 +46,7 @@
 
 class WaitingHelpingHandler(object):
     """An auxiliary class that helps wait for events."""
+
     def __init__(self, event_queue, waiting_events, waiting_kwargs,
                  result=None):
         self.deferred = defer.Deferred()
@@ -104,7 +105,7 @@
         self.event_q = event_queue.EventQueue(self.fs, ignore_files)
         self.fs.register_eq(self.event_q)
 
-        # subscribe VM to EQ
+        # subscribe VM to EQ, to be unsubscribed in shutdown
         self.event_q.subscribe(self.vm)
         self.vm.init_root()
 
@@ -143,12 +144,14 @@
     def start_event_logger(self):
         """Start the event logger if it's available for this platform."""
         self.eventlog_listener = event_logging.get_listener(self.fs, self.vm)
+        # subscribe to EQ, to be unsubscribed in shutdown
         if self.eventlog_listener:
             self.event_q.subscribe(self.eventlog_listener)
 
     def start_status_listener(self):
         """Start the status listener if it is configured to start."""
         self.status_listener = status_listener.get_listener(self.fs, self.vm)
+        # subscribe to EQ, to be unsubscribed in shutdown
         if self.status_listener:
             self.event_q.subscribe(self.status_listener)
 
@@ -203,11 +206,20 @@
         """Shutdown the daemon; optionally restart it."""
         self.event_q.push('SYS_USER_DISCONNECT')
         self.event_q.push('SYS_QUIT')
+
+        self.event_q.unsubscribe(self.vm)
+        if getattr(self, 'eventlog_listener', None) is not None:
+            self.event_q.unsubscribe(self.eventlog_listener)
+        if getattr(self, 'status_listener', None) is not None:
+            self.event_q.unsubscribe(self.status_listener)
+
+        # shutdown these before event_q so the listeners are unsubscribed
+        self.state_manager.shutdown()
+        self.hash_q.shutdown()
+        self.external.shutdown(with_restart)
+
         self.event_q.shutdown()
-        self.hash_q.shutdown()
         self.db.shutdown()
-        self.state_manager.shutdown()
-        self.external.shutdown(with_restart)
         self.mark.stop()
 
     def restart(self):

=== modified file 'ubuntuone/syncdaemon/states.py'
--- ubuntuone/syncdaemon/states.py	2011-03-07 15:39:09 +0000
+++ ubuntuone/syncdaemon/states.py	2011-06-15 21:34:36 +0000
@@ -491,3 +491,4 @@
     def shutdown(self):
         """Finish all pending work."""
         self.connection.shutdown()
+        self.eq.unsubscribe(self)