src/python.c

   1 /**
   2  * collectd - src/python.c
   3  * Copyright (C) 2009  Sven Trenkel
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Sven Trenkel <collectd at semidefinite.de>
  25  **/
  26
  27 #include <Python.h>
  28 #include <structmember.h>
  29
  30 #include <signal.h>
  31
  32 #include "collectd.h"
  33
  34 #include "common.h"
  35
  36 #include "cpython.h"
  37
  38 typedef struct cpy_callback_s {
  39         char *name;
  40         PyObject *callback;
  41         PyObject *data;
  42         struct cpy_callback_s *next;
  43 } cpy_callback_t;
  44
  45 static char log_doc[] = "This function sends a string to all logging plugins.";
  46
  47 static char get_ds_doc[] = "get_dataset(name) -> definition\n"
  48                 "\n"
  49                 "Returns the definition of a dataset specified by name.\n"
  50                 "\n"
  51                 "'name' is a string specifying the dataset to query.\n"
  52                 "'definition' is a list of 4-tuples. Every tuple represents a \n"
  53                 "    data source within the data set and its 4 values are the \n"
  54                 "    name, type, min and max value.\n"
  55                 "    'name' is a string.\n"
  56                 "    'type' is a string that is equal to either DS_TYPE_COUNTER,\n"
  57                 "        DS_TYPE_GAUGE, DS_TYPE_DERIVE or DS_TYPE_ABSOLUTE.\n"
  58                 "    'min' and 'max' are either a float or None.";
  59
  60 static char flush_doc[] = "flush([plugin][, timeout][, identifier]) -> None\n"
  61                 "\n"
  62                 "Flushes the cache of another plugin.";
  63
  64 static char unregister_doc[] = "Unregisters a callback. This function needs exactly one parameter either\n"
  65                 "the function to unregister or the callback identifier to unregister.";
  66
  67 static char reg_log_doc[] = "register_log(callback[, data][, name]) -> identifier\n"
  68                 "\n"
  69                 "Register a callback function for log messages.\n"
  70                 "\n"
  71                 "'callback' is a callable object that will be called every time something\n"
  72                 "    is logged.\n"
  73                 "'data' is an optional object that will be passed back to the callback\n"
  74                 "    function every time it is called.\n"
  75                 "'name' is an optional identifier for this callback. The default name\n"
  76                 "    is 'python.<module>'.\n"
  77                 "    Every callback needs a unique identifier, so if you want to\n"
  78                 "    register this callback multiple time from the same module you need\n"
  79                 "    to specify a name here.\n"
  80                 "'identifier' is the full identifier assigned to this callback.\n"
  81                 "\n"
  82                 "The callback function will be called with two or three parameters:\n"
  83                 "severity: An integer that should be compared to the LOG_ constants.\n"
  84                 "message: The text to be logged.\n"
  85                 "data: The optional data parameter passed to the register function.\n"
  86                 "    If the parameter was omitted it will be omitted here, too.";
  87
  88 static char reg_init_doc[] = "register_init(callback[, data][, name]) -> identifier\n"
  89                 "\n"
  90                 "Register a callback function that will be executed once after the config.\n"
  91                 "file has been read, all plugins heve been loaded and the collectd has\n"
  92                 "forked into the background.\n"
  93                 "\n"
  94                 "'callback' is a callable object that will be executed.\n"
  95                 "'data' is an optional object that will be passed back to the callback\n"
  96                 "    function when it is called.\n"
  97                 "'name' is an optional identifier for this callback. The default name\n"
  98                 "    is 'python.<module>'.\n"
  99                 "    Every callback needs a unique identifier, so if you want to\n"
 100                 "    register this callback multiple time from the same module you need\n"
 101                 "    to specify a name here.\n"
 102                 "'identifier' is the full identifier assigned to this callback.\n"
 103                 "\n"
 104                 "The callback function will be called without parameters, except for\n"
 105                 "data if it was supplied.";
 106
 107 static char reg_config_doc[] = "register_config(callback[, data][, name]) -> identifier\n"
 108                 "\n"
 109                 "Register a callback function for config file entries.\n"
 110                 "'callback' is a callable object that will be called for every config block.\n"
 111                 "'data' is an optional object that will be passed back to the callback\n"
 112                 "    function every time it is called.\n"
 113                 "'name' is an optional identifier for this callback. The default name\n"
 114                 "    is 'python.<module>'.\n"
 115                 "    Every callback needs a unique identifier, so if you want to\n"
 116                 "    register this callback multiple time from the same module you need\n"
 117                 "    to specify a name here.\n"
 118                 "'identifier' is the full identifier assigned to this callback.\n"
 119                 "\n"
 120                 "The callback function will be called with one or two parameters:\n"
 121                 "config: A Config object.\n"
 122                 "data: The optional data parameter passed to the register function.\n"
 123                 "    If the parameter was omitted it will be omitted here, too.";
 124
 125 static char reg_read_doc[] = "register_read(callback[, interval][, data][, name]) -> identifier\n"
 126                 "\n"
 127                 "Register a callback function for reading data. It will just be called\n"
 128                 "in a fixed interval to signal that it's time to dispatch new values.\n"
 129                 "'callback' is a callable object that will be called every time something\n"
 130                 "    is logged.\n"
 131                 "'interval' is the number of seconds between between calls to the callback\n"
 132                 "    function. Full float precision is supported here.\n"
 133                 "'data' is an optional object that will be passed back to the callback\n"
 134                 "    function every time it is called.\n"
 135                 "'name' is an optional identifier for this callback. The default name\n"
 136                 "    is 'python.<module>'.\n"
 137                 "    Every callback needs a unique identifier, so if you want to\n"
 138                 "    register this callback multiple time from the same module you need\n"
 139                 "    to specify a name here.\n"
 140                 "'identifier' is the full identifier assigned to this callback.\n"
 141                 "\n"
 142                 "The callback function will be called without parameters, except for\n"
 143                 "data if it was supplied.";
 144
 145 static char reg_write_doc[] = "register_write(callback[, data][, name]) -> identifier\n"
 146                 "\n"
 147                 "Register a callback function to receive values dispatched by other plugins.\n"
 148                 "'callback' is a callable object that will be called every time a value\n"
 149                 "    is dispatched.\n"
 150                 "'data' is an optional object that will be passed back to the callback\n"
 151                 "    function every time it is called.\n"
 152                 "'name' is an optional identifier for this callback. The default name\n"
 153                 "    is 'python.<module>'.\n"
 154                 "    Every callback needs a unique identifier, so if you want to\n"
 155                 "    register this callback multiple time from the same module you need\n"
 156                 "    to specify a name here.\n"
 157                 "'identifier' is the full identifier assigned to this callback.\n"
 158                 "\n"
 159                 "The callback function will be called with one or two parameters:\n"
 160                 "values: A Values object which is a copy of the dispatched values.\n"
 161                 "data: The optional data parameter passed to the register function.\n"
 162                 "    If the parameter was omitted it will be omitted here, too.";
 163
 164 static char reg_notification_doc[] = "register_notification(callback[, data][, name]) -> identifier\n"
 165                 "\n"
 166                 "Register a callback function for notifications.\n"
 167                 "'callback' is a callable object that will be called every time a notification\n"
 168                 "    is dispatched.\n"
 169                 "'data' is an optional object that will be passed back to the callback\n"
 170                 "    function every time it is called.\n"
 171                 "'name' is an optional identifier for this callback. The default name\n"
 172                 "    is 'python.<module>'.\n"
 173                 "    Every callback needs a unique identifier, so if you want to\n"
 174                 "    register this callback multiple time from the same module you need\n"
 175                 "    to specify a name here.\n"
 176                 "'identifier' is the full identifier assigned to this callback.\n"
 177                 "\n"
 178                 "The callback function will be called with one or two parameters:\n"
 179                 "notification: A copy of the notification that was dispatched.\n"
 180                 "data: The optional data parameter passed to the register function.\n"
 181                 "    If the parameter was omitted it will be omitted here, too.";
 182
 183 static char reg_flush_doc[] = "register_flush(callback[, data][, name]) -> identifier\n"
 184                 "\n"
 185                 "Register a callback function for flush messages.\n"
 186                 "'callback' is a callable object that will be called every time a plugin\n"
 187                 "    requests a flush for either this or all plugins.\n"
 188                 "'data' is an optional object that will be passed back to the callback\n"
 189                 "    function every time it is called.\n"
 190                 "'name' is an optional identifier for this callback. The default name\n"
 191                 "    is 'python.<module>'.\n"
 192                 "    Every callback needs a unique identifier, so if you want to\n"
 193                 "    register this callback multiple time from the same module you need\n"
 194                 "    to specify a name here.\n"
 195                 "'identifier' is the full identifier assigned to this callback.\n"
 196                 "\n"
 197                 "The callback function will be called with two or three parameters:\n"
 198                 "timeout: Indicates that only data older than 'timeout' seconds is to\n"
 199                 "    be flushed.\n"
 200                 "id: Specifies which values are to be flushed.\n"
 201                 "data: The optional data parameter passed to the register function.\n"
 202                 "    If the parameter was omitted it will be omitted here, too.";
 203
 204 static char reg_shutdown_doc[] = "register_shutdown(callback[, data][, name]) -> identifier\n"
 205                 "\n"
 206                 "Register a callback function for collectd shutdown.\n"
 207                 "'callback' is a callable object that will be called once collectd is\n"
 208                 "    shutting down.\n"
 209                 "'data' is an optional object that will be passed back to the callback\n"
 210                 "    function if it is called.\n"
 211                 "'name' is an optional identifier for this callback. The default name\n"
 212                 "    is 'python.<module>'.\n"
 213                 "    Every callback needs a unique identifier, so if you want to\n"
 214                 "    register this callback multiple time from the same module you need\n"
 215                 "    to specify a name here.\n"
 216                 "'identifier' is the full identifier assigned to this callback.\n"
 217                 "\n"
 218                 "The callback function will be called with no parameters except for\n"
 219                 "    data if it was supplied.";
 220
 221
 222 static pthread_t main_thread;
 223 static PyOS_sighandler_t python_sigint_handler;
 224 static _Bool do_interactive = 0;
 225
 226 /* This is our global thread state. Python saves some stuff in thread-local
 227  * storage. So if we allow the interpreter to run in the background
 228  * (the scriptwriters might have created some threads from python), we have
 229  * to save the state so we can resume it later after shutdown. */
 230
 231 static PyThreadState *state;
 232
 233 static PyObject *sys_path, *cpy_format_exception;
 234
 235 static cpy_callback_t *cpy_config_callbacks;
 236 static cpy_callback_t *cpy_init_callbacks;
 237 static cpy_callback_t *cpy_shutdown_callbacks;
 238
 239 static void cpy_destroy_user_data(void *data) {
 240         cpy_callback_t *c = data;
 241         free(c->name);
 242         CPY_LOCK_THREADS
 243         Py_DECREF(c->callback);
 244         Py_XDECREF(c->data);
 245         CPY_RELEASE_THREADS
 246         free(c);
 247 }
 248
 249 /* You must hold the GIL to call this function!
 250  * But if you managed to extract the callback parameter then you probably already do. */
 251
 252 static void cpy_build_name(char *buf, size_t size, PyObject *callback, const char *name) {
 253         const char *module = NULL;
 254         PyObject *mod = NULL;
 255
 256         if (name != NULL) {
 257                 snprintf(buf, size, "python.%s", name);
 258                 return;
 259         }
 260
 261         mod = PyObject_GetAttrString(callback, "__module__"); /* New reference. */
 262         if (mod != NULL)
 263                 module = cpy_unicode_or_bytes_to_string(&mod);
 264
 265         if (module != NULL) {
 266                 snprintf(buf, size, "python.%s", module);
 267                 Py_XDECREF(mod);
 268                 PyErr_Clear();
 269                 return;
 270         }
 271         Py_XDECREF(mod);
 272
 273         snprintf(buf, size, "python.%p", callback);
 274         PyErr_Clear();
 275 }
 276
 277 void cpy_log_exception(const char *context) {
 278         int l = 0;
 279         const char *typename = NULL, *message = NULL;
 280         PyObject *type, *value, *traceback, *tn, *m, *list;
 281
 282         PyErr_Fetch(&type, &value, &traceback);
 283         PyErr_NormalizeException(&type, &value, &traceback);
 284         if (type == NULL) return;
 285         tn = PyObject_GetAttrString(type, "__name__"); /* New reference. */
 286         m = PyObject_Str(value); /* New reference. */
 287         if (tn != NULL)
 288                 typename = cpy_unicode_or_bytes_to_string(&tn);
 289         if (m != NULL)
 290                 message = cpy_unicode_or_bytes_to_string(&m);
 291         if (typename == NULL)
 292                 typename = "NamelessException";
 293         if (message == NULL)
 294                 message = "N/A";
 295         Py_BEGIN_ALLOW_THREADS
 296         ERROR("Unhandled python exception in %s: %s: %s", context, typename, message);
 297         Py_END_ALLOW_THREADS
 298         Py_XDECREF(tn);
 299         Py_XDECREF(m);
 300         if (!cpy_format_exception || !traceback) {
 301                 PyErr_Clear();
 302                 Py_DECREF(type);
 303                 Py_XDECREF(value);
 304                 Py_XDECREF(traceback);
 305                 return;
 306         }
 307         list = PyObject_CallFunction(cpy_format_exception, "NNN", type, value, traceback); /* New reference. Steals references from "type", "value" and "traceback". */
 308         if (list)
 309                 l = PyObject_Length(list);
 310
 311         for (int i = 0; i < l; ++i) {
 312                 PyObject *line;
 313                 char const *msg;
 314                 char *cpy;
 315
 316                 line = PyList_GET_ITEM(list, i); /* Borrowed reference. */
 317                 Py_INCREF(line);
 318
 319                 msg = cpy_unicode_or_bytes_to_string(&line);
 320                 Py_DECREF(line);
 321                 if (msg == NULL)
 322                         continue;
 323
 324                 cpy = strdup(msg);
 325                 if (cpy == NULL)
 326                         continue;
 327
 328                 if (cpy[strlen(cpy) - 1] == '\n')
 329                         cpy[strlen(cpy) - 1] = 0;
 330
 331                 Py_BEGIN_ALLOW_THREADS
 332                 ERROR("%s", cpy);
 333                 Py_END_ALLOW_THREADS
 334
 335                 free(cpy);
 336         }
 337
 338         Py_XDECREF(list);
 339         PyErr_Clear();
 340 }
 341
 342 static int cpy_read_callback(user_data_t *data) {
 343         cpy_callback_t *c = data->data;
 344         PyObject *ret;
 345
 346         CPY_LOCK_THREADS
 347                 ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
 348                 if (ret == NULL) {
 349                         cpy_log_exception("read callback");
 350                 } else {
 351                         Py_DECREF(ret);
 352                 }
 353         CPY_RELEASE_THREADS
 354         if (ret == NULL)
 355                 return 1;
 356         return 0;
 357 }
 358
 359 static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_list, user_data_t *data) {
 360         cpy_callback_t *c = data->data;
 361         PyObject *ret, *list, *temp, *dict = NULL;
 362         Values *v;
 363
 364         CPY_LOCK_THREADS
 365                 list = PyList_New(value_list->values_len); /* New reference. */
 366                 if (list == NULL) {
 367                         cpy_log_exception("write callback");
 368                         CPY_RETURN_FROM_THREADS 0;
 369                 }
 370                 for (size_t i = 0; i < value_list->values_len; ++i) {
 371                         if (ds->ds[i].type == DS_TYPE_COUNTER) {
 372                                 PyList_SetItem(list, i, PyLong_FromUnsignedLongLong(value_list->values[i].counter));
 373                         } else if (ds->ds[i].type == DS_TYPE_GAUGE) {
 374                                 PyList_SetItem(list, i, PyFloat_FromDouble(value_list->values[i].gauge));
 375                         } else if (ds->ds[i].type == DS_TYPE_DERIVE) {
 376                                 PyList_SetItem(list, i, PyLong_FromLongLong(value_list->values[i].derive));
 377                         } else if (ds->ds[i].type == DS_TYPE_ABSOLUTE) {
 378                                 PyList_SetItem(list, i, PyLong_FromUnsignedLongLong(value_list->values[i].absolute));
 379                         } else {
 380                                 Py_BEGIN_ALLOW_THREADS
 381                                 ERROR("cpy_write_callback: Unknown value type %d.", ds->ds[i].type);
 382                                 Py_END_ALLOW_THREADS
 383                                 Py_DECREF(list);
 384                                 CPY_RETURN_FROM_THREADS 0;
 385                         }
 386                         if (PyErr_Occurred() != NULL) {
 387                                 cpy_log_exception("value building for write callback");
 388                                 Py_DECREF(list);
 389                                 CPY_RETURN_FROM_THREADS 0;
 390                         }
 391                 }
 392                 dict = PyDict_New();  /* New reference. */
 393                 if (value_list->meta) {
 394                         char **table;
 395                         meta_data_t *meta = value_list->meta;
 396
 397                         int num = meta_data_toc(meta, &table);
 398                         for (int i = 0; i < num; ++i) {
 399                                 int type;
 400                                 char *string;
 401                                 int64_t si;
 402                                 uint64_t ui;
 403                                 double d;
 404                                 _Bool b;
 405
 406                                 type = meta_data_type(meta, table[i]);
 407                                 if (type == MD_TYPE_STRING) {
 408                                         if (meta_data_get_string(meta, table[i], &string))
 409                                                 continue;
 410                                         temp = cpy_string_to_unicode_or_bytes(string);  /* New reference. */
 411                                         free(string);
 412                                         PyDict_SetItemString(dict, table[i], temp);
 413                                         Py_XDECREF(temp);
 414                                 } else if (type == MD_TYPE_SIGNED_INT) {
 415                                         if (meta_data_get_signed_int(meta, table[i], &si))
 416                                                 continue;
 417                                         temp = PyObject_CallFunctionObjArgs((void *) &SignedType, PyLong_FromLongLong(si), (void *) 0);  /* New reference. */
 418                                         PyDict_SetItemString(dict, table[i], temp);
 419                                         Py_XDECREF(temp);
 420                                 } else if (type == MD_TYPE_UNSIGNED_INT) {
 421                                         if (meta_data_get_unsigned_int(meta, table[i], &ui))
 422                                                 continue;
 423                                         temp = PyObject_CallFunctionObjArgs((void *) &UnsignedType, PyLong_FromUnsignedLongLong(ui), (void *) 0);  /* New reference. */
 424                                         PyDict_SetItemString(dict, table[i], temp);
 425                                         Py_XDECREF(temp);
 426                                 } else if (type == MD_TYPE_DOUBLE) {
 427                                         if (meta_data_get_double(meta, table[i], &d))
 428                                                 continue;
 429                                         temp = PyFloat_FromDouble(d);  /* New reference. */
 430                                         PyDict_SetItemString(dict, table[i], temp);
 431                                         Py_XDECREF(temp);
 432                                 } else if (type == MD_TYPE_BOOLEAN) {
 433                                         if (meta_data_get_boolean(meta, table[i], &b))
 434                                                 continue;
 435                                         if (b)
 436                                                 PyDict_SetItemString(dict, table[i], Py_True);
 437                                         else
 438                                                 PyDict_SetItemString(dict, table[i], Py_False);
 439                                 }
 440                                 free(table[i]);
 441                         }
 442                         free(table);
 443                 }
 444                 v = (Values *) Values_New(); /* New reference. */
 445                 sstrncpy(v->data.host, value_list->host, sizeof(v->data.host));
 446                 sstrncpy(v->data.type, value_list->type, sizeof(v->data.type));
 447                 sstrncpy(v->data.type_instance, value_list->type_instance, sizeof(v->data.type_instance));
 448                 sstrncpy(v->data.plugin, value_list->plugin, sizeof(v->data.plugin));
 449                 sstrncpy(v->data.plugin_instance, value_list->plugin_instance, sizeof(v->data.plugin_instance));
 450                 v->data.time = CDTIME_T_TO_DOUBLE(value_list->time);
 451                 v->interval = CDTIME_T_TO_DOUBLE(value_list->interval);
 452                 Py_CLEAR(v->values);
 453                 v->values = list;
 454                 Py_CLEAR(v->meta);
 455                 v->meta = dict;  /* Steals a reference. */
 456                 ret = PyObject_CallFunctionObjArgs(c->callback, v, c->data, (void *) 0); /* New reference. */
 457                 Py_XDECREF(v);
 458                 if (ret == NULL) {
 459                         cpy_log_exception("write callback");
 460                 } else {
 461                         Py_DECREF(ret);
 462                 }
 463         CPY_RELEASE_THREADS
 464         return 0;
 465 }
 466
 467 static int cpy_notification_callback(const notification_t *notification, user_data_t *data) {
 468         cpy_callback_t *c = data->data;
 469         PyObject *ret, *notify;
 470         Notification *n;
 471
 472         CPY_LOCK_THREADS
 473                 notify = Notification_New(); /* New reference. */
 474                 n = (Notification *) notify;
 475                 sstrncpy(n->data.host, notification->host, sizeof(n->data.host));
 476                 sstrncpy(n->data.type, notification->type, sizeof(n->data.type));
 477                 sstrncpy(n->data.type_instance, notification->type_instance, sizeof(n->data.type_instance));
 478                 sstrncpy(n->data.plugin, notification->plugin, sizeof(n->data.plugin));
 479                 sstrncpy(n->data.plugin_instance, notification->plugin_instance, sizeof(n->data.plugin_instance));
 480                 n->data.time = CDTIME_T_TO_DOUBLE(notification->time);
 481                 sstrncpy(n->message, notification->message, sizeof(n->message));
 482                 n->severity = notification->severity;
 483                 ret = PyObject_CallFunctionObjArgs(c->callback, n, c->data, (void *) 0); /* New reference. */
 484                 Py_XDECREF(notify);
 485                 if (ret == NULL) {
 486                         cpy_log_exception("notification callback");
 487                 } else {
 488                         Py_DECREF(ret);
 489                 }
 490         CPY_RELEASE_THREADS
 491         return 0;
 492 }
 493
 494 static void cpy_log_callback(int severity, const char *message, user_data_t *data) {
 495         cpy_callback_t * c = data->data;
 496         PyObject *ret, *text;
 497
 498         CPY_LOCK_THREADS
 499         text = cpy_string_to_unicode_or_bytes(message);  /* New reference. */
 500         if (c->data == NULL)
 501                 ret = PyObject_CallFunction(c->callback, "iN", severity, text); /* New reference. Steals a reference from "text". */
 502         else
 503                 ret = PyObject_CallFunction(c->callback, "iNO", severity, text, c->data); /* New reference. Steals a reference from "text". */
 504
 505         if (ret == NULL) {
 506                 /* FIXME */
 507                 /* Do we really want to trigger a log callback because a log callback failed?
 508                  * Probably not. */
 509                 PyErr_Print();
 510                 /* In case someone wanted to be clever, replaced stderr and failed at that. */
 511                 PyErr_Clear();
 512         } else {
 513                 Py_DECREF(ret);
 514         }
 515         CPY_RELEASE_THREADS
 516 }
 517
 518 static void cpy_flush_callback(int timeout, const char *id, user_data_t *data) {
 519         cpy_callback_t * c = data->data;
 520         PyObject *ret, *text;
 521
 522         CPY_LOCK_THREADS
 523         text = cpy_string_to_unicode_or_bytes(id);
 524         if (c->data == NULL)
 525                 ret = PyObject_CallFunction(c->callback, "iN", timeout, text); /* New reference. */
 526         else
 527                 ret = PyObject_CallFunction(c->callback, "iNO", timeout, text, c->data); /* New reference. */
 528
 529         if (ret == NULL) {
 530                 cpy_log_exception("flush callback");
 531         } else {
 532                 Py_DECREF(ret);
 533         }
 534         CPY_RELEASE_THREADS
 535 }
 536
 537 static PyObject *cpy_register_generic(cpy_callback_t **list_head, PyObject *args, PyObject *kwds) {
 538         char buf[512];
 539         cpy_callback_t *c;
 540         char *name = NULL;
 541         PyObject *callback = NULL, *data = NULL, *mod = NULL;
 542         static char *kwlist[] = {"callback", "data", "name", NULL};
 543
 544         if (PyArg_ParseTupleAndKeywords(args, kwds, "O|Oet", kwlist, &callback, &data, NULL, &name) == 0) return NULL;
 545         if (PyCallable_Check(callback) == 0) {
 546                 PyMem_Free(name);
 547                 PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object.");
 548                 return NULL;
 549         }
 550         cpy_build_name(buf, sizeof(buf), callback, name);
 551
 552         Py_INCREF(callback);
 553         Py_XINCREF(data);
 554
 555         c = calloc(1, sizeof(*c));
 556         if (c == NULL)
 557                 return NULL;
 558
 559         c->name = strdup(buf);
 560         c->callback = callback;
 561         c->data = data;
 562         c->next = *list_head;
 563         *list_head = c;
 564         Py_XDECREF(mod);
 565         PyMem_Free(name);
 566         return cpy_string_to_unicode_or_bytes(buf);
 567 }
 568
 569 static PyObject *float_or_none(float number) {
 570         if (isnan(number)) {
 571                 Py_RETURN_NONE;
 572         }
 573         return PyFloat_FromDouble(number);
 574 }
 575
 576 static PyObject *cpy_get_dataset(PyObject *self, PyObject *args) {
 577         char *name;
 578         const data_set_t *ds;
 579         PyObject *list, *tuple;
 580
 581         if (PyArg_ParseTuple(args, "et", NULL, &name) == 0) return NULL;
 582         ds = plugin_get_ds(name);
 583         PyMem_Free(name);
 584         if (ds == NULL) {
 585                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", name);
 586                 return NULL;
 587         }
 588         list = PyList_New(ds->ds_num); /* New reference. */
 589         for (size_t i = 0; i < ds->ds_num; ++i) {
 590                 tuple = PyTuple_New(4);
 591                 PyTuple_SET_ITEM(tuple, 0, cpy_string_to_unicode_or_bytes(ds->ds[i].name));
 592                 PyTuple_SET_ITEM(tuple, 1, cpy_string_to_unicode_or_bytes(DS_TYPE_TO_STRING(ds->ds[i].type)));
 593                 PyTuple_SET_ITEM(tuple, 2, float_or_none(ds->ds[i].min));
 594                 PyTuple_SET_ITEM(tuple, 3, float_or_none(ds->ds[i].max));
 595                 PyList_SET_ITEM(list, i, tuple);
 596         }
 597         return list;
 598 }
 599
 600 static PyObject *cpy_flush(PyObject *self, PyObject *args, PyObject *kwds) {
 601         int timeout = -1;
 602         char *plugin = NULL, *identifier = NULL;
 603         static char *kwlist[] = {"plugin", "timeout", "identifier", NULL};
 604
 605         if (PyArg_ParseTupleAndKeywords(args, kwds, "|etiet", kwlist, NULL, &plugin, &timeout, NULL, &identifier) == 0) return NULL;
 606         Py_BEGIN_ALLOW_THREADS
 607         plugin_flush(plugin, timeout, identifier);
 608         Py_END_ALLOW_THREADS
 609         PyMem_Free(plugin);
 610         PyMem_Free(identifier);
 611         Py_RETURN_NONE;
 612 }
 613
 614 static PyObject *cpy_register_config(PyObject *self, PyObject *args, PyObject *kwds) {
 615         return cpy_register_generic(&cpy_config_callbacks, args, kwds);
 616 }
 617
 618 static PyObject *cpy_register_init(PyObject *self, PyObject *args, PyObject *kwds) {
 619         return cpy_register_generic(&cpy_init_callbacks, args, kwds);
 620 }
 621
 622 typedef int reg_function_t(const char *name, void *callback, void *data);
 623
 624 static PyObject *cpy_register_generic_userdata(void *reg, void *handler, PyObject *args, PyObject *kwds) {
 625         char buf[512];
 626         reg_function_t *register_function = (reg_function_t *) reg;
 627         cpy_callback_t *c = NULL;
 628         char *name = NULL;
 629         PyObject *callback = NULL, *data = NULL;
 630         static char *kwlist[] = {"callback", "data", "name", NULL};
 631
 632         if (PyArg_ParseTupleAndKeywords(args, kwds, "O|Oet", kwlist, &callback, &data, NULL, &name) == 0) return NULL;
 633         if (PyCallable_Check(callback) == 0) {
 634                 PyMem_Free(name);
 635                 PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object.");
 636                 return NULL;
 637         }
 638         cpy_build_name(buf, sizeof(buf), callback, name);
 639         PyMem_Free(name);
 640
 641         Py_INCREF(callback);
 642         Py_XINCREF(data);
 643
 644         c = calloc(1, sizeof(*c));
 645         if (c == NULL)
 646                 return NULL;
 647
 648         c->name = strdup(buf);
 649         c->callback = callback;
 650         c->data = data;
 651         c->next = NULL;
 652
 653         user_data_t user_data = {
 654                 .data = c,
 655                 .free_func = cpy_destroy_user_data
 656         };
 657
 658         register_function(buf, handler, &user_data);
 659         return cpy_string_to_unicode_or_bytes(buf);
 660 }
 661
 662 static PyObject *cpy_register_read(PyObject *self, PyObject *args, PyObject *kwds) {
 663         char buf[512];
 664         cpy_callback_t *c = NULL;
 665         double interval = 0;
 666         char *name = NULL;
 667         PyObject *callback = NULL, *data = NULL;
 668         static char *kwlist[] = {"callback", "interval", "data", "name", NULL};
 669
 670         if (PyArg_ParseTupleAndKeywords(args, kwds, "O|dOet", kwlist, &callback, &interval, &data, NULL, &name) == 0) return NULL;
 671         if (PyCallable_Check(callback) == 0) {
 672                 PyMem_Free(name);
 673                 PyErr_SetString(PyExc_TypeError, "callback needs a be a callable object.");
 674                 return NULL;
 675         }
 676         cpy_build_name(buf, sizeof(buf), callback, name);
 677         PyMem_Free(name);
 678
 679         Py_INCREF(callback);
 680         Py_XINCREF(data);
 681
 682         c = calloc(1, sizeof(*c));
 683         if (c == NULL)
 684                 return NULL;
 685
 686         c->name = strdup(buf);
 687         c->callback = callback;
 688         c->data = data;
 689         c->next = NULL;
 690
 691         user_data_t user_data = {
 692                 .data = c,
 693                 .free_func = cpy_destroy_user_data
 694         };
 695
 696         plugin_register_complex_read(/* group = */ "python", buf,
 697                         cpy_read_callback, DOUBLE_TO_CDTIME_T (interval), &user_data);
 698         return cpy_string_to_unicode_or_bytes(buf);
 699 }
 700
 701 static PyObject *cpy_register_log(PyObject *self, PyObject *args, PyObject *kwds) {
 702         return cpy_register_generic_userdata((void *) plugin_register_log,
 703                         (void *) cpy_log_callback, args, kwds);
 704 }
 705
 706 static PyObject *cpy_register_write(PyObject *self, PyObject *args, PyObject *kwds) {
 707         return cpy_register_generic_userdata((void *) plugin_register_write,
 708                         (void *) cpy_write_callback, args, kwds);
 709 }
 710
 711 static PyObject *cpy_register_notification(PyObject *self, PyObject *args, PyObject *kwds) {
 712         return cpy_register_generic_userdata((void *) plugin_register_notification,
 713                         (void *) cpy_notification_callback, args, kwds);
 714 }
 715
 716 static PyObject *cpy_register_flush(PyObject *self, PyObject *args, PyObject *kwds) {
 717         return cpy_register_generic_userdata((void *) plugin_register_flush,
 718                         (void *) cpy_flush_callback, args, kwds);
 719 }
 720
 721 static PyObject *cpy_register_shutdown(PyObject *self, PyObject *args, PyObject *kwds) {
 722         return cpy_register_generic(&cpy_shutdown_callbacks, args, kwds);
 723 }
 724
 725 static PyObject *cpy_error(PyObject *self, PyObject *args) {
 726         char *text;
 727         if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL;
 728         Py_BEGIN_ALLOW_THREADS
 729         plugin_log(LOG_ERR, "%s", text);
 730         Py_END_ALLOW_THREADS
 731         PyMem_Free(text);
 732         Py_RETURN_NONE;
 733 }
 734
 735 static PyObject *cpy_warning(PyObject *self, PyObject *args) {
 736         char *text;
 737         if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL;
 738         Py_BEGIN_ALLOW_THREADS
 739         plugin_log(LOG_WARNING, "%s", text);
 740         Py_END_ALLOW_THREADS
 741         PyMem_Free(text);
 742         Py_RETURN_NONE;
 743 }
 744
 745 static PyObject *cpy_notice(PyObject *self, PyObject *args) {
 746         char *text;
 747         if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL;
 748         Py_BEGIN_ALLOW_THREADS
 749         plugin_log(LOG_NOTICE, "%s", text);
 750         Py_END_ALLOW_THREADS
 751         PyMem_Free(text);
 752         Py_RETURN_NONE;
 753 }
 754
 755 static PyObject *cpy_info(PyObject *self, PyObject *args) {
 756         char *text;
 757         if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL;
 758         Py_BEGIN_ALLOW_THREADS
 759         plugin_log(LOG_INFO, "%s", text);
 760         Py_END_ALLOW_THREADS
 761         PyMem_Free(text);
 762         Py_RETURN_NONE;
 763 }
 764
 765 static PyObject *cpy_debug(PyObject *self, PyObject *args) {
 766 #ifdef COLLECT_DEBUG
 767         char *text;
 768         if (PyArg_ParseTuple(args, "et", NULL, &text) == 0) return NULL;
 769         Py_BEGIN_ALLOW_THREADS
 770         plugin_log(LOG_DEBUG, "%s", text);
 771         Py_END_ALLOW_THREADS
 772         PyMem_Free(text);
 773 #endif
 774         Py_RETURN_NONE;
 775 }
 776
 777 static PyObject *cpy_unregister_generic(cpy_callback_t **list_head, PyObject *arg, const char *desc) {
 778         char buf[512];
 779         const char *name;
 780         cpy_callback_t *prev = NULL, *tmp;
 781
 782         Py_INCREF(arg);
 783         name = cpy_unicode_or_bytes_to_string(&arg);
 784         if (name == NULL) {
 785                 PyErr_Clear();
 786                 if (!PyCallable_Check(arg)) {
 787                         PyErr_SetString(PyExc_TypeError, "This function needs a string or a callable object as its only parameter.");
 788                         Py_DECREF(arg);
 789                         return NULL;
 790                 }
 791                 cpy_build_name(buf, sizeof(buf), arg, NULL);
 792                 name = buf;
 793         }
 794         for (tmp = *list_head; tmp; prev = tmp, tmp = tmp->next)
 795                 if (strcmp(name, tmp->name) == 0)
 796                         break;
 797
 798         Py_DECREF(arg);
 799         if (tmp == NULL) {
 800                 PyErr_Format(PyExc_RuntimeError, "Unable to unregister %s callback '%s'.", desc, name);
 801                 return NULL;
 802         }
 803         /* Yes, this is actually save. To call this function the caller has to
 804          * hold the GIL. Well, save as long as there is only one GIL anyway ... */
 805         if (prev == NULL)
 806                 *list_head = tmp->next;
 807         else
 808                 prev->next = tmp->next;
 809         cpy_destroy_user_data(tmp);
 810         Py_RETURN_NONE;
 811 }
 812
 813 typedef int cpy_unregister_function_t(const char *name);
 814
 815 static PyObject *cpy_unregister_generic_userdata(cpy_unregister_function_t *unreg, PyObject *arg, const char *desc) {
 816         char buf[512];
 817         const char *name;
 818
 819         Py_INCREF(arg);
 820         name = cpy_unicode_or_bytes_to_string(&arg);
 821         if (name == NULL) {
 822                 PyErr_Clear();
 823                 if (!PyCallable_Check(arg)) {
 824                         PyErr_SetString(PyExc_TypeError, "This function needs a string or a callable object as its only parameter.");
 825                         Py_DECREF(arg);
 826                         return NULL;
 827                 }
 828                 cpy_build_name(buf, sizeof(buf), arg, NULL);
 829                 name = buf;
 830         }
 831         if (unreg(name) == 0) {
 832                 Py_DECREF(arg);
 833                 Py_RETURN_NONE;
 834         }
 835         PyErr_Format(PyExc_RuntimeError, "Unable to unregister %s callback '%s'.", desc, name);
 836         Py_DECREF(arg);
 837         return NULL;
 838 }
 839
 840 static PyObject *cpy_unregister_log(PyObject *self, PyObject *arg) {
 841         return cpy_unregister_generic_userdata(plugin_unregister_log, arg, "log");
 842 }
 843
 844 static PyObject *cpy_unregister_init(PyObject *self, PyObject *arg) {
 845         return cpy_unregister_generic(&cpy_init_callbacks, arg, "init");
 846 }
 847
 848 static PyObject *cpy_unregister_config(PyObject *self, PyObject *arg) {
 849         return cpy_unregister_generic(&cpy_config_callbacks, arg, "config");
 850 }
 851
 852 static PyObject *cpy_unregister_read(PyObject *self, PyObject *arg) {
 853         return cpy_unregister_generic_userdata(plugin_unregister_read, arg, "read");
 854 }
 855
 856 static PyObject *cpy_unregister_write(PyObject *self, PyObject *arg) {
 857         return cpy_unregister_generic_userdata(plugin_unregister_write, arg, "write");
 858 }
 859
 860 static PyObject *cpy_unregister_notification(PyObject *self, PyObject *arg) {
 861         return cpy_unregister_generic_userdata(plugin_unregister_notification, arg, "notification");
 862 }
 863
 864 static PyObject *cpy_unregister_flush(PyObject *self, PyObject *arg) {
 865         return cpy_unregister_generic_userdata(plugin_unregister_flush, arg, "flush");
 866 }
 867
 868 static PyObject *cpy_unregister_shutdown(PyObject *self, PyObject *arg) {
 869         return cpy_unregister_generic(&cpy_shutdown_callbacks, arg, "shutdown");
 870 }
 871
 872 static PyMethodDef cpy_methods[] = {
 873         {"debug", cpy_debug, METH_VARARGS, log_doc},
 874         {"info", cpy_info, METH_VARARGS, log_doc},
 875         {"notice", cpy_notice, METH_VARARGS, log_doc},
 876         {"warning", cpy_warning, METH_VARARGS, log_doc},
 877         {"error", cpy_error, METH_VARARGS, log_doc},
 878         {"get_dataset", (PyCFunction) cpy_get_dataset, METH_VARARGS, get_ds_doc},
 879         {"flush", (PyCFunction) cpy_flush, METH_VARARGS | METH_KEYWORDS, flush_doc},
 880         {"register_log", (PyCFunction) cpy_register_log, METH_VARARGS | METH_KEYWORDS, reg_log_doc},
 881         {"register_init", (PyCFunction) cpy_register_init, METH_VARARGS | METH_KEYWORDS, reg_init_doc},
 882         {"register_config", (PyCFunction) cpy_register_config, METH_VARARGS | METH_KEYWORDS, reg_config_doc},
 883         {"register_read", (PyCFunction) cpy_register_read, METH_VARARGS | METH_KEYWORDS, reg_read_doc},
 884         {"register_write", (PyCFunction) cpy_register_write, METH_VARARGS | METH_KEYWORDS, reg_write_doc},
 885         {"register_notification", (PyCFunction) cpy_register_notification, METH_VARARGS | METH_KEYWORDS, reg_notification_doc},
 886         {"register_flush", (PyCFunction) cpy_register_flush, METH_VARARGS | METH_KEYWORDS, reg_flush_doc},
 887         {"register_shutdown", (PyCFunction) cpy_register_shutdown, METH_VARARGS | METH_KEYWORDS, reg_shutdown_doc},
 888         {"unregister_log", cpy_unregister_log, METH_O, unregister_doc},
 889         {"unregister_init", cpy_unregister_init, METH_O, unregister_doc},
 890         {"unregister_config", cpy_unregister_config, METH_O, unregister_doc},
 891         {"unregister_read", cpy_unregister_read, METH_O, unregister_doc},
 892         {"unregister_write", cpy_unregister_write, METH_O, unregister_doc},
 893         {"unregister_notification", cpy_unregister_notification, METH_O, unregister_doc},
 894         {"unregister_flush", cpy_unregister_flush, METH_O, unregister_doc},
 895         {"unregister_shutdown", cpy_unregister_shutdown, METH_O, unregister_doc},
 896         {0, 0, 0, 0}
 897 };
 898
 899 static int cpy_shutdown(void) {
 900         PyObject *ret;
 901
 902         /* This can happen if the module was loaded but not configured. */
 903         if (state != NULL)
 904                 PyEval_RestoreThread(state);
 905
 906         for (cpy_callback_t *c = cpy_shutdown_callbacks; c; c = c->next) {
 907                 ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
 908                 if (ret == NULL)
 909                         cpy_log_exception("shutdown callback");
 910                 else
 911                         Py_DECREF(ret);
 912         }
 913         PyErr_Print();
 914         Py_Finalize();
 915         return 0;
 916 }
 917
 918 static void *cpy_interactive(void *data) {
 919         PyOS_sighandler_t cur_sig;
 920
 921         /* Signal handler in a plugin? Bad stuff, but the best way to
 922          * handle it I guess. In an interactive session people will
 923          * press Ctrl+C at some time, which will generate a SIGINT.
 924          * This will cause collectd to shutdown, thus killing the
 925          * interactive interpreter, and leaving the terminal in a
 926          * mess. Chances are, this isn't what the user wanted to do.
 927          *
 928          * So this is the plan:
 929          * 1. Restore Python's own signal handler
 930          * 2. Tell Python we just forked so it will accept this thread
 931          *    as the main one. No version of Python will ever handle
 932          *    interrupts anywhere but in the main thread.
 933          * 3. After the interactive loop is done, restore collectd's
 934          *    SIGINT handler.
 935          * 4. Raise SIGINT for a clean shutdown. The signal is sent to
 936          *    the main thread to ensure it wakes up the main interval
 937          *    sleep so that collectd shuts down immediately not in 10
 938          *    seconds.
 939          *
 940          * This will make sure that SIGINT won't kill collectd but
 941          * still interrupt syscalls like sleep and pause. */
 942
 943         PyEval_AcquireThread(state);
 944         if (PyImport_ImportModule("readline") == NULL) {
 945                 /* This interactive session will suck. */
 946                 cpy_log_exception("interactive session init");
 947         }
 948         cur_sig = PyOS_setsig(SIGINT, python_sigint_handler);
 949         /* We totally forked just now. Everyone saw that, right? */
 950         PyOS_AfterFork();
 951         PyRun_InteractiveLoop(stdin, "<stdin>");
 952         PyOS_setsig(SIGINT, cur_sig);
 953         PyErr_Print();
 954         PyEval_ReleaseThread(state);
 955         NOTICE("python: Interactive interpreter exited, stopping collectd ...");
 956         pthread_kill(main_thread, SIGINT);
 957         return NULL;
 958 }
 959
 960 static int cpy_init(void) {
 961         PyObject *ret;
 962         static pthread_t thread;
 963
 964         if (!Py_IsInitialized()) {
 965                 WARNING("python: Plugin loaded but not configured.");
 966                 plugin_unregister_shutdown("python");
 967                 return 0;
 968         }
 969         PyEval_InitThreads();
 970         /* Now it's finally OK to use python threads. */
 971         for (cpy_callback_t *c = cpy_init_callbacks; c; c = c->next) {
 972                 ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
 973                 if (ret == NULL)
 974                         cpy_log_exception("init callback");
 975                 else
 976                         Py_DECREF(ret);
 977         }
 978         state = PyEval_SaveThread();
 979         main_thread = pthread_self();
 980         if (do_interactive) {
 981                 if (plugin_thread_create(&thread, NULL, cpy_interactive, NULL)) {
 982                         ERROR("python: Error creating thread for interactive interpreter.");
 983                 }
 984         }
 985
 986         return 0;
 987 }
 988
 989 static PyObject *cpy_oconfig_to_pyconfig(oconfig_item_t *ci, PyObject *parent) {
 990         PyObject *item, *values, *children, *tmp;
 991
 992         if (parent == NULL)
 993                 parent = Py_None;
 994
 995         values = PyTuple_New(ci->values_num); /* New reference. */
 996         for (int i = 0; i < ci->values_num; ++i) {
 997                 if (ci->values[i].type == OCONFIG_TYPE_STRING) {
 998                         PyTuple_SET_ITEM(values, i, cpy_string_to_unicode_or_bytes(ci->values[i].value.string));
 999                 } else if (ci->values[i].type == OCONFIG_TYPE_NUMBER) {
1000                         PyTuple_SET_ITEM(values, i, PyFloat_FromDouble(ci->values[i].value.number));
1001                 } else if (ci->values[i].type == OCONFIG_TYPE_BOOLEAN) {
1002                         PyTuple_SET_ITEM(values, i, PyBool_FromLong(ci->values[i].value.boolean));
1003                 }
1004         }
1005
1006         tmp = cpy_string_to_unicode_or_bytes(ci->key);
1007         item = PyObject_CallFunction((void *) &ConfigType, "NONO", tmp, parent, values, Py_None);
1008         if (item == NULL)
1009                 return NULL;
1010         children = PyTuple_New(ci->children_num); /* New reference. */
1011         for (int i = 0; i < ci->children_num; ++i) {
1012                 PyTuple_SET_ITEM(children, i, cpy_oconfig_to_pyconfig(ci->children + i, item));
1013         }
1014         tmp = ((Config *) item)->children;
1015         ((Config *) item)->children = children;
1016         Py_XDECREF(tmp);
1017         return item;
1018 }
1019
1020 #ifdef IS_PY3K
1021 static struct PyModuleDef collectdmodule = {
1022         PyModuleDef_HEAD_INIT,
1023         "collectd",   /* name of module */
1024         "The python interface to collectd", /* module documentation, may be NULL */
1025         -1,
1026         cpy_methods
1027 };
1028
1029 PyMODINIT_FUNC PyInit_collectd(void) {
1030         return PyModule_Create(&collectdmodule);
1031 }
1032 #endif
1033
1034 static int cpy_init_python(void) {
1035         PyOS_sighandler_t cur_sig;
1036         PyObject *sys;
1037         PyObject *module;
1038
1039 #ifdef IS_PY3K
1040         wchar_t *argv = L"";
1041         /* Add a builtin module, before Py_Initialize */
1042         PyImport_AppendInittab("collectd", PyInit_collectd);
1043 #else
1044         char *argv = "";
1045 #endif
1046
1047         /* Chances are the current signal handler is already SIG_DFL, but let's make sure. */
1048         cur_sig = PyOS_setsig(SIGINT, SIG_DFL);
1049         Py_Initialize();
1050         python_sigint_handler = PyOS_setsig(SIGINT, cur_sig);
1051
1052         PyType_Ready(&ConfigType);
1053         PyType_Ready(&PluginDataType);
1054         ValuesType.tp_base = &PluginDataType;
1055         PyType_Ready(&ValuesType);
1056         NotificationType.tp_base = &PluginDataType;
1057         PyType_Ready(&NotificationType);
1058         SignedType.tp_base = &PyLong_Type;
1059         PyType_Ready(&SignedType);
1060         UnsignedType.tp_base = &PyLong_Type;
1061         PyType_Ready(&UnsignedType);
1062         sys = PyImport_ImportModule("sys"); /* New reference. */
1063         if (sys == NULL) {
1064                 cpy_log_exception("python initialization");
1065                 return 1;
1066         }
1067         sys_path = PyObject_GetAttrString(sys, "path"); /* New reference. */
1068         Py_DECREF(sys);
1069         if (sys_path == NULL) {
1070                 cpy_log_exception("python initialization");
1071                 return 1;
1072         }
1073         PySys_SetArgv(1, &argv);
1074         PyList_SetSlice(sys_path, 0, 1, NULL);
1075
1076 #ifdef IS_PY3K
1077         module = PyImport_ImportModule("collectd");
1078 #else
1079         module = Py_InitModule("collectd", cpy_methods); /* Borrowed reference. */
1080 #endif
1081         PyModule_AddObject(module, "Config", (void *) &ConfigType); /* Steals a reference. */
1082         PyModule_AddObject(module, "Values", (void *) &ValuesType); /* Steals a reference. */
1083         PyModule_AddObject(module, "Notification", (void *) &NotificationType); /* Steals a reference. */
1084         PyModule_AddObject(module, "Signed", (void *) &SignedType); /* Steals a reference. */
1085         PyModule_AddObject(module, "Unsigned", (void *) &UnsignedType); /* Steals a reference. */
1086         PyModule_AddIntConstant(module, "LOG_DEBUG", LOG_DEBUG);
1087         PyModule_AddIntConstant(module, "LOG_INFO", LOG_INFO);
1088         PyModule_AddIntConstant(module, "LOG_NOTICE", LOG_NOTICE);
1089         PyModule_AddIntConstant(module, "LOG_WARNING", LOG_WARNING);
1090         PyModule_AddIntConstant(module, "LOG_ERROR", LOG_ERR);
1091         PyModule_AddIntConstant(module, "NOTIF_FAILURE", NOTIF_FAILURE);
1092         PyModule_AddIntConstant(module, "NOTIF_WARNING", NOTIF_WARNING);
1093         PyModule_AddIntConstant(module, "NOTIF_OKAY", NOTIF_OKAY);
1094         PyModule_AddStringConstant(module, "DS_TYPE_COUNTER", DS_TYPE_TO_STRING(DS_TYPE_COUNTER));
1095         PyModule_AddStringConstant(module, "DS_TYPE_GAUGE", DS_TYPE_TO_STRING(DS_TYPE_GAUGE));
1096         PyModule_AddStringConstant(module, "DS_TYPE_DERIVE", DS_TYPE_TO_STRING(DS_TYPE_DERIVE));
1097         PyModule_AddStringConstant(module, "DS_TYPE_ABSOLUTE", DS_TYPE_TO_STRING(DS_TYPE_ABSOLUTE));
1098         return 0;
1099 }
1100
1101 static int cpy_config(oconfig_item_t *ci) {
1102         PyObject *tb;
1103         int status = 0;
1104
1105         /* Ok in theory we shouldn't do initialization at this point
1106          * but we have to. In order to give python scripts a chance
1107          * to register a config callback we need to be able to execute
1108          * python code during the config callback so we have to start
1109          * the interpreter here. */
1110         /* Do *not* use the python "thread" module at this point! */
1111
1112         if (!Py_IsInitialized() && cpy_init_python()) return 1;
1113
1114         for (int i = 0; i < ci->children_num; ++i) {
1115                 oconfig_item_t *item = ci->children + i;
1116
1117                 if (strcasecmp(item->key, "Interactive") == 0) {
1118                         if (cf_util_get_boolean(item, &do_interactive) != 0) {
1119                                 status = 1;
1120                                 continue;
1121                         }
1122                 } else if (strcasecmp(item->key, "Encoding") == 0) {
1123                         char *encoding = NULL;
1124                         if (cf_util_get_string(item, &encoding) != 0) {
1125                                 status = 1;
1126                                 continue;
1127                         }
1128 #ifdef IS_PY3K
1129                         ERROR("python: \"Encoding\" was used in the config file but Python3 was used, which does not support changing encodings");
1130                         status = 1;
1131                         sfree(encoding);
1132                         continue;
1133 #else
1134                         /* Why is this even necessary? And undocumented? */
1135                         if (PyUnicode_SetDefaultEncoding(encoding)) {
1136                                 cpy_log_exception("setting default encoding");
1137                                 status = 1;
1138                         }
1139 #endif
1140                         sfree(encoding);
1141                 } else if (strcasecmp(item->key, "LogTraces") == 0) {
1142                         _Bool log_traces;
1143                         if (cf_util_get_boolean(item, &log_traces) != 0) {
1144                                 status = 1;
1145                                 continue;
1146                         }
1147                         if (!log_traces) {
1148                                 Py_XDECREF(cpy_format_exception);
1149                                 cpy_format_exception = NULL;
1150                                 continue;
1151                         }
1152                         if (cpy_format_exception)
1153                                 continue;
1154                         tb = PyImport_ImportModule("traceback"); /* New reference. */
1155                         if (tb == NULL) {
1156                                 cpy_log_exception("python initialization");
1157                                 status = 1;
1158                                 continue;
1159                         }
1160                         cpy_format_exception = PyObject_GetAttrString(tb, "format_exception"); /* New reference. */
1161                         Py_DECREF(tb);
1162                         if (cpy_format_exception == NULL) {
1163                                 cpy_log_exception("python initialization");
1164                                 status = 1;
1165                         }
1166                 } else if (strcasecmp(item->key, "ModulePath") == 0) {
1167                         char *dir = NULL;
1168                         PyObject *dir_object;
1169
1170                         if (cf_util_get_string(item, &dir) != 0) {
1171                                 status = 1;
1172                                 continue;
1173                         }
1174                         dir_object = cpy_string_to_unicode_or_bytes(dir); /* New reference. */
1175                         if (dir_object == NULL) {
1176                                 ERROR("python plugin: Unable to convert \"%s\" to "
1177                                       "a python object.", dir);
1178                                 free(dir);
1179                                 cpy_log_exception("python initialization");
1180                                 status = 1;
1181                                 continue;
1182                         }
1183                         if (PyList_Insert(sys_path, 0, dir_object) != 0) {
1184                                 ERROR("python plugin: Unable to prepend \"%s\" to "
1185                                       "python module path.", dir);
1186                                 cpy_log_exception("python initialization");
1187                                 status = 1;
1188                         }
1189                         Py_DECREF(dir_object);
1190                         free(dir);
1191                 } else if (strcasecmp(item->key, "Import") == 0) {
1192                         char *module_name = NULL;
1193                         PyObject *module;
1194
1195                         if (cf_util_get_string(item, &module_name) != 0) {
1196                                 status = 1;
1197                                 continue;
1198                         }
1199                         module = PyImport_ImportModule(module_name); /* New reference. */
1200                         if (module == NULL) {
1201                                 ERROR("python plugin: Error importing module \"%s\".", module_name);
1202                                 cpy_log_exception("importing module");
1203                                 status = 1;
1204                         }
1205                         free(module_name);
1206                         Py_XDECREF(module);
1207                 } else if (strcasecmp(item->key, "Module") == 0) {
1208                         char *name = NULL;
1209                         cpy_callback_t *c;
1210                         PyObject *ret;
1211
1212                         if (cf_util_get_string(item, &name) != 0) {
1213                                 status = 1;
1214                                 continue;
1215                         }
1216                         for (c = cpy_config_callbacks; c; c = c->next) {
1217                                 if (strcasecmp(c->name + 7, name) == 0)
1218                                         break;
1219                         }
1220                         if (c == NULL) {
1221                                 WARNING("python plugin: Found a configuration for the \"%s\" plugin, "
1222                                         "but the plugin isn't loaded or didn't register "
1223                                         "a configuration callback.", name);
1224                                 free(name);
1225                                 continue;
1226                         }
1227                         free(name);
1228                         if (c->data == NULL)
1229                                 ret = PyObject_CallFunction(c->callback, "N",
1230                                         cpy_oconfig_to_pyconfig(item, NULL)); /* New reference. */
1231                         else
1232                                 ret = PyObject_CallFunction(c->callback, "NO",
1233                                         cpy_oconfig_to_pyconfig(item, NULL), c->data); /* New reference. */
1234                         if (ret == NULL) {
1235                                 cpy_log_exception("loading module");
1236                                 status = 1;
1237                         } else
1238                                 Py_DECREF(ret);
1239                 } else {
1240                         ERROR("python plugin: Unknown config key \"%s\".", item->key);
1241                         status = 1;
1242                 }
1243         }
1244         return (status);
1245 }
1246
1247 void module_register(void) {
1248         plugin_register_complex_config("python", cpy_config);
1249         plugin_register_init("python", cpy_init);
1250         plugin_register_shutdown("python", cpy_shutdown);
1251 }