src/pyvalues.c

   1 /**
   2  * collectd - src/pyvalues.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 "collectd.h"
  31 #include "common.h"
  32
  33 #include "cpython.h"
  34
  35 #define FreeAll() do {\
  36         PyMem_Free(type);\
  37         PyMem_Free(plugin_instance);\
  38         PyMem_Free(type_instance);\
  39         PyMem_Free(plugin);\
  40         PyMem_Free(host);\
  41 } while(0)
  42
  43 static PyObject *cpy_common_repr(PyObject *s) {
  44         PyObject *ret, *tmp;
  45         static PyObject *l_type = NULL, *l_type_instance = NULL, *l_plugin = NULL, *l_plugin_instance = NULL;
  46         static PyObject *l_host = NULL, *l_time = NULL;
  47         PluginData *self = (PluginData *) s;
  48
  49         if (l_type == NULL)
  50                 l_type = cpy_string_to_unicode_or_bytes("(type=");
  51         if (l_type_instance == NULL)
  52                 l_type_instance = cpy_string_to_unicode_or_bytes(",type_instance=");
  53         if (l_plugin == NULL)
  54                 l_plugin = cpy_string_to_unicode_or_bytes(",plugin=");
  55         if (l_plugin_instance == NULL)
  56                 l_plugin_instance = cpy_string_to_unicode_or_bytes(",plugin_instance=");
  57         if (l_host == NULL)
  58                 l_host = cpy_string_to_unicode_or_bytes(",host=");
  59         if (l_time == NULL)
  60                 l_time = cpy_string_to_unicode_or_bytes(",time=");
  61
  62         if (!l_type || !l_type_instance || !l_plugin || !l_plugin_instance || !l_host || !l_time)
  63                 return NULL;
  64
  65         ret = cpy_string_to_unicode_or_bytes(s->ob_type->tp_name);
  66
  67         CPY_STRCAT(&ret, l_type);
  68         tmp = cpy_string_to_unicode_or_bytes(self->type);
  69         CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
  70         CPY_STRCAT_AND_DEL(&ret, tmp);
  71
  72         if (self->type_instance[0] != 0) {
  73                 CPY_STRCAT(&ret, l_type_instance);
  74                 tmp = cpy_string_to_unicode_or_bytes(self->type_instance);
  75                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
  76                 CPY_STRCAT_AND_DEL(&ret, tmp);
  77         }
  78
  79         if (self->plugin[0] != 0) {
  80                 CPY_STRCAT(&ret, l_plugin);
  81                 tmp = cpy_string_to_unicode_or_bytes(self->plugin);
  82                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
  83                 CPY_STRCAT_AND_DEL(&ret, tmp);
  84         }
  85
  86         if (self->plugin_instance[0] != 0) {
  87                 CPY_STRCAT(&ret, l_plugin_instance);
  88                 tmp = cpy_string_to_unicode_or_bytes(self->plugin_instance);
  89                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
  90                 CPY_STRCAT_AND_DEL(&ret, tmp);
  91         }
  92
  93         if (self->host[0] != 0) {
  94                 CPY_STRCAT(&ret, l_host);
  95                 tmp = cpy_string_to_unicode_or_bytes(self->host);
  96                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
  97                 CPY_STRCAT_AND_DEL(&ret, tmp);
  98         }
  99
 100         if (self->time != 0) {
 101                 CPY_STRCAT(&ret, l_time);
 102                 tmp = PyFloat_FromDouble(self->time);
 103                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
 104                 CPY_STRCAT_AND_DEL(&ret, tmp);
 105         }
 106         return ret;
 107 }
 108
 109 static char time_doc[] = "This is the Unix timestap of the time this value was read.\n"
 110                 "For dispatching values this can be set to 0 which means \"now\".\n"
 111                 "This means the time the value is actually dispatched, not the time\n"
 112                 "it was set to 0.";
 113
 114 static char host_doc[] = "The hostname of the host this value was read from.\n"
 115                 "For dispatching this can be set to an empty string which means\n"
 116                 "the local hostname as defined in the collectd.conf.";
 117
 118 static char type_doc[] = "The type of this value. This type has to be defined\n"
 119                 "in your types.db. Attempting to set it to any other value will\n"
 120                 "raise a TypeError exception.\n"
 121                 "Assigning a type is mandetory, calling dispatch without doing\n"
 122                 "so will raise a RuntimeError exception.";
 123
 124 static char type_instance_doc[] = "";
 125
 126 static char plugin_doc[] = "The name of the plugin that read the data. Setting this\n"
 127                 "member to an empty string will insert \"python\" upon dispatching.";
 128
 129 static char plugin_instance_doc[] = "";
 130
 131 static char PluginData_doc[] = "This is an internal class that is the base for Values\n"
 132                 "and Notification. It is pretty useless by itself and was therefore not\n"
 133                 "exported to the collectd module.";
 134
 135 static PyObject *PluginData_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
 136         PluginData *self;
 137
 138         self = (PluginData *) type->tp_alloc(type, 0);
 139         if (self == NULL)
 140                 return NULL;
 141
 142         self->time = 0;
 143         self->host[0] = 0;
 144         self->plugin[0] = 0;
 145         self->plugin_instance[0] = 0;
 146         self->type[0] = 0;
 147         self->type_instance[0] = 0;
 148         return (PyObject *) self;
 149 }
 150
 151 static int PluginData_init(PyObject *s, PyObject *args, PyObject *kwds) {
 152         PluginData *self = (PluginData *) s;
 153         double time = 0;
 154         char *type = NULL, *plugin_instance = NULL, *type_instance = NULL, *plugin = NULL, *host = NULL;
 155         static char *kwlist[] = {"type", "plugin_instance", "type_instance",
 156                         "plugin", "host", "time", NULL};
 157
 158         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etetetetetd", kwlist, NULL, &type,
 159                         NULL, &plugin_instance, NULL, &type_instance, NULL, &plugin, NULL, &host, &time))
 160                 return -1;
 161
 162         if (type && plugin_get_ds(type) == NULL) {
 163                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", type);
 164                 FreeAll();
 165                 return -1;
 166         }
 167
 168         sstrncpy(self->host, host ? host : "", sizeof(self->host));
 169         sstrncpy(self->plugin, plugin ? plugin : "", sizeof(self->plugin));
 170         sstrncpy(self->plugin_instance, plugin_instance ? plugin_instance : "", sizeof(self->plugin_instance));
 171         sstrncpy(self->type, type ? type : "", sizeof(self->type));
 172         sstrncpy(self->type_instance, type_instance ? type_instance : "", sizeof(self->type_instance));
 173         self->time = time;
 174
 175         FreeAll();
 176
 177         return 0;
 178 }
 179
 180 static PyObject *PluginData_repr(PyObject *s) {
 181         PyObject *ret;
 182         static PyObject *l_closing = NULL;
 183
 184         if (l_closing == NULL)
 185                 l_closing = cpy_string_to_unicode_or_bytes(")");
 186
 187         if (l_closing == NULL)
 188                 return NULL;
 189
 190         ret = cpy_common_repr(s);
 191         CPY_STRCAT(&ret, l_closing);
 192         return ret;
 193 }
 194
 195 static PyMemberDef PluginData_members[] = {
 196         {"time", T_DOUBLE, offsetof(PluginData, time), 0, time_doc},
 197         {NULL}
 198 };
 199
 200 static PyObject *PluginData_getstring(PyObject *self, void *data) {
 201         const char *value = ((char *) self) + (intptr_t) data;
 202
 203         return cpy_string_to_unicode_or_bytes(value);
 204 }
 205
 206 static int PluginData_setstring(PyObject *self, PyObject *value, void *data) {
 207         char *old;
 208         const char *new;
 209
 210         if (value == NULL) {
 211                 PyErr_SetString(PyExc_TypeError, "Cannot delete this attribute");
 212                 return -1;
 213         }
 214         Py_INCREF(value);
 215         new = cpy_unicode_or_bytes_to_string(&value);
 216         if (new == NULL) {
 217                 Py_DECREF(value);
 218                 return -1;
 219         }
 220         old = ((char *) self) + (intptr_t) data;
 221         sstrncpy(old, new, DATA_MAX_NAME_LEN);
 222         Py_DECREF(value);
 223         return 0;
 224 }
 225
 226 static int PluginData_settype(PyObject *self, PyObject *value, void *data) {
 227         char *old;
 228         const char *new;
 229
 230         if (value == NULL) {
 231                 PyErr_SetString(PyExc_TypeError, "Cannot delete this attribute");
 232                 return -1;
 233         }
 234         Py_INCREF(value);
 235         new = cpy_unicode_or_bytes_to_string(&value);
 236         if (new == NULL) {
 237                 Py_DECREF(value);
 238                 return -1;
 239         }
 240
 241         if (plugin_get_ds(new) == NULL) {
 242                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", new);
 243                 Py_DECREF(value);
 244                 return -1;
 245         }
 246
 247         old = ((char *) self) + (intptr_t) data;
 248         sstrncpy(old, new, DATA_MAX_NAME_LEN);
 249         Py_DECREF(value);
 250         return 0;
 251 }
 252
 253 static PyGetSetDef PluginData_getseters[] = {
 254         {"host", PluginData_getstring, PluginData_setstring, host_doc, (void *) offsetof(PluginData, host)},
 255         {"plugin", PluginData_getstring, PluginData_setstring, plugin_doc, (void *) offsetof(PluginData, plugin)},
 256         {"plugin_instance", PluginData_getstring, PluginData_setstring, plugin_instance_doc, (void *) offsetof(PluginData, plugin_instance)},
 257         {"type_instance", PluginData_getstring, PluginData_setstring, type_instance_doc, (void *) offsetof(PluginData, type_instance)},
 258         {"type", PluginData_getstring, PluginData_settype, type_doc, (void *) offsetof(PluginData, type)},
 259         {NULL}
 260 };
 261
 262 PyTypeObject PluginDataType = {
 263         CPY_INIT_TYPE
 264         "collectd.PluginData",     /* tp_name */
 265         sizeof(PluginData),        /* tp_basicsize */
 266         0,                         /* Will be filled in later */
 267         0,                         /* tp_dealloc */
 268         0,                         /* tp_print */
 269         0,                         /* tp_getattr */
 270         0,                         /* tp_setattr */
 271         0,                         /* tp_compare */
 272         PluginData_repr,           /* tp_repr */
 273         0,                         /* tp_as_number */
 274         0,                         /* tp_as_sequence */
 275         0,                         /* tp_as_mapping */
 276         0,                         /* tp_hash */
 277         0,                         /* tp_call */
 278         0,                         /* tp_str */
 279         0,                         /* tp_getattro */
 280         0,                         /* tp_setattro */
 281         0,                         /* tp_as_buffer */
 282         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE /*| Py_TPFLAGS_HAVE_GC*/, /*tp_flags*/
 283         PluginData_doc,            /* tp_doc */
 284         0,                         /* tp_traverse */
 285         0,                         /* tp_clear */
 286         0,                         /* tp_richcompare */
 287         0,                         /* tp_weaklistoffset */
 288         0,                         /* tp_iter */
 289         0,                         /* tp_iternext */
 290         0,                         /* tp_methods */
 291         PluginData_members,        /* tp_members */
 292         PluginData_getseters,      /* tp_getset */
 293         0,                         /* tp_base */
 294         0,                         /* tp_dict */
 295         0,                         /* tp_descr_get */
 296         0,                         /* tp_descr_set */
 297         0,                         /* tp_dictoffset */
 298         PluginData_init,           /* tp_init */
 299         0,                         /* tp_alloc */
 300         PluginData_new             /* tp_new */
 301 };
 302
 303 static char interval_doc[] = "The interval is the timespan in seconds between two submits for\n"
 304                 "the same data source. This value has to be a positive integer, so you can't\n"
 305                 "submit more than one value per second. If this member is set to a\n"
 306                 "non-positive value, the default value as specified in the config file will\n"
 307                 "be used (default: 10).\n"
 308                 "\n"
 309                 "If you submit values more often than the specified interval, the average\n"
 310                 "will be used. If you submit less values, your graphs will have gaps.";
 311
 312 static char values_doc[] = "These are the actual values that get dispatched to collectd.\n"
 313                 "It has to be a sequence (a tuple or list) of numbers.\n"
 314                 "The size of the sequence and the type of its content depend on the type\n"
 315                 "member your types.db file. For more information on this read the types.db\n"
 316                 "man page.\n"
 317                 "\n"
 318                 "If the sequence does not have the correct size upon dispatch a RuntimeError\n"
 319                 "exception will be raised. If the content of the sequence is not a number,\n"
 320                 "a TypeError exception will be raised.";
 321
 322 static char meta_doc[] = "These are the meta data for this Value object.\n"
 323                 "It has to be a dictionary of numbers, strings or bools. All keys must be\n"
 324                 "strings. int and long objects will be dispatched as signed integers unless\n"
 325                 "they are between 2**63 and 2**64-1, which will result in a unsigned integer.\n"
 326                 "You can force one of these storage classes by using the classes\n"
 327                 "collectd.Signed and collectd.Unsigned. A meta object received by a write\n"
 328                 "callback will always contain Signed or Unsigned objects.";
 329
 330 static char dispatch_doc[] = "dispatch([type][, values][, plugin_instance][, type_instance]"
 331                 "[, plugin][, host][, time][, interval]) -> None.  Dispatch a value list.\n"
 332                 "\n"
 333                 "Dispatch this instance to the collectd process. The object has members\n"
 334                 "for each of the possible arguments for this method. For a detailed explanation\n"
 335                 "of these parameters see the member of the same same.\n"
 336                 "\n"
 337                 "If you do not submit a parameter the value saved in its member will be submitted.\n"
 338                 "If you do provide a parameter it will be used instead, without altering the member.";
 339
 340 static char write_doc[] = "write([destination][, type][, values][, plugin_instance][, type_instance]"
 341                 "[, plugin][, host][, time][, interval]) -> None.  Dispatch a value list.\n"
 342                 "\n"
 343                 "Write this instance to a single plugin or all plugins if 'destination' is obmitted.\n"
 344                 "This will bypass the main collectd process and all filtering and caching.\n"
 345                 "Other than that it works similar to 'dispatch'. In most cases 'dispatch' should be\n"
 346                 "used instead of 'write'.\n";
 347
 348 static char Values_doc[] = "A Values object used for dispatching values to collectd and receiving values from write callbacks.";
 349
 350 static PyObject *Values_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
 351         Values *self;
 352
 353         self = (Values *) PluginData_new(type, args, kwds);
 354         if (self == NULL)
 355                 return NULL;
 356
 357         self->values = PyList_New(0);
 358         self->meta = PyDict_New();
 359         self->interval = 0;
 360         return (PyObject *) self;
 361 }
 362
 363 static int Values_init(PyObject *s, PyObject *args, PyObject *kwds) {
 364         Values *self = (Values *) s;
 365         double interval = 0, time = 0;
 366         PyObject *values = NULL, *meta = NULL, *tmp;
 367         char *type = NULL, *plugin_instance = NULL, *type_instance = NULL, *plugin = NULL, *host = NULL;
 368         static char *kwlist[] = {"type", "values", "plugin_instance", "type_instance",
 369                         "plugin", "host", "time", "interval", "meta", NULL};
 370
 371         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etOetetetetddO", kwlist,
 372                         NULL, &type, &values, NULL, &plugin_instance, NULL, &type_instance,
 373                         NULL, &plugin, NULL, &host, &time, &interval, &meta))
 374                 return -1;
 375
 376         if (type && plugin_get_ds(type) == NULL) {
 377                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", type);
 378                 FreeAll();
 379                 return -1;
 380         }
 381
 382         sstrncpy(self->data.host, host ? host : "", sizeof(self->data.host));
 383         sstrncpy(self->data.plugin, plugin ? plugin : "", sizeof(self->data.plugin));
 384         sstrncpy(self->data.plugin_instance, plugin_instance ? plugin_instance : "", sizeof(self->data.plugin_instance));
 385         sstrncpy(self->data.type, type ? type : "", sizeof(self->data.type));
 386         sstrncpy(self->data.type_instance, type_instance ? type_instance : "", sizeof(self->data.type_instance));
 387         self->data.time = time;
 388
 389         FreeAll();
 390
 391         if (values == NULL) {
 392                 values = PyList_New(0);
 393                 PyErr_Clear();
 394         } else {
 395                 Py_INCREF(values);
 396         }
 397
 398         if (meta == NULL) {
 399                 meta = PyDict_New();
 400                 PyErr_Clear();
 401         } else {
 402                 Py_INCREF(meta);
 403         }
 404
 405         tmp = self->values;
 406         self->values = values;
 407         Py_XDECREF(tmp);
 408
 409         tmp = self->meta;
 410         self->meta = meta;
 411         Py_XDECREF(tmp);
 412
 413         self->interval = interval;
 414         return 0;
 415 }
 416
 417 static meta_data_t *cpy_build_meta(PyObject *meta) {
 418         int i, s;
 419         meta_data_t *m = NULL;
 420         PyObject *l;
 421
 422         if ((meta == NULL) || (meta == Py_None))
 423                 return NULL;
 424
 425         l = PyDict_Items(meta); /* New reference. */
 426         if (!l) {
 427                 cpy_log_exception("building meta data");
 428                 return NULL;
 429         }
 430         s = PyList_Size(l);
 431         if (s <= 0) {
 432                 Py_XDECREF(l);
 433                 return NULL;
 434         }
 435
 436         m = meta_data_create();
 437         for (i = 0; i < s; ++i) {
 438                 const char *string, *keystring;
 439                 PyObject *key, *value, *item, *tmp;
 440
 441                 item = PyList_GET_ITEM(l, i);
 442                 key = PyTuple_GET_ITEM(item, 0);
 443                 Py_INCREF(key);
 444                 keystring = cpy_unicode_or_bytes_to_string(&key);
 445                 if (!keystring) {
 446                         PyErr_Clear();
 447                         Py_XDECREF(key);
 448                         continue;
 449                 }
 450                 value = PyTuple_GET_ITEM(item, 1);
 451                 Py_INCREF(value);
 452                 if (value == Py_True) {
 453                         meta_data_add_boolean(m, keystring, 1);
 454                 } else if (value == Py_False) {
 455                         meta_data_add_boolean(m, keystring, 0);
 456                 } else if (PyFloat_Check(value)) {
 457                         meta_data_add_double(m, keystring, PyFloat_AsDouble(value));
 458                 } else if (PyObject_TypeCheck(value, &SignedType)) {
 459                         long long int lli;
 460                         lli = PyLong_AsLongLong(value);
 461                         if (!PyErr_Occurred() && (lli == (int64_t) lli))
 462                                 meta_data_add_signed_int(m, keystring, lli);
 463                 } else if (PyObject_TypeCheck(value, &UnsignedType)) {
 464                         long long unsigned llu;
 465                         llu = PyLong_AsUnsignedLongLong(value);
 466                         if (!PyErr_Occurred() && (llu == (uint64_t) llu))
 467                                 meta_data_add_unsigned_int(m, keystring, llu);
 468                 } else if (PyNumber_Check(value)) {
 469                         long long int lli;
 470                         long long unsigned llu;
 471                         tmp = PyNumber_Long(value);
 472                         lli = PyLong_AsLongLong(tmp);
 473                         if (!PyErr_Occurred() && (lli == (int64_t) lli)) {
 474                                 meta_data_add_signed_int(m, keystring, lli);
 475                         } else {
 476                                 PyErr_Clear();
 477                                 llu = PyLong_AsUnsignedLongLong(tmp);
 478                                 if (!PyErr_Occurred() && (llu == (uint64_t) llu))
 479                                         meta_data_add_unsigned_int(m, keystring, llu);
 480                         }
 481                         Py_XDECREF(tmp);
 482                 } else {
 483                         string = cpy_unicode_or_bytes_to_string(&value);
 484                         if (string) {
 485                                 meta_data_add_string(m, keystring, string);
 486                         } else {
 487                                 PyErr_Clear();
 488                                 tmp = PyObject_Str(value);
 489                                 string = cpy_unicode_or_bytes_to_string(&tmp);
 490                                 if (string)
 491                                         meta_data_add_string(m, keystring, string);
 492                                 Py_XDECREF(tmp);
 493                         }
 494                 }
 495                 if (PyErr_Occurred())
 496                         cpy_log_exception("building meta data");
 497                 Py_XDECREF(value);
 498                 Py_DECREF(key);
 499         }
 500         Py_XDECREF(l);
 501         return m;
 502 }
 503
 504 static PyObject *Values_dispatch(Values *self, PyObject *args, PyObject *kwds) {
 505         int i, ret;
 506         const data_set_t *ds;
 507         int size;
 508         value_t *value;
 509         value_list_t value_list = VALUE_LIST_INIT;
 510         PyObject *values = self->values, *meta = self->meta;
 511         double time = self->data.time, interval = self->interval;
 512         char *host = NULL, *plugin = NULL, *plugin_instance = NULL, *type = NULL, *type_instance = NULL;
 513
 514         static char *kwlist[] = {"type", "values", "plugin_instance", "type_instance",
 515                         "plugin", "host", "time", "interval", "meta", NULL};
 516         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etOetetetetddO", kwlist,
 517                         NULL, &type, &values, NULL, &plugin_instance, NULL, &type_instance,
 518                         NULL, &plugin, NULL, &host, &time, &interval, &meta))
 519                 return NULL;
 520
 521         sstrncpy(value_list.host, host ? host : self->data.host, sizeof(value_list.host));
 522         sstrncpy(value_list.plugin, plugin ? plugin : self->data.plugin, sizeof(value_list.plugin));
 523         sstrncpy(value_list.plugin_instance, plugin_instance ? plugin_instance : self->data.plugin_instance, sizeof(value_list.plugin_instance));
 524         sstrncpy(value_list.type, type ? type : self->data.type, sizeof(value_list.type));
 525         sstrncpy(value_list.type_instance, type_instance ? type_instance : self->data.type_instance, sizeof(value_list.type_instance));
 526         FreeAll();
 527         if (value_list.type[0] == 0) {
 528                 PyErr_SetString(PyExc_RuntimeError, "type not set");
 529                 FreeAll();
 530                 return NULL;
 531         }
 532         ds = plugin_get_ds(value_list.type);
 533         if (ds == NULL) {
 534                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", value_list.type);
 535                 return NULL;
 536         }
 537         if (values == NULL || (PyTuple_Check(values) == 0 && PyList_Check(values) == 0)) {
 538                 PyErr_Format(PyExc_TypeError, "values must be list or tuple");
 539                 return NULL;
 540         }
 541         if (meta != NULL && meta != Py_None && !PyDict_Check(meta)) {
 542                 PyErr_Format(PyExc_TypeError, "meta must be a dict");
 543                 return NULL;
 544         }
 545         size = (int) PySequence_Length(values);
 546         if (size != ds->ds_num) {
 547                 PyErr_Format(PyExc_RuntimeError, "type %s needs %d values, got %i", value_list.type, ds->ds_num, size);
 548                 return NULL;
 549         }
 550         value = malloc(size * sizeof(*value));
 551         for (i = 0; i < size; ++i) {
 552                 PyObject *item, *num;
 553                 item = PySequence_Fast_GET_ITEM(values, i); /* Borrowed reference. */
 554                 if (ds->ds->type == DS_TYPE_COUNTER) {
 555                         num = PyNumber_Long(item); /* New reference. */
 556                         if (num != NULL) {
 557                                 value[i].counter = PyLong_AsUnsignedLongLong(num);
 558                                 Py_XDECREF(num);
 559                         }
 560                 } else if (ds->ds->type == DS_TYPE_GAUGE) {
 561                         num = PyNumber_Float(item); /* New reference. */
 562                         if (num != NULL) {
 563                                 value[i].gauge = PyFloat_AsDouble(num);
 564                                 Py_XDECREF(num);
 565                         }
 566                 } else if (ds->ds->type == DS_TYPE_DERIVE) {
 567                         /* This might overflow without raising an exception.
 568                          * Not much we can do about it */
 569                         num = PyNumber_Long(item); /* New reference. */
 570                         if (num != NULL) {
 571                                 value[i].derive = PyLong_AsLongLong(num);
 572                                 Py_XDECREF(num);
 573                         }
 574                 } else if (ds->ds->type == DS_TYPE_ABSOLUTE) {
 575                         /* This might overflow without raising an exception.
 576                          * Not much we can do about it */
 577                         num = PyNumber_Long(item); /* New reference. */
 578                         if (num != NULL) {
 579                                 value[i].absolute = PyLong_AsUnsignedLongLong(num);
 580                                 Py_XDECREF(num);
 581                         }
 582                 } else {
 583                         free(value);
 584                         PyErr_Format(PyExc_RuntimeError, "unknown data type %d for %s", ds->ds->type, value_list.type);
 585                         return NULL;
 586                 }
 587                 if (PyErr_Occurred() != NULL) {
 588                         free(value);
 589                         return NULL;
 590                 }
 591         }
 592         value_list.values = value;
 593         value_list.meta = cpy_build_meta(meta);
 594         value_list.values_len = size;
 595         value_list.time = DOUBLE_TO_CDTIME_T(time);
 596         value_list.interval = DOUBLE_TO_CDTIME_T(interval);
 597         if (value_list.host[0] == 0)
 598                 sstrncpy(value_list.host, hostname_g, sizeof(value_list.host));
 599         if (value_list.plugin[0] == 0)
 600                 sstrncpy(value_list.plugin, "python", sizeof(value_list.plugin));
 601         Py_BEGIN_ALLOW_THREADS;
 602         ret = plugin_dispatch_values(&value_list);
 603         Py_END_ALLOW_THREADS;
 604         meta_data_destroy(value_list.meta);
 605         free(value);
 606         if (ret != 0) {
 607                 PyErr_SetString(PyExc_RuntimeError, "error dispatching values, read the logs");
 608                 return NULL;
 609         }
 610         Py_RETURN_NONE;
 611 }
 612
 613 static PyObject *Values_write(Values *self, PyObject *args, PyObject *kwds) {
 614         int i, ret;
 615         const data_set_t *ds;
 616         int size;
 617         value_t *value;
 618         value_list_t value_list = VALUE_LIST_INIT;
 619         PyObject *values = self->values, *meta = self->meta;
 620         double time = self->data.time, interval = self->interval;
 621         char *host = NULL, *plugin = NULL, *plugin_instance = NULL, *type = NULL, *type_instance = NULL, *dest = NULL;
 622
 623         static char *kwlist[] = {"destination", "type", "values", "plugin_instance", "type_instance",
 624                         "plugin", "host", "time", "interval", "meta", NULL};
 625         if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|etOetetetetdiO", kwlist, NULL, &dest,
 626                         NULL, &type, &values, NULL, &plugin_instance, NULL, &type_instance,
 627                         NULL, &plugin, NULL, &host, &time, &interval, &meta))
 628                 return NULL;
 629
 630         sstrncpy(value_list.host, host ? host : self->data.host, sizeof(value_list.host));
 631         sstrncpy(value_list.plugin, plugin ? plugin : self->data.plugin, sizeof(value_list.plugin));
 632         sstrncpy(value_list.plugin_instance, plugin_instance ? plugin_instance : self->data.plugin_instance, sizeof(value_list.plugin_instance));
 633         sstrncpy(value_list.type, type ? type : self->data.type, sizeof(value_list.type));
 634         sstrncpy(value_list.type_instance, type_instance ? type_instance : self->data.type_instance, sizeof(value_list.type_instance));
 635         FreeAll();
 636         if (value_list.type[0] == 0) {
 637                 PyErr_SetString(PyExc_RuntimeError, "type not set");
 638                 return NULL;
 639         }
 640         ds = plugin_get_ds(value_list.type);
 641         if (ds == NULL) {
 642                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", value_list.type);
 643                 return NULL;
 644         }
 645         if (values == NULL || (PyTuple_Check(values) == 0 && PyList_Check(values) == 0)) {
 646                 PyErr_Format(PyExc_TypeError, "values must be list or tuple");
 647                 return NULL;
 648         }
 649         size = (int) PySequence_Length(values);
 650         if (size != ds->ds_num) {
 651                 PyErr_Format(PyExc_RuntimeError, "type %s needs %d values, got %i", value_list.type, ds->ds_num, size);
 652                 return NULL;
 653         }
 654         value = malloc(size * sizeof(*value));
 655         for (i = 0; i < size; ++i) {
 656                 PyObject *item, *num;
 657                 item = PySequence_Fast_GET_ITEM(values, i); /* Borrowed reference. */
 658                 if (ds->ds->type == DS_TYPE_COUNTER) {
 659                         num = PyNumber_Long(item); /* New reference. */
 660                         if (num != NULL) {
 661                                 value[i].counter = PyLong_AsUnsignedLongLong(num);
 662                                 Py_XDECREF(num);
 663                         }
 664                 } else if (ds->ds->type == DS_TYPE_GAUGE) {
 665                         num = PyNumber_Float(item); /* New reference. */
 666                         if (num != NULL) {
 667                                 value[i].gauge = PyFloat_AsDouble(num);
 668                                 Py_XDECREF(num);
 669                         }
 670                 } else if (ds->ds->type == DS_TYPE_DERIVE) {
 671                         /* This might overflow without raising an exception.
 672                          * Not much we can do about it */
 673                         num = PyNumber_Long(item); /* New reference. */
 674                         if (num != NULL) {
 675                                 value[i].derive = PyLong_AsLongLong(num);
 676                                 Py_XDECREF(num);
 677                         }
 678                 } else if (ds->ds->type == DS_TYPE_ABSOLUTE) {
 679                         /* This might overflow without raising an exception.
 680                          * Not much we can do about it */
 681                         num = PyNumber_Long(item); /* New reference. */
 682                         if (num != NULL) {
 683                                 value[i].absolute = PyLong_AsUnsignedLongLong(num);
 684                                 Py_XDECREF(num);
 685                         }
 686                 } else {
 687                         free(value);
 688                         PyErr_Format(PyExc_RuntimeError, "unknown data type %d for %s", ds->ds->type, value_list.type);
 689                         return NULL;
 690                 }
 691                 if (PyErr_Occurred() != NULL) {
 692                         free(value);
 693                         return NULL;
 694                 }
 695         }
 696         value_list.values = value;
 697         value_list.values_len = size;
 698         value_list.time = DOUBLE_TO_CDTIME_T(time);
 699         value_list.interval = DOUBLE_TO_CDTIME_T(interval);
 700         value_list.meta = cpy_build_meta(meta);;
 701         if (value_list.host[0] == 0)
 702                 sstrncpy(value_list.host, hostname_g, sizeof(value_list.host));
 703         if (value_list.plugin[0] == 0)
 704                 sstrncpy(value_list.plugin, "python", sizeof(value_list.plugin));
 705         Py_BEGIN_ALLOW_THREADS;
 706         ret = plugin_write(dest, NULL, &value_list);
 707         Py_END_ALLOW_THREADS;
 708         meta_data_destroy(value_list.meta);
 709         free(value);
 710         if (ret != 0) {
 711                 PyErr_SetString(PyExc_RuntimeError, "error dispatching values, read the logs");
 712                 return NULL;
 713         }
 714         Py_RETURN_NONE;
 715 }
 716
 717 static PyObject *Values_repr(PyObject *s) {
 718         PyObject *ret, *tmp;
 719         static PyObject *l_interval = NULL, *l_values = NULL, *l_meta = NULL, *l_closing = NULL;
 720         Values *self = (Values *) s;
 721
 722         if (l_interval == NULL)
 723                 l_interval = cpy_string_to_unicode_or_bytes(",interval=");
 724         if (l_values == NULL)
 725                 l_values = cpy_string_to_unicode_or_bytes(",values=");
 726         if (l_meta == NULL)
 727                 l_meta = cpy_string_to_unicode_or_bytes(",meta=");
 728         if (l_closing == NULL)
 729                 l_closing = cpy_string_to_unicode_or_bytes(")");
 730
 731         if (l_interval == NULL || l_values == NULL || l_meta == NULL || l_closing == NULL)
 732                 return NULL;
 733
 734         ret = cpy_common_repr(s);
 735         if (self->interval != 0) {
 736                 CPY_STRCAT(&ret, l_interval);
 737                 tmp = PyFloat_FromDouble(self->interval);
 738                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
 739                 CPY_STRCAT_AND_DEL(&ret, tmp);
 740         }
 741         if (self->values && (!PyList_Check(self->values) || PySequence_Length(self->values) > 0)) {
 742                 CPY_STRCAT(&ret, l_values);
 743                 tmp = PyObject_Repr(self->values);
 744                 CPY_STRCAT_AND_DEL(&ret, tmp);
 745         }
 746         if (self->meta && (!PyDict_Check(self->meta) || PyDict_Size(self->meta) > 0)) {
 747                 CPY_STRCAT(&ret, l_meta);
 748                 tmp = PyObject_Repr(self->meta);
 749                 CPY_STRCAT_AND_DEL(&ret, tmp);
 750         }
 751         CPY_STRCAT(&ret, l_closing);
 752         return ret;
 753 }
 754
 755 static int Values_traverse(PyObject *self, visitproc visit, void *arg) {
 756         Values *v = (Values *) self;
 757         Py_VISIT(v->values);
 758         Py_VISIT(v->meta);
 759         return 0;
 760 }
 761
 762 static int Values_clear(PyObject *self) {
 763         Values *v = (Values *) self;
 764         Py_CLEAR(v->values);
 765         Py_CLEAR(v->meta);
 766         return 0;
 767 }
 768
 769 static void Values_dealloc(PyObject *self) {
 770         Values_clear(self);
 771         self->ob_type->tp_free(self);
 772 }
 773
 774 static PyMemberDef Values_members[] = {
 775         {"interval", T_DOUBLE, offsetof(Values, interval), 0, interval_doc},
 776         {"values", T_OBJECT_EX, offsetof(Values, values), 0, values_doc},
 777         {"meta", T_OBJECT_EX, offsetof(Values, meta), 0, meta_doc},
 778         {NULL}
 779 };
 780
 781 static PyMethodDef Values_methods[] = {
 782         {"dispatch", (PyCFunction) Values_dispatch, METH_VARARGS | METH_KEYWORDS, dispatch_doc},
 783         {"write", (PyCFunction) Values_write, METH_VARARGS | METH_KEYWORDS, write_doc},
 784         {NULL}
 785 };
 786
 787 PyTypeObject ValuesType = {
 788         CPY_INIT_TYPE
 789         "collectd.Values",         /* tp_name */
 790         sizeof(Values),            /* tp_basicsize */
 791         0,                         /* Will be filled in later */
 792         Values_dealloc,            /* tp_dealloc */
 793         0,                         /* tp_print */
 794         0,                         /* tp_getattr */
 795         0,                         /* tp_setattr */
 796         0,                         /* tp_compare */
 797         Values_repr,               /* tp_repr */
 798         0,                         /* tp_as_number */
 799         0,                         /* tp_as_sequence */
 800         0,                         /* tp_as_mapping */
 801         0,                         /* tp_hash */
 802         0,                         /* tp_call */
 803         0,                         /* tp_str */
 804         0,                         /* tp_getattro */
 805         0,                         /* tp_setattro */
 806         0,                         /* tp_as_buffer */
 807         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
 808         Values_doc,                /* tp_doc */
 809         Values_traverse,           /* tp_traverse */
 810         Values_clear,              /* tp_clear */
 811         0,                         /* tp_richcompare */
 812         0,                         /* tp_weaklistoffset */
 813         0,                         /* tp_iter */
 814         0,                         /* tp_iternext */
 815         Values_methods,            /* tp_methods */
 816         Values_members,            /* tp_members */
 817         0,                         /* tp_getset */
 818         0,                         /* tp_base */
 819         0,                         /* tp_dict */
 820         0,                         /* tp_descr_get */
 821         0,                         /* tp_descr_set */
 822         0,                         /* tp_dictoffset */
 823         Values_init,               /* tp_init */
 824         0,                         /* tp_alloc */
 825         Values_new                 /* tp_new */
 826 };
 827
 828 static char severity_doc[] = "The severity of this notification. Assign or compare to\n"
 829                 "NOTIF_FAILURE, NOTIF_WARNING or NOTIF_OKAY.";
 830
 831 static char message_doc[] = "Some kind of description what's going on and why this Notification was generated.";
 832
 833 static char Notification_doc[] = "The Notification class is a wrapper around the collectd notification.\n"
 834                 "It can be used to notify other plugins about bad stuff happening. It works\n"
 835                 "similar to Values but has a severity and a message instead of interval\n"
 836                 "and time.\n"
 837                 "Notifications can be dispatched at any time and can be received with register_notification.";
 838
 839 static int Notification_init(PyObject *s, PyObject *args, PyObject *kwds) {
 840         Notification *self = (Notification *) s;
 841         int severity = 0;
 842         double time = 0;
 843         char *message = NULL;
 844         char *type = NULL, *plugin_instance = NULL, *type_instance = NULL, *plugin = NULL, *host = NULL;
 845         static char *kwlist[] = {"type", "message", "plugin_instance", "type_instance",
 846                         "plugin", "host", "time", "severity", NULL};
 847
 848         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etetetetetetdi", kwlist,
 849                         NULL, &type, NULL, &message, NULL, &plugin_instance, NULL, &type_instance,
 850                         NULL, &plugin, NULL, &host, &time, &severity))
 851                 return -1;
 852
 853         if (type && plugin_get_ds(type) == NULL) {
 854                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", type);
 855                 FreeAll();
 856                 PyMem_Free(message);
 857                 return -1;
 858         }
 859
 860         sstrncpy(self->data.host, host ? host : "", sizeof(self->data.host));
 861         sstrncpy(self->data.plugin, plugin ? plugin : "", sizeof(self->data.plugin));
 862         sstrncpy(self->data.plugin_instance, plugin_instance ? plugin_instance : "", sizeof(self->data.plugin_instance));
 863         sstrncpy(self->data.type, type ? type : "", sizeof(self->data.type));
 864         sstrncpy(self->data.type_instance, type_instance ? type_instance : "", sizeof(self->data.type_instance));
 865         sstrncpy(self->message, message ? message : "", sizeof(self->message));
 866         self->data.time = time;
 867         self->severity = severity;
 868
 869         FreeAll();
 870         PyMem_Free(message);
 871         return 0;
 872 }
 873
 874 static PyObject *Notification_dispatch(Notification *self, PyObject *args, PyObject *kwds) {
 875         int ret;
 876         const data_set_t *ds;
 877         notification_t notification;
 878         double t = self->data.time;
 879         int severity = self->severity;
 880         char *host = NULL, *plugin = NULL, *plugin_instance = NULL, *type = NULL, *type_instance = NULL;
 881         char *message = NULL;
 882
 883         static char *kwlist[] = {"type", "message", "plugin_instance", "type_instance",
 884                         "plugin", "host", "time", "severity", NULL};
 885         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|etetetetetetdi", kwlist,
 886                         NULL, &type, NULL, &message, NULL, &plugin_instance, NULL, &type_instance,
 887                         NULL, &plugin, NULL, &host, &t, &severity))
 888                 return NULL;
 889
 890         notification.time = DOUBLE_TO_CDTIME_T(t);
 891         notification.severity = severity;
 892         sstrncpy(notification.message, message ? message : self->message, sizeof(notification.message));
 893         sstrncpy(notification.host, host ? host : self->data.host, sizeof(notification.host));
 894         sstrncpy(notification.plugin, plugin ? plugin : self->data.plugin, sizeof(notification.plugin));
 895         sstrncpy(notification.plugin_instance, plugin_instance ? plugin_instance : self->data.plugin_instance, sizeof(notification.plugin_instance));
 896         sstrncpy(notification.type, type ? type : self->data.type, sizeof(notification.type));
 897         sstrncpy(notification.type_instance, type_instance ? type_instance : self->data.type_instance, sizeof(notification.type_instance));
 898         notification.meta = NULL;
 899         FreeAll();
 900         PyMem_Free(message);
 901
 902         if (notification.type[0] == 0) {
 903                 PyErr_SetString(PyExc_RuntimeError, "type not set");
 904                 return NULL;
 905         }
 906         ds = plugin_get_ds(notification.type);
 907         if (ds == NULL) {
 908                 PyErr_Format(PyExc_TypeError, "Dataset %s not found", notification.type);
 909                 return NULL;
 910         }
 911
 912         if (notification.time == 0)
 913                 notification.time = cdtime();
 914         if (notification.host[0] == 0)
 915                 sstrncpy(notification.host, hostname_g, sizeof(notification.host));
 916         if (notification.plugin[0] == 0)
 917                 sstrncpy(notification.plugin, "python", sizeof(notification.plugin));
 918         Py_BEGIN_ALLOW_THREADS;
 919         ret = plugin_dispatch_notification(&notification);
 920         Py_END_ALLOW_THREADS;
 921         if (ret != 0) {
 922                 PyErr_SetString(PyExc_RuntimeError, "error dispatching notification, read the logs");
 923                 return NULL;
 924         }
 925         Py_RETURN_NONE;
 926 }
 927
 928 static PyObject *Notification_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
 929         Notification *self;
 930
 931         self = (Notification *) PluginData_new(type, args, kwds);
 932         if (self == NULL)
 933                 return NULL;
 934
 935         self->message[0] = 0;
 936         self->severity = 0;
 937         return (PyObject *) self;
 938 }
 939
 940 static int Notification_setstring(PyObject *self, PyObject *value, void *data) {
 941         char *old;
 942         const char *new;
 943
 944         if (value == NULL) {
 945                 PyErr_SetString(PyExc_TypeError, "Cannot delete this attribute");
 946                 return -1;
 947         }
 948         Py_INCREF(value);
 949         new = cpy_unicode_or_bytes_to_string(&value);
 950         if (new == NULL) {
 951                 Py_DECREF(value);
 952                 return -1;
 953         }
 954         old = ((char *) self) + (intptr_t) data;
 955         sstrncpy(old, new, NOTIF_MAX_MSG_LEN);
 956         Py_DECREF(value);
 957         return 0;
 958 }
 959
 960 static PyObject *Notification_repr(PyObject *s) {
 961         PyObject *ret, *tmp;
 962         static PyObject *l_severity = NULL, *l_message = NULL, *l_closing = NULL;
 963         Notification *self = (Notification *) s;
 964
 965         if (l_severity == NULL)
 966                 l_severity = cpy_string_to_unicode_or_bytes(",severity=");
 967         if (l_message == NULL)
 968                 l_message = cpy_string_to_unicode_or_bytes(",message=");
 969         if (l_closing == NULL)
 970                 l_closing = cpy_string_to_unicode_or_bytes(")");
 971
 972         if (l_severity == NULL || l_message == NULL || l_closing == NULL)
 973                 return NULL;
 974
 975         ret = cpy_common_repr(s);
 976         if (self->severity != 0) {
 977                 CPY_STRCAT(&ret, l_severity);
 978                 tmp = PyInt_FromLong(self->severity);
 979                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
 980                 CPY_STRCAT_AND_DEL(&ret, tmp);
 981         }
 982         if (self->message[0] != 0) {
 983                 CPY_STRCAT(&ret, l_message);
 984                 tmp = cpy_string_to_unicode_or_bytes(self->message);
 985                 CPY_SUBSTITUTE(PyObject_Repr, tmp, tmp);
 986                 CPY_STRCAT_AND_DEL(&ret, tmp);
 987         }
 988         CPY_STRCAT(&ret, l_closing);
 989         return ret;
 990 }
 991
 992 static PyMethodDef Notification_methods[] = {
 993         {"dispatch", (PyCFunction) Notification_dispatch, METH_VARARGS | METH_KEYWORDS, dispatch_doc},
 994         {NULL}
 995 };
 996
 997 static PyMemberDef Notification_members[] = {
 998         {"severity", T_INT, offsetof(Notification, severity), 0, severity_doc},
 999         {NULL}
1000 };
1001
1002 static PyGetSetDef Notification_getseters[] = {
1003         {"message", PluginData_getstring, Notification_setstring, message_doc, (void *) offsetof(Notification, message)},
1004         {NULL}
1005 };
1006
1007 PyTypeObject NotificationType = {
1008         CPY_INIT_TYPE
1009         "collectd.Notification",   /* tp_name */
1010         sizeof(Notification),      /* tp_basicsize */
1011         0,                         /* Will be filled in later */
1012         0,                         /* tp_dealloc */
1013         0,                         /* tp_print */
1014         0,                         /* tp_getattr */
1015         0,                         /* tp_setattr */
1016         0,                         /* tp_compare */
1017         Notification_repr,         /* tp_repr */
1018         0,                         /* tp_as_number */
1019         0,                         /* tp_as_sequence */
1020         0,                         /* tp_as_mapping */
1021         0,                         /* tp_hash */
1022         0,                         /* tp_call */
1023         0,                         /* tp_str */
1024         0,                         /* tp_getattro */
1025         0,                         /* tp_setattro */
1026         0,                         /* tp_as_buffer */
1027         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1028         Notification_doc,          /* tp_doc */
1029         0,                         /* tp_traverse */
1030         0,                         /* tp_clear */
1031         0,                         /* tp_richcompare */
1032         0,                         /* tp_weaklistoffset */
1033         0,                         /* tp_iter */
1034         0,                         /* tp_iternext */
1035         Notification_methods,      /* tp_methods */
1036         Notification_members,      /* tp_members */
1037         Notification_getseters,    /* tp_getset */
1038         0,                         /* tp_base */
1039         0,                         /* tp_dict */
1040         0,                         /* tp_descr_get */
1041         0,                         /* tp_descr_set */
1042         0,                         /* tp_dictoffset */
1043         Notification_init,         /* tp_init */
1044         0,                         /* tp_alloc */
1045         Notification_new           /* tp_new */
1046 };
1047
1048 static char Signed_doc[] = "This is a long by another name. Use it in meta data dicts\n"
1049                 "to choose the way it is stored in the meta data.";
1050
1051 PyTypeObject SignedType = {
1052         CPY_INIT_TYPE
1053         "collectd.Signed",         /* tp_name */
1054         sizeof(Signed),            /* tp_basicsize */
1055         0,                         /* Will be filled in later */
1056         0,                         /* tp_dealloc */
1057         0,                         /* tp_print */
1058         0,                         /* tp_getattr */
1059         0,                         /* tp_setattr */
1060         0,                         /* tp_compare */
1061         0,                         /* tp_repr */
1062         0,                         /* tp_as_number */
1063         0,                         /* tp_as_sequence */
1064         0,                         /* tp_as_mapping */
1065         0,                         /* tp_hash */
1066         0,                         /* tp_call */
1067         0,                         /* tp_str */
1068         0,                         /* tp_getattro */
1069         0,                         /* tp_setattro */
1070         0,                         /* tp_as_buffer */
1071         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1072         Signed_doc                 /* tp_doc */
1073 };
1074
1075 static char Unsigned_doc[] = "This is a long by another name. Use it in meta data dicts\n"
1076                 "to choose the way it is stored in the meta data.";
1077
1078 PyTypeObject UnsignedType = {
1079         CPY_INIT_TYPE
1080         "collectd.Unsigned",       /* tp_name */
1081         sizeof(Unsigned),          /* tp_basicsize */
1082         0,                         /* Will be filled in later */
1083         0,                         /* tp_dealloc */
1084         0,                         /* tp_print */
1085         0,                         /* tp_getattr */
1086         0,                         /* tp_setattr */
1087         0,                         /* tp_compare */
1088         0,                         /* tp_repr */
1089         0,                         /* tp_as_number */
1090         0,                         /* tp_as_sequence */
1091         0,                         /* tp_as_mapping */
1092         0,                         /* tp_hash */
1093         0,                         /* tp_call */
1094         0,                         /* tp_str */
1095         0,                         /* tp_getattro */
1096         0,                         /* tp_setattro */
1097         0,                         /* tp_as_buffer */
1098         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1099         Unsigned_doc               /* tp_doc */
1100 };