Changeset 1777

Timestamp:

02/20/07 11:50:11 (22 months ago)

Author:

abaumann

Message:

first pass at updating moto-sync to new API and python wrappers
this is incomplete, and guaranteed not to work :)

Files:

• plugins/moto-sync/motosync.py (modified) (17 diffs)

plugins/moto-sync/motosync.py

@@ -4 +4 @@
 """
 
-# Copyright (C) 2006  Andrew Baumann <andrewb@cse.unsw.edu.au>
+# Copyright (C) 2006-2007  Andrew Baumann <andrewb@cse.unsw.edu.au>
 #
 #  This program is free software; you can redistribute it and/or modify
@@ -368 +368 @@
 
 
-class OpenSyncError(Exception):
-    """Simple exception class carrying a message and an opensync error number.
-
-    These errors are reported back to opensync by the stdexceptions decorator
-    on SyncClass methods.
-    """
-    def __init__(self, msg, errnum=opensync.ERROR_GENERIC):
-        Exception.__init__(self)
-        self.msg = msg
-        self.num = errnum
-    def __str__(self):
-        return self.msg
-    def report(self, context):
-        """Report myself as an error to the given OSyncContext object."""
-        context.report_error(self.num, self.msg)
-
-
 class UnsupportedDataError(Exception):
     """Exception raised by PhoneEntry classes when the data cannot be stored."""
@@ -400 +383 @@
     """
     def __init__(self, device):
+        self.devstr = device
         self.__calendar_open = False
         self.__fd = self.__btsock = None
-
-        if BT_MAC_RE.match(device):
+        self.max_events = None
+        self.num_events = None
+        self.event_name_len = None
+        self.event_max_exceptions = None
+        self.min_contact_pos = None
+        self.max_contact_pos = None
+        self.contact_data_len = None
+        self.contact_name_len = None
+
+    def connect(self):
+        if BT_MAC_RE.match(self.devstr):
             assert(USE_BLUETOOTH_MODULE,
                    "MAC address specified, but pybluez module is not available")
@@ -409 +402 @@
             # search for the port to use on the device
             port = BT_DEFAULT_CHANNEL
-            found = bluetooth.find_service(name=BT_SERVICE_NAME, address=device)
+            found = bluetooth.find_service(name=BT_SERVICE_NAME, address=self.devstr)
             if found:
                 assert(found[0]['protocol'] == 'RFCOMM')
                 port = found[0]['port']
             self.__btsock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
-            self.__btsock.connect((device, port))
-        else:
-            self.__fd = os.open(device, os.O_RDWR)
+            self.__btsock.connect((self.devstr, port))
+        else:
+            self.__fd = os.open(self.devstr, os.O_RDWR)
             if USE_TTY_MODULE:
                 tty.setraw(self.__fd)
@@ -443 +436 @@
         self.contact_name_len = namelen
 
-    def __del__(self):
+    def disconnect(self):
         self.close_calendar()
         if self.__fd:
             os.close(self.__fd)
+            self.__fd = None
         if self.__btsock:
             self.__btsock.close()
+            self.__btsock = None
 
     def read_serial(self):
@@ -508 +503 @@
             for (expos, exnum, extype) in self.__parse_results('MDBRE', data):
                 if extype != 1: # haven't seen anything else
-                    raise OpenSyncError('unexpected exception type %d' % extype)
+                    raise opensync.Error('unexpected exception type %d' % extype)
                 if not exceptions.has_key(expos):
                     exceptions[expos] = []
@@ -637 +632 @@
         debug('<-- ' + ret)
         if c == '': # EOF, shouldn't happen
-            raise OpenSyncError('Unexpected EOF talking to phone',
-                                opensync.ERROR_IO_ERROR)
+            raise opensync.Error('Unexpected EOF talking to phone',
+                                 opensync.ERROR_IO_ERROR)
         return ret
 
@@ -664 +659 @@
             return ret
         else:
-            raise OpenSyncError("Error in phone command '%s'" % cmd,
-                                opensync.ERROR_IO_ERROR)
+            raise opensync.Error("Error in phone command '%s'" % cmd,
+                                 opensync.ERROR_IO_ERROR)
 
     def __parse_results(self, restype, lines):
@@ -1477 +1472 @@
                 i += 1
             if i > self.maxpos:
-                raise OpenSyncError('No %s positions free' % self.objtype)
+                raise opensync.Error('No %s positions free' % self.objtype)
             self.used.add(i)
             ret.append(i)
@@ -1490 +1485 @@
     def __init__(self, comms):
         self.comms = comms
+        self.serial = None
+        self.positions = {}
+        self.categories = {}
+        self.revcategories = {}
+
+    def connect(self):
+        self.comms.connect()
         self.serial = comms.read_serial()
 
@@ -1496 +1498 @@
         for (bit, desc) in REQUIRED_FEATURES:
             if not features[bit]:
-                raise OpenSyncError(desc + ' feature not present',
-                                    opensync.ERROR_NOT_SUPPORTED)
+                raise opensync.Error(desc + ' feature not present',
+                                     opensync.ERROR_NOT_SUPPORTED)
 
         # read current time on the phone, check if it matches our local time
@@ -1507 +1509 @@
             msg = ("ERROR: Phone appears to be in a different timezone!\n"
                    + "Phone time is %s" % time.strftime('%c', phone_now))
-            raise OpenSyncError(msg)
+            raise opensync.Error(msg)
 
         # initialise the position allocators
-        self.positions = {}
         self.positions['event'] = PosAllocator('event', 0,
                                                self.comms.max_events - 1)
@@ -1518 +1519 @@
 
         # initialise the category mappings
-        self.categories = {}
-        self.revcategories = {}
         self.__init_categories()
 
-    def list_changes(self, objtype, member):
+    def disconnect(self):
+        self.comms.disconnect()
+
+    def list_changes(self, objtype, info):
         """Return a list of change objects for all entries of the given type."""
 
@@ -1542 +1544 @@
         ret = []
         for entry in entries:
-            change = opensync.OSyncChange()
+            change = opensync.Change()
             change.member = member
             change.objtype = objtype
@@ -1577 +1579 @@
         objtype = change.objtype
         if change.format != 'xml-%s-doc' % objtype:
-            raise OpenSyncError("unhandled data format %s" % change.format,
-                                opensync.ERROR_NOT_SUPPORTED)
+            raise opensync.Error("unhandled data format %s" % change.format,
+                                 opensync.ERROR_NOT_SUPPORTED)
         try:
             if objtype == 'event':
@@ -1675 +1677 @@
 
 
-def stdexceptions(func):
-    """Decorator used to wrap every method in SyncClass with the same
-    exception handlers. Reports any exception back to opensync as an error,
-    otherwise reports success.
-    """
-    def new_func(*args, **kwds):
-        """Invoke func, report success, otherwise report an error."""
-
-        context = args[1] # context is always the first argument after 'self'
-
-        # if the bluetooth module is present, handle its exceptions as IO errors
-        if USE_BLUETOOTH_MODULE:
-            ioerrors = (IOError, OSError, bluetooth.BluetoothError)
-        else:
-            ioerrors = (IOError, OSError)
-
-        try:
-            func(*args, **kwds)
-            context.report_success()
-        except OpenSyncError, e:
-            e.report(context)
-        except ioerrors, e:
-            context.report_error(opensync.ERROR_IO_ERROR, str(e))
-        except:
-            context.report_error(opensync.ERROR_GENERIC, traceback.format_exc())
-    new_func.func_name = func.func_name
-    return new_func
-
-
-class SyncClass:
-    """Synchronisation class used by OpenSync."""
-
-    def __init__(self, member):
-        self.member = member
-        self.comms = self.access = None
-        self.config = {}
-        self.__parse_config(self.member.config)
-        self.hashtable = opensync.OSyncHashTable()
-        if not self.hashtable.load(self.member):
-            raise OpenSyncError('hashtable load failed',
-                                opensync.ERROR_INITIALIZATION)
-
-    @stdexceptions
-    def connect(self, ctx):
+class MotoSink(opensync.ObjTypeSink):
+    """Event synchronisation class used by OpenSync."""
+
+    def __init__(self, objtype, info, access):
+        opensync.ObjTypeSink.__init__(self, objtype, self)
+        self.objtype = objtype
+        self.add_objformat("xml-%s-doc" % objtype)
+        self.access = access
+        hashpath = os.path.join(info.configdir, "%s-hash.db" % objtype)
+        self.hashtable = opensync.HashTable(hashpath, objtype)
+
+    def connect(self, info, ctx):
         """Connect to the phone."""
-        self.comms = PhoneComms(self.config['device'])
-        self.access = PhoneAccess(self.comms)
-
-    @stdexceptions
-    def get_changeinfo(self, ctx):
+        self.access.connect()
+
+    def get_changes(self, info, ctx):
         """Report all OSyncChange objects for entries on the phone."""
-        for objtype in SUPPORTED_OBJTYPES:
-            if self.member.objtype_enabled(objtype):
-                if self.member.get_slow_sync(objtype):
-                    self.hashtable.set_slow_sync(objtype)
-
-                for change in self.access.list_changes(objtype, self.member):
-                    self.hashtable.detect_change(change)
-                    if change.changetype != opensync.CHANGE_UNMODIFIED:
-                        change.report(ctx)
-                        self.hashtable.update_hash(change)
-
-                self.hashtable.report_deleted(ctx, objtype)
-
-    @stdexceptions
-    def commit_change(self, ctx, change):
+        if self.slowsink:
+            self.hashtable.reset()
+        for change in self.access.list_changes(self.objtype, info):
+            self.hashtable.report(change.uid)
+            change.changetype = self.hashtable.get_changetype(change.uid, change.hash)
+            if change.changetype != opensync.CHANGE_UNMODIFIED:
+                self.hashtable.update_hash(change.changetype, change.uid, change.hash)
+                ctx.report_change(change)
+        for uid in self.hashtable.get_deleted():
+            change = opensync.Change()
+            change.uid = uid
+            change.changetype = opensync.CHANGE_DELETED
+            ctx.report_change(change)
+            hashtable.update_hash(opensync.CHANGE_DELETED, uid, None)
+
+    def commit(self, info, ctx, change):
         """Write a change to the phone."""
-        if change.objtype not in SUPPORTED_OBJTYPES:
-            raise OpenSyncError('unsupported objtype %s' % change.objtype,
-                                opensync.ERROR_NOT_SUPPORTED)
+        if change.objtype != self.objtype:
+            raise opensync.Error('unsupported objtype %s' % change.objtype,
+                                 opensync.ERROR_NOT_SUPPORTED)
         if change.changetype == opensync.CHANGE_DELETED:
             success = (self.access.uid_seen(change.uid)
@@ -1754 +1723 @@
             # the old one was deleted, to keep it consistent
             if (success and old_uid != change.uid):
-                fake_change = opensync.OSyncChange()
-                fake_change.uid = old_uid
-                fake_change.changetype = opensync.CHANGE_DELETED
-                self.hashtable.update_hash(fake_change)
+                self.hashtable.update_hash(opensync.CHANGE_DELETED, old_uid, None)
         else:
             success = self.access.update_entry(change)
         if success:
-            self.hashtable.update_hash(change)
-
-    @stdexceptions
-    def sync_done(self, ctx):
+            self.hashtable.update_hash(change.changetype, change.uid, change.hash)
+
+    def sync_done(self, info, ctx):
         """Called when the sync is complete."""
         self.hashtable.forget()
-
-    @stdexceptions
-    def disconnect(self, ctx):
+        self.hashtable.close()
+
+    def disconnect(self, info, ctx):
         """Called to disconnect from the phone."""
-        del self.access
-        del self.comms
-
-    def finalize(self):
-        """Called just before we are cleaned up."""
-        self.hashtable.close()
-        del self.hashtable
-        del self.member
-
-    def __parse_config(self, configstr):
-        """Parse the config data and return a hash of config values."""
-        try:
-            doc = xml.dom.minidom.parseString(configstr)
-        except:
-            raise OpenSyncError('failed to parse config data',
-                                opensync.ERROR_MISCONFIGURATION)
-
-        self.config['device'] = getXMLField(doc, 'device').strip()
-        if self.config['device'] == '':
-            raise OpenSyncError('device not specified in config file',
-                                opensync.ERROR_MISCONFIGURATION)
-
-
-def initialize(member):
-    """Called by python-module plugin wrapper, returns instance of SyncClass."""
-    return SyncClass(member)
-
-def get_info(info):
+        self.access.disconnect()
+
+
+def parse_config(configstr):
+    """Parse the config data and return the device string."""
+    try:
+        doc = xml.dom.minidom.parseString(configstr)
+    except:
+        raise opensync.Error('failed to parse config data',
+                             opensync.ERROR_MISCONFIGURATION)
+
+    ret = getXMLField(doc, 'device').strip()
+    if ret == '':
+        raise opensync.Error('device not specified in config file',
+                             opensync.ERROR_MISCONFIGURATION)
+    return ret
+
+def initialize(info):
+    """Called by python-module plugin wrapper, registers sync classes."""
+    comms = PhoneComms(parse_config(info.config))
+    access = PhoneAccess(comms)
+    for objtype in SUPPORTED_OBJTYPES:
+        info.add_objtype(MotoSink(objtype, info, access))
+
+def discover(info):
+    """Called by python-module plugin wrapper, discovers capabilities of device."""
+    for sink in info.objtypes:
+        sink.available = True
+    info.version = opensync.Version()
+    info.version.plugin = "moto-sync"
+
+def get_sync_info(plugin):
     """Called by python-module plugin wrapper, returns plugin metadata."""
-    info.name = "moto-sync"
-    info.longname = "Motorola synchronisation plugin"
-    info.description = ("Plugin to synchronise phone book and calendar entries "
-                      + "on a Motorola mobile phone using extended AT commands")
-    for objtype in SUPPORTED_OBJTYPES:
-        info.accept_objtype(objtype)
-        info.accept_objformat(objtype, "xml-%s-doc" % objtype)
+    plugin.name = "moto-sync"
+    plugin.longname = "Motorola synchronisation plugin"
+    plugin.description = ("OpenSync plugin to synchronise phone book and"
+        " calendar entries on a locally-connected Motorola mobile phone using"
+        " extended AT commands. Please see the README file for configuration"
+        " instructions and a list of supported models.")
+    plugin.config_type = opensync.PLUGIN_NEEDS_CONFIGURATION