Merge lp:~mandel/ubuntuone-client/windows_sdtool into lp:ubuntuone-client

[Manuel de la Peña]

Provides an SDTool implementation that works on windows.

Provides an SDTool implementation that works on windows. In order to run the tests please do:

python C:\Python27\Scripts\u1trial tests\platform\windows\test_tools.py

[Natalia Bidart (nataliabidart)]

* In order to really handle all the possible errors in UbuntuOneClient.connect, please add to it the inlineCallbacks decorator and change:

            d = self.factory.getRootObject()
            d.addCallback(self._request_remote_objects)
            return d

for:

            yield self.factory.getRootObject()
            yield self._request_remote_objects

* We need tests for the SDTool...

review: Needs Fixing

[lp:~mandel/ubuntuone-client/windows_sdtool]

1056. By Manuel de la Peña on 2011-06-23

Added the tests to ensure that the sdtool works as expected.

1057. By Manuel de la Peña on 2011-06-23

Merged with previous changes made on linux.

1058. By Manuel de la Peña on 2011-06-23

Fixed a number of lint issues

1059. By Manuel de la Peña on 2011-06-23

Use inlineCallbacks in the connect method.

1060. By Manuel de la Peña on 2011-06-23

Added forgotten test file.

1061. By Manuel de la Peña on 2011-06-23

Fixed lint issues and comments from reviews.

[Natalia Bidart (nataliabidart)]

review: Approve

[Alejandro J. Cura (alecu)]

As we discussed on IRC, it would make sense to have the functions that create and return a deferred use inlineCallbacks instead. Please fix this and remove the self.bus that's not defined anywhere.

Good branch otherwise, thanks!

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

Marking as Needs Fixing to track what Alejandro asked.

review: Needs Fixing

[Alejandro J. Cura (alecu)]

I'm changing the review to approve, pending the fixes that nessita will check.

review: Approve

[Natalia Bidart (nataliabidart)]

Filed bug #801685 so Manuel can make the improvements later, without blocking this branch.

review: Approve

=== modified file 'tests/platform/windows/test_ipc.py'
--- tests/platform/windows/test_ipc.py	2011-06-22 14:30:55 +0000
+++ tests/platform/windows/test_ipc.py	2011-06-23 16:46:29 +0000
@@ -2131,6 +2131,7 @@
         return d
     
     def test_enable_bandwidth_throttling(self):
+        """Enable bandwidth throttling."""
         reply_handler = lambda: None
         error_handler = lambda: None
     
@@ -2148,7 +2149,6 @@
         d.addCallback(test_execution)
         # pylint: enable=E1101
         return d
-        """Enable bandwidth throttling."""
     
     def test_disable_bandwidth_throttling(self):
         """Disable bandwidth throttling."""
 
