X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fgraph_list.c;h=2112c76faa88dc7b84623df2ee975ee93aaa6259;hb=99f31aafefdd00b788d9ab2ba74b1cfb70c679e3;hp=de80b3b63c2647c534b2ffe92dd0824fc7776ae7;hpb=c048f2d5c5dab7e4944ca9a50463fdf4d2748aff;p=collection4.git diff --git a/src/graph_list.c b/src/graph_list.c index de80b3b..2112c76 100644 --- a/src/graph_list.c +++ b/src/graph_list.c @@ -1,3 +1,26 @@ +/** + * collection4 - graph_list.c + * Copyright (C) 2010 Florian octo Forster + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA + * + * Authors: + * Florian octo Forster + **/ + #include #include #include @@ -5,14 +28,22 @@ #include #include #include +#include +#include +#include + +#include #include "graph_list.h" -#include "graph_ident.h" -#include "graph_def.h" -#include "graph_config.h" #include "common.h" #include "filesystem.h" +#include "graph.h" +#include "graph_config.h" +#include "graph_def.h" +#include "graph_ident.h" +#include "graph_instance.h" #include "utils_cgi.h" +#include "utils_search.h" #include #include @@ -20,7 +51,8 @@ /* * Defines */ -#define UPDATE_INTERVAL 10 +#define UPDATE_INTERVAL 900 +#define CACHE_FILE "/tmp/collection4.json" /* * Global variables @@ -31,12 +63,20 @@ static size_t gl_active_num = 0; static graph_config_t **gl_staging = NULL; static size_t gl_staging_num = 0; +/* Graphs created on-the-fly for files which don't match any existing graph + * definition. */ +static graph_config_t **gl_dynamic = NULL; +static size_t gl_dynamic_num = 0; + +static char **host_list = NULL; +static size_t host_list_len = 0; + static time_t gl_last_update = 0; /* * Private functions */ -int gl_add_graph_internal (graph_config_t *cfg, /* {{{ */ +static int gl_add_graph_internal (graph_config_t *cfg, /* {{{ */ graph_config_t ***gl_array, size_t *gl_array_num) { graph_config_t **tmp; @@ -61,6 +101,74 @@ int gl_add_graph_internal (graph_config_t *cfg, /* {{{ */ return (0); } /* }}} int gl_add_graph_internal */ +static void gl_destroy (graph_config_t ***gl_array, /* {{{ */ + size_t *gl_array_num) +{ + size_t i; + + if ((gl_array == NULL) || (gl_array_num == NULL)) + return; + +#define ARRAY_PTR (*gl_array) +#define ARRAY_SIZE (*gl_array_num) + + for (i = 0; i < ARRAY_SIZE; i++) + { + graph_destroy (ARRAY_PTR[i]); + ARRAY_PTR[i] = NULL; + } + free (ARRAY_PTR); + ARRAY_PTR = NULL; + ARRAY_SIZE = 0; + +#undef ARRAY_SIZE +#undef ARRAY_PTR +} /* }}} void gl_destroy */ + +static int gl_register_host (const char *host) /* {{{ */ +{ + char **tmp; + size_t i; + + if (host == NULL) + return (EINVAL); + + for (i = 0; i < host_list_len; i++) + if (strcmp (host_list[i], host) == 0) + return (0); + + tmp = realloc (host_list, sizeof (*host_list) * (host_list_len + 1)); + if (tmp == NULL) + return (ENOMEM); + host_list = tmp; + + host_list[host_list_len] = strdup (host); + if (host_list[host_list_len] == NULL) + return (ENOMEM); + + host_list_len++; + return (0); +} /* }}} int gl_register_host */ + +static int gl_clear_hosts (void) /* {{{ */ +{ + size_t i; + + for (i = 0; i < host_list_len; i++) + free (host_list[i]); + free (host_list); + + host_list = NULL; + host_list_len = 0; + + return (0); +} /* }}} int gl_clear_hosts */ + +static int gl_compare_hosts (const void *v0, const void *v1) /* {{{ */ +{ + return (strcmp (*(char * const *) v0, *(char * const *) v1)); +} /* }}} int gl_compare_hosts */ + static int gl_register_file (const graph_ident_t *file, /* {{{ */ __attribute__((unused)) void *user_data) { @@ -73,7 +181,7 @@ static int gl_register_file (const graph_ident_t *file, /* {{{ */ graph_config_t *cfg = gl_active[i]; int status; - if (!graph_matches_ident (cfg, file)) + if (!graph_ident_matches (cfg, file)) continue; status = graph_add_file (cfg, file); @@ -90,10 +198,12 @@ static int gl_register_file (const graph_ident_t *file, /* {{{ */ if (num_graphs == 0) { cfg = graph_create (file); - gl_add_graph_internal (cfg, &gl_active, &gl_active_num); + gl_add_graph_internal (cfg, &gl_dynamic, &gl_dynamic_num); graph_add_file (cfg, file); } + gl_register_host (ident_get_host (file)); + return (0); } /* }}} int gl_register_file */ @@ -119,6 +229,351 @@ static int gl_clear_instances (void) /* {{{ */ return (0); } /* }}} int gl_clear_instances */ +static void gl_dump_cb (void *ctx, /* {{{ */ + const char *str, unsigned int len) +{ + FILE *fh = ctx; + + /* FIXME: Has everything been written? */ + fwrite ((void *) str, /* size = */ 1, /* nmemb = */ len, fh); +} /* }}} void gl_dump_cb */ + +static int gl_dump (void) /* {{{ */ +{ + FILE *fh; + yajl_gen handler; + yajl_gen_config handler_config = { /* pretty = */ 1, /* indent = */ " " }; + size_t i; + + /* FIXME: Lock the file */ + fh = fopen (CACHE_FILE, "w"); + if (fh == NULL) + return (errno); + + handler = yajl_gen_alloc2 (gl_dump_cb, &handler_config, + /* alloc funcs = */ NULL, /* ctx = */ fh); + if (handler == NULL) + { + fclose (fh); + return (-1); + } + + yajl_gen_array_open (handler); + + for (i = 0; i < gl_active_num; i++) + graph_to_json (gl_active[i], handler); + + for (i = 0; i < gl_dynamic_num; i++) + graph_to_json (gl_dynamic[i], handler); + + yajl_gen_array_close (handler); + + yajl_gen_free (handler); + fclose (fh); + + return (0); +} /* }}} int gl_dump */ + +/* + * JSON parsing functions + */ +#define CTX_MASK 0xff000000 +#define CTX_GRAPH 0x01000000 +#define CTX_GRAPH_SELECT 0x02000000 +#define CTX_INST 0x03000000 +#define CTX_INST_SELECT 0x04000000 +#define CTX_INST_FILE 0x05000000 + +#define CTX_IDENT_MASK 0x00ff0000 +#define CTX_IDENT_HOST 0x00010000 +#define CTX_IDENT_PLUGIN 0x00020000 +#define CTX_IDENT_PLUGIN_INSTANCE 0x00030000 +#define CTX_IDENT_TYPE 0x00040000 +#define CTX_IDENT_TYPE_INSTANCE 0x00050000 + +struct gl_json_context_s +{ + uint32_t state; + + graph_config_t *cfg; + graph_instance_t *inst; + graph_ident_t *ident; + + _Bool dynamic_graph; +}; +typedef struct gl_json_context_s gl_json_context_t; + +static void set_state (gl_json_context_t *ctx, /* {{{ */ + uint32_t new_state, uint32_t mask) +{ + uint32_t old_state = ctx->state; + ctx->state = (old_state & ~mask) | (new_state & mask); +} /* }}} void set_state */ + +static int gl_json_string (void *user_data, /* {{{ */ + const unsigned char *str, + unsigned int str_length) +{ + gl_json_context_t *ctx = user_data; + char buffer[str_length + 1]; + + memcpy (buffer, str, str_length); + buffer[str_length] = 0; + + if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT) + || ((ctx->state & CTX_MASK) == CTX_INST_SELECT) + || ((ctx->state & CTX_MASK) == CTX_INST_FILE)) + { + switch (ctx->state & CTX_IDENT_MASK) + { + case CTX_IDENT_HOST: + ident_set_host (ctx->ident, buffer); + break; + case CTX_IDENT_PLUGIN: + ident_set_plugin (ctx->ident, buffer); + break; + case CTX_IDENT_PLUGIN_INSTANCE: + ident_set_plugin_instance (ctx->ident, buffer); + break; + case CTX_IDENT_TYPE: + ident_set_type (ctx->ident, buffer); + break; + case CTX_IDENT_TYPE_INSTANCE: + ident_set_type_instance (ctx->ident, buffer); + break; + } + } + + return (1); +} /* }}} int gl_json_string */ + +static int gl_json_end_map (void *user_data) /* {{{ */ +{ + gl_json_context_t *ctx = user_data; + + if ((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT) + { + size_t i; + + /* ctx->ident should now hold the valid selector */ + assert (ctx->cfg == NULL); + assert (ctx->inst == NULL); + assert (ctx->ident != NULL); + + for (i = 0; i < gl_active_num; i++) + { + if (graph_compare (gl_active[i], ctx->ident) != 0) + continue; + + ctx->cfg = gl_active[i]; + ctx->dynamic_graph = 0; + break; + } + + if (ctx->cfg == NULL) + { + ctx->cfg = graph_create (ctx->ident); + ctx->dynamic_graph = 1; + } + + ident_destroy (ctx->ident); + ctx->ident = NULL; + + set_state (ctx, CTX_GRAPH, CTX_MASK); + } + else if ((ctx->state & CTX_MASK) == CTX_INST_SELECT) + { + /* ctx->ident should now hold the valid selector */ + assert (ctx->cfg != NULL); + assert (ctx->inst == NULL); + assert (ctx->ident != NULL); + + ctx->inst = inst_create (ctx->cfg, ctx->ident); + ident_destroy (ctx->ident); + ctx->ident = NULL; + + set_state (ctx, CTX_INST, CTX_MASK); + } + else if ((ctx->state & CTX_MASK) == CTX_INST_FILE) + { + /* ctx->ident should now hold the valid file */ + assert (ctx->cfg != NULL); + assert (ctx->inst != NULL); + assert (ctx->ident != NULL); + + inst_add_file (ctx->inst, ctx->ident); + ident_destroy (ctx->ident); + ctx->ident = NULL; + + /* Don't reset the state here, files are in an array. */ + } + else if ((ctx->state & CTX_MASK) == CTX_INST) + { + /* ctx->inst should now hold a complete instance */ + assert (ctx->cfg != NULL); + assert (ctx->inst != NULL); + assert (ctx->ident == NULL); + + graph_add_inst (ctx->cfg, ctx->inst); + /* don't destroy / free ctx->inst */ + ctx->inst = NULL; + + /* Don't reset the state here, instances are in an array. */ + } + else if ((ctx->state & CTX_MASK) == CTX_GRAPH) + { + /* ctx->cfg should now hold a complete graph */ + assert (ctx->cfg != NULL); + assert (ctx->inst == NULL); + assert (ctx->ident == NULL); + + if (ctx->dynamic_graph) + gl_add_graph_internal (ctx->cfg, &gl_dynamic, &gl_dynamic_num); + /* else: already contained in gl_active */ + ctx->cfg = NULL; + + /* Don't reset the state here, graphs are in an array. */ + } + + return (1); +} /* }}} int gl_json_end_map */ + +static int gl_json_end_array (void *user_data) /* {{{ */ +{ + gl_json_context_t *ctx = user_data; + + if ((ctx->state & CTX_MASK) == CTX_INST_FILE) + set_state (ctx, CTX_INST, CTX_MASK); + else if ((ctx->state & CTX_MASK) == CTX_INST) + set_state (ctx, CTX_GRAPH, CTX_MASK); + else if ((ctx->state & CTX_MASK) == CTX_GRAPH) + { + /* We're done */ + } + + return (1); +} /* }}} int gl_json_end_array */ + +static int gl_json_key (void *user_data, /* {{{ */ + const unsigned char *str, + unsigned int str_length) +{ + gl_json_context_t *ctx = user_data; + char buffer[str_length + 1]; + + memcpy (buffer, str, str_length); + buffer[str_length] = 0; + + if ((ctx->state & CTX_MASK) == CTX_GRAPH) + { + if (strcasecmp ("select", buffer) == 0) + set_state (ctx, CTX_GRAPH_SELECT, CTX_MASK); + else if (strcasecmp ("instances", buffer) == 0) + set_state (ctx, CTX_INST, CTX_MASK); + } + else if ((ctx->state & CTX_MASK) == CTX_INST) + { + if (strcasecmp ("select", buffer) == 0) + set_state (ctx, CTX_INST_SELECT, CTX_MASK); + else if (strcasecmp ("files", buffer) == 0) + set_state (ctx, CTX_INST_FILE, CTX_MASK); + } + else if (((ctx->state & CTX_MASK) == CTX_GRAPH_SELECT) + || ((ctx->state & CTX_MASK) == CTX_INST_SELECT) + || ((ctx->state & CTX_MASK) == CTX_INST_FILE)) + { + if (strcasecmp ("host", buffer) == 0) + set_state (ctx, CTX_IDENT_HOST, CTX_IDENT_MASK); + else if (strcasecmp ("plugin", buffer) == 0) + set_state (ctx, CTX_IDENT_PLUGIN, CTX_IDENT_MASK); + else if (strcasecmp ("plugin_instance", buffer) == 0) + set_state (ctx, CTX_IDENT_PLUGIN_INSTANCE, CTX_IDENT_MASK); + else if (strcasecmp ("type", buffer) == 0) + set_state (ctx, CTX_IDENT_TYPE, CTX_IDENT_MASK); + else if (strcasecmp ("type_instance", buffer) == 0) + set_state (ctx, CTX_IDENT_TYPE_INSTANCE, CTX_IDENT_MASK); + } + + return (0); +} /* }}} int gl_json_key */ + +yajl_callbacks gl_json_callbacks = +{ + /* null = */ NULL, + /* boolean = */ NULL, + /* integer = */ NULL, + /* double = */ NULL, + /* number = */ NULL, + /* string = */ gl_json_string, + /* start_map = */ NULL, + /* map_key = */ gl_json_key, + /* end_map = */ gl_json_end_map, + /* start_array = */ NULL, + /* end_array = */ gl_json_end_array +}; + +static int gl_read_cache (_Bool block) /* {{{ */ +{ + yajl_handle handle; + gl_json_context_t context; + yajl_parser_config handle_config = { /* comments = */ 0, /* check UTF-8 */ 0 }; + + int fd; + int cmd; + struct flock lock; + int status; + + fd = open (CACHE_FILE, O_RDONLY); + if (fd < 0) + { + fprintf (stderr, "gl_read_cache: open(2) failed with status %i\n", errno); + return (errno); + } + + if (block) + cmd = F_SETLKW; + else + cmd = F_SETLK; + + memset (&lock, 0, sizeof (lock)); + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0; + lock.l_len = 0; /* lock everything */ + + while (42) + { + status = fcntl (fd, cmd, &lock); + if (status == 0) + break; + + if (!block && ((errno == EACCES) || (errno == EAGAIN))) + { + close (fd); + return (0); + } + + if (errno == EINTR) + continue; + + fprintf (stderr, "gl_read_cache: fcntl(2) failed with status %i\n", + errno); + return (errno); + } + + memset (&context, 0, sizeof (context)); + context.cfg = NULL; + context.inst = NULL; + context.ident = NULL; + + handle = yajl_alloc (&gl_json_callbacks, + &handle_config, + /* alloc funcs = */ NULL, + &context); + + close (fd); + +} /* }}} int gl_read_cache */ /* * Global functions @@ -132,7 +587,6 @@ int gl_config_submit (void) /* {{{ */ { graph_config_t **old; size_t old_num; - size_t i; old = gl_active; old_num = gl_active_num; @@ -143,12 +597,7 @@ int gl_config_submit (void) /* {{{ */ gl_staging = NULL; gl_staging_num = 0; - for (i = 0; i < old_num; i++) - { - graph_destroy (old[i]); - old[i] = NULL; - } - free (old); + gl_destroy (&old, &old_num); return (0); } /* }}} int graph_config_submit */ @@ -172,6 +621,15 @@ int gl_graph_get_all (graph_callback_t callback, /* {{{ */ return (status); } + for (i = 0; i < gl_dynamic_num; i++) + { + int status; + + status = (*callback) (gl_dynamic[i], user_data); + if (status != 0) + return (status); + } + return (0); } /* }}} int gl_graph_get_all */ @@ -203,6 +661,15 @@ graph_config_t *gl_graph_get_selected (void) /* {{{ */ return (gl_active[i]); } + for (i = 0; i < gl_dynamic_num; i++) + { + if (graph_compare (gl_dynamic[i], ident) != 0) + continue; + + ident_destroy (ident); + return (gl_dynamic[i]); + } + ident_destroy (ident); return (NULL); } /* }}} graph_config_t *gl_graph_get_selected */ @@ -255,20 +722,64 @@ int gl_instance_get_all (graph_inst_callback_t callback, /* {{{ */ return (status); } + for (i = 0; i < gl_dynamic_num; i++) + { + int status; + + status = gl_graph_instance_get_all (gl_dynamic[i], callback, user_data); + if (status != 0) + return (status); + } + return (0); } /* }}} int gl_instance_get_all */ /* }}} gl_instance_get_all, gl_graph_instance_get_all */ -int gl_search (const char *term, graph_inst_callback_t callback, /* {{{ */ - void *user_data) +int gl_search (search_info_t *si, /* {{{ */ + graph_inst_callback_t callback, void *user_data) { size_t i; + graph_ident_t *ident; + + if ((si == NULL) || (callback == NULL)) + return (EINVAL); + + if (search_has_selector (si)) + { + ident = search_to_ident (si); + if (ident == NULL) + { + fprintf (stderr, "gl_search: search_to_ident failed\n"); + return (-1); + } + } + else + { + ident = NULL; + } for (i = 0; i < gl_active_num; i++) { int status; - status = graph_inst_search (gl_active[i], term, + if ((ident != NULL) && !graph_ident_intersect (gl_active[i], ident)) + continue; + + status = graph_search_inst (gl_active[i], si, + /* callback = */ callback, + /* user data = */ user_data); + if (status != 0) + return (status); + } + + for (i = 0; i < gl_dynamic_num; i++) + { + int status; + + if ((ident != NULL) && !graph_ident_intersect (gl_dynamic[i], ident)) + continue; + + status = graph_search_inst (gl_dynamic[i], si, /* callback = */ callback, /* user data = */ user_data); if (status != 0) @@ -278,6 +789,36 @@ int gl_search (const char *term, graph_inst_callback_t callback, /* {{{ */ return (0); } /* }}} int gl_search */ +int gl_search_string (const char *term, graph_inst_callback_t callback, /* {{{ */ + void *user_data) +{ + size_t i; + + for (i = 0; i < gl_active_num; i++) + { + int status; + + status = graph_search_inst_string (gl_active[i], term, + /* callback = */ callback, + /* user data = */ user_data); + if (status != 0) + return (status); + } + + for (i = 0; i < gl_dynamic_num; i++) + { + int status; + + status = graph_search_inst_string (gl_dynamic[i], term, + /* callback = */ callback, + /* user data = */ user_data); + if (status != 0) + return (status); + } + + return (0); +} /* }}} int gl_search_string */ + int gl_search_field (graph_ident_field_t field, /* {{{ */ const char *field_value, graph_inst_callback_t callback, void *user_data) @@ -299,13 +840,42 @@ int gl_search_field (graph_ident_field_t field, /* {{{ */ return (status); } + for (i = 0; i < gl_dynamic_num; i++) + { + int status; + + status = graph_inst_search_field (gl_dynamic[i], + field, field_value, + /* callback = */ callback, + /* user data = */ user_data); + if (status != 0) + return (status); + } + return (0); } /* }}} int gl_search_field */ +int gl_foreach_host (int (*callback) (const char *host, void *user_data), /* {{{ */ + void *user_data) +{ + int status; + size_t i; + + for (i = 0; i < host_list_len; i++) + { + status = (*callback) (host_list[i], user_data); + if (status != 0) + return (status); + } + + return (0); +} /* }}} int gl_foreach_host */ + int gl_update (void) /* {{{ */ { time_t now; int status; + size_t i; /* printf ("Content-Type: text/plain\n\n"); @@ -316,13 +886,26 @@ int gl_update (void) /* {{{ */ if ((gl_last_update + UPDATE_INTERVAL) >= now) return (0); + /* Clear state */ + gl_clear_instances (); + gl_clear_hosts (); + gl_destroy (&gl_dynamic, &gl_dynamic_num); + graph_read_config (); - gl_clear_instances (); status = fs_scan (/* callback = */ gl_register_file, /* user data = */ NULL); + if (host_list_len > 0) + qsort (host_list, host_list_len, sizeof (*host_list), + gl_compare_hosts); + gl_last_update = now; + for (i = 0; i < gl_active_num; i++) + graph_sort_instances (gl_active[i]); + + gl_dump (); + return (status); } /* }}} int gl_update */