src/graph.[ch]: Implement "graph_sort_instances".
[collection4.git] / src / graph_list.c
1 /**
2  * collection4 - graph_list.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
32 #include "graph_list.h"
33 #include "common.h"
34 #include "filesystem.h"
35 #include "graph.h"
36 #include "graph_config.h"
37 #include "graph_def.h"
38 #include "graph_ident.h"
39 #include "utils_cgi.h"
40
41 #include <fcgiapp.h>
42 #include <fcgi_stdio.h>
43
44 /*
45  * Defines
46  */
47 #define UPDATE_INTERVAL 10
48
49 /*
50  * Global variables
51  */
52 static graph_config_t **gl_active = NULL;
53 static size_t gl_active_num = 0;
54
55 static graph_config_t **gl_staging = NULL;
56 static size_t gl_staging_num = 0;
57
58 static char **host_list = NULL;
59 static size_t host_list_len = 0;
60
61 static time_t gl_last_update = 0;
62
63 /*
64  * Private functions
65  */
66 static int gl_add_graph_internal (graph_config_t *cfg, /* {{{ */
67     graph_config_t ***gl_array, size_t *gl_array_num)
68 {
69   graph_config_t **tmp;
70
71 #define ARRAY_PTR  (*gl_array)
72 #define ARRAY_SIZE (*gl_array_num)
73
74   if (cfg == NULL)
75     return (EINVAL);
76
77   tmp = realloc (ARRAY_PTR, sizeof (*ARRAY_PTR) * (ARRAY_SIZE + 1));
78   if (tmp == NULL)
79     return (ENOMEM);
80   ARRAY_PTR = tmp;
81
82   ARRAY_PTR[ARRAY_SIZE] = cfg;
83   ARRAY_SIZE++;
84
85 #undef ARRAY_SIZE
86 #undef ARRAY_PTR
87
88   return (0);
89 } /* }}} int gl_add_graph_internal */
90
91 static int gl_register_host (const char *host) /* {{{ */
92 {
93   char **tmp;
94   size_t i;
95
96   if (host == NULL)
97     return (EINVAL);
98
99   for (i = 0; i < host_list_len; i++)
100     if (strcmp (host_list[i], host) == 0)
101       return (0);
102
103   tmp = realloc (host_list, sizeof (*host_list) * (host_list_len + 1));
104   if (tmp == NULL)
105     return (ENOMEM);
106   host_list = tmp;
107
108   host_list[host_list_len] = strdup (host);
109   if (host_list[host_list_len] == NULL)
110     return (ENOMEM);
111
112   host_list_len++;
113   return (0);
114 } /* }}} int gl_register_host */
115
116 static int gl_clear_hosts (void) /* {{{ */
117 {
118   size_t i;
119
120   for (i = 0; i < host_list_len; i++)
121     free (host_list[i]);
122   free (host_list);
123
124   host_list = NULL;
125   host_list_len = 0;
126
127   return (0);
128 } /* }}} int gl_clear_hosts */
129
130 static int gl_compare_hosts (const void *v0, const void *v1) /* {{{ */
131 {
132   return (strcmp (v0, v1));
133 } /* }}} int gl_compare_hosts */
134
135 static int gl_register_file (const graph_ident_t *file, /* {{{ */
136     __attribute__((unused)) void *user_data)
137 {
138   graph_config_t *cfg;
139   int num_graphs = 0;
140   size_t i;
141
142   for (i = 0; i < gl_active_num; i++)
143   {
144     graph_config_t *cfg = gl_active[i];
145     int status;
146
147     if (!graph_matches_ident (cfg, file))
148       continue;
149
150     status = graph_add_file (cfg, file);
151     if (status != 0)
152     {
153       /* report error */;
154     }
155     else
156     {
157       num_graphs++;
158     }
159   }
160
161   if (num_graphs == 0)
162   {
163     cfg = graph_create (file);
164     gl_add_graph_internal (cfg, &gl_active, &gl_active_num);
165     graph_add_file (cfg, file);
166   }
167
168   gl_register_host (ident_get_host (file));
169
170   return (0);
171 } /* }}} int gl_register_file */
172
173 static const char *get_part_from_param (const char *prim_key, /* {{{ */
174     const char *sec_key)
175 {
176   const char *val;
177
178   val = param (prim_key);
179   if (val != NULL)
180     return (val);
181   
182   return (param (sec_key));
183 } /* }}} const char *get_part_from_param */
184
185 static int gl_clear_instances (void) /* {{{ */
186 {
187   size_t i;
188
189   for (i = 0; i < gl_active_num; i++)
190     graph_clear_instances (gl_active[i]);
191
192   return (0);
193 } /* }}} int gl_clear_instances */
194
195
196 /*
197  * Global functions
198  */
199 int gl_add_graph (graph_config_t *cfg) /* {{{ */
200 {
201   return (gl_add_graph_internal (cfg, &gl_staging, &gl_staging_num));
202 } /* }}} int gl_add_graph */
203
204 int gl_config_submit (void) /* {{{ */
205 {
206   graph_config_t **old;
207   size_t old_num;
208   size_t i;
209
210   old = gl_active;
211   old_num = gl_active_num;
212
213   gl_active = gl_staging;
214   gl_active_num = gl_staging_num;
215
216   gl_staging = NULL;
217   gl_staging_num = 0;
218
219   for (i = 0; i < old_num; i++)
220   {
221     graph_destroy (old[i]);
222     old[i] = NULL;
223   }
224   free (old);
225
226   return (0);
227 } /* }}} int graph_config_submit */
228
229 int gl_graph_get_all (graph_callback_t callback, /* {{{ */
230     void *user_data)
231 {
232   size_t i;
233
234   if (callback == NULL)
235     return (EINVAL);
236
237   gl_update ();
238
239   for (i = 0; i < gl_active_num; i++)
240   {
241     int status;
242
243     status = (*callback) (gl_active[i], user_data);
244     if (status != 0)
245       return (status);
246   }
247
248   return (0);
249 } /* }}} int gl_graph_get_all */
250
251 graph_config_t *gl_graph_get_selected (void) /* {{{ */
252 {
253   const char *host = get_part_from_param ("graph_host", "host");
254   const char *plugin = get_part_from_param ("graph_plugin", "plugin");
255   const char *plugin_instance = get_part_from_param ("graph_plugin_instance", "plugin_instance");
256   const char *type = get_part_from_param ("graph_type", "type");
257   const char *type_instance = get_part_from_param ("graph_type_instance", "type_instance");
258   graph_ident_t *ident;
259   size_t i;
260
261   if ((host == NULL)
262       || (plugin == NULL) || (plugin_instance == NULL)
263       || (type == NULL) || (type_instance == NULL))
264     return (NULL);
265
266   ident = ident_create (host, plugin, plugin_instance, type, type_instance);
267
268   gl_update ();
269
270   for (i = 0; i < gl_active_num; i++)
271   {
272     if (graph_compare (gl_active[i], ident) != 0)
273       continue;
274
275     ident_destroy (ident);
276     return (gl_active[i]);
277   }
278
279   ident_destroy (ident);
280   return (NULL);
281 } /* }}} graph_config_t *gl_graph_get_selected */
282
283 /* gl_instance_get_all, gl_graph_instance_get_all {{{ */
284 struct gl_inst_callback_data /* {{{ */
285 {
286   graph_config_t *cfg;
287   graph_inst_callback_t callback;
288   void *user_data;
289 }; /* }}} struct gl_inst_callback_data */
290
291 static int gl_inst_callback_handler (graph_instance_t *inst, /* {{{ */
292     void *user_data)
293 {
294   struct gl_inst_callback_data *data = user_data;
295
296   return ((*data->callback) (data->cfg, inst, data->user_data));
297 } /* }}} int gl_inst_callback_handler */
298
299 int gl_graph_instance_get_all (graph_config_t *cfg, /* {{{ */
300     graph_inst_callback_t callback, void *user_data)
301 {
302   struct gl_inst_callback_data data =
303   {
304     cfg,
305     callback,
306     user_data
307   };
308
309   if ((cfg == NULL) || (callback == NULL))
310     return (EINVAL);
311
312   return (graph_inst_foreach (cfg, gl_inst_callback_handler, &data));
313 } /* }}} int gl_graph_instance_get_all */
314
315 int gl_instance_get_all (graph_inst_callback_t callback, /* {{{ */
316     void *user_data)
317 {
318   size_t i;
319
320   gl_update ();
321
322   for (i = 0; i < gl_active_num; i++)
323   {
324     int status;
325
326     status = gl_graph_instance_get_all (gl_active[i], callback, user_data);
327     if (status != 0)
328       return (status);
329   }
330
331   return (0);
332 } /* }}} int gl_instance_get_all */
333 /* }}} gl_instance_get_all, gl_graph_instance_get_all */
334
335 int gl_search (const char *term, graph_inst_callback_t callback, /* {{{ */
336     void *user_data)
337 {
338   size_t i;
339
340   for (i = 0; i < gl_active_num; i++)
341   {
342     int status;
343
344     status = graph_inst_search (gl_active[i], term,
345         /* callback  = */ callback,
346         /* user data = */ user_data);
347     if (status != 0)
348       return (status);
349   }
350
351   return (0);
352 } /* }}} int gl_search */
353
354 int gl_search_field (graph_ident_field_t field, /* {{{ */
355     const char *field_value,
356     graph_inst_callback_t callback, void *user_data)
357 {
358   size_t i;
359
360   if ((field_value == NULL) || (callback == NULL))
361     return (EINVAL);
362
363   for (i = 0; i < gl_active_num; i++)
364   {
365     int status;
366
367     status = graph_inst_search_field (gl_active[i],
368         field, field_value,
369         /* callback  = */ callback,
370         /* user data = */ user_data);
371     if (status != 0)
372       return (status);
373   }
374
375   return (0);
376 } /* }}} int gl_search_field */
377
378 int gl_foreach_host (int (*callback) (const char *host, void *user_data), /* {{{ */
379     void *user_data)
380 {
381   int status;
382   size_t i;
383
384   for (i = 0; i < host_list_len; i++)
385   {
386     status = (*callback) (host_list[i], user_data);
387     if (status != 0)
388       return (status);
389   }
390
391   return (0);
392 } /* }}} int gl_foreach_host */
393
394 int gl_update (void) /* {{{ */
395 {
396   time_t now;
397   int status;
398
399   /*
400   printf ("Content-Type: text/plain\n\n");
401   */
402
403   now = time (NULL);
404
405   if ((gl_last_update + UPDATE_INTERVAL) >= now)
406     return (0);
407
408   graph_read_config ();
409
410   gl_clear_instances ();
411   gl_clear_hosts ();
412   status = fs_scan (/* callback = */ gl_register_file, /* user data = */ NULL);
413
414   if (host_list_len > 0)
415     qsort (host_list, host_list_len, sizeof (*host_list),
416         gl_compare_hosts);
417
418   gl_last_update = now;
419
420   return (status);
421 } /* }}} int gl_update */
422
423 /* vim: set sw=2 sts=2 et fdm=marker : */