Code

README: Describe licensing terms of the Highcharts library.
[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  **/
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>
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"
43 #include <fcgiapp.h>
44 #include <fcgi_stdio.h>
46 /*
47  * Data types
48  */
49 struct graph_config_s /* {{{ */
50 {
51   graph_ident_t *select;
53   char *title;
54   char *vertical_label;
55   _Bool show_zero;
57   graph_def_t *defs;
59   graph_instance_t **instances;
60   size_t instances_num;
61 }; /* }}} struct graph_config_s */
63 /*
64  * Private functions
65  */
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;
80   for (i = 0; i < ci->children_num; i++)
81   {
82     oconfig_item_t *child;
84     child = ci->children + i;
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 */
99   ret = ident_create (host, plugin, plugin_instance, type, type_instance);
101   free (host);
102   free (plugin);
103   free (plugin_instance);
104   free (type);
105   free (type_instance);
107   return (ret);
108 } /* }}} int graph_config_get_selector */
110 /*
111  * Global functions
112  */
113 graph_config_t *graph_create (const graph_ident_t *selector) /* {{{ */
115   graph_config_t *cfg;
117   cfg = malloc (sizeof (*cfg));
118   if (cfg == NULL)
119     return (NULL);
120   memset (cfg, 0, sizeof (*cfg));
122   if (selector != NULL)
123     cfg->select = ident_clone (selector);
124   else
125     cfg->select = NULL;
127   cfg->title = NULL;
128   cfg->vertical_label = NULL;
129   cfg->defs = NULL;
130   cfg->instances = NULL;
132   return (cfg);
133 } /* }}} int graph_create */
135 void graph_destroy (graph_config_t *cfg) /* {{{ */
137   size_t i;
139   if (cfg == NULL)
140     return;
142   ident_destroy (cfg->select);
144   free (cfg->title);
145   free (cfg->vertical_label);
147   def_destroy (cfg->defs);
149   for (i = 0; i < cfg->instances_num; i++)
150     inst_destroy (cfg->instances[i]);
151   free (cfg->instances);
152 } /* }}} void graph_destroy */
154 int graph_config_add (const oconfig_item_t *ci) /* {{{ */
156   graph_ident_t *select;
157   graph_config_t *cfg = NULL;
158   int i;
160   select = graph_config_get_selector (ci);
161   if (select == NULL)
162     return (EINVAL);
164   cfg = graph_create (/* selector = */ NULL);
165   if (cfg == NULL)
166     return (ENOMEM);
168   cfg->select = select;
170   for (i = 0; i < ci->children_num; i++)
171   {
172     oconfig_item_t *child;
174     child = ci->children + i;
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 */
186   gl_add_graph (cfg);
188   return (0);
189 } /* }}} graph_config_add */
191 int graph_add_inst (graph_config_t *graph, graph_instance_t *inst) /* {{{ */
193   graph_instance_t **tmp;
195   if ((graph == NULL) || (inst == NULL))
196     return (EINVAL);
198   tmp = realloc (graph->instances,
199       sizeof (*graph->instances) * (graph->instances_num + 1));
200   if (tmp == NULL)
201     return (ENOMEM);
202   graph->instances = tmp;
204   graph->instances[graph->instances_num] = inst;
205   graph->instances_num++;
207   return (0);
208 } /* }}} int graph_add_inst */
210 int graph_add_file (graph_config_t *cfg, const graph_ident_t *file) /* {{{ */
212   graph_instance_t *inst;
214   inst = graph_inst_find_matching (cfg, file);
215   if (inst == NULL)
216   {
217     inst = inst_create (cfg, file);
218     if (inst == NULL)
219       return (ENOMEM);
221     graph_add_inst (cfg, inst);
222   }
224   return (inst_add_file (inst, file));
225 } /* }}} int graph_add_file */
227 int graph_get_title (graph_config_t *cfg, /* {{{ */
228     char *buffer, size_t buffer_size)
230   if ((cfg == NULL) || (buffer == NULL) || (buffer_size < 1))
231     return (EINVAL);
233   if (cfg->title == NULL)
234     cfg->title = ident_to_string (cfg->select);
236   if (cfg->title == NULL)
237     return (ENOMEM);
239   strncpy (buffer, cfg->title, buffer_size);
240   buffer[buffer_size - 1] = 0;
242   return (0);
243 } /* }}} int graph_get_title */
245 int graph_get_params (graph_config_t *cfg, /* {{{ */
246     char *buffer, size_t buffer_size)
248   buffer[0] = 0;
250 #define COPY_FIELD(field) do {                                       \
251   const char *str = ident_get_##field (cfg->select);                 \
252   char uri_str[1024];                                                \
253   uri_escape_copy (uri_str, str, sizeof (uri_str));                  \
254   strlcat (buffer, #field, buffer_size);                             \
255   strlcat (buffer, "=", buffer_size);                                \
256   strlcat (buffer, uri_str, buffer_size);                            \
257 } while (0)
259   COPY_FIELD(host);
260   strlcat (buffer, ";", buffer_size);
261   COPY_FIELD(plugin);
262   strlcat (buffer, ";", buffer_size);
263   COPY_FIELD(plugin_instance);
264   strlcat (buffer, ";", buffer_size);
265   COPY_FIELD(type);
266   strlcat (buffer, ";", buffer_size);
267   COPY_FIELD(type_instance);
269 #undef COPY_FIELD
271   return (0);
272 } /* }}} int graph_get_params */
274 graph_ident_t *graph_get_selector (graph_config_t *cfg) /* {{{ */
276   if (cfg == NULL)
277     return (NULL);
279   return (ident_clone (cfg->select));
280 } /* }}} graph_ident_t *graph_get_selector */
282 graph_def_t *graph_get_defs (graph_config_t *cfg) /* {{{ */
284   if (cfg == NULL)
285     return (NULL);
287   return (cfg->defs);
288 } /* }}} graph_def_t *graph_get_defs */
290 int graph_add_def (graph_config_t *cfg, graph_def_t *def) /* {{{ */
292   graph_def_t *tmp;
294   if ((cfg == NULL) || (def == NULL))
295     return (EINVAL);
297   if (cfg->defs == NULL)
298   {
299     cfg->defs = def;
300     return (0);
301   }
303   /* Insert in reverse order. This makes the order in the config file and the
304    * order of the DEFs in the graph more natural. Really. */
305   tmp = cfg->defs;
306   cfg->defs = def;
307   return (def_append (cfg->defs, tmp));
308 } /* }}} int graph_add_def */
310 _Bool graph_ident_matches (graph_config_t *cfg, const graph_ident_t *ident) /* {{{ */
312 #if C4_DEBUG
313   if ((cfg == NULL) || (ident == NULL))
314     return (0);
315 #endif
317   return (ident_matches (cfg->select, ident));
318 } /* }}} _Bool graph_ident_matches */
320 _Bool graph_matches_ident (graph_config_t *cfg, /* {{{ */
321     const graph_ident_t *selector)
323 #if C4_DEBUG
324   if ((cfg == NULL) || (selector == NULL))
325     return (0);
326 #endif
328   return (ident_matches (selector, cfg->select));
329 } /* }}} _Bool graph_matches_ident */
331 _Bool graph_ident_intersect (graph_config_t *cfg, /* {{{ */
332     const graph_ident_t *selector)
334 #if C4_DEBUG
335   if ((cfg == NULL) || (selector == NULL))
336     return (0);
337 #endif
339   return (ident_intersect (cfg->select, selector));
340 } /* }}} _Bool graph_ident_intersect */
342 _Bool graph_matches_field (graph_config_t *cfg, /* {{{ */
343     graph_ident_field_t field, const char *field_value)
345   const char *selector_value;
347   if ((cfg == NULL) || (field_value == NULL))
348     return (0);
350   selector_value = ident_get_field (cfg->select, field);
351   if (selector_value == NULL)
352     return (0);
354   if (IS_ALL (selector_value) || IS_ANY (selector_value))
355     return (1);
356   else if (strcasecmp (selector_value, field_value) == 0)
357     return (1);
359   return (0);
360 } /* }}} _Bool graph_matches_field */
362 int graph_inst_foreach (graph_config_t *cfg, /* {{{ */
363                 inst_callback_t cb, void *user_data)
365   size_t i;
366   int status;
368   for (i = 0; i < cfg->instances_num; i++)
369   {
370     status = (*cb) (cfg->instances[i], user_data);
371     if (status != 0)
372       return (status);
373   }
375   return (0);
376 } /* }}} int graph_inst_foreach */
378 graph_instance_t *graph_inst_find_exact (graph_config_t *cfg, /* {{{ */
379     graph_ident_t *ident)
381   size_t i;
383   if ((cfg == NULL) || (ident == NULL))
384     return (NULL);
386   for (i = 0; i < cfg->instances_num; i++)
387     if (inst_compare_ident (cfg->instances[i], ident) == 0)
388       return (cfg->instances[i]);
390   return (NULL);
391 } /* }}} graph_instance_t *graph_inst_find_exact */
393 graph_instance_t *graph_inst_find_matching (graph_config_t *cfg, /* {{{ */
394     const graph_ident_t *ident)
396   size_t i;
398   if ((cfg == NULL) || (ident == NULL))
399     return (NULL);
401   for (i = 0; i < cfg->instances_num; i++)
402     if (inst_ident_matches (cfg->instances[i], ident))
403       return (cfg->instances[i]);
405   return (NULL);
406 } /* }}} graph_instance_t *graph_inst_find_matching */
408 int graph_inst_find_all_matching (graph_config_t *cfg, /* {{{ */
409     const graph_ident_t *ident,
410     graph_inst_callback_t callback, void *user_data)
412   size_t i;
414   if ((cfg == NULL) || (ident == NULL) || (callback == NULL))
415     return (EINVAL);
417   for (i = 0; i < cfg->instances_num; i++)
418   {
419     int status;
421     if (!inst_matches_ident (cfg->instances[i], ident))
422       continue;
424     status = (*callback) (cfg, cfg->instances[i], user_data);
425     if (status != 0)
426       return (status);
427   }
429   return (0);
430 } /* }}} int graph_inst_find_all_matching */
432 /* Lightweight variant of the "graph_search_inst" which is used if the
433  * search_info_t doesn't select any field values explicitely. */
434 static int graph_search_inst_noselector (graph_config_t *cfg, /* {{{ */
435     search_info_t *si, graph_inst_callback_t cb, void *user_data)
437   char title[1024];
438   int status;
439   size_t i;
441   /* parameters have already been checked in "graph_search_inst" */
443   status = graph_get_title (cfg, title, sizeof (title));
444   if (status != 0)
445   {
446     fprintf (stderr, "graph_search_inst_noselector: "
447         "graph_get_title failed\n");
448     return (status);
449   }
450   strtolower (title);
452   for (i = 0; i < cfg->instances_num; i++)
453   {
454     if (search_graph_inst_matches (si, cfg, cfg->instances[i], title))
455     {
456       status = (*cb) (cfg, cfg->instances[i], user_data);
457       if (status != 0)
458         return (status);
459     }
460   } /* for (cfg->instances_num) */
462   return (0);
463 } /* }}} int graph_search_inst_noselector */
465 /* When this function is called from graph_list, it will already have checked
466  * that the selector of the graph does not contradict the field selections contained in
467  * the search_info_t. We still have to check if the instance contradicts the
468  * search parameters, though, since the "ANY" wildcard is filled in now -
469  * possibly with contradicting values. */
470 int graph_search_inst (graph_config_t *cfg, search_info_t *si, /* {{{ */
471     graph_inst_callback_t cb,
472     void *user_data)
474   char title[1024];
475   int status;
476   size_t i;
477   graph_ident_t *search_selector;
479   if ((cfg == NULL) || (si == NULL) || (cb == NULL))
480     return (EINVAL);
482   if (!search_has_selector (si))
483     return (graph_search_inst_noselector (cfg, si, cb, user_data));
485   search_selector = search_to_ident (si);
486   if (search_selector == NULL)
487     return (ENOMEM);
489   status = graph_get_title (cfg, title, sizeof (title));
490   if (status != 0)
491   {
492     ident_destroy (search_selector);
493     fprintf (stderr, "graph_search_inst: graph_get_title failed\n");
494     return (status);
495   }
496   strtolower (title);
498   for (i = 0; i < cfg->instances_num; i++)
499   {
500     graph_ident_t *inst_selector;
502     inst_selector = inst_get_selector (cfg->instances[i]);
503     if (inst_selector == NULL)
504       continue;
506     /* If the two selectors contradict one another, there is no point in
507      * calling the (more costly) "search_graph_inst_matches" function. */
508     if (!ident_intersect (search_selector, inst_selector))
509     {
510       ident_destroy (inst_selector);
511       continue;
512     }
514     if (search_graph_inst_matches (si, cfg, cfg->instances[i], title))
515     {
516       status = (*cb) (cfg, cfg->instances[i], user_data);
517       if (status != 0)
518       {
519         ident_destroy (search_selector);
520         ident_destroy (inst_selector);
521         return (status);
522       }
523     }
525     ident_destroy (inst_selector);
526   } /* for (cfg->instances_num) */
528   ident_destroy (search_selector);
529   return (0);
530 } /* }}} int graph_search_inst */
532 int graph_search_inst_string (graph_config_t *cfg, const char *term, /* {{{ */
533     graph_inst_callback_t cb,
534     void *user_data)
536   char buffer[1024];
537   int status;
538   size_t i;
540   status = graph_get_title (cfg, buffer, sizeof (buffer));
541   if (status != 0)
542   {
543     fprintf (stderr, "graph_search_inst_string: graph_get_title failed\n");
544     return (status);
545   }
547   strtolower (buffer);
549   if (strstr (buffer, term) != NULL)
550   {
551     for (i = 0; i < cfg->instances_num; i++)
552     {
553       status = (*cb) (cfg, cfg->instances[i], user_data);
554       if (status != 0)
555         return (status);
556     }
557   }
558   else
559   {
560     for (i = 0; i < cfg->instances_num; i++)
561     {
562       if (inst_matches_string (cfg, cfg->instances[i], term))
563       {
564         status = (*cb) (cfg, cfg->instances[i], user_data);
565         if (status != 0)
566           return (status);
567       }
568     }
569   }
571   return (0);
572 } /* }}} int graph_search_inst_string */
574 int graph_inst_search_field (graph_config_t *cfg, /* {{{ */
575     graph_ident_field_t field, const char *field_value,
576     graph_inst_callback_t callback, void *user_data)
578   size_t i;
579   const char *selector_field;
580   _Bool need_check_instances = 0;
582   if ((cfg == NULL) || (field_value == NULL) || (callback == NULL))
583     return (EINVAL);
585   if (!graph_matches_field (cfg, field, field_value))
586     return (0);
588   selector_field = ident_get_field (cfg->select, field);
589   if (selector_field == NULL)
590     return (-1);
592   if (IS_ALL (selector_field) || IS_ANY (selector_field))
593     need_check_instances = 1;
595   for (i = 0; i < cfg->instances_num; i++)
596   {
597     int status;
599     if (need_check_instances
600         && !inst_matches_field (cfg->instances[i], field, field_value))
601       continue;
603     status = (*callback) (cfg, cfg->instances[i], user_data);
604     if (status != 0)
605       return (status);
606   }
608   return (0);
609 } /* }}} int graph_inst_search_field */
611 int graph_compare (graph_config_t *cfg, const graph_ident_t *ident) /* {{{ */
613   if ((cfg == NULL) || (ident == NULL))
614     return (0);
616   return (ident_compare (cfg->select, ident));
617 } /* }}} int graph_compare */
619 size_t graph_num_instances (graph_config_t *cfg) /* {{{ */
621   if (cfg == NULL)
622     return ((size_t) -1);
624   return (cfg->instances_num);
625 } /* }}} size_t graph_num_instances */
627 int graph_to_json (const graph_config_t *cfg, /* {{{ */
628     yajl_gen handler)
630   size_t i;
632   if ((cfg == NULL) || (handler == NULL))
633     return (EINVAL);
635   yajl_gen_map_open (handler);
636   yajl_gen_string (handler,
637       (unsigned char *) "select",
638       (unsigned int) strlen ("select"));
639   ident_to_json (cfg->select, handler);
640   yajl_gen_string (handler,
641       (unsigned char *) "instances",
642       (unsigned int) strlen ("instances"));
643   yajl_gen_array_open (handler);
644   for (i = 0; i < cfg->instances_num; i++)
645     inst_to_json (cfg->instances[i], handler);
646   yajl_gen_array_close (handler);
647   yajl_gen_map_close (handler);
649   return (0);
650 } /* }}} int graph_to_json */
652 int graph_def_to_json (graph_config_t *cfg, /* {{{ */
653     graph_instance_t *inst,
654     yajl_gen handler)
656 #define yajl_gen_string_cast(h,p,l) \
657   yajl_gen_string (h, (unsigned char *) p, (unsigned int) l)
659   if ((cfg == NULL) || (handler == NULL))
660     return (EINVAL);
662   yajl_gen_map_open (handler);
664   yajl_gen_string_cast (handler, "select", strlen ("select"));
665   ident_to_json (cfg->select, handler);
666   if (cfg->title != NULL)
667   {
668     yajl_gen_string_cast (handler, "title", strlen ("title"));
669     yajl_gen_string_cast (handler, cfg->title, strlen (cfg->title));
670   }
671   if (cfg->vertical_label != NULL)
672   {
673     yajl_gen_string_cast (handler, "vertical_label", strlen ("vertical_label"));
674     yajl_gen_string_cast (handler, cfg->vertical_label, strlen (cfg->vertical_label));
675   }
676   yajl_gen_string_cast (handler, "show_zero", strlen ("show_zero"));
677   yajl_gen_bool (handler, cfg->show_zero);
679   yajl_gen_string_cast (handler, "defs", strlen ("defs"));
680   if (cfg->defs == NULL)
681   {
682     graph_def_t *defs;
684     defs = inst_get_default_defs (cfg, inst);
685     def_to_json (defs, handler);
686     def_destroy (defs);
687   }
688   else
689   {
690     def_to_json (cfg->defs, handler);
691   }
693   yajl_gen_map_close (handler);
695   return (0);
696 #undef yajl_gen_string_cast
697 } /* }}} int graph_def_to_json */
699 static int graph_sort_instances_cb (const void *v0, const void *v1) /* {{{ */
701   return (inst_compare (*(graph_instance_t * const *) v0,
702         *(graph_instance_t * const *) v1));
703 } /* }}} int graph_sort_instances_cb */
705 int graph_sort_instances (graph_config_t *cfg) /* {{{ */
707   if (cfg == NULL)
708     return (EINVAL);
710   if (cfg->instances_num < 2)
711     return (0);
713   qsort (cfg->instances, cfg->instances_num, sizeof (*cfg->instances),
714       graph_sort_instances_cb);
716   return (0);
717 } /* }}} int graph_sort_instances */
719 int graph_clear_instances (graph_config_t *cfg) /* {{{ */
721   size_t i;
723   if (cfg == NULL)
724     return (EINVAL);
726   for (i = 0; i < cfg->instances_num; i++)
727     inst_destroy (cfg->instances[i]);
728   free (cfg->instances);
729   cfg->instances = NULL;
730   cfg->instances_num = 0;
732   return (0);
733 } /* }}} int graph_clear_instances */
735 int graph_get_rrdargs (graph_config_t *cfg, graph_instance_t *inst, /* {{{ */
736     rrd_args_t *args)
738   if ((cfg == NULL) || (inst == NULL) || (args == NULL))
739     return (EINVAL);
741   if (cfg->title != NULL)
742   {
743     array_append (args->options, "-t");
744     array_append (args->options, cfg->title);
745   }
747   if (cfg->vertical_label != NULL)
748   {
749     array_append (args->options, "-v");
750     array_append (args->options, cfg->vertical_label);
751   }
753   if (cfg->show_zero)
754   {
755     array_append (args->options, "-l");
756     array_append (args->options, "0");
757   }
759   return (0);
760 } /* }}} int graph_get_rrdargs */
762 /* vim: set sw=2 sts=2 et fdm=marker : */