Merge pull request #795 from vincentbernat/fix/libstatgrab
[collectd.git] / src / table.c
1 /**
2  * collectd - src/table.c
3  * Copyright (C) 2009       Sebastian Harl
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  *   Sebastian Harl <sh at tokkee.org>
25  **/
26
27 /*
28  * This module provides generic means to parse and dispatch tabular data.
29  */
30
31 #include "collectd.h"
32 #include "common.h"
33
34 #include "configfile.h"
35 #include "plugin.h"
36
37 #define log_err(...) ERROR ("table plugin: " __VA_ARGS__)
38 #define log_warn(...) WARNING ("table plugin: " __VA_ARGS__)
39
40 /*
41  * private data types
42  */
43
44 typedef struct {
45         char  *type;
46         char  *instance_prefix;
47         int   *instances;
48         size_t instances_num;
49         int   *values;
50         size_t values_num;
51
52         const data_set_t *ds;
53 } tbl_result_t;
54
55 typedef struct {
56         char *file;
57         char *sep;
58         char *instance;
59
60         tbl_result_t *results;
61         size_t        results_num;
62
63         size_t max_colnum;
64 } tbl_t;
65
66 static void tbl_result_setup (tbl_result_t *res)
67 {
68         res->type            = NULL;
69
70         res->instance_prefix = NULL;
71         res->instances       = NULL;
72         res->instances_num   = 0;
73
74         res->values          = NULL;
75         res->values_num      = 0;
76
77         res->ds              = NULL;
78 } /* tbl_result_setup */
79
80 static void tbl_result_clear (tbl_result_t *res)
81 {
82         sfree (res->type);
83
84         sfree (res->instance_prefix);
85         sfree (res->instances);
86         res->instances_num = 0;
87
88         sfree (res->values);
89         res->values_num = 0;
90
91         res->ds = NULL;
92 } /* tbl_result_clear */
93
94 static void tbl_setup (tbl_t *tbl, char *file)
95 {
96         tbl->file        = sstrdup (file);
97         tbl->sep         = NULL;
98         tbl->instance    = NULL;
99
100         tbl->results     = NULL;
101         tbl->results_num = 0;
102
103         tbl->max_colnum  = 0;
104 } /* tbl_setup */
105
106 static void tbl_clear (tbl_t *tbl)
107 {
108         size_t i;
109
110         sfree (tbl->file);
111         sfree (tbl->sep);
112         sfree (tbl->instance);
113
114         for (i = 0; i < tbl->results_num; ++i)
115                 tbl_result_clear (tbl->results + i);
116         sfree (tbl->results);
117         tbl->results_num = 0;
118
119         tbl->max_colnum  = 0;
120 } /* tbl_clear */
121
122 static tbl_t *tables;
123 static size_t tables_num;
124
125 /*
126  * configuration handling
127  */
128
129 static int tbl_config_set_s (char *name, char **var, oconfig_item_t *ci)
130 {
131         if ((1 != ci->values_num)
132                         || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
133                 log_err ("\"%s\" expects a single string argument.", name);
134                 return 1;
135         }
136
137         sfree (*var);
138         *var = sstrdup (ci->values[0].value.string);
139         return 0;
140 } /* tbl_config_set_separator */
141
142 static int tbl_config_append_array_i (char *name, int **var, size_t *len,
143                 oconfig_item_t *ci)
144 {
145         int *tmp;
146
147         size_t i;
148
149         if (1 > ci->values_num) {
150                 log_err ("\"%s\" expects at least one argument.", name);
151                 return 1;
152         }
153
154         for (i = 0; i < ci->values_num; ++i) {
155                 if (OCONFIG_TYPE_NUMBER != ci->values[i].type) {
156                         log_err ("\"%s\" expects numerical arguments only.", name);
157                         return 1;
158                 }
159         }
160
161         *len += ci->values_num;
162         tmp = (int *)realloc (*var, *len * sizeof (**var));
163         if (NULL == tmp) {
164                 char errbuf[1024];
165                 log_err ("realloc failed: %s.",
166                                 sstrerror (errno, errbuf, sizeof (errbuf)));
167                 return -1;
168         }
169
170         *var = tmp;
171
172         for (i = *len - ci->values_num; i < *len; ++i)
173                 (*var)[i] = (int)ci->values[i].value.number;
174         return 0;
175 } /* tbl_config_append_array_s */
176
177 static int tbl_config_result (tbl_t *tbl, oconfig_item_t *ci)
178 {
179         tbl_result_t *res;
180
181         int status = 0;
182         size_t i;
183
184         if (0 != ci->values_num) {
185                 log_err ("<Result> does not expect any arguments.");
186                 return 1;
187         }
188
189         res = (tbl_result_t *)realloc (tbl->results,
190                         (tbl->results_num + 1) * sizeof (*tbl->results));
191         if (NULL == tbl) {
192                 char errbuf[1024];
193                 log_err ("realloc failed: %s.",
194                                 sstrerror (errno, errbuf, sizeof (errbuf)));
195                 return -1;
196         }
197
198         tbl->results = res;
199         ++tbl->results_num;
200
201         res = tbl->results + tbl->results_num - 1;
202         tbl_result_setup (res);
203
204         for (i = 0; i < ci->children_num; ++i) {
205                 oconfig_item_t *c = ci->children + i;
206
207                 if (0 == strcasecmp (c->key, "Type"))
208                         tbl_config_set_s (c->key, &res->type, c);
209                 else if (0 == strcasecmp (c->key, "InstancePrefix"))
210                         tbl_config_set_s (c->key, &res->instance_prefix, c);
211                 else if (0 == strcasecmp (c->key, "InstancesFrom"))
212                         tbl_config_append_array_i (c->key,
213                                         &res->instances, &res->instances_num, c);
214                 else if (0 == strcasecmp (c->key, "ValuesFrom"))
215                         tbl_config_append_array_i (c->key,
216                                         &res->values, &res->values_num, c);
217                 else
218                         log_warn ("Ignoring unknown config key \"%s\" "
219                                         " in <Result>.", c->key);
220         }
221
222         if (NULL == res->type) {
223                 log_err ("No \"Type\" option specified for <Result> "
224                                 "in table \"%s\".", tbl->file);
225                 status = 1;
226         }
227
228         if (NULL == res->values) {
229                 log_err ("No \"ValuesFrom\" option specified for <Result> "
230                                 "in table \"%s\".", tbl->file);
231                 status = 1;
232         }
233
234         if (0 != status) {
235                 tbl_result_clear (res);
236                 --tbl->results_num;
237                 return status;
238         }
239         return 0;
240 } /* tbl_config_result */
241
242 static int tbl_config_table (oconfig_item_t *ci)
243 {
244         tbl_t *tbl;
245
246         int status = 0;
247         size_t i;
248
249         if ((1 != ci->values_num)
250                         || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
251                 log_err ("<Table> expects a single string argument.");
252                 return 1;
253         }
254
255         tbl = (tbl_t *)realloc (tables, (tables_num + 1) * sizeof (*tables));
256         if (NULL == tbl) {
257                 char errbuf[1024];
258                 log_err ("realloc failed: %s.",
259                                 sstrerror (errno, errbuf, sizeof (errbuf)));
260                 return -1;
261         }
262
263         tables = tbl;
264         ++tables_num;
265
266         tbl = tables + tables_num - 1;
267         tbl_setup (tbl, ci->values[0].value.string);
268
269         for (i = 0; i < ci->children_num; ++i) {
270                 oconfig_item_t *c = ci->children + i;
271
272                 if (0 == strcasecmp (c->key, "Separator"))
273                         tbl_config_set_s (c->key, &tbl->sep, c);
274                 else if (0 == strcasecmp (c->key, "Instance"))
275                         tbl_config_set_s (c->key, &tbl->instance, c);
276                 else if (0 == strcasecmp (c->key, "Result"))
277                         tbl_config_result (tbl, c);
278                 else
279                         log_warn ("Ignoring unknown config key \"%s\" "
280                                         "in <Table %s>.", c->key, tbl->file);
281         }
282
283         if (NULL == tbl->sep) {
284                 log_err ("Table \"%s\" does not specify any separator.", tbl->file);
285                 status = 1;
286         }
287         strunescape (tbl->sep, strlen (tbl->sep) + 1);
288
289         if (NULL == tbl->instance) {
290                 tbl->instance = sstrdup (tbl->file);
291                 replace_special (tbl->instance, strlen (tbl->instance));
292         }
293
294         if (NULL == tbl->results) {
295                 log_err ("Table \"%s\" does not specify any (valid) results.",
296                                 tbl->file);
297                 status = 1;
298         }
299
300         if (0 != status) {
301                 tbl_clear (tbl);
302                 --tables_num;
303                 return status;
304         }
305
306         for (i = 0; i < tbl->results_num; ++i) {
307                 tbl_result_t *res = tbl->results + i;
308                 size_t j;
309
310                 for (j = 0; j < res->instances_num; ++j)
311                         if (res->instances[j] > tbl->max_colnum)
312                                 tbl->max_colnum = res->instances[j];
313
314                 for (j = 0; j < res->values_num; ++j)
315                         if (res->values[j] > tbl->max_colnum)
316                                 tbl->max_colnum = res->values[j];
317         }
318         return 0;
319 } /* tbl_config_table */
320
321 static int tbl_config (oconfig_item_t *ci)
322 {
323         size_t i;
324
325         for (i = 0; i < ci->children_num; ++i) {
326                 oconfig_item_t *c = ci->children + i;
327
328                 if (0 == strcasecmp (c->key, "Table"))
329                         tbl_config_table (c);
330                 else
331                         log_warn ("Ignoring unknown config key \"%s\".", c->key);
332         }
333         return 0;
334 } /* tbl_config */
335
336 /*
337  * result handling
338  */
339
340 static int tbl_prepare (tbl_t *tbl)
341 {
342         size_t i;
343
344         for (i = 0; i < tbl->results_num; ++i) {
345                 tbl_result_t *res = tbl->results + i;
346
347                 res->ds = plugin_get_ds (res->type);
348                 if (NULL == res->ds) {
349                         log_err ("Unknown type \"%s\". See types.db(5) for details.",
350                                         res->type);
351                         return -1;
352                 }
353
354                 if (res->values_num != (size_t)res->ds->ds_num) {
355                         log_err ("Invalid type \"%s\". Expected %zu data source%s, "
356                                         "got %i.", res->type, res->values_num,
357                                         (1 == res->values_num) ? "" : "s",
358                                         res->ds->ds_num);
359                         return -1;
360                 }
361         }
362         return 0;
363 } /* tbl_prepare */
364
365 static int tbl_finish (tbl_t *tbl)
366 {
367         size_t i;
368
369         for (i = 0; i < tbl->results_num; ++i)
370                 tbl->results[i].ds = NULL;
371         return 0;
372 } /* tbl_finish */
373
374 static int tbl_result_dispatch (tbl_t *tbl, tbl_result_t *res,
375                 char **fields, size_t fields_num)
376 {
377         value_list_t vl = VALUE_LIST_INIT;
378         value_t values[res->values_num];
379
380         size_t i;
381
382         assert (NULL != res->ds);
383         assert (res->values_num == res->ds->ds_num);
384
385         for (i = 0; i < res->values_num; ++i) {
386                 char *value;
387
388                 assert (res->values[i] < fields_num);
389                 value = fields[res->values[i]];
390
391                 if (0 != parse_value (value, &values[i], res->ds->ds[i].type))
392                         return -1;
393         }
394
395         vl.values     = values;
396         vl.values_len = STATIC_ARRAY_SIZE (values);
397
398         sstrncpy (vl.host, hostname_g, sizeof (vl.host));
399         sstrncpy (vl.plugin, "table", sizeof (vl.plugin));
400         sstrncpy (vl.plugin_instance, tbl->instance, sizeof (vl.plugin_instance));
401         sstrncpy (vl.type, res->type, sizeof (vl.type));
402
403         if (0 == res->instances_num) {
404                 if (NULL != res->instance_prefix)
405                         sstrncpy (vl.type_instance, res->instance_prefix,
406                                         sizeof (vl.type_instance));
407         }
408         else {
409                 char *instances[res->instances_num];
410                 char  instances_str[DATA_MAX_NAME_LEN];
411
412                 for (i = 0; i < res->instances_num; ++i) {
413                         assert (res->instances[i] < fields_num);
414                         instances[i] = fields[res->instances[i]];
415                 }
416
417                 strjoin (instances_str, sizeof (instances_str),
418                                 instances, STATIC_ARRAY_SIZE (instances), "-");
419                 instances_str[sizeof (instances_str) - 1] = '\0';
420
421                 vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
422                 if (NULL == res->instance_prefix)
423                         strncpy (vl.type_instance, instances_str,
424                                         sizeof (vl.type_instance));
425                 else
426                         snprintf (vl.type_instance, sizeof (vl.type_instance),
427                                         "%s-%s", res->instance_prefix, instances_str);
428
429                 if ('\0' != vl.type_instance[sizeof (vl.type_instance) - 1]) {
430                         vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
431                         log_warn ("Truncated type instance: %s.", vl.type_instance);
432                 }
433         }
434
435         plugin_dispatch_values (&vl);
436         return 0;
437 } /* tbl_result_dispatch */
438
439 static int tbl_parse_line (tbl_t *tbl, char *line, size_t len)
440 {
441         char *fields[tbl->max_colnum + 1];
442         char *ptr, *saveptr;
443
444         size_t i;
445
446         i = 0;
447         ptr = line;
448         saveptr = NULL;
449         while (NULL != (fields[i] = strtok_r (ptr, tbl->sep, &saveptr))) {
450                 ptr = NULL;
451                 ++i;
452
453                 if (i > tbl->max_colnum)
454                         break;
455         }
456
457         if (i <= tbl->max_colnum) {
458                 log_err ("Not enough columns in line "
459                                 "(expected at least %zu, got %zu).",
460                                 tbl->max_colnum + 1, i);
461                 return -1;
462         }
463
464         for (i = 0; i < tbl->results_num; ++i)
465                 if (0 != tbl_result_dispatch (tbl, tbl->results + i,
466                                         fields, STATIC_ARRAY_SIZE (fields))) {
467                         log_err ("Failed to dispatch result.");
468                         continue;
469                 }
470         return 0;
471 } /* tbl_parse_line */
472
473 static int tbl_read_table (tbl_t *tbl)
474 {
475         FILE *fh;
476         char  buf[4096];
477
478         fh = fopen (tbl->file, "r");
479         if (NULL == fh) {
480                 char errbuf[1024];
481                 log_err ("Failed to open file \"%s\": %s.", tbl->file,
482                                 sstrerror (errno, errbuf, sizeof (errbuf)));
483                 return -1;
484         }
485
486         buf[sizeof (buf) - 1] = '\0';
487         while (NULL != fgets (buf, sizeof (buf), fh)) {
488                 if ('\0' != buf[sizeof (buf) - 1]) {
489                         buf[sizeof (buf) - 1] = '\0';
490                         log_err ("Table %s: Truncated line: %s", tbl->file, buf);
491                 }
492
493                 if (0 != tbl_parse_line (tbl, buf, sizeof (buf))) {
494                         log_err ("Table %s: Failed to parse line: %s", tbl->file, buf);
495                         continue;
496                 }
497         }
498
499         if (0 != ferror (fh)) {
500                 char errbuf[1024];
501                 log_err ("Failed to read from file \"%s\": %s.", tbl->file,
502                                 sstrerror (errno, errbuf, sizeof (errbuf)));
503                 fclose (fh);
504                 return -1;
505         }
506
507         fclose (fh);
508         return 0;
509 } /* tbl_read_table */
510
511 /*
512  * collectd callbacks
513  */
514
515 static int tbl_read (void)
516 {
517         int status = -1;
518         size_t i;
519
520         if (0 == tables_num)
521                 return 0;
522
523         for (i = 0; i < tables_num; ++i) {
524                 tbl_t *tbl = tables + i;
525
526                 if (0 != tbl_prepare (tbl)) {
527                         log_err ("Failed to prepare and parse table \"%s\".", tbl->file);
528                         continue;
529                 }
530
531                 if (0 == tbl_read_table (tbl))
532                         status = 0;
533
534                 tbl_finish (tbl);
535         }
536         return status;
537 } /* tbl_read */
538
539 static int tbl_shutdown (void)
540 {
541         size_t i;
542
543         for (i = 0; i < tables_num; ++i)
544                 tbl_clear (&tables[i]);
545         sfree (tables);
546         return 0;
547 } /* tbl_shutdown */
548
549 static int tbl_init (void)
550 {
551         if (0 == tables_num)
552                 return 0;
553
554         plugin_register_read ("table", tbl_read);
555         plugin_register_shutdown ("table", tbl_shutdown);
556         return 0;
557 } /* tbl_init */
558
559 void module_register (void)
560 {
561         plugin_register_complex_config ("table", tbl_config);
562         plugin_register_init ("table", tbl_init);
563 } /* module_register */
564
565 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */