Changeset 640:237cf6339546 in freeDiameter for extensions/dbg_interactive

Timestamp:

Dec 20, 2010, 7:36:40 PM (13 years ago)

Author:

Sebastien Decugis <sdecugis@nict.go.jp>

Branch:

default

Phase:

public

Message:

dbg_interactive almost complete

Location:

extensions/dbg_interactive

Files:

• CMakeLists.txt (modified) (1 diff)
• dbg_interactive.i (modified) (5 diffs)
• endpoints.i (added)
• events.i (added)
• lists.i (modified) (1 diff)
• messages.i (modified) (1 diff)
• peers.i (modified) (2 diffs)
• queues.i (modified) (4 diffs)
• routing.i (modified) (2 diffs)

extensions/dbg_interactive/CMakeLists.txt

@@ -26 +26 @@
         queues.i
         peers.i
+        events.i
+        endpoints.i
         )
 SET_SOURCE_FILES_PROPERTIES(dbg_interactive.i PROPERTIES SWIG_MODULE_NAME fDpy)

extensions/dbg_interactive/dbg_interactive.i

@@ -68 +68 @@
 static int wrapper_errno;
 static PyObject* wrapper_errno_py;
-static char * wrapper_error_txt; /* if NULL, use strerror(errno) */
+static const char * wrapper_error_txt; /* if NULL, use strerror(errno) */
 #define DI_ERROR(code, pycode, str) {   \
         fd_log_debug("[dbg_interactive] ERROR: %s: %s\n", __PRETTY_FUNCTION__, str ? str : strerror(code)); \
