src/vpp-api/python/vpp_papi/pneum_wrap.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <Python.h>
  17 #include "../pneum/pneum.h"
  18 #include <vppinfra/hash.h>
  19
  20 static PyObject *pneum_callback = NULL;
  21
  22 static void
  23 wrap_pneum_callback (unsigned char * data, int len)
  24 {
  25   PyGILState_STATE gstate;
  26   PyObject *result;//, *arglist;
  27
  28   gstate = PyGILState_Ensure();
  29
  30   /* Time to call the callback */
  31 #if PY_VERSION_HEX >= 0x03000000
  32   result = PyObject_CallFunction(pneum_callback, "y#", data, len);
  33 #else
  34   result = PyObject_CallFunction(pneum_callback, "s#", data, len);
  35 #endif
  36   if (result)
  37     Py_DECREF(result);
  38   else
  39     PyErr_Print();
  40
  41   PyGILState_Release(gstate);
  42 }
  43
  44 static PyObject *
  45 wrap_connect (PyObject *self, PyObject *args, PyObject *kw)
  46 {
  47   char * name, * chroot_prefix = NULL;
  48   int rx_qlen = 32; /* default rx queue length */
  49   int rv;
  50   PyObject * temp = NULL;
  51   pneum_callback_t cb = NULL;
  52
  53   if (!PyArg_ParseTuple(args, "sOzi:wrap_connect",
  54                         &name, &temp, &chroot_prefix, &rx_qlen))
  55     return (NULL);
  56
  57   if (temp != Py_None)
  58     {
  59       if (!PyCallable_Check(temp))
  60         {
  61           PyErr_SetString(PyExc_TypeError, "parameter must be callable");
  62           return NULL;
  63         }
  64
  65       Py_XINCREF(temp);         /* Add a reference to new callback */
  66       Py_XDECREF(pneum_callback);  /* Dispose of previous callback */
  67       pneum_callback = temp;       /* Remember new callback */
  68       cb = wrap_pneum_callback;
  69     }
  70   Py_BEGIN_ALLOW_THREADS
  71   rv = pneum_connect(name, chroot_prefix, cb, rx_qlen);
  72   Py_END_ALLOW_THREADS
  73   return PyLong_FromLong(rv);
  74 }
  75
  76 static PyObject *
  77 wrap_disconnect (PyObject *self, PyObject *args)
  78 {
  79   int rv;
  80   Py_BEGIN_ALLOW_THREADS
  81   rv = pneum_disconnect();
  82   Py_END_ALLOW_THREADS
  83   return PyLong_FromLong(rv);
  84 }
  85
  86 static PyObject *
  87 wrap_write (PyObject *self, PyObject *args)
  88 {
  89   char *data;
  90   int len, rv;
  91
  92   if (!PyArg_ParseTuple(args, "s#", &data, &len))
  93     return NULL;
  94
  95   Py_BEGIN_ALLOW_THREADS
  96   rv = pneum_write(data, len);
  97   Py_END_ALLOW_THREADS
  98
  99   return PyLong_FromLong(rv);
 100 }
 101
 102 static PyObject *
 103 wrap_read (PyObject *self, PyObject *args)
 104 {
 105   char *data;
 106   int len, rv;
 107   unsigned short timeout;
 108
 109   if (!PyArg_ParseTuple(args, "H", &timeout))
 110     return (NULL);
 111   Py_BEGIN_ALLOW_THREADS
 112   rv = pneum_read(&data, &len, timeout);
 113   Py_END_ALLOW_THREADS
 114
 115   if (rv != 0) { Py_RETURN_NONE; }
 116 #if PY_VERSION_HEX >= 0x03000000
 117   PyObject *ret = Py_BuildValue("y#", data, len);
 118 #else
 119   PyObject *ret = Py_BuildValue("s#", data, len);
 120 #endif
 121   pneum_free(data);
 122   if (!ret) { Py_RETURN_NONE; }
 123
 124   return ret;
 125 }
 126
 127 static PyObject *
 128 wrap_msg_table (PyObject *self, PyObject *args)
 129 {
 130   int i = 0, rv = 0;
 131   hash_pair_t *hp;
 132   uword *h = pneum_msg_table_get_hash();
 133   PyObject *ret = PyList_New(pneum_msg_table_size());
 134   if (!ret) goto error;
 135   hash_foreach_pair (hp, h,
 136   ({
 137     PyObject *item = PyTuple_New(2);
 138     if (!item) goto error;
 139     rv = PyTuple_SetItem(item, 0, PyLong_FromLong((u32)hp->value[0]));
 140     if (rv) goto error;
 141     rv = PyTuple_SetItem(item, 1, PyString_FromString((char *)hp->key));
 142     if (rv) goto error;
 143     PyList_SetItem(ret, i, item);
 144     i++;
 145   }));
 146
 147   return ret;
 148
 149  error:
 150   /* TODO: Raise exception */
 151   printf("msg_table failed");
 152   Py_RETURN_NONE;
 153 }
 154
 155 static PyObject *
 156 wrap_suspend (PyObject *self, PyObject *args)
 157 {
 158   Py_BEGIN_ALLOW_THREADS
 159   pneum_rx_suspend();
 160   Py_END_ALLOW_THREADS
 161   Py_RETURN_NONE;
 162 }
 163
 164 static PyObject *
 165 wrap_resume (PyObject *self, PyObject *args)
 166 {
 167   Py_BEGIN_ALLOW_THREADS
 168   pneum_rx_resume();
 169   Py_END_ALLOW_THREADS
 170   Py_RETURN_NONE;
 171 }
 172
 173 static PyMethodDef vpp_api_Methods[] = {
 174   {"connect", wrap_connect, METH_VARARGS, "Connect to the VPP API."},
 175   {"disconnect", wrap_disconnect, METH_VARARGS, "Disconnect from the VPP API."},
 176   {"write", wrap_write, METH_VARARGS, "Write data to the VPP API."},
 177   {"read", wrap_read, METH_VARARGS, "Read data from the VPP API."},
 178   {"msg_table", wrap_msg_table, METH_VARARGS, "Get API dictionary."},
 179   {"suspend", wrap_suspend, METH_VARARGS, "Suspend RX thread."},
 180   {"resume", wrap_resume, METH_VARARGS, "Resume RX thread."},
 181   {NULL, NULL, 0, NULL}        /* Sentinel */
 182 };
 183
 184 #if PY_VERSION_HEX >= 0x03000000
 185 PyMODINIT_FUNC
 186 PyInit_vpp_api (void)
 187 #else
 188 void
 189 initvpp_api (void)
 190 #endif
 191 {
 192 #if PY_VERSION_HEX >= 0x03000000
 193   static struct PyModuleDef vpp_api_module = {
 194 #if PY_VERSION_HEX >= 0x03020000
 195     PyModuleDef_HEAD_INIT,
 196 #else
 197     {
 198       PyObject_HEAD_INIT(NULL)
 199       NULL, /* m_init */
 200       0,    /* m_index */
 201       NULL, /* m_copy */
 202     },
 203 #endif
 204     (char *) "vpp_api",
 205     NULL,
 206     -1,
 207     vpp_api_Methods,
 208     NULL,
 209     NULL,
 210     NULL,
 211     NULL
 212   };
 213 #endif
 214
 215   /* Ensure threading is initialised */
 216   if (!PyEval_ThreadsInitialized()) {
 217     PyEval_InitThreads();
 218   }
 219
 220 #if PY_VERSION_HEX >= 0x03000000
 221   return PyModule_Create(&vpp_api_module);
 222 #else
 223   Py_InitModule((char *) "vpp_api", vpp_api_Methods);
 224   return;
 225 #endif
 226 }