X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fpython.c;h=110a8e024a4ea8bcdd25a76dd80892de3e40f6c3;hb=addc746565334182a816790d3073d5da86aad16e;hp=eed0591d395aed66ba373d3b02b208e65912adf3;hpb=4dc9287f4de0283ae986444377075dcbdada2871;p=collectd.git diff --git a/src/python.c b/src/python.c index eed0591d..110a8e02 100644 --- a/src/python.c +++ b/src/python.c @@ -217,7 +217,7 @@ static int do_interactive = 0; static PyThreadState *state; -static PyObject *cpy_format_exception; +static PyObject *sys_path, *cpy_format_exception; static cpy_callback_t *cpy_config_callbacks; static cpy_callback_t *cpy_init_callbacks; @@ -282,35 +282,44 @@ void cpy_log_exception(const char *context) { Py_END_ALLOW_THREADS Py_XDECREF(tn); Py_XDECREF(m); - if (!cpy_format_exception) { + if (!cpy_format_exception || !traceback) { PyErr_Clear(); - Py_XDECREF(type); + Py_DECREF(type); Py_XDECREF(value); Py_XDECREF(traceback); return; } - if (!traceback) { - PyErr_Clear(); - return; - } - list = PyObject_CallFunction(cpy_format_exception, "NNN", type, value, traceback); /* New reference. */ + list = PyObject_CallFunction(cpy_format_exception, "NNN", type, value, traceback); /* New reference. Steals references from "type", "value" and "traceback". */ if (list) l = PyObject_Length(list); + for (i = 0; i < l; ++i) { - char *s; PyObject *line; - + char const *msg; + char *cpy; + line = PyList_GET_ITEM(list, i); /* Borrowed reference. */ Py_INCREF(line); - s = strdup(cpy_unicode_or_bytes_to_string(&line)); + + msg = cpy_unicode_or_bytes_to_string(&line); Py_DECREF(line); - if (s[strlen(s) - 1] == '\n') - s[strlen(s) - 1] = 0; + if (msg == NULL) + continue; + + cpy = strdup(msg); + if (cpy == NULL) + continue; + + if (cpy[strlen(cpy) - 1] == '\n') + cpy[strlen(cpy) - 1] = 0; + Py_BEGIN_ALLOW_THREADS - ERROR("%s", s); + ERROR("%s", cpy); Py_END_ALLOW_THREADS - free(s); + + free(cpy); } + Py_XDECREF(list); PyErr_Clear(); } @@ -335,7 +344,7 @@ static int cpy_read_callback(user_data_t *data) { static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_list, user_data_t *data) { int i; cpy_callback_t *c = data->data; - PyObject *ret, *list, *temp, *dict = NULL, *val; + PyObject *ret, *list, *temp, *dict = NULL; Values *v; CPY_LOCK_THREADS @@ -345,26 +354,26 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li CPY_RETURN_FROM_THREADS 0; } for (i = 0; i < value_list->values_len; ++i) { - if (ds->ds->type == DS_TYPE_COUNTER) { + if (ds->ds[i].type == DS_TYPE_COUNTER) { if ((long) value_list->values[i].counter == value_list->values[i].counter) PyList_SetItem(list, i, PyInt_FromLong(value_list->values[i].counter)); else PyList_SetItem(list, i, PyLong_FromUnsignedLongLong(value_list->values[i].counter)); - } else if (ds->ds->type == DS_TYPE_GAUGE) { + } else if (ds->ds[i].type == DS_TYPE_GAUGE) { PyList_SetItem(list, i, PyFloat_FromDouble(value_list->values[i].gauge)); - } else if (ds->ds->type == DS_TYPE_DERIVE) { + } else if (ds->ds[i].type == DS_TYPE_DERIVE) { if ((long) value_list->values[i].derive == value_list->values[i].derive) PyList_SetItem(list, i, PyInt_FromLong(value_list->values[i].derive)); else PyList_SetItem(list, i, PyLong_FromLongLong(value_list->values[i].derive)); - } else if (ds->ds->type == DS_TYPE_ABSOLUTE) { + } else if (ds->ds[i].type == DS_TYPE_ABSOLUTE) { if ((long) value_list->values[i].absolute == value_list->values[i].absolute) PyList_SetItem(list, i, PyInt_FromLong(value_list->values[i].absolute)); else PyList_SetItem(list, i, PyLong_FromUnsignedLongLong(value_list->values[i].absolute)); } else { Py_BEGIN_ALLOW_THREADS - ERROR("cpy_write_callback: Unknown value type %d.", ds->ds->type); + ERROR("cpy_write_callback: Unknown value type %d.", ds->ds[i].type); Py_END_ALLOW_THREADS Py_DECREF(list); CPY_RETURN_FROM_THREADS 0; @@ -375,9 +384,9 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li CPY_RETURN_FROM_THREADS 0; } } - dict = PyDict_New(); + dict = PyDict_New(); /* New reference. */ if (value_list->meta) { - int i, num; + int num; char **table; meta_data_t *meta = value_list->meta; @@ -394,26 +403,26 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li if (type == MD_TYPE_STRING) { if (meta_data_get_string(meta, table[i], &string)) continue; - temp = cpy_string_to_unicode_or_bytes(string); + temp = cpy_string_to_unicode_or_bytes(string); /* New reference. */ free(string); PyDict_SetItemString(dict, table[i], temp); Py_XDECREF(temp); } else if (type == MD_TYPE_SIGNED_INT) { if (meta_data_get_signed_int(meta, table[i], &si)) continue; - temp = PyObject_CallFunctionObjArgs((void *) &SignedType, PyLong_FromLongLong(si), (void *) 0); + temp = PyObject_CallFunctionObjArgs((void *) &SignedType, PyLong_FromLongLong(si), (void *) 0); /* New reference. */ PyDict_SetItemString(dict, table[i], temp); Py_XDECREF(temp); } else if (type == MD_TYPE_UNSIGNED_INT) { if (meta_data_get_unsigned_int(meta, table[i], &ui)) continue; - temp = PyObject_CallFunctionObjArgs((void *) &UnsignedType, PyLong_FromUnsignedLongLong(ui), (void *) 0); + temp = PyObject_CallFunctionObjArgs((void *) &UnsignedType, PyLong_FromUnsignedLongLong(ui), (void *) 0); /* New reference. */ PyDict_SetItemString(dict, table[i], temp); Py_XDECREF(temp); } else if (type == MD_TYPE_DOUBLE) { if (meta_data_get_double(meta, table[i], &d)) continue; - temp = PyFloat_FromDouble(d); + temp = PyFloat_FromDouble(d); /* New reference. */ PyDict_SetItemString(dict, table[i], temp); Py_XDECREF(temp); } else if (type == MD_TYPE_BOOLEAN) { @@ -428,8 +437,7 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li } free(table); } - val = Values_New(); /* New reference. */ - v = (Values *) val; + v = (Values *) Values_New(); /* New reference. */ sstrncpy(v->data.host, value_list->host, sizeof(v->data.host)); sstrncpy(v->data.type, value_list->type, sizeof(v->data.type)); sstrncpy(v->data.type_instance, value_list->type_instance, sizeof(v->data.type_instance)); @@ -440,9 +448,9 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li Py_CLEAR(v->values); v->values = list; Py_CLEAR(v->meta); - v->meta = dict; + v->meta = dict; /* Steals a reference. */ ret = PyObject_CallFunctionObjArgs(c->callback, v, c->data, (void *) 0); /* New reference. */ - Py_XDECREF(val); + Py_XDECREF(v); if (ret == NULL) { cpy_log_exception("write callback"); } else { @@ -484,11 +492,11 @@ static void cpy_log_callback(int severity, const char *message, user_data_t *dat PyObject *ret, *text; CPY_LOCK_THREADS - text = cpy_string_to_unicode_or_bytes(message); + text = cpy_string_to_unicode_or_bytes(message); /* New reference. */ if (c->data == NULL) - ret = PyObject_CallFunction(c->callback, "iN", severity, text); /* New reference. */ + ret = PyObject_CallFunction(c->callback, "iN", severity, text); /* New reference. Steals a reference from "text". */ else - ret = PyObject_CallFunction(c->callback, "iNO", severity, text, c->data); /* New reference. */ + ret = PyObject_CallFunction(c->callback, "iNO", severity, text, c->data); /* New reference. Steals a reference from "text". */ if (ret == NULL) { /* FIXME */ @@ -525,12 +533,13 @@ static void cpy_flush_callback(int timeout, const char *id, user_data_t *data) { static PyObject *cpy_register_generic(cpy_callback_t **list_head, PyObject *args, PyObject *kwds) { char buf[512]; cpy_callback_t *c; - const char *name = NULL; + char *name = NULL; PyObject *callback = NULL, *data = NULL, *mod = NULL; static char *kwlist[] = {"callback", "data", "name", NULL}; if (PyArg_ParseTupleAndKeywords(args, kwds, "O|Oet", kwlist, &callback, &data, NULL, &name) == 0) return NULL; if (PyCallable_Check(callback) == 0) { + PyMem_Free(name); PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object."); return NULL; } @@ -538,25 +547,33 @@ static PyObject *cpy_register_generic(cpy_callback_t **list_head, PyObject *args Py_INCREF(callback); Py_XINCREF(data); + c = malloc(sizeof(*c)); + if (c == NULL) + return NULL; + memset (c, 0, sizeof (*c)); + c->name = strdup(buf); c->callback = callback; c->data = data; c->next = *list_head; *list_head = c; Py_XDECREF(mod); + PyMem_Free(name); return cpy_string_to_unicode_or_bytes(buf); } static PyObject *cpy_flush(cpy_callback_t **list_head, PyObject *args, PyObject *kwds) { int timeout = -1; - const char *plugin = NULL, *identifier = NULL; + char *plugin = NULL, *identifier = NULL; static char *kwlist[] = {"plugin", "timeout", "identifier", NULL}; if (PyArg_ParseTupleAndKeywords(args, kwds, "|etiet", kwlist, NULL, &plugin, &timeout, NULL, &identifier) == 0) return NULL; Py_BEGIN_ALLOW_THREADS plugin_flush(plugin, timeout, identifier); Py_END_ALLOW_THREADS + PyMem_Free(plugin); + PyMem_Free(identifier); Py_RETURN_NONE; } @@ -574,63 +591,82 @@ static PyObject *cpy_register_generic_userdata(void *reg, void *handler, PyObjec char buf[512]; reg_function_t *register_function = (reg_function_t *) reg; cpy_callback_t *c = NULL; - user_data_t *user_data = NULL; - const char *name = NULL; + user_data_t user_data; + char *name = NULL; PyObject *callback = NULL, *data = NULL; static char *kwlist[] = {"callback", "data", "name", NULL}; if (PyArg_ParseTupleAndKeywords(args, kwds, "O|Oet", kwlist, &callback, &data, NULL, &name) == 0) return NULL; if (PyCallable_Check(callback) == 0) { + PyMem_Free(name); PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object."); return NULL; } cpy_build_name(buf, sizeof(buf), callback, name); + PyMem_Free(name); Py_INCREF(callback); Py_XINCREF(data); + c = malloc(sizeof(*c)); + if (c == NULL) + return NULL; + memset (c, 0, sizeof (*c)); + c->name = strdup(buf); c->callback = callback; c->data = data; c->next = NULL; - user_data = malloc(sizeof(*user_data)); - user_data->free_func = cpy_destroy_user_data; - user_data->data = c; - register_function(buf, handler, user_data); + + memset (&user_data, 0, sizeof (user_data)); + user_data.free_func = cpy_destroy_user_data; + user_data.data = c; + + register_function(buf, handler, &user_data); return cpy_string_to_unicode_or_bytes(buf); } static PyObject *cpy_register_read(PyObject *self, PyObject *args, PyObject *kwds) { char buf[512]; cpy_callback_t *c = NULL; - user_data_t *user_data = NULL; + user_data_t user_data; double interval = 0; - const char *name = NULL; + char *name = NULL; PyObject *callback = NULL, *data = NULL; struct timespec ts; static char *kwlist[] = {"callback", "interval", "data", "name", NULL}; if (PyArg_ParseTupleAndKeywords(args, kwds, "O|dOet", kwlist, &callback, &interval, &data, NULL, &name) == 0) return NULL; if (PyCallable_Check(callback) == 0) { + PyMem_Free(name); PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object."); return NULL; } cpy_build_name(buf, sizeof(buf), callback, name); + PyMem_Free(name); Py_INCREF(callback); Py_XINCREF(data); + c = malloc(sizeof(*c)); + if (c == NULL) + return NULL; + memset (c, 0, sizeof (*c)); + c->name = strdup(buf); c->callback = callback; c->data = data; c->next = NULL; - user_data = malloc(sizeof(*user_data)); - user_data->free_func = cpy_destroy_user_data; - user_data->data = c; + + memset (&user_data, 0, sizeof (user_data)); + user_data.free_func = cpy_destroy_user_data; + user_data.data = c; + ts.tv_sec = interval; ts.tv_nsec = (interval - ts.tv_sec) * 1000000000; - plugin_register_complex_read(/* group = */ NULL, buf, - cpy_read_callback, &ts, user_data); + plugin_register_complex_read(/* group = */ "python", buf, + cpy_read_callback, &ts, &user_data); + return cpy_string_to_unicode_or_bytes(buf); } @@ -659,48 +695,53 @@ static PyObject *cpy_register_shutdown(PyObject *self, PyObject *args, PyObject } static PyObject *cpy_error(PyObject *self, PyObject *args) { - const char *text; + char *text; if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL; Py_BEGIN_ALLOW_THREADS plugin_log(LOG_ERR, "%s", text); Py_END_ALLOW_THREADS + PyMem_Free(text); Py_RETURN_NONE; } static PyObject *cpy_warning(PyObject *self, PyObject *args) { - const char *text; + char *text; if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL; Py_BEGIN_ALLOW_THREADS plugin_log(LOG_WARNING, "%s", text); Py_END_ALLOW_THREADS + PyMem_Free(text); Py_RETURN_NONE; } static PyObject *cpy_notice(PyObject *self, PyObject *args) { - const char *text; + char *text; if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL; Py_BEGIN_ALLOW_THREADS plugin_log(LOG_NOTICE, "%s", text); Py_END_ALLOW_THREADS + PyMem_Free(text); Py_RETURN_NONE; } static PyObject *cpy_info(PyObject *self, PyObject *args) { - const char *text; + char *text; if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL; Py_BEGIN_ALLOW_THREADS plugin_log(LOG_INFO, "%s", text); Py_END_ALLOW_THREADS + PyMem_Free(text); Py_RETURN_NONE; } static PyObject *cpy_debug(PyObject *self, PyObject *args) { #ifdef COLLECT_DEBUG - const char *text; + char *text; if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL; Py_BEGIN_ALLOW_THREADS plugin_log(LOG_DEBUG, "%s", text); Py_END_ALLOW_THREADS + PyMem_Free(text); #endif Py_RETURN_NONE; } @@ -725,7 +766,7 @@ static PyObject *cpy_unregister_generic(cpy_callback_t **list_head, PyObject *ar for (tmp = *list_head; tmp; prev = tmp, tmp = tmp->next) if (strcmp(name, tmp->name) == 0) break; - + Py_DECREF(arg); if (tmp == NULL) { PyErr_Format(PyExc_RuntimeError, "Unable to unregister %s callback '%s'.", desc, name); @@ -922,7 +963,7 @@ static int cpy_init(void) { pthread_sigmask(SIG_BLOCK, &sigset, NULL); state = PyEval_SaveThread(); if (do_interactive) { - if (pthread_create(&thread, NULL, cpy_interactive, NULL)) { + if (plugin_thread_create(&thread, NULL, cpy_interactive, NULL)) { ERROR("python: Error creating thread for interactive interpreter."); } } @@ -976,19 +1017,10 @@ PyMODINIT_FUNC PyInit_collectd(void) { } #endif -static int cpy_config(oconfig_item_t *ci) { - int i; +static int cpy_init_python(void) { char *argv = ""; - PyObject *sys, *tb; - PyObject *sys_path; + PyObject *sys; PyObject *module; - - /* Ok in theory we shouldn't do initialization at this point - * but we have to. In order to give python scripts a chance - * to register a config callback we need to be able to execute - * python code during the config callback so we have to start - * the interpreter here. */ - /* Do *not* use the python "thread" module at this point! */ #ifdef IS_PY3K /* Add a builtin module, before Py_Initialize */ @@ -1039,6 +1071,22 @@ static int cpy_config(oconfig_item_t *ci) { PyModule_AddIntConstant(module, "NOTIF_FAILURE", NOTIF_FAILURE); PyModule_AddIntConstant(module, "NOTIF_WARNING", NOTIF_WARNING); PyModule_AddIntConstant(module, "NOTIF_OKAY", NOTIF_OKAY); + return 0; +} + +static int cpy_config(oconfig_item_t *ci) { + int i; + PyObject *tb; + + /* Ok in theory we shouldn't do initialization at this point + * but we have to. In order to give python scripts a chance + * to register a config callback we need to be able to execute + * python code during the config callback so we have to start + * the interpreter here. */ + /* Do *not* use the python "thread" module at this point! */ + + if (!Py_IsInitialized() && cpy_init_python()) return 1; + for (i = 0; i < ci->children_num; ++i) { oconfig_item_t *item = ci->children + i; @@ -1138,7 +1186,6 @@ static int cpy_config(oconfig_item_t *ci) { WARNING("python plugin: Ignoring unknown config key \"%s\".", item->key); } } - Py_DECREF(sys_path); return 0; }