=== added file 'tests/platform/windows/test_tools.py'
--- tests/platform/windows/test_tools.py	1970-01-01 00:00:00 +0000
+++ tests/platform/windows/test_tools.py	2011-06-23 16:46:29 +0000
@@ -0,0 +1,1043 @@
+# tests.platform.windows.test_tools - test tools for SyncDaemon
+#
+# Author: Manuel de la Pena <[e-mail]>
+#
+# 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/>.
+
+from mocker import Mocker, ANY
+
+from twisted.trial.unittest import TestCase
+from twisted.internet import defer, reactor
+from twisted.spread.pb import (
+    PBServerFactory,
+    Root)
+
+from ubuntuone.platform.windows.tools import SyncDaemonTool
+from ubuntuone.platform.windows.ipc import (
+    Config,
+    Events,
+    Folders,
+    FileSystem,
+    PublicFiles,
+    Shares,
+    Status,
+    SyncDaemon,
+    NAMED_PIPE_URL)
+
+
+class SaveProtocolServerFactory(PBServerFactory):
+    """A PBServerFactory that saves the latest connected client."""
+
+    protocolInstance = None
+
+    def clientConnectionMade(self, protocol):
+        """Keep track of the given protocol."""
+        self.protocolInstance = protocol
+
+
+class FakeRoot(Root):
+    """Root object that exposes the diff referenceable objects."""
+
+    def __init__(self, status, events, sync_daemon, file_system, shares,
+                 config, folders, public_files):
+        """Create a new instance that will expose the objects."""
+        self._status = status
+        self._events = events
+        self._sync_daemon = sync_daemon
+        self._file_system = file_system
+        self._shares = shares
+        self._config = config
+        self._folders = folders
+        self._public_files = public_files
+
+    def remote_get_status(self):
+        """Return the status remote object."""
+        return self._status
+
+    def remote_get_events(self):
+        """Return the events remote object."""
+        return self._events
+
+    def remote_get_sync_daemon(self):
+        """Return the sync daemon remote object."""
+        return self._sync_daemon
+
+    def remote_get_file_system(self):
+        """Return the file system remote object."""
+        return self._file_system
+
+    def remote_get_shares(self):
+        """Return the shares remote object."""
+        return self._shares
+
+    def remote_get_config(self):
+        """Return the config remote object."""
+        return self._config
+
+    def remote_get_folders(self):
+        """Return the folders remote object."""
+        return self._folders
+
+    def remote_get_public_files(self):
+        """Return the public files remote object."""
+        return self._public_files
+
+
+class TestSyncDaemonTool(TestCase):
+    """Various utility methods to test/play with the SyncDaemon."""
+
+    def setUp(self):
+        """Set up the different tests."""
+        super(TestSyncDaemonTool, self).setUp()
+        self.pipe = NAMED_PIPE_URL % 'test_stdtool'
+        self.mocker = Mocker()
+        self.root = self.mocker.mock()
+        self.status = Status(None, None, None)
+        self.status.syncdaemon_status = self.root
+        self.events = Events(None)
+        self.events.events = self.root
+        self.daemon = SyncDaemon(None, None, None, None)
+        self.daemon.service = self.root
+        self.fs = FileSystem(None, None)
+        self.fs.syncdaemon_filesystem  = self.root
+        self.shares = Shares(None, None)
+        self.shares.syncdaemon_shares = self.root
+        self.config = Config(None, None)
+        self.config.syncdaemon_config = self.root
+        self.folders = Folders(None, None)
+        self.folders.syncdaemon_folders = self.root
+        self.files = PublicFiles(None, None)
+        self.files.syncdaemon_public_files = self.root
+        self.is_running = self.mocker.replace(
+                                'ubuntuone.platform.windows.tools.is_running')
+        # start pb
+        self.syncdaemon_root = FakeRoot(self.status, self.events, self.daemon,
+                                        self.fs, self.shares, self.config,
+                                        self.folders, self.files)
+        self.server_factory = SaveProtocolServerFactory(self.syncdaemon_root)
+        # pylint: disable=E1101
+        self.listener = reactor.listenPipe(self.pipe, self.server_factory)
+        self.sdtool = SyncDaemonTool(named_pipe=self.pipe)
+
+    def tearDown(self):
+        """Clean reactor."""
+        if self.server_factory.protocolInstance is not None:
+            self.server_factory.protocolInstance.transport.loseConnection()
+        return defer.gatherResults([self._tearDownServer(),
+                                    self._tearDownClient()])
+
+    def _tearDownServer(self):
+        """Teardown the server."""
+        return defer.maybeDeferred(self.listener.stopListening)
+
+    def _tearDownClient(self):
+        """Tear down the client."""
+        self.sdtool.client.disconnect()
+        return defer.succeed(None)
+
+    @defer.inlineCallbacks
+    def _connect(self):
+        """Connect to the running service."""
+        yield self.sdtool.client.connect(self.pipe)
+        defer.returnValue(self.sdtool)
+
+    def test_wait_connected(self):
+        """Test that we wait until we connect to the server."""
+
+    def test_get_current_downloads(self):
+        """Test gettting the current downloads."""
+        downloads = [dict(name='name', id='id'),
+                     dict(name='name', id='id')]
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.current_downloads()
+            self.mocker.result(downloads)
+            self.mocker.replay()
+            result = yield sdtool.get_current_downloads()
+            self.mocker.verify()
+            self.assertEqual(downloads, result)
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_current_uploads(self):
+        """Test that we get all the current uploads."""
+        uploads = [dict(name='name', id='id'),
+                   dict(name='name', id='id')]
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.current_uploads()
+            self.mocker.replay()
+            self.mocker.result(uploads)
+            result = yield sdtool.get_current_uploads()
+            self.mocker.verify()
+            self.assertEqual(uploads, result)
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_wait_for_nirvana(self, last_event_interval=5, verbose=False):
+        """Test that we can reach nirvana."""
+        last_event_interval = 5
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.wait_for_nirvana(last_event_interval, ANY, ANY)
+            self.mocker.replay()
+            yield sdtool.wait_for_nirvana()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_accept_share(self):
+        """Test that we do accept the share."""
+        share_id = 'share_id'
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.accept_share(share_id, ANY, ANY)
+            self.mocker.replay()
+            yield sdtool.accept_share(share_id)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_reject_share(self):
+        """Test that we do reject the share."""
+        share_id = 'share_id'
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.reject_share(share_id, ANY, ANY)
+            self.mocker.replay()
+            yield sdtool.reject_share(share_id)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_subscribe_share(self):
+        """Test that we subscribe to the share."""
+        share_id = 'share_id'
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.subscribe(share_id)
+            self.mocker.replay()
+            yield sdtool.subscribe_share(share_id)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_unsubscribe_share(self):
+        """Unsubscribe from a share given its id."""
+        share_id = 'share_id'
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.unsubscribe(share_id)
+            self.mocker.replay()
+            yield sdtool.unsubscribe_share(share_id)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_shares(self):
+        """Test that we get the list of shares."""
+        shares = [dict(name='name', id='id'),
+                  dict(name='name', id='id')]
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_shares()
+            self.mocker.result(shares)
+            self.mocker.replay()
+            yield sdtool.get_shares()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_refresh_shares(self):
+        """Test that we can refresh the shares."""
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.refresh_shares()
+            self.mocker.replay()
+            yield sdtool.refresh_shares()
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_offer_share(self):
+        """Test that we can indeed offer a share."""
+        path = 'path'
+        username = 'username'
+        name = 'name'
+        access_level = 'level'
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.create_share(path, username, name, access_level)
+            self.mocker.replay()
+            yield sdtool.offer_share(path, username, name, access_level)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_list_shared(self):
+        """Test that we can list the shared."""
+        shares = [dict(name='name', id='id'),
+                  dict(name='name', id='id')]
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_shared()
+            self.mocker.result(shares)
+            self.mocker.replay()
+            yield sdtool.list_shared()
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_create_folder(self):
+        """Test that we can create a folder."""
+        path = 'path'
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.create(path)
+            self.mocker.replay()
+            yield sdtool.create_folder(path)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_delete_folder(self):
+        """Test that we can delete a folder."""
+        folder_id = 'folder_id'
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.delete(folder_id)
+            self.mocker.replay()
+            yield sdtool.delete_folder(folder_id)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_subscribe_folder(self):
+        """Test that we can subscribe to a folder."""
+        folder_id = 'folder_id' 
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.subscribe(folder_id )
+            self.mocker.replay()
+            yield sdtool.subscribe_folder(folder_id )
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_unsubscribe_folder(self):
+        """Test that we can unsubscribe to a folder."""
+        folder_id = 'folder_id'
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.unsubscribe(folder_id)
+            self.mocker.replay()
+            yield sdtool.unsubscribe_folder(folder_id)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_folders(self):
+        """Test that we can get the folders."""
+        folders = [dict(name='name', id='id'),
+                   dict(name='name', id='id')]
+    
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_folders()
+            self.mocker.result(folders)
+            self.mocker.replay()
+            yield sdtool.get_folders()
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_folder_info(self):
+        """Test that we can get the info of a folder."""
+        path = 'path'
+
+        @defer.inlineCallbacks
+        def test_execution(client):
+            """Actual test."""
+            self.root.get_info(path)
+            self.mocker.replay()
+            yield client.get_folder_info(path)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_metadata(self):
+        """Test that we can get the metadata."""
+        path = 'path'
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_metadata(path)
+            self.mocker.replay()
+            yield sdtool.get_metadata(path)
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_change_public_access(self):
+        """Test that we can change the public access."""
+        path = 'path'
+        share_id = 'share_id'
+        node_id = 'node_id'
+        is_public = False
+        metadata = dict(share_id=share_id, node_id=node_id)
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_metadata(path)
+            self.mocker.result(metadata)
+            self.root.change_public_access(share_id, node_id, is_public)
+            self.mocker.replay()
+            yield sdtool.change_public_access(path, is_public)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_quit(self):
+        """Test that we can quit."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.is_running()
+            self.mocker.result(True)
+            self.root.quit(None, None)
+            self.mocker.replay()
+            yield sdtool.quit()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_connect(self):
+        """Test we can connect."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.connect()
+            self.mocker.replay()
+            yield sdtool.connect()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_disconnect(self):
+        """Test we can disconnect."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.disconnect()
+            self.mocker.replay()
+            yield sdtool.disconnect()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_status(self):
+        """Test we can get the status."""
+        status = dict(is_error=False, is_online=True, is_connected=True)
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.current_status()
+            self.mocker.result(status)
+            self.mocker.replay()
+            yield sdtool.get_status()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_waiting(self):
+        """Test that we get the info of what is waitig."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.waiting()
+            self.mocker.result({})
+            self.mocker.replay()
+            yield sdtool.waiting()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_waiting_metadata(self):
+        """Test that we can get the waiting metadata."""
+        
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.waiting_metadata()
+            self.mocker.replay()
+            yield sdtool.waiting_metadata()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_waiting_content(self):
+        """Test that we get the waiting content."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.waiting_content()
+            self.mocker.replay()
+            yield sdtool.waiting_content()
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_throttling_limits(self):
+        """Test that we get the throttling limits."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_throttling_limits(ANY, ANY)
+            self.mocker.replay()
+            yield sdtool.get_throttling_limits()
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_set_throttling_limits(self):
+        """Test that we can set the limits."""
+        download = 'download'
+        upload = 'upload'
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.set_throttling_limits(download, upload, ANY, ANY)
+            self.mocker.replay()
+            yield sdtool.set_throttling_limits(download, upload)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_is_throttling_enabled(self):
+        """Test that we get the bool stating if they are active."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.bandwidth_throttling_enabled(ANY, ANY)
+            self.mocker.result(True)
+            self.mocker.replay()
+            result = yield sdtool.is_throttling_enabled()
+            self.mocker.verify()
+            self.assertTrue(result)
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_throttling_true(self):
+        """Test that we can set them."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.enable_bandwidth_throttling(ANY, ANY)
+            self.mocker.replay()
+            yield sdtool.enable_throttling(True)
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_throttling_false(self):
+        """Test that we can set them."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.disable_bandwidth_throttling(ANY, ANY)
+            self.mocker.replay()
+            yield sdtool.enable_throttling(False)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_is_autoconnect_enabled(self):
+        """Test that we can read the config."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.autoconnect_enabled()
+            self.mocker.replay()
+            self.mocker.result(True)
+            result = yield sdtool.is_autoconnect_enabled()
+            self.mocker.verify()
+            self.assertTrue(result)
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_autoconnect(self):
+        """Test that we can enable the autoconnect."""
+        enabled = False
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.set_autoconnect_enabled(enabled)
+            self.mocker.replay()
+            yield sdtool.enable_autoconnect(enabled)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_is_show_all_notifications_enabled(self):
+        """Test if we can read the info."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.show_all_notifications_enabled()
+            self.mocker.result(True)
+            self.mocker.replay()
+            result = yield sdtool.is_show_all_notifications_enabled()
+            self.mocker.verify()
+            self.assertTrue(result)
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_show_all_notifications_true(self):
+        """Enable/disable show_all_notifications."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.enable_show_all_notifications()
+            self.mocker.replay()
+            yield sdtool.enable_show_all_notifications(True)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_show_all_notifications_false(self):
+        """Enable/disable show_all_notifications."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.disable_show_all_notifications()
+            self.mocker.replay()
+            yield sdtool.enable_show_all_notifications(False)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_is_share_autosubscribe_enabled(self):
+        """Test that we can get the config."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.share_autosubscribe_enabled()
+            self.mocker.result(True)
+            self.mocker.replay()
+            result = yield sdtool.is_share_autosubscribe_enabled()
+            self.mocker.verify()
+            self.assertTrue(result)
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_share_autosubscribe_true(self):
+        """Enable/disable share_autosubscribe."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.enable_share_autosubscribe()
+            self.mocker.replay()
+            yield sdtool.enable_share_autosubscribe(True)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_share_autosubscribe_false(self):
+        """Enable/disable share_autosubscribe."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.disable_share_autosubscribe()
+            self.mocker.replay()
+            yield sdtool.enable_share_autosubscribe(False)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_is_udf_autosubscribe_enabled(self):
+        """Test that we can get the config value."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.udf_autosubscribe_enabled()
+            self.mocker.result(True)
+            self.mocker.replay()
+            result = yield sdtool.is_udf_autosubscribe_enabled()
+            self.mocker.verify()
+            self.assertTrue(result)
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_udf_autosubscribe_true(self):
+        """Test that we can get the config."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.enable_udf_autosubscribe()
+            self.mocker.replay()
+            yield sdtool.enable_udf_autosubscribe(True)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_enable_udf_autosubscribe_false(self):
+        """Test that we can set the config."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.disable_udf_autosubscribe()
+            self.mocker.replay()
+            yield sdtool.enable_udf_autosubscribe(False)
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_refresh_volumes(self):
+        """Test that we can refresh the volumes."""
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.refresh_volumes()
+            self.mocker.replay()
+            yield sdtool.refresh_volumes()
+            self.mocker.verify()
+    
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_rescan_from_scratch(self):
+        """Test that we can rescan from scratch."""
+        volume_id = 'volume_id'
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.rescan_from_scratch(volume_id)
+            self.mocker.replay()
+            yield sdtool.rescan_from_scratch(volume_id)
+            self.mocker.verify()
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_dirty_nodes(self):
+        """Test that we get the dirty nodes."""
+        dirty_nodes = ['node_1', 'node_2', 'node_3']
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_dirty_nodes()
+            self.mocker.result(dirty_nodes)
+            self.mocker.replay()
+            result = yield sdtool.get_dirty_nodes()
+            self.mocker.verify()
+            self.assertEqual(dirty_nodes, result)
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_root_dir(self):
+        """Test that we get the root dir."""
+        root = '/path/to/root'
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_rootdir()
+            self.mocker.result(root)
+            self.mocker.replay()
+            result = yield sdtool.get_root_dir()
+            self.mocker.verify()
+            self.assertEqual(root, result)
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_shares_dir(self):
+        """Test that we get the shares dir."""
+        shares_dir = '/path/to/shares'
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_sharesdir()
+            self.mocker.result(shares_dir)
+            self.mocker.replay()
+            result = yield sdtool.get_shares_dir()
+            self.mocker.verify()
+            self.assertEqual(shares_dir, result)
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_shares_dir_link(self):
+        """Test that we get the link dir."""
+        link = 'path/to/link'
+
+        @defer.inlineCallbacks
+        def test_execution(sdtool):
+            """Actual test."""
+            self.root.get_sharesdir_link()
+            self.mocker.result(link)
+            self.mocker.replay()
+            result = yield sdtool.get_shares_dir_link()
+            self.mocker.verify()
+            self.assertEqual(link, result)
+
+        d = self._connect()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d       
 
=== modified file 'ubuntuone/platform/windows/ipc_client.py'
--- ubuntuone/platform/windows/ipc_client.py	2011-05-04 13:39:41 +0000
+++ ubuntuone/platform/windows/ipc_client.py	2011-06-23 16:46:29 +0000
@@ -18,13 +18,26 @@
 """Client lib to simplify the ipc client code."""
 
 import logging
+
 from functools import wraps
-from twisted.spread.pb import Referenceable
-from ubuntuone.platform.windows.ipc import RemoteMeta
+from win32api import GetUserNameEx
+from win32con import NameSamCompatible
+from twisted.internet import defer, reactor
+from twisted.spread.pb import Referenceable, PBClientFactory
+
+from ubuntuone.platform.windows.ipc import RemoteMeta, NAMED_PIPE_URL
 
 logger = logging.getLogger("ubuntuone.SyncDaemon.Client")
 
 
+class SyncDaemonClientError(Exception):
+    """Error ocurred when trying to be a client."""
+
+
+class SyncDaemonClientConnectionError(SyncDaemonClientError):
+    """Error ocurrend when trying to connect."""
+
+
 def remote(function):
     """Decorate the function to make the remote call."""
     @wraps(function)
@@ -660,3 +673,95 @@
     @signal
     def on_public_files_list_error(self, error):
         """Emit the PublicFilesListError signal."""
+
+class UbuntuOneClient(object):
+    """Root object that provides access to all the remote objects."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.status = None
+        self.events = None
+        self.sync_daemon = None
+        self.file_system = None
+        self.shares = None
+        self.config = None
+        self.folders = None
+        self.public_files = None
+        self.factory = None
+        self.client = None
+
+    @defer.inlineCallbacks
+    def _request_remote_objects(self, root):
+        """Request all the diff remote objects used for the communication."""
+        status = yield root.callRemote('get_status')
+        self.status = StatusClient(status)
+
+        events = yield root.callRemote('get_events')
+        self.events = EventsClient(events)
+
+        sync_daemon = yield root.callRemote('get_sync_daemon')
+        self.sync_daemon = SyncDaemonClient(sync_daemon)
+
+        file_system = yield root.callRemote('get_file_system')
+        self.file_system = FileSystemClient(file_system)
+
+        shares = yield root.callRemote('get_shares')
+        self.shares = SharesClient(shares)
+
+        config = yield root.callRemote('get_config')
+        self.config = ConfigClient(config)
+
+        folders = yield root.callRemote('get_folders')
+        self.folders = FoldersClient(folders)
+
+        public_files = yield root.callRemote('get_public_files')
+        self.public_files = PublicFilesClient(public_files)
+
+        defer.returnValue(self)
+
+    @defer.inlineCallbacks
+    def connect(self, pipe=None):
+        """Connect to the sso service."""
+        # pylint: disable=W0702
+        try:
+            if pipe is None:
+                pipe = NAMED_PIPE_URL % GetUserNameEx(NameSamCompatible)
+            # got the pipe, lets try and  connect to it and get the diff
+            # remote objects for the wrappers
+            self.factory = PBClientFactory()
+            # the reactor does have a connectTCP method
+            # pylint: disable=E1101
+            self.client = reactor.connectPipe(pipe, self.factory)
+            # pylint: enable=E1101
+            yield self.factory.getRootObject()
+            yield self._request_remote_objects()
+        except:
+            raise SyncDaemonClientConnectionError(
+                            'Could not connect to the syncdaemon on pipe %.',
+                            pipe)
+        # pylint: disable=W0702
+
+    @defer.inlineCallbacks
+    def register_to_signals(self):
+        """Register the different clients to the signals."""
+        for client in [self.status, self.events, self.sync_daemon, self.shares,
+                       self.folders, self.public_files]:
+            register = getattr(client, 'register_to_signals', None)
+            if register is not None:
+                yield register()
+        defer.returnValue(self)
+
+    @defer.inlineCallbacks
+    def unregister_to_signals(self):
+        """Unregister from the diff signals."""
+        for client in [self.status, self.events, self.sync_daemon, self.shares,
+                       self.folders, self.public_files]:
+            unregister = getattr(client, 'unregister_to_signals', None)
+            if unregister is not None:
+                yield unregister()
+        defer.returnValue(self)
+
+    def disconnect(self):
+        """Disconnect from the process."""
+        if self.client:
+            self.client.disconnect()
 
