src/graph_list.c

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