#include <Python.h>
#include <structmember.h>
+#if HAVE_PTHREAD_H
+# include <pthread.h>
+#endif
+
#include "collectd.h"
#include "common.h"
struct cpy_callback_s *next;
} cpy_callback_t;
+static int do_interactive = 0;
+
/* This is our global thread state. Python saves some stuff in thread-local
* storage. So if we allow the interpreter to run in the background
* (the scriptwriters might have created some threads from python), we have
static PyThreadState *state;
+static PyObject *cpy_format_exception;
+
static cpy_callback_t *cpy_config_callbacks;
static cpy_callback_t *cpy_init_callbacks;
static cpy_callback_t *cpy_shutdown_callbacks;
/* You must hold the GIL to call this function!
* But if you managed to extract the callback parameter then you probably already do. */
-static void cpy_build_name(char *buf, size_t size, PyObject *callback, const char *name) {
+static void cpy_build_name(char *buf, size_t size, PyObject *callback, const char *name, int short_name) {
const char *module;
PyObject *mod = NULL, *n = NULL;
- if (name != NULL && strchr(name, '.') != NULL) {
+ if (name != NULL && (strchr(name, '.') != NULL || short_name)) {
snprintf(buf, size, "python.%s", name);
return;
}
module = PyString_AsString(mod);
else
module = "collectd";
+
+ if (short_name) {
+ snprintf(buf, size, "python.%s", module);
+ Py_XDECREF(mod);
+ return;
+ }
+
if (name != NULL) {
snprintf(buf, size, "python.%s.%s", module, name);
Py_XDECREF(mod);
Py_XDECREF(n);
}
+static 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. */
+ if (tn != NULL)
+ typename = PyString_AsString(tn);
+ if (m != NULL)
+ message = PyString_AsString(m);
+ if (typename == NULL)
+ typename = "NamelessException";
+ if (message == NULL)
+ message = "N/A";
+ ERROR("Unhandled python exception in %s: %s: %s", context, typename, message);
+ Py_XDECREF(tn);
+ Py_XDECREF(m);
+ if (!cpy_format_exception) {
+ PyErr_Clear();
+ Py_XDECREF(type);
+ Py_XDECREF(value);
+ Py_XDECREF(traceback);
+ return;
+ }
+ if (!traceback) {
+ PyErr_Clear();
+ return;
+ }
+ list = PyObject_CallFunction(cpy_format_exception, "NNN", type, value, traceback);
+ if (list)
+ l = PyObject_Length(list);
+ for (i = 0; i < l; ++i) {
+ char *s;
+ PyObject *line;
+
+ line = PyList_GET_ITEM(list, i);
+ s = strdup(PyString_AsString(line));
+ Py_DECREF(line);
+ if (s[strlen(s) - 1] == '\n')
+ s[strlen(s) - 1] = 0;
+ ERROR("%s", s);
+ free(s);
+ }
+ PyErr_Clear();
+}
+
static int cpy_read_callback(user_data_t *data) {
cpy_callback_t *c = data->data;
PyObject *ret;
CPY_LOCK_THREADS
- if (c->data == NULL)
- ret = PyObject_CallFunctionObjArgs(c->callback, (void *) 0);
- else
- ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0);
+ ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
if (ret == NULL) {
- /* FIXME */
- PyErr_Print();
+ cpy_log_exception("read callback");
} else {
Py_DECREF(ret);
}
CPY_LOCK_THREADS
list = PyList_New(value_list->values_len); /* New reference. */
if (list == NULL) {
- PyErr_Print();
+ cpy_log_exception("write callback");
CPY_RETURN_FROM_THREADS 0;
}
for (i = 0; i < value_list->values_len; ++i) {
CPY_RETURN_FROM_THREADS 0;
}
if (PyErr_Occurred() != NULL) {
- PyErr_Print();
+ cpy_log_exception("value building for write callback");
CPY_RETURN_FROM_THREADS 0;
}
}
value_list->plugin_instance, value_list->type_instance, value_list->plugin,
value_list->host, (double) value_list->time, value_list->interval);
Py_DECREF(list);
- if (c->data == NULL)
- ret = PyObject_CallFunctionObjArgs(c->callback, v, (void *) 0);
- else
- ret = PyObject_CallFunctionObjArgs(c->callback, v, c->data, (void *) 0);
+ ret = PyObject_CallFunctionObjArgs(c->callback, v, c->data, (void *) 0); /* New reference. */
if (ret == NULL) {
- /* FIXME */
- PyErr_Print();
+ cpy_log_exception("write callback");
} else {
Py_DECREF(ret);
}
if (ret == NULL) {
/* FIXME */
+ /* Do we really want to trigger a log callback because a log callback failed?
+ * Probably not. */
PyErr_Print();
} else {
Py_DECREF(ret);
CPY_RELEASE_THREADS
}
-static PyObject *cpy_register_generic(cpy_callback_t **list_head, PyObject *args, PyObject *kwds) {
+static void cpy_flush_callback(int timeout, const char *id, user_data_t *data) {
+ cpy_callback_t * c = data->data;
+ PyObject *ret;
+
+ CPY_LOCK_THREADS
+ if (c->data == NULL)
+ ret = PyObject_CallFunction(c->callback, "is", timeout, id); /* New reference. */
+ else
+ ret = PyObject_CallFunction(c->callback, "isO", timeout, id, c->data); /* New reference. */
+
+ if (ret == NULL) {
+ cpy_log_exception("flush callback");
+ } else {
+ Py_DECREF(ret);
+ }
+ CPY_RELEASE_THREADS
+}
+
+static PyObject *cpy_register_generic(cpy_callback_t **list_head, PyObject *args, PyObject *kwds, int short_name) {
+ char buf[512];
cpy_callback_t *c;
const char *name = NULL;
PyObject *callback = NULL, *data = NULL, *mod = NULL;
PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object.");
return NULL;
}
- if (name == NULL) {
- mod = PyObject_GetAttrString(callback, "__module__"); /* New reference. */
- if (mod != NULL) name = PyString_AsString(mod);
- if (name == NULL) {
- Py_XDECREF(mod);
- PyErr_SetString(PyExc_ValueError, "No module name specified and "
- "callback function does not have a \"__module__\" attribute.");
- return NULL;
- }
- }
+ cpy_build_name(buf, sizeof(buf), callback, name, short_name);
+
Py_INCREF(callback);
Py_XINCREF(data);
c = malloc(sizeof(*c));
- c->name = strdup(name);
+ c->name = strdup(buf);
c->callback = callback;
c->data = data;
c->next = *list_head;
*list_head = c;
Py_XDECREF(mod);
+ return PyString_FromString(buf);
+}
+
+static PyObject *cpy_flush(cpy_callback_t **list_head, PyObject *args, PyObject *kwds) {
+ int timeout = -1;
+ const 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;
+ Py_BEGIN_ALLOW_THREADS
+ plugin_flush(plugin, timeout, identifier);
+ Py_END_ALLOW_THREADS
Py_RETURN_NONE;
}
static PyObject *cpy_register_config(PyObject *self, PyObject *args, PyObject *kwds) {
- return cpy_register_generic(&cpy_config_callbacks, args, kwds);
+ return cpy_register_generic(&cpy_config_callbacks, args, kwds, 1);
}
static PyObject *cpy_register_init(PyObject *self, PyObject *args, PyObject *kwds) {
- return cpy_register_generic(&cpy_init_callbacks, args, kwds);
+ return cpy_register_generic(&cpy_init_callbacks, args, kwds, 0);
}
typedef int reg_function_t(const char *name, void *callback, void *data);
-static PyObject *cpy_register_generic_userdata(void *reg, void *handler, PyObject *args, PyObject *kwds) {
+static PyObject *cpy_register_generic_userdata(void *reg, void *handler, PyObject *args, PyObject *kwds, int short_name) {
char buf[512];
reg_function_t *register_function = (reg_function_t *) reg;
cpy_callback_t *c = NULL;
PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object.");
return NULL;
}
- cpy_build_name(buf, sizeof(buf), callback, name);
+ cpy_build_name(buf, sizeof(buf), callback, name, short_name);
Py_INCREF(callback);
Py_XINCREF(data);
PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object.");
return NULL;
}
- cpy_build_name(buf, sizeof(buf), callback, name);
+ cpy_build_name(buf, sizeof(buf), callback, name, 0);
Py_INCREF(callback);
Py_XINCREF(data);
}
static PyObject *cpy_register_log(PyObject *self, PyObject *args, PyObject *kwds) {
- return cpy_register_generic_userdata(plugin_register_log, cpy_log_callback, args, kwds);
+ return cpy_register_generic_userdata(plugin_register_log, cpy_log_callback, args, kwds, 0);
}
static PyObject *cpy_register_write(PyObject *self, PyObject *args, PyObject *kwds) {
- return cpy_register_generic_userdata(plugin_register_write, cpy_write_callback, args, kwds);
+ return cpy_register_generic_userdata(plugin_register_write, cpy_write_callback, args, kwds, 0);
+}
+
+static PyObject *cpy_register_flush(PyObject *self, PyObject *args, PyObject *kwds) {
+ return cpy_register_generic_userdata(plugin_register_flush, cpy_flush_callback, args, kwds, 1);
}
static PyObject *cpy_register_shutdown(PyObject *self, PyObject *args, PyObject *kwds) {
- return cpy_register_generic(&cpy_shutdown_callbacks, args, kwds);
+ return cpy_register_generic(&cpy_shutdown_callbacks, args, kwds, 0);
}
-static PyObject *cpy_Error(PyObject *self, PyObject *args) {
+static PyObject *cpy_error(PyObject *self, PyObject *args) {
const char *text;
if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL;
Py_BEGIN_ALLOW_THREADS
Py_RETURN_NONE;
}
-static PyObject *cpy_Warning(PyObject *self, PyObject *args) {
+static PyObject *cpy_warning(PyObject *self, PyObject *args) {
const char *text;
if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL;
Py_BEGIN_ALLOW_THREADS
Py_RETURN_NONE;
}
-static PyObject *cpy_Notice(PyObject *self, PyObject *args) {
+static PyObject *cpy_notice(PyObject *self, PyObject *args) {
const char *text;
if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL;
Py_BEGIN_ALLOW_THREADS
Py_RETURN_NONE;
}
-static PyObject *cpy_Info(PyObject *self, PyObject *args) {
+static PyObject *cpy_info(PyObject *self, PyObject *args) {
const char *text;
if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL;
Py_BEGIN_ALLOW_THREADS
Py_RETURN_NONE;
}
-static PyObject *cpy_Debug(PyObject *self, PyObject *args) {
+static PyObject *cpy_debug(PyObject *self, PyObject *args) {
#ifdef COLLECT_DEBUG
const char *text;
if (PyArg_ParseTuple(args, "s", &text) == 0) return NULL;
Py_RETURN_NONE;
}
+static PyObject *cpy_unregister_generic(cpy_callback_t **list_head, PyObject *arg, const char *desc, int short_name) {
+ char buf[512];
+ const char *name;
+ cpy_callback_t *prev = NULL, *tmp;
+
+ if (PyString_Check(arg)) {
+ name = PyString_AsString(arg);
+ } else {
+ if (!PyCallable_Check(arg)) {
+ PyErr_SetString(PyExc_TypeError, "This function needs a string or a callable object as its only parameter.");
+ return NULL;
+ }
+ cpy_build_name(buf, sizeof(buf), arg, NULL, short_name);
+ name = buf;
+ }
+ for (tmp = *list_head; tmp; prev = tmp, tmp = tmp->next)
+ if (strcmp(name, tmp->name) == 0)
+ break;
+
+ if (tmp == NULL) {
+ PyErr_Format(PyExc_RuntimeError, "Unable to unregister %s callback '%s'.", desc, name);
+ return NULL;
+ }
+ /* Yes, this is actually save. To call this function the calles has to
+ * hold the GIL. Well, save as long as there is only one GIL anyway ... */
+ if (prev == NULL)
+ *list_head = tmp->next;
+ else
+ prev->next = tmp->next;
+ cpy_destroy_user_data(tmp);
+ Py_RETURN_NONE;
+}
+
+typedef int cpy_unregister_function_t(const char *name);
+
+static PyObject *cpy_unregister_generic_userdata(cpy_unregister_function_t *unreg, PyObject *arg, const char *desc, int short_name) {
+ char buf[512];
+ const char *name;
+
+ if (PyString_Check(arg)) {
+ name = PyString_AsString(arg);
+ } else {
+ if (!PyCallable_Check(arg)) {
+ PyErr_SetString(PyExc_TypeError, "This function needs a string or a callable object as its only parameter.");
+ return NULL;
+ }
+ cpy_build_name(buf, sizeof(buf), arg, NULL, short_name);
+ name = buf;
+ }
+ if (unreg(name) == 0)
+ Py_RETURN_NONE;
+ PyErr_Format(PyExc_RuntimeError, "Unable to unregister %s callback '%s'.", desc, name);
+ return NULL;
+}
+
+static PyObject *cpy_unregister_log(PyObject *self, PyObject *arg) {
+ return cpy_unregister_generic_userdata(plugin_unregister_log, arg, "log", 0);
+}
+
+static PyObject *cpy_unregister_init(PyObject *self, PyObject *arg) {
+ return cpy_unregister_generic(&cpy_init_callbacks, arg, "init", 0);
+}
+
+static PyObject *cpy_unregister_config(PyObject *self, PyObject *arg) {
+ return cpy_unregister_generic(&cpy_config_callbacks, arg, "config", 1);
+}
+
+static PyObject *cpy_unregister_read(PyObject *self, PyObject *arg) {
+ return cpy_unregister_generic_userdata(plugin_unregister_read, arg, "read", 0);
+}
+
+static PyObject *cpy_unregister_write(PyObject *self, PyObject *arg) {
+ return cpy_unregister_generic_userdata(plugin_unregister_write, arg, "write", 0);
+}
+
+static PyObject *cpy_unregister_flush(PyObject *self, PyObject *arg) {
+ return cpy_unregister_generic_userdata(plugin_unregister_flush, arg, "flush", 1);
+}
+
+static PyObject *cpy_unregister_shutdown(PyObject *self, PyObject *arg) {
+ return cpy_unregister_generic(&cpy_shutdown_callbacks, arg, "shutdown", 0);
+}
+
static PyMethodDef cpy_methods[] = {
- {"Debug", cpy_Debug, METH_VARARGS, "This is an unhelpful text."},
- {"Info", cpy_Info, METH_VARARGS, "This is an unhelpful text."},
- {"Notice", cpy_Notice, METH_VARARGS, "This is an unhelpful text."},
- {"Warning", cpy_Warning, METH_VARARGS, "This is an unhelpful text."},
- {"Error", cpy_Error, METH_VARARGS, "This is an unhelpful text."},
+ {"debug", cpy_debug, METH_VARARGS, "This is an unhelpful text."},
+ {"info", cpy_info, METH_VARARGS, "This is an unhelpful text."},
+ {"notice", cpy_notice, METH_VARARGS, "This is an unhelpful text."},
+ {"warning", cpy_warning, METH_VARARGS, "This is an unhelpful text."},
+ {"error", cpy_error, METH_VARARGS, "This is an unhelpful text."},
+ {"flush", (PyCFunction) cpy_flush, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
{"register_log", (PyCFunction) cpy_register_log, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
{"register_init", (PyCFunction) cpy_register_init, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
{"register_config", (PyCFunction) cpy_register_config, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
{"register_read", (PyCFunction) cpy_register_read, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
{"register_write", (PyCFunction) cpy_register_write, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
+ {"register_flush", (PyCFunction) cpy_register_flush, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
{"register_shutdown", (PyCFunction) cpy_register_shutdown, METH_VARARGS | METH_KEYWORDS, "This is an unhelpful text."},
+ {"unregister_log", cpy_unregister_log, METH_O, "This is an unhelpful text."},
+ {"unregister_init", cpy_unregister_init, METH_O, "This is an unhelpful text."},
+ {"unregister_config", cpy_unregister_config, METH_O, "This is an unhelpful text."},
+ {"unregister_read", cpy_unregister_read, METH_O, "This is an unhelpful text."},
+ {"unregister_write", cpy_unregister_write, METH_O, "This is an unhelpful text."},
+ {"unregister_flush", cpy_unregister_flush, METH_O, "This is an unhelpful text."},
+ {"unregister_shutdown", cpy_unregister_shutdown, METH_O, "This is an unhelpful text."},
{0, 0, 0, 0}
};
PyEval_RestoreThread(state);
for (c = cpy_shutdown_callbacks; c; c = c->next) {
- if (c->data == NULL)
- ret = PyObject_CallObject(c->callback, NULL); /* New reference. */
- else
- ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
+ ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
if (ret == NULL)
- PyErr_Print(); /* FIXME */
+ cpy_log_exception("shutdown callback");
else
Py_DECREF(ret);
}
return 0;
}
+static void *cpy_interactive(void *data) {
+ CPY_LOCK_THREADS
+ if (PyImport_ImportModule("readline") == NULL) {
+ /* This interactive session will suck. */
+ cpy_log_exception("interactive session init");
+ }
+ PyRun_InteractiveLoop(stdin, "<stdin>");
+ CPY_RELEASE_THREADS
+ NOTICE("python: Interactive interpreter exited, stopping collectd ...");
+ raise(SIGINT);
+ return NULL;
+}
+
static int cpy_init(void) {
cpy_callback_t *c;
PyObject *ret;
+ static pthread_t thread;
PyEval_InitThreads();
/* Now it's finally OK to use python threads. */
for (c = cpy_init_callbacks; c; c = c->next) {
- if (c->data == NULL)
- ret = PyObject_CallObject(c->callback, NULL); /* New reference. */
- else
- ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
+ ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
if (ret == NULL)
- PyErr_Print(); /* FIXME */
+ cpy_log_exception("init callback");
else
Py_DECREF(ret);
}
state = PyEval_SaveThread();
+ if (do_interactive) {
+ if (pthread_create(&thread, NULL, cpy_interactive, NULL)) {
+ ERROR("python: Error creating thread for interactive interpreter.");
+ }
+ }
+
return 0;
}
return NULL;
children = PyTuple_New(ci->children_num); /* New reference. */
for (i = 0; i < ci->children_num; ++i) {
- PyTuple_SET_ITEM(children, i, cpy_oconfig_to_pyconfig(ci->children + i, item));
+ PyTuple_SET_ITEM(children, i, cpy_oconfig_to_pyconfig(ci->children + i, item));
}
tmp = ((Config *) item)->children;
((Config *) item)->children = children;
static int cpy_config(oconfig_item_t *ci) {
int i;
- PyObject *sys;
+ PyObject *sys, *tb;
PyObject *sys_path;
PyObject *module;
Py_Initialize();
PyType_Ready(&ConfigType);
+ PyType_Ready(&PluginDataType);
+ ValuesType.tp_base = &PluginDataType;
PyType_Ready(&ValuesType);
sys = PyImport_ImportModule("sys"); /* New reference. */
if (sys == NULL) {
- ERROR("python module: Unable to import \"sys\" module.");
- /* Just print the default python exception text to stderr. */
- PyErr_Print();
+ cpy_log_exception("python initialization");
return 1;
}
sys_path = PyObject_GetAttrString(sys, "path"); /* New reference. */
Py_DECREF(sys);
if (sys_path == NULL) {
- ERROR("python module: Unable to read \"sys.path\".");
- PyErr_Print();
+ cpy_log_exception("python initialization");
return 1;
}
module = Py_InitModule("collectd", cpy_methods); /* Borrowed reference. */
for (i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
- if (strcasecmp(item->key, "ModulePath") == 0) {
+ if (strcasecmp(item->key, "Interactive") == 0) {
+ if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN)
+ continue;
+ do_interactive = item->values[0].value.boolean;
+ } else if (strcasecmp(item->key, "LogTraces") == 0) {
+ if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN)
+ continue;
+ if (!item->values[0].value.boolean) {
+ Py_XDECREF(cpy_format_exception);
+ cpy_format_exception = NULL;
+ continue;
+ }
+ if (cpy_format_exception)
+ continue;
+ tb = PyImport_ImportModule("traceback"); /* New reference. */
+ if (tb == NULL) {
+ cpy_log_exception("python initialization");
+ continue;
+ }
+ cpy_format_exception = PyObject_GetAttrString(tb, "format_exception"); /* New reference. */
+ Py_DECREF(tb);
+ if (cpy_format_exception == NULL)
+ cpy_log_exception("python initialization");
+ } else if (strcasecmp(item->key, "ModulePath") == 0) {
char *dir = NULL;
PyObject *dir_object;
ERROR("python plugin: Unable to convert \"%s\" to "
"a python object.", dir);
free(dir);
- PyErr_Print();
+ cpy_log_exception("python initialization");
continue;
}
if (PyList_Append(sys_path, dir_object) != 0) {
ERROR("python plugin: Unable to append \"%s\" to "
"python module path.", dir);
- PyErr_Print();
+ cpy_log_exception("python initialization");
}
Py_DECREF(dir_object);
free(dir);
module = PyImport_ImportModule(module_name); /* New reference. */
if (module == NULL) {
ERROR("python plugin: Error importing module \"%s\".", module_name);
+ cpy_log_exception("python initialization");
PyErr_Print();
}
free(module_name);
if (cf_util_get_string(item, &name) != 0)
continue;
for (c = cpy_config_callbacks; c; c = c->next) {
- if (strcasecmp(c->name, name) == 0)
+ if (strcasecmp(c->name + 7, name) == 0)
break;
}
if (c == NULL) {
ret = PyObject_CallFunction(c->callback, "NO",
cpy_oconfig_to_pyconfig(item, NULL), c->data); /* New reference. */
if (ret == NULL)
- PyErr_Print();
+ cpy_log_exception("loading module");
else
Py_DECREF(ret);
} else {