mockNagios.c

Go to the documentation of this file.

/*--------------------------------------------------------------------------

   Copyright (c) 2006-2010, Intellectual Reserve, Inc. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation.

   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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  --------------------------------------------------------------------------*/

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#ifndef NSCORE
# define NSCORE
#endif
#include "nagios.h"
#include "nebstructs.h"
#include "nebcallbacks.h"
#include "neberrors.h"
#include "nebmodules.h"
#include "broker.h"

#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <dlfcn.h>

#define USEC2MSEC 1000L

typedef int nebmodule_init(int flags, char * args, void * handle);
typedef int nebmodule_deinit(int flags, int reason);

#if CURRENT_NEB_API_VERSION == 2

int check_result_buffer_slots = 4096;
circular_buffer service_result_buffer;

int init_service_result_buffer(void)
{
   int result;

   /* initialize circular buffer */
   service_result_buffer.head = 0;
   service_result_buffer.tail = 0;
   service_result_buffer.items = 0;
   service_result_buffer.high = 0;
   service_result_buffer.overflow = 0L;
   service_result_buffer.buffer = (void **)malloc(
      check_result_buffer_slots * sizeof(service_message **));

   if (service_result_buffer.buffer == 0)
      return ERROR;

   /* initialize mutex */
   pthread_mutex_init(&service_result_buffer.buffer_lock, 0);

   return OK;
}

# define OBJECT_FIELD_NAME object

#elif CURRENT_NEB_API_VERSION == 3

# define DIRECT_POST
# ifdef DIRECT_POST

check_result * check_result_list = 0;

static volatile int results_processed = 0;

void process_results_list(void)
{
   check_result * tmp = check_result_list;
   while (tmp)
   {
      check_result_list = tmp->next;
      results_processed++;
      free(tmp->host_name);
      free(tmp->service_description);
      free(tmp->output);
      free(tmp);
      tmp = check_result_list;
   }
}

# else // !DIRECT_POST

// used to indicate how many results have been processed 
static volatile int files_moved = 0;

int my_rename(char * source, char * destination)
{
   files_moved++
   return rename(source, destination);
}

# endif // ?DIRECT_POST

char * temp_path;
char * check_result_path;

check_result check_result_info;

# define OBJECT_FIELD_NAME object_ptr

#else
# error Unsupported NEB API version.
#endif

service * service_list = 0;

int (*pdata_callback)(int,void *);
int (*schk_callback)(int,void *);
int (*tevt_callback)(int,void *);

int neb_register_callback(int callback_type, void *handle, 
      int priority, int (*callback_func)(int,void *))
{
   int err = 0;
   if (callback_type == NEBCALLBACK_PROCESS_DATA)
      pdata_callback = callback_func;
   else if (callback_type == NEBCALLBACK_SERVICE_CHECK_DATA)
      schk_callback = callback_func;
   else if (callback_type == NEBCALLBACK_TIMED_EVENT_DATA)
      tevt_callback = callback_func;
   else
   {
      printf("Unhandled callback type in neb_register_callback.\n");
      err = -1;
   }
   return err;
}

int neb_deregister_callback(int callback_type, int (*callback_func)(int,void *))
{
   int err = 0;
   if (callback_type == NEBCALLBACK_PROCESS_DATA)
      pdata_callback = 0;
   else if (callback_type == NEBCALLBACK_SERVICE_CHECK_DATA)
      schk_callback = 0;
   else if (callback_type == NEBCALLBACK_TIMED_EVENT_DATA)
      tevt_callback = 0;
   else 
   {
      printf("Unhandled callback type in neb_deregister_callback.\n");
      err = -1;
   }
   return err;
}

int neb_deregister_module_callbacks(nebmodule * mod)
{
   return 0;
}

int neb_unload_module(void * handle, int (*deinitfunc)(int, int), int flags, int reason)
{
   char temp_buffer[MAX_INPUT_BUFFER];
   int result;

   if (!handle) return -1;

   /* call the de-initialization function if available (and the module was initialized) */
   if (deinitfunc && reason != NEBMODULE_ERROR_BAD_INIT)
   {
      /* module can opt to not be unloaded */
      result = (*deinitfunc)(flags, reason);

      /* if module doesn't want to be unloaded, exit with error (unless its being forced) */
      if (result != OK && !(flags & NEBMODULE_FORCE_UNLOAD))
         return ERROR;
   }

   /* deregister all of the module's callbacks */
   // neb_deregister_module_callbacks(mod);

   /* unload the module */
   result = dlclose(handle);

   return OK;
}

int main(int argc, char ** argv)
{
   int i, ret;
   void * handle; 
   nebmodule_init * initptr;
   nebmodule_deinit * deinitptr;
   int * module_version_ptr;
   nebstruct_process_data pdata;
   service svc;
   nebstruct_service_check_data svcdata;
   timed_event evt;
   nebstruct_timed_event_data evtdata;
   int dnxHandled = 0;
   int nagiosHandled = 0; 

   if (argc != 4)
   {
      printf("Usage: mockNagios <run-path> <dnx-plugin-path> <dnx-server-cfg-path>\n");
      exit(1);
   }

   // ignore broken pipe signals
   signal(SIGPIPE, SIG_IGN);

#if CURRENT_NEB_API_VERSION == 2

   init_service_result_buffer();
   
#elif CURRENT_NEB_API_VERSION == 3
   
   memset(&check_result_info, 0, sizeof check_result_info);
   temp_path = check_result_path = argv[1];
   
#endif

   if ((handle = dlopen(argv[2], RTLD_NOW|RTLD_GLOBAL)) == 0)
   {
      printf("Error opening %s: %s.\n", argv[2], dlerror());
      return -1;
   }

   initptr = dlsym(handle, "nebmodule_init");
   deinitptr = dlsym(handle, "nebmodule_deinit");
   if (initptr == 0 || deinitptr == 0)
   {
      printf("Error importing symbols: %s.\n", dlerror());
      return -1;
   }

   module_version_ptr = (int *)dlsym(handle, "__neb_api_version");
   if (!module_version_ptr || *module_version_ptr != CURRENT_NEB_API_VERSION)
   {
      printf("Error: Module '%s' is using an old or unspecified version of "
            "the event broker API. Module will be unloaded.\n", argv[2]);
      
      neb_unload_module(handle, deinitptr, NEBMODULE_FORCE_UNLOAD, NEBMODULE_ERROR_NO_INIT);
      return -1; 
   }

   if ((ret = initptr(0, argv[3], handle)) != 0)
   {
      printf("Error executing init: %d.\n", ret);
      return ret;
   }

   if (pdata_callback == 0)
   {
      printf("Oops! init function didn't register process data callback.\n");
      return -1;
   }

   pdata.type = NEBTYPE_PROCESS_EVENTLOOPSTART;
   if ((ret = pdata_callback(NEBCALLBACK_PROCESS_DATA, &pdata)) != 0)
   {
      printf("pdata_callback returned %d.\n", ret);
      return ret;
   }

   if (schk_callback == 0)
   {
      printf("Oops! pdata_callback didn't register svc check callback.\n");
      return -1;
   }

#ifdef DIRECT_POST
   if (tevt_callback == 0)
   {
      printf("Oops! pdata_callback didn't register timed event callback.\n");
      return -1;
   }
#endif

   // give the client time to wake up and notice the server is running
   sleep(2);

   // post 100 bogus service checks
   svc.host_name = "bogushost";
   svc.description = "description of a bogushost";
   svc.parallelize = 1;
   svcdata.type = NEBTYPE_SERVICECHECK_INITIATE;
   svcdata.command_line = "/bin/check.script --version";
   gettimeofday(&svcdata.start_time, 0);
   svcdata.OBJECT_FIELD_NAME = &svc;
   svcdata.timeout = 10;
   for (i = 0; i < 100; i++)
   {
      // imitate Nagios internal latency; sleep 10 ms between calls
      usleep(10L * USEC2MSEC);
      ret = schk_callback(NEBCALLBACK_SERVICE_CHECK_DATA, &svcdata);
      if (ret == NEBERROR_CALLBACKOVERRIDE)
         dnxHandled++;
      else if (ret == 0)
         nagiosHandled++;
      else
      {
         printf("schk_callback failed: %d.\n", ret);
         return -1;
      }
   }
   printf("TEST: DNX handled %d, Nagios handled %d of %d checks.\n", 
         dnxHandled, nagiosHandled, i);

   if (getenv("DNX_KEYSTROKE_TERMINATE") != 0)
   {
      printf("Press any key to terminate...");
      getchar();
      printf("Cleaning up, please wait...\n");
   }
   
   // wait for all results to be posted back to results buffer
#if CURRENT_NEB_API_VERSION == 2

   while (service_result_buffer.items < dnxHandled)
      usleep(250L * USEC2MSEC);

#elif CURRENT_NEB_API_VERSION == 3
# ifdef DIRECT_POST

   evt.event_type = EVENT_CHECK_REAPER;
   evt.recurring = 1;
   evt.run_time = 0;
   evt.event_data = 0;

   evtdata.type = NEBTYPE_TIMEDEVENT_EXECUTE;
   evtdata.flags = 0;
   evtdata.attr = 0; 
   gettimeofday(&evtdata.timestamp, 0);
   evtdata.event_type = evt.event_type;
   evtdata.recurring = evt.recurring;
   evtdata.run_time = evt.run_time;
   evtdata.event_data = evt.event_data;
   evtdata.event_ptr = &evt;

   tevt_callback(NEBCALLBACK_TIMED_EVENT_DATA, &evtdata);
   process_results_list();
   while (results_processed < dnxHandled)
   {
      usleep(500L * USEC2MSEC);
      tevt_callback(NEBCALLBACK_TIMED_EVENT_DATA, &evtdata);
      process_results_list();
   }

# else

   while (files_moved < dnxHandled)
      usleep(250L * USEC2MSEC);

# endif
#endif

   // going down...
   if ((ret = deinitptr(0, 0)) != 0)
   {
      printf("Error executing deinit: %d.\n", ret);
      return ret;
   }

#ifdef DIRECT_POST
   if (tevt_callback != 0)
   {
      printf("Oops! deinit didn't deregister timed event callback.\n");
      return -1;
   }
#endif

   if (schk_callback != 0)
   {
      printf("Oops! deinit didn't deregister svc check callback.\n");
      return -1;
   }

   if (pdata_callback != 0)
   {
      printf("Oops! deinit didn't deregister process data callback.\n");
      return -1;
   }


   dlclose(handle);
   return 0;
}

/*--------------------------------------------------------------------------*/