X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fpython.c;h=4a828b44c6352c6a3be8c5757b2cc6ddebafb96f;hb=4ecefb9fb8183eadee48538553615c0425e51f69;hp=00516fb24180c40a99b1cb924c4fb4a7291631f2;hpb=ff8390d53b08dd36f8b0c5f4e530fe7ea9f21b90;p=collectd.git diff --git a/src/python.c b/src/python.c index 00516fb2..4a828b44 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; @@ -335,7 +335,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; + PyObject *ret, *list, *temp, *dict = NULL, *val; Values *v; CPY_LOCK_THREADS @@ -345,32 +345,33 @@ 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; } if (PyErr_Occurred() != NULL) { cpy_log_exception("value building for write callback"); + Py_DECREF(list); CPY_RETURN_FROM_THREADS 0; } } @@ -427,17 +428,21 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li } free(table); } - v = PyObject_New(Values, (void *) &ValuesType); + val = Values_New(); /* New reference. */ + v = (Values *) val; 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)); sstrncpy(v->data.plugin, value_list->plugin, sizeof(v->data.plugin)); sstrncpy(v->data.plugin_instance, value_list->plugin_instance, sizeof(v->data.plugin_instance)); - v->data.time = value_list->time; - v->interval = value_list->interval; + v->data.time = CDTIME_T_TO_DOUBLE(value_list->time); + v->interval = CDTIME_T_TO_DOUBLE(value_list->interval); + Py_CLEAR(v->values); v->values = list; + Py_CLEAR(v->meta); v->meta = dict; ret = PyObject_CallFunctionObjArgs(c->callback, v, c->data, (void *) 0); /* New reference. */ + Py_XDECREF(val); if (ret == NULL) { cpy_log_exception("write callback"); } else { @@ -449,20 +454,22 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li static int cpy_notification_callback(const notification_t *notification, user_data_t *data) { cpy_callback_t *c = data->data; - PyObject *ret; + PyObject *ret, *notify; Notification *n; CPY_LOCK_THREADS - n = PyObject_New(Notification, (void *) &NotificationType); + notify = Notification_New(); /* New reference. */ + n = (Notification *) notify; sstrncpy(n->data.host, notification->host, sizeof(n->data.host)); sstrncpy(n->data.type, notification->type, sizeof(n->data.type)); sstrncpy(n->data.type_instance, notification->type_instance, sizeof(n->data.type_instance)); sstrncpy(n->data.plugin, notification->plugin, sizeof(n->data.plugin)); sstrncpy(n->data.plugin_instance, notification->plugin_instance, sizeof(n->data.plugin_instance)); - n->data.time = notification->time; + n->data.time = CDTIME_T_TO_DOUBLE(notification->time); sstrncpy(n->message, notification->message, sizeof(n->message)); n->severity = notification->severity; ret = PyObject_CallFunctionObjArgs(c->callback, n, c->data, (void *) 0); /* New reference. */ + Py_XDECREF(notify); if (ret == NULL) { cpy_log_exception("notification callback"); } else { @@ -896,6 +903,11 @@ static int cpy_init(void) { static pthread_t thread; sigset_t sigset; + if (!Py_IsInitialized()) { + WARNING("python: Plugin loaded but not configured."); + plugin_unregister_shutdown("python"); + return 0; + } PyEval_InitThreads(); /* Now it's finally OK to use python threads. */ for (c = cpy_init_callbacks; c; c = c->next) { @@ -964,18 +976,10 @@ PyMODINIT_FUNC PyInit_collectd(void) { } #endif -static int cpy_config(oconfig_item_t *ci) { - int i; - PyObject *sys, *tb; - PyObject *sys_path; +static int cpy_init_python() { + char *argv = ""; + 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 */ @@ -1005,6 +1009,9 @@ static int cpy_config(oconfig_item_t *ci) { cpy_log_exception("python initialization"); return 1; } + PySys_SetArgv(1, &argv); + PyList_SetSlice(sys_path, 0, 1, NULL); + #ifdef IS_PY3K module = PyImport_ImportModule("collectd"); #else @@ -1023,6 +1030,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; @@ -1122,7 +1145,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; }