=== added file 'ubuntuone/platform/windows/tools.py'
--- ubuntuone/platform/windows/tools.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/platform/windows/tools.py	2011-06-23 16:46:29 +0000
@@ -0,0 +1,570 @@
+# ubuntuone.syncdaemon.tools - tools for SyncDaemon
+#
+# Author: Guillermo Gonzalez <[e-mail]>
+#         Manuel de la Pena <[e-mail]>
+#
+# 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/>.
+
+"""SyncDaemon Tools."""
+
+import logging
+import time
+import sys
+
+from win32api import GetUserNameEx
+from win32con import NameSamCompatible
+from win32pipe import CallNamedPipe
+from twisted.internet import defer, reactor
+
+from ubuntuone.syncdaemon.config import get_user_config
+from ubuntuone.platform.windows.ipc import NAMED_PIPE_URL
+from ubuntuone.platform.windows.ipc_client import UbuntuOneClient
+
+
+def is_running(bus=None):
+    """Check if there is a syncdaemon instance running.
+
+    Running means the name is registered in the given bus.
+
+    """
+    pipe = NAMED_PIPE_URL % GetUserNameEx(NameSamCompatible)
+    try:
+        CallNamedPipe(pipe, '', 512, 0)
+        return True
+    except:
+        return False
+
+
+class SyncDaemonTool(object):
+    """Various utility methods to test/play with the SyncDaemon."""
+
+    def __init__(self, named_pipe=None):
+        self.named_pipe = named_pipe
+        self.client = UbuntuOneClient() 
+        self.last_event = 0
+        self.delayed_call = None
+        self.log = logging.getLogger('ubuntuone.SyncDaemon.SDTool')
+
+
+    def _get_dict(self, a_dict):
+        """Converts a dict returned by the IPC to a dict of strings."""
+        str_dict = {}
+        for key in a_dict:
+            str_dict[key] = unicode(a_dict[key])
+        return str_dict
+
+    def wait_connected(self):
+        """Wait until syncdaemon is connected to the server."""
+        self.log.debug('wait_connected')
+        d = defer.Deferred()
+
+        def check_connection_status():
+            """Check if the daemon is up and running."""
+            # check if the syncdaemon is running
+            # catch all errors, pylint: disable-msg=W0703
+            try:
+                self.client.connect(pipe=self.named_pipe)
+                d.callback(True)
+            except Exception, e:
+                self.log.debug('Not connected: %s', e)
+                d.errback()
+
+        reactor.callLater(.5, check_connection_status)
+        return d
+
+    def get_current_downloads(self):
+        """Return a deferred that will be fired with the current downloads."""
+        d = defer.Deferred()
+
+        def reply_handler(downloads, d):
+            """Current downloads callback."""
+            downloads_str = []
+            for download in downloads:
+                downloads_str.append(self._get_dict(download))
+            d.callback(downloads_str)
+
+        downloads_d = self.client.status.current_downloads()
+        downloads_d.addCallback(lambda downloads: reply_handler(downloads, d))
+        return d
+
+    def wait_all_downloads(self, verbose=False):
+        """Wait until there is no more pending downloads."""
+        self.log.debug('wait_all_downloads')
+        d = self.get_current_downloads()
+
+        def reply_handler(downloads):
+            """Check if the are downloads in progress.
+
+            If so, reschelude a new check if there is at least one.
+
+            """
+            if verbose:
+                sys.stdout.write(', %s' % str(len(downloads)))
+                sys.stdout.flush()
+            if len(downloads) > 0:
+                self.log.debug('wait_all_downloads: %d', len(downloads))
+                return self.get_current_downloads()
+            else:
+                self.log.debug('wait_all_downloads: No more downloads')
+                return True
+
+        if verbose:
+            sys.stdout.write('\nchecking current downloads')
+            sys.stdout.flush()
+        d.addCallback(reply_handler)
+        return d
+
+    def get_current_uploads(self):
+        """Return a deferred that will be called with the current uploads."""
+        d = defer.Deferred()
+
+        def reply_handler(uploads, d):
+            """Reply handler."""
+            uploads_str = []
+            for upload in uploads:
+                uploads_str.append(self._get_dict(upload))
+            d.callback(uploads_str)
+
+        uploads_d = self.client.status.current_uploads()
+        uploads_d.addCallback(lambda uploads: reply_handler(uploads, d))
+        return d
+
+    def wait_all_uploads(self, verbose=False):
+        """Wait until there is no more pending uploads."""
+        self.log.debug('wait_all_uploads')
+        d = self.get_current_uploads()
+
+        def reply_handler(uploads):
+            """Check if the are downloads in progress.
+
+            If so, reschelude a new check if there is at least one.
+
+            """
+            if verbose:
+                sys.stdout.write(', %s' % str(len(uploads)))
+                sys.stdout.flush()
+            if len(uploads) > 0:
+                self.log.debug('wait_all_uploads: %d', len(uploads))
+                return self.get_current_uploads()
+            else:
+                self.log.debug('wait_all_uploads: No more uploads')
+                return True
+
+        if verbose:
+            sys.stdout.write('\nchecking current uploads')
+            sys.stdout.flush()
+
+        d.addCallback(reply_handler)
+        return d
+
+    def wait_no_more_events(self, last_event_interval, verbose=False):
+        """Wait until no more events are fired by the syncdaemon."""
+        self.log.debug('wait_no_more_events')
+        d = defer.Deferred()
+
+        def check_last_event():
+            """Check time!
+
+            Check if the daemon is connected and didn't received event
+            in the last_event_interval.
+            """
+            current_time = time.time()
+            if self.last_event and \
+               current_time - self.last_event < last_event_interval:
+                # keep it running in case this is the last event
+                self.log.debug('rescheduling wait_no_more_events')
+                if not self.delayed_call.active():
+                    self.delayed_call = reactor.callLater(last_event_interval,
+                                                          check_last_event)
+                else:
+                    self.delayed_call.reset(last_event_interval)
+            else:
+                self.log.debug('wait_no_more_events: No more events!')
+                d.callback(True)
+
+        if verbose:
+            sys.stdout.write("Listening events")
+            sys.stdout.flush()
+
+        def event_handler(event_dict):
+            """Update last_event and run checks."""
+            self.last_event = time.time()
+            self.log.debug('wait_no_more_events - new event: %s - %s',
+                           event_dict['event_name'], str(self.last_event))
+            if verbose:
+                sys.stdout.write('.')
+                sys.stdout.flush()
+            if self.delayed_call.active():
+                self.delayed_call.reset(last_event_interval)
+
+        self.client.events.on_event_cb = event_handler
+
+        def cleanup(result):
+            """Remove the signal handler."""
+            self.client.events.on_event_cb = None
+            return result
+        d.addBoth(cleanup)
+
+        # in case the daemon already reached nirvana
+        self.delayed_call = reactor.callLater(last_event_interval,
+                                              check_last_event)
+        return d
+
+    def wait_for_nirvana(self, last_event_interval=5, verbose=False):
+        """Wait until the syncdaemon reachs nirvana.
+
+        This is when there are:
+            - the syncdaemon is connected
+            - 0 transfers inprogress
+            - no more events are fired in the event queue
+        @param last_event_interval: the seconds to wait to determine that there
+        is no more events in the queue and the daemon reached nirvana
+        """
+        self.log.debug('wait_for_nirvana')
+        return self.client.sync_daemon.wait_for_nirvana(last_event_interval)
+
+    def accept_share(self, share_id):
+        """Accept the share with id: share_id."""
+        self.log.debug('accept_share(%s)', share_id)
+        self.client.shares.on_share_answer_response = lambda info:\
+                                                info['volume_id']==share_id
+        return self.client.shares.accept_share(share_id)
+
+    def reject_share(self, share_id):
+        """Reject the share with id: share_id."""
+        self.log.debug('reject_share(%s)', share_id)
+        self.client.shares.on_share_answer_response = lambda info:\
+                                                info['volume_id']==share_id
+        return self.client.shares.reject_share(share_id)
+
+    def subscribe_share(self, share_id):
+        """Subscribe to a share given its id."""
+        self.log.debug('subscribe_share: %r', share_id)
+        return self.client.shares.subscribe(share_id)
+
+    def unsubscribe_share(self, share_id):
+        """Unsubscribe from a share given its id."""
+        self.log.debug('unsubscribe_share: %r', share_id)
+        return self.client.shares.unsubscribe(share_id)
+
+    def get_shares(self):
+        """Get the list of shares (accepted or not)."""
+        self.log.debug('get_shares')
+        d = defer.Deferred()
+
+        def reply_handler(results):
+            """Get_shares reply handler."""
+            shares = []
+            for result in results:
+                shares.append(self._get_dict(result))
+            self.log.debug('shares: %r', shares)
+            d.callback(shares)
+
+        shares_d = self.client.shares.get_shares()
+        shares_d.addCallback(reply_handler)
+        return d
+
+    def refresh_shares(self):
+        """Call refresh_shares method via DBus.
+
+        Request a refresh of share list to the server.
+
+        """
+        self.log.debug('refresh_shares')
+        return self.client.shares.refresh_shares()
+
+    def offer_share(self, path, username, name, access_level):
+        """Offer a share at the specified path to user with id: username."""
+        self.log.debug('offer_share(%s, %s, %s, %s)',
+                   path, username, name, access_level)
+        return self.client.shares.create_share(path, username, name,
+                                               access_level)
+
+    def list_shared(self):
+        """Get the list of the shares "shared"/created/offered."""
+        self.log.debug('list_shared')
+        d = defer.Deferred()
+
+        def reply_handler(results):
+            """Get_shares reply handler."""
+            shares = []
+            for result in results:
+                shares.append(self._get_dict(result))
+            self.log.debug('shared: %r', shares)
+            d.callback(shares)
+
+        shared_d = self.client.shares.get_shared()
+        shared_d.addCallback(reply_handler)
+        return d
+
+    def wait_for_signals(self, signal_ok, signal_error,
+                         dbus_iface=None):
+        """Wait for one of the specified signals, return a deferred.
+
+        @param signal_ok: this will fire the deferred's callback
+        @param signal_error: the will fire the deferred's errback
+        @param dbus_iface: the interface the signal belongs to
+        """
+        raise NotImplementedError('Not implemented yet!')
+
+    def create_folder(self, path):
+        """Create a user defined folder in the specified path."""
+        self.log.debug('create_folder')
+        return self.client.folders.create(path)
+
+    def delete_folder(self, folder_id):
+        """Delete a user defined folder given its id."""
+        self.log.debug('delete_folder')
+        return self.client.folders.delete(folder_id)
+
+    def subscribe_folder(self, folder_id):
+        """Subscribe to a user defined folder given its id."""
+        self.log.debug('subscribe_folder')
+        return self.client.folders.subscribe(folder_id)
+
+    def unsubscribe_folder(self, folder_id):
+        """Unsubscribe from a user defined folder given its id."""
+        self.log.debug('unsubscribe_folder')
+        return self.client.folders.unsubscribe(folder_id)
+
+    def get_folders(self):
+        """Return the list of folders (a list of dicts)."""
+        self.log.debug('get_folders')
+        d = defer.Deferred()
+
+        def reply_handler(results):
+            """Get_folders reply handler."""
+            folders = []
+            for result in results:
+                folders.append(self._get_dict(result))
+            self.log.debug('folders: %r', folders)
+            d.callback(folders)
+
+        folders_d = self.client.folders.get_folders()
+        folders_d.addCallback(reply_handler)
+        return d
+
+    def get_folder_info(self, path):
+        """Call the get_info method for a UDF path."""
+        self.log.debug('get_info')
+        return self.client.folders.get_info(path)
+
+    def get_metadata(self, path):
+        """Call the exposed mtehod FileSystem.get_metadata using DBus."""
+        self.log.debug('get_metadata(%s)', path)
+        return self.client.file_system.get_metadata(path)
+
+    @defer.inlineCallbacks
+    def change_public_access(self, path, is_public):
+        """Change the public access for a given path."""
+        self.log.debug('change_public_access(%s)', path)
+        metadata = yield self.client.file_system.get_metadata(path)
+        file_info = yield self.client.public_files.change_public_access(
+                                                          metadata['share_id'],
+                                                          metadata['node_id'],
+                                                          is_public)
+        defer.returnValue(file_info)
+
+    def quit(self):
+        """Quit the syncdaemon."""
+        self.log.debug('quit')
+        # avoid triggering dbus activation while calling quit
+        if not is_running():
+            return defer.succeed(None)
+
+        def check(r):
+            """Wait 0.5 sec to return, to allow syncdaemon to shutdown."""
+            d1 = defer.Deferred()
+            reactor.callLater(0.5, d1.callback, r)
+            return d1
+        
+        d = self.client.sync_daemon.quit()
+        d.addCallback(check)
+        return d
+
+    def wait_for_signal(self, signal_name, filter):
+        """Wait for the specified DBus signal (the first received).
+
+        @param signal_name: the signal name
+        @param filter: a callable to filter signal, must return True, and is
+        used to fire the deferred callback.
+
+        """
+        raise NotImplementedError('Not implemented.')
+
+    def connect(self):
+        """Connect syncdaemon."""
+        return self.client.sync_daemon.connect()
+
+    def disconnect(self):
+        """Disconnect syncdaemon."""
+        return self.client.sync_daemon.disconnect()
+
+    def get_status(self):
+        """Get the current_status dict."""
+
+        d = defer.Deferred()
+        def reply_handler(status):
+            """The reply handler"""
+            state_dict = self._get_dict(status)
+            state_dict['is_connected'] = bool(state_dict['is_connected'])
+            state_dict['is_online'] = bool(state_dict['is_online'])
+            state_dict['is_error'] = bool(state_dict['is_error'])
+            d.callback(state_dict)
+        status_d = self.client.status.current_status()
+        status_d.addCallback(reply_handler)
+        status_d.addErrback(d.errback)
+        return d
+
+    def waiting(self):
+        """Return a description of the waiting queue elements."""
+        return self.client.status.waiting()
+
+    def waiting_metadata(self):
+        """Return a description of the waiting metadata queue elements."""
+        return self.client.status.waiting_metadata()
+
+    def waiting_content(self):
+        """Return the waiting content queue elements."""
+        return self.client.status.waiting_content()
+
+    def start(self):
+        """Start syncdaemon if it's not running."""
+        if not is_running(self.bus):
+            raise Exception('Not implemented yet!')
+        else:
+            return defer.succeed(None)
+
+    def get_throttling_limits(self):
+        """Return a dict with the read and write limits."""
+        return self.client.config.get_throttling_limits()
+
+    def set_throttling_limits(self, read_limit, write_limit):
+        """Set the read and write limits."""
+        return self.client.config.set_throttling_limits(read_limit,
+                                                        write_limit)
+
+    def is_throttling_enabled(self):
+        """Check if throttling is enabled."""
+        return self.client.config.bandwidth_throttling_enabled()
+
+    def enable_throttling(self, enabled):
+        """Enable/disable throttling."""
+        if enabled:
+            return self.client.config.enable_bandwidth_throttling()
+        else:
+            return self.client.config.disable_bandwidth_throttling()
+
+    def is_files_sync_enabled(self):
+        """Check if files sync is enabled."""
+        self.log.debug('is_files_sync_enabled')
+        return get_user_config().get_files_sync_enabled()
+
+    @defer.inlineCallbacks
+    def enable_files_sync(self, enabled):
+        """Enable/disable files sync."""
+        config = get_user_config()
+        was_enabled = config.get_files_sync_enabled()
+        self.log.debug('enable_files_sync: enable? %r was enabled? %r',
+                       enabled, was_enabled)
+        if was_enabled:
+            yield self.client.config.set_files_sync_enabled(enabled)
+            config.set_files_sync_enabled(enabled)
+            if not enabled:
+                # User requested the service to be disabled
+                self.quit()
+        else:
+            if enabled:
+                config.set_files_sync_enabled(True)
+                config.save()
+                self.start()
+
+    def is_autoconnect_enabled(self):
+        """Check if autoconnect is enabled."""
+        return self.client.config.autoconnect_enabled()
+
+    def enable_autoconnect(self, enabled):
+        """Enable/disable autoconnect."""
+        return self.client.config.set_autoconnect_enabled(enabled)
+
+    def is_show_all_notifications_enabled(self):
+        """Check if show_all_notifications is enabled."""
+        return self.client.config.show_all_notifications_enabled()
+
+    def enable_show_all_notifications(self, enabled):
+        """Enable/disable show_all_notifications."""
+        if enabled:
+            return self.client.config.enable_show_all_notifications()
+        else:
+            return self.client.config.disable_show_all_notifications()
+
+    def is_share_autosubscribe_enabled(self):
+        """Check if share_autosubscribe is enabled."""
+        return self.client.config.share_autosubscribe_enabled()
+
+    def enable_share_autosubscribe(self, enabled):
+        """Enable/disable share_autosubscribe."""
+        if enabled:
+            return self.client.config.enable_share_autosubscribe()
+        else:
+            return self.client.config.disable_share_autosubscribe()
+
+    def is_udf_autosubscribe_enabled(self):
+        """Check if udf_autosubscribe is enabled."""
+        return self.client.config.udf_autosubscribe_enabled()
+
+    def enable_udf_autosubscribe(self, enabled):
+        """Enable/disable udf_autosubscribe."""
+        if enabled:
+            return self.client.config.enable_udf_autosubscribe()
+        else:
+            return self.client.config.disable_udf_autosubscribe()
+
+    def refresh_volumes(self):
+        """Call refresh_volumes method via DBus.
+
+        Request the volumes list to the server.
+        """
+        self.log.debug('refresh_volumes')
+        return self.client.folders.refresh_volumes()
+
+    def rescan_from_scratch(self, volume_id):
+        """Call rescan_from_scratch via DBus.
+
+        Request a rescan from scratch for volume_id.
+        """
+        self.log.debug('rescan_from_scratch %r', volume_id)
+        return self.client.sync_daemon.rescan_from_scratch(volume_id)
+
+    def get_dirty_nodes(self):
+        """Call get_dirty_nodes via DBus.
+
+        Return the list of dirty nodes.
+        """
+        self.log.debug('get_dirty_nodes')
+        return self.client.file_system.get_dirty_nodes()
+
+    def get_root_dir(self):
+        """Return the root directory."""
+        return self.client.sync_daemon.get_rootdir()
+
+    def get_shares_dir(self):
+        """Return the shares directory."""
+        return self.client.sync_daemon.get_sharesdir()
+
+    def get_shares_dir_link(self):
+        """Return the shares link directory."""
+        return self.client.sync_daemon.get_sharesdir_link()
+