@@ -88 +88 @@
         /* Now, test for error */
         if (wrapper_errno) {
-                char * str = wrapper_error_txt ? wrapper_error_txt : strerror(wrapper_errno);
+                const char * str = wrapper_error_txt ? wrapper_error_txt : strerror(wrapper_errno);
                 PyObject * exc = wrapper_errno_py;
                 if (!exc) {
@@ -109 +109 @@
  ***********************************/
 
-%apply (char *STRING, size_t LENGTH) { ( char * string, size_t len ) }; /* fd_hash */
+%apply (char *STRING, size_t LENGTH) { ( char * string, size_t len ) };
 
 /* Generic typemap for functions that create something */
@@ -119 +119 @@
 }
 
+/* Typemap to return a boolean value as output parameter */
+%typemap(in, numinputs=0,noblock=1) int * BOOL_OUT (int temp) {
+        $1 = &temp;
+}
+%typemap(argout,noblock=1) int * BOOL_OUT {
+        PyObject * r;
+        if (*$1)
+                r = Py_True;
+        else
+                r = Py_False;
+        Py_XINCREF(r);
+        %append_output(r);
+}
+
 /* To allow passing callback functions defined in python */
 %typemap(in) PyObject *PyCb {
-        if (!PyCallable_Check($input)) {
-                PyErr_SetString(PyExc_TypeError, "Need a callable object!");
-                SWIG_fail;
+        if (!$input || ($input == Py_None)) {
+                $1 = NULL;
+        } else {
+                if (!PyCallable_Check($input)) {
+                        PyErr_SetString(PyExc_TypeError, "Need a callable object!");
+                        SWIG_fail;
+                }
+                $1 = $input;
         }
-        $1 = $input;
 }
 
-
+%{
 /* Forward declaration for the peers module */
-%{
 static void fd_add_cb(struct peer_info *peer, void *data);
 %}
+
+/* Overwrite declaration to apply typemaps */
+int fd_sess_fromsid ( char * STRING, size_t LENGTH, struct session ** OUTPUT, int * BOOL_OUT);
+
 
 /*********************************************************
@@ -155 +176 @@
 
 %include "peers.i"
+%include "events.i"
+%include "endpoints.i"

extensions/dbg_interactive/lists.i

@@ -71 +71 @@
         }
         /* Test for emptyness */
-        int isempty() {
-                return FD_IS_LIST_EMPTY($self);
+        PyObject * isempty() {
+                PyObject * ret;
+                if (FD_IS_LIST_EMPTY($self))
+                        ret = Py_True;
+                else
+                        ret = Py_False;
+                Py_XINCREF(ret);
+                return ret;
         }
         /* Concatenate two lists */

extensions/dbg_interactive/messages.i

@@ -293 +293 @@
         
         /* Is routable? */
-        int is_routable() {
-                return fd_msg_is_routable($self);
+        PyObject * is_routable() {
+                PyObject * r;
+                if (fd_msg_is_routable($self))
+                        r = Py_True;
+                else
+                        r = Py_False;
+                Py_XINCREF(r);
+                return r;
         }
         

extensions/dbg_interactive/peers.i

@@ -67 +67 @@
 
 %extend peer_info {
+        peer_info () {
+                struct peer_info *np = (struct peer_info *)calloc(1, sizeof(struct peer_info));
+                if (!np) {
+                        DI_ERROR_MALLOC;
+                        return NULL;
+                }
+                
+                fd_list_init(&np->pi_endpoints, NULL);
+                
+                return np;
+        }
+
         /* Wrapper around fd_peer_add to allow calling the python callback */
+        %delobject add;
         void add(PyObject * PyCb=NULL) {
                 int ret;
@@ -81 +94 @@
                 }
         }
-
-        /* Add an endpoint */
-        void add_endpoint(char * endpoint) {
-                fd_log_debug("What is the best way in python to pass an endpoint? (ip + port)");
-        }
-
-}
+}
+
+%inline %{
+static struct peer_hdr * peer_search(char *diamid) {
+        struct peer_hdr *r = NULL;
+        int ret = fd_peer_getbyid( diamid, &r );
+        if (ret) {
+                DI_ERROR(ret, NULL, NULL);
+                return NULL;
+        }
+        return r;
+}
+%}
+
+%{
+static PyObject * validate_cb_py = NULL;
+static PyObject * validate_cb2_py = NULL;
+
+/* C wrapper that calls validate_cb2_py */
+int call_the_python_validate_callback2(struct peer_info * info) {
+        PyObject *PyInfo;
+        PyObject *result = NULL;
+        int ret = 0;
+        
+        if (!validate_cb2_py) {
+                fd_log_debug("Internal error: missing the callback2!\n");
+                return ENOTSUP;
+        }
+        
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        /* Convert the arguments */
+        PyInfo  = SWIG_NewPointerObj((void *)info,     SWIGTYPE_p_peer_info,     0 );
+        
+        /* Call the function */
+        result = PyEval_CallFunction(validate_cb2_py, "(O)", PyInfo);
+        
+        /* The result is an integer */
+        if ((result == NULL) || !SWIG_IsOK(SWIG_AsVal_int(result, &ret))) {
+                fd_log_debug("Error: The Python callback did not return an integer.\n");
+                ret = EINVAL;
+                goto out;
+        }
+        
+out:    
+        Py_XDECREF(result);
+        SWIG_PYTHON_THREAD_END_BLOCK;
+        return ret;
+}
+
+/* C wrapper that calls validate_cb_py */
+int call_the_python_validate_callback(struct peer_info * info, int * auth, int (**cb2)(struct peer_info *)) {
+        PyObject *PyInfo;
+        PyObject *result = NULL;
+        int ret = 0;
+        
+        if (!validate_cb_py) {
+                fd_log_debug("Internal error: missing the callback!\n");
+                return ENOTSUP;
+        }
+        
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        /* Convert the arguments */
+        PyInfo  = SWIG_NewPointerObj((void *)info,     SWIGTYPE_p_peer_info,     0 );
+        
+        /* Call the function */
+        result = PyEval_CallFunction(validate_cb_py, "(O)", PyInfo);
+        
+        /* The result is supposedly -1, 1, or a cb2 */
+        if (result == NULL) {
+                fd_log_debug("Error: The Python callback did not return a value.\n");
+                ret = EINVAL;
+                goto out;
+        }
+        
+        if (PyCallable_Check(result)) {
+                if (cb2) {
+                        if (validate_cb2_py && (validate_cb2_py != result)) {
+                                fd_log_debug("Only 1 register callback2 is supported currently\n");
+                                ret = ENOTSUP;
+                                goto out;
+                        }
+                        validate_cb2_py = result;
+                        *cb2 = call_the_python_validate_callback2;
+                        *auth = 1;
+                        goto out_nodec;
+                } else {
+                        *auth = 1;
+                        goto out; /* ignore the callback since it won't be used */
+                }
+        } else { /* In this case, the return value must be -1, 0, or 1 */
+                if (!SWIG_IsOK(SWIG_AsVal_int(result, auth))) {
+                        fd_log_debug("Error: Cannot convert the return value to integer.\n");
+                        ret = EINVAL;
+                        goto out;
+                }
+        }
+        
+out:    
+        Py_XDECREF(result);
+out_nodec:      
+        SWIG_PYTHON_THREAD_END_BLOCK;
+        TRACE_DEBUG(FULL, "ret=%d, *auth=%d, cb2=%p, *cb2=%p", ret, *auth, cb2, cb2 ? *cb2 : NULL);
+        return ret;
+}
+
+%}
+
+%inline %{
+static void peer_validate_register(PyObject * PyCb) {
+        int ret ;
+        
+        if (!PyCb) {
+                DI_ERROR(EINVAL, NULL, "The callback must be provided");
+                return;
+        }
+        
+        if (validate_cb_py) {
+                if (PyCb != validate_cb_py) {
+                        DI_ERROR(ENOTSUP, PyExc_RuntimeError, "Only 1 register callback is supported currently");
+                        return;
+                }
+        } else {
+                validate_cb_py = PyCb;
+                Py_XINCREF(PyCb);
+        }
+        
+        ret = fd_peer_validate_register ( call_the_python_validate_callback );
+        if (ret) {
+                DI_ERROR(ret, NULL, NULL);
+        }
+}
+%}

extensions/dbg_interactive/queues.i

@@ -77 +77 @@
         
         /* Post an item */
-        void post(PyObject * item) {
-                int ret;
-                PyObject * i = item;
-                
-                Py_XINCREF(i);
-                ret = fd_fifo_post($self, &i);
+        void post(PyObject * item, char * type = NULL) {
+                int ret;
+                if (type) {
+                        void * real_obj = NULL;
+                        swig_type_info * desttype = NULL;
+                        desttype = SWIG_TypeQuery(type);
+                        if (!desttype) {
+                                DI_ERROR(EINVAL, NULL, "Unable to resolve this type. Please check the form: 'struct blahbla *'");
+                                return;
+                        }
+                        /* Now, get the "real" value under the shadow umbrella */
+                        ret = SWIG_ConvertPtr(item, &real_obj, desttype, SWIG_POINTER_DISOWN );
+                        if (!SWIG_IsOK(ret)) {
+                                DI_ERROR(EINVAL, SWIG_ErrorType(ret), "Unable to convert the item to given type");
+                                return;
+                        }
+                        ret = fd_fifo_post($self, &real_obj);
+                } else {
+                        PyObject * i = item;
+                        Py_XINCREF(i);
+                        ret = fd_fifo_post($self, &i);
+                }
                 if (ret != 0) {
                         DI_ERROR(ret, NULL, NULL);
@@ -89 +105 @@
         
         /* Get (blocking) */
-        PyObject * get() {
+        PyObject * get(char * type = NULL) {
                 int ret;
                 PyObject * i = NULL;
-                
-                ret = fd_fifo_get($self, &i);
-                if (ret != 0) {
-                        DI_ERROR(ret, NULL, NULL);
-                }
-                
-                return i;
+                void * obj = NULL;
+                swig_type_info * desttype = NULL;
+                if (type) {
+                        desttype = SWIG_TypeQuery(type);
+                        if (!desttype) {
+                                DI_ERROR(EINVAL, NULL, "Unable to resolve this type. Please check the form: 'struct blahbla *'");
+                                return NULL;
+                        }
+                }
+                
+                ret = fd_fifo_get($self, &obj);
+                if (ret != 0) {
+                        DI_ERROR(ret, NULL, NULL);
+                }
+                
+                if (type) {
+                        return SWIG_NewPointerObj(obj, desttype, 0 );
+                } else {
+                        i = obj;
+                        return i;
+                }
         }
         
         /* TryGet (non-blocking, returns None on empty queue) */
-        PyObject * tryget() {
+        PyObject * tryget(char * type = NULL) {
                 int ret;
                 PyObject * i = NULL;
-                
-                ret = fd_fifo_tryget($self, &i);
+                void * obj = NULL;
+                swig_type_info * desttype = NULL;
+                if (type) {
+                        desttype = SWIG_TypeQuery(type);
+                        if (!desttype) {
+                                DI_ERROR(EINVAL, NULL, "Unable to resolve this type. Please check the form: 'struct blahbla *'");
+                                return NULL;
+                        }
+                }
+                
+                ret = fd_fifo_tryget($self, &obj);
                 if (ret == EWOULDBLOCK) {
                         Py_XINCREF(Py_None);
@@ -115 +154 @@
                 }
                 
-                return i;
+                if (type) {
+                        return SWIG_NewPointerObj(obj, desttype, 0 );
+                } else {
+                        i = obj;
+                        return i;
+                }
         }
         
         /* TimedGet (blocking for a while) */
-        PyObject * timedget(long seconds) {
+        PyObject * timedget(long seconds, char * type = NULL) {
                 int ret;
                 PyObject * i = NULL;
                 struct timespec ts;
+                void * obj = NULL;
+                swig_type_info * desttype = NULL;
+                if (type) {
+                        desttype = SWIG_TypeQuery(type);
+                        if (!desttype) {
+                                DI_ERROR(EINVAL, NULL, "Unable to resolve this type. Please check the form: 'struct blahbla *'");
+                                return NULL;
+                        }
+                }
                 
                 clock_gettime(CLOCK_REALTIME, &ts);
                 ts.tv_sec += seconds;
                 
-                ret = fd_fifo_timedget($self, &i, &ts);
+                ret = fd_fifo_timedget($self, &obj, &ts);
                 if (ret == ETIMEDOUT) {
                         Py_XINCREF(Py_None);
@@ -136 +189 @@
                 }
                 
-                return i;
+                if (type) {
+                        return SWIG_NewPointerObj(obj, desttype, 0 );
+                } else {
+                        i = obj;
+                        return i;
+                }
         }
         

extensions/dbg_interactive/routing.i

@@ -77 +77 @@
 }
 
+
+
 %extend rtd_candidate {
         void dump() {
@@ -86 +88 @@
 }
 
+
+%{
+/* call it (will be called from a different thread than the interpreter, when message arrives) */
+static int call_the_python_rt_fwd_callback(void * pycb, struct msg **msg) {
+        PyObject *PyMsg;
+        PyObject *cb, *result = NULL;
+        int ret = 0;
+        
+        if (!pycb) {
+                fd_log_debug("Internal error: missing the callback!\n");
+                return ENOTSUP;
+        }
+        cb = pycb;
+        
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        /* Convert the arguments */
+        PyMsg  = SWIG_NewPointerObj((void *)*msg,     SWIGTYPE_p_msg,     0 );
+        
+        /* Call the function */
+        result = PyEval_CallFunction(cb, "(O)", PyMsg);
+        
+        /* The result is supposedly composed of: [ ret, *msg ] */
+        if ((result == NULL) || (!PyList_Check(result)) || (PyList_Size(result) != 2)) {
+                fd_log_debug("Error: The Python callback did not return [ ret, msg ].\n");
+                ret = EINVAL;
+                goto out;
+        }
+        
+        /* Convert the return values */
+        if (!SWIG_IsOK(SWIG_AsVal_int(PyList_GetItem(result, 0), &ret))) {
+                fd_log_debug("Error: Cannot convert the first return value to integer.\n");
+                ret = EINVAL;
+                goto out;
+        }
+        if (ret) {
+                TRACE_DEBUG(INFO, "The Python callback returned the error code %d (%s)\n", ret, strerror(ret));
+                goto out;
+        }
+        
+        if (!SWIG_IsOK(SWIG_ConvertPtr(PyList_GetItem(result, 1), (void *)msg, SWIGTYPE_p_msg, SWIG_POINTER_DISOWN))) {
+                fd_log_debug("Error: Cannot convert the second return value to message.\n");
+                ret = EINVAL;
+                goto out;
+        }
+        
+out:    
+        Py_XDECREF(result);
+        
+        SWIG_PYTHON_THREAD_END_BLOCK;
+        return ret;
+}
+%}
+
+
+struct fd_rt_fwd_hdl {
+};
+
+%extend fd_rt_fwd_hdl{
+        fd_rt_fwd_hdl(PyObject * PyCb, enum fd_rt_fwd_dir dir) {
+                struct fd_rt_fwd_hdl * r = NULL;
+                int ret;
+                
+                Py_XINCREF(PyCb);
+
+                ret = fd_rt_fwd_register( call_the_python_rt_fwd_callback, PyCb, dir, &r );
+                if (ret != 0) {
+                        DI_ERROR(ret, NULL, NULL);
+                        return NULL;
+                }
+                return r;
+        }
+        
+        ~fd_rt_fwd_hdl() {
+                PyObject * func;
+                int ret = fd_rt_fwd_unregister ( $self, (void *) &func );
+                if (ret != 0) {
+                        DI_ERROR(ret, NULL, NULL);
+                        return;
+                }
+                Py_XDECREF(func);
+                return;
+        }
+}
+
+
+%{
+/* call it (will be called from a different thread than the interpreter, when message arrives) */
+static int call_the_python_rt_out_callback(void * pycb, struct msg *msg, struct fd_list * candidates) {
+        PyObject *PyMsg, *PyCands;
+        PyObject *cb, *result = NULL;
+        int ret = 0;
+        
+        if (!pycb) {
+                fd_log_debug("Internal error: missing the callback!\n");
+                return ENOTSUP;
+        }
+        cb = pycb;
+        
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+        /* Convert the arguments */
+        PyMsg   = SWIG_NewPointerObj((void *)msg,        SWIGTYPE_p_msg,     0 );
+        PyCands = SWIG_NewPointerObj((void *)candidates, SWIGTYPE_p_fd_list, 0 );
+        
+        /* Call the function */
+        result = PyEval_CallFunction(cb, "(OO)", PyMsg, PyCands);
+        
+        /* The result is supposedly composed of: [ ret, *msg ] */
+        if (result == NULL){
+                fd_log_debug("Error: The Python callback raised an exception.\n");
+                ret = EINVAL;
+                goto out;
+        }
+        
+        /* Convert the return values */
+        if (!SWIG_IsOK(SWIG_AsVal_int(result, &ret))) {
+                fd_log_debug("Error: Cannot convert the return value to integer.\n");
+                ret = EINVAL;
+                goto out;
+        }
+out:    
+        Py_XDECREF(result);
+        
+        SWIG_PYTHON_THREAD_END_BLOCK;
+        return ret;
+}
+%}
+
+
+struct fd_rt_out_hdl {
+};
+
+%extend fd_rt_out_hdl{
+        fd_rt_out_hdl(PyObject * PyCb, int priority = 0) {
+                struct fd_rt_out_hdl * r = NULL;
+                int ret;
+                
+                Py_XINCREF(PyCb);
+
+                ret = fd_rt_out_register( call_the_python_rt_out_callback, PyCb, priority, &r );
+                if (ret != 0) {
+                        DI_ERROR(ret, NULL, NULL);
+                        return NULL;
+                }
+                return r;
+        }
+        
+        ~fd_rt_out_hdl() {
+                PyObject * func;
+                int ret = fd_rt_out_unregister ( $self, (void *) &func );
+                if (ret != 0) {
+                        DI_ERROR(ret, NULL, NULL);
+                        return;
+                }
+                Py_XDECREF(func);
+                return;
+        }
+}
+