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 **/
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 #include <unistd.h>
33 #include <fcntl.h>
35 #include <yajl/yajl_parse.h>
37 #include "graph_list.h"
38 #include "common.h"
39 #include "filesystem.h"
40 #include "graph.h"
41 #include "graph_config.h"
42 #include "graph_def.h"
43 #include "graph_ident.h"
44 #include "graph_instance.h"
45 #include "utils_cgi.h"
46 #include "utils_search.h"
48 #include <fcgiapp.h>
49 #include <fcgi_stdio.h>
51 /*
52 * Defines
53 */
54 #define UPDATE_INTERVAL 900
55 #define CACHE_FILE "/tmp/collection4.json"
57 /*
58 * Global variables
59 */
60 static graph_config_t **gl_active = NULL;
61 static size_t gl_active_num = 0;
63 static graph_config_t **gl_staging = NULL;
64 static size_t gl_staging_num = 0;
66 /* Graphs created on-the-fly for files which don't match any existing graph
67 * definition. */
68 static graph_config_t **gl_dynamic = NULL;
69 static size_t gl_dynamic_num = 0;
71 static char **host_list = NULL;
72 static size_t host_list_len = 0;
74 static time_t gl_last_update = 0;
76 /*
77 * Private functions
78 */
79 static int gl_add_graph_internal (graph_config_t *cfg, /* {{{ */
80 graph_config_t ***gl_array, size_t *gl_array_num)
81 {
82 graph_config_t **tmp;
84 #define ARRAY_PTR (*gl_array)
85 #define ARRAY_SIZE (*gl_array_num)
87 if (cfg == NULL)
88 return (EINVAL);
90 tmp = realloc (ARRAY_PTR, sizeof (*ARRAY_PTR) * (ARRAY_SIZE + 1));
91 if (tmp == NULL)
92 return (ENOMEM);
93 ARRAY_PTR = tmp;
95 ARRAY_PTR[ARRAY_SIZE] = cfg;
96 ARRAY_SIZE++;
98 #undef ARRAY_SIZE
99 #undef ARRAY_PTR
101 return (0);
102 } /* }}} int gl_add_graph_internal */
104 static void gl_destroy (graph_config_t ***gl_array, /* {{{ */
105 size_t *gl_array_num)
106 {
107 size_t i;
109 if ((gl_array == NULL) || (gl_array_num == NULL))
110 return;
112 #define ARRAY_PTR (*gl_array)
113 #define ARRAY_SIZE (*gl_array_num)
115 for (i = 0; i < ARRAY_SIZE; i++)
116 {
117 graph_destroy (ARRAY_PTR[i]);
118 ARRAY_PTR[i] = NULL;
119 }
120 free (ARRAY_PTR);
121 ARRAY_PTR = NULL;
122 ARRAY_SIZE = 0;
124 #undef ARRAY_SIZE
125 #undef ARRAY_PTR
126 } /* }}} void gl_destroy */
128 static int gl_register_host (const char *host) /* {{{ */
129 {
130 char **tmp;
131 size_t i;
133 if (host == NULL)
134 return (EINVAL);
136 for (i = 0; i < host_list_len; i++)
137 if (strcmp (host_list[i], host) == 0)
138 return (0);
140 tmp = realloc (host_list, sizeof (*host_list) * (host_list_len + 1));
141 if (tmp == NULL)
142 return (ENOMEM);
143 host_list = tmp;
145 host_list[host_list_len] = strdup (host);
146 if (host_list[host_list_len] == NULL)
147 return (ENOMEM);
149 host_list_len++;
150 return (0);
151 } /* }}} int gl_register_host */
153 static int gl_clear_hosts (void) /* {{{ */
154 {
155 size_t i;
157 for (i = 0; i < host_list_len; i++)
158 free (host_list[i]);
159 free (host_list);
161 host_list = NULL;
162 host_list_len = 0;
164 return (0);
165 } /* }}} int gl_clear_hosts */
167 static int gl_compare_hosts (const void *v0, const void *v1) /* {{{ */
168 {
169 return (strcmp (*(char * const *) v0, *(char * const *) v1));
170 } /* }}} int gl_compare_hosts */
172 static int gl_register_file (const graph_ident_t *file, /* {{{ */
173 __attribute__((unused)) void *user_data)
174 {
175 graph_config_t *cfg;
176 int num_graphs = 0;
177 size_t i;
179 for (i = 0; i < gl_active_num; i++)
180 {
181 graph_config_t *cfg = gl_active[i];
182 int status;
184 if (!graph_ident_matches (cfg, file))
185 continue;
187 status = graph_add_file (cfg, file);
188 if (status != 0)
189 {
190 /* report error */;
191 }
192 else
193 {
194 num_graphs++;
195 }
196 }
198 if (num_graphs == 0)
199 {
200 cfg = graph_create (file);
201 gl_add_graph_internal (cfg, &gl_dynamic, &gl_dynamic_num);
202 graph_add_file (cfg, file);
203 }
205 gl_register_host (ident_get_host (file));
207 return (0);
208 } /* }}} int gl_register_file */
210 static const char *get_part_from_param (const char *prim_key, /* {{{ */
211 const char *sec_key)
212 {
213 const char *val;
215 val = param (prim_key);
216 if (val != NULL)
217 return (val);
219 return (param (sec_key));
220 } /* }}} const char *get_part_from_param */
222 static int gl_clear_instances (void) /* {{{ */
223 {
224 size_t i;
226 for (i = 0; i < gl_active_num; i++)
227 graph_clear_instances (gl_active[i]);
229 return (0);
230 } /* }}} int gl_clear_instances */
232 static void gl_dump_cb (void *ctx, /* {{{ */
233 const char *str, unsigned int len)
234 {
235 FILE *fh = ctx;
237 /* FIXME: Has everything been written? */
238 fwrite ((void *) str, /* size = */ 1, /* nmemb = */ len, fh);
239 } /* }}} void gl_dump_cb */
241 static int gl_dump (void) /* {{{ */
242 {
243 FILE *fh;
244 yajl_gen handler;
245 yajl_gen_config handler_config = { /* pretty = */ 1, /* indent = */ " " };
246 size_t i;
248 /* FIXME: Lock the file */
249 fh = fopen (CACHE_FILE, "w");
250 if (fh == NULL)
251 return (errno);
253 handler = yajl_gen_alloc2 (gl_dump_cb, &handler_config,
254 /* alloc funcs = */ NULL, /* ctx = */ fh);
255 if (handler == NULL)
256 {
257 fclose (fh);
258 return (-1);
259 }
261 yajl_gen_array_open (handler);
263 for (i = 0; i < gl_active_num; i++)
264 graph_to_json (gl_active[i], handler);
266 for (i = 0; i < gl_dynamic_num; i++)
267 graph_to_json (gl_dynamic[i], handler);
269 yajl_gen_array_close (handler);
271 yajl_gen_free (handler);
272 fclose (fh);
274 return (0);
275 } /* }}} int gl_dump */
277 /*
278 * JSON parsing functions
279 */
280 #define CTX_MASK 0xff000000
281 #define CTX_GRAPH 0x01000000
282 #define CTX_GRAPH_SELECT 0x02000000
283 #define CTX_INST 0x03000000
284 #define CTX_INST_SELECT 0x04000000
285 #define CTX_INST_FILE 0x05000000
287 #define CTX_IDENT_MASK 0x00ff0000
288 #define CTX_IDENT_HOST 0x00010000
289 #define CTX_IDENT_PLUGIN 0x00020000
290 #define CTX_IDENT_PLUGIN_INSTANCE 0x00030000
291 #define CTX_IDENT_TYPE 0x00040000
292 #define CTX_IDENT_TYPE_INSTANCE 0x00050000
294 struct gl_json_context_s
295 {
296 uint32_t state;
298 graph_config_t *cfg;
299 graph_instance_t *inst;
300 graph_ident_t *ident;
302 _Bool dynamic_graph;
303 };
304 typedef struct gl_json_context_s gl_json_context_t;
306 static void set_state (gl_json_context_t *ctx, /* {{{ */
307 uint32_t new_state, uint32_t mask)
308 {
309 uint32_t old_state = ctx->state;
310 ctx->state = (old_state & ~mask) | (new_state & mask);
311 } /* }}} void set_state */
313 static int gl_json_string (void *user_data, /* {{{ */
314 const unsigned char *str,
315 unsigned int str_length)
316 {
317 gl_json_context_t *ctx = user_data;
318 char buffer[str_length + 1];
320 memcpy (buffer, str, str_length);
321 buffer[str_length] = 0;
323 if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
324 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
325 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
326 {
327 switch (ctx->state & CTX_IDENT_MASK)
328 {
329 case CTX_IDENT_HOST:
330 ident_set_host (ctx->ident, buffer);
331 break;
332 case CTX_IDENT_PLUGIN:
333 ident_set_plugin (ctx->ident, buffer);
334 break;
335 case CTX_IDENT_PLUGIN_INSTANCE:
336 ident_set_plugin_instance (ctx->ident, buffer);
337 break;
338 case CTX_IDENT_TYPE:
339 ident_set_type (ctx->ident, buffer);
340 break;
341 case CTX_IDENT_TYPE_INSTANCE:
342 ident_set_type_instance (ctx->ident, buffer);
343 break;
344 }
345 }
347 return (1);
348 } /* }}} int gl_json_string */
350 static int gl_json_end_map (void *user_data) /* {{{ */
351 {
352 gl_json_context_t *ctx = user_data;
354 if ((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
355 {
356 size_t i;
358 /* ctx->ident should now hold the valid selector */
359 assert (ctx->cfg == NULL);
360 assert (ctx->inst == NULL);
361 assert (ctx->ident != NULL);
363 for (i = 0; i < gl_active_num; i++)
364 {
365 if (graph_compare (gl_active[i], ctx->ident) != 0)
366 continue;
368 ctx->cfg = gl_active[i];
369 ctx->dynamic_graph = 0;
370 break;
371 }
373 if (ctx->cfg == NULL)
374 {
375 ctx->cfg = graph_create (ctx->ident);
376 ctx->dynamic_graph = 1;
377 }
379 ident_destroy (ctx->ident);
380 ctx->ident = NULL;
382 set_state (ctx, CTX_GRAPH, CTX_MASK);
383 }
384 else if ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
385 {
386 /* ctx->ident should now hold the valid selector */
387 assert (ctx->cfg != NULL);
388 assert (ctx->inst == NULL);
389 assert (ctx->ident != NULL);
391 ctx->inst = inst_create (ctx->cfg, ctx->ident);
392 ident_destroy (ctx->ident);
393 ctx->ident = NULL;
395 set_state (ctx, CTX_INST, CTX_MASK);
396 }
397 else if ((ctx->state & CTX_MASK) == CTX_INST_FILE)
398 {
399 /* ctx->ident should now hold the valid file */
400 assert (ctx->cfg != NULL);
401 assert (ctx->inst != NULL);
402 assert (ctx->ident != NULL);
404 inst_add_file (ctx->inst, ctx->ident);
405 ident_destroy (ctx->ident);
406 ctx->ident = NULL;
408 /* Don't reset the state here, files are in an array. */
409 }
410 else if ((ctx->state & CTX_MASK) == CTX_INST)
411 {
412 /* ctx->inst should now hold a complete instance */
413 assert (ctx->cfg != NULL);
414 assert (ctx->inst != NULL);
415 assert (ctx->ident == NULL);
417 graph_add_inst (ctx->cfg, ctx->inst);
418 /* don't destroy / free ctx->inst */
419 ctx->inst = NULL;
421 /* Don't reset the state here, instances are in an array. */
422 }
423 else if ((ctx->state & CTX_MASK) == CTX_GRAPH)
424 {
425 /* ctx->cfg should now hold a complete graph */
426 assert (ctx->cfg != NULL);
427 assert (ctx->inst == NULL);
428 assert (ctx->ident == NULL);
430 if (ctx->dynamic_graph)
431 gl_add_graph_internal (ctx->cfg, &gl_dynamic, &gl_dynamic_num);
432 /* else: already contained in gl_active */
433 ctx->cfg = NULL;
435 /* Don't reset the state here, graphs are in an array. */
436 }
438 return (1);
439 } /* }}} int gl_json_end_map */
441 static int gl_json_end_array (void *user_data) /* {{{ */
442 {
443 gl_json_context_t *ctx = user_data;
445 if ((ctx->state & CTX_MASK) == CTX_INST_FILE)
446 set_state (ctx, CTX_INST, CTX_MASK);
447 else if ((ctx->state & CTX_MASK) == CTX_INST)
448 set_state (ctx, CTX_GRAPH, CTX_MASK);
449 else if ((ctx->state & CTX_MASK) == CTX_GRAPH)
450 {
451 /* We're done */
452 }
454 return (1);
455 } /* }}} int gl_json_end_array */
457 static int gl_json_key (void *user_data, /* {{{ */
458 const unsigned char *str,
459 unsigned int str_length)
460 {
461 gl_json_context_t *ctx = user_data;
462 char buffer[str_length + 1];
464 memcpy (buffer, str, str_length);
465 buffer[str_length] = 0;
467 if ((ctx->state & CTX_MASK) == CTX_GRAPH)
468 {
469 if (strcasecmp ("select", buffer) == 0)
470 set_state (ctx, CTX_GRAPH_SELECT, CTX_MASK);
471 else if (strcasecmp ("instances", buffer) == 0)
472 set_state (ctx, CTX_INST, CTX_MASK);
473 }
474 else if ((ctx->state & CTX_MASK) == CTX_INST)
475 {
476 if (strcasecmp ("select", buffer) == 0)
477 set_state (ctx, CTX_INST_SELECT, CTX_MASK);
478 else if (strcasecmp ("files", buffer) == 0)
479 set_state (ctx, CTX_INST_FILE, CTX_MASK);
480 }
481 else if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
482 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
483 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
484 {
485 if (strcasecmp ("host", buffer) == 0)
486 set_state (ctx, CTX_IDENT_HOST, CTX_IDENT_MASK);
487 else if (strcasecmp ("plugin", buffer) == 0)
488 set_state (ctx, CTX_IDENT_PLUGIN, CTX_IDENT_MASK);
489 else if (strcasecmp ("plugin_instance", buffer) == 0)
490 set_state (ctx, CTX_IDENT_PLUGIN_INSTANCE, CTX_IDENT_MASK);
491 else if (strcasecmp ("type", buffer) == 0)
492 set_state (ctx, CTX_IDENT_TYPE, CTX_IDENT_MASK);
493 else if (strcasecmp ("type_instance", buffer) == 0)
494 set_state (ctx, CTX_IDENT_TYPE_INSTANCE, CTX_IDENT_MASK);
495 }
497 return (0);
498 } /* }}} int gl_json_key */
500 yajl_callbacks gl_json_callbacks =
501 {
502 /* null = */ NULL,
503 /* boolean = */ NULL,
504 /* integer = */ NULL,
505 /* double = */ NULL,
506 /* number = */ NULL,
507 /* string = */ gl_json_string,
508 /* start_map = */ NULL,
509 /* map_key = */ gl_json_key,
510 /* end_map = */ gl_json_end_map,
511 /* start_array = */ NULL,
512 /* end_array = */ gl_json_end_array
513 };
515 static int gl_read_cache (_Bool block) /* {{{ */
516 {
517 yajl_handle handle;
518 gl_json_context_t context;
519 yajl_parser_config handle_config = { /* comments = */ 0, /* check UTF-8 */ 0 };
521 int fd;
522 int cmd;
523 struct flock lock;
524 int status;
526 fd = open (CACHE_FILE, O_RDONLY);
527 if (fd < 0)
528 {
529 fprintf (stderr, "gl_read_cache: open(2) failed with status %i\n", errno);
530 return (errno);
531 }
533 if (block)
534 cmd = F_SETLKW;
535 else
536 cmd = F_SETLK;
538 memset (&lock, 0, sizeof (lock));
539 lock.l_type = F_RDLCK;
540 lock.l_whence = SEEK_SET;
541 lock.l_start = 0;
542 lock.l_len = 0; /* lock everything */
544 while (42)
545 {
546 status = fcntl (fd, cmd, &lock);
547 if (status == 0)
548 break;
550 if (!block && ((errno == EACCES) || (errno == EAGAIN)))
551 {
552 close (fd);
553 return (0);
554 }
556 if (errno == EINTR)
557 continue;
559 fprintf (stderr, "gl_read_cache: fcntl(2) failed with status %i\n",
560 errno);
561 return (errno);
562 }
564 memset (&context, 0, sizeof (context));
565 context.cfg = NULL;
566 context.inst = NULL;
567 context.ident = NULL;
569 handle = yajl_alloc (&gl_json_callbacks,
570 &handle_config,
571 /* alloc funcs = */ NULL,
572 &context);
574 close (fd);
576 } /* }}} int gl_read_cache */
578 /*
579 * Global functions
580 */
581 int gl_add_graph (graph_config_t *cfg) /* {{{ */
582 {
583 return (gl_add_graph_internal (cfg, &gl_staging, &gl_staging_num));
584 } /* }}} int gl_add_graph */
586 int gl_config_submit (void) /* {{{ */
587 {
588 graph_config_t **old;
589 size_t old_num;
591 old = gl_active;
592 old_num = gl_active_num;
594 gl_active = gl_staging;
595 gl_active_num = gl_staging_num;
597 gl_staging = NULL;
598 gl_staging_num = 0;
600 gl_destroy (&old, &old_num);
602 return (0);
603 } /* }}} int graph_config_submit */
605 int gl_graph_get_all (graph_callback_t callback, /* {{{ */
606 void *user_data)
607 {
608 size_t i;
610 if (callback == NULL)
611 return (EINVAL);
613 gl_update ();
615 for (i = 0; i < gl_active_num; i++)
616 {
617 int status;
619 status = (*callback) (gl_active[i], user_data);
620 if (status != 0)
621 return (status);
622 }
624 for (i = 0; i < gl_dynamic_num; i++)
625 {
626 int status;
628 status = (*callback) (gl_dynamic[i], user_data);
629 if (status != 0)
630 return (status);
631 }
633 return (0);
634 } /* }}} int gl_graph_get_all */
636 graph_config_t *gl_graph_get_selected (void) /* {{{ */
637 {
638 const char *host = get_part_from_param ("graph_host", "host");
639 const char *plugin = get_part_from_param ("graph_plugin", "plugin");
640 const char *plugin_instance = get_part_from_param ("graph_plugin_instance", "plugin_instance");
641 const char *type = get_part_from_param ("graph_type", "type");
642 const char *type_instance = get_part_from_param ("graph_type_instance", "type_instance");
643 graph_ident_t *ident;
644 size_t i;
646 if ((host == NULL)
647 || (plugin == NULL) || (plugin_instance == NULL)
648 || (type == NULL) || (type_instance == NULL))
649 return (NULL);
651 ident = ident_create (host, plugin, plugin_instance, type, type_instance);
653 gl_update ();
655 for (i = 0; i < gl_active_num; i++)
656 {
657 if (graph_compare (gl_active[i], ident) != 0)
658 continue;
660 ident_destroy (ident);
661 return (gl_active[i]);
662 }
664 for (i = 0; i < gl_dynamic_num; i++)
665 {
666 if (graph_compare (gl_dynamic[i], ident) != 0)
667 continue;
669 ident_destroy (ident);
670 return (gl_dynamic[i]);
671 }
673 ident_destroy (ident);
674 return (NULL);
675 } /* }}} graph_config_t *gl_graph_get_selected */
677 /* gl_instance_get_all, gl_graph_instance_get_all {{{ */
678 struct gl_inst_callback_data /* {{{ */
679 {
680 graph_config_t *cfg;
681 graph_inst_callback_t callback;
682 void *user_data;
683 }; /* }}} struct gl_inst_callback_data */
685 static int gl_inst_callback_handler (graph_instance_t *inst, /* {{{ */
686 void *user_data)
687 {
688 struct gl_inst_callback_data *data = user_data;
690 return ((*data->callback) (data->cfg, inst, data->user_data));
691 } /* }}} int gl_inst_callback_handler */
693 int gl_graph_instance_get_all (graph_config_t *cfg, /* {{{ */
694 graph_inst_callback_t callback, void *user_data)
695 {
696 struct gl_inst_callback_data data =
697 {
698 cfg,
699 callback,
700 user_data
701 };
703 if ((cfg == NULL) || (callback == NULL))
704 return (EINVAL);
706 return (graph_inst_foreach (cfg, gl_inst_callback_handler, &data));
707 } /* }}} int gl_graph_instance_get_all */
709 int gl_instance_get_all (graph_inst_callback_t callback, /* {{{ */
710 void *user_data)
711 {
712 size_t i;
714 gl_update ();
716 for (i = 0; i < gl_active_num; i++)
717 {
718 int status;
720 status = gl_graph_instance_get_all (gl_active[i], callback, user_data);
721 if (status != 0)
722 return (status);
723 }
725 for (i = 0; i < gl_dynamic_num; i++)
726 {
727 int status;
729 status = gl_graph_instance_get_all (gl_dynamic[i], callback, user_data);
730 if (status != 0)
731 return (status);
732 }
734 return (0);
735 } /* }}} int gl_instance_get_all */
736 /* }}} gl_instance_get_all, gl_graph_instance_get_all */
738 int gl_search (search_info_t *si, /* {{{ */
739 graph_inst_callback_t callback, void *user_data)
740 {
741 size_t i;
742 graph_ident_t *ident;
744 if ((si == NULL) || (callback == NULL))
745 return (EINVAL);
747 if (search_has_selector (si))
748 {
749 ident = search_to_ident (si);
750 if (ident == NULL)
751 {
752 fprintf (stderr, "gl_search: search_to_ident failed\n");
753 return (-1);
754 }
755 }
756 else
757 {
758 ident = NULL;
759 }
761 for (i = 0; i < gl_active_num; i++)
762 {
763 int status;
765 if ((ident != NULL) && !graph_ident_intersect (gl_active[i], ident))
766 continue;
768 status = graph_search_inst (gl_active[i], si,
769 /* callback = */ callback,
770 /* user data = */ user_data);
771 if (status != 0)
772 return (status);
773 }
775 for (i = 0; i < gl_dynamic_num; i++)
776 {
777 int status;
779 if ((ident != NULL) && !graph_ident_intersect (gl_dynamic[i], ident))
780 continue;
782 status = graph_search_inst (gl_dynamic[i], si,
783 /* callback = */ callback,
784 /* user data = */ user_data);
785 if (status != 0)
786 return (status);
787 }
789 return (0);
790 } /* }}} int gl_search */
792 int gl_search_string (const char *term, graph_inst_callback_t callback, /* {{{ */
793 void *user_data)
794 {
795 size_t i;
797 for (i = 0; i < gl_active_num; i++)
798 {
799 int status;
801 status = graph_search_inst_string (gl_active[i], term,
802 /* callback = */ callback,
803 /* user data = */ user_data);
804 if (status != 0)
805 return (status);
806 }
808 for (i = 0; i < gl_dynamic_num; i++)
809 {
810 int status;
812 status = graph_search_inst_string (gl_dynamic[i], term,
813 /* callback = */ callback,
814 /* user data = */ user_data);
815 if (status != 0)
816 return (status);
817 }
819 return (0);
820 } /* }}} int gl_search_string */
822 int gl_search_field (graph_ident_field_t field, /* {{{ */
823 const char *field_value,
824 graph_inst_callback_t callback, void *user_data)
825 {
826 size_t i;
828 if ((field_value == NULL) || (callback == NULL))
829 return (EINVAL);
831 for (i = 0; i < gl_active_num; i++)
832 {
833 int status;
835 status = graph_inst_search_field (gl_active[i],
836 field, field_value,
837 /* callback = */ callback,
838 /* user data = */ user_data);
839 if (status != 0)
840 return (status);
841 }
843 for (i = 0; i < gl_dynamic_num; i++)
844 {
845 int status;
847 status = graph_inst_search_field (gl_dynamic[i],
848 field, field_value,
849 /* callback = */ callback,
850 /* user data = */ user_data);
851 if (status != 0)
852 return (status);
853 }
855 return (0);
856 } /* }}} int gl_search_field */
858 int gl_foreach_host (int (*callback) (const char *host, void *user_data), /* {{{ */
859 void *user_data)
860 {
861 int status;
862 size_t i;
864 for (i = 0; i < host_list_len; i++)
865 {
866 status = (*callback) (host_list[i], user_data);
867 if (status != 0)
868 return (status);
869 }
871 return (0);
872 } /* }}} int gl_foreach_host */
874 int gl_update (void) /* {{{ */
875 {
876 time_t now;
877 int status;
878 size_t i;
880 /*
881 printf ("Content-Type: text/plain\n\n");
882 */
884 now = time (NULL);
886 if ((gl_last_update + UPDATE_INTERVAL) >= now)
887 return (0);
889 /* Clear state */
890 gl_clear_instances ();
891 gl_clear_hosts ();
892 gl_destroy (&gl_dynamic, &gl_dynamic_num);
894 graph_read_config ();
896 status = fs_scan (/* callback = */ gl_register_file, /* user data = */ NULL);
898 if (host_list_len > 0)
899 qsort (host_list, host_list_len, sizeof (*host_list),
900 gl_compare_hosts);
902 gl_last_update = now;
904 for (i = 0; i < gl_active_num; i++)
905 graph_sort_instances (gl_active[i]);
907 gl_dump ();
909 return (status);
910 } /* }}} int gl_update */
912 /* vim: set sw=2 sts=2 et fdm=marker : */