nebtest.c

   1 #include "ndbneb.h"
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include <dlfcn.h>
   5 #include "logutils.h"
   6 #include "test_utils.h"
   7 #include "nagios/nebstructs.h"
   8 #include "nagios/nebmodules.h"
   9 #include "nagios/nebmods.h"
  10 #include "nagios/broker.h"
  11 #include "nagios/objects.h"
  12
  13 static int (*hooks[NEBCALLBACK_NUMITEMS])(int, void *);
  14 static int reg_errors;
  15 static int dereg_errors;
  16 int event_broker_options = 0;
  17 int daemon_dumps_core = 0;
  18
  19 int is_tested(int callback_type, const char *caller_func)
  20 {
  21         switch (callback_type) {
  22         case NEBCALLBACK_SERVICE_CHECK_DATA:
  23         case NEBCALLBACK_HOST_CHECK_DATA:
  24         case NEBCALLBACK_DOWNTIME_DATA:
  25         case NEBCALLBACK_PROCESS_DATA:
  26                 t_pass("%s: callback %d is handled by nebtest",
  27                            caller_func, callback_type);
  28                 return 1;
  29         }
  30
  31         t_fail("%s: callback %d is unhandled by nebtest",
  32                    caller_func, callback_type);
  33         return 0;
  34 }
  35
  36 int neb_register_callback(int callback_type, void *mod_handle,
  37                                                   int priority, int (*callback_func)(int,void *))
  38 {
  39         if (!is_tested(callback_type, __func__))
  40                 reg_errors |= 1 << callback_type;
  41
  42         if (hooks[callback_type]) {
  43                 reg_errors |= 1 << callback_type;
  44                 printf("! Registering a second hook for %d!", callback_type);
  45         }
  46
  47         hooks[callback_type] = callback_func;
  48
  49         return 0;
  50 }
  51
  52 int neb_deregister_callback(int callback_type, int (*callback_func)(int, void *))
  53 {
  54         if (!is_tested(callback_type, __func__))
  55                 dereg_errors |= 1 << callback_type;
  56
  57         if (!hooks[callback_type]) {
  58                 dereg_errors |= 1 << callback_type;
  59                 printf("! Trying to unregister an unregistered hook!\n");
  60         }
  61
  62         hooks[callback_type] = NULL;
  63
  64         return 0;
  65 }
  66
  67 static void check_callbacks(void)
  68 {
  69         int i;
  70
  71         for (i = 0; i < NEBCALLBACK_NUMITEMS; i++) {
  72                 /* only print it if something's wrong, to suppress noise */
  73                 if (!hooks[i])
  74                         continue;
  75
  76                 t_fail("hook %d not unregistered by module unload function", i);
  77         }
  78 }
  79
  80 static int check_symbols(void *dso)
  81 {
  82         int i, result = 0;
  83
  84         const char *syms[] = {
  85                 "__neb_api_version", "nebmodule_init", "nebmodule_deinit",
  86                         NULL,
  87         };
  88
  89         for (i = 0; syms[i]; i++) {
  90                 const char *sym = syms[i];
  91
  92                 if (dlsym(dso, sym))
  93                         t_pass("%s exists in module", sym);
  94                 else {
  95                         t_fail("%s can't be looked up: %s", sym, dlerror());
  96                         result = -1;
  97                 }
  98         }
  99
 100         return result;
 101 }
 102
 103
 104 static char *__host_name = "ndb, host";
 105 static char *__service_description = "ndb, service";
 106 #define init_ds(x) \
 107         do { \
 108                 memset(&x, 0, sizeof(x)); \
 109                 x.timestamp.tv_sec = time(NULL); \
 110                 x.host_name = __host_name; \
 111         } while(0)
 112 #define set_service(x) x.service_description = __service_description
 113
 114 static int test_sql_host_insert(void)
 115 {
 116         int (*hook)(int, void *);
 117         nebstruct_host_check_data ds;
 118         int cb = NEBCALLBACK_HOST_CHECK_DATA;
 119
 120         if (!(hook = hooks[cb])) {
 121                 return -1;
 122         }
 123
 124         init_ds(ds);
 125         ds.type = NEBTYPE_HOSTCHECK_PROCESSED;
 126         ds.output = "nebtest host check";
 127         return hook(cb, &ds);
 128 }
 129
 130 static int test_sql_service_insert(void)
 131 {
 132         int (*hook)(int, void *);
 133         nebstruct_service_check_data ds;
 134         int cb = NEBCALLBACK_SERVICE_CHECK_DATA;
 135
 136         if (!(hook = hooks[cb])) {
 137                 printf("  ! Missing service_check hook\n");
 138                 return -1;
 139         }
 140
 141         init_ds(ds);
 142         set_service(ds);
 143         ds.type = NEBTYPE_SERVICECHECK_PROCESSED;
 144         ds.output = strdup("nebtest service check");
 145
 146         return hook(cb, &ds);
 147 }
 148
 149 static int test_sql_process_data_insert(void)
 150 {
 151         int (*hook)(int, void *);
 152         nebstruct_process_data ds;
 153         int cb = NEBCALLBACK_PROCESS_DATA;
 154
 155         if (!(hook = hooks[cb])) {
 156                 printf("  ! Missing process data hook\n");
 157                 return -1;
 158         }
 159
 160         memset(&ds, 0, sizeof(ds));
 161         ds.timestamp.tv_sec = time(NULL);
 162         ds.type = NEBTYPE_PROCESS_START;
 163
 164         return hook(cb, &ds);
 165 }
 166
 167 static void test_sql_downtime_insert(void)
 168 {
 169         int (*hook)(int, void *);
 170         nebstruct_downtime_data ds;
 171         int cb = NEBCALLBACK_DOWNTIME_DATA;
 172
 173         if (!(hook = hooks[cb])) {
 174                 t_fail("downtime data hook missing");
 175                 return;
 176         }
 177         t_pass("downtime data hook exists");
 178
 179         init_ds(ds);
 180         ds.type = NEBTYPE_DOWNTIME_START;
 181         ds.comment_data = "nebtest downtime";
 182
 183         ok_int(hook(cb, &ds), 0, "host downtime insertion");
 184         set_service(ds);
 185         ok_int(hook(cb, &ds), 0, "service downtime insertion");
 186 }
 187
 188
 189 static void test_sql_inserts(void)
 190 {
 191         t_start("Testing hooks");
 192         ok_int(test_sql_host_insert(), 0, "host check hook");
 193         ok_int(test_sql_service_insert(), 0, "service check hook");
 194         test_sql_downtime_insert();
 195         ok_int(test_sql_process_data_insert(), 0, "process data hook");
 196 }
 197
 198 static nebmodule *neb;
 199 static void test_one_module(char *arg)
 200 {
 201         static void *dso = NULL;
 202         char *path;
 203         int (*init_func)(int, const char *, nebmodule *);
 204         int (*deinit_func)(int, int);
 205         int (*log_grok_var)(const char *, const char *);
 206
 207         if (dso)
 208                 dlclose(dso);
 209
 210         if (strchr(arg, '/'))
 211                 path = arg;
 212         else {
 213                 int len = strlen(arg);
 214                 path = calloc(len + 3, 1);
 215                 path[0] = '.';
 216                 path[1] = '/';
 217                 memcpy(path + 2, arg, len);
 218         }
 219
 220         dso = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 221         if (!dso) {
 222                 t_fail("dlopen() failed: %s", dlerror());
 223                 return;
 224         }
 225
 226         t_start("Testing module '%s'", path);
 227         t_pass("dlopen() worked out fine");
 228         log_grok_var = dlsym(dso, "log_grok_var");
 229         if (log_grok_var) {
 230                 log_grok_var("log_file", "/dev/null");
 231         }
 232         t_start("Checking symbols in '%s'", path);
 233         check_symbols(dso);
 234         t_end();
 235
 236         init_func = dlsym(dso, "nebmodule_init");
 237         ok_int(init_func(-1, neb->args, neb), 0, "module init function");
 238
 239         test_sql_inserts();
 240         deinit_func = dlsym(dso, "nebmodule_deinit");
 241         ok_int(deinit_func(0, 0), 0, "module deinit function");
 242         ok_int(reg_errors, 0, "registering callbacks");
 243         ok_int(dereg_errors, 0, "deregistering callbacks");
 244         check_callbacks();
 245         t_end();
 246
 247         return;
 248 }
 249
 250 int main(int argc, char **argv)
 251 {
 252         int i;
 253
 254         t_set_colors(0);
 255         t_verbose = 1;
 256         neb = calloc(sizeof(*neb), 1);
 257
 258         for (i = 1; i < argc; i++) {
 259                 char *arg = argv[i];
 260
 261                 if (*arg == '-' && arg[1] == 'f' && i < argc - 1) {
 262                         neb->args = argv[++i];
 263                         continue;
 264                 }
 265
 266                 test_one_module(arg);
 267         }
 268
 269         return t_end();
 270 }