From 5d775d64bdec554b9842823bd1c46263210425fd Mon Sep 17 00:00:00 2001 From: Vasilii Chernov Date: Tue, 1 Mar 2016 10:42:40 +0100 Subject: 1. multithreading: - Enable multiprocessing for api_server - Enable mutrithreading for html_server 2. py: - extract pcilib->py bases from pcilib->py functions - add api for interact directly with pcilib->py without pcilib context. 3. pcipywrap - Add scripts handling. --- CMakeLists.txt | 4 +- html_server/html_server.py | 3 +- html_server/templates/base.html | 2 +- pcilib/locking.c | 207 ++++++++------- pcilib/property.c | 4 +- pcilib/py.c | 309 ++++++++++++++++------- pcilib/py.h | 26 ++ pywrap/CMakeLists.txt | 2 +- pywrap/api_server.py | 516 ++++++++++++++++++++++++++++++++++++++ pywrap/pcipywrap.c | 333 +++++++++++++++---------- pywrap/pcipywrap.h | 15 ++ pywrap/pcipywrap.i | 3 + pywrap/server.py | 539 ---------------------------------------- run | 6 +- xml/scripts/test_script.py | 4 + xml/scripts/test_script2.py | 4 + xml/test/test_prop_mt.py | 6 +- 17 files changed, 1119 insertions(+), 864 deletions(-) create mode 100644 pywrap/api_server.py delete mode 100644 pywrap/server.py create mode 100644 xml/scripts/test_script.py create mode 100644 xml/scripts/test_script2.py diff --git a/CMakeLists.txt b/CMakeLists.txt index dfbd50a..4445af7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,7 +38,7 @@ find_package(PkgConfig REQUIRED) find_package(Threads REQUIRED) if (NOT DISABLE_PYTHON) - find_package(PythonLibs 2.7 REQUIRED) + find_package(PythonLibs 2 REQUIRED) find_package(SWIG REQUIRED) set(HAVE_PYTHON TRUE) include(FindPythonInterp) @@ -123,6 +123,8 @@ if (NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR) DESTINATION ${CMAKE_BINARY_DIR} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE ) + + configure_file(${CMAKE_SOURCE_DIR}/pcilib/version.h.in ${CMAKE_SOURCE_DIR}/pcilib/version.h) endif(NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR) install(FILES diff --git a/html_server/html_server.py b/html_server/html_server.py index dba24e9..0d4bca8 100644 --- a/html_server/html_server.py +++ b/html_server/html_server.py @@ -137,7 +137,6 @@ def get_registers_list(): value = dict() for reg in reg_list: - print reg try: value[reg['name']] = pcilib.read_register(str(reg['name']), str(reg['bank'])) @@ -212,4 +211,4 @@ if __name__ == "__main__": pcilib = pcipywrap.Pcipywrap(device, model) pcipywrap.__redirect_logs_to_exeption() - app.run(host = HOST_NAME, port = PORT_NUMBER) + app.run(host = HOST_NAME, port = PORT_NUMBER, threaded=True) diff --git a/html_server/templates/base.html b/html_server/templates/base.html index 39f8d00..0e3aea8 100644 --- a/html_server/templates/base.html +++ b/html_server/templates/base.html @@ -187,7 +187,7 @@ } .infoTable { - padding: 5px; + padding: 2px; border: 1px solid #aaa; line-height: 28px; diff --git a/pcilib/locking.c b/pcilib/locking.c index 71f204e..28aa4c4 100644 --- a/pcilib/locking.c +++ b/pcilib/locking.c @@ -102,118 +102,117 @@ pcilib_lock_t *pcilib_get_lock_by_id(pcilib_t *ctx, pcilib_lock_id_t id) { } pcilib_lock_t *pcilib_get_lock(pcilib_t *ctx, pcilib_lock_flags_t flags, const char *lock_id, ...) { - pcilib_lock_id_t i; - int err, ret; - - pcilib_lock_t *lock; - char buffer[PCILIB_LOCK_SIZE]; - - /* we construct the complete lock_id given the parameters of the function*/ - va_list pa; - va_start(pa, lock_id); - ret = vsnprintf(buffer, PCILIB_LOCK_SIZE, lock_id, pa); - va_end(pa); - - if (ret < 0) { - pcilib_error("Failed to construct the lock id, probably arguments does not match the format string (%s)...", lock_id); - return NULL; - } - - - /* we iterate through locks to see if there is one already with the same name*/ - // Would be nice to have hash here - for (i = 0; i < PCILIB_MAX_LOCKS; i++) { - lock = pcilib_get_lock_by_id(ctx, i); - - const char *name = pcilib_lock_get_name(lock); - if (!name) break; - - if (!strcmp(buffer, name)) { - if ((pcilib_lock_get_flags(lock)&PCILIB_LOCK_FLAG_PERSISTENT) != (flags&PCILIB_LOCK_FLAG_PERSISTENT)) { - if (flags&PCILIB_LOCK_FLAG_PERSISTENT) - pcilib_error("Requesting persistent lock (%s), but requested lock is already existing and is robust", name); - else - pcilib_error("Requesting robust lock (%s), but requested lock is already existing and is persistent", name); - return NULL; - } - -#ifndef HAVE_STDATOMIC_H - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) { - err = pcilib_lock(ctx->locks.locking); - if (err) { - pcilib_error("Error (%i) obtaining global lock", err); - return NULL; - } - } -#endif /* ! HAVE_STDATOMIC_H */ - /* if yes, we increment its ref variable*/ - pcilib_lock_ref(lock); -#ifndef HAVE_STDATOMIC_H - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) - pcilib_unlock(ctx->locks.locking); -#endif /* ! HAVE_STDATOMIC_H */ - - return lock; - } - } + pcilib_lock_id_t i; + int err, ret; - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) { - err = pcilib_lock(ctx->locks.locking); - if (err) { - pcilib_error("Error (%i) obtaining global lock", err); - return NULL; - } - } + pcilib_lock_t *lock; + char buffer[PCILIB_LOCK_SIZE]; - // Make sure it was not allocated meanwhile - for (; i < PCILIB_MAX_LOCKS; i++) { - lock = pcilib_get_lock_by_id(ctx, i); - - const char *name = pcilib_lock_get_name(lock); - if (!name) break; + /* we construct the complete lock_id given the parameters of the function*/ + va_list pa; + va_start(pa, lock_id); + ret = vsnprintf(buffer, PCILIB_LOCK_SIZE, lock_id, pa); + va_end(pa); - if (!strcmp(buffer, name)) { - if ((pcilib_lock_get_flags(lock)&PCILIB_LOCK_FLAG_PERSISTENT) != (flags&PCILIB_LOCK_FLAG_PERSISTENT)) { - if (flags&PCILIB_LOCK_FLAG_PERSISTENT) - pcilib_error("Requesting persistent lock (%s), but requested lock is already existing and is robust", name); - else - pcilib_error("Requesting robust lock (%s), but requested lock is already existing and is persistent", name); - - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) - pcilib_unlock(ctx->locks.locking); - return NULL; - } + if (ret < 0) { + pcilib_error("Failed to construct the lock id, probably arguments does not match the format string (%s)...", lock_id); + return NULL; + } - pcilib_lock_ref(lock); - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) - pcilib_unlock(ctx->locks.locking); - return lock; - } - } - if (i == PCILIB_MAX_LOCKS) { - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) - pcilib_unlock(ctx->locks.locking); - pcilib_error("Failed to create lock (%s), only %u locks is supported", buffer, PCILIB_MAX_LOCKS); - return NULL; - } + /* we iterate through locks to see if there is one already with the same name*/ + // Would be nice to have hash here + for (i = 0; i < PCILIB_MAX_LOCKS; i++) { + lock = pcilib_get_lock_by_id(ctx, i); - /* if the lock did not exist before, then we create it*/ - err = pcilib_init_lock(lock, flags, buffer); - - if (err) { - pcilib_error("Lock initialization failed with error %i", err); + const char *name = pcilib_lock_get_name(lock); + if (!name) break; - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) - pcilib_unlock(ctx->locks.locking); - - return NULL; - } - - if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) - pcilib_unlock(ctx->locks.locking); + if (!strcmp(buffer, name)) { + if ((pcilib_lock_get_flags(lock)&PCILIB_LOCK_FLAG_PERSISTENT) != (flags&PCILIB_LOCK_FLAG_PERSISTENT)) { + if (flags&PCILIB_LOCK_FLAG_PERSISTENT) + pcilib_error("Requesting persistent lock (%s), but requested lock is already existing and is robust", name); + else + pcilib_error("Requesting robust lock (%s), but requested lock is already existing and is persistent", name); + return NULL; + } - return lock; +#ifndef HAVE_STDATOMIC_H + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) { + err = pcilib_lock(ctx->locks.locking); + if (err) { + pcilib_error("Error (%i) obtaining global lock", err); + return NULL; + } + } +#endif /* ! HAVE_STDATOMIC_H */ + /* if yes, we increment its ref variable*/ + pcilib_lock_ref(lock); + #ifndef HAVE_STDATOMIC_H + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) + pcilib_unlock(ctx->locks.locking); + #endif /* ! HAVE_STDATOMIC_H */ + return lock; + } + } + + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) { + err = pcilib_lock(ctx->locks.locking); + if (err) { + pcilib_error("Error (%i) obtaining global lock", err); + return NULL; + } + } + + // Make sure it was not allocated meanwhile + for (; i < PCILIB_MAX_LOCKS; i++) { + lock = pcilib_get_lock_by_id(ctx, i); + + const char *name = pcilib_lock_get_name(lock); + if (!name) break; + + if (!strcmp(buffer, name)) { + if ((pcilib_lock_get_flags(lock)&PCILIB_LOCK_FLAG_PERSISTENT) != (flags&PCILIB_LOCK_FLAG_PERSISTENT)) { + if (flags&PCILIB_LOCK_FLAG_PERSISTENT) + pcilib_error("Requesting persistent lock (%s), but requested lock is already existing and is robust", name); + else + pcilib_error("Requesting robust lock (%s), but requested lock is already existing and is persistent", name); + + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) + pcilib_unlock(ctx->locks.locking); + return NULL; + } + + pcilib_lock_ref(lock); + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) + pcilib_unlock(ctx->locks.locking); + return lock; + } + } + + if (i == PCILIB_MAX_LOCKS) { + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) + pcilib_unlock(ctx->locks.locking); + pcilib_error("Failed to create lock (%s), only %u locks is supported", buffer, PCILIB_MAX_LOCKS); + return NULL; + } + + /* if the lock did not exist before, then we create it*/ + err = pcilib_init_lock(lock, flags, buffer); + + if (err) { + pcilib_error("Lock initialization failed with error %i", err); + + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) + pcilib_unlock(ctx->locks.locking); + + return NULL; + } + + if ((flags&PCILIB_LOCK_FLAG_UNLOCKED)==0) + pcilib_unlock(ctx->locks.locking); + + return lock; } void pcilib_return_lock(pcilib_t *ctx, pcilib_lock_flags_t flags, pcilib_lock_t *lock) { diff --git a/pcilib/property.c b/pcilib/property.c index dfab9a6..1dba1be 100644 --- a/pcilib/property.c +++ b/pcilib/property.c @@ -226,8 +226,8 @@ pcilib_property_info_t *pcilib_get_property_list(pcilib_t *ctx, const char *bran } HASH_ITER(hh, dir_hash, dir, dir_tmp) { - HASH_DEL(dir_hash, dir); - free(dir); + HASH_DEL(dir_hash, dir); + free(dir); } HASH_CLEAR(hh, dir_hash); diff --git a/pcilib/py.c b/pcilib/py.c index 6cf9fdc..934c11f 100644 --- a/pcilib/py.c +++ b/pcilib/py.c @@ -89,8 +89,6 @@ void pcilib_log_python_error(const char *file, int line, pcilib_log_flags_t flag #endif /* HAVE_PYTHON */ } - - int pcilib_init_py(pcilib_t *ctx) { #ifdef HAVE_PYTHON ctx->py = (pcilib_py_t*)malloc(sizeof(pcilib_py_t)); @@ -143,8 +141,6 @@ int pcilib_init_py(pcilib_t *ctx) { int pcilib_py_add_script_dir(pcilib_t *ctx, const char *dir) { #ifdef HAVE_PYTHON int err = 0; - PyObject *pypath, *pynewdir; - PyObject *pydict, *pystr, *pyret = NULL; char *script_dir; const char *model_dir = getenv("PCILIB_MODEL_DIR"); @@ -160,83 +156,59 @@ int pcilib_py_add_script_dir(pcilib_t *ctx, const char *dir) { sprintf(script_dir, "%s/%s", model_dir, dir); } - pypath = PySys_GetObject("path"); - if (!pypath) { - pcilib_python_error("Can't get python path"); - return PCILIB_ERROR_FAILED; - } + err = pcilib_py_ctx_add_script_dir(ctx->py, script_dir); + if(err) return err; +#endif /* HAVE_PYTHON */ - pynewdir = PyString_FromString(script_dir); - if (!pynewdir) { - pcilib_python_error("Can't create python string"); - return PCILIB_ERROR_MEMORY; + return 0; +} + +void pcilib_py_free_hash(pcilib_py_t *ctx_py) { + if (ctx_py->script_hash) { + pcilib_script_t *script, *script_tmp; + + HASH_ITER(hh, ctx_py->script_hash, script, script_tmp) { + Py_DECREF(script->module); + HASH_DEL(ctx_py->script_hash, script); + free(script); + } + ctx_py->script_hash = NULL; } - - // Checking if the directory already in the path - pydict = PyDict_New(); - if (pydict) { - pystr = PyString_FromString("cur"); - if (pystr) { - PyDict_SetItem(pydict, pystr, pynewdir); - Py_DECREF(pystr); - } +} - pystr = PyString_FromString("path"); - if (pystr) { - PyDict_SetItem(pydict, pystr, pypath); - Py_DECREF(pystr); - } +void pcilib_free_py_ctx(pcilib_py_t *ctx_py) { +#ifdef HAVE_PYTHON + int finalyze = 0; - pyret = PyRun_String("cur in path", Py_eval_input, ctx->py->global_dict, pydict); - Py_DECREF(pydict); - } + if (ctx_py) { + if (ctx_py->finalyze) finalyze = 1; - if ((pyret == Py_False)&&(PyList_Append(pypath, pynewdir) == -1)) - err = PCILIB_ERROR_FAILED; + pcilib_py_free_hash(ctx_py); - if (pyret) Py_DECREF(pyret); - Py_DECREF(pynewdir); + if (ctx_py->pcilib_pywrap) + Py_DECREF(ctx_py->pcilib_pywrap); - if (err) { - pcilib_python_error("Can't add directory (%s) to python path", script_dir); - return err; - } -#endif /* HAVE_PYTHON */ + free(ctx_py); + } - return 0; + if (finalyze) + Py_Finalize(); +#endif /* HAVE_PYTHON */ } + void pcilib_free_py(pcilib_t *ctx) { #ifdef HAVE_PYTHON - int finalyze = 0; - - if (ctx->py) { - if (ctx->py->finalyze) finalyze = 1; - - if (ctx->py->script_hash) { - pcilib_script_t *script, *script_tmp; - - HASH_ITER(hh, ctx->py->script_hash, script, script_tmp) { - Py_DECREF(script->module); - HASH_DEL(ctx->py->script_hash, script); - free(script); - } - ctx->py->script_hash = NULL; - } - - if (ctx->py->pcilib_pywrap) - Py_DECREF(ctx->py->pcilib_pywrap); - - free(ctx->py); - ctx->py = NULL; - } - - if (finalyze) - Py_Finalize(); + pcilib_free_py_ctx(ctx->py); + ctx->py = NULL; #endif /* HAVE_PYTHON */ } int pcilib_py_load_script(pcilib_t *ctx, const char *script_name) { + return pcilib_py_ctx_load_script(ctx->py, script_name); +} + +int pcilib_py_ctx_load_script(pcilib_py_t *ctx_py, const char *script_name) { #ifdef HAVE_PYTHON PyObject* pymodule; pcilib_script_t *module = NULL; @@ -252,7 +224,7 @@ int pcilib_py_load_script(pcilib_t *ctx, const char *script_name) { } *py = 0; - HASH_FIND_STR(ctx->py->script_hash, script_name, module); + HASH_FIND_STR(ctx_py->script_hash, script_name, module); if (module) return 0; pymodule = PyImport_ImportModule(module_name); @@ -266,7 +238,7 @@ int pcilib_py_load_script(pcilib_t *ctx, const char *script_name) { module->module = pymodule; module->name = script_name; - HASH_ADD_KEYPTR(hh, ctx->py->script_hash, module->name, strlen(module->name), module); + HASH_ADD_STR(ctx_py->script_hash, name, module); #endif /* HAVE_PYTHON */ return 0; } @@ -527,51 +499,218 @@ int pcilib_py_eval_string(pcilib_t *ctx, const char *codestr, pcilib_value_t *va int pcilib_py_eval_func(pcilib_t *ctx, const char *script_name, const char *func_name, pcilib_value_t *val) { #ifdef HAVE_PYTHON int err = 0; + PyObject *pyval = NULL; + + if (val) { + pyval = pcilib_get_value_as_pyobject(ctx, val, &err); + if (err) return err; + } + + PyObject* pyret = pcilib_py_ctx_eval_func(ctx->py, script_name, + func_name, pyval, &err); + if (err) return err; + + if ((val)&&(pyret != Py_None)) + err = pcilib_set_value_from_pyobject(ctx, val, pyret); + + Py_DECREF(pyret); + + return err; +#else /* HAVE_PYTHON */ + pcilib_error("Python is not supported"); + return PCILIB_ERROR_NOTSUPPORTED; +#endif /* HAVE_PYTHON */ +} + +pcilib_py_object* pcilib_py_ctx_eval_func(pcilib_py_t *ctx_py, + const char *script_name, + const char *func_name, + pcilib_py_object *pyval, + int *err) { +#ifdef HAVE_PYTHON PyObject *pyfunc; - PyObject *pyval = NULL, *pyret; + PyObject *pyret; pcilib_script_t *module = NULL; - HASH_FIND_STR(ctx->py->script_hash, script_name, module); + HASH_FIND_STR(ctx_py->script_hash, script_name, module); if (!module) { pcilib_error("Script (%s) is not loaded", script_name); - return PCILIB_ERROR_NOTFOUND; - } - - if (val) { - pyval = pcilib_get_value_as_pyobject(ctx, val, &err); - if (err) return err; + if(err) *err = PCILIB_ERROR_NOTFOUND; + return NULL; } - + PyGILState_STATE gstate = PyGILState_Ensure(); pyfunc = PyUnicode_FromString(func_name); if (!pyfunc) { if (pyval) Py_DECREF(pyval); PyGILState_Release(gstate); - return PCILIB_ERROR_MEMORY; + if(err) *err = PCILIB_ERROR_MEMORY; + return NULL; } - pyret = PyObject_CallMethodObjArgs(module->module, pyfunc, ctx->py->pcilib_pywrap, pyval, NULL); + pyret = PyObject_CallMethodObjArgs(module->module, + pyfunc, + ctx_py->pcilib_pywrap, + pyval, + NULL); Py_DECREF(pyfunc); Py_DECREF(pyval); - + if (!pyret) { PyGILState_Release(gstate); - pcilib_python_error("Error executing function (%s) of python script (%s)", func_name, script_name); + pcilib_python_error("Error executing function (%s) of python " + "script (%s)", func_name, script_name); + if(err) *err = PCILIB_ERROR_FAILED; + return NULL; + } + PyGILState_Release(gstate); + + return pyret; + +#else /* HAVE_PYTHON */ + pcilib_error("Python is not supported"); + if(err) *err = PCILIB_ERROR_NOTSUPPORTED; + return NULL; +#endif /* HAVE_PYTHON */ +} + +int pcilib_py_ctx_add_script_dir(pcilib_py_t *ctx_py, const char *dir) { +#ifdef HAVE_PYTHON + int err = 0; + PyObject *pypath, *pynewdir; + PyObject *pydict, *pystr, *pyret = NULL; + + //const char *model_dir = getenv("PCILIB_MODEL_DIR"); + //if (!model_dir) model_dir = PCILIB_MODEL_DIR; + + pypath = PySys_GetObject("path"); + if (!pypath) { + pcilib_python_error("Can't get python path"); return PCILIB_ERROR_FAILED; } - if ((val)&&(pyret != Py_None)) - err = pcilib_set_value_from_pyobject(ctx, val, pyret); + pynewdir = PyString_FromString(dir); + if (!pynewdir) { + pcilib_python_error("Can't create python string"); + return PCILIB_ERROR_MEMORY; + } - Py_DECREF(pyret); - PyGILState_Release(gstate); + // Checking if the directory already in the path + pydict = PyDict_New(); + if (pydict) { + pystr = PyString_FromString("cur"); + if (pystr) { + PyDict_SetItem(pydict, pystr, pynewdir); + Py_DECREF(pystr); + } else { + pcilib_python_error("Can't create python string"); + return PCILIB_ERROR_MEMORY; + } - return err; + pystr = PyString_FromString("path"); + if (pystr) { + PyDict_SetItem(pydict, pystr, pypath); + Py_DECREF(pystr); + } else { + pcilib_python_error("Can't create python string"); + return PCILIB_ERROR_MEMORY; + } + + pyret = PyRun_String("cur in path", Py_eval_input, ctx_py->global_dict, pydict); + Py_DECREF(pydict); + + } else { + pcilib_python_error("Can't create python dict"); + return PCILIB_ERROR_MEMORY; + } + + if ((pyret == Py_False)&&(PyList_Append(pypath, pynewdir) == -1)) + err = PCILIB_ERROR_FAILED; + + if (pyret) Py_DECREF(pyret); + Py_DECREF(pynewdir); + + if (err) { + pcilib_python_error("Can't add directory (%s) to python path", dir); + return err; + } + return 0; #else /* HAVE_PYTHON */ pcilib_error("Python is not supported"); return PCILIB_ERROR_NOTSUPPORTED; #endif /* HAVE_PYTHON */ } + +pcilib_py_t* pcilib_init_py_ctx(pcilib_py_t* in, int *err) { + pcilib_py_t* out = (pcilib_py_t*)malloc(sizeof(pcilib_py_t)); + if (!out) { + if(err) *err = PCILIB_ERROR_MEMORY; + return NULL; + } + + out->finalyze = 0; + out->main_module = in->main_module; + out->global_dict = in->global_dict; + out->pcilib_pywrap = in->pcilib_pywrap; + out->script_hash = NULL; + + if(err) *err = 0; + return out; +} + +/*! + * \brief Wrap for PyDict_SetItem, with decrease reference counting after set. + */ +void pcilib_pydict_set_item(pcilib_py_object* dict, pcilib_py_object* name, pcilib_py_object* value) +{ + PyDict_SetItem(dict, + name, + value); + Py_XDECREF(name); + Py_XDECREF(value); +} + +/*! + * \brief Wrap for PyList_Append, with decrease reference counting after append. + */ +void pcilib_pylist_append(pcilib_py_object* list, pcilib_py_object* value) +{ + PyList_Append(list, value); + Py_XDECREF(value); +} + +pcilib_py_object *pcilib_py_ctx_get_scripts_info(pcilib_py_t *ctx_py) { + + PyObject* pyList = PyList_New(0); + + if (ctx_py->script_hash) { + pcilib_script_t *script, *script_tmp; + + HASH_ITER(hh, ctx_py->script_hash, script, script_tmp) { + + PyObject* pylistItem = PyDict_New(); + pcilib_pydict_set_item(pylistItem, + PyString_FromString("name"), + PyString_FromString(script->name)); + + PyObject* dict = PyModule_GetDict(script->module); + if (dict) { + PyObject* pystr = PyString_FromString("description"); + if (pystr) { + if (PyDict_Contains(dict, pystr)) { + PyDict_SetItem(pylistItem, + pystr, + PyDict_GetItem(dict, pystr)); + } + Py_DECREF(pystr); + } + } + pcilib_pylist_append(pyList, pylistItem); + + } + } + return pyList; +} diff --git a/pcilib/py.h b/pcilib/py.h index c372a09..549eddf 100644 --- a/pcilib/py.h +++ b/pcilib/py.h @@ -118,6 +118,32 @@ int pcilib_py_eval_string(pcilib_t *ctx, const char *codestr, pcilib_value_t *va */ int pcilib_py_eval_func(pcilib_t *ctx, const char *script, const char *func, pcilib_value_t *val); + +/** Clone pcilib_py_t content without scripts hash + * @param[in] in - pcilib_py_t content to clone + * @param[out] err - error + * @return - NULL or cloned pcilib_py_t content pointer on success + */ +pcilib_py_t* pcilib_init_py_ctx(pcilib_py_t* in, int *err); +pcilib_py_object* pcilib_py_ctx_eval_func(pcilib_py_t *ctx_py, + const char *script_name, + const char *func_name, + pcilib_py_object *pyval, + int *err); +int pcilib_py_ctx_add_script_dir(pcilib_py_t *ctx_py, const char *dir); +void pcilib_free_py_ctx(pcilib_py_t *ctx_py); +int pcilib_py_ctx_load_script(pcilib_py_t *ctx_py, const char *script_name); +pcilib_py_object *pcilib_py_ctx_get_scripts_info(pcilib_py_t *ctx_py); + +/*! + * \brief Wrap for PyDict_SetItem, with decrease reference counting after set. + */ +void pcilib_pydict_set_item(pcilib_py_object* dict, pcilib_py_object* name, pcilib_py_object* value); + +/*! + * \brief Wrap for PyList_Append, with decrease reference counting after append. + */ +void pcilib_pylist_append(pcilib_py_object* list, pcilib_py_object* value); #ifdef __cplusplus } #endif diff --git a/pywrap/CMakeLists.txt b/pywrap/CMakeLists.txt index b00fdb0..4f38354 100644 --- a/pywrap/CMakeLists.txt +++ b/pywrap/CMakeLists.txt @@ -25,6 +25,6 @@ install(TARGETS ${SWIG_MODULE_pcipywrap_REAL_NAME} DESTINATION ${PYTHON_SITE_PAC install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pcipywrap.py DESTINATION ${PYTHON_SITE_PACKAGES}) if (NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR) - file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/server.py DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) + file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/api_server.py DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test_pcipywrap.py DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) endif(NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR) diff --git a/pywrap/api_server.py b/pywrap/api_server.py new file mode 100644 index 0000000..da3a275 --- /dev/null +++ b/pywrap/api_server.py @@ -0,0 +1,516 @@ +import os +import sys + +import pcipywrap + +import time +import json +from optparse import OptionParser + +from multiprocessing import Process, current_process +from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler + +class PcilibServerHandler(BaseHTTPRequestHandler): + + def __init__(s, pcilib, *args): + s.pcilib = pcilib + BaseHTTPRequestHandler.__init__(s, *args) + + def do_HEAD(s): + s.send_response(200) + s.send_header('content-type', 'application/json') + s.end_headers() + + def do_GET(s): + length = int(s.headers['Content-Length']) + + #deserialize input data + data = json.loads(s.rfile.read(length).decode('utf-8')) + + if 'command' in data: + command = data['command'] + if(command == 'help'): + s.help(data) + + + + #elif(command == 'open'): + # #check required arguments + # if not 'device' in data: + # s.error('message doesnt contains "device" field, ' + # 'which is required for "open" command', data) + # return + # #parse command arguments and convert them to string + # device = str(data.get('device', None)) + # model = data.get('model', None) + # if not model is None: + # model = str(model) + # + # try: + # s.openPcilibInstance(device, model) + # except Exception as e: + # s.error(str(e), data) + # return + # + # #Success! Create and send reply + # out = dict() + # out['status'] = 'ok' + # s.wrapMessageAndSend(out, data) + + + + elif(command == 'get_registers_list'): + #parse command arguments and convert them to string + bank = data.get('bank', None) + if not bank is None: + bank = str(bank) + + registers = dict() + try: + registers = s.pcilib.get_registers_list(bank) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + out = dict() + out['status'] = 'ok' + out['registers'] = registers + s.wrapMessageAndSend(out, data) + + + + elif(command == 'get_register_info'): + #check required arguments + if not 'reg' in data: + s.error('message doesnt contains "reg" field, ' + 'which is required for "get_register_info" command', data) + return + + #parse command arguments and convert them to string + reg = str(data.get('reg', None)) + bank = data.get('bank', None) + if not bank is None: + bank = str(bank) + + register = dict() + try: + register = s.pcilib.get_register_info(reg, bank) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + s.wrapMessageAndSend({'status': 'ok', 'register': register}, data) + + + + elif(command == 'get_property_list'): + #parse command arguments and convert them to string + branch = data.get('branch', None) + if not branch is None: + branch = str(branch) + + properties = dict() + try: + properties = s.pcilib.get_property_list(branch) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + out = dict() + out['status'] = 'ok' + out['properties'] = properties + s.wrapMessageAndSend(out, data) + + + + elif(command == 'read_register'): + #check required arguments + if not 'reg' in data: + s.error('message doesnt contains "reg" field, ' + 'which is required for "read_register" command', data) + return + + #parse command arguments and convert them to string + reg = str(data.get('reg', None)) + bank = data.get('bank', None) + if not bank is None: + bank = str(bank) + + value = 0 + try: + value = s.pcilib.read_register(reg, bank) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + out = dict() + out['status'] = 'ok' + out['value'] = value + s.wrapMessageAndSend(out, data) + + + + elif(command == 'write_register'): + #check required arguments + if not 'reg' in data: + s.error('message doesnt contains "reg" field, ' + 'which is required for "write_register" command', data) + return + + if not 'value' in data: + s.error('message doesnt contains "value" field, ' + 'which is required for "write_register" command', data) + return + + #parse command arguments and convert them to string + reg = str(data.get('reg', None)) + value = str(data.get('value', None)) + bank = data.get('bank', None) + if not bank is None: + bank = str(bank) + + try: + s.pcilib.write_register(value, reg, bank) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + s.wrapMessageAndSend({'status': 'ok'}, data) + + + + elif(command == 'get_property'): + #check required arguments + if not 'prop' in data: + s.error('message doesnt contains "prop" field, ' + 'which is required for "get_property" command', data) + return + + #parse command arguments and convert them to string + prop = str(data.get('prop', None)) + + value = 0 + try: + value = s.pcilib.get_property(prop) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + out = dict() + out['status'] = 'ok' + out['value'] = value + s.wrapMessageAndSend(out, data) + + + + elif(command == 'set_property'): + #check required arguments + if not 'prop' in data: + s.error('message doesnt contains "prop" field, ' + 'which is required for "set_property" command', data) + return + + if not 'value' in data: + s.error('message doesnt contains "value" field, ' + 'which is required for "set_property" command', data) + return + + #parse command arguments and convert them to string + prop = str(data.get('prop', None)) + value = str(data.get('value', None)) + + try: + s.pcilib.set_property(value, prop) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + s.wrapMessageAndSend({'status': 'ok'}, data) + + + + elif(command == 'lock'): + #check required arguments + if not 'lock_id' in data: + s.error('message doesnt contains "lock_id" field, ' + 'which is required for "lock" command', data) + return + + #parse command arguments and convert them to string + lock_id = str(data.get('lock_id')) + + try: + s.pcilib.lock(lock_id) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + s.wrapMessageAndSend({'status': 'ok'}, data) + + + + elif(command == 'try_lock'): + #check required arguments + if not 'lock_id' in data: + s.error('message doesnt contains "lock_id" field, ' + 'which is required for "try_lock" command', data) + return + + #parse command arguments and convert them to string + lock_id = str(data.get('lock_id')) + + try: + s.pcilib.try_lock(lock_id) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + s.wrapMessageAndSend({'status': 'ok'}, data) + + + + elif(command == 'unlock'): + #check required arguments + if not 'lock_id' in data: + s.error('message doesnt contains "lock_id" field, ' + 'which is required for "unlock" command', data) + return + + #parse command arguments and convert them to string + lock_id = str(data.get('lock_id')) + + try: + print 'unlocking ' + lock_id + s.pcilib.unlock(lock_id) + except Exception as e: + s.error(str(e), data) + return + + #Success! Create and send reply + s.wrapMessageAndSend({'status': 'ok'}, data) + + + + #elif(command == 'lock_global'): + # #check if global_lock already setted by server + # try: + # s.pcilib.lock_global() + # except Exception as e: + # s.error(str(e), data) + # return + # + # #Success! Create and send reply + # s.wrapMessageAndSend({'status': 'ok'}, data) + + + + #elif(command == 'unlock_global'): + # try: + # s.pcilib.unlock_global() + # except Exception as e: + # s.error(str(e), data) + # return + # + # #Success! Create and send reply + # s.wrapMessageAndSend({'status': 'ok'}, data) + + + + else: + s.error('command "' + command + '" undefined', data) + return + else: + s.error('message doesnt contains "command" field, which is required', data) + return + + + #print str(s.headers['content-type']) + #print post_data['some'] + + #open device context + #def openPcilibInstance(s, device, model): + # s.pcilib = pcipywrap.create_pcilib_instance(device, model) + + #Send help message + def help(s, received_message = None): + usage = str('Usage:\n' + ' Server receive commands via http GET with json packet.\n' + ' content-type should have value "application/json"\n' + ' Server could handle only commands. to set command, you\n' + ' should specify field "command" in packet with command name\n' + ' List of commands:\n' + '\n' + ' command: help - Get help. This will return usage\n' + '\n' + + ' command: open - Opens context of device. It will be reopened if already open.\n' + ' required fields\n' + ' device: - path to the device file [/dev/fpga0]\n' + ' optional fields\n' + ' model: - specifies the model of hardware, autodetected if doesnt exists\n' + '\n' + + ' command: get_registers_list - Returns the list of registers provided by the hardware model.\n' + ' optional fields\n' + ' bank: - if set, only register within the specified bank will be returned\n' + '\n' + + ' command: get_register_info - Returns the information about the specified register.\n' + ' required fields\n' + ' reg: - the name of the register\n' + ' optional fields\n' + ' bank: - if set, only register within the specified bank will be returned\n' + '\n' + + ' command: get_property_list - Returns the list of properties available under the specified path.\n' + ' optional fields\n' + ' branch: - Path. If not set, will return the top-level properties\n' + '\n' + + ' command: read_register - Reads the specified register.\n' + ' required fields\n' + ' reg: - the name of the register\n' + ' optional fields\n' + ' bank: - if set, only register within the specified bank will be processed\n' + '\n' + + ' command: write_register - Writes to specified register.\n' + ' required fields\n' + ' reg: - the name of the register\n' + ' value: - the register value to write. Should be int, float or string (with number)\n' + ' optional fields\n' + ' bank: - if set, only register within the specified bank will be processed\n' + '\n' + + ' command: get_property - Reads / computes the property value.\n' + ' required fields\n' + ' prop: - full name including path\n' + '\n' + + ' command: set_property - Writes the property value or executes the code associated with property.\n' + ' required fields\n' + ' prop: - full name including path\n' + ' value: - the property value to write. Should be int, float or string (with number)\n' + '\n' + + ' command: lock - function to acquire a lock, and wait till the lock can be acquire.\n' + ' required fields\n' + ' lock_id: - lock id\n' + '\n' + + ' command: try_lock - this function will try to take a lock for the mutex pointed by \n' + ' lockfunction to acquire a lock, but that returns immediatly if the\n' + ' lock can\'t be acquired on first try\n' + ' lock_id: - lock id\n' + '\n' + + ' command: unlock - this function unlocks the lock.\n' + ' required fields\n' + ' lock_id: - lock id\n' + '\n' + + '\n') + out = {'status': 'ok', 'usage' : usage} + s.wrapMessageAndSend(out, received_message) + + #Send error message with text description + def error(s, info, received_message = None): + out = dict() + + out['status'] = 'error' + out['description'] = info + out['note'] = 'send {"command" : "help"} to get help' + s.wrapMessageAndSend(out, received_message, 400) + + def wrapMessageAndSend(s, message, received_message = None, response = 200): + s.send_response(response) + s.send_header('content-type', 'application/json') + s.end_headers() + if not received_message is None: + message['received_message'] = received_message + s.wfile.write(json.dumps(message)) + +def serve_forever(server): + try: + server.serve_forever() + except KeyboardInterrupt: + pass + +def runpool(server, number_of_processes): + # create child processes to act as workers + for i in range(number_of_processes-1): + Process(target=serve_forever, args=(server,)).start() + + # main process also acts as a worker + serve_forever(server) + +if __name__ == '__main__': + + #parce command line options + parser = OptionParser() + parser.add_option("-p", "--port", action="store", + type="int", dest="port", default=9000, + help="Set server port (9000)") + parser.add_option("-d", "--device", action="store", + type="string", dest="device", default=str('/dev/fpga0'), + help="FPGA device (/dev/fpga0)") + parser.add_option("-m", "--model", action="store", + type="string", dest="model", default=None, + help="Memory model (autodetected)") + parser.add_option("-n", "--number_processes", action="store", + type="int", dest="processes", default=4, + help="Number of processes, used by server (4)") + opts = parser.parse_args()[0] + + HOST_NAME = '' + PORT_NUMBER = opts.port + MODEL = opts.model + DEVICE = opts.device + + + + #Set enviroment variables, if it not setted already + if not 'APP_PATH' in os.environ: + APP_PATH = '' + file_dir = os.path.dirname(os.path.abspath(__file__)) + APP_PATH = str(os.path.abspath(file_dir + '/../..')) + os.environ["APP_PATH"] = APP_PATH + + if not 'PCILIB_MODEL_DIR' in os.environ: + os.environ['PCILIB_MODEL_DIR'] = os.environ["APP_PATH"] + "/xml" + + if not 'LD_LIBRARY_PATH' in os.environ: + os.environ['LD_LIBRARY_PATH'] = os.environ["APP_PATH"] + "/pcilib" + + + + #redirect logs to exeption + pcipywrap.__redirect_logs_to_exeption() + + #pass Pcipywrap to to server handler + global pcilib + lib = pcipywrap.Pcipywrap(DEVICE, MODEL) + def handler(*args): + PcilibServerHandler(lib, *args) + + #start server + httpd = HTTPServer((HOST_NAME, PORT_NUMBER), handler) + runpool(httpd, opts.processes) + + print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, PORT_NUMBER) + #try: + # httpd.serve_forever() + #except KeyboardInterrupt: + # pass + + httpd.server_close() + print time.asctime(), "Server Stops - %s:%s" % (HOST_NAME, PORT_NUMBER) diff --git a/pywrap/pcipywrap.c b/pywrap/pcipywrap.c index 391bdf4..cfb4e53 100644 --- a/pywrap/pcipywrap.c +++ b/pywrap/pcipywrap.c @@ -1,6 +1,9 @@ #include "pcipywrap.h" #include "locking.h" +#include +#include + char* full_log = NULL; /*! @@ -101,27 +104,6 @@ void __redirect_logs_to_exeption() pcilib_get_logger_context()); } -/*! - * \brief Wrap for PyDict_SetItem, with decrease reference counting after set. - */ -void pcilib_pydict_set_item(PyObject* dict, PyObject* name, PyObject* value) -{ - PyDict_SetItem(dict, - name, - value); - Py_XDECREF(name); - Py_XDECREF(value); -} - -/*! - * \brief Wrap for PyList_Append, with decrease reference counting after append. - */ -void pcilib_pylist_append(PyObject* list, PyObject* value) -{ - PyList_Append(list, value); - Py_XDECREF(value); -} - void add_pcilib_value_to_dict(pcilib_t* ctx, PyObject* dict, pcilib_value_t* val, const char *name) { PyObject *py_val = (PyObject*)pcilib_get_value_as_pyobject(ctx, val, NULL); @@ -215,126 +197,198 @@ PyObject * pcilib_convert_property_info_to_pyobject(pcilib_t* ctx, pcilib_proper PyObject * pcilib_convert_register_info_to_pyobject(pcilib_t* ctx, pcilib_register_info_t listItem) { - PyObject* pylistItem = PyDict_New(); - - if(listItem.name) - pcilib_pydict_set_item(pylistItem, - PyString_FromString("name"), - PyString_FromString(listItem.name)); - - if(listItem.description) - pcilib_pydict_set_item(pylistItem, - PyString_FromString("description"), - PyString_FromString(listItem.description)); - - if(listItem.bank) - pcilib_pydict_set_item(pylistItem, - PyString_FromString("bank"), - PyString_FromString(listItem.bank)); - - - //serialize modes - PyObject* modes = PyList_New(0); - - if((listItem.mode & PCILIB_REGISTER_R) == PCILIB_REGISTER_R) - pcilib_pylist_append(modes, PyString_FromString("R")); - if((listItem.mode & PCILIB_REGISTER_W) == PCILIB_REGISTER_W) - pcilib_pylist_append(modes, PyString_FromString("W")); - if((listItem.mode & PCILIB_REGISTER_RW) == PCILIB_REGISTER_RW) - pcilib_pylist_append(modes, PyString_FromString("RW")); - if((listItem.mode & PCILIB_REGISTER_W1C) == PCILIB_REGISTER_W1C) - pcilib_pylist_append(modes, PyString_FromString("W1C")); - if((listItem.mode & PCILIB_REGISTER_RW1C) == PCILIB_REGISTER_RW1C) - pcilib_pylist_append(modes, PyString_FromString("RW1C")); - if((listItem.mode & PCILIB_REGISTER_W1I) == PCILIB_REGISTER_W1I) - pcilib_pylist_append(modes, PyString_FromString("W1I")); - if((listItem.mode & PCILIB_REGISTER_RW1I) == PCILIB_REGISTER_RW1I) - pcilib_pylist_append(modes, PyString_FromString("RW1I")); - if((listItem.mode & PCILIB_REGISTER_INCONSISTENT) == PCILIB_REGISTER_INCONSISTENT) - pcilib_pylist_append(modes, PyString_FromString("NO_CHK")); - - pcilib_pydict_set_item(pylistItem, - PyString_FromString("mode"), - modes); - - pcilib_value_t defval = {0}; - pcilib_set_value_from_register_value(ctx, &defval, listItem.defvalue); - add_pcilib_value_to_dict(ctx, pylistItem, &defval, "defvalue"); - - if(listItem.range) - { - pcilib_value_t minval = {0}; - pcilib_set_value_from_register_value(ctx, &minval, listItem.range->min); - - pcilib_value_t maxval = {0}; - pcilib_set_value_from_register_value(ctx, &maxval, listItem.range->max); - - PyObject* range = PyDict_New(); - add_pcilib_value_to_dict(ctx, range, &minval, "min"); - add_pcilib_value_to_dict(ctx, range, &maxval, "max"); - pcilib_pydict_set_item(pylistItem, - PyString_FromString("range"), - range); - } - - if(listItem.values) - { + PyObject* pylistItem = PyDict_New(); + + if(listItem.name) + pcilib_pydict_set_item(pylistItem, + PyString_FromString("name"), + PyString_FromString(listItem.name)); + + if(listItem.description) + pcilib_pydict_set_item(pylistItem, + PyString_FromString("description"), + PyString_FromString(listItem.description)); + + if(listItem.bank) + pcilib_pydict_set_item(pylistItem, + PyString_FromString("bank"), + PyString_FromString(listItem.bank)); + + + //serialize modes + PyObject* modes = PyList_New(0); + + if((listItem.mode & PCILIB_REGISTER_R) == PCILIB_REGISTER_R) + pcilib_pylist_append(modes, PyString_FromString("R")); + if((listItem.mode & PCILIB_REGISTER_W) == PCILIB_REGISTER_W) + pcilib_pylist_append(modes, PyString_FromString("W")); + if((listItem.mode & PCILIB_REGISTER_RW) == PCILIB_REGISTER_RW) + pcilib_pylist_append(modes, PyString_FromString("RW")); + if((listItem.mode & PCILIB_REGISTER_W1C) == PCILIB_REGISTER_W1C) + pcilib_pylist_append(modes, PyString_FromString("W1C")); + if((listItem.mode & PCILIB_REGISTER_RW1C) == PCILIB_REGISTER_RW1C) + pcilib_pylist_append(modes, PyString_FromString("RW1C")); + if((listItem.mode & PCILIB_REGISTER_W1I) == PCILIB_REGISTER_W1I) + pcilib_pylist_append(modes, PyString_FromString("W1I")); + if((listItem.mode & PCILIB_REGISTER_RW1I) == PCILIB_REGISTER_RW1I) + pcilib_pylist_append(modes, PyString_FromString("RW1I")); + if((listItem.mode & PCILIB_REGISTER_INCONSISTENT) == PCILIB_REGISTER_INCONSISTENT) + pcilib_pylist_append(modes, PyString_FromString("NO_CHK")); + + pcilib_pydict_set_item(pylistItem, + PyString_FromString("mode"), + modes); + + pcilib_value_t defval = {0}; + pcilib_set_value_from_register_value(ctx, &defval, listItem.defvalue); + add_pcilib_value_to_dict(ctx, pylistItem, &defval, "defvalue"); + + if(listItem.range) + { + pcilib_value_t minval = {0}; + pcilib_set_value_from_register_value(ctx, &minval, listItem.range->min); + + pcilib_value_t maxval = {0}; + pcilib_set_value_from_register_value(ctx, &maxval, listItem.range->max); + + PyObject* range = PyDict_New(); + add_pcilib_value_to_dict(ctx, range, &minval, "min"); + add_pcilib_value_to_dict(ctx, range, &maxval, "max"); + pcilib_pydict_set_item(pylistItem, + PyString_FromString("range"), + range); + } - PyObject* values = PyList_New(0); + if(listItem.values) + { - for (int j = 0; listItem.values[j].name; j++) - { - PyObject* valuesItem = PyDict_New(); + PyObject* values = PyList_New(0); - pcilib_value_t val = {0}; - pcilib_set_value_from_register_value(ctx, &val, listItem.values[j].value); + for (int j = 0; listItem.values[j].name; j++) + { + PyObject* valuesItem = PyDict_New(); - pcilib_value_t min = {0}; - pcilib_set_value_from_register_value(ctx, &min, listItem.values[j].min); + pcilib_value_t val = {0}; + pcilib_set_value_from_register_value(ctx, &val, listItem.values[j].value); - pcilib_value_t max = {0}; - pcilib_set_value_from_register_value(ctx, &max, listItem.values[j].max); + pcilib_value_t min = {0}; + pcilib_set_value_from_register_value(ctx, &min, listItem.values[j].min); - add_pcilib_value_to_dict(ctx, valuesItem, &val, "value"); - add_pcilib_value_to_dict(ctx, valuesItem, &min, "min"); - add_pcilib_value_to_dict(ctx, valuesItem, &max, "max"); + pcilib_value_t max = {0}; + pcilib_set_value_from_register_value(ctx, &max, listItem.values[j].max); - if(listItem.values[j].name) - pcilib_pydict_set_item(valuesItem, - PyString_FromString("name"), - PyString_FromString(listItem.values[j].name)); - if(listItem.values[j].description) - { - pcilib_pydict_set_item(valuesItem, - PyString_FromString("description"), - PyString_FromString(listItem.values[j].description)); + add_pcilib_value_to_dict(ctx, valuesItem, &val, "value"); + add_pcilib_value_to_dict(ctx, valuesItem, &min, "min"); + add_pcilib_value_to_dict(ctx, valuesItem, &max, "max"); - } - pcilib_pylist_append(values, valuesItem); - } + if(listItem.values[j].name) + pcilib_pydict_set_item(valuesItem, + PyString_FromString("name"), + PyString_FromString(listItem.values[j].name)); + if(listItem.values[j].description) + { + pcilib_pydict_set_item(valuesItem, + PyString_FromString("description"), + PyString_FromString(listItem.values[j].description)); - pcilib_pydict_set_item(pylistItem, - PyString_FromString("values"), - values); - } + } + pcilib_pylist_append(values, valuesItem); + } - return pylistItem; + pcilib_pydict_set_item(pylistItem, + PyString_FromString("values"), + values); + } + return pylistItem; } + Pcipywrap *new_Pcipywrap(const char* fpga_device, const char* model) { //opening device pcilib_t* ctx = pcilib_open(fpga_device, model); - if(!ctx) - { + if(!ctx) { set_python_exception("Failed pcilib_open(%s, %s)", fpga_device, model); return NULL; } + Pcipywrap *self; self = (Pcipywrap *) malloc(sizeof(Pcipywrap)); + if(!self) { + pcilib_close(ctx); + return (Pcipywrap *)PyExc_MemoryError; + } self->shared = 0; self->ctx = ctx; + self->py = NULL; + self->names = NULL; + self->names_size = 0; + + + //processing pcilib scrips + const char *scripts_dir = getenv("PCILIB_SCRIPTS_DIR"); + if(scripts_dir) { + int err = 0; + + self->py = pcilib_init_py_ctx(ctx->py, &err); + if(err) { + delete_Pcipywrap(self); + set_python_exception("Failed pcilib_py_s_clone (%i)", err); + return NULL; + } + + //add scripts directory to Python path + err = pcilib_py_ctx_add_script_dir(self->py, scripts_dir); + if(err) { + delete_Pcipywrap(self); + set_python_exception("Failed pcilib_py_add_dir (%i)", err); + return NULL; + } + + //load scripts in PCILIB_SCRIPTS_DIR + self->names = malloc(++(self->names_size) * sizeof(char*)); + self->names[self->names_size - 1] = NULL; + + DIR *dir; + struct dirent *script_path; + dir = opendir(scripts_dir); + if (dir) { + while ((script_path = readdir(dir)) != NULL) { + + char *py = strrchr(script_path->d_name, '.'); + if ((!py)||(strcasecmp(py, ".py"))) { + continue; + } + + char *name = malloc(strlen(script_path->d_name)); + if(!name) { + delete_Pcipywrap(self); + return (Pcipywrap *)PyExc_MemoryError; + } + + strcpy(name, script_path->d_name); + + err = pcilib_py_ctx_load_script(self->py, name); + + if(err) { + delete_Pcipywrap(self); + set_python_exception("pcilib_py_ctx_load_script (%i)", err); + return NULL; + } + + self->names = realloc(self->names, ++(self->names_size)); + if(!self->names) { + delete_Pcipywrap(self); + return (Pcipywrap *)PyExc_MemoryError; + } + self->names[self->names_size - 1] = NULL; + self->names[self->names_size - 2] = name; + } + closedir(dir); + } + } + return self; } @@ -350,14 +404,27 @@ Pcipywrap *create_Pcipywrap(PyObject* ctx) self = (Pcipywrap *) malloc(sizeof(Pcipywrap)); self->shared = 1; self->ctx = PyCObject_AsVoidPtr(ctx); + self->py = NULL; + self->names = NULL; + self->names_size = 0; return self; } void delete_Pcipywrap(Pcipywrap *self) { - if(!self->shared) - pcilib_close(self->ctx); - - free(self); + if(!self->shared) + pcilib_close(self->ctx); + + pcilib_free_py_ctx(self->py); + + if(self->names) { + for(int i = 0; self->names[i]; i++) + free(self->names[i]); + free(self->names); + self->names = NULL; + self->names_size = 0; + } + + free(self); } PyObject* Pcipywrap_read_register(Pcipywrap *self, const char *regname, const char *bank) @@ -464,7 +531,7 @@ PyObject* Pcipywrap_get_registers_list(Pcipywrap *self, const char *bank) set_python_exception("pcilib_get_register_list return NULL"); return NULL; } - + PyObject* pyList = PyList_New(0); for(int i = 0; list[i].name; i++) { @@ -554,7 +621,7 @@ void Pcipywrap_unlock_global(Pcipywrap *self) PyObject* Pcipywrap_lock(Pcipywrap *self, const char *lock_id) { pcilib_lock_t* lock = pcilib_get_lock(self->ctx, - PCILIB_LOCK_FLAGS_DEFAULT, + PCILIB_LOCK_FLAG_PERSISTENT, lock_id); if(!lock) { @@ -576,7 +643,7 @@ PyObject* Pcipywrap_lock(Pcipywrap *self, const char *lock_id) PyObject* Pcipywrap_try_lock(Pcipywrap *self, const char *lock_id) { pcilib_lock_t* lock = pcilib_get_lock(self->ctx, - PCILIB_LOCK_FLAGS_DEFAULT, + PCILIB_LOCK_FLAG_PERSISTENT, lock_id); if(!lock) { @@ -597,7 +664,7 @@ PyObject* Pcipywrap_try_lock(Pcipywrap *self, const char *lock_id) PyObject* Pcipywrap_unlock(Pcipywrap *self, const char *lock_id) { pcilib_lock_t* lock = pcilib_get_lock(self->ctx, - PCILIB_LOCK_FLAGS_DEFAULT, + PCILIB_LOCK_FLAG_PERSISTENT, lock_id); if(!lock) { @@ -609,4 +676,20 @@ PyObject* Pcipywrap_unlock(Pcipywrap *self, const char *lock_id) return PyInt_FromLong((long)1); } +PyObject* Pcipywrap_get_scripts_list(Pcipywrap *self) +{ + return pcilib_py_ctx_get_scripts_info(self->py); +} +PyObject* Pcipywrap_run_script(Pcipywrap *self, const char* script_name, PyObject* value) +{ + int err = 0; + PyObject* value_out = pcilib_py_ctx_eval_func(self->py, script_name, "run", value, &err); + + if(err) { + set_python_exception("Failed pcilib_py_ctx_eval_func (%i)", err); + return NULL; + } + + return value_out; +} diff --git a/pywrap/pcipywrap.h b/pywrap/pcipywrap.h index dcce245..2d9115b 100644 --- a/pywrap/pcipywrap.h +++ b/pywrap/pcipywrap.h @@ -5,11 +5,23 @@ #include "error.h" #include +#include "config.h" +#include "py.h" + +#include "pci.h" +#include "pcilib.h" + + typedef struct { + char** names; + int names_size; + void* ctx; + struct pcilib_py_s *py; int shared; } Pcipywrap; + /*! * \brief Redirect pcilib standart log stream to exeption text. * Logger will accumulate errors untill get message, starts with "#E". @@ -83,4 +95,7 @@ PyObject* Pcipywrap_lock(Pcipywrap *self, const char *lock_id); PyObject* Pcipywrap_try_lock(Pcipywrap *self, const char *lock_id); PyObject* Pcipywrap_unlock(Pcipywrap *self, const char *lock_id); +PyObject* Pcipywrap_get_scripts_list(Pcipywrap *self); +PyObject* Pcipywrap_run_script(Pcipywrap *self, const char* script_name, PyObject* value); + #endif /* PCIPYWRAP_H */ diff --git a/pywrap/pcipywrap.i b/pywrap/pcipywrap.i index f08ceb7..104e19f 100644 --- a/pywrap/pcipywrap.i +++ b/pywrap/pcipywrap.i @@ -29,5 +29,8 @@ typedef struct { PyObject* lock(const char *lock_id); PyObject* try_lock(const char *lock_id); PyObject* unlock(const char *lock_id); + + PyObject* get_scripts_list(); + PyObject* run_script(const char* script_name, PyObject* value); } } Pcipywrap; diff --git a/pywrap/server.py b/pywrap/server.py deleted file mode 100644 index b59ae55..0000000 --- a/pywrap/server.py +++ /dev/null @@ -1,539 +0,0 @@ -import time -import os -import pcipywrap -import json -import sys -from optparse import OptionParser - -from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler -from SocketServer import ThreadingMixIn -import threading - -pcilib = None - -class MultiThreadedHTTPServer(ThreadingMixIn, HTTPServer): - pass - -class PcilibServerHandler(BaseHTTPRequestHandler): - locks = list() - lock_global = 0 - - #def __init__(s, pcilib, *args): - # s.pcilib = pcilib - # BaseHTTPRequestHandler.__init__(s, *args) - - def do_HEAD(s): - s.send_response(200) - s.send_header('content-type', 'application/json') - s.end_headers() - - def do_GET(s): - length = int(s.headers['Content-Length']) - - #deserialize input data - data = json.loads(s.rfile.read(length).decode('utf-8')) - - if 'command' in data: - command = data['command'] - if(command == 'help'): - s.help(data) - - - - #elif(command == 'open'): - # #check required arguments - # if not 'device' in data: - # s.error('message doesnt contains "device" field, ' - # 'which is required for "open" command', data) - # return - # #parse command arguments and convert them to string - # device = str(data.get('device', None)) - # model = data.get('model', None) - # if not model is None: - # model = str(model) - # - # try: - # s.openPcilibInstance(device, model) - # except Exception as e: - # s.error(str(e), data) - # return - # - # #Success! Create and send reply - # out = dict() - # out['status'] = 'ok' - # s.wrapMessageAndSend(out, data) - - - - elif(command == 'get_registers_list'): - #parse command arguments and convert them to string - bank = data.get('bank', None) - if not bank is None: - bank = str(bank) - - registers = dict() - try: - registers = pcilib.get_registers_list(bank) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - out = dict() - out['status'] = 'ok' - out['registers'] = registers - s.wrapMessageAndSend(out, data) - - - - elif(command == 'get_register_info'): - #check required arguments - if not 'reg' in data: - s.error('message doesnt contains "reg" field, ' - 'which is required for "get_register_info" command', data) - return - - #parse command arguments and convert them to string - reg = str(data.get('reg', None)) - bank = data.get('bank', None) - if not bank is None: - bank = str(bank) - - register = dict() - try: - register = pcilib.get_register_info(reg, bank) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - s.wrapMessageAndSend({'status': 'ok', 'register': register}, data) - - - - elif(command == 'get_property_list'): - #parse command arguments and convert them to string - branch = data.get('branch', None) - if not branch is None: - branch = str(branch) - - properties = dict() - try: - properties = pcilib.get_property_list(branch) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - out = dict() - out['status'] = 'ok' - out['properties'] = properties - s.wrapMessageAndSend(out, data) - - - - elif(command == 'read_register'): - #check required arguments - if not 'reg' in data: - s.error('message doesnt contains "reg" field, ' - 'which is required for "read_register" command', data) - return - - #parse command arguments and convert them to string - reg = str(data.get('reg', None)) - bank = data.get('bank', None) - if not bank is None: - bank = str(bank) - - value = 0 - try: - value = pcilib.read_register(reg, bank) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - out = dict() - out['status'] = 'ok' - out['value'] = value - s.wrapMessageAndSend(out, data) - - - - elif(command == 'write_register'): - #check required arguments - if not 'reg' in data: - s.error('message doesnt contains "reg" field, ' - 'which is required for "write_register" command', data) - return - - if not 'value' in data: - s.error('message doesnt contains "value" field, ' - 'which is required for "write_register" command', data) - return - - #parse command arguments and convert them to string - reg = str(data.get('reg', None)) - value = str(data.get('value', None)) - bank = data.get('bank', None) - if not bank is None: - bank = str(bank) - - try: - pcilib.write_register(value, reg, bank) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - s.wrapMessageAndSend({'status': 'ok'}, data) - - - - elif(command == 'get_property'): - #check required arguments - if not 'prop' in data: - s.error('message doesnt contains "prop" field, ' - 'which is required for "get_property" command', data) - return - - #parse command arguments and convert them to string - prop = str(data.get('prop', None)) - - value = 0 - try: - value = pcilib.get_property(prop) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - out = dict() - out['status'] = 'ok' - out['value'] = value - s.wrapMessageAndSend(out, data) - - - - elif(command == 'set_property'): - #check required arguments - if not 'prop' in data: - s.error('message doesnt contains "prop" field, ' - 'which is required for "set_property" command', data) - return - - if not 'value' in data: - s.error('message doesnt contains "value" field, ' - 'which is required for "set_property" command', data) - return - - #parse command arguments and convert them to string - prop = str(data.get('prop', None)) - value = str(data.get('value', None)) - - try: - pcilib.set_property(value, prop) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - s.wrapMessageAndSend({'status': 'ok'}, data) - - - - elif(command == 'lock'): - #check required arguments - if not 'lock_id' in data: - s.error('message doesnt contains "lock_id" field, ' - 'which is required for "lock" command', data) - return - - #parse command arguments and convert them to string - lock_id = str(data.get('lock_id')) - - #check if lock already setted - #if lock_id in PcilibServerHandler.locks: - # s.error('Lock with id: ' + lock_id + - # 'already setted by this server', - # data) - # return - - try: - pcilib.lock(lock_id) - except Exception as e: - s.error(str(e), data) - return - - PcilibServerHandler.locks.append(lock_id) - - #Success! Create and send reply - s.wrapMessageAndSend({'status': 'ok'}, data) - - - - elif(command == 'try_lock'): - #check required arguments - if not 'lock_id' in data: - s.error('message doesnt contains "lock_id" field, ' - 'which is required for "try_lock" command', data) - return - - #parse command arguments and convert them to string - lock_id = str(data.get('lock_id')) - - try: - pcilib.try_lock(lock_id) - except Exception as e: - s.error(str(e), data) - return - - #Success! Create and send reply - s.wrapMessageAndSend({'status': 'ok'}, data) - - - - elif(command == 'unlock'): - #check required arguments - #if not 'lock_id' in data: - # s.error('message doesnt contains "lock_id" field, ' - # 'which is required for "unlock" command', data) - # return - - #parse command arguments and convert them to string - #lock_id = str(data.get('lock_id')) - - #try: - # pcilib.unlock(lock_id) - #except Exception as e: - # s.error(str(e), data) - # return - # - #remove lock from locks list - #if lock_id in PcilibServerHandler.locks: - # PcilibServerHandler.locks.remove(lock_id) - time.sleep(20) - #Success! Create and send reply - s.wrapMessageAndSend({'status': 'ok'}, data) - - - - #elif(command == 'lock_global'): - # #check if global_lock already setted by server - # print 'aaa' - # if PcilibServerHandler.lock_global: - # - # s.error('global lock already setted by this server', data) - # return - # - # try: - # pcilib.lock_global() - # except Exception as e: - # s.error(str(e), data) - # return - # - # PcilibServerHandler.lock_global = 1 - # - # #Success! Create and send reply - # s.wrapMessageAndSend({'status': 'ok'}, data) - - - - #elif(command == 'unlock_global'): - # try: - # pcilib.unlock_global() - # except Exception as e: - # s.error(str(e), data) - # return - # - # PcilibServerHandler.lock_global = 0 - # - # #Success! Create and send reply - # s.wrapMessageAndSend({'status': 'ok'}, data) - - - - else: - s.error('command "' + command + '" undefined', data) - return - else: - s.error('message doesnt contains "command" field, which is required', data) - return - - - #print str(s.headers['content-type']) - #print post_data['some'] - - #"""open device context """ - #def openPcilibInstance(s, device, model): - # pcilib = pcipywrap.create_pcilib_instance(device, model) - - """Send help message""" - def help(s, received_message = None): - usage = str('Usage:\n' - ' Server receive commands via http GET with json packet.\n' - ' content-type should have value "application/json"\n' - ' Server could handle only commands. to set command, you\n' - ' should specify field "command" in packet with command name\n' - ' List of commands:\n' - '\n' - ' command: help - Get help. This will return usage\n' - '\n' - - ' command: open - Opens context of device. It will be reopened if already open.\n' - ' required fields\n' - ' device: - path to the device file [/dev/fpga0]\n' - ' optional fields\n' - ' model: - specifies the model of hardware, autodetected if doesnt exists\n' - '\n' - - ' command: get_registers_list - Returns the list of registers provided by the hardware model.\n' - ' optional fields\n' - ' bank: - if set, only register within the specified bank will be returned\n' - '\n' - - ' command: get_register_info - Returns the information about the specified register.\n' - ' required fields\n' - ' reg: - the name of the register\n' - ' optional fields\n' - ' bank: - if set, only register within the specified bank will be returned\n' - '\n' - - ' command: get_property_list - Returns the list of properties available under the specified path.\n' - ' optional fields\n' - ' branch: - Path. If not set, will return the top-level properties\n' - '\n' - - ' command: read_register - Reads the specified register.\n' - ' required fields\n' - ' reg: - the name of the register\n' - ' optional fields\n' - ' bank: - if set, only register within the specified bank will be processed\n' - '\n' - - ' command: write_register - Writes to specified register.\n' - ' required fields\n' - ' reg: - the name of the register\n' - ' value: - the register value to write. Should be int, float or string (with number)\n' - ' optional fields\n' - ' bank: - if set, only register within the specified bank will be processed\n' - '\n' - - ' command: get_property - Reads / computes the property value.\n' - ' required fields\n' - ' prop: - full name including path\n' - '\n' - - ' command: set_property - Writes the property value or executes the code associated with property.\n' - ' required fields\n' - ' prop: - full name including path\n' - ' value: - the property value to write. Should be int, float or string (with number)\n' - '\n' - - ' command: lock - function to acquire a lock, and wait till the lock can be acquire.\n' - ' required fields\n' - ' lock_id: - lock id\n' - '\n' - - ' command: try_lock - this function will try to take a lock for the mutex pointed by \n' - ' lockfunction to acquire a lock, but that returns immediatly if the\n' - ' lock can\'t be acquired on first try\n' - ' lock_id: - lock id\n' - '\n' - - ' command: unlock - this function unlocks the lock.\n' - ' required fields\n' - ' lock_id: - lock id\n' - '\n' - - '\n') - out = {'status': 'ok', 'usage' : usage} - s.wrapMessageAndSend(out, received_message) - - """Send error message with text description""" - def error(s, info, received_message = None): - out = dict() - - out['status'] = 'error' - out['description'] = info - out['note'] = 'send {"command" : "help"} to get help' - s.wrapMessageAndSend(out, received_message, 400) - - def wrapMessageAndSend(s, message, received_message = None, response = 200): - s.send_response(response) - s.send_header('content-type', 'application/json') - s.end_headers() - if not received_message is None: - message['received_message'] = received_message - message['thread'] = threading.currentThread().getName() - s.wfile.write(json.dumps(message)) - -if __name__ == '__main__': - - #parce command line options - parser = OptionParser() - parser.add_option("-p", "--port", action="store", - type="int", dest="port", default=9000, - help="Set server port (9000)") - parser.add_option("-d", "--device", action="store", - type="string", dest="device", default=str('/dev/fpga0'), - help="FPGA device (/dev/fpga0)") - parser.add_option("-m", "--model", action="store", - type="string", dest="model", default=None, - help="Memory model (autodetected)") - opts = parser.parse_args()[0] - - HOST_NAME = '' - PORT_NUMBER = opts.port - MODEL = opts.model - DEVICE = opts.device - - - - #Set enviroment variables, if it not setted already - if not 'APP_PATH' in os.environ: - APP_PATH = '' - file_dir = os.path.dirname(os.path.abspath(__file__)) - APP_PATH = str(os.path.abspath(file_dir + '/../..')) - os.environ["APP_PATH"] = APP_PATH - - if not 'PCILIB_MODEL_DIR' in os.environ: - os.environ['PCILIB_MODEL_DIR'] = os.environ["APP_PATH"] + "/xml" - - if not 'LD_LIBRARY_PATH' in os.environ: - os.environ['LD_LIBRARY_PATH'] = os.environ["APP_PATH"] + "/pcilib" - - - - #redirect logs to exeption - pcipywrap.__redirect_logs_to_exeption() - - #pass Pcipywrap to to server handler - global pcilib - pcilib = pcipywrap.Pcipywrap(DEVICE, MODEL) - #def handler(*args): - # PcilibServerHandler(lib, *args) - - #start server - httpd = MultiThreadedHTTPServer((HOST_NAME, PORT_NUMBER), PcilibServerHandler) - - print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, PORT_NUMBER) - try: - httpd.serve_forever() - except KeyboardInterrupt: - #unlocking global lock - if PcilibServerHandler.lock_global: - lib.unlock_global() - PcilibServerHandler.lock_global = False - - #delete created locks - for lock in PcilibServerHandler.locks: - lib.unlock(lock) - del PcilibServerHandler.locks[:] - pass - - - - - httpd.server_close() - print time.asctime(), "Server Stops - %s:%s" % (HOST_NAME, PORT_NUMBER) diff --git a/run b/run index 42160f2..6c322c5 100755 --- a/run +++ b/run @@ -2,4 +2,8 @@ APP_PATH=`dirname $0` -PYTHONPATH="$APP_PATH/pywrap:$PYTHONPATH" PCILIB_MODEL_DIR="$APP_PATH/xml" LD_LIBRARY_PATH="$APP_PATH/pcilib" $* +PYTHONPATH="$APP_PATH/pywrap:$PYTHONPATH" \ +PCILIB_MODEL_DIR="$APP_PATH/xml" \ +LD_LIBRARY_PATH="$APP_PATH/pcilib" \ +PCILIB_SCRIPTS_DIR="$APP_PATH/xml/scripts" \ +$* diff --git a/xml/scripts/test_script.py b/xml/scripts/test_script.py new file mode 100644 index 0000000..16e4adb --- /dev/null +++ b/xml/scripts/test_script.py @@ -0,0 +1,4 @@ +description='this is a test script' + +def run(ctx, inpt): + return ctx.get_registers_list(); diff --git a/xml/scripts/test_script2.py b/xml/scripts/test_script2.py new file mode 100644 index 0000000..16e4adb --- /dev/null +++ b/xml/scripts/test_script2.py @@ -0,0 +1,4 @@ +description='this is a test script' + +def run(ctx, inpt): + return ctx.get_registers_list(); diff --git a/xml/test/test_prop_mt.py b/xml/test/test_prop_mt.py index f8c63d0..3714597 100644 --- a/xml/test/test_prop_mt.py +++ b/xml/test/test_prop_mt.py @@ -4,15 +4,15 @@ lock = threading.Lock() def read_from_register(ctx, value): with lock: - ctx.lock('lock5') + ctx.lock('lock12') cur = read_from_register.counter read_from_register.counter += 1 - for i in range (0, 5): + for i in range (0, 60): time.sleep(0.1) print cur out = ctx.get_property('/test/prop3') / 2 - ctx.unlock('lock5') + ctx.unlock('lock12') return out -- cgit v1.2.3