def __init__(self): """Initialize this instance.""" self.client = UbuntuOneClient() self.last_event = 0 self.delayed_call = None self.log = logging.getLogger('ubuntuone.SyncDaemon.SDTool') self.connected = self.client.connect()
class SyncDaemonToolProxy(object): """Platform dependent proxy to syncdaemon. Please note that most of the methods of this class are "pre-processed" by overriding __getattribute__, in a way where _call_after_connection is called before the method itself, so every public method will return a deferred that will be fired when this client is connected. """ _SIGNAL_MAPPING = { "Event": ("events", "on_event_cb"), "FolderCreated": ("folders", "on_folder_created_cb"), "FolderCreateError": ("folders", "on_folder_create_error_cb"), "FolderDeleted": ("folders", "on_folder_deleted_cb"), "FolderDeleteError": ("folders", "on_folder_delete_error_cb"), "FolderSubscribed": ("folders", "on_folder_subscribed_cb"), "FolderSubscribeError": ("folders", "on_folder_subscribe_error_cb"), "FolderUnSubscribed": ("folders", "on_folder_unsubscribed_cb"), "FolderUnSubscribeError": ("folders", "on_folder_unsubscribe_error_cb"), "NewShare": ("shares", "on_new_share_cb"), "PublicAccessChanged": ("public_files", "on_public_access_changed_cb"), "PublicAccessChangeError": ("public_files", "on_public_access_change_error_cb"), "PublicFilesList": ("public_files", "on_public_files_list_cb"), "PublicFilesListError": ("public_files", "on_public_files_list_error_cb"), "ShareAnswerResponse": ("shares", "on_share_answer_response_cb"), "ShareChanges": ("shares", "on_share_changed_cb"), "ShareCreated": ("shares", "on_share_created_cb"), "ShareCreateError": ("shares", "on_share_create_error_cb"), "ShareDeleted": ("shares", "on_share_deleted_cb"), "ShareDeleteError": ("shares", "on_share_delete_error_cb"), "ShareSubscribed": ("shares", "on_share_subscribed_cb"), "ShareSubscribeError": ("shares", "on_share_subscribe_error_cb"), "ShareUnSubscribed": ("shares", "on_share_unsubscribed_cb"), "ShareUnSubscribeError": ("shares", "on_share_unsubscribe_error_cb"), "StatusChanged": ("status", "on_status_changed_cb"), "VolumesChanged": ("sync_daemon", "on_volumes_changed_cb"), } # All methods and instance variables that should not be handled by # _call_after_connection should be put in the list below (or start with _) _DONT_VERIFY_CONNECTED = ["wait_connected", "client", "last_event", "delayed_call", "log", "connected"] def _should_wrap(self, attr_name): """Check if this attribute should be wrapped.""" return not (attr_name in SyncDaemonToolProxy._DONT_VERIFY_CONNECTED or attr_name.startswith("_")) def __getattribute__(self, attr_name): """If the attribute is not special, verify the ipc connection.""" attr = super(SyncDaemonToolProxy, self).__getattribute__(attr_name) if SyncDaemonToolProxy._should_wrap(self, attr_name): return self._call_after_connection(attr) else: return attr def __init__(self, bus=None): self.client = UbuntuOneClient() self.connected = self.client.connect() def _call_after_connection(self, method): """Make sure Perspective Broker is connected before calling.""" @defer.inlineCallbacks def call_after_connection_inner(*args, **kwargs): """Call the given method after the connection to pb is made.""" yield self.connected retval = yield method(*args, **kwargs) defer.returnValue(retval) return call_after_connection_inner def call_method(self, client_kind, method_name, *args, **kwargs): """Call the 'method_name' passing 'args' and 'kwargs'.""" client = getattr(self.client, client_kind) method = getattr(client, method_name) result = method(*args, **kwargs) return result def shutdown(self): """Close connections.""" return self.client.disconnect() def connect_signal(self, signal_name, handler): """Connect 'handler' with 'signal_name'.""" client_kind, callback = self._SIGNAL_MAPPING[signal_name] client = getattr(self.client, client_kind) setattr(client, callback, handler) return handler def disconnect_signal(self, signal_name, handler_or_match): """Disconnect 'handler_or_match' from 'signal_name'.""" client_kind, callback = self._SIGNAL_MAPPING[signal_name] client = getattr(self.client, client_kind) setattr(client, callback, None) return handler_or_match def wait_connected(self): """Wait until syncdaemon is connected to the server.""" return self.connected def start(self): """Start syncdaemon, should *not* be running.""" # look in the reg to find the path of the .exe to be executed # to launch the sd on windows key = OpenKey(HKEY_LOCAL_MACHINE, U1_REG_PATH) path = QueryValueEx(key, SD_INSTALL_PATH)[0] if not os.path.exists(path): # either the .exe was moved of the value is wrong return defer.fail(WindowsError(errno.ENOENT, "Could not start syncdaemon: File not found %s" % path)) p = subprocess.Popen([path]) return defer.succeed(p)
def __init__(self, bus=None): self.client = UbuntuOneClient() self.connected = self.client.connect()
class SyncDaemonTool(object): """Various utility methods to test/play with the SyncDaemon.""" # WARNING: most of the methods of this class are "pre-processed" by # __getattribute__, to call _call_after_connection before the method # is called, so they should either be decorated with inlineCallbacks # or return a deferred. # # All methods and instance variables that should not be handled that way # should be put in the list below (or start with _): _DONT_VERIFY_CONNECTED = [ "wait_connected", "client", "last_event", "delayed_call", "log", "connected", ] def _should_wrap(self, attr_name): """Check if this attribute should be wrapped.""" return not (attr_name in SyncDaemonTool._DONT_VERIFY_CONNECTED or attr_name.startswith("_")) def __getattribute__(self, attr_name): """If the attribute is not special, verify the ipc connection.""" attr = super(SyncDaemonTool, self).__getattribute__(attr_name) if SyncDaemonTool._should_wrap(self, attr_name): return self._call_after_connection(attr) else: return attr def __init__(self): """Initialize this instance.""" self.client = UbuntuOneClient() self.last_event = 0 self.delayed_call = None self.log = logging.getLogger('ubuntuone.SyncDaemon.SDTool') self.connected = self.client.connect() def _call_after_connection(self, method): """Make sure Perspective Broker is connected before calling.""" @defer.inlineCallbacks def call_after_connection_inner(*args, **kwargs): """Call the given method after the connection to pb is made.""" yield self.connected retval = yield method(*args, **kwargs) defer.returnValue(retval) return call_after_connection_inner 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() d.callback(True) except Exception, e: self.log.debug('Not connected: %s', e) d.errback() reactor.callLater(.5, check_connection_status) return d