Changeset 487

Timestamp:

04/11/05 17:41:43 (4 years ago)

Author:

ehabkost

Message:

Getting the changes from the python-plugins branch

Location:

plugins/python-module

Files:

• . (modified) (1 prop)
• Makefile.am (modified) (2 diffs)
• configure.in (modified) (1 diff)
• setup.py (copied) (copied from branches/python-plugins/plugins/python-module/setup.py)
• src/opensync.pyx (modified) (8 diffs)
• src/python_module.c (modified) (12 diffs)
• src/pywrap.c (copied) (copied from branches/python-plugins/plugins/python-module/src/pywrap.c)
• src/pywrap.h (modified) (1 diff)
• src/sample.py (copied) (copied from branches/python-plugins/plugins/python-module/src/sample.py)

plugins/python-module

@@ -13 +13 @@
 missing
 install-sh
+config.log
+config.h
+.libs
+.deps
+Makefile
+config.status
+stamp-h1
+libtool

@@ -13 +13 @@
 missing
 install-sh
+config.log
+config.h
+.libs
+.deps
+Makefile
+config.status
+stamp-h1
+libtool

plugins/python-module/Makefile.am

@@ -1 +1 @@
 plugindir=@OPENSYNC_PLUGINDIR@
 pythonplgdir=@OPENSYNC_PYTHONPLG_DIR@
-pythonlibdir=@OPENSYNC_PYTHONLIB_DIR@
 
 OPENSYNC_LIBS=-lopensync
@@ -7 +6 @@
 #FIXME: set EXTRA_DIST
 
+EXTRA_DIST = \
+        src/pywrap.c \
+        src/opensync.pyx
 
 plugin_LTLIBRARIES = python_module.la
 
 python_module_la_SOURCES = src/python_module.c
-python_module_la_LDFLAGS = @PYTHON_LDFLAGS@ -avoid-version -export-dynamic -module
-python_module_la_CFLAGS = -Wall -Werror
+python_module_la_LDFLAGS = @PYTHON_LDFLAGS@ -avoid-version -export-dynamic -module $(OSYNC_LIBS)
+python_module_la_CFLAGS = -Wall -Werror $(OSYNC_CFLAGS)
 python_module_la_CPPFLAGS = @PYTHON_CFLAGS@ \
-        -DOPENSYNC_PYTHONPLG_DIR=\"$(pythonplgdir)\" \
-        -DOPENSYNC_PYTHONLIB_DIR=\"$(pythonlibdir)\"
+        -DOPENSYNC_PYTHONPLG_DIR=\"$(pythonplgdir)\"
 python_module_la_LIBADD = @PYTHON_LIBS@
 
 
-# yes, _PROGRAMS. I am trying to avoid using libtool here
-pythonlib_PROGRAMS = opensync.so
-
-#FIXME: the lines below don't work. check why (maybe use distutils?)
-# only -Werror. pyrex generated code doesn't support -Wall
-opensync_so_CFLAGS = -Werror -fPIC
-opensync_so_CPPFLAGS = @PYTHON_CFLAGS@ -Werror
-nodist_opensync_so_SOURCES = src/opensync.c
-opensync_so_LDFLAGS = @PYTHON_LDFLAGS@ -shared
-opensync_so_LDADD = $(OPENSYNC_LIBS)
 
 src/opensync.c: src/opensync.pyx
         pyrexc $<
+
+# opensync python module building rules
+# It uses setup.py and distutils to
+# make things easier
+opensync.so: src/opensync.c setup.py
+        CFLAGS="$$CFLAGS $(OSYNC_CFLAGS)" python setup.py build_ext
+
+all-local: opensync.so
+
+install-exec-local:
+        python setup.py install
+
+clean-local:
+        python setup.py clean

plugins/python-module/configure.in

@@ -67 +67 @@
                 os_cv_python_sdk=yes])])])
 
-OPENSYNC_PLUGINDIR=${libdir}/opensync/plugins
+PKG_CHECK_MODULES(OSYNC, [opensync-1.0])
+
+OPENSYNC_CONFIGDIR=$(pkg-config --variable=configdir opensync-1.0)
+OPENSYNC_PLUGINDIR=$(pkg-config --variable=plugindir opensync-1.0)
+OPENSYNC_FORMATSDIR=$(pkg-config --variable=formatsdir opensync-1.0)
+OPENSYNC_HEADERDIR=$(pkg-config --variable=headerdir opensync-1.0)
+
+AC_SUBST(OPENSYNC_CONFIGDIR)
 AC_SUBST(OPENSYNC_PLUGINDIR)
+AC_SUBST(OPENSYNC_FORMATSDIR)
+AC_SUBST(OPENSYNC_HEADERDIR)
 
+#FIXME: Set the python plugin path using a better method, instead of just
+# using libdir
 OPENSYNC_PYTHONPLG_DIR=${libdir}/opensync/python-plugins
 AC_SUBST(OPENSYNC_PYTHONPLG_DIR)
 
-#FIXME: install opensync module on python library path, not on opensync directory
-OPENSYNC_PYTHONLIB_DIR=${libdir}/opensync/python
-AC_SUBST(OPENSYNC_PYTHONLIB_DIR)
-
 AC_OUTPUT([Makefile])

plugins/python-module/src/opensync.pyx

@@ -29 +29 @@
         OSyncObjFormat *osync_change_get_objformat(OSyncChange *change)
         void osync_change_set_member(OSyncChange *change, OSyncMember *member)
+        void osync_change_ref(OSyncChange *change)
+        void osync_change_decref(OSyncChange *change)
         
         #objformat methods
@@ -39 +41 @@
 
 cdef extern from "pywrap.h":
+        ctypedef struct PythonPluginInfo
+
+        # pyrex doesn't handle typecasts gracefully,
+        # so the functions below are just macros that
+        # do typecasts
         OSyncMember *osync_member_from_void(void *m)
         OSyncContext *osync_context_from_void(void *c)
+        OSyncChange *osync_change_from_void(void *c)
+        PythonPluginInfo *osync_plginfo_from_void(void *v)
+
+
+        void pywrap_accept_objtype(PythonPluginInfo *info, char *objtype)
+        void pywrap_accept_objformat(PythonPluginInfo *info, char *objtype, char *objformat, char *extension)
+        void pywrap_set_name_and_version(PythonPluginInfo *info, char *name, int version)
 
 cdef class Member:
@@ -59 +73 @@
                 self.memb = osync_member_from_void(v)
 
+# forward declaration
 cdef class Change
 
@@ -64 +79 @@
         """opensync OSyncContext object"""
         cdef OSyncContext *ctx
-        cdef void *v
         def __new__(self, c):
                 """Never call this method from python code.
@@ -70 +84 @@
                 Objects of this class are created only internally by OpenSync
                 """
-                # Another hack like the OSyncMember hack above,
-                # to be able to convert a python object
-                # to OSyncContext *
                 cdef void *v
                 v = PyCObject_AsVoidPtr(c)
@@ -78 +89 @@
 
         def report_change(self, Change chg):
+                # call _ref() to avoid the change
+                # from being free()d after destroying
+                # the python opensync.Change object
+                osync_change_ref(chg.chg)
+                #FIXME: Are we supposed to call ref() here,
+                # or osync_context_report_change() implies
+                # on a _ref() call?
+
                 osync_context_report_change(self.ctx, chg.chg)
 
@@ -90 +109 @@
         cdef OSyncChange *chg
 
-        def __new__(self, Member member):
-                self.chg = osync_change_new()
-                osync_change_set_member(self.chg, member.memb)
+        def __new__(self, Member member, chg = None):
+                """Creates a new change object
+
+                The chg parameter can be used only internally
+                by OpenSync. It is a CObject containing
+                an existing OSyncChange"""
+                cdef void *v
+                if chg is None:
+                        self.chg = osync_change_new()
+                        osync_change_set_member(self.chg, member.memb)
+                else:
+                        v = PyCObject_AsVoidPtr(chg)
+                        self.chg = osync_change_from_void(v)
+                        osync_change_ref(self.chg)
 
         def __dealloc__(self):
-                osync_change_free(self.chg)
+                osync_change_decref(self.chg)
 
         def set_objformat(self, name):
@@ -106 +136 @@
                 else: return None
 
+cdef class PluginInfo:
+        """opensync OSyncPluginInfo object"""
+
+        # python_module.c should be able to tell,
+        # somehow, which functions should be registered,
+        # pyinfo is used for that
+        cdef PythonPluginInfo *info
+
+        def __new__(self, info):
+                """Never call this method from python code.
+                
+                Objects of this class are created only internally by OpenSync
+                """
+                cdef void *v
+                v = PyCObject_AsVoidPtr(info)
+                self.info = osync_plginfo_from_void(v)
+
+        def accept_objtype(self, objtype):
+                pywrap_accept_objtype(self.info, objtype)
+        
+        def accept_objformat(self, objtype, objformat, extension = None):
+                cdef char *ext
+                if extension is None:
+                        ext = NULL
+                else:
+                        ext = extension
+                pywrap_accept_objformat(self.info, objtype, objformat, ext)
+
+        def set_name(self, name, version):
+                pywrap_set_name_and_version(self.info, name, version);
 
 # vim:ft=python

plugins/python-module/src/python_module.c

@@ -11 +11 @@
 #include <signal.h>
 
+#include "pywrap.h"
 
 struct MemberData {
@@ -19 +20 @@
 };
 
-/*FIXME: Provide the opensync plugin API to python modules.
- * Probably only a OSyncContext class implementation will suffice
- *
- * (report_change, report_error, report_success, etc.)
- *
- * Then, add parameters to the initialize, connect, etc. functions
- * of the python module
- */
-
-/** Insert plugin search path to sys.path
+/** Insert plugin search path in sys.path
  *
  * Isn't there an easier way of setting it?
+ *
+ *FIXME: It would be better if we just load modules from
+ * their filename, not setting the module search path
  */
 static int change_sys_path()
 {
         int rv = -1;
-        PyObject *sys, *path, *dir;
+        PyObject *sys = NULL;
+        PyObject *path = NULL;
+        PyObject *dir = NULL;
 
         sys = PyImport_ImportModule("sys");
-        if (!sys) goto error_sys;
+        if (!sys) goto error;
 
         path = PyObject_GetAttrString(sys, "path");
-        if (!path) goto error_path;
+        if (!path) goto error;
 
         dir = PyString_FromString(OPENSYNC_PYTHONPLG_DIR);
-        if (!dir) goto error_dir;
+        if (!dir) goto error;
 
         if (PyList_Insert(path, 0, dir) < 0)
-                goto error_insert;
-
-        /*FIXME: temporary hack, while the opensync module is not
-         * installed on the python module path
-         */
-        Py_DECREF(dir);
-        dir = PyString_FromString(OPENSYNC_PYTHONLIB_DIR);
-        if (!dir) goto error_dir;
-
-        if (PyList_Insert(path, 0, dir) < 0)
-                goto error_insert;
+                goto error;
 
         /* Success */
         rv = 0;
 
-error_insert:
-        Py_DECREF(dir);
-error_dir:
-        Py_DECREF(path);
-error_path:
-        Py_DECREF(sys);
-error_sys:
+error:
+        Py_XDECREF(dir);
+        Py_XDECREF(path);
+        Py_XDECREF(sys);
         return rv;
 }
@@ -74 +58 @@
 /** Calls the method initialize function
  *
- * The initialize() function should return an object that
+ * The python initialize() function should return an object that
  * has the other plugin methods (get_changeinfo, commit, etc.)
  */
-static void *py_initialize(OSyncMember *member)
-{
+static void *py_initialize(OSyncMember *member, OSyncError **error)
+{
+        char *name;
         struct MemberData *data = malloc(sizeof(struct MemberData));
         if (!data)
+                /*FIXME: set error info */
                 return NULL;
 
-        /*FIXME: the code loading should be on the get_info() function,
-         * if we support registering many plugins by a single
-         * loadable module.
-         *
-         * Suggestion: on get_info(), use the main interpreter, to avoid
-         * creating interpreter objects only to get plugin information.
-         * Then on initialize(), load the plugin using another interpreter
-         * (or thread state?) to keep the members on separated interpreters (or
-         * threads)
-         */
+        /* The plugin name was set on register_plugin() on plugin_data */
+        name = osync_plugin_get_plugin_data(osync_member_get_plugin(member));
+        if (!name)
+                /*FIXME: set error info */
+                return NULL;
+
         data->interp_thread = Py_NewInterpreter();
         if (0 && !data->interp_thread) {
@@ -100 +82 @@
         if (change_sys_path() < 0) {
                 osync_debug("python", 1, "Exception when initializing python intepreter");
+                PyErr_Print();
                 PyErr_Clear();
                 goto error_free_interp;
@@ -106 +89 @@
         if (!data->module) {
                 osync_debug("python", 1, "Couldn't load OpenSync module");
+                PyErr_Print();
                 PyErr_Clear();
                 goto error_free_interp;
         }
-        data->module = PyImport_ImportModule("testmodule");
+        data->module = PyImport_ImportModule(name);
         if (!data->module) {
                 osync_debug("python", 1, "Couldn't load testmodule");
+                PyErr_Print();
                 PyErr_Clear();
                 goto error_unload_osync_mod;
@@ -120 +105 @@
         if (!data->object) {
                 osync_debug("python", 1, "Error during initialize()");
+                PyErr_Print();
                 PyErr_Clear();
                 goto error_unload_module;
@@ -141 +127 @@
 
 static void py_finalize(void *data)
-{ /*FIXME: Implement me */
+{
         struct MemberData *mydata = data;
         PyEval_AcquireThread(mydata->interp_thread);
@@ -148 +134 @@
                 if (!ret) {
                         osync_debug("python", 1, "Error during finalize()");
+                        PyErr_Print();
                         PyErr_Clear();
                 } else
@@ -154 +141 @@
         Py_DECREF(mydata->object);
         Py_DECREF(mydata->module);
+        Py_DECREF(mydata->osync_module);
+        free(mydata);
+
         Py_EndInterpreter(mydata->interp_thread);
 }
 
-static void call_module_method(OSyncContext *ctx, char *name)
-{
+/** Create a new opensync.Change object for a given change */
+static PyObject *new_pychange(struct MemberData *mydata, OSyncChange *chg)
+{
+        PyObject *cobject = NULL;
+        PyObject *ret = NULL;
+
+        cobject = PyCObject_FromVoidPtr(chg, NULL);
+        if (!cobject)
+                goto error;
+
+        /* ret = opensync.Context(member=None, chg=cobject) */
+        ret = PyObject_CallMethod(mydata->osync_module, "Change", "OO", Py_None, cobject);
+
+        /* Done, drop reference even on success (the opensync.Change object
+         * will hold a reference to the cobject)
+         */
+        Py_XDECREF(cobject);
+
+        return ret;
+
+error:
+        Py_XDECREF(ret);
+        Py_XDECREF(cobject);
+        return NULL;
+}
+
+/** Create a new opensync.Context object for a given context */
+static PyObject *new_pycontext(struct MemberData *mydata, OSyncContext *ctx)
+{
+        PyObject *cobject = NULL;
+        PyObject *ret = NULL;
+
+        cobject = PyCObject_FromVoidPtr(ctx, NULL);
+        if (!cobject)
+                goto error;
+
+        /* ret = opensync.Context(cobject) */
+        ret = PyObject_CallMethod(mydata->osync_module, "Context", "O", cobject);
+
+        /* Done, drop reference even on success (the opensync.Context object
+         * will hold a reference to the cobject)
+         */
+        Py_XDECREF(cobject);
+
+        return ret;
+
+error:
+        Py_XDECREF(ret);
+        Py_XDECREF(cobject);
+        return NULL;
+}
+
+/** Call a python method
+ *
+ * Methods called using this function can
+ * have one of these formats:
+ *
+ * - function(context)
+ * - function(context, change)
+ */
+static void call_module_method(OSyncContext *ctx, OSyncChange *chg, char *name)
+{
+        PyObject *context = NULL;
+        PyObject *ret = NULL;
+        PyObject *change = NULL;
+
         struct MemberData *data = osync_context_get_plugin_data(ctx);
         PyEval_AcquireThread(data->interp_thread);
-        /*FIXME: send parameters */
-        {
-                PyObject *ret = PyObject_CallMethod(data->object, name, NULL);
-                if (!ret) {
-                        osync_debug("python", 1, "Error during %s() method", name);
+
+        if (chg) {
+                change = new_pychange(data, chg);
+                if (!change) {
+                        osync_debug("python", 1, "Can't create a change object");
+                        PyErr_Print();
+                        osync_context_report_error(ctx, OSYNC_ERROR_GENERIC, "Couldn't create a opensync.Change object");
                         PyErr_Clear();
-                } else
-                        Py_DECREF(ret);
-        }
+                        goto out;
+                }
+        }
+
+        context = new_pycontext(data, ctx);
+        if (!context) {
+                osync_debug("python", 1, "Can't create a context object");
+                PyErr_Print();
+                osync_context_report_error(ctx, OSYNC_ERROR_GENERIC, "Couldn't create a opensync.Context object");
+                PyErr_Clear();
+                goto out;
+        }
+
+        if (change)
+                ret = PyObject_CallMethod(data->object, name, "OO", context, change);
+        else
+                ret = PyObject_CallMethod(data->object, name, "O", context);
+
+        if (!ret) {
+                osync_debug("python", 1, "Error during %s() method", name);
+                PyErr_Print();
+                osync_context_report_error(ctx, OSYNC_ERROR_GENERIC, "Couldn't call python %s() method", name);
+                PyErr_Clear();
+                goto out;
+        }
+
+out:
+        Py_XDECREF(ret);
+        Py_XDECREF(change);
+        Py_XDECREF(context);
         PyEval_ReleaseThread(data->interp_thread);
 }
@@ -175 +258 @@
 static void py_connect(OSyncContext *ctx)
 {
-        call_module_method(ctx, "connect");
+        call_module_method(ctx, NULL, "connect");
 }
 
@@ -181 +264 @@
 static void py_get_changeinfo(OSyncContext *ctx)
 {
-        call_module_method(ctx, "get_changeinfo");
+        call_module_method(ctx, NULL, "get_changeinfo");
 }
 
 
 static void py_get_data(OSyncContext *ctx, OSyncChange *change)
-{ /*FIXME: Implement me */
+{
+        call_module_method(ctx, change, "get_data");
 }
 
 static osync_bool py_access(OSyncContext *ctx, OSyncChange *change)
-{ /*FIXME: Implement me */
+{
+        call_module_method(ctx, change, "access");
+        return TRUE;
+}
+
+static osync_bool py_commit_change(OSyncContext *ctx, OSyncChange *change)
+{
+        call_module_method(ctx, change, "commit_change");
         return 0;
 }
 
-static osync_bool py_commit_change(OSyncContext *ctx, OSyncChange *change)
-{ /*FIXME: Implement me */
-        return 0;
-}
-
 static void py_sync_done(OSyncContext *ctx)
-{ /*FIXME: Implement me */
+{
+        call_module_method(ctx, NULL, "sync_done");
 }
 
 static void py_disconnect(OSyncContext *ctx)
-{ /*FIXME: Implement me */
-}
-
-void get_info(OSyncPluginInfo *info)
-{
-        /* Python initialization */
-        struct sigaction old_sigint;
-
-        /* Hack to make python not overwrite SIGINT */
-        sigaction(SIGINT, NULL, &old_sigint);  /* Save old handler */
-        Py_Initialize();
-        sigaction(SIGINT, &old_sigint, NULL);  /* Restore it */
-        PyEval_InitThreads();
-        py_initialize(NULL);
-
-        info->name = "python_module";
-        info->version = 1;
-        info->is_threadsafe = 1;
-        
+{
+        call_module_method(ctx, NULL, "disconnect");
+}
+
+/** Register a new plugin from python module called name.
+ *
+ * @todo We need to avoid the loading of the python runtime
+ *       on get_info() somehow, but then we need to store all
+ *       plugin information on another place (including
+ *       accepted objtypes/formats info)
+ */
+static int register_plugin(OSyncEnv *env, PyObject *osync_module, char *name)
+{
+        PyObject *module = NULL;
+        PyObject *get_info_result = NULL;
+        PythonPluginInfo pyinfo;
+        PyObject *pyinfo_cobject = NULL;
+        PyObject *get_info_parm = NULL;
+        OSyncPluginInfo *info;
+        int ret = -1;
+
+        osync_trace(TRACE_ENTRY, "register_plugin");
+
+        module = PyImport_ImportModule(name);
+        if (!module) {
+                osync_debug("python", 1, "Couldn't load testmodule");
+                PyErr_Print();
+                PyErr_Clear();
+                goto out;
+        }
+
+        info = osync_plugin_new_info(env);
+        if (!info) {
+                osync_debug("python", 1, "Couldn't create a new plugin object");
+                goto error;
+        }
+
         info->functions.initialize = py_initialize;
         info->functions.connect = py_connect;
@@ -231 +336 @@
         info->functions.get_data = py_get_data;
         
-        /*FIXME: We can't know all accepted objtypes here. Only after
-         * loading the python module. This is possible only after loading
-         * the python module.
-         *
-         * There are two approaches to fix this: the first one is
-         * getting the python module name from the configuration
-         * data, loading the module and registering the formats on
-         * initialize() time. Then we need to support registering
-         * the accepted formats on initialize(). Even if we choose
-         * the other approach described below, maybe it would be a good thing
-         * make possible to register the accepted formats on initialize
-         * (but I am not sure, maybe it is a good thing to force the
-         * format information to be available after get_info()
-         *
-         * Another possible fix: make possible to
-         * a single loadable module report any number of plugin info,
-         * so the get_info() function here just
-         * scans the OSYNC_LIBDIR/python-plugins directory, and reports
-         * all plugins. I think this is more elegant, and the better approach.
-         * It has the disadvantage of loading the python interpreter at plugin-listing
-         * time, but if we have any python plugins available, listing them
-         * is expected, anyway
+        /*TODO: let the module get_info function fill the fields below: */
+        info->is_threadsafe = 1;
+
+        /* The plugin data is just the plugin name,
+         * to be used on py_initialize()
          */
-        osync_plugin_accept_objtype(info, "contact");
-        osync_plugin_accept_objformat(info, "contact", "vcard30");
-        osync_plugin_set_commit_objformat(info, "contact", "vcard30", py_commit_change);
-        osync_plugin_set_access_objformat(info, "contact", "vcard30", py_access);
-}
+        info->plugin_data = strdup(name);
+        
+        /** Build a PluginInfo object for use by get_info */
+        pyinfo.commit_fn = py_commit_change;
+        pyinfo.access_fn = py_access;
+        pyinfo.osync_info = info;

@@ -13 +13 @@
 missing
 install-sh
+config.log
+config.h
+.libs
+.deps
+Makefile
+config.status
+stamp-h1
+libtool