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

[Manuel de la Peña]

Adds the basic implementation of the remotes objects that will expose the DBus API found on Linux on Windows using twisted.pb.

Adds the basic implementation of the remotes objects that will expose the DBus API found on Linux on Windows using twisted.pb. To run the tests executed on windows:

u1trial tests/platform/windows/test_ipc.py
u1trial tests/platform/test_interaction_interfaces.py

The tests on Linux should all pas and can be ran with 'make check'

[Facundo Batista (facundo)]

In linux all tests pass. Not tested in windows.

review: Approve

[Manuel de la Peña (mandel)]

> In linux all tests pass. Not tested in windows

Tx! I'll make sure I get a windows review.

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'tests/platform/test_interaction_interfaces.py'
--- tests/platform/test_interaction_interfaces.py	2011-02-16 10:04:56 +0000
+++ tests/platform/test_interaction_interfaces.py	2011-02-23 09:03:55 +0000
@@ -17,7 +17,7 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Test that the interaction_interfaces are correctly called."""
 
-from mocker import MockerTestCase
+from mocker import MockerTestCase, MATCH
 from tests.platform import IPCTestCase
 
 class TestStatusIPC(MockerTestCase, IPCTestCase):
@@ -146,10 +146,10 @@
         """Test if the method is relayed."""
         result = 'nirvana'
         last_event_interval = 'interval'
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.service.wait_for_nirvana(last_event_interval, reply_handler,
-            error_handler)
+        reply_handler = lambda: None 
+        error_handler = lambda: None 
+        self.service.wait_for_nirvana(last_event_interval, MATCH(callable),
+            MATCH(callable))
         self.mocker.result(result)
         self.mocker.replay()
         self.assertEqual(result, self.sync.wait_for_nirvana(
@@ -157,9 +157,9 @@
 
     def test_quit(self):
         """Test if the method is relayed."""
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.service.quit(reply_handler, error_handler)
+        reply_handler = lambda: None 
+        error_handler = lambda: None 
+        self.service.quit(MATCH(callable), MATCH(callable))
         self.mocker.replay()
         self.sync.quit(reply_handler, error_handler)
 
@@ -238,20 +238,20 @@
     def test_accept_share(self):
         """Test if the method is relayed."""
         share_id = 'id'
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.syncdaemon_shares.accept_share(share_id, reply_handler,
-            error_handler)
+        reply_handler = lambda: None 
+        error_handler = lambda: None 
+        self.syncdaemon_shares.accept_share(share_id, MATCH(callable),
+            MATCH(callable))
         self.mocker.replay()
         self.shares.accept_share(share_id, reply_handler, error_handler)
 
     def test_reject_share(self):
         """Test if the method is relayed."""
         share_id = 'id'
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.syncdaemon_shares.reject_share(share_id, reply_handler,
-            error_handler)
+        reply_handler = lambda: None 
+        error_handler = lambda: None 
+        self.syncdaemon_shares.reject_share(share_id, MATCH(callable),
+            MATCH(callable))
         self.mocker.replay()
         self.shares.reject_share(share_id, reply_handler, error_handler)
 
@@ -324,10 +324,10 @@
 
     def test_get_throttling_limits(self):
         """Test if the method is relayed."""
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.syncdaemon_config.get_throttling_limits(reply_handler,
-            error_handler)
+        reply_handler = lambda: None
+        error_handler = lambda: None
+        self.syncdaemon_config.get_throttling_limits(MATCH(callable),
+            MATCH(callable))
         self.mocker.replay()
         self.config.get_throttling_limits(reply_handler, error_handler)
 
@@ -335,39 +335,39 @@
         """Test if the method is relayed."""
         download = 'download'
         upload = 'upload'
-        reply_handler = 'handler'
-        error_handler = 'error'
+        reply_handler = lambda: None
+        error_handler = lambda: None
         self.syncdaemon_config.set_throttling_limits(download, upload,
-            reply_handler, error_handler)
+            MATCH(callable), MATCH(callable))
         self.mocker.replay()
         self.config.set_throttling_limits(download, upload, reply_handler,
             error_handler)
 
     def test_enable_bandwidth_throttling(self):
         """Test if the method is relayed."""
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.syncdaemon_config.enable_bandwidth_throttling(reply_handler,
-            error_handler)
+        reply_handler = lambda: None
+        error_handler = lambda: None
+        self.syncdaemon_config.enable_bandwidth_throttling(MATCH(callable),
+            MATCH(callable))
         self.mocker.replay()
         self.config.enable_bandwidth_throttling(reply_handler, error_handler)
 
     def test_disable_bandwidth_throttling(self):
         """Test if the method is relayed."""
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.syncdaemon_config.disable_bandwidth_throttling(reply_handler,
-            error_handler)
+        reply_handler = lambda: None
+        error_handler = lambda: None
+        self.syncdaemon_config.disable_bandwidth_throttling(MATCH(callable),
+            MATCH(callable))
         self.mocker.replay()
         self.config.disable_bandwidth_throttling(reply_handler, error_handler)
 
     def test_bandwidth_throttling_enabled(self):
         """Test if the method is relayed."""
         result = 1
-        reply_handler = 'handler'
-        error_handler = 'error'
-        self.syncdaemon_config.bandwidth_throttling_enabled(reply_handler,
-            error_handler)
+        reply_handler = lambda: None
+        error_handler = lambda: None
+        self.syncdaemon_config.bandwidth_throttling_enabled(MATCH(callable),
+            MATCH(callable))
         self.mocker.result(result)
         self.mocker.replay()
         self.assertEqual(result, self.config.bandwidth_throttling_enabled(
 
=== modified file 'tests/platform/windows/test_ipc.py'
--- tests/platform/windows/test_ipc.py	2011-02-23 09:03:55 +0000
+++ tests/platform/windows/test_ipc.py	2011-02-23 09:03:55 +0000
@@ -21,8 +21,17 @@
 
 from unittest import TestCase
 
-# to be later implemented, TDD work here
-SignalBroadcaster = None
+from ubuntuone.platform.windows.dbus_interface import (
+    Config,
+    Events,
+    Folders,
+    FileSystem,
+    PublicFiles,
+    Shares,
+    SignalBroadcaster,
+    Status,
+    SyncDaemon
+)
 
 class PerspectiveBrokerTestCase(TestCase):
     """Base test case for the IPC used on Windows."""
@@ -30,12 +39,14 @@
     def setUp(self):
         """Setup tests."""
         super(PerspectiveBrokerTestCase, self).setUp()
-        self.status = None
-        self.events = None
-        self.sync = None
-        self.shares = None
-        self.folders = None
-        self.public_files = None
+        self.config = Config(None, None)
+        self.status = Status(None, None, None)
+        self.events = Events(None)
+        self.sync = SyncDaemon(None, None, None, None)
+        self.shares = Shares(None, None, None)
+        self.folders = Folders(None, None)
+        self.public_files = PublicFiles(None, None)
+        self.fs = FileSystem(None, None)
 
 class TestSignalBroadcaster(MockerTestCase):
     """Test the signal brocaster code."""
@@ -44,6 +55,7 @@
         super(TestSignalBroadcaster, self).setUp()
         self.client = self.mocker.mock()
         self.broad_caster = SignalBroadcaster()
+        self.broad_caster.clients.append(self.client)
 
     def test_remote_register_to_signals(self):
         """Assert that the client was added."""
@@ -58,7 +70,8 @@
         word = 'word'
         signal_name = 'on_test'
         self.client.callRemote(signal_name, first, second, word=word)
-        self.broad_caster.emit_gisnal(signal_name, first, second, word=word)
+        self.mocker.replay()
+        self.broad_caster.emit_signal(signal_name, first, second, word=word)
 
 
 class TestStatusEmitSignals(PerspectiveBrokerTestCase, MockerTestCase):
@@ -103,7 +116,7 @@
         self.mocker.result(status)
         self.signal_method('on_status_changed', status)
         self.mocker.replay()
-        self.status.emit_status_changed()
+        self.status.emit_status_changed(status)
 
     def test_emit_download_started(self):
         """Emit DownloadStarted."""
@@ -118,7 +131,7 @@
         string_info = {'test':'2', 'name':'3'}
         self.signal_method('on_download_file_progress', download, string_info)
         self.mocker.replay()
-        self.status.emit_download_file_progress(download, test=1, name=2)
+        self.status.emit_download_file_progress(download, test=2, name=3)
 
     def test_emit_download_finished(self):
         """Emit DownloadFinished."""
@@ -126,7 +139,7 @@
         string_info = {'test':'2', 'name':'3'}
         self.signal_method('on_download_finished', download, string_info)
         self.mocker.replay()
-        self.status.emit_download_finished(download, test=1, name=2)
+        self.status.emit_download_finished(download, test=2, name=3)
 
     def test_emit_upload_started(self):
         """Emit UploadStarted."""
@@ -141,7 +154,7 @@
         string_info = {'test':'2', 'name':'3'}
         self.signal_method('on_upload_file_progress', upload, string_info)
         self.mocker.replay()
-        self.status.emit_upload_file_progress(upload, test=1, name=2)
+        self.status.emit_upload_file_progress(upload, test=2, name=3)
 
     def test_emit_upload_finished(self):
         """Emit UploadFinished."""
@@ -149,7 +162,7 @@
         string_info = {'test':'2', 'name':'3'}
         self.signal_method('on_upload_finished', upload, string_info)
         self.mocker.replay()
-        self.status.emit_upload_finished(upload, test=1, name=2)
+        self.status.emit_upload_finished(upload, test=2, name=3)
 
     def test_emit_account_changed(self):
         """Emit AccountChanged."""
@@ -219,7 +232,7 @@
 
     def setUp(self):
         """Setup tests."""       
-        super(TestEventsEmitSignals, self).setUp()
+        super(TestSharesEmitSignals, self).setUp()
         self.signal_method = self.mocker.mock()
         self.shares.emit_signal = self.signal_method
         self.shares.syncdaemon_shares = self.mocker.mock()
@@ -256,6 +269,8 @@
         self.get_share_dict(share)
         self.mocker.result(share_dict)
         self.signal_method('on_share_deleted_error', share_dict, error)
+        self.mocker.replay()
+        self.shares.emit_share_delete_error(share, error)
 
     def test_emit_free_space(self):
         """Emit ShareChanged when free space changes """
@@ -269,14 +284,14 @@
         self.mocker.result(shares)
         self.get_share_dict(share)
         self.mocker.result(share_dict)
-        self.signal_method(share_dict)
+        self.signal_method('on_share_changed', share_dict)
         self.mocker.replay()
         self.shares.emit_free_space(share_id, free_bytes)
 
     def test_emit_share_created(self):
         """Emit ShareCreated signal """
         share_info = 'info'
-        self.signal_method(share_info)
+        self.signal_method('on_share_created', share_info)
         self.mocker.replay()
         self.shares.emit_share_created(share_info)
 
@@ -287,7 +302,7 @@
         info = 'info'
         self.shares.syncdaemon_shares.get_create_error_share_info(share_info)
         self.mocker.result(info)
-        self.signal_method(info, error)
+        self.signal_method('on_share_create_error', info, error)
         self.mocker.replay()
         self.shares.emit_share_create_error(share_info, error)
 
@@ -297,7 +312,7 @@
         answer = 'yes'
         error = 'boom'
         answer_info = dict(volume_id=share_id, answer=answer, error=error)
-        self.signal_method(answer_info)
+        self.signal_method('on_share_answer_response', answer_info)
         self.mocker.replay()
         self.shares.emit_share_answer_response(share_id, answer, error)
 
@@ -310,7 +325,7 @@
         self.mocker.result(share)
         self.get_share_dict(share)
         self.mocker.result(share_dict)
-        self.signal_method(share_dict)
+        self.signal_method('on_new_share', share_dict)
         self.mocker.replay()
         self.shares.emit_new_share(share_id)
 
@@ -320,7 +335,7 @@
         share_dict = {'share' : 'id'}
         self.get_share_dict(share)
         self.mocker.result(share_dict)
-        self.signal_method(share_dict)
+        self.signal_method('on_share_subscribed', share_dict)
         self.mocker.replay()
         self.shares.emit_share_subscribed(share)
 
@@ -328,7 +343,8 @@
         """Emit the ShareSubscribeError signal"""
         share_id = 'id'
         error = 'error'
-        self.signal_method({'id': share_id}, str(error))
+        self.signal_method('on_share_subscribed_error',
+                           {'id': share_id}, str(error))
         self.mocker.replay()
         self.shares.emit_share_subscribe_error(share_id, error)
 
@@ -338,7 +354,7 @@
         share_dict = {'share':'id'}
         self.get_share_dict(share)
         self.mocker.result(share_dict) 
-        self.signal_method(share_dict)
+        self.signal_method('on_share_unsubscribed', share_dict)
         self.mocker.replay()
         self.shares.emit_share_unsubscribed(share)
 
@@ -346,7 +362,7 @@
         """Emit the ShareUnSubscribeError signal"""
         share_id = 'id'
         error = 'error'
-        self.signal_method({'id': share_id}, str(error))
+        self.signal_method('on_share_unsubscribed_error',{'id': share_id}, str(error))
         self.mocker.replay()
         self.shares.emit_share_unsubscribe_error(share_id, error)
 
@@ -358,6 +374,7 @@
         """Setup tests."""
         super(TestFoldersEmitSignals, self).setUp()
         self.signal_method = self.mocker.mock()
+        self.folders.emit_signal = self.signal_method
         self.get_udf_dict = self.mocker.replace(
             'ubuntuone.syncdaemon.interaction_interfaces.get_udf_dict')
 
@@ -367,7 +384,7 @@
         udf_dict = {'udf':'id'}
         self.get_udf_dict(folder)
         self.mocker.result(udf_dict)
-        self.signal_method(udf_dict)
+        self.signal_method('on_folder_deleted', udf_dict)
         self.mocker.replay()
         self.folders.emit_folder_deleted(folder)
 
@@ -378,7 +395,7 @@
         udf_dict = {'udf':'id'}
         self.get_udf_dict(folder)
         self.mocker.result(udf_dict)
-        self.signal_method(udf_dict, str(error))
+        self.signal_method('on_folder_delete_error', udf_dict, str(error))
         self.mocker.replay()
         self.folders.emit_folder_delete_error(folder, error)
 
@@ -388,7 +405,7 @@
         udf_dict = {'udf':'id'}
         self.get_udf_dict(folder)
         self.mocker.result(udf_dict)
-        self.signal_method(udf_dict)
+        self.signal_method('on_folder_subscribed', udf_dict)
         self.mocker.replay()
         self.folders.emit_folder_subscribed(folder)
 
@@ -396,7 +413,8 @@
         """Emit the FolderSubscribeError signal"""
         folder_id = 'id'
         error = 'error'
-        self.signal_method({'id':folder_id}, str(error))
+        self.signal_method('on_folder_subscribe_error',
+                           {'id':folder_id}, str(error))
         self.mocker.replay()
         self.folders.emit_folder_subscribe_error(folder_id, error)
 
@@ -406,7 +424,7 @@
         udf_dict = {'udf':'id'}
         self.get_udf_dict(folder)
         self.mocker.result(udf_dict)
-        self.signal_method(udf_dict)
+        self.signal_method('on_folder_unsubscribed', udf_dict)
         self.mocker.replay()
         self.folders.emit_folder_unsubscribed(folder)
 
@@ -414,7 +432,8 @@
         """Emit the FolderUnSubscribeError signal"""
         folder_id = 'id'
         error = 'error'
-        self.signal_method({'id':folder_id}, str(error))
+        self.signal_method('on_folder_unsubscribe_error',
+                           {'id':folder_id}, str(error))
         self.mocker.replay()
         self.folders.emit_folder_unsubscribe_error(folder_id, error)
 
@@ -426,6 +445,7 @@
         """Setup tests."""
         super(TestPublicFilesEmitSignals, self).setUp()
         self.signal_method = self.mocker.mock()
+        self.public_files.emit_signal = self.signal_method
         self.public_files.syncdaemon_public_files = self.mocker.mock()
         self.bool_str = self.mocker.replace(
             'ubuntuone.syncdaemon.interaction_interfaces.bool_str')
@@ -441,7 +461,8 @@
         self.mocker.result(path)
         self.bool_str(is_public)
         self.mocker.result('True')
-        self.signal_method(dict(share_id=share_id, node_id=node_id,
+        self.signal_method('on_public_access_changed',
+                           dict(share_id=share_id, node_id=node_id,
                                 is_public='True', public_url=public_url,
                                 path=path))
         self.mocker.replay()
@@ -456,7 +477,8 @@
         path = 'path'
         self.public_files.syncdaemon_public_files.get_path(share_id, node_id)
         self.mocker.result(path)
-        self.signal_method(dict(share_id=share_id, node_id=node_id, path=path),
+        self.signal_method('on_public_access_change_error',
+                           dict(share_id=share_id, node_id=node_id, path=path),
                            error)
         self.mocker.replay()
         self.public_files.emit_public_access_change_error(share_id, node_id,
@@ -474,14 +496,14 @@
                       public_url=public_url, path=path)]
         self.public_files.syncdaemon_public_files.get_path(volume_id, node_id)
         self.mocker.result(path)
-        self.signal_method(files)
+        self.signal_method('on_public_files_list',files)
         self.mocker.replay()
         self.public_files.emit_public_files_list(public_files)
 
     def test_emit_public_files_list_error(self):
         """Emit the PublicFilesListError signal."""
         error = 'error'
-        self.signal_method(error)
+        self.signal_method('on_public_files_list_error', error)
         self.mocker.replay()
         self.public_files.emit_public_files_list_error(error)
 
 
=== modified file 'ubuntuone/platform/windows/dbus_interface.py'
--- ubuntuone/platform/windows/dbus_interface.py	2011-02-14 11:56:44 +0000
+++ ubuntuone/platform/windows/dbus_interface.py	2011-02-23 09:03:55 +0000
@@ -17,9 +17,811 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """IPC implementation that replaces Dbus."""
 
+import logging
+
+from twisted.spread.pb import Referenceable
+from ubuntuone.syncdaemon.interaction_interfaces import (
+    bool_str,
+    get_share_dict,
+    get_udf_dict,
+    SyncdaemonConfig,
+    SyncdaemonEvents,
+    SyncdaemonFileSystem,
+    SyncdaemonFolders,
+    SyncdaemonPublicFiles,
+    SyncdaemonService,
+    SyncdaemonShares,
+    SyncdaemonStatus
+)
+
+logger = logging.getLogger("ubuntuone.SyncDaemon.Pb")
+
+
+def remote_handler(handler):    
+    if handler:
+        handler = lambda x: handler.callRemote('execute', x)
+    return handler
+
+class RemoteMeta(type):
+    """Append remte_ to the remote methods.
+    
+    Remote has to be appended to the remote method to work over pb but this
+    names cannot be used since the other platforms do not expect the remote
+    prefix. This metaclass create those prefix so that the methods can be
+    correctly called.
+    """
+    
+    def __new__(cls, name, bases, attrs):
+        remote_calls = attrs.get('remote_calls', None)
+        if remote_calls:
+            for current in remote_calls:
+                attrs['remote_' + current] = attrs[current]
+        return super(RemoteMeta, cls).__new__(cls, name, bases, attrs)
+
+
+class SignalBroadcaster(object):
+    """Object that allows to emit signals to clients over the IPC."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.clients = []
+
+    def remote_register_to_signals(self, client):
+        """Allow a client to register to a signal."""
+        self.clients.append(client)
+    
+    def emit_signal(self, signal_name, *args, **kwargs):
+        """Emit the given signal to the clients."""
+        for current_client in self.clients:
+            try:
+                current_client.callRemote(signal_name, *args, **kwargs)
+            except:
+                logger.warn('Could not emit signal to %s', current_client)
+
+class Status(Referenceable, SignalBroadcaster):
+    """ Represent the status of the syncdaemon """
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+        'current_status',
+        'current_downloads',
+        'waiting_metadata',
+        'waiting_content',
+        'schedule_next',
+        'current_uploads',
+    ]
+    
+    def __init__(self, main, action_queue, fs_manager):
+        """ Creates the instance."""
+        super(Status, self).__init__()
+        self.syncdaemon_status = SyncdaemonStatus(main, action_queue,
+            fs_manager)
+
+    def current_status(self):
+        """ return the current status of the system, one of: local_rescan,
+        offline, trying_to_connect, server_rescan or online.
+        """
+        logger.debug('called current_status')
+        return self.syncdaemon_status.current_status()
+
+    def current_downloads(self):
+        """Return a list of files with a download in progress."""
+        logger.debug('called current_downloads')
+        return self.syncdaemon_status.current_downloads()
+
+    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.
+        """
+        logger.debug('called waiting_metadata')
+        return self.syncdaemon_status.waiting_metadata()
+
+    def waiting_content(self):
+        """Return a list of files that are waiting to be up- or downloaded.
+
+        As we don't have content-queue anymore, this is faked.
+        """
+        logger.debug('called waiting_content')
+        return self.syncdaemon_status.waiting_content()
+
+    def schedule_next(self, share_id, node_id):
+        """
+        Make the command on the given share and node be next in the
+        queue of waiting commands.
+        """
+        logger.debug('called schedule_next')
+        self.syncdaemon_status.schedule_next(share_id, node_id)
+
+    def current_uploads(self):
+        """ return a list of files with a upload in progress """
+        logger.debug('called current_uploads')
+        return self.syncdaemon_status.current_uploads()
+
+    def emit_content_queue_changed(self):
+        """Emit ContentQueueChanged."""
+        self.emit_signal('on_content_queue_changed')
+
+    def emit_invalid_name(self, dirname, filename):
+        """Emit InvalidName."""
+        self.emit_signal('on_invalid_name', unicode(dirname), str(filename))
+
+    def emit_broken_node(self, volume_id, node_id, mdid, path):
+        """Emit BrokenNode."""
+        if mdid is None:
+            mdid = ''
+        if path is None:
+            path = ''
+        self.emit_signal('on_broken_node', volume_id, node_id, mdid,
+            path.decode('utf8'))
+
+    def emit_status_changed(self, state):
+        """Emit StatusChanged."""
+        self.emit_signal('on_status_changed',
+                         self.syncdaemon_status.current_status())
+
+    def emit_download_started(self, download):
+        """Emit DownloadStarted."""
+        self.emit_signal('on_download_started', download)
+
+    def emit_download_file_progress(self, download, **info):
+        """Emit DownloadFileProgress."""
+        for k, v in info.copy().items():
+            info[str(k)] = str(v)
+        self.emit_signal('on_download_file_progress', download, info)        
+
+    def emit_download_finished(self, download, **info):
+        """Emit DownloadFinished."""
+        for k, v in info.copy().items():
+            info[str(k)] = str(v)
+        self.emit_signal('on_download_finished', download, info)
+
+    def emit_upload_started(self, upload):
+        """Emit UploadStarted."""
+        self.emit_signal('on_upload_started', upload)
+
+    def emit_upload_file_progress(self, upload, **info):
+        """Emit UploadFileProgress."""
+        for k, v in info.copy().items():
+            info[str(k)] = str(v)
+        self.emit_signal('on_upload_file_progress', upload, info)
+
+    def emit_upload_finished(self, upload, **info):
+        """Emit UploadFinished."""
+        for k, v in info.copy().items():
+            info[str(k)] = str(v)
+        self.emit_signal('on_upload_finished', upload, info)
+
+    def emit_account_changed(self, account_info):
+        """Emit AccountChanged."""
+        info_dict = {'purchased_bytes': unicode(account_info.purchased_bytes)}
+        self.emit_signal('on_account_changed', info_dict)
+
+    def emit_metaqueue_changed(self):
+        """Emit MetaQueueChanged."""
+        self.emit_signal('on_metaqueue_changed')
+
 
-class Status(object):
-    """ Represent the status of the syncdaemon """
-
-    def __init__(self, bus_name, dbus_iface, syncdaemon_status=None):
-        pass
 \ No newline at end of file
+class Events(Referenceable, SignalBroadcaster):
+    """The events of the system translated to ipc signals."""
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+        'push_event',
+    ]
+
+    def __init__(self, event_queue):
+        super(Events, self).__init__()
+        self.events = SyncdaemonEvents(event_queue)
+
+    def emit_event(self, event):
+        """Emit the signal."""
+        event_dict = {}
+        for key, value in event.iteritems():
+            event_dict[str(key)] = str(value)
+        self.emit_signal('on_event', event_dict)
+
+    def push_event(self, event_name, args):
+        """Push an event to the event queue."""
+        logger.debug('push_event: %r with %r', event_name, args)
+        self.events.push_event(event_name, args)
+
+
+class SyncDaemon(Referenceable, SignalBroadcaster):
+    """ The Daemon ipc interface. """
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+        'connect',
+        'disconnect',
+        'get_rootdir',
+        'get_sharesdir',
+        'get_sharesdir_link',
+        'wait_for_nirvana',
+        'quit',
+        'rescan_from_scratch',
+    ]
+
+    def __init__(self, root, main, volume_manager, action_queue):
+        """ Creates the instance."""
+        self.service = SyncdaemonService(root, main, volume_manager,
+            action_queue)
+        self.clients = []
+
+    def connect(self):
+        """ Connect to the server. """
+        logger.debug('connect requested')
+        self.service.connect()
+
+    def disconnect(self):
+        """ Disconnect from the server. """
+        logger.debug('disconnect requested')
+        self.service.disconnect()
+
+    def get_rootdir(self):
+        """ Returns the root dir/mount point. """
+        logger.debug('called get_rootdir')
+        return self.service.get_rootdir()
+
+    def get_sharesdir(self):
+        """ Returns the shares dir/mount point. """
+        logger.debug('called get_sharesdir')
+        return self.service.get_sharesdir()
+
+    def get_sharesdir_link(self):
+        """ Returns the shares dir/mount point. """
+        logger.debug('called get_sharesdir_link')
+        return self.service.get_sharesdir_link()
+
+    def wait_for_nirvana(self, last_event_interval,
+                         reply_handler=None, error_handler=None):
+        """ call the reply handler when there are no more
+        events or transfers.
+        """
+        logger.debug('called wait_for_nirvana')
+        return self.service.wait_for_nirvana(last_event_interval,
+            remote_handler(reply_handler), remote_handler(error_handler))
+
+    def quit(self, reply_handler=None, error_handler=None):
+        """ shutdown the syncdaemon. """
+        logger.debug('Quit requested')
+        self.service.quit(remote_handler(reply_handler),
+            remote_handler(error_handler))
+
+    def rescan_from_scratch(self, volume_id):
+        """Request a rescan from scratch of the volume with volume_id."""
+        self.service.rescan_from_scratch(volume_id)
+
+    def emit_root_mismatch(self, root_id, new_root_id):
+        """Emit RootMismatch signal."""
+        self.emit_signal('on_root_mismatch', root_id, new_root_id)
+
+    def emit_quota_exceeded(self, volume_dict):
+        """Emit QuotaExceeded signal."""
+        self.emit_signal('on_quota_exceeded', volume_dict)
+
+
+class FileSystem(object, Referenceable):
+    """ An ipc interface to the FileSystem Manager. """
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+        'get_metadata',
+        'get_metadata_by_node',
+        'get_metadata_and_quick_tree_synced',
+        'get_dirty_nodes',
+    ]
+
+    def __init__(self, fs_manager, action_queue):
+        """ Creates the instance. """
+        super(FileSystem, self).__init__()
+        self.syncdaemon_filesystem = SyncdaemonFileSystem(fs_manager,
+            action_queue)
+
+    def get_metadata(self, path):
+        """Return the metadata (as a dict) for the specified path."""
+        logger.debug('get_metadata by path: %r', path)
+        return self.syncdaemon_filesystem.get_metadata(path)
+
+    def get_metadata_by_node(self, share_id, node_id):
+        """Return the metadata (as a dict) for the specified share/node."""
+        logger.debug('get_metadata by share: %r  node: %r', share_id, node_id)
+        return self.syncdaemon_filesystem.get_metadata_by_node(share_id,
+                                                               node_id)
+
+    def get_metadata_and_quick_tree_synced(self, path):
+        """ returns the dict with the attributes of the metadata for
+        the specified path, including the quick subtree status.
+        """
+        logger.debug('get_metadata_and_quick_tree_synced: %r', path)
+        return self.syncdaemon_filesystem.get_metadata_and_quick_tree_synced(
+            path)
+
+    def get_dirty_nodes(self):
+        """Rerturn a list of dirty nodes."""
+        return self.syncdaemon_filesystem.get_dirty_nodes()
+
+
+class Shares(Referenceable, SignalBroadcaster):
+    """A ipc interface to interact with shares."""
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+       'get_shares',
+       'accept_share',
+       'reject_share',
+       'delete_share',
+       'subscribe',
+       'unsubscribe',
+       'create_share',
+       'create_shares',
+       'refresh_shares',
+       'get_shared',
+    ]
+
+    def __init__(self, bus_name, fs_manager, volume_manager):
+        """Create the instance."""
+        self.syncdaemon_shares = SyncdaemonShares(fs_manager, volume_manager)
+
+    def get_shares(self):
+        """Return a list of dicts, each dict represents a share."""
+        logger.debug('called get_shares')
+        return self.syncdaemon_shares.get_shares()
+
+    def accept_share(self, share_id, reply_handler=None, error_handler=None):
+        """Accept a share.
+
+        A ShareAnswerOk|Error signal will be fired in the future as a
+        success/failure indicator.
+
+        """
+        logger.debug('accept_share: %r', share_id)
+        self.syncdaemon_shares.accept_share(share_id,
+            remote_handler(reply_handler), remote_handler(error_handler))
+        
+    def reject_share(self, share_id, reply_handler=None, error_handler=None):
+        """Reject a share."""
+        logger.debug('reject_share: %r', share_id)
+        self.syncdaemon_shares.reject_share(share_id,
+            remote_handler(reply_handler),
+            remote_handler(error_handler))
+
+    def delete_share(self, share_id):
+        """Delete a Share, both kinds: "to me" and "from me"."""
+        logger.debug('delete_share: %r', share_id)
+        try:
+            self.syncdaemon_shares.delete_share(share_id)
+        except Exception, e:
+            logger.exception('Error while deleting share: %r', share_id)
+            self.emit_share_delete_error({'volume_id':share_id}, str(e))
+            # propagate the error
+            raise
+
+    def subscribe(self, share_id):
+        """Subscribe to the specified share."""
+        logger.debug('Shares.subscribe: %r', share_id)
+        self.syncdaemon_shares.subscribe(share_id)
+
+    def unsubscribe(self, share_id):
+        """Unsubscribe from the specified share."""
+        logger.debug('Shares.unsubscribe: %r', share_id)
+        self.syncdaemon_shares.unsubscribe(share_id)
+
+    def emit_share_changed(self, message, share):
+        """ emits ShareChanged or ShareDeleted signal for the share
+        notification.
+        """
+        logger.debug('emit_share_changed: message %r, share %r.',
+                    message, share)
+        if message == 'deleted':
+            self.emit_signal('on_share_deleted', get_share_dict(share))
+        elif message == 'changed':
+            self.emit_signal('on_share_changed', get_share_dict(share))
+
+    def emit_share_delete_error(self, share, error):
+        """Emits ShareDeleteError signal."""
+        logger.info('emit_share_delete_error: share %r, error %r.',
+                    share, error)
+        self.emit_signal('on_share_deleted_error',
+            get_share_dict(share), error)
+
+    def emit_free_space(self, share_id, free_bytes):
+        """ emits ShareChanged when free space changes """
+        if share_id in self.syncdaemon_shares.shares:
+            share = self.syncdaemon_shares.shares[share_id]
+            share_dict = get_share_dict(share)
+            share_dict['free_bytes'] = unicode(free_bytes)
+            self.emit_signal('on_share_changed',
+                share_dict)
+
+    def create_share(self, path, username, name, access_level):
+        """ Share a subtree to the user identified by username.
+
+        @param path: that path to share (the root of the subtree)
+        @param username: the username to offer the share to
+        @param name: the name of the share
+        @param access_level: 'View' or 'Modify'
+        """
+        logger.debug('create share: %r, %r, %r, %r',
+                     path, username, name, access_level)
+        self.syncdaemon_shares.create_share(path, username, name, access_level)
+
+    def create_shares(self, path, usernames, name, access_level):
+        """Share a subtree with several users at once.
+
+        @param path: that path to share (the root of the subtree)
+        @param usernames: the user names to offer the share to
+        @param name: the name of the share
+        @param access_level: 'View' or 'Modify'
+        """
+        logger.debug('create shares: %r, %r, %r, %r',
+                     path, usernames, name, access_level)
+        for user in usernames:
+            self.syncdaemon_shares.create_share(path, user, name,
+                access_level)
+
+    def emit_share_created(self, share_info):
+        """ emits ShareCreated signal """
+        logger.debug('emit_share_created: share_info %r.', share_info)
+        self.emit_signal('on_share_created',
+                share_info)
+
+    def emit_share_create_error(self, share_info, error):
+        """Emit ShareCreateError signal."""
+        info = self.syncdaemon_shares.get_create_error_share_info(share_info)
+        logger.info('emit_share_create_error: share_info %r, error %r.',
+                    info, error)
+        self.emit_signal('on_share_create_error', info, error)
+
+    def refresh_shares(self):
+        """ Refresh the share list, requesting it to the server. """
+        self.syncdaemon_shares.refresh_shares() 
+
+    def get_shared(self):
+        """ returns a list of dicts, each dict represents a shared share.
+        A share might not have the path set, as we might be still fetching the
+        nodes from the server. In this cases the path is ''
+        """
+        logger.debug('called get_shared')
+        return self.syncdaemon_shares.get_shared()
+
+    def emit_share_answer_response(self, share_id, answer, error=None):
+        """Emits ShareAnswerResponse signal."""
+        answer_info = dict(volume_id=share_id, answer=answer)
+        if error:
+            answer_info['error'] = error
+        logger.debug('emit_share_answer_response: answer_info %r.', answer_info)
+        self.emit_signal('on_share_answer_response', answer_info)
+
+    def emit_new_share(self, share_id):
+        """Emits NewShare signal."""
+        share = self.syncdaemon_shares.get_volume(share_id)
+        logger.debug('emit_new_share: share_id %r.', share_id)
+        self.emit_signal('on_new_share', get_share_dict(share))
+
+    def emit_share_subscribed(self, share):
+        """Emit the ShareSubscribed signal"""
+        self.emit_signal('on_share_subscribed', get_share_dict(share))
+
+    def emit_share_subscribe_error(self, share_id, error):
+        """Emit the ShareSubscribeError signal"""
+        self.emit_signal('on_share_subscribed_error', {'id': share_id},
+            str(error))
+
+    def emit_share_unsubscribed(self, share):
+        """Emit the ShareUnSubscribed signal"""
+        self.emit_signal('on_share_unsubscribed', get_share_dict(share))
+
+    def emit_share_unsubscribe_error(self, share_id, error):
+        """Emit the ShareUnSubscribeError signal"""
+        self.emit_signal('on_share_unsubscribed_error', {'id': share_id},
+            str(error))
+
+class Config(object, Referenceable):
+    """ The Syncdaemon config/settings ipc interface. """
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+        'get_throttling_limits',
+        'set_throttling_limits',
+        'enable_bandwidth_throttling',
+        'disable_bandwidth_throttling',
+        'bandwidth_throttling_enabled',
+        'udf_autosubscribe_enabled',
+        'enable_udf_autosubscribe',
+        'share_autosubscribe_enabled',
+        'enable_share_autosubscribe',
+        'disable_share_autosubscribe',
+        'set_files_sync_enabled',
+        'autoconnect_enabled',
+        'set_autoconnect_enabled',
+        'show_all_notifications_enabled',
+        'enable_show_all_notifications',
+        'disable_show_all_notifications'
+    ]
+    
+    def __init__(self, main, action_queue):
+        """ Creates the instance."""
+        super(Config, self).__init__()
+        self.syncdaemon_config = SyncdaemonConfig(main, action_queue)
+
+    def get_throttling_limits(self, reply_handler=None, error_handler=None):
+        """Get the read/write limit from AQ and return a dict.
+        Returns a dict(download=int, upload=int), if int is -1 the value isn't
+        configured.
+        The values are bytes/second
+        """
+        logger.debug("called get_throttling_limits")
+        return self.syncdaemon_config.get_throttling_limits(
+            remote_handler(reply_handler), remote_handler(error_handler))
+
+    def set_throttling_limits(self, download, upload,
+                         reply_handler=None, error_handler=None):
+        """Set the read and write limits. The expected values are bytes/sec."""
+        logger.debug("called set_throttling_limits")
+        self.syncdaemon_config.set_throttling_limits(download, upload,
+            remote_handler(reply_handler), remote_handler(error_handler))
+
+    def enable_bandwidth_throttling(self, reply_handler=None,
+                                    error_handler=None):
+        """Enable bandwidth throttling."""
+        self.syncdaemon_config.enable_bandwidth_throttling(
+            remote_handler(reply_handler), remote_handler(error_handler))
+
+    def disable_bandwidth_throttling(self, reply_handler=None,
+                                     error_handler=None):
+        """Disable bandwidth throttling."""
+        self.syncdaemon_config.disable_bandwidth_throttling(
+            remote_handler(reply_handler), remote_handler(error_handler))
+
+    def bandwidth_throttling_enabled(self, reply_handler=None,
+                                     error_handler=None):
+        """Returns True (actually 1) if bandwidth throttling is enabled and
+        False (0) otherwise.
+        """
+        return self.syncdaemon_config.bandwidth_throttling_enabled(
+            remote_handler(reply_handler), remote_handler(error_handler))
+
+    def udf_autosubscribe_enabled(self):
+        """Return the udf_autosubscribe config value."""
+        return self.syncdaemon_config.udf_autosubscribe_enabled()
+
+    def enable_udf_autosubscribe(self):
+        """Enable UDF autosubscribe."""
+        self.syncdaemon_config.enable_udf_autosubscribe()
+
+    def disable_udf_autosubscribe(self):
+        """Enable UDF autosubscribe."""
+        self.syncdaemon_config.disable_udf_autosubscribe()
+
+    def share_autosubscribe_enabled(self):
+        """Return the share_autosubscribe config value."""
+        return self.syncdaemon_config.share_autosubscribe_enabled()
+
+    def enable_share_autosubscribe(self):
+        """Enable UDF autosubscribe."""
+        self.syncdaemon_config.enable_share_autosubscribe()
+
+    def disable_share_autosubscribe(self):
+        """Enable UDF autosubscribe."""
+        self.syncdaemon_config.disable_share_autosubscribe()
+
+    def set_files_sync_enabled(self, enabled):
+        """Enable/disable file sync service."""
+        logger.debug('called set_files_sync_enabled %d', enabled)
+        self.syncdaemon_config.set_files_sync_enabled(enabled)
+
+    def files_sync_enabled(self):
+        """Return the files_sync_enabled config value."""
+        logger.debug('called files_sync_enabled')
+        return self.syncdaemon_config.files_sync_enabled()
+
+    def autoconnect_enabled(self):
+        """Return the autoconnect config value."""
+        return self.syncdaemon_config.autoconnect_enabled()
+
+    def set_autoconnect_enabled(self, enabled):
+        """Enable syncdaemon autoconnect."""
+        self.syncdaemon_config.set_autoconnect_enabled(enabled)
+
+    def show_all_notifications_enabled(self):
+        """Return the show_all_notifications config value."""
+        return self.syncdaemon_config.show_all_notifications_enabled()
+
+    def enable_show_all_notifications(self):
+        """Enable showing all notifications."""
+        self.syncdaemon_config.enable_show_all_notifications()
+
+    def disable_show_all_notifications(self):
+        """Disable showing all notifications."""
+        self.syncdaemon_config.disable_show_all_notifications()
+
+
+class Folders(Referenceable, SignalBroadcaster):
+    """An interface to interact with User Defined Folders"""
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+        'create',
+        'delete',
+        'get_folders',
+        'subscribe',
+        'unsubscribe',
+        'get_info',
+        'refresh_volumes',
+    ]
+    
+    def __init__(self, volume_manager, fs_manager):
+        """Creates the instance."""
+        super(Folders, self).__init__()
+        self.syncdaemon_folders = SyncdaemonFolders(volume_manager, fs_manager)
+
+    def create(self, path):
+        """Create a user defined folder in the specified path."""
+        logger.debug('Folders.create: %r', path)
+        try:
+            self.syncdaemon_folders.create(path)
+        except Exception, e:
+            logger.exception('Error while creating udf: %r', path)
+            self.emit_folder_create_error(path, str(e))
+
+    def delete(self, folder_id):
+        """Delete the folder specified by folder_id"""
+        from ubuntuone.syncdaemon.volume_manager import VolumeDoesNotExist
+        logger.debug('Folders.delete: %r', folder_id)
+        try:
+            self.syncdaemon_folders.delete(folder_id)
+        except VolumeDoesNotExist, e:
+            self.emit_folder_delete_error(folder_id, e)
+        except Exception, e:
+            logger.exception('Error while deleting volume: %r', folder_id)
+            self.emit_folder_delete_error(folder_id, e)
+
+    def get_folders(self):
+        """Return the list of folders (a list of dicts)"""
+        logger.debug('Folders.get_folders')
+        return self.syncdaemon_folders.get_folders()
+
+    def subscribe(self, folder_id):
+        """Subscribe to the specified folder"""
+        logger.debug('Folders.subscribe: %r', folder_id)
+        self.syncdaemon_folders.subscribe(folder_id)
+
+    def unsubscribe(self, folder_id):
+        """Unsubscribe from the specified folder"""
+        logger.debug('Folders.unsubscribe: %r', folder_id)
+        self.syncdaemon_folders.unsubscribe(folder_id)
+
+    def get_info(self, path):
+        """Returns a dict containing the folder information."""
+        logger.debug('Folders.get_info: %r', path)
+        return self.syncdaemon_folders.get_info(path)
+
+    def refresh_volumes(self):
+        """Refresh the volumes list, requesting it to the server."""
+        self.syncdaemon_folders.refresh_volumes()
+
+    def emit_folder_created(self, folder):
+        """Emit the FolderCreated signal"""
+        udf_dict = get_udf_dict(folder)
+        self.emit_signal('on_folder_created', udf_dict)
+
+    def emit_folder_create_error(self, path, error):
+        """Emit the FolderCreateError signal"""
+        info = dict(path=path.decode('utf-8'))
+        self.emit_signal('on_folder_create_error', info, str(error))
+
+    def emit_folder_deleted(self, folder):
+        """Emit the FolderCreated signal"""
+        udf_dict = get_udf_dict(folder)
+        self.emit_signal('on_folder_deleted', udf_dict)
+
+    def emit_folder_delete_error(self, folder, error):
+        """Emit the FolderCreateError signal"""
+        udf_dict = get_udf_dict(folder)
+        self.emit_signal('on_folder_delete_error', udf_dict, str(error))
+
+    def emit_folder_subscribed(self, folder):
+        """Emit the FolderSubscribed signal"""
+        udf_dict = get_udf_dict(folder)
+        self.emit_signal('on_folder_subscribed', udf_dict)
+
+    def emit_folder_subscribe_error(self, folder_id, error):
+        """Emit the FolderSubscribeError signal"""
+        self.emit_signal('on_folder_subscribe_error', {'id':folder_id},
+            str(error))
+
+    def emit_folder_unsubscribed(self, folder):
+        """Emit the FolderUnSubscribed signal"""
+        udf_dict = get_udf_dict(folder)
+        self.emit_signal('on_folder_unsubscribed', udf_dict)
+
+    def emit_folder_unsubscribe_error(self, folder_id, error):
+        """Emit the FolderUnSubscribeError signal"""
+        self.emit_signal('on_folder_unsubscribe_error',
+            {'id':folder_id}, str(error))
+
+
+class PublicFiles(Referenceable, SignalBroadcaster):
+    """An IPC interface for handling public files."""
+
+    __metaclass__ = RemoteMeta
+    
+    # calls that will be accessible remotly
+    remote_calls = [
+        'change_public_access',
+        'get_public_files',
+    ]
+    
+    def __init__(self, fs_manager, action_queue):
+        super(PublicFiles, self).__init__()
+        self.syncdaemon_public_files = SyncdaemonPublicFiles(fs_manager,
+            action_queue)
+
+    def change_public_access(self, share_id, node_id, is_public):
+        """Change the public access of a file."""
+        logger.debug('PublicFiles.change_public_access: %r, %r, %r',
+                     share_id, node_id, is_public)
+        self.syncdaemon_public_files.change_public_access(share_id, node_id,
+            is_public)
+
+    def get_public_files(self):
+        """Request the list of public files to the server.
+
+        The result will be send in a PublicFilesList signal.
+        """
+        self.syncdaemon_public_files.get_public_files()
+
+    def emit_public_access_changed(self, share_id, node_id, is_public,
+                                   public_url):
+        """Emit the PublicAccessChanged signal."""
+        share_id = str(share_id) if share_id else ''
+        node_id = str(node_id)
+        path = self.syncdaemon_public_files.get_path(share_id, node_id)
+        info = dict(
+            share_id=str(share_id) if share_id else '',
+            node_id=str(node_id),
+            is_public=bool_str(is_public),
+            public_url=public_url if public_url else '',
+            path=path)
+        self.emit_signal('on_public_access_changed', info)
+
+    def emit_public_access_change_error(self, share_id, node_id, error):
+        """Emit the PublicAccessChangeError signal."""
+        path = self.syncdaemon_public_files.get_path(share_id, node_id)
+        info = dict(
+            share_id=str(share_id) if share_id else '',
+            node_id=str(node_id),
+            path=path)
+        self.emit_signal('on_public_access_change_error', info, str(error))
+
+    def emit_public_files_list(self, public_files):
+        """Emit the PublicFilesList signal."""
+        files = []
+        for pf in public_files:
+            volume_id = str(pf['volume_id'])
+            node_id = str(pf['node_id'])
+            public_url = str(pf['public_url'])
+            path = self.syncdaemon_public_files.get_path(volume_id ,
+                node_id).decode('utf-8')
+            files.append(dict(volume_id=volume_id, node_id=node_id,
+                public_url=public_url, path=path))
+        self.emit_signal('on_public_files_list', files)
+
+    def emit_public_files_list_error(self, error):
+        """Emit the PublicFilesListError signal."""
+        self.emit_signal('on_public_files_list_error', str(error))