2 * collection4 - graph_list.c
3 * Copyright (C) 2010 Florian octo Forster
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.
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.
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
21 * Florian octo Forster <ff at octo.it>
34 #include <sys/types.h>
37 #include <yajl/yajl_parse.h>
39 #include "graph_list.h"
41 #include "filesystem.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"
51 #include <fcgi_stdio.h>
56 #define UPDATE_INTERVAL 900
57 #define CACHE_FILE "/tmp/collection4.json"
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
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;
81 static int gl_add_graph_internal (graph_config_t *cfg, /* {{{ */
82 graph_config_t ***gl_array, size_t *gl_array_num)
86 #define ARRAY_PTR (*gl_array)
87 #define ARRAY_SIZE (*gl_array_num)
92 tmp = realloc (ARRAY_PTR, sizeof (*ARRAY_PTR) * (ARRAY_SIZE + 1));
97 ARRAY_PTR[ARRAY_SIZE] = cfg;
104 } /* }}} int gl_add_graph_internal */
106 static void gl_destroy (graph_config_t ***gl_array, /* {{{ */
107 size_t *gl_array_num)
111 if ((gl_array == NULL) || (gl_array_num == NULL))
114 #define ARRAY_PTR (*gl_array)
115 #define ARRAY_SIZE (*gl_array_num)
117 for (i = 0; i < ARRAY_SIZE; i++)
119 graph_destroy (ARRAY_PTR[i]);
128 } /* }}} void gl_destroy */
130 static int gl_register_host (const char *host) /* {{{ */
138 for (i = 0; i < host_list_len; i++)
139 if (strcmp (host_list[i], host) == 0)
142 tmp = realloc (host_list, sizeof (*host_list) * (host_list_len + 1));
147 host_list[host_list_len] = strdup (host);
148 if (host_list[host_list_len] == NULL)
153 } /* }}} int gl_register_host */
155 static int gl_clear_hosts (void) /* {{{ */
159 for (i = 0; i < host_list_len; i++)
167 } /* }}} int gl_clear_hosts */
169 static int gl_compare_hosts (const void *v0, const void *v1) /* {{{ */
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)
181 for (i = 0; i < gl_active_num; i++)
183 graph_config_t *cfg = gl_active[i];
186 if (!graph_ident_matches (cfg, file))
189 status = graph_add_file (cfg, file);
202 cfg = graph_create (file);
203 gl_add_graph_internal (cfg, &gl_dynamic, &gl_dynamic_num);
204 graph_add_file (cfg, file);
207 gl_register_host (ident_get_host (file));
210 } /* }}} int gl_register_file */
212 static const char *get_part_from_param (const char *prim_key, /* {{{ */
217 val = param (prim_key);
221 return (param (sec_key));
222 } /* }}} const char *get_part_from_param */
224 static int gl_clear_instances (void) /* {{{ */
228 for (i = 0; i < gl_active_num; i++)
229 graph_clear_instances (gl_active[i]);
232 } /* }}} int gl_clear_instances */
234 static void gl_dump_cb (void *ctx, /* {{{ */
235 const char *str, unsigned int len)
237 int fd = *((int *) ctx);
243 buffer_size = (size_t) len;
244 while (buffer_size > 0)
246 status = write (fd, buffer, buffer_size);
249 fprintf (stderr, "write(2) failed with status %i\n", errno);
254 buffer_size -= status;
256 } /* }}} void gl_dump_cb */
258 static int gl_update_cache (void) /* {{{ */
262 yajl_gen_config handler_config = { /* pretty = */ 1, /* indent = */ " " };
268 memset (&statbuf, 0, sizeof (statbuf));
269 status = stat (CACHE_FILE, &statbuf);
272 if (statbuf.st_mtime >= gl_last_update)
276 fd = open (CACHE_FILE, O_WRONLY | O_TRUNC | O_CREAT,
277 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
280 fprintf (stderr, "gl_update_cache: open(2) failed with status %i\n", errno);
284 memset (&lock, 0, sizeof (lock));
285 lock.l_type = F_WRLCK;
286 lock.l_whence = SEEK_SET;
288 lock.l_len = 0; /* lock everything */
292 status = fcntl (fd, F_SETLKW, &lock);
299 fprintf (stderr, "gl_update_cache: fcntl(2) failed with status %i\n", errno);
304 handler = yajl_gen_alloc2 (gl_dump_cb, &handler_config,
305 /* alloc funcs = */ NULL, /* ctx = */ &fd);
312 yajl_gen_array_open (handler);
314 for (i = 0; i < gl_active_num; i++)
315 graph_to_json (gl_active[i], handler);
317 for (i = 0; i < gl_dynamic_num; i++)
318 graph_to_json (gl_dynamic[i], handler);
320 yajl_gen_array_close (handler);
322 yajl_gen_free (handler);
326 } /* }}} int gl_update_cache */
328 static int gl_scan_directory (void)
331 } /* }}} int gl_scan_directory */
334 * JSON parsing functions
336 #define CTX_MASK 0xff000000
337 #define CTX_GRAPH 0x01000000
338 #define CTX_GRAPH_SELECT 0x02000000
339 #define CTX_INST 0x03000000
340 #define CTX_INST_SELECT 0x04000000
341 #define CTX_INST_FILE 0x05000000
343 #define CTX_IDENT_MASK 0x00ff0000
344 #define CTX_IDENT_HOST 0x00010000
345 #define CTX_IDENT_PLUGIN 0x00020000
346 #define CTX_IDENT_PLUGIN_INSTANCE 0x00030000
347 #define CTX_IDENT_TYPE 0x00040000
348 #define CTX_IDENT_TYPE_INSTANCE 0x00050000
350 struct gl_json_context_s
355 graph_instance_t *inst;
356 graph_ident_t *ident;
360 typedef struct gl_json_context_s gl_json_context_t;
362 static void set_state (gl_json_context_t *ctx, /* {{{ */
363 uint32_t new_state, uint32_t mask)
365 uint32_t old_state = ctx->state;
366 ctx->state = (old_state & ~mask) | (new_state & mask);
367 } /* }}} void set_state */
369 static int gl_json_string (void *user_data, /* {{{ */
370 const unsigned char *str,
371 unsigned int str_length)
373 gl_json_context_t *ctx = user_data;
374 char buffer[str_length + 1];
376 memcpy (buffer, str, str_length);
377 buffer[str_length] = 0;
379 if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
380 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
381 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
383 switch (ctx->state & CTX_IDENT_MASK)
386 ident_set_host (ctx->ident, buffer);
388 case CTX_IDENT_PLUGIN:
389 ident_set_plugin (ctx->ident, buffer);
391 case CTX_IDENT_PLUGIN_INSTANCE:
392 ident_set_plugin_instance (ctx->ident, buffer);
395 ident_set_type (ctx->ident, buffer);
397 case CTX_IDENT_TYPE_INSTANCE:
398 ident_set_type_instance (ctx->ident, buffer);
404 } /* }}} int gl_json_string */
406 static int gl_json_start_map (void *user_data) /* {{{ */
408 gl_json_context_t *ctx = user_data;
410 if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
411 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
412 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
414 assert (ctx->ident == NULL);
415 ctx->ident = ident_create (ANY_TOKEN,
416 ANY_TOKEN, ANY_TOKEN,
417 ANY_TOKEN, ANY_TOKEN);
421 } /* }}} int gl_json_start_map */
423 static int gl_json_end_map (void *user_data) /* {{{ */
425 gl_json_context_t *ctx = user_data;
427 if ((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
431 /* ctx->ident should now hold the valid selector */
432 assert (ctx->cfg == NULL);
433 assert (ctx->inst == NULL);
434 assert (ctx->ident != NULL);
436 for (i = 0; i < gl_active_num; i++)
438 if (graph_compare (gl_active[i], ctx->ident) != 0)
441 ctx->cfg = gl_active[i];
442 ctx->dynamic_graph = 0;
446 if (ctx->cfg == NULL)
448 ctx->cfg = graph_create (ctx->ident);
449 ctx->dynamic_graph = 1;
452 ident_destroy (ctx->ident);
455 set_state (ctx, CTX_GRAPH, CTX_MASK);
457 else if ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
459 /* ctx->ident should now hold the valid selector */
460 assert (ctx->cfg != NULL);
461 assert (ctx->inst == NULL);
462 assert (ctx->ident != NULL);
464 ctx->inst = inst_create (ctx->cfg, ctx->ident);
465 ident_destroy (ctx->ident);
468 set_state (ctx, CTX_INST, CTX_MASK);
470 else if ((ctx->state & CTX_MASK) == CTX_INST_FILE)
472 /* ctx->ident should now hold the valid file */
473 assert (ctx->cfg != NULL);
474 assert (ctx->inst != NULL);
475 assert (ctx->ident != NULL);
477 inst_add_file (ctx->inst, ctx->ident);
478 ident_destroy (ctx->ident);
481 /* Don't reset the state here, files are in an array. */
483 else if ((ctx->state & CTX_MASK) == CTX_INST)
485 /* ctx->inst should now hold a complete instance */
486 assert (ctx->cfg != NULL);
487 assert (ctx->inst != NULL);
488 assert (ctx->ident == NULL);
490 graph_add_inst (ctx->cfg, ctx->inst);
491 /* don't destroy / free ctx->inst */
494 /* Don't reset the state here, instances are in an array. */
496 else if ((ctx->state & CTX_MASK) == CTX_GRAPH)
498 /* ctx->cfg should now hold a complete graph */
499 assert (ctx->cfg != NULL);
500 assert (ctx->inst == NULL);
501 assert (ctx->ident == NULL);
503 if (ctx->dynamic_graph)
504 gl_add_graph_internal (ctx->cfg, &gl_dynamic, &gl_dynamic_num);
505 /* else: already contained in gl_active */
508 /* Don't reset the state here, graphs are in an array. */
512 } /* }}} int gl_json_end_map */
514 static int gl_json_end_array (void *user_data) /* {{{ */
516 gl_json_context_t *ctx = user_data;
518 if ((ctx->state & CTX_MASK) == CTX_INST_FILE)
519 set_state (ctx, CTX_INST, CTX_MASK);
520 else if ((ctx->state & CTX_MASK) == CTX_INST)
521 set_state (ctx, CTX_GRAPH, CTX_MASK);
522 else if ((ctx->state & CTX_MASK) == CTX_GRAPH)
528 } /* }}} int gl_json_end_array */
530 static int gl_json_key (void *user_data, /* {{{ */
531 const unsigned char *str,
532 unsigned int str_length)
534 gl_json_context_t *ctx = user_data;
535 char buffer[str_length + 1];
537 memcpy (buffer, str, str_length);
538 buffer[str_length] = 0;
540 if ((ctx->state & CTX_MASK) == CTX_GRAPH)
542 if (strcasecmp ("select", buffer) == 0)
543 set_state (ctx, CTX_GRAPH_SELECT, CTX_MASK);
544 else if (strcasecmp ("instances", buffer) == 0)
545 set_state (ctx, CTX_INST, CTX_MASK);
547 else if ((ctx->state & CTX_MASK) == CTX_INST)
549 if (strcasecmp ("select", buffer) == 0)
550 set_state (ctx, CTX_INST_SELECT, CTX_MASK);
551 else if (strcasecmp ("files", buffer) == 0)
552 set_state (ctx, CTX_INST_FILE, CTX_MASK);
554 else if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT)
555 || ((ctx->state & CTX_MASK) == CTX_INST_SELECT)
556 || ((ctx->state & CTX_MASK) == CTX_INST_FILE))
558 assert (ctx->ident != NULL);
560 if (strcasecmp ("host", buffer) == 0)
561 set_state (ctx, CTX_IDENT_HOST, CTX_IDENT_MASK);
562 else if (strcasecmp ("plugin", buffer) == 0)
563 set_state (ctx, CTX_IDENT_PLUGIN, CTX_IDENT_MASK);
564 else if (strcasecmp ("plugin_instance", buffer) == 0)
565 set_state (ctx, CTX_IDENT_PLUGIN_INSTANCE, CTX_IDENT_MASK);
566 else if (strcasecmp ("type", buffer) == 0)
567 set_state (ctx, CTX_IDENT_TYPE, CTX_IDENT_MASK);
568 else if (strcasecmp ("type_instance", buffer) == 0)
569 set_state (ctx, CTX_IDENT_TYPE_INSTANCE, CTX_IDENT_MASK);
573 } /* }}} int gl_json_key */
575 yajl_callbacks gl_json_callbacks =
578 /* boolean = */ NULL,
579 /* integer = */ NULL,
582 /* string = */ gl_json_string,
583 /* start_map = */ gl_json_start_map,
584 /* map_key = */ gl_json_key,
585 /* end_map = */ gl_json_end_map,
586 /* start_array = */ NULL,
587 /* end_array = */ gl_json_end_array
590 static int gl_read_cache (_Bool block) /* {{{ */
593 gl_json_context_t context;
594 yajl_parser_config handle_config = { /* comments = */ 0, /* check UTF-8 */ 0 };
603 fd = open (CACHE_FILE, O_RDONLY);
606 fprintf (stderr, "gl_read_cache: open(2) failed with status %i\n", errno);
615 memset (&lock, 0, sizeof (lock));
616 lock.l_type = F_RDLCK;
617 lock.l_whence = SEEK_SET;
619 lock.l_len = 0; /* lock everything */
623 status = fcntl (fd, cmd, &lock);
627 if (!block && ((errno == EACCES) || (errno == EAGAIN)))
637 fprintf (stderr, "gl_read_cache: fcntl(2) failed with status %i\n",
643 fprintf (stderr, "gl_read_cache: Opening and locking "
644 "cache file successful\n");
646 memset (&statbuf, 0, sizeof (statbuf));
647 status = fstat (fd, &statbuf);
651 fprintf (stderr, "gl_read_cache: fstat(2) failed with status %i\n",
659 if (statbuf.st_mtime <= gl_last_update)
661 /* Our current data is at least as new as the cache. Return. */
665 else if ((statbuf.st_mtime + UPDATE_INTERVAL) < now)
667 /* We'll scan the directory anyway, so there is no need to parse the cache here. */
672 memset (&context, 0, sizeof (context));
673 context.state = CTX_GRAPH;
676 context.ident = NULL;
678 handle = yajl_alloc (&gl_json_callbacks,
680 /* alloc funcs = */ NULL,
686 char buffer[1024*1024];
688 rd_status = read (fd, buffer, sizeof (buffer));
691 if ((errno == EINTR) || (errno == EAGAIN))
694 fprintf (stderr, "gl_read_cache: read(2) failed with status %i\n",
699 else if (rd_status == 0)
701 yajl_parse_complete (handle);
707 (unsigned char *) &buffer[0],
708 (unsigned int) rd_status);
712 fprintf (stderr, "gl_read_cache: Closing cache file and returning\n");
713 gl_last_update = statbuf.st_mtime;
717 } /* }}} int gl_read_cache */
722 int gl_add_graph (graph_config_t *cfg) /* {{{ */
724 return (gl_add_graph_internal (cfg, &gl_staging, &gl_staging_num));
725 } /* }}} int gl_add_graph */
727 int gl_config_submit (void) /* {{{ */
729 graph_config_t **old;
733 old_num = gl_active_num;
735 gl_active = gl_staging;
736 gl_active_num = gl_staging_num;
741 gl_destroy (&old, &old_num);
744 } /* }}} int graph_config_submit */
746 int gl_graph_get_all (graph_callback_t callback, /* {{{ */
751 if (callback == NULL)
754 gl_update (/* request served = */ 0);
756 for (i = 0; i < gl_active_num; i++)
760 status = (*callback) (gl_active[i], user_data);
765 for (i = 0; i < gl_dynamic_num; i++)
769 status = (*callback) (gl_dynamic[i], user_data);
775 } /* }}} int gl_graph_get_all */
777 graph_config_t *gl_graph_get_selected (void) /* {{{ */
779 const char *host = get_part_from_param ("graph_host", "host");
780 const char *plugin = get_part_from_param ("graph_plugin", "plugin");
781 const char *plugin_instance = get_part_from_param ("graph_plugin_instance", "plugin_instance");
782 const char *type = get_part_from_param ("graph_type", "type");
783 const char *type_instance = get_part_from_param ("graph_type_instance", "type_instance");
784 graph_ident_t *ident;
788 || (plugin == NULL) || (plugin_instance == NULL)
789 || (type == NULL) || (type_instance == NULL))
792 ident = ident_create (host, plugin, plugin_instance, type, type_instance);
794 gl_update (/* request served = */ 0);
796 for (i = 0; i < gl_active_num; i++)
798 if (graph_compare (gl_active[i], ident) != 0)
801 ident_destroy (ident);
802 return (gl_active[i]);
805 for (i = 0; i < gl_dynamic_num; i++)
807 if (graph_compare (gl_dynamic[i], ident) != 0)
810 ident_destroy (ident);
811 return (gl_dynamic[i]);
814 ident_destroy (ident);
816 } /* }}} graph_config_t *gl_graph_get_selected */
818 /* gl_instance_get_all, gl_graph_instance_get_all {{{ */
819 struct gl_inst_callback_data /* {{{ */
822 graph_inst_callback_t callback;
824 }; /* }}} struct gl_inst_callback_data */
826 static int gl_inst_callback_handler (graph_instance_t *inst, /* {{{ */
829 struct gl_inst_callback_data *data = user_data;
831 return ((*data->callback) (data->cfg, inst, data->user_data));
832 } /* }}} int gl_inst_callback_handler */
834 int gl_graph_instance_get_all (graph_config_t *cfg, /* {{{ */
835 graph_inst_callback_t callback, void *user_data)
837 struct gl_inst_callback_data data =
844 if ((cfg == NULL) || (callback == NULL))
847 return (graph_inst_foreach (cfg, gl_inst_callback_handler, &data));
848 } /* }}} int gl_graph_instance_get_all */
850 int gl_instance_get_all (graph_inst_callback_t callback, /* {{{ */
855 gl_update (/* request served = */ 0);
857 for (i = 0; i < gl_active_num; i++)
861 status = gl_graph_instance_get_all (gl_active[i], callback, user_data);
866 for (i = 0; i < gl_dynamic_num; i++)
870 status = gl_graph_instance_get_all (gl_dynamic[i], callback, user_data);
876 } /* }}} int gl_instance_get_all */
877 /* }}} gl_instance_get_all, gl_graph_instance_get_all */
879 int gl_search (search_info_t *si, /* {{{ */
880 graph_inst_callback_t callback, void *user_data)
883 graph_ident_t *ident;
885 if ((si == NULL) || (callback == NULL))
888 if (search_has_selector (si))
890 ident = search_to_ident (si);
893 fprintf (stderr, "gl_search: search_to_ident failed\n");
902 for (i = 0; i < gl_active_num; i++)
906 if ((ident != NULL) && !graph_ident_intersect (gl_active[i], ident))
909 status = graph_search_inst (gl_active[i], si,
910 /* callback = */ callback,
911 /* user data = */ user_data);
916 for (i = 0; i < gl_dynamic_num; i++)
920 if ((ident != NULL) && !graph_ident_intersect (gl_dynamic[i], ident))
923 status = graph_search_inst (gl_dynamic[i], si,
924 /* callback = */ callback,
925 /* user data = */ user_data);
931 } /* }}} int gl_search */
933 int gl_search_string (const char *term, graph_inst_callback_t callback, /* {{{ */
938 for (i = 0; i < gl_active_num; i++)
942 status = graph_search_inst_string (gl_active[i], term,
943 /* callback = */ callback,
944 /* user data = */ user_data);
949 for (i = 0; i < gl_dynamic_num; i++)
953 status = graph_search_inst_string (gl_dynamic[i], term,
954 /* callback = */ callback,
955 /* user data = */ user_data);
961 } /* }}} int gl_search_string */
963 int gl_search_field (graph_ident_field_t field, /* {{{ */
964 const char *field_value,
965 graph_inst_callback_t callback, void *user_data)
969 if ((field_value == NULL) || (callback == NULL))
972 for (i = 0; i < gl_active_num; i++)
976 status = graph_inst_search_field (gl_active[i],
978 /* callback = */ callback,
979 /* user data = */ user_data);
984 for (i = 0; i < gl_dynamic_num; i++)
988 status = graph_inst_search_field (gl_dynamic[i],
990 /* callback = */ callback,
991 /* user data = */ user_data);
997 } /* }}} int gl_search_field */
999 int gl_foreach_host (int (*callback) (const char *host, void *user_data), /* {{{ */
1005 for (i = 0; i < host_list_len; i++)
1007 status = (*callback) (host_list[i], user_data);
1013 } /* }}} int gl_foreach_host */
1015 int gl_update (_Bool request_served) /* {{{ */
1021 if (!request_served && (gl_last_update > 0))
1026 if ((gl_last_update + UPDATE_INTERVAL) >= now)
1028 /* Write data to cache if appropriate */
1035 gl_clear_instances ();
1037 gl_destroy (&gl_dynamic, &gl_dynamic_num);
1039 graph_read_config ();
1041 status = gl_read_cache (/* block = */ 1);
1044 || ((gl_last_update + UPDATE_INTERVAL) < now))
1046 status = fs_scan (/* callback = */ gl_register_file,
1047 /* user data = */ NULL);
1048 gl_last_update = now;
1051 if (host_list_len > 0)
1052 qsort (host_list, host_list_len, sizeof (*host_list),
1055 for (i = 0; i < gl_active_num; i++)
1056 graph_sort_instances (gl_active[i]);
1062 } /* }}} int gl_update */
1064 /* vim: set sw=2 sts=2 et fdm=marker : */