"list graphs" action: Remove the functionality to actually search for graphs.
[collection4.git] / src / graph.c
1 /**
2  * collection4 - graph.c
3  * Copyright (C) 2010  Florian octo Forster
4  * 
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  * 
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  * 
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA  02110-1301  USA
19  *
20  * Authors:
21  *   Florian octo Forster <ff at octo.it>
22  **/
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <stdint.h>
27 #include <inttypes.h>
28 #include <string.h>
29 #include <time.h>
30 #include <errno.h>
31 #include <assert.h>
32
33 #include "graph.h"
34 #include "graph_ident.h"
35 #include "graph_instance.h"
36 #include "graph_list.h"
37 #include "graph_def.h"
38 #include "graph_config.h"
39 #include "common.h"
40 #include "filesystem.h"
41 #include "utils_cgi.h"
42
43 #include <fcgiapp.h>
44 #include <fcgi_stdio.h>
45
46 /*
47  * Data types
48  */
49 struct graph_config_s /* {{{ */
50 {
51   graph_ident_t *select;
52
53   char *title;
54   char *vertical_label;
55   _Bool show_zero;
56
57   graph_def_t *defs;
58
59   graph_instance_t **instances;
60   size_t instances_num;
61 }; /* }}} struct graph_config_s */
62
63 /*
64  * Private functions
65  */
66
67 /*
68  * Config functions
69  */
70 static graph_ident_t *graph_config_get_selector (const oconfig_item_t *ci) /* {{{ */
71 {
72   char *host = NULL;
73   char *plugin = NULL;
74   char *plugin_instance = NULL;
75   char *type = NULL;
76   char *type_instance = NULL;
77   graph_ident_t *ret;
78   int i;
79
80   for (i = 0; i < ci->children_num; i++)
81   {
82     oconfig_item_t *child;
83
84     child = ci->children + i;
85
86     if (strcasecmp ("Host", child->key) == 0)
87       graph_config_get_string (child, &host);
88     else if (strcasecmp ("Plugin", child->key) == 0)
89       graph_config_get_string (child, &plugin);
90     else if (strcasecmp ("PluginInstance", child->key) == 0)
91       graph_config_get_string (child, &plugin_instance);
92     else if (strcasecmp ("Type", child->key) == 0)
93       graph_config_get_string (child, &type);
94     else if (strcasecmp ("TypeInstance", child->key) == 0)
95       graph_config_get_string (child, &type_instance);
96     /* else: ignore all other directives here. */
97   } /* for */
98
99   ret = ident_create (host, plugin, plugin_instance, type, type_instance);
100
101   free (host);
102   free (plugin);
103   free (plugin_instance);
104   free (type);
105   free (type_instance);
106
107   return (ret);
108 } /* }}} int graph_config_get_selector */
109
110 /*
111  * Global functions
112  */
113 graph_config_t *graph_create (const graph_ident_t *selector) /* {{{ */
114 {
115   graph_config_t *cfg;
116
117   cfg = malloc (sizeof (*cfg));
118   if (cfg == NULL)
119     return (NULL);
120   memset (cfg, 0, sizeof (*cfg));
121
122   if (selector != NULL)
123     cfg->select = ident_clone (selector);
124   else
125     cfg->select = NULL;
126
127   cfg->title = NULL;
128   cfg->vertical_label = NULL;
129   cfg->defs = NULL;
130   cfg->instances = NULL;
131
132   return (cfg);
133 } /* }}} int graph_create */
134
135 void graph_destroy (graph_config_t *cfg) /* {{{ */
136 {
137   size_t i;
138
139   if (cfg == NULL)
140     return;
141
142   ident_destroy (cfg->select);
143
144   free (cfg->title);
145   free (cfg->vertical_label);
146
147   def_destroy (cfg->defs);
148
149   for (i = 0; i < cfg->instances_num; i++)
150     inst_destroy (cfg->instances[i]);
151   free (cfg->instances);
152 } /* }}} void graph_destroy */
153
154 int graph_config_add (const oconfig_item_t *ci) /* {{{ */
155 {
156   graph_ident_t *select;
157   graph_config_t *cfg = NULL;
158   int i;
159
160   select = graph_config_get_selector (ci);
161   if (select == NULL)
162     return (EINVAL);
163
164   cfg = graph_create (/* selector = */ NULL);
165   if (cfg == NULL)
166     return (ENOMEM);
167
168   cfg->select = select;
169
170   for (i = 0; i < ci->children_num; i++)
171   {
172     oconfig_item_t *child;
173
174     child = ci->children + i;
175
176     if (strcasecmp ("Title", child->key) == 0)
177       graph_config_get_string (child, &cfg->title);
178     else if (strcasecmp ("VerticalLabel", child->key) == 0)
179       graph_config_get_string (child, &cfg->vertical_label);
180     else if (strcasecmp ("ShowZero", child->key) == 0)
181       graph_config_get_bool (child, &cfg->show_zero);
182     else if (strcasecmp ("DEF", child->key) == 0)
183       def_config (cfg, child);
184   } /* for */
185
186   gl_add_graph (cfg);
187
188   return (0);
189 } /* }}} graph_config_add */
190
191 int graph_add_file (graph_config_t *cfg, const graph_ident_t *file) /* {{{ */
192 {
193   graph_instance_t *inst;
194
195   inst = graph_inst_find_matching (cfg, file);
196   if (inst == NULL)
197   {
198     graph_instance_t **tmp;
199
200     tmp = realloc (cfg->instances,
201         sizeof (*cfg->instances) * (cfg->instances_num + 1));
202     if (tmp == NULL)
203       return (ENOMEM);
204     cfg->instances = tmp;
205
206     inst = inst_create (cfg, file);
207     if (inst == NULL)
208       return (ENOMEM);
209
210     cfg->instances[cfg->instances_num] = inst;
211     cfg->instances_num++;
212   }
213
214   return (inst_add_file (inst, file));
215 } /* }}} int graph_add_file */
216
217 int graph_get_title (graph_config_t *cfg, /* {{{ */
218     char *buffer, size_t buffer_size)
219 {
220   if ((cfg == NULL) || (buffer == NULL) || (buffer_size < 1))
221     return (EINVAL);
222
223   if (cfg->title == NULL)
224     cfg->title = ident_to_string (cfg->select);
225
226   if (cfg->title == NULL)
227     return (ENOMEM);
228
229   strncpy (buffer, cfg->title, buffer_size);
230   buffer[buffer_size - 1] = 0;
231
232   return (0);
233 } /* }}} int graph_get_title */
234
235 int graph_get_params (graph_config_t *cfg, /* {{{ */
236     char *buffer, size_t buffer_size)
237 {
238   buffer[0] = 0;
239
240 #define COPY_FIELD(field) do {                                       \
241   const char *str = ident_get_##field (cfg->select);                 \
242   char uri_str[1024];                                                \
243   uri_escape_copy (uri_str, str, sizeof (uri_str));                  \
244   strlcat (buffer, #field, buffer_size);                             \
245   strlcat (buffer, "=", buffer_size);                                \
246   strlcat (buffer, uri_str, buffer_size);                            \
247 } while (0)
248
249   COPY_FIELD(host);
250   strlcat (buffer, ";", buffer_size);
251   COPY_FIELD(plugin);
252   strlcat (buffer, ";", buffer_size);
253   COPY_FIELD(plugin_instance);
254   strlcat (buffer, ";", buffer_size);
255   COPY_FIELD(type);
256   strlcat (buffer, ";", buffer_size);
257   COPY_FIELD(type_instance);
258
259 #undef COPY_FIELD
260
261   return (0);
262 } /* }}} int graph_get_params */
263
264 graph_ident_t *graph_get_selector (graph_config_t *cfg) /* {{{ */
265 {
266   if (cfg == NULL)
267     return (NULL);
268
269   return (ident_clone (cfg->select));
270 } /* }}} graph_ident_t *graph_get_selector */
271
272 graph_def_t *graph_get_defs (graph_config_t *cfg) /* {{{ */
273 {
274   if (cfg == NULL)
275     return (NULL);
276
277   return (cfg->defs);
278 } /* }}} graph_def_t *graph_get_defs */
279
280 int graph_add_def (graph_config_t *cfg, graph_def_t *def) /* {{{ */
281 {
282   graph_def_t *tmp;
283
284   if ((cfg == NULL) || (def == NULL))
285     return (EINVAL);
286
287   if (cfg->defs == NULL)
288   {
289     cfg->defs = def;
290     return (0);
291   }
292
293   /* Insert in reverse order. This makes the order in the config file and the
294    * order of the DEFs in the graph more natural. Really. */
295   tmp = cfg->defs;
296   cfg->defs = def;
297   return (def_append (cfg->defs, tmp));
298 } /* }}} int graph_add_def */
299
300 _Bool graph_matches_ident (graph_config_t *cfg, const graph_ident_t *ident) /* {{{ */
301 {
302 #if C4_DEBUG
303   if ((cfg == NULL) || (ident == NULL))
304     return (0);
305 #endif
306
307   return (ident_matches (cfg->select, ident));
308 } /* }}} _Bool graph_matches_ident */
309
310 _Bool graph_matches_field (graph_config_t *cfg, /* {{{ */
311     graph_ident_field_t field, const char *field_value)
312 {
313   const char *selector_value;
314
315   if ((cfg == NULL) || (field_value == NULL))
316     return (0);
317
318   selector_value = ident_get_field (cfg->select, field);
319   if (selector_value == NULL)
320     return (0);
321
322   if (IS_ALL (selector_value) || IS_ANY (selector_value))
323     return (1);
324   else if (strcasecmp (selector_value, field_value) == 0)
325     return (1);
326
327   return (0);
328 } /* }}} _Bool graph_matches_field */
329
330 int graph_inst_foreach (graph_config_t *cfg, /* {{{ */
331                 inst_callback_t cb, void *user_data)
332 {
333   size_t i;
334   int status;
335
336   for (i = 0; i < cfg->instances_num; i++)
337   {
338     status = (*cb) (cfg->instances[i], user_data);
339     if (status != 0)
340       return (status);
341   }
342
343   return (0);
344 } /* }}} int graph_inst_foreach */
345
346 graph_instance_t *graph_inst_find_exact (graph_config_t *cfg, /* {{{ */
347     graph_ident_t *ident)
348 {
349   size_t i;
350
351   if ((cfg == NULL) || (ident == NULL))
352     return (NULL);
353
354   for (i = 0; i < cfg->instances_num; i++)
355     if (inst_compare_ident (cfg->instances[i], ident) == 0)
356       return (cfg->instances[i]);
357
358   return (NULL);
359 } /* }}} graph_instance_t *graph_inst_find_exact */
360
361 graph_instance_t *graph_inst_find_matching (graph_config_t *cfg, /* {{{ */
362     const graph_ident_t *ident)
363 {
364   size_t i;
365
366   if ((cfg == NULL) || (ident == NULL))
367     return (NULL);
368
369   for (i = 0; i < cfg->instances_num; i++)
370     if (inst_ident_matches (cfg->instances[i], ident))
371       return (cfg->instances[i]);
372
373   return (NULL);
374 } /* }}} graph_instance_t *graph_inst_find_matching */
375
376 int graph_inst_find_all_matching (graph_config_t *cfg, /* {{{ */
377     const graph_ident_t *ident,
378     graph_inst_callback_t callback, void *user_data)
379 {
380   size_t i;
381
382   if ((cfg == NULL) || (ident == NULL) || (callback == NULL))
383     return (EINVAL);
384
385   for (i = 0; i < cfg->instances_num; i++)
386   {
387     int status;
388
389     if (!inst_matches_ident (cfg->instances[i], ident))
390       continue;
391
392     status = (*callback) (cfg, cfg->instances[i], user_data);
393     if (status != 0)
394       return (status);
395   }
396
397   return (0);
398 } /* }}} int graph_inst_find_all_matching */
399
400 int graph_inst_search (graph_config_t *cfg, const char *term, /* {{{ */
401     graph_inst_callback_t cb,
402     void *user_data)
403 {
404   char buffer[1024];
405   int status;
406   size_t i;
407
408   status = graph_get_title (cfg, buffer, sizeof (buffer));
409   if (status != 0)
410   {
411     fprintf (stderr, "graph_inst_search: graph_get_title failed\n");
412     return (status);
413   }
414
415   strtolower (buffer);
416
417   if (strstr (buffer, term) != NULL)
418   {
419     for (i = 0; i < cfg->instances_num; i++)
420     {
421       status = (*cb) (cfg, cfg->instances[i], user_data);
422       if (status != 0)
423         return (status);
424     }
425   }
426   else
427   {
428     for (i = 0; i < cfg->instances_num; i++)
429     {
430       if (inst_matches_string (cfg, cfg->instances[i], term))
431       {
432         status = (*cb) (cfg, cfg->instances[i], user_data);
433         if (status != 0)
434           return (status);
435       }
436     }
437   }
438
439   return (0);
440 } /* }}} int graph_inst_search */
441
442 int graph_inst_search_field (graph_config_t *cfg, /* {{{ */
443     graph_ident_field_t field, const char *field_value,
444     graph_inst_callback_t callback, void *user_data)
445 {
446   size_t i;
447   const char *selector_field;
448   _Bool need_check_instances = 0;
449
450   if ((cfg == NULL) || (field_value == NULL) || (callback == NULL))
451     return (EINVAL);
452
453   if (!graph_matches_field (cfg, field, field_value))
454     return (0);
455
456   selector_field = ident_get_field (cfg->select, field);
457   if (selector_field == NULL)
458     return (-1);
459
460   if (IS_ALL (selector_field) || IS_ANY (selector_field))
461     need_check_instances = 1;
462
463   for (i = 0; i < cfg->instances_num; i++)
464   {
465     int status;
466
467     if (need_check_instances
468         && !inst_matches_field (cfg->instances[i], field, field_value))
469       continue;
470
471     status = (*callback) (cfg, cfg->instances[i], user_data);
472     if (status != 0)
473       return (status);
474   }
475
476   return (0);
477 } /* }}} int graph_inst_search_field */
478
479 int graph_compare (graph_config_t *cfg, const graph_ident_t *ident) /* {{{ */
480 {
481   if ((cfg == NULL) || (ident == NULL))
482     return (0);
483
484   return (ident_compare (cfg->select, ident));
485 } /* }}} int graph_compare */
486
487 static int graph_sort_instances_cb (const void *v0, const void *v1) /* {{{ */
488 {
489   return (inst_compare (*(graph_instance_t * const *) v0,
490         *(graph_instance_t * const *) v1));
491 } /* }}} int graph_sort_instances_cb */
492
493 size_t graph_num_instances (graph_config_t *cfg) /* {{{ */
494 {
495   if (cfg == NULL)
496     return ((size_t) -1);
497
498   return (cfg->instances_num);
499 } /* }}} size_t graph_num_instances */
500
501 int graph_sort_instances (graph_config_t *cfg) /* {{{ */
502 {
503   if (cfg == NULL)
504     return (EINVAL);
505
506   if (cfg->instances_num < 2)
507     return (0);
508
509   qsort (cfg->instances, cfg->instances_num, sizeof (*cfg->instances),
510       graph_sort_instances_cb);
511
512   return (0);
513 } /* }}} int graph_sort_instances */
514
515 int graph_clear_instances (graph_config_t *cfg) /* {{{ */
516 {
517   size_t i;
518
519   if (cfg == NULL)
520     return (EINVAL);
521
522   for (i = 0; i < cfg->instances_num; i++)
523     inst_destroy (cfg->instances[i]);
524   free (cfg->instances);
525   cfg->instances = NULL;
526   cfg->instances_num = 0;
527
528   return (0);
529 } /* }}} int graph_clear_instances */
530
531 int graph_get_rrdargs (graph_config_t *cfg, graph_instance_t *inst, /* {{{ */
532     rrd_args_t *args)
533 {
534   if ((cfg == NULL) || (inst == NULL) || (args == NULL))
535     return (EINVAL);
536
537   if (cfg->title != NULL)
538   {
539     array_append (args->options, "-t");
540     array_append (args->options, cfg->title);
541   }
542
543   if (cfg->vertical_label != NULL)
544   {
545     array_append (args->options, "-v");
546     array_append (args->options, cfg->vertical_label);
547   }
548
549   if (cfg->show_zero)
550   {
551     array_append (args->options, "-l");
552     array_append (args->options, "0");
553   }
554
555   return (0);
556 } /* }}} int graph_get_rrdargs */
557
558 /* vim: set sw=2 sts=2 et fdm=marker : */