60cb82a925f0abc1751840ee32347fa8d1231dad
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>
34 #include <sys/types.h>
35 #include <sys/stat.h>
37 #include <yajl/yajl_parse.h>
39 #include "graph_list.h"
40 #include "common.h"
41 #include "filesystem.h"
42 #include "graph.h"
43 #include "graph_config.h"
44 #include "graph_def.h"
45 #include "graph_ident.h"
46 #include "graph_instance.h"
47 #include "utils_cgi.h"
48 #include "utils_search.h"
50 #include <fcgiapp.h>
51 #include <fcgi_stdio.h>
53 /*
54 * Defines
55 */
56 #define UPDATE_INTERVAL 900
57 #define CACHE_FILE "/tmp/collection4.json"
59 /*
60 * Global variables
61 */
62 static graph_config_t **gl_active = NULL;
63 static size_t gl_active_num = 0;
65 static graph_config_t **gl_staging = NULL;
66 static size_t gl_staging_num = 0;
68 /* Graphs created on-the-fly for files which don't match any existing graph
69 * definition. */
70 static graph_config_t **gl_dynamic = NULL;
71 static size_t gl_dynamic_num = 0;
73 static char **host_list = NULL;
74 static size_t host_list_len = 0;
76 static time_t gl_last_update = 0;
78 /*
79 * Private functions
80 */
81 static int gl_add_graph_internal (graph_config_t *cfg, /* {{{ */
82 graph_config_t ***gl_array, size_t *gl_array_num)
83 {
84 graph_config_t **tmp;
86 #define ARRAY_PTR (*gl_array)
87 #define ARRAY_SIZE (*gl_array_num)
89 if (cfg == NULL)
90 return (EINVAL);
92 tmp = realloc (ARRAY_PTR, sizeof (*ARRAY_PTR) * (ARRAY_SIZE + 1));
93 if (tmp == NULL)
94 return (ENOMEM);
95 ARRAY_PTR = tmp;
97 ARRAY_PTR[ARRAY_SIZE] = cfg;
98 ARRAY_SIZE++;
100 #undef ARRAY_SIZE
101 #undef ARRAY_PTR
103 return (0);
104 } /* }}} int gl_add_graph_internal */
106 static void gl_destroy (graph_config_t ***gl_array, /* {{{ */
107 size_t *gl_array_num)
108 {
109 size_t i;
111 if ((gl_array == NULL) || (gl_array_num == NULL))
112 return;
114 #define ARRAY_PTR (*gl_array)
115 #define ARRAY_SIZE (*gl_array_num)
117 for (i = 0; i < ARRAY_SIZE; i++)
118 {
119 graph_destroy (ARRAY_PTR[i]);
120 ARRAY_PTR[i] = NULL;
121 }
122 free (ARRAY_PTR);
123 ARRAY_PTR = NULL;
124 ARRAY_SIZE = 0;
126 #undef ARRAY_SIZE
127 #undef ARRAY_PTR
128 } /* }}} void gl_destroy */
130 static int gl_register_host (const char *host) /* {{{ */
131 {
132 char **tmp;
133 size_t i;
135 if (host == NULL)
136 return (EINVAL);
138 for (i = 0; i < host_list_len; i++)
139 if (strcmp (host_list[i], host) == 0)
140 return (0);
142 tmp = realloc (host_list, sizeof (*host_list) * (host_list_len + 1));
143 if (tmp == NULL)
144 return (ENOMEM);
145 host_list = tmp;
147 host_list[host_list_len] = strdup (host);
148 if (host_list[host_list_len] == NULL)
149 return (ENOMEM);
151 host_list_len++;
152 return (0);
153 } /* }}} int gl_register_host */
155 static int gl_clear_hosts (void) /* {{{ */
156 {
157 size_t i;
159 for (i = 0; i < host_list_len; i++)
160 free (host_list[i]);
161 free (host_list);
163 host_list = NULL;
164 host_list_len = 0;
166 return (0);
167 } /* }}} int gl_clear_hosts */
169 static int gl_compare_hosts (const void *v0, const void *v1) /* {{{ */
170 {
171 return (strcmp (*(char * const *) v0, *(char * const *) v1));
172 } /* }}} int gl_compare_hosts */
174 static int gl_register_file (const graph_ident_t *file, /* {{{ */
175 __attribute__((unused)) void *user_data)
176 {
177 graph_config_t *cfg;
178 int num_graphs = 0;
179 size_t i;
181 for (i = 0; i < gl_active_num; i++)
182 {
183 graph_config_t *cfg = gl_active[i];
184 int status;
186 if (!graph_ident_matches (cfg, file))
187 continue;
189 status = graph_add_file (cfg, file);
190 if (status != 0)
191 {
192 /* report error */;
193 }
194 else
195 {
196 num_graphs++;
197 }
198 }
200 if (num_graphs == 0)
201 {
202 cfg = graph_create (file);
203 gl_add_graph_internal (cfg, &gl_dynamic, &gl_dynamic_num);
204 graph_add_file (cfg, file);
205 }
207 gl_register_host (ident_get_host (file));
209 return (0);
210 } /* }}} int gl_register_file */
212 static const char *get_part_from_param (const char *prim_key, /* {{{ */
213 const char *sec_key)
214 {
215 const char *val;
217 val = param (prim_key);
218 if (val != NULL)
219 return (val);
221 return (param (sec_key));
222 } /* }}} const char *get_part_from_param */
224 static int gl_clear_instances (void) /* {{{ */
225 {
226 size_t i;
228 for (i = 0; i < gl_active_num; i++)
229 graph_clear_instances (gl_active[i]);
231 return (0);
232 } /* }}} int gl_clear_instances */
234 static void gl_dump_cb (void *ctx, /* {{{ */
235 const char *str, unsigned int len)
236 {
237 int fd = *((int *) ctx);
238 const char *buffer;
239 size_t buffer_size;
240 ssize_t status;
242 buffer = str;
243 buffer_size = (size_t) len;
244 while (buffer_size > 0)
245 {
246 status = write (fd, buffer, buffer_size);
247 if (status < 0)
248 {
249 fprintf (stderr, "write(2) failed with status %i\n", errno);
250 return;
251 }
253 buffer += status;
254 buffer_size -= status;
255 }
256 } /* }}} void gl_dump_cb */
258 static int gl_update_cache (void) /* {{{ */
259 {
260 int fd;
261 yajl_gen handler;
262 yajl_gen_config handler_config = { /* pretty = */ 1, /* indent = */ " " };
263 struct flock lock;
264 struct stat statbuf;
265 int status;
266 size_t i;
268 memset (&statbuf, 0, sizeof (statbuf));
269 status = stat (CACHE_FILE, &statbuf);
270 if (status == 0)
271 {
272 if (statbuf.st_mtime >= gl_last_update)
273 {
274 fprintf (stderr, "gl_update_cache: Not writing to cache because it's "
275 "at least as new as our internal data\n");
276 return (0);
277 }
278 }
279 else
280 {
281 status = errno;
282 fprintf (stderr, "gl_update_cache: stat(2) failed with status %i\n",
283 status);
284 /* Continue writing the file if possible. */
285 }
287 fd = open (CACHE_FILE, O_WRONLY | O_TRUNC | O_CREAT,
288 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
289 if (fd < 0)
290 {
291 status = errno;
292 fprintf (stderr, "gl_update_cache: open(2) failed with status %i\n",
293 status);
294 return (status);
295 }
297 memset (&lock, 0, sizeof (lock));
298 lock.l_type = F_WRLCK;
299 lock.l_whence = SEEK_SET;
300 lock.l_start = 0;
301 lock.l_len = 0; /* lock everything */
303 while (42)
304 {
305 status = fcntl (fd, F_SETLKW, &lock);
306 if (status == 0)
307 break;
309 if (errno == EINTR)
310 continue;
312 fprintf (stderr, "gl_update_cache: fcntl(2) failed with status %i\n", errno);
313 close (fd);
314 return (errno);
315 }
317 handler = yajl_gen_alloc2 (gl_dump_cb, &handler_config,
318 /* alloc funcs = */ NULL, /* ctx = */ &fd);
319 if (handler == NULL)
320 {
321 close (fd);
322 return (-1);
323 }
325 fprintf (stderr, "gl_update_cache: Start writing data\n");
326 fflush (stderr);
328 yajl_gen_array_open (handler);
330 for (i = 0; i < gl_active_num; i++)
331 graph_to_json (gl_active[i], handler);
333 for (i = 0; i < gl_dynamic_num; i++)
334 graph_to_json (gl_dynamic[i], handler);
336 yajl_gen_array_close (handler);
338 yajl_gen_free (handler);
339 close (fd);
341 fprintf (stderr, "gl_update_cache: Finished writing data\n");
342 fflush (stderr);
344 return (0);
345 } /* }}} int gl_update_cache */
347 static int gl_scan_directory (void)
348 {
349 return (-1);
350 } /* }}} int gl_scan_directory */
352 /*
353 * JSON parsing functions
354 */
355 #define CTX_MASK 0xff000000
356 #define CTX_GRAPH 0x01000000
357 #define CTX_GRAPH_SELECT 0x02000000
358 #define CTX_INST 0x03000000
359 #define CTX_INST_SELECT 0x04000000
360 #define CTX_INST_FILE 0x05000000
362 #define CTX_IDENT_MASK 0x00ff0000
363 #define CTX_IDENT_HOST 0x00010000
364 #define CTX_IDENT_PLUGIN 0x00020000
365 #define CTX_IDENT_PLUGIN_INSTANCE 0x00030000
366 #define CTX_IDENT_TYPE 0x00040000
367 #define CTX_IDENT_TYPE_INSTANCE 0x00050000
369 struct gl_json_context_s
370 {
371 uint32_t state;
373 graph_config_t *cfg;
374 graph_instance_t *inst;
375 graph_ident_t *ident;
377 _Bool dynamic_graph;
378 };
379 typedef struct gl_json_context_s gl_json_context_t;
381 static void set_state (gl_json_context_t *ctx, /* {{{ */
382 uint32_t new_state, uint32_t mask)
383 {
384 uint32_t old_state = ctx->state;
385 ctx->state = (old_state & ~mask) | (new_state & mask);
386 } /* }}} void set_state */
388 static int gl_json_string (void *user_data, /* {{{ */
389 const unsigned char *str,
390 unsigned int str_length)
391 {
392 gl_json_context_t *ctx = user_data;
393 char buffer[str_length + 1];
395 memcpy (buffer, str, str_length);
396 buffer[str_length] = 0;
398 if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
399 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
400 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
401 {
402 switch (ctx->state & CTX_IDENT_MASK)
403 {
404 case CTX_IDENT_HOST:
405 ident_set_host (ctx->ident, buffer);
406 break;
407 case CTX_IDENT_PLUGIN:
408 ident_set_plugin (ctx->ident, buffer);
409 break;
410 case CTX_IDENT_PLUGIN_INSTANCE:
411 ident_set_plugin_instance (ctx->ident, buffer);
412 break;
413 case CTX_IDENT_TYPE:
414 ident_set_type (ctx->ident, buffer);
415 break;
416 case CTX_IDENT_TYPE_INSTANCE:
417 ident_set_type_instance (ctx->ident, buffer);
418 break;
419 }
420 }
422 return (1);
423 } /* }}} int gl_json_string */
425 static int gl_json_start_map (void *user_data) /* {{{ */
426 {
427 gl_json_context_t *ctx = user_data;
429 if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
430 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
431 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
432 {
433 assert (ctx->ident == NULL);
434 ctx->ident = ident_create (ANY_TOKEN,
435 ANY_TOKEN, ANY_TOKEN,
436 ANY_TOKEN, ANY_TOKEN);
437 }
439 return (1);
440 } /* }}} int gl_json_start_map */
442 static int gl_json_end_map (void *user_data) /* {{{ */
443 {
444 gl_json_context_t *ctx = user_data;
446 if ((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
447 {
448 size_t i;
450 /* ctx->ident should now hold the valid selector */
451 assert (ctx->cfg == NULL);
452 assert (ctx->inst == NULL);
453 assert (ctx->ident != NULL);
455 for (i = 0; i < gl_active_num; i++)
456 {
457 if (graph_compare (gl_active[i], ctx->ident) != 0)
458 continue;
460 ctx->cfg = gl_active[i];
461 ctx->dynamic_graph = 0;
462 break;
463 }
465 if (ctx->cfg == NULL)
466 {
467 ctx->cfg = graph_create (ctx->ident);
468 ctx->dynamic_graph = 1;
469 }
471 ident_destroy (ctx->ident);
472 ctx->ident = NULL;
474 set_state (ctx, CTX_GRAPH, CTX_MASK);
475 }
476 else if ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
477 {
478 /* ctx->ident should now hold the valid selector */
479 assert (ctx->cfg != NULL);
480 assert (ctx->inst == NULL);
481 assert (ctx->ident != NULL);
483 ctx->inst = inst_create (ctx->cfg, ctx->ident);
484 ident_destroy (ctx->ident);
485 ctx->ident = NULL;
487 set_state (ctx, CTX_INST, CTX_MASK);
488 }
489 else if ((ctx->state & CTX_MASK) == CTX_INST_FILE)
490 {
491 /* ctx->ident should now hold the valid file */
492 assert (ctx->cfg != NULL);
493 assert (ctx->inst != NULL);
494 assert (ctx->ident != NULL);
496 inst_add_file (ctx->inst, ctx->ident);
497 ident_destroy (ctx->ident);
498 ctx->ident = NULL;
500 /* Don't reset the state here, files are in an array. */
501 }
502 else if ((ctx->state & CTX_MASK) == CTX_INST)
503 {
504 /* ctx->inst should now hold a complete instance */
505 assert (ctx->cfg != NULL);
506 assert (ctx->inst != NULL);
507 assert (ctx->ident == NULL);
509 graph_add_inst (ctx->cfg, ctx->inst);
510 /* don't destroy / free ctx->inst */
511 ctx->inst = NULL;
513 /* Don't reset the state here, instances are in an array. */
514 }
515 else if ((ctx->state & CTX_MASK) == CTX_GRAPH)
516 {
517 /* ctx->cfg should now hold a complete graph */
518 assert (ctx->cfg != NULL);
519 assert (ctx->inst == NULL);
520 assert (ctx->ident == NULL);
522 if (ctx->dynamic_graph)
523 gl_add_graph_internal (ctx->cfg, &gl_dynamic, &gl_dynamic_num);
524 /* else: already contained in gl_active */
525 ctx->cfg = NULL;
527 /* Don't reset the state here, graphs are in an array. */
528 }
530 return (1);
531 } /* }}} int gl_json_end_map */
533 static int gl_json_end_array (void *user_data) /* {{{ */
534 {
535 gl_json_context_t *ctx = user_data;
537 if ((ctx->state & CTX_MASK) == CTX_INST_FILE)
538 set_state (ctx, CTX_INST, CTX_MASK);
539 else if ((ctx->state & CTX_MASK) == CTX_INST)
540 set_state (ctx, CTX_GRAPH, CTX_MASK);
541 else if ((ctx->state & CTX_MASK) == CTX_GRAPH)
542 {
543 /* We're done */
544 }
546 return (1);
547 } /* }}} int gl_json_end_array */
549 static int gl_json_key (void *user_data, /* {{{ */
550 const unsigned char *str,
551 unsigned int str_length)
552 {
553 gl_json_context_t *ctx = user_data;
554 char buffer[str_length + 1];
556 memcpy (buffer, str, str_length);
557 buffer[str_length] = 0;
559 if ((ctx->state & CTX_MASK) == CTX_GRAPH)
560 {
561 if (strcasecmp ("select", buffer) == 0)
562 set_state (ctx, CTX_GRAPH_SELECT, CTX_MASK);
563 else if (strcasecmp ("instances", buffer) == 0)
564 set_state (ctx, CTX_INST, CTX_MASK);
565 }
566 else if ((ctx->state & CTX_MASK) == CTX_INST)
567 {
568 if (strcasecmp ("select", buffer) == 0)
569 set_state (ctx, CTX_INST_SELECT, CTX_MASK);
570 else if (strcasecmp ("files", buffer) == 0)
571 set_state (ctx, CTX_INST_FILE, CTX_MASK);
572 }
573 else if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
574 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
575 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
576 {
577 assert (ctx->ident != NULL);
579 if (strcasecmp ("host", buffer) == 0)
580 set_state (ctx, CTX_IDENT_HOST, CTX_IDENT_MASK);
581 else if (strcasecmp ("plugin", buffer) == 0)
582 set_state (ctx, CTX_IDENT_PLUGIN, CTX_IDENT_MASK);
583 else if (strcasecmp ("plugin_instance", buffer) == 0)
584 set_state (ctx, CTX_IDENT_PLUGIN_INSTANCE, CTX_IDENT_MASK);
585 else if (strcasecmp ("type", buffer) == 0)
586 set_state (ctx, CTX_IDENT_TYPE, CTX_IDENT_MASK);
587 else if (strcasecmp ("type_instance", buffer) == 0)
588 set_state (ctx, CTX_IDENT_TYPE_INSTANCE, CTX_IDENT_MASK);
589 }
591 return (1);
592 } /* }}} int gl_json_key */
594 yajl_callbacks gl_json_callbacks =
595 {
596 /* null = */ NULL,
597 /* boolean = */ NULL,
598 /* integer = */ NULL,
599 /* double = */ NULL,
600 /* number = */ NULL,
601 /* string = */ gl_json_string,
602 /* start_map = */ gl_json_start_map,
603 /* map_key = */ gl_json_key,
604 /* end_map = */ gl_json_end_map,
605 /* start_array = */ NULL,
606 /* end_array = */ gl_json_end_array
607 };
609 static int gl_read_cache (_Bool block) /* {{{ */
610 {
611 yajl_handle handle;
612 gl_json_context_t context;
613 yajl_parser_config handle_config = { /* comments = */ 0, /* check UTF-8 */ 0 };
615 int fd;
616 int cmd;
617 struct stat statbuf;
618 struct flock lock;
619 int status;
620 time_t now;
622 fd = open (CACHE_FILE, O_RDONLY);
623 if (fd < 0)
624 {
625 fprintf (stderr, "gl_read_cache: open(2) failed with status %i\n", errno);
626 return (errno);
627 }
629 if (block)
630 cmd = F_SETLKW;
631 else
632 cmd = F_SETLK;
634 memset (&lock, 0, sizeof (lock));
635 lock.l_type = F_RDLCK;
636 lock.l_whence = SEEK_SET;
637 lock.l_start = 0;
638 lock.l_len = 0; /* lock everything */
640 while (42)
641 {
642 status = fcntl (fd, cmd, &lock);
643 if (status == 0)
644 break;
646 if (!block && ((errno == EACCES) || (errno == EAGAIN)))
647 {
648 close (fd);
649 return (0);
650 }
652 if (errno == EINTR)
653 continue;
655 status = errno;
656 fprintf (stderr, "gl_read_cache: fcntl(2) failed with status %i\n",
657 status);
658 close (fd);
659 return (status);
660 }
662 fprintf (stderr, "gl_read_cache: Opening and locking "
663 "cache file successful\n");
665 memset (&statbuf, 0, sizeof (statbuf));
666 status = fstat (fd, &statbuf);
667 if (status != 0)
668 {
669 status = errno;
670 fprintf (stderr, "gl_read_cache: fstat(2) failed with status %i\n",
671 status);
672 close (fd);
673 return (status);
674 }
676 now = time (NULL);
678 if (block)
679 {
680 /* Read the file. No excuses. */
681 }
682 else if (statbuf.st_mtime <= gl_last_update)
683 {
684 /* Our current data is at least as new as the cache. Return. */
685 fprintf (stderr, "gl_read_cache: Not using cache because "
686 "the internal data is newer\n");
687 fflush (stderr);
688 close (fd);
689 return (0);
690 }
691 else if ((statbuf.st_mtime + UPDATE_INTERVAL) < now)
692 {
693 /* We'll scan the directory anyway, so there is no need to parse the cache
694 * here. */
695 fprintf (stderr, "gl_read_cache: Not using cache because it's too old\n");
696 fflush (stderr);
697 close (fd);
698 return (0);
699 }
701 memset (&context, 0, sizeof (context));
702 context.state = CTX_GRAPH;
703 context.cfg = NULL;
704 context.inst = NULL;
705 context.ident = NULL;
707 handle = yajl_alloc (&gl_json_callbacks,
708 &handle_config,
709 /* alloc funcs = */ NULL,
710 &context);
712 fprintf (stderr, "gl_read_cache: Start parsing data\n");
713 fflush (stderr);
715 while (42)
716 {
717 ssize_t rd_status;
718 char buffer[1024*1024];
720 rd_status = read (fd, buffer, sizeof (buffer));
721 if (rd_status < 0)
722 {
723 if ((errno == EINTR) || (errno == EAGAIN))
724 continue;
726 status = errno;
727 fprintf (stderr, "gl_read_cache: read(2) failed with status %i\n",
728 status);
729 close (fd);
730 return (status);
731 }
732 else if (rd_status == 0)
733 {
734 yajl_parse_complete (handle);
735 break;
736 }
737 else
738 {
739 yajl_parse (handle,
740 (unsigned char *) &buffer[0],
741 (unsigned int) rd_status);
742 }
743 }
745 yajl_free (handle);
747 gl_last_update = statbuf.st_mtime;
748 close (fd);
750 fprintf (stderr, "gl_read_cache: Finished parsing data\n");
751 fflush (stderr);
753 return (0);
754 } /* }}} int gl_read_cache */
756 /*
757 * Global functions
758 */
759 int gl_add_graph (graph_config_t *cfg) /* {{{ */
760 {
761 return (gl_add_graph_internal (cfg, &gl_staging, &gl_staging_num));
762 } /* }}} int gl_add_graph */
764 int gl_config_submit (void) /* {{{ */
765 {
766 graph_config_t **old;
767 size_t old_num;
769 old = gl_active;
770 old_num = gl_active_num;
772 gl_active = gl_staging;
773 gl_active_num = gl_staging_num;
775 gl_staging = NULL;
776 gl_staging_num = 0;
778 gl_destroy (&old, &old_num);
780 return (0);
781 } /* }}} int graph_config_submit */
783 int gl_graph_get_all (_Bool include_dynamic, /* {{{ */
784 graph_callback_t callback, void *user_data)
785 {
786 size_t i;
788 if (callback == NULL)
789 return (EINVAL);
791 gl_update (/* request served = */ 0);
793 for (i = 0; i < gl_active_num; i++)
794 {
795 int status;
797 status = (*callback) (gl_active[i], user_data);
798 if (status != 0)
799 return (status);
800 }
802 if (!include_dynamic)
803 return (0);
805 for (i = 0; i < gl_dynamic_num; i++)
806 {
807 int status;
809 status = (*callback) (gl_dynamic[i], user_data);
810 if (status != 0)
811 return (status);
812 }
814 return (0);
815 } /* }}} int gl_graph_get_all */
817 graph_config_t *gl_graph_get_selected (void) /* {{{ */
818 {
819 const char *host = get_part_from_param ("graph_host", "host");
820 const char *plugin = get_part_from_param ("graph_plugin", "plugin");
821 const char *plugin_instance = get_part_from_param ("graph_plugin_instance", "plugin_instance");
822 const char *type = get_part_from_param ("graph_type", "type");
823 const char *type_instance = get_part_from_param ("graph_type_instance", "type_instance");
824 graph_ident_t *ident;
825 size_t i;
827 if ((host == NULL)
828 || (plugin == NULL) || (plugin_instance == NULL)
829 || (type == NULL) || (type_instance == NULL))
830 return (NULL);
832 ident = ident_create (host, plugin, plugin_instance, type, type_instance);
834 gl_update (/* request served = */ 0);
836 for (i = 0; i < gl_active_num; i++)
837 {
838 if (graph_compare (gl_active[i], ident) != 0)
839 continue;
841 ident_destroy (ident);
842 return (gl_active[i]);
843 }
845 for (i = 0; i < gl_dynamic_num; i++)
846 {
847 if (graph_compare (gl_dynamic[i], ident) != 0)
848 continue;
850 ident_destroy (ident);
851 return (gl_dynamic[i]);
852 }
854 ident_destroy (ident);
855 return (NULL);
856 } /* }}} graph_config_t *gl_graph_get_selected */
858 /* gl_instance_get_all, gl_graph_instance_get_all {{{ */
859 struct gl_inst_callback_data /* {{{ */
860 {
861 graph_config_t *cfg;
862 graph_inst_callback_t callback;
863 void *user_data;
864 }; /* }}} struct gl_inst_callback_data */
866 static int gl_inst_callback_handler (graph_instance_t *inst, /* {{{ */
867 void *user_data)
868 {
869 struct gl_inst_callback_data *data = user_data;
871 return ((*data->callback) (data->cfg, inst, data->user_data));
872 } /* }}} int gl_inst_callback_handler */
874 int gl_graph_instance_get_all (graph_config_t *cfg, /* {{{ */
875 graph_inst_callback_t callback, void *user_data)
876 {
877 struct gl_inst_callback_data data =
878 {
879 cfg,
880 callback,
881 user_data
882 };
884 if ((cfg == NULL) || (callback == NULL))
885 return (EINVAL);
887 return (graph_inst_foreach (cfg, gl_inst_callback_handler, &data));
888 } /* }}} int gl_graph_instance_get_all */
890 int gl_instance_get_all (graph_inst_callback_t callback, /* {{{ */
891 void *user_data)
892 {
893 size_t i;
895 gl_update (/* request served = */ 0);
897 for (i = 0; i < gl_active_num; i++)
898 {
899 int status;
901 status = gl_graph_instance_get_all (gl_active[i], callback, user_data);
902 if (status != 0)
903 return (status);
904 }
906 for (i = 0; i < gl_dynamic_num; i++)
907 {
908 int status;
910 status = gl_graph_instance_get_all (gl_dynamic[i], callback, user_data);
911 if (status != 0)
912 return (status);
913 }
915 return (0);
916 } /* }}} int gl_instance_get_all */
917 /* }}} gl_instance_get_all, gl_graph_instance_get_all */
919 int gl_search (search_info_t *si, /* {{{ */
920 graph_inst_callback_t callback, void *user_data)
921 {
922 size_t i;
923 graph_ident_t *ident;
925 if ((si == NULL) || (callback == NULL))
926 return (EINVAL);
928 if (search_has_selector (si))
929 {
930 ident = search_to_ident (si);
931 if (ident == NULL)
932 {
933 fprintf (stderr, "gl_search: search_to_ident failed\n");
934 return (-1);
935 }
936 }
937 else
938 {
939 ident = NULL;
940 }
942 for (i = 0; i < gl_active_num; i++)
943 {
944 int status;
946 if ((ident != NULL) && !graph_ident_intersect (gl_active[i], ident))
947 continue;
949 status = graph_search_inst (gl_active[i], si,
950 /* callback = */ callback,
951 /* user data = */ user_data);
952 if (status != 0)
953 return (status);
954 }
956 for (i = 0; i < gl_dynamic_num; i++)
957 {
958 int status;
960 if ((ident != NULL) && !graph_ident_intersect (gl_dynamic[i], ident))
961 continue;
963 status = graph_search_inst (gl_dynamic[i], si,
964 /* callback = */ callback,
965 /* user data = */ user_data);
966 if (status != 0)
967 return (status);
968 }
970 return (0);
971 } /* }}} int gl_search */
973 int gl_search_string (const char *term, graph_inst_callback_t callback, /* {{{ */
974 void *user_data)
975 {
976 size_t i;
978 for (i = 0; i < gl_active_num; i++)
979 {
980 int status;
982 status = graph_search_inst_string (gl_active[i], term,
983 /* callback = */ callback,
984 /* user data = */ user_data);
985 if (status != 0)
986 return (status);
987 }
989 for (i = 0; i < gl_dynamic_num; i++)
990 {
991 int status;
993 status = graph_search_inst_string (gl_dynamic[i], term,
994 /* callback = */ callback,
995 /* user data = */ user_data);
996 if (status != 0)
997 return (status);
998 }
1000 return (0);
1001 } /* }}} int gl_search_string */
1003 int gl_search_field (graph_ident_field_t field, /* {{{ */
1004 const char *field_value,
1005 graph_inst_callback_t callback, void *user_data)
1006 {
1007 size_t i;
1009 if ((field_value == NULL) || (callback == NULL))
1010 return (EINVAL);
1012 for (i = 0; i < gl_active_num; i++)
1013 {
1014 int status;
1016 status = graph_inst_search_field (gl_active[i],
1017 field, field_value,
1018 /* callback = */ callback,
1019 /* user data = */ user_data);
1020 if (status != 0)
1021 return (status);
1022 }
1024 for (i = 0; i < gl_dynamic_num; i++)
1025 {
1026 int status;
1028 status = graph_inst_search_field (gl_dynamic[i],
1029 field, field_value,
1030 /* callback = */ callback,
1031 /* user data = */ user_data);
1032 if (status != 0)
1033 return (status);
1034 }
1036 return (0);
1037 } /* }}} int gl_search_field */
1039 int gl_foreach_host (int (*callback) (const char *host, void *user_data), /* {{{ */
1040 void *user_data)
1041 {
1042 int status;
1043 size_t i;
1045 for (i = 0; i < host_list_len; i++)
1046 {
1047 status = (*callback) (host_list[i], user_data);
1048 if (status != 0)
1049 return (status);
1050 }
1052 return (0);
1053 } /* }}} int gl_foreach_host */
1055 int gl_update (_Bool request_served) /* {{{ */
1056 {
1057 time_t now;
1058 int status;
1059 size_t i;
1061 if (!request_served && (gl_last_update > 0))
1062 return (0);
1064 now = time (NULL);
1066 if ((gl_last_update + UPDATE_INTERVAL) >= now)
1067 {
1068 /* Write data to cache if appropriate */
1069 if (request_served)
1070 gl_update_cache ();
1071 return (0);
1072 }
1074 /* Clear state */
1075 gl_clear_instances ();
1076 gl_clear_hosts ();
1077 gl_destroy (&gl_dynamic, &gl_dynamic_num);
1079 graph_read_config ();
1081 status = gl_read_cache (/* block = */ 1);
1082 /* We have *something* to work with. Even if it's outdated, just get on with
1083 * handling the request and take care of re-reading data later on. */
1084 if ((status == 0) && !request_served)
1085 return (0);
1087 if ((status != 0)
1088 || ((gl_last_update + UPDATE_INTERVAL) < now))
1089 {
1090 status = fs_scan (/* callback = */ gl_register_file,
1091 /* user data = */ NULL);
1092 gl_last_update = now;
1093 }
1095 if (host_list_len > 0)
1096 qsort (host_list, host_list_len, sizeof (*host_list),
1097 gl_compare_hosts);
1099 for (i = 0; i < gl_active_num; i++)
1100 graph_sort_instances (gl_active[i]);
1102 if (request_served)
1103 gl_update_cache ();
1105 return (status);
1106 } /* }}} int gl_update */
1108 /* vim: set sw=2 sts=2 et fdm=marker : */