"show graph" action: Implement displaying _graphs_ (rather than instances).
[collection4.git] / src / graph_instance.c
1 #include <stdlib.h>
2 #include <string.h>
3 #include <errno.h>
4 #include <time.h>
5
6 #include "graph_instance.h"
7 #include "graph_def.h"
8 #include "graph_ident.h"
9 #include "graph_list.h"
10 #include "common.h"
11 #include "utils_cgi.h"
12
13 #include <fcgiapp.h>
14 #include <fcgi_stdio.h>
15
16 struct graph_instance_s /* {{{ */
17 {
18   graph_ident_t *select;
19
20   graph_ident_t **files;
21   size_t files_num;
22
23   graph_instance_t *next;
24 }; /* }}} struct graph_instance_s */
25
26 struct def_callback_data_s
27 {
28   graph_instance_t *inst;
29   str_array_t *args;
30 };
31 typedef struct def_callback_data_s def_callback_data_t;
32
33 /*
34  * Private functions
35  */
36 /* Create one DEF for each data source in the file. Called by
37  * "inst_get_default_defs" for each file. */
38 static graph_def_t *ident_get_default_defs (graph_config_t *cfg, /* {{{ */
39     graph_ident_t *ident, graph_def_t *def_head)
40 {
41   graph_def_t *defs = NULL;
42   char *file;
43   char **dses = NULL;
44   size_t dses_num = 0;
45   int status;
46   size_t i;
47
48   if ((cfg == NULL) || (ident == NULL))
49     return (def_head);
50
51   file = ident_to_file (ident);
52   if (file == NULL)
53   {
54     fprintf (stderr, "ident_get_default_defs: ident_to_file failed\n");
55     return (def_head);
56   }
57
58   status = ds_list_from_rrd_file (file, &dses_num, &dses);
59   if (status != 0)
60   {
61     free (file);
62     return (def_head);
63   }
64
65   for (i = 0; i < dses_num; i++)
66   {
67     graph_def_t *def;
68
69     def = def_search (def_head, ident, dses[i]);
70     if (def != NULL)
71       continue;
72
73     def = def_create (cfg, ident, dses[i]);
74     if (def == NULL)
75       continue;
76
77     if (defs == NULL)
78       defs = def;
79     else
80       def_append (defs, def);
81
82     free (dses[i]);
83   }
84
85   free (dses);
86   free (file);
87
88   return (defs);
89 } /* }}} int ident_get_default_defs */
90
91 /* Create one or more DEFs for each file in the graph instance. The number
92  * depends on the number of data sources in each of the files. Called from
93  * "inst_get_rrdargs" if no DEFs are available from the configuration.
94  * */
95 static graph_def_t *inst_get_default_defs (graph_config_t *cfg, /* {{{ */
96     graph_instance_t *inst)
97 {
98   graph_def_t *defs = NULL;
99   size_t i;
100
101   if ((cfg == NULL) || (inst == NULL))
102     return (NULL);
103
104   for (i = 0; i < inst->files_num; i++)
105   {
106     graph_def_t *def;
107
108     def = ident_get_default_defs (cfg, inst->files[i], defs);
109     if (def == NULL)
110       continue;
111
112     if (defs == NULL)
113       defs = def;
114     else
115       def_append (defs, def);
116   }
117
118   return (defs);
119 } /* }}} graph_def_t *inst_get_default_defs */
120
121 /* Called with each DEF in turn. Calls "def_get_rrdargs" with every appropriate
122  * file / DEF pair. */
123 static int gl_instance_get_rrdargs_cb (graph_def_t *def, void *user_data) /* {{{ */
124 {
125   def_callback_data_t *data = user_data;
126   graph_instance_t *inst = data->inst;
127   str_array_t *args = data->args;
128
129   size_t i;
130
131   for (i = 0; i < inst->files_num; i++)
132   {
133     if (!def_matches (def, inst->files[i]))
134       continue;
135
136     def_get_rrdargs (def, inst->files[i], args);
137   }
138
139   return (0);
140 } /* }}} int gl_instance_get_rrdargs_cb */
141
142 static const char *get_part_from_param (const char *prim_key, /* {{{ */
143     const char *sec_key)
144 {
145   const char *val;
146
147   val = param (prim_key);
148   if (val != NULL)
149     return (val);
150   
151   return (param (sec_key));
152 } /* }}} const char *get_part_from_param */
153
154 /*
155  * Public functions
156  */
157 graph_instance_t *inst_create (graph_config_t *cfg, /* {{{ */
158     const graph_ident_t *ident)
159 {
160   graph_instance_t *i;
161   graph_ident_t *selector;
162
163   if ((cfg == NULL) || (ident == NULL))
164     return (NULL);
165
166   i = malloc (sizeof (*i));
167   if (i == NULL)
168     return (NULL);
169   memset (i, 0, sizeof (*i));
170
171   selector = graph_get_selector (cfg);
172   if (selector == NULL)
173   {
174     fprintf (stderr, "inst_create: graph_get_selector failed\n");
175     free (i);
176     return (NULL);
177   }
178
179   i->select = ident_copy_with_selector (selector, ident,
180       IDENT_FLAG_REPLACE_ANY);
181   if (i->select == NULL)
182   {
183     fprintf (stderr, "inst_create: ident_copy_with_selector failed\n");
184     ident_destroy (selector);
185     free (i);
186     return (NULL);
187   }
188
189   ident_destroy (selector);
190
191   i->files = NULL;
192   i->files_num = 0;
193
194   i->next = NULL;
195
196   return (i);
197 } /* }}} graph_instance_t *inst_create */
198
199 void inst_destroy (graph_instance_t *inst) /* {{{ */
200 {
201   graph_instance_t *next;
202   size_t i;
203
204   if (inst == NULL)
205     return;
206
207   next = inst->next;
208
209   ident_destroy (inst->select);
210
211   for (i = 0; i < inst->files_num; i++)
212     ident_destroy (inst->files[i]);
213   free (inst->files);
214
215   free (inst);
216
217   inst_destroy (next);
218 } /* }}} void inst_destroy */
219
220 int inst_add_file (graph_instance_t *inst, /* {{{ */
221     const graph_ident_t *file)
222 {
223   graph_ident_t **tmp;
224
225   tmp = realloc (inst->files, sizeof (*inst->files) * (inst->files_num + 1));
226   if (tmp == NULL)
227     return (ENOMEM);
228   inst->files = tmp;
229
230   inst->files[inst->files_num] = ident_clone (file);
231   if (inst->files[inst->files_num] == NULL)
232     return (ENOMEM);
233
234   inst->files_num++;
235
236   return (0);
237 } /* }}} int inst_add_file */
238
239 graph_instance_t *inst_get_selected (graph_config_t *cfg) /* {{{ */
240 {
241   const char *host = get_part_from_param ("inst_host", "host");
242   const char *plugin = get_part_from_param ("inst_plugin", "plugin");
243   const char *plugin_instance = get_part_from_param ("inst_plugin_instance", "plugin_instance");
244   const char *type = get_part_from_param ("inst_type", "type");
245   const char *type_instance = get_part_from_param ("inst_type_instance", "type_instance");
246   graph_ident_t *ident;
247   graph_instance_t *inst;
248
249   if (cfg == NULL)
250     cfg = gl_graph_get_selected ();
251
252   if (cfg == NULL)
253   {
254     DEBUG ("inst_get_selected: cfg == NULL;\n");
255     return (NULL);
256   }
257
258   if ((host == NULL)
259       || (plugin == NULL) || (plugin_instance == NULL)
260       || (type == NULL) || (type_instance == NULL))
261   {
262     DEBUG ("inst_get_selected: A parameter is NULL.\n");
263     return (NULL);
264   }
265
266   ident = ident_create (host, plugin, plugin_instance, type, type_instance);
267
268   for (inst = graph_get_instances (cfg); inst != NULL; inst = inst->next)
269   {
270     if (ident_compare (ident, inst->select) != 0)
271       continue;
272
273     ident_destroy (ident);
274     return (inst);
275   }
276
277   DEBUG ("inst_get_selected: No match found.\n");
278   ident_destroy (ident);
279   return (NULL);
280 } /* }}} graph_instance_t *inst_get_selected */
281
282 int inst_get_rrdargs (graph_config_t *cfg, /* {{{ */
283     graph_instance_t *inst,
284     str_array_t *args)
285 {
286   def_callback_data_t data = { inst, args };
287   graph_def_t *defs;
288   int status;
289
290   if ((cfg == NULL) || (inst == NULL) || (args == NULL))
291     return (EINVAL);
292
293   status = graph_get_rrdargs (cfg, inst, args);
294   if (status != 0)
295     return (status);
296
297   defs = graph_get_defs (cfg);
298   if (defs == NULL)
299   {
300     defs = inst_get_default_defs (cfg, inst);
301
302     if (defs == NULL)
303       return (-1);
304
305     status = def_foreach (defs, gl_instance_get_rrdargs_cb, &data);
306
307     def_destroy (defs);
308   }
309   else
310   {
311     status = def_foreach (defs, gl_instance_get_rrdargs_cb, &data);
312   }
313
314   return (status);
315 } /* }}} int inst_get_rrdargs */
316
317 graph_ident_t *inst_get_selector (graph_instance_t *inst) /* {{{ */
318 {
319   if (inst == NULL)
320     return (NULL);
321
322   return (ident_clone (inst->select));
323 } /* }}} graph_ident_t *inst_get_selector */
324
325 int inst_get_params (graph_config_t *cfg, graph_instance_t *inst, /* {{{ */
326     char *buffer, size_t buffer_size)
327 {
328   graph_ident_t *cfg_select;
329
330   if ((cfg == NULL) || (inst == NULL)
331       || (buffer == NULL) || (buffer_size < 1))
332     return (EINVAL);
333
334   cfg_select = graph_get_selector (cfg);
335   if (cfg_select == NULL)
336   {
337     fprintf (stderr, "inst_get_params: graph_get_selector failed");
338     return (-1);
339   }
340
341   buffer[0] = 0;
342
343 #define COPY_FIELD(field) do {                                  \
344   const char *cfg_f  = ident_get_##field (cfg_select);          \
345   const char *inst_f = ident_get_##field (inst->select);        \
346   if (strcmp (cfg_f, inst_f) == 0)                              \
347   {                                                             \
348     strlcat (buffer, #field, buffer_size);                      \
349     strlcat (buffer, "=", buffer_size);                         \
350     strlcat (buffer, cfg_f, buffer_size);                       \
351   }                                                             \
352   else                                                          \
353   {                                                             \
354     strlcat (buffer, "graph_", buffer_size);                    \
355     strlcat (buffer, #field, buffer_size);                      \
356     strlcat (buffer, "=", buffer_size);                         \
357     strlcat (buffer, cfg_f, buffer_size);                       \
358     strlcat (buffer, ";", buffer_size);                         \
359     strlcat (buffer, "inst_", buffer_size);                     \
360     strlcat (buffer, #field, buffer_size);                      \
361     strlcat (buffer, "=", buffer_size);                         \
362     strlcat (buffer, inst_f, buffer_size);                      \
363   }                                                             \
364 } while (0)
365
366   COPY_FIELD(host);
367   strlcat (buffer, ";", buffer_size);
368   COPY_FIELD(plugin);
369   strlcat (buffer, ";", buffer_size);
370   COPY_FIELD(plugin_instance);
371   strlcat (buffer, ";", buffer_size);
372   COPY_FIELD(type);
373   strlcat (buffer, ";", buffer_size);
374   COPY_FIELD(type_instance);
375
376 #undef COPY_FIELD
377
378   ident_destroy (cfg_select);
379
380   return (0);
381 } /* }}} int inst_get_params */
382
383 int inst_append (graph_instance_t *head, graph_instance_t *inst) /* {{{ */
384 {
385   graph_instance_t *ptr;
386
387   if ((head == NULL) || (inst == NULL))
388     return (EINVAL);
389
390   ptr = head;
391   while (ptr->next != NULL)
392     ptr = ptr->next;
393
394   ptr->next = inst;
395
396   return (0);
397 } /* }}} int inst_append */
398
399 int inst_foreach (graph_instance_t *inst, /* {{{ */
400                 inst_callback_t cb, void *user_data)
401 {
402   graph_instance_t *ptr;
403
404   if ((inst == NULL) || (cb == NULL))
405     return (EINVAL);
406
407   for (ptr = inst; ptr != NULL; ptr = ptr->next)
408   {
409     int status;
410
411     status = (*cb) (ptr, user_data);
412     if (status != 0)
413       return (status);
414   }
415
416   return (0);
417 } /* }}} int inst_foreach */
418
419 int inst_search (graph_config_t *cfg, graph_instance_t *inst, /* {{{ */
420     const char *term, inst_callback_t cb, void *user_data)
421 {
422   graph_instance_t *ptr;
423   char buffer[1024];
424   int status;
425
426   if ((inst == NULL) || (cb == NULL))
427     return (EINVAL);
428
429   for (ptr = inst; ptr != NULL; ptr = ptr->next)
430   {
431     status = inst_describe (cfg, ptr, buffer, sizeof (buffer));
432     if (status != 0)
433     {
434       fprintf (stderr, "inst_search: inst_describe failed\n");
435       return (status);
436     }
437
438     strtolower (buffer);
439
440     /* no match */
441     if (strstr (buffer, term) == NULL)
442       continue;
443
444     /* match */
445     status = (*cb) (ptr, user_data);
446     if (status != 0)
447       return (status);
448   }
449
450   return (0);
451 } /* }}} int inst_search */
452
453 graph_instance_t *inst_find_matching (graph_instance_t *inst, /* {{{ */
454     const graph_ident_t *ident)
455 {
456   graph_instance_t *ptr;
457
458   if ((inst == NULL) || (ident == NULL))
459     return (NULL);
460
461   for (ptr = inst; ptr != NULL; ptr = ptr->next)
462     if (ident_matches (ptr->select, ident))
463       return (ptr);
464
465   return (NULL);
466 } /* }}} graph_instance_t *inst_find_matching */
467
468 int inst_describe (graph_config_t *cfg, graph_instance_t *inst, /* {{{ */
469     char *buffer, size_t buffer_size)
470 {
471   graph_ident_t *cfg_select;
472
473   if ((cfg == NULL) || (inst == NULL)
474       || (buffer == NULL) || (buffer_size < 2))
475     return (EINVAL);
476
477   cfg_select = graph_get_selector (cfg);
478   if (cfg_select == NULL)
479   {
480     fprintf (stderr, "inst_describe: graph_get_selector failed\n");
481     return (-1);
482   }
483
484   buffer[0] = 0;
485
486 #define CHECK_FIELD(field) do {                                              \
487   if (IS_ANY (ident_get_##field (cfg_select)))                               \
488   {                                                                          \
489     if (buffer[0] != 0)                                                      \
490       strlcat (buffer, "/", buffer_size);                                    \
491     strlcat (buffer, ident_get_##field (inst->select), buffer_size);         \
492   }                                                                          \
493 } while (0)
494
495   CHECK_FIELD (host);
496   CHECK_FIELD (plugin);
497   CHECK_FIELD (plugin_instance);
498   CHECK_FIELD (type);
499   CHECK_FIELD (type_instance);
500
501 #undef CHECK_FIELD
502
503   if (buffer[0] == 0)
504     strlcat (buffer, "default", buffer_size);
505
506   ident_destroy (cfg_select);
507
508   return (0);
509 } /* }}} int inst_describe */
510
511 time_t inst_get_mtime (graph_instance_t *inst) /* {{{ */
512 {
513   size_t i;
514   time_t mtime;
515
516   if (inst == NULL)
517     return (0);
518
519   mtime = 0;
520   for (i = 0; i < inst->files_num; i++)
521   {
522     time_t tmp;
523
524     tmp = ident_get_mtime (inst->files[i]);
525     if (mtime < tmp)
526       mtime = tmp;
527   }
528
529   return (mtime);
530 } /* }}} time_t inst_get_mtime */
531
532 /* vim: set sw=2 sts=2 et fdm=marker : */