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                 printf("  ! Missing host_check hook\n");
 122                 return -1;
 123         }
 124
 125         init_ds(ds);
 126         ds.type = NEBTYPE_HOSTCHECK_PROCESSED;
 127         ds.output = "nebtest host check";
 128         return hook(cb, &ds);
 129 }
 130
 131 static int test_sql_service_insert(void)
 132 {
 133         int (*hook)(int, void *);
 134         nebstruct_service_check_data ds;
 135         int cb = NEBCALLBACK_SERVICE_CHECK_DATA;
 136
 137         if (!(hook = hooks[cb])) {
 138                 printf("  ! Missing service_check hook\n");
 139                 return -1;
 140         }
 141
 142         init_ds(ds);
 143         set_service(ds);
 144         ds.type = NEBTYPE_SERVICECHECK_PROCESSED;
 145         ds.output = strdup("nebtest service check");
 146
 147         return hook(cb, &ds);
 148 }
 149
 150 static int test_sql_process_data_insert(void)
 151 {
 152         int (*hook)(int, void *);
 153         nebstruct_process_data ds;
 154         int cb = NEBCALLBACK_PROCESS_DATA;
 155
 156         if (!(hook = hooks[cb])) {
 157                 printf("  ! Missing process data hook\n");
 158                 return -1;
 159         }
 160
 161         memset(&ds, 0, sizeof(ds));
 162         ds.timestamp.tv_sec = time(NULL);
 163         ds.type = NEBTYPE_PROCESS_START;
 164
 165         return hook(cb, &ds);
 166 }
 167
 168 static void test_sql_downtime_insert(void)
 169 {
 170         int (*hook)(int, void *);
 171         nebstruct_downtime_data ds;
 172         int cb = NEBCALLBACK_DOWNTIME_DATA;
 173
 174         if (!(hook = hooks[cb])) {
 175                 t_fail("downtime data hook missing");
 176                 return;
 177         }
 178         t_pass("downtime data hook exists");
 179
 180         init_ds(ds);
 181         ds.type = NEBTYPE_DOWNTIME_START;
 182         ds.comment_data = "nebtest downtime";
 183
 184         ok_int(hook(cb, &ds), 0, "host downtime insertion");
 185         set_service(ds);
 186         ok_int(hook(cb, &ds), 0, "service downtime insertion");
 187 }
 188
 189
 190 static void test_sql_inserts(void)
 191 {
 192         printf("%sTesting hooks%s\n", cyan, reset);
 193         ok_int(test_sql_host_insert(), 0, "host check hook");
 194         ok_int(test_sql_service_insert(), 0, "service check hook");
 195         test_sql_downtime_insert();
 196         ok_int(test_sql_process_data_insert(), 0, "process data hook");
 197 }
 198
 199 static nebmodule *neb;
 200 static void test_one_module(char *arg)
 201 {
 202         static void *dso = NULL;
 203         char *path;
 204         int (*init_func)(int, const char *, nebmodule *);
 205         int (*deinit_func)(int, int);
 206         int (*log_grok_var)(const char *, const char *);
 207
 208         if (dso)
 209                 dlclose(dso);
 210
 211         if (strchr(arg, '/'))
 212                 path = arg;
 213         else {
 214                 int len = strlen(arg);
 215                 path = calloc(len + 3, 1);
 216                 path[0] = '.';
 217                 path[1] = '/';
 218                 memcpy(path + 2, arg, len);
 219         }
 220
 221         dso = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 222         if (!dso) {
 223                 t_fail("dlopen() failed: %s", dlerror());
 224                 return;
 225         }
 226
 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         printf("%sChecking symbols in '%s'%s\n", cyan, path, reset);
 233
 234         check_symbols(dso);
 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
 246         return;
 247 }
 248
 249 int main(int argc, char **argv)
 250 {
 251         int i;
 252
 253         t_set_colors(0);
 254         t_verbose = 1;
 255         neb = calloc(sizeof(*neb), 1);
 256
 257         for (i = 1; i < argc; i++) {
 258                 char *arg = argv[i];
 259
 260                 if (*arg == '-' && arg[1] == 'f' && i < argc - 1) {
 261                         neb->args = argv[++i];
 262                         continue;
 263                 }
 264
 265                 test_one_module(arg);
 266         }
 267
 268         return t_end();
 269 }