X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fpython.c;h=1ed6dc0165b0c5477b55d7c05f2f77eba8a8c261;hb=d0540d2ebaead6661de0ef29c0435c046c7ff4f7;hp=622160a572d4286f374063038b9f55ed6270fbc4;hpb=27cd1bfc12b4c3c81ccd2d3f2cc1f6ef5028a94f;p=collectd.git diff --git a/src/python.c b/src/python.c index 622160a5..1ed6dc01 100644 --- a/src/python.c +++ b/src/python.c @@ -21,7 +21,7 @@ * DEALINGS IN THE SOFTWARE. * * Authors: - * Sven Trenkel + * Sven Trenkel **/ #include @@ -46,6 +46,19 @@ typedef struct cpy_callback_s { static char log_doc[] = "This function sends a string to all logging plugins."; +static char get_ds_doc[] = "get_dataset(name) -> definition\n" + "\n" + "Returns the definition of a dataset specified by name.\n" + "\n" + "'name' is a string specifying the dataset to query.\n" + "'definition' is a list of 4-tuples. Every tuple represents a \n" + " data source within the data set and its 4 values are the \n" + " name, type, min and max value.\n" + " 'name' is a string.\n" + " 'type' is a string that is equal to either DS_TYPE_COUNTER,\n" + " DS_TYPE_GAUGE, DS_TYPE_DERIVE or DS_TYPE_ABSOLUTE.\n" + " 'min' and 'max' are either a float or None."; + static char flush_doc[] = "flush([plugin][, timeout][, identifier]) -> None\n" "\n" "Flushes the cache of another plugin."; @@ -217,7 +230,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; @@ -237,16 +250,16 @@ static void cpy_destroy_user_data(void *data) { static void cpy_build_name(char *buf, size_t size, PyObject *callback, const char *name) { const char *module = NULL; PyObject *mod = NULL; - + if (name != NULL) { snprintf(buf, size, "python.%s", name); return; } - + mod = PyObject_GetAttrString(callback, "__module__"); /* New reference. */ if (mod != NULL) - module = PyString_AsString(mod); - + module = cpy_unicode_or_bytes_to_string(&mod); + if (module != NULL) { snprintf(buf, size, "python.%s", module); Py_XDECREF(mod); @@ -254,25 +267,25 @@ static void cpy_build_name(char *buf, size_t size, PyObject *callback, const cha return; } Py_XDECREF(mod); - + snprintf(buf, size, "python.%p", callback); PyErr_Clear(); } -static void cpy_log_exception(const char *context) { +void cpy_log_exception(const char *context) { int l = 0, i; const char *typename = NULL, *message = NULL; PyObject *type, *value, *traceback, *tn, *m, *list; - + PyErr_Fetch(&type, &value, &traceback); PyErr_NormalizeException(&type, &value, &traceback); if (type == NULL) return; tn = PyObject_GetAttrString(type, "__name__"); /* New reference. */ - m = PyObject_GetAttrString(value, "message"); /* New reference. */ + m = PyObject_Str(value); /* New reference. */ if (tn != NULL) - typename = PyString_AsString(tn); + typename = cpy_unicode_or_bytes_to_string(&tn); if (m != NULL) - message = PyString_AsString(m); + message = cpy_unicode_or_bytes_to_string(&m); if (typename == NULL) typename = "NamelessException"; if (message == NULL) @@ -282,33 +295,44 @@ static 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. */ - s = strdup(PyString_AsString(line)); - if (s[strlen(s) - 1] == '\n') - s[strlen(s) - 1] = 0; + Py_INCREF(line); + + msg = cpy_unicode_or_bytes_to_string(&line); + Py_DECREF(line); + 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(); } @@ -331,9 +355,10 @@ 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; + size_t i; cpy_callback_t *c = data->data; - PyObject *ret, *v, *list; + PyObject *ret, *list, *temp, *dict = NULL; + Values *v; CPY_LOCK_THREADS list = PyList_New(value_list->values_len); /* New reference. */ @@ -343,22 +368,13 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li } for (i = 0; i < value_list->values_len; ++i) { 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)); + PyList_SetItem(list, i, PyLong_FromUnsignedLongLong(value_list->values[i].counter)); } else if (ds->ds[i].type == DS_TYPE_GAUGE) { PyList_SetItem(list, i, PyFloat_FromDouble(value_list->values[i].gauge)); } 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)); + PyList_SetItem(list, i, PyLong_FromLongLong(value_list->values[i].derive)); } 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)); + 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[i].type); @@ -372,11 +388,71 @@ static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_li CPY_RETURN_FROM_THREADS 0; } } - v = PyObject_CallFunction((void *) &ValuesType, "sOssssdi", value_list->type, - list, value_list->plugin_instance, value_list->type_instance, - value_list->plugin, value_list->host, (double) value_list->time, - value_list->interval); /* New reference. */ - Py_DECREF(list); + dict = PyDict_New(); /* New reference. */ + if (value_list->meta) { + int num; + char **table; + meta_data_t *meta = value_list->meta; + + num = meta_data_toc(meta, &table); + for (i = 0; i < num; ++i) { + int type; + char *string; + int64_t si; + uint64_t ui; + double d; + _Bool b; + + type = meta_data_type(meta, table[i]); + if (type == MD_TYPE_STRING) { + if (meta_data_get_string(meta, table[i], &string)) + continue; + 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); /* 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); /* 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); /* New reference. */ + PyDict_SetItemString(dict, table[i], temp); + Py_XDECREF(temp); + } else if (type == MD_TYPE_BOOLEAN) { + if (meta_data_get_boolean(meta, table[i], &b)) + continue; + if (b) + PyDict_SetItemString(dict, table[i], Py_True); + else + PyDict_SetItemString(dict, table[i], Py_False); + } + free(table[i]); + } + free(table); + } + 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)); + 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 = 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; /* Steals a reference. */ ret = PyObject_CallFunctionObjArgs(c->callback, v, c->data, (void *) 0); /* New reference. */ Py_XDECREF(v); if (ret == NULL) { @@ -390,14 +466,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, *n; + PyObject *ret, *notify; + Notification *n; CPY_LOCK_THREADS - n = PyObject_CallFunction((void *) &NotificationType, "ssssssdi", notification->type, notification->message, - notification->plugin_instance, notification->type_instance, notification->plugin, - notification->host, (double) notification->time, notification->severity); /* New reference. */ + 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 = 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(n); + Py_XDECREF(notify); if (ret == NULL) { cpy_log_exception("notification callback"); } else { @@ -409,13 +493,14 @@ static int cpy_notification_callback(const notification_t *notification, user_da static void cpy_log_callback(int severity, const char *message, user_data_t *data) { cpy_callback_t * c = data->data; - PyObject *ret; + PyObject *ret, *text; CPY_LOCK_THREADS + text = cpy_string_to_unicode_or_bytes(message); /* New reference. */ if (c->data == NULL) - ret = PyObject_CallFunction(c->callback, "is", severity, message); /* New reference. */ + ret = PyObject_CallFunction(c->callback, "iN", severity, text); /* New reference. Steals a reference from "text". */ else - ret = PyObject_CallFunction(c->callback, "isO", severity, message, 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 */ @@ -432,13 +517,14 @@ static void cpy_log_callback(int severity, const char *message, user_data_t *dat static void cpy_flush_callback(int timeout, const char *id, user_data_t *data) { cpy_callback_t * c = data->data; - PyObject *ret; + PyObject *ret, *text; CPY_LOCK_THREADS + text = cpy_string_to_unicode_or_bytes(id); if (c->data == NULL) - ret = PyObject_CallFunction(c->callback, "is", timeout, id); /* New reference. */ + ret = PyObject_CallFunction(c->callback, "iN", timeout, text); /* New reference. */ else - ret = PyObject_CallFunction(c->callback, "isO", timeout, id, c->data); /* New reference. */ + ret = PyObject_CallFunction(c->callback, "iNO", timeout, text, c->data); /* New reference. */ if (ret == NULL) { cpy_log_exception("flush callback"); @@ -451,12 +537,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|Oz", kwlist, &callback, &data, &name) == 0) return 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; } @@ -464,25 +551,64 @@ static PyObject *cpy_register_generic(cpy_callback_t **list_head, PyObject *args Py_INCREF(callback); Py_XINCREF(data); - c = malloc(sizeof(*c)); + + c = calloc(1, sizeof(*c)); + if (c == NULL) + return NULL; + c->name = strdup(buf); c->callback = callback; c->data = data; c->next = *list_head; *list_head = c; Py_XDECREF(mod); - return PyString_FromString(buf); + PyMem_Free(name); + return cpy_string_to_unicode_or_bytes(buf); } -static PyObject *cpy_flush(cpy_callback_t **list_head, PyObject *args, PyObject *kwds) { +static PyObject *float_or_none(float number) { + if (isnan(number)) { + Py_RETURN_NONE; + } + return PyFloat_FromDouble(number); +} + +static PyObject *cpy_get_dataset(PyObject *self, PyObject *args) { + size_t i; + char *name; + const data_set_t *ds; + PyObject *list, *tuple; + + if (PyArg_ParseTuple(args, "et", NULL, &name) == 0) return NULL; + ds = plugin_get_ds(name); + PyMem_Free(name); + if (ds == NULL) { + PyErr_Format(PyExc_TypeError, "Dataset %s not found", name); + return NULL; + } + list = PyList_New(ds->ds_num); /* New reference. */ + for (i = 0; i < ds->ds_num; ++i) { + tuple = PyTuple_New(4); + PyTuple_SET_ITEM(tuple, 0, cpy_string_to_unicode_or_bytes(ds->ds[i].name)); + PyTuple_SET_ITEM(tuple, 1, cpy_string_to_unicode_or_bytes(DS_TYPE_TO_STRING(ds->ds[i].type))); + PyTuple_SET_ITEM(tuple, 2, float_or_none(ds->ds[i].min)); + PyTuple_SET_ITEM(tuple, 3, float_or_none(ds->ds[i].max)); + PyList_SET_ITEM(list, i, tuple); + } + return list; +} + +static PyObject *cpy_flush(PyObject *self, 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, "|ziz", kwlist, &plugin, &timeout, &identifier) == 0) return 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; } @@ -500,63 +626,77 @@ 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|Oz", kwlist, &callback, &data, &name) == 0) return 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)); + + c = calloc(1, sizeof(*c)); + if (c == NULL) + return NULL; + 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); - return PyString_FromString(buf); + + 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|dOz", kwlist, &callback, &interval, &data, &name) == 0) return 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)); + + c = calloc(1, sizeof(*c)); + if (c == NULL) + return NULL; + 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; - ts.tv_sec = interval; - ts.tv_nsec = (interval - ts.tv_sec) * 1000000000; - plugin_register_complex_read(buf, cpy_read_callback, &ts, user_data); - return PyString_FromString(buf); + + memset (&user_data, 0, sizeof (user_data)); + user_data.free_func = cpy_destroy_user_data; + user_data.data = c; + + plugin_register_complex_read(/* group = */ "python", buf, + cpy_read_callback, DOUBLE_TO_CDTIME_T (interval), &user_data); + return cpy_string_to_unicode_or_bytes(buf); } static PyObject *cpy_register_log(PyObject *self, PyObject *args, PyObject *kwds) { @@ -584,48 +724,53 @@ static PyObject *cpy_register_shutdown(PyObject *self, PyObject *args, PyObject } static PyObject *cpy_error(PyObject *self, PyObject *args) { - const char *text; - if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL; + 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; - if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL; + 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; - if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL; + 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; - if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL; + 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; - if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL; + 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; } @@ -635,17 +780,13 @@ static PyObject *cpy_unregister_generic(cpy_callback_t **list_head, PyObject *ar const char *name; cpy_callback_t *prev = NULL, *tmp; - if (PyUnicode_Check(arg)) { - arg = PyUnicode_AsEncodedString(arg, NULL, NULL); - if (arg == NULL) - return NULL; - name = PyString_AsString(arg); - Py_DECREF(arg); - } else if (PyString_Check(arg)) { - name = PyString_AsString(arg); - } else { + Py_INCREF(arg); + name = cpy_unicode_or_bytes_to_string(&arg); + if (name == NULL) { + PyErr_Clear(); if (!PyCallable_Check(arg)) { PyErr_SetString(PyExc_TypeError, "This function needs a string or a callable object as its only parameter."); + Py_DECREF(arg); return NULL; } cpy_build_name(buf, sizeof(buf), arg, NULL); @@ -654,7 +795,8 @@ 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); return NULL; @@ -675,25 +817,24 @@ static PyObject *cpy_unregister_generic_userdata(cpy_unregister_function_t *unre char buf[512]; const char *name; - if (PyUnicode_Check(arg)) { - arg = PyUnicode_AsEncodedString(arg, NULL, NULL); - if (arg == NULL) - return NULL; - name = PyString_AsString(arg); - Py_DECREF(arg); - } else if (PyString_Check(arg)) { - name = PyString_AsString(arg); - } else { + Py_INCREF(arg); + name = cpy_unicode_or_bytes_to_string(&arg); + if (name == NULL) { + PyErr_Clear(); if (!PyCallable_Check(arg)) { PyErr_SetString(PyExc_TypeError, "This function needs a string or a callable object as its only parameter."); + Py_DECREF(arg); return NULL; } cpy_build_name(buf, sizeof(buf), arg, NULL); name = buf; } - if (unreg(name) == 0) + if (unreg(name) == 0) { + Py_DECREF(arg); Py_RETURN_NONE; + } PyErr_Format(PyExc_RuntimeError, "Unable to unregister %s callback '%s'.", desc, name); + Py_DECREF(arg); return NULL; } @@ -735,6 +876,7 @@ static PyMethodDef cpy_methods[] = { {"notice", cpy_notice, METH_VARARGS, log_doc}, {"warning", cpy_warning, METH_VARARGS, log_doc}, {"error", cpy_error, METH_VARARGS, log_doc}, + {"get_dataset", (PyCFunction) cpy_get_dataset, METH_VARARGS, get_ds_doc}, {"flush", (PyCFunction) cpy_flush, METH_VARARGS | METH_KEYWORDS, flush_doc}, {"register_log", (PyCFunction) cpy_register_log, METH_VARARGS | METH_KEYWORDS, reg_log_doc}, {"register_init", (PyCFunction) cpy_register_init, METH_VARARGS | METH_KEYWORDS, reg_init_doc}, @@ -758,7 +900,7 @@ static PyMethodDef cpy_methods[] = { static int cpy_shutdown(void) { cpy_callback_t *c; PyObject *ret; - + /* This can happen if the module was loaded but not configured. */ if (state != NULL) PyEval_RestoreThread(state); @@ -782,14 +924,14 @@ static void cpy_int_handler(int sig) { static void *cpy_interactive(void *data) { sigset_t sigset; struct sigaction sig_int_action, old; - + /* Signal handler in a plugin? Bad stuff, but the best way to * handle it I guess. In an interactive session people will * press Ctrl+C at some time, which will generate a SIGINT. * This will cause collectd to shutdown, thus killing the * interactive interpreter, and leaving the terminal in a * mess. Chances are, this isn't what the user wanted to do. - * + * * So this is the plan: * 1. Block SIGINT in the main thread. * 2. Install our own signal handler that does nothing. @@ -802,7 +944,7 @@ static void *cpy_interactive(void *data) { memset (&sig_int_action, '\0', sizeof (sig_int_action)); sig_int_action.sa_handler = cpy_int_handler; sigaction (SIGINT, &sig_int_action, &old); - + sigemptyset(&sigset); sigaddset(&sigset, SIGINT); pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); @@ -831,7 +973,7 @@ static int cpy_init(void) { PyObject *ret; static pthread_t thread; sigset_t sigset; - + if (!Py_IsInitialized()) { WARNING("python: Plugin loaded but not configured."); plugin_unregister_shutdown("python"); @@ -851,7 +993,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."); } } @@ -862,22 +1004,23 @@ static int cpy_init(void) { static PyObject *cpy_oconfig_to_pyconfig(oconfig_item_t *ci, PyObject *parent) { int i; PyObject *item, *values, *children, *tmp; - + if (parent == NULL) parent = Py_None; - + values = PyTuple_New(ci->values_num); /* New reference. */ for (i = 0; i < ci->values_num; ++i) { if (ci->values[i].type == OCONFIG_TYPE_STRING) { - PyTuple_SET_ITEM(values, i, PyString_FromString(ci->values[i].value.string)); + PyTuple_SET_ITEM(values, i, cpy_string_to_unicode_or_bytes(ci->values[i].value.string)); } else if (ci->values[i].type == OCONFIG_TYPE_NUMBER) { PyTuple_SET_ITEM(values, i, PyFloat_FromDouble(ci->values[i].value.number)); } else if (ci->values[i].type == OCONFIG_TYPE_BOOLEAN) { PyTuple_SET_ITEM(values, i, PyBool_FromLong(ci->values[i].value.boolean)); } } - - item = PyObject_CallFunction((void *) &ConfigType, "sONO", ci->key, parent, values, Py_None); + + tmp = cpy_string_to_unicode_or_bytes(ci->key); + item = PyObject_CallFunction((void *) &ConfigType, "NONO", tmp, parent, values, Py_None); if (item == NULL) return NULL; children = PyTuple_New(ci->children_num); /* New reference. */ @@ -890,27 +1033,44 @@ static PyObject *cpy_oconfig_to_pyconfig(oconfig_item_t *ci, PyObject *parent) { return item; } -static int cpy_config(oconfig_item_t *ci) { - int i; - char *argv = ""; - PyObject *sys, *tb; - PyObject *sys_path; +#ifdef IS_PY3K +static struct PyModuleDef collectdmodule = { + PyModuleDef_HEAD_INIT, + "collectd", /* name of module */ + "The python interface to collectd", /* module documentation, may be NULL */ + -1, + cpy_methods +}; + +PyMODINIT_FUNC PyInit_collectd(void) { + return PyModule_Create(&collectdmodule); +} +#endif + +static int cpy_init_python(void) { + 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 + wchar_t *argv = L""; + /* Add a builtin module, before Py_Initialize */ + PyImport_AppendInittab("collectd", PyInit_collectd); +#else + char *argv = ""; +#endif + Py_Initialize(); - + PyType_Ready(&ConfigType); PyType_Ready(&PluginDataType); ValuesType.tp_base = &PluginDataType; PyType_Ready(&ValuesType); NotificationType.tp_base = &PluginDataType; PyType_Ready(&NotificationType); + SignedType.tp_base = &PyLong_Type; + PyType_Ready(&SignedType); + UnsignedType.tp_base = &PyLong_Type; + PyType_Ready(&UnsignedType); sys = PyImport_ImportModule("sys"); /* New reference. */ if (sys == NULL) { cpy_log_exception("python initialization"); @@ -925,10 +1085,16 @@ static int cpy_config(oconfig_item_t *ci) { PySys_SetArgv(1, &argv); PyList_SetSlice(sys_path, 0, 1, NULL); +#ifdef IS_PY3K + module = PyImport_ImportModule("collectd"); +#else module = Py_InitModule("collectd", cpy_methods); /* Borrowed reference. */ +#endif PyModule_AddObject(module, "Config", (void *) &ConfigType); /* Steals a reference. */ PyModule_AddObject(module, "Values", (void *) &ValuesType); /* Steals a reference. */ PyModule_AddObject(module, "Notification", (void *) &NotificationType); /* Steals a reference. */ + PyModule_AddObject(module, "Signed", (void *) &SignedType); /* Steals a reference. */ + PyModule_AddObject(module, "Unsigned", (void *) &UnsignedType); /* Steals a reference. */ PyModule_AddIntConstant(module, "LOG_DEBUG", LOG_DEBUG); PyModule_AddIntConstant(module, "LOG_INFO", LOG_INFO); PyModule_AddIntConstant(module, "LOG_NOTICE", LOG_NOTICE); @@ -937,9 +1103,29 @@ 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); + PyModule_AddStringConstant(module, "DS_TYPE_COUNTER", DS_TYPE_TO_STRING(DS_TYPE_COUNTER)); + PyModule_AddStringConstant(module, "DS_TYPE_GAUGE", DS_TYPE_TO_STRING(DS_TYPE_GAUGE)); + PyModule_AddStringConstant(module, "DS_TYPE_DERIVE", DS_TYPE_TO_STRING(DS_TYPE_DERIVE)); + PyModule_AddStringConstant(module, "DS_TYPE_ABSOLUTE", DS_TYPE_TO_STRING(DS_TYPE_ABSOLUTE)); + 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; - + if (strcasecmp(item->key, "Interactive") == 0) { if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) continue; @@ -947,9 +1133,13 @@ static int cpy_config(oconfig_item_t *ci) { } else if (strcasecmp(item->key, "Encoding") == 0) { if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_STRING) continue; +#ifdef IS_PY3K + NOTICE("python: \"Encoding\" was used in the config file but Python3 was used, which does not support changing encodings. Ignoring this."); +#else /* Why is this even necessary? And undocumented? */ if (PyUnicode_SetDefaultEncoding(item->values[0].value.string)) cpy_log_exception("setting default encoding"); +#endif } else if (strcasecmp(item->key, "LogTraces") == 0) { if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) continue; @@ -972,10 +1162,10 @@ static int cpy_config(oconfig_item_t *ci) { } else if (strcasecmp(item->key, "ModulePath") == 0) { char *dir = NULL; PyObject *dir_object; - - if (cf_util_get_string(item, &dir) != 0) + + if (cf_util_get_string(item, &dir) != 0) continue; - dir_object = PyString_FromString(dir); /* New reference. */ + dir_object = cpy_string_to_unicode_or_bytes(dir); /* New reference. */ if (dir_object == NULL) { ERROR("python plugin: Unable to convert \"%s\" to " "a python object.", dir); @@ -983,8 +1173,8 @@ static int cpy_config(oconfig_item_t *ci) { cpy_log_exception("python initialization"); continue; } - if (PyList_Append(sys_path, dir_object) != 0) { - ERROR("python plugin: Unable to append \"%s\" to " + if (PyList_Insert(sys_path, 0, dir_object) != 0) { + ERROR("python plugin: Unable to prepend \"%s\" to " "python module path.", dir); cpy_log_exception("python initialization"); } @@ -993,14 +1183,13 @@ static int cpy_config(oconfig_item_t *ci) { } else if (strcasecmp(item->key, "Import") == 0) { char *module_name = NULL; PyObject *module; - - if (cf_util_get_string(item, &module_name) != 0) + + if (cf_util_get_string(item, &module_name) != 0) continue; module = PyImport_ImportModule(module_name); /* New reference. */ if (module == NULL) { ERROR("python plugin: Error importing module \"%s\".", module_name); cpy_log_exception("importing module"); - PyErr_Print(); } free(module_name); Py_XDECREF(module); @@ -1008,7 +1197,7 @@ static int cpy_config(oconfig_item_t *ci) { char *name = NULL; cpy_callback_t *c; PyObject *ret; - + if (cf_util_get_string(item, &name) != 0) continue; for (c = cpy_config_callbacks; c; c = c->next) { @@ -1037,7 +1226,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; }