Beesnest/Engines/BnPython/BnPython.cpp

Go to the documentation of this file.

#include "BnPython.h"

/* This is the print function to set stuff to the server. */
static PyObject* Print (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    /* all args are the stuff to print */
    PyObject *itr = PyObject_GetIter(args);
    if (itr == NULL) return NULL;
    PyObject *item, *str;
    const char* ps;
    while (item = PyIter_Next(itr))
    {
        if (str = PyObject_Str (item))
            if (ps = PyString_AsString (str))
                myObj->sBuffer += ps;
        Py_DECREF(str);
        Py_DECREF(item);
    }
    Py_DECREF(itr);
    if (!myObj->CheckSizeLimit ())
        return NULL;
    Py_RETURN_NONE;
}

/*
 * The following functions are wrappers for the IdcRequest, IdcResponse and
 * IdcAdaptersSet objects. most of it is pretty much the same in every function.
 */
static PyObject* GetRequestHeader (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    const char* name;
    if (!PyArg_ParseTuple(args, "s", &name))
        return NULL;
    BufferHolder result = myObj->pReq->GetRequestHeader (BufferHolder (name));
    return Py_BuildValue("s", result.pointer);
}

static PyObject* GetRequestVariable (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    const char* name;
    if (!PyArg_ParseTuple(args, "s", &name))
        return NULL;
    BufferHolder result = myObj->pReq->GetRequestVariable (BufferHolder (name));
    return Py_BuildValue("s", result.pointer);
}

static PyObject* SetRequestVariable (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    const char* name;
    const char* value;
    if (!PyArg_ParseTuple(args, "ss", &name, &value))
        return NULL;
    myObj->pReq->SetRequestVariable (BufferHolder (name), BufferHolder (value));
    Py_RETURN_NONE;
}

static PyObject* GetRequestVarsNamesList (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    const char* sep;
    if (!PyArg_ParseTuple(args, "s", &sep))
        return NULL;
    BufferHolder result = myObj->pReq->GetRequestVarsNamesList (BufferHolder (sep));
    return Py_BuildValue("s", result.pointer);
}

static PyObject* SetResponseHeader (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    const char* name;
    const char* value;
    if (!PyArg_ParseTuple(args, "ss", &name, &value))
        return NULL;
    myObj->pRes->SetResponseHeader (BufferHolder (name), BufferHolder (value));
    Py_RETURN_NONE;
}

static PyObject* SetResponseCookie (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    const char* name;
    const char* value;
    int days = 1;
    const char* path = NULL;
    if (!PyArg_ParseTuple(args, "ss|is", &name, &value, &days, &path))
        return NULL;
    if (path)
        myObj->pRes->SetResponseCookie (BufferHolder (name), BufferHolder (value),
            days, BufferHolder (path));
    else
        myObj->pRes->SetResponseCookie (BufferHolder (name), BufferHolder (value), days);
    Py_RETURN_NONE;
}

static PyObject* Clear (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    myObj->pRes->Clear ();
    myObj->sBuffer.clear ();
    Py_RETURN_NONE;
}

static PyObject* Flush (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    try
    {   /* Flush my throw an exception. */
        myObj->pRes->Flush (BufferHolder (myObj->sBuffer.c_str (),
            myObj->sBuffer. size ()));
    }
    catch (int e)
    {   /* Beesnest socket has an exception, need to terminate the script and
            throw it back. */
        myObj->nException = e;  /* Store the exception for later. */
        PyErr_SetString(PyExc_SystemError, "Connection closed");
        return NULL;
    }
    myObj->sBuffer.clear ();
    Py_RETURN_NONE;
}

static PyObject* GetAdapter (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    const char* name;
    if (!PyArg_ParseTuple(args, "s", &name))
        return NULL;
    unsigned int aid = 0;
    if (myObj->pSet)
        aid = myObj->pSet->GetAdapter (BufferHolder (name));
    if (aid > 0)
        myObj->oAdaptersList.insert (aid);
    return Py_BuildValue("i", aid);
}

static PyObject* ReleaseAdapter (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    unsigned int aid;
    if (!PyArg_ParseTuple(args, "i", &aid))
        return NULL;
    if (myObj->pSet)
    {
        myObj->pSet->ReleaseAdapter (aid);
        myObj->oAdaptersList.erase (aid);
    }
    Py_RETURN_NONE;
}

static PyObject* Read (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    unsigned int aid;
    const char* address;
    if (!PyArg_ParseTuple(args, "is", &aid, &address))
        return NULL;
    BufferHolder result ("");
    try
    {
        if (myObj->pSet)
            result = myObj->pSet->Read (aid, BufferHolder (address));
    }
    catch (BufferHolder e)
    {   /* e.pointer doesn't have to end with NULL */
        char tmp [100] = {0};
        strncpy (tmp, e.pointer, e.size < 100 ? e.size : 99);
        PyErr_SetString(PyExc_SystemError, tmp);
        return NULL;
    }
    return Py_BuildValue("s", result.pointer);
}

static PyObject* Write (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    unsigned int aid;
    const char* address;
    const char* value = NULL;
    if (!PyArg_ParseTuple(args, "is|s", &aid, &address, &value))
        return NULL;
    bool result = false;
    try
    {
        if (myObj->pSet)
            result = myObj->pSet->Write (aid, BufferHolder (address),
                BufferHolder (value));
    }
    catch (BufferHolder e)
    {   /* e.pointer doesn't have to end with NULL */
        char tmp [100] = {0};
        strncpy (tmp, e.pointer, e.size < 100 ? e.size : 99);
        PyErr_SetString(PyExc_SystemError, tmp);
        return NULL;
    }
    return Py_BuildValue("b", result);
}

static PyObject* Exit (PyObject *self, PyObject *args)
{
    BnPython* myObj = BnPython::GetPointer (PyInt_AsLong (self));
    if (!myObj) return NULL;
    myObj->bExit = true;    /* Just set the exit flag to True. */
    return NULL;            /* NULL will terminate the script. */
}

/* This is the map of functions the interpreter will get */
static PyMethodDef EmbMethods[] =
{
    {"bn_print", Print, METH_VARARGS, "Print string to Beesnest buffer"},
    {"bn_get_hdr", GetRequestHeader, METH_VARARGS, "Return a HTTP request header"},
    {"bn_get_var", GetRequestVariable, METH_VARARGS, "Return a HTTP request variable"},
    {"bn_set_var", SetRequestVariable, METH_VARARGS, "Set a HTTP request variable"},
    {"bn_get_vars", GetRequestVarsNamesList, METH_VARARGS, "Return all HTTP request variables"},
    {"bn_set_hdr", SetResponseHeader, METH_VARARGS, "Set HTTP response header"},
    {"bn_set_cookie", SetResponseCookie, METH_VARARGS, "Set HTTP response cookie"},
    {"bn_clear", Clear, METH_VARARGS, "Clear the response"},
    {"bn_flush", Flush, METH_VARARGS, "Flush the response"},
    {"bn_adapter", GetAdapter, METH_VARARGS, "Get an adapter ID by name"},
    {"bn_free", ReleaseAdapter, METH_VARARGS, "Release an adapter by ID"},
    {"bn_read", Read, METH_VARARGS, "Read from adapter"},
    {"bn_write", Write, METH_VARARGS, "Write to adapter"},
    {"exit", Exit, METH_VARARGS, "Terminate the script"},
    {NULL, NULL, 0, NULL}
};

/*============================================================================*/


int BnPython::counter = 0;
map<int, BnPython*> BnPython::mPointers;

/*
Static function to get a BnPython pointer from an int.
This is a multi-thread function (using one static object),
but it should be OK also without using a Mutex.
*/
BnPython* BnPython::GetPointer (int num)
{
    map<int, BnPython*>::const_iterator itr = mPointers.find (num);
    if (itr == mPointers.end ())
    {
        PyErr_SetString(PyExc_ValueError,
            "First argument to bn_XXX function is not valid");
        return NULL;
    }
    return (itr->second);
}

BnPython::BnPython (const char* name, bool (*pGetParam)(const char*, char*, int))
:pRes (NULL), pReq (NULL), pSet (NULL), nException (0)
{
    sName = name;
    pfGetParam = pGetParam;
    nPointerCell = ++counter;
    mPointers[nPointerCell] = this;

    PyEval_AcquireLock();
    oTS = Py_NewInterpreter();

    /* This function initialize the BnPython module, and set the "self" argument
        to the value of nPointerCell */
    Py_InitModule4("BnPython", EmbMethods, "Beesnest-Python Functions",
        Py_BuildValue ("i", nPointerCell), PYTHON_API_VERSION);

    PyRun_SimpleString("import sys\nimport cStringIO");
    PyRun_SimpleString("from BnPython import *");

    PyThreadState_Swap(NULL);
    PyEval_ReleaseLock();
}


BnPython::~BnPython ()
{
    Stored ();
    mPointers.erase (nPointerCell);

    PyEval_AcquireLock();
    PyThreadState_Swap(oTS);
    Py_EndInterpreter(oTS);
    PyEval_ReleaseLock();
}

void BnPython::Stored ()
{
    ReleaseAdapters ();
    sBuffer.clear ();
}


void BnPython::Prepare (IdcRequest* preq, IdcResponse* pres, IdcAdaptersSet* pset)
{
    pReq = preq;
    pRes = pres;
    pSet = pset;
}


bool BnPython::Process (BufferHolder code, BufferHolder& result, int size_limit)
{
    bool ret_val = true;
    nSizeLimit = size_limit;
    sBuffer.clear ();
    if (code.empty ()) return false;

    bExit = false;

    string tmp (code.pointer, code.size);
    int place;
    while ((place = tmp.find ("\r")) != string::npos)
        tmp.replace (place, 1, "");

    PyEval_AcquireLock();
    PyThreadState_Swap(oTS);

    PyRun_SimpleString("sys.stdout = cStringIO.StringIO()\nsys.stderr = cStringIO.StringIO()");

    ret_val = PyRun_SimpleString(tmp.c_str ()) > -1;
    if (!ret_val && !bExit)     /* if bExit don't need to print a message. */
        PyRun_SimpleString("bn_print ('\\n<P><PRE>\\n', sys.stderr.getvalue(), '\\n</PRE></P>\\n')");

    PyRun_SimpleString("bn_print (sys.stdout.getvalue())");
    PyRun_SimpleString("sys.stdout.close()\nsys.stderr.close()");

    PyThreadState_Swap(NULL);
    PyEval_ReleaseLock();

    ReleaseAdapters ();
    /* Check if need to throw an exception to Beesnest. */
    if (nException != 0) throw nException;
    result.set (sBuffer.c_str ());
    return ret_val || bExit;
}

void BnPython::ReleaseAdapters ()
{
    if (pSet)
    {
        for (set<unsigned int>::iterator itr = oAdaptersList.begin ();
            itr != oAdaptersList.end (); ++itr)
            pSet->AdapterDone (*itr);

    }
    oAdaptersList.clear ();
}

bool BnPython::CheckSizeLimit ()
{
    if (nSizeLimit == 0 || sBuffer.size ()  <  nSizeLimit)
        return true;
    PyErr_SetString(PyExc_SystemError, "Reached the buffer size limit");
    return false;
}