Changeset 1ecd26f in nscp for modules


Ignore:
Timestamp:
01/03/11 08:21:00 (2 years ago)
Author:
Michael Medin <michael@…>
Branches:
master, 0.4.0, 0.4.1, 0.4.2
Children:
e6792f3
Parents:
f7663c9
Message:

syncronized streams between 0.4.x and 0.3.x as well as improed the CMAke build *alot*

Location:
modules
Files:
11 added
1 deleted
27 edited

Legend:

Unmodified
Added
Removed

  • modules/CheckDisk/CMakeLists.txt

    rf7663c9 r1ecd26f  
    3030  version.lib 
    3131) 
     32INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/CheckEventLog/CMakeLists.txt

    r497b779 r1ecd26f  
    4545  version.lib 
    4646) 
     47INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/CheckEventLog/CheckEventLog.cpp

    rc015acc r1ecd26f  
    166166      error_type errors; 
    167167      static const parsers::where::value_type type_custom_severity = parsers::where::type_custom_int_1; 
     168      static const parsers::where::value_type type_custom_type = parsers::where::type_custom_int_2; 
    168169      EventLogRecord *record; 
    169170      type_obj() : record(NULL) { 
    … …  
    173174          (_T("id"), (type_int)) 
    174175          (_T("source"), (type_string)) 
    175           (_T("type"), (type_int)) 
     176          (_T("type"), (type_custom_type)) 
    176177          (_T("severity"), (type_custom_severity)) 
    177178          (_T("message"), (type_string)) 
    … …  
    192193      bool can_convert(parsers::where::value_type from, parsers::where::value_type to) { 
    193194        if ((from == parsers::where::type_string)&&(to == type_custom_severity)) 
     195          return true; 
     196        if ((from == parsers::where::type_string)&&(to == type_custom_type)) 
    194197          return true; 
    195198        return false; 
    … …  
    260263        if (to == type_custom_severity) 
    261264          return true; 
     265        if (to == type_custom_type) 
     266          return true; 
    262267        return false; 
    263268      } 
    … …  
    266271        if (to == type_custom_severity) 
    267272          ret = &type_obj::fun_convert_severity; 
     273        if (to == type_custom_type) 
     274          ret = &type_obj::fun_convert_type; 
    268275        return ret; 
    269276      } 
    … …  
    271278      parsers::where::expression_ast<type_obj> fun_convert_severity(parsers::where::value_type target_type, parsers::where::expression_ast<type_obj> const& subject) { 
    272279        return parsers::where::expression_ast<type_obj>(parsers::where::int_value(convert_severity(subject.get_string(*this)))); 
     280      } 
     281      parsers::where::expression_ast<type_obj> fun_convert_type(parsers::where::value_type target_type, parsers::where::expression_ast<type_obj> const& subject) { 
     282        return parsers::where::expression_ast<type_obj>(parsers::where::int_value(convert_type(subject.get_string(*this)))); 
    273283      } 
    274284      int convert_severity(std::wstring str) { 
    … …  
    284294        return strEx::stoi(str); 
    285295      } 
    286  
     296      int convert_type(std::wstring str) { 
     297        if (str == _T("error")) 
     298          return EVENTLOG_ERROR_TYPE; 
     299        if (str == _T("warning")) 
     300          return EVENTLOG_WARNING_TYPE; 
     301        if (str == _T("info")) 
     302          return EVENTLOG_INFORMATION_TYPE; 
     303        if (str == _T("auditSuccess")) 
     304          return EVENTLOG_AUDIT_SUCCESS; 
     305        if (str == _T("auditFailure")) 
     306          return EVENTLOG_AUDIT_FAILURE; 
     307        return strEx::stoi(str); 
     308      } 
    287309 
    288310      std::wstring get_error() { 
    … …  
    494516} 
    495517 
     518 
     519 
    496520std::wstring find_eventlog_name(std::wstring name) { 
    497521  try { 
    … …  
    571595  typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsULongInteger> EventLogQuery1Container; 
    572596  typedef checkHolders::CheckContainer<checkHolders::ExactBoundsULongInteger> EventLogQuery2Container; 
    573  
     597   
    574598  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
    575599 
    … …  
    750774        DWORD err = GetLastError(); 
    751775        if (err == ERROR_INSUFFICIENT_BUFFER) { 
    752           message = _T("EvenlogBuffer is too small change the value of ") + setting_keys::event_log::BUFFER_SIZE_PATH + _T("=") + strEx::itos(dwNeeded+1) + _T(": ") + error::lookup::last_error(err); 
    753           NSC_LOG_ERROR_STD(message); 
    754           CloseEventLog(hLog); 
    755           return NSCAPI::returnUNKNOWN; 
     776          if (!buffer_error_reported) { 
     777            NSC_LOG_ERROR_STD(_T("EvenlogBuffer is too small change the value of ") + setting_keys::event_log::BUFFER_SIZE_PATH + _T("=") + strEx::itos(dwNeeded+1) + _T(": ") + error::lookup::last_error(err)); 
     778            buffer_error_reported = true; 
     779          } 
    756780        } else if (err == ERROR_HANDLE_EOF) { 
    757781          break; 

  • modules/CheckExternalScripts/CMakeLists.txt

    r86632db r1ecd26f  
    3232  ${NSCP_DEF_PLUGIN_LIB} 
    3333) 
     34 
     35INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/CheckHelpers/CMakeLists.txt

    r60375ed r1ecd26f  
    3333  ${NSCP_DEF_PLUGIN_LIB} 
    3434) 
    35  
    36  
    37 #INSTALL(FILES ${PROJECT_SOURCE_DIR}/cmake/FindWt.cmake DESTINATION 
    38 #    ${CMAKE_INSTALL_PREFIX}/${WT_CMAKE_FINDER_INSTALL_DIR} ) 
    39  
    40  
    41  
     35INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/CheckHelpers/CheckHelpers.cpp

    r5e12ba6 r1ecd26f  
    2424#include <time.h> 
    2525#include <utils.h> 
     26#include <vector> 
     27#include <program_options_ex.hpp> 
     28#include <boost/program_options.hpp> 
     29#include <boost/thread/thread.hpp> 
    2630 
    2731CheckHelpers gCheckHelpers; 
    … …  
    3135CheckHelpers::~CheckHelpers() { 
    3236} 
     37 
    3338 
    3439bool CheckHelpers::loadModule() { 
    … …  
    115120  } else if (command == _T("checkmultiple")) { 
    116121    return checkMultiple(arguments, message, perf); 
     122  } else if (command == _T("Negate")) { 
     123    return negate(arguments, message, perf); 
    117124  } 
    118125  return NSCAPI::returnIgnored; 
    … …  
    157164} 
    158165 
     166NSCAPI::nagiosReturn CheckHelpers::negate(std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf)  
     167{ 
     168  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
     169  if (arguments.empty()) { 
     170    msg = _T("Missing argument(s)."); 
     171    return NSCAPI::returnCRIT; 
     172  } 
     173 
     174  std::wstring command; 
     175  NSCAPI::nagiosReturn OK = NSCAPI::returnOK, WARN = NSCAPI::returnWARN, CRIT = NSCAPI::returnCRIT, UNKNOWN = NSCAPI::returnUNKNOWN; 
     176  std::vector<std::wstring> cmd_args; 
     177 
     178  //#define USE_BOOST 
     179 
     180  try { 
     181 
     182 
     183    boost::program_options::options_description desc("Allowed options"); 
     184    desc.add_options() 
     185      ("help,h", "Show this help message.") 
     186 
     187      ("ok,o",    boost::program_options::wvalue<std::wstring>(), "The state to return instead of OK") 
     188      ("warning,w", boost::program_options::wvalue<std::wstring>(), "The state to return instead of WARNING") 
     189      ("critical,c",  boost::program_options::wvalue<std::wstring>(), "The state to return instead of CRITICAL") 
     190      ("unknown,u", boost::program_options::wvalue<std::wstring>(), "The state to return instead of UNKNOWN") 
     191 
     192      ("command,q", boost::program_options::wvalue<std::wstring>(&command), "Wrapped command to execute") 
     193        ("arguments,a", boost::program_options::wvalue<std::vector<std::wstring> >(&cmd_args), "List of arguments (for wrapped command)") 
     194      ; 
     195 
     196    boost::program_options::positional_options_description p; 
     197    p.add("arguments", -1); 
     198 
     199    std::vector<std::wstring> arg_list(arguments.begin(), arguments.end()); 
     200 
     201    boost::program_options::variables_map vm; 
     202    boost::program_options::store(boost::program_options::basic_command_line_parser<wchar_t>(arg_list).options(desc).positional(p).run(), vm); 
     203    boost::program_options::notify(vm);  
     204 
     205    if (vm.count("help")) { 
     206      std::stringstream ss; 
     207      desc.print(ss); 
     208      msg = strEx::string_to_wstring(ss.str()); 
     209      return NSCAPI::returnUNKNOWN; 
     210    } 
     211 
     212    if (vm.count("ok")) 
     213      OK = nscapi::plugin_helper::translateReturn(vm["ok"].as<std::wstring>()); 
     214    if (vm.count("warning")) 
     215      WARN = nscapi::plugin_helper::translateReturn(vm["warning"].as<std::wstring>()); 
     216    if (vm.count("critical")) 
     217      CRIT = nscapi::plugin_helper::translateReturn(vm["critical"].as<std::wstring>()); 
     218    if (vm.count("unknown")) 
     219      UNKNOWN = nscapi::plugin_helper::translateReturn(vm["unknown"].as<std::wstring>()); 
     220 
     221  } catch (std::exception &e) { 
     222    msg = _T("Could not parse command: ") + strEx::string_to_wstring(e.what()); 
     223    return NSCAPI::returnCRIT; 
     224  } catch (...) { 
     225    msg = _T("Could not parse command: <UNKNOWN EXCEPTION>"); 
     226    return NSCAPI::returnCRIT; 
     227  } 
     228  std::list<std::wstring> cmd_args_l(cmd_args.begin(), cmd_args.end()); 
     229 
     230  NSCAPI::nagiosReturn tRet = GET_CORE()->InjectSimpleCommand(command, cmd_args_l, msg, perf); 
     231  switch (tRet) { 
     232    case NSCAPI::returnOK: 
     233      return OK; 
     234    case NSCAPI::returnCRIT: 
     235      return CRIT; 
     236    case NSCAPI::returnWARN: 
     237      return WARN; 
     238    case NSCAPI::returnUNKNOWN: 
     239      return UNKNOWN; 
     240    default: 
     241      return UNKNOWN; 
     242  } 
     243} 
     244 
     245 
     246class worker { 
     247public: 
     248  void proc(std::wstring command, std::list<std::wstring> arguments) { 
     249    code = GET_CORE()->InjectSimpleCommand(command, arguments, msg, perf); 
     250  } 
     251  std::wstring msg; 
     252  std::wstring perf; 
     253  NSCAPI::nagiosReturn code; 
     254 
     255}; 
     256 
     257NSCAPI::nagiosReturn CheckHelpers::timeout(std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf)  
     258{ 
     259  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK; 
     260  if (arguments.empty()) { 
     261    msg = _T("Missing argument(s)."); 
     262    return NSCAPI::returnCRIT; 
     263  } 
     264 
     265  std::wstring command; 
     266  NSCAPI::nagiosReturn retCode = NSCAPI::returnUNKNOWN; 
     267  std::vector<std::wstring> cmd_args; 
     268  unsigned long timeout = 30; 
     269 
     270  try { 
     271 
     272    boost::program_options::options_description desc("Allowed options"); 
     273    desc.add_options() 
     274      ("help,h", "Show this help message.") 
     275 
     276      ("timeout,t", boost::program_options::value<unsigned long>(&timeout), "The timeout value") 
     277 
     278      ("command,q", boost::program_options::wvalue<std::wstring>(&command), "Wrapped command to execute") 
     279      ("arguments,a", boost::program_options::wvalue<std::vector<std::wstring> >(&cmd_args), "List of arguments (for wrapped command)") 
     280      ; 
     281 
     282    boost::program_options::positional_options_description p; 
     283    p.add("arguments", -1); 
     284 
     285    std::vector<std::wstring> arg_list(arguments.begin(), arguments.end()); 
     286 
     287    boost::program_options::variables_map vm; 
     288    boost::program_options::store(boost::program_options::basic_command_line_parser<wchar_t>(arg_list).options(desc).positional(p).run(), vm); 
     289    boost::program_options::notify(vm);  
     290 
     291    if (vm.count("help")) { 
     292      std::stringstream ss; 
     293      desc.print(ss); 
     294      msg = strEx::string_to_wstring(ss.str()); 
     295      return NSCAPI::returnUNKNOWN; 
     296    } 
     297 
     298    if (vm.count("return")) 
     299      retCode = nscapi::plugin_helper::translateReturn(vm["return"].as<std::wstring>()); 
     300 
     301  } catch (std::exception &e) { 
     302    msg = _T("Could not parse command: ") + strEx::string_to_wstring(e.what()); 
     303    return NSCAPI::returnCRIT; 
     304  } catch (...) { 
     305    msg = _T("Could not parse command: <UNKNOWN EXCEPTION>"); 
     306    return NSCAPI::returnCRIT; 
     307  } 
     308  std::list<std::wstring> cmd_args_l(cmd_args.begin(), cmd_args.end()); 
     309 
     310  worker obj; 
     311  boost::shared_ptr<boost::thread> t = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&worker::proc, obj, command, cmd_args_l))); 
     312 
     313  if (t->timed_join(boost::posix_time::seconds(timeout))) { 
     314    msg = obj.msg; 
     315    perf = obj.perf; 
     316    return obj.code; 
     317  } 
     318  t->detach(); 
     319  msg = _T("Thread failed to return within given timeout"); 
     320  return retCode; 
     321} 
    159322 
    160323NSC_WRAP_DLL(); 

  • modules/CheckHelpers/CheckHelpers.h

    r5e12ba6 r1ecd26f  
    5454  NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5555  NSCAPI::nagiosReturn checkSimpleStatus(NSCAPI::nagiosReturn status, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf); 
     56  NSCAPI::nagiosReturn timeout(std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf); 
     57  NSCAPI::nagiosReturn negate(std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf); 
    5658}; 

  • modules/CheckSystem/CMakeLists.txt

    r294b37b r1ecd26f  
    11CMAKE_MINIMUM_REQUIRED(VERSION 2.6) 
    22 
    3 IF(WIN32) 
    4   SET(TARGET CheckSystem) 
    5      
    6   PROJECT(${TARGET}) 
     3SET(TARGET CheckSystem) 
     4   
     5PROJECT(${TARGET}) 
    76 
    8   SET(SRCS 
    9     stdafx.cpp 
    10     "${TARGET}.cpp" 
    11     "PDHCollector.cpp" 
    12     ${NSCP_DEF_PLUGIN_CPP} 
    13      
    14     ${NSCP_INCLUDEDIR}/pdh/basic_impl.cpp 
    15     ${NSCP_INCLUDEDIR}/pdh/core.cpp 
     7SET(SRCS 
     8  stdafx.cpp 
     9  "${TARGET}.cpp" 
     10  "PDHCollector.cpp" 
     11  ${NSCP_DEF_PLUGIN_CPP} 
     12   
     13  ${NSCP_INCLUDEDIR}/pdh/basic_impl.cpp 
     14  ${NSCP_INCLUDEDIR}/pdh/core.cpp 
    1615 
    17     ${NSCP_INCLUDEDIR}/EnumProcess.cpp 
    18     ${NSCP_INCLUDEDIR}/EnumNtSrv.cpp 
    19     ${NSCP_INCLUDEDIR}/sysinfo.cpp 
    20      
    21   ) 
     16  ${NSCP_INCLUDEDIR}/EnumProcess.cpp 
     17  ${NSCP_INCLUDEDIR}/EnumNtSrv.cpp 
     18  ${NSCP_INCLUDEDIR}/sysinfo.cpp 
     19   
     20) 
    2221 
    23   ADD_DEFINITIONS(${NSCP_GLOBAL_DEFINES}) 
     22ADD_DEFINITIONS(${NSCP_GLOBAL_DEFINES}) 
    2423 
    25   SET(SRCS ${SRCS} 
    26     stdafx.h 
    27     "${TARGET}.h" 
    28     "${TARGET}.def" 
    29     "PDHCollector.h" 
     24SET(SRCS ${SRCS} 
     25  stdafx.h 
     26  "${TARGET}.h" 
     27  "${TARGET}.def" 
     28  "PDHCollector.h" 
    3029 
    31     ${NSCP_INCLUDEDIR}/EnumProcess.h 
    32     ${NSCP_INCLUDEDIR}/EnumNtSrv.h 
    33     ${NSCP_INCLUDEDIR}/sysinfo.h 
     30  ${NSCP_INCLUDEDIR}/EnumProcess.h 
     31  ${NSCP_INCLUDEDIR}/EnumNtSrv.h 
     32  ${NSCP_INCLUDEDIR}/sysinfo.h 
    3433 
    35     ${NSCP_INCLUDEDIR}/pdh/basic_impl.hpp 
    36     ${NSCP_INCLUDEDIR}/pdh/collectors.hpp 
    37     ${NSCP_INCLUDEDIR}/pdh/core.hpp 
    38     ${NSCP_INCLUDEDIR}/pdh/counters.hpp 
    39     ${NSCP_INCLUDEDIR}/pdh/enumerations.hpp 
    40     ${NSCP_INCLUDEDIR}/pdh/query.hpp 
    41     ${NSCP_INCLUDEDIR}/pdh/resolver.hpp 
    42     ${NSCP_INCLUDEDIR}/pdh/thread_safe_impl.hpp 
    43      
    44     ${NSCP_DEF_PLUGIN_HPP} 
    45   ) 
     34  ${NSCP_INCLUDEDIR}/pdh/basic_impl.hpp 
     35  ${NSCP_INCLUDEDIR}/pdh/collectors.hpp 
     36  ${NSCP_INCLUDEDIR}/pdh/core.hpp 
     37  ${NSCP_INCLUDEDIR}/pdh/counters.hpp 
     38  ${NSCP_INCLUDEDIR}/pdh/enumerations.hpp 
     39  ${NSCP_INCLUDEDIR}/pdh/query.hpp 
     40  ${NSCP_INCLUDEDIR}/pdh/resolver.hpp 
     41  ${NSCP_INCLUDEDIR}/pdh/thread_safe_impl.hpp 
     42   
     43  ${NSCP_DEF_PLUGIN_HPP} 
     44) 
    4645 
    47   add_library(${TARGET} MODULE ${SRCS}) 
     46add_library(${TARGET} MODULE ${SRCS}) 
    4847 
    49   target_link_libraries(${TARGET} 
    50     ${Boost_FILESYSTEM_LIBRARY} 
    51     ${NSCP_DEF_PLUGIN_LIB} 
    52   ) 
    53 ENDIF(WIN32) 
     48target_link_libraries(${TARGET} 
     49  ${Boost_FILESYSTEM_LIBRARY} 
     50  ${NSCP_DEF_PLUGIN_LIB} 
     51) 
     52INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/CheckSystem/CheckSystem.cpp

    rc015acc r1ecd26f  
    843843typedef struct NSPROCDATA__ { 
    844844  unsigned int count; 
     845  unsigned int hung_count; 
    845846  CEnumProcess::CProcessEntry entry; 
    846847  std::wstring key; 
    847848 
    848   NSPROCDATA__() : count(0) {} 
    849   NSPROCDATA__(const NSPROCDATA__ &other) : count(other.count), entry(other.entry), key(other.key) {} 
     849  NSPROCDATA__() : count(0), hung_count(0) {} 
     850  NSPROCDATA__(const NSPROCDATA__ &other) : count(other.count), hung_count(other.hung_count), entry(other.entry), key(other.key) {} 
    850851} NSPROCDATA; 
    851852typedef std::map<std::wstring,NSPROCDATA,strEx::StrICmp> NSPROCLST; 
    … …  
    895896      ret[key].entry = (*entry); 
    896897      ret[key].count = 1; 
     898      ret[key].hung_count = (*entry).hung?1:0; 
    897899      ret[key].key = key; 
    898     } else 
     900    } else { 
     901      if ((*entry).hung)  
     902        (*it).second.hung_count++; 
    899903      (*it).second.count++; 
     904    } 
    900905  } 
    901906  return ret; 
    … …  
    10301035      checkHolders::MaxMinStateValueType<int, checkHolders::state_type> value; 
    10311036      if (bFound) { 
    1032         value.count = (*proc).second.count; 
    1033         value.state = checkHolders::state_started; 
     1037        if ((*proc).second.hung_count > 0) { 
     1038          NSC_LOG_ERROR_STD(_T("Hung proc: ") + strEx::itos((*proc).second.hung_count)); 
     1039          value.count = (*proc).second.count; 
     1040          value.state = checkHolders::state_hung; 
     1041        } else { 
     1042          value.count = (*proc).second.count; 
     1043          value.state = checkHolders::state_started; 
     1044        } 
    10341045      } else { 
    10351046        value.count = 0; 

  • modules/CheckTaskSched/CheckTaskSched.cpp

    r739db5a r1ecd26f  
    3030CheckTaskSched gCheckTaskSched; 
    3131 
    32 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) 
    33 { 
    34   NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call); 
    35   return TRUE; 
     32bool CheckTaskSched::loadModule() { 
     33  return false; 
    3634} 
    37  
    38 bool CheckTaskSched::loadModule(NSCAPI::moduleLoadMode mode) { 
     35bool CheckTaskSched::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) { 
    3936  try { 
    40     NSCModuleHelper::registerCommand(_T("CheckTaskSchedValue"), _T("Run a WMI query and check the resulting value (the values of each row determin the state).")); 
    41     NSCModuleHelper::registerCommand(_T("CheckTaskSched"), _T("Run a WMI query and check the resulting rows (the number of hits determine state).")); 
     37    get_core()->registerCommand(_T("CheckTaskSchedValue"), _T("Run a WMI query and check the resulting value (the values of each row determin the state).")); 
     38    get_core()->registerCommand(_T("CheckTaskSched"), _T("Run a WMI query and check the resulting rows (the number of hits determine state).")); 
    4239 
    4340    SETTINGS_REG_PATH(task_scheduler::SECTION); 
    4441    SETTINGS_REG_KEY_S(task_scheduler::SYNTAX); 
    45   } catch (NSCModuleHelper::NSCMHExcpetion &e) { 
     42  } catch (nscapi::nscapi_exception &e) { 
    4643    NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_); 
    4744  } catch (...) { 
    … …  
    7875 
    7976 
    80 NSCAPI::nagiosReturn CheckTaskSched::TaskSchedule(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
     77NSCAPI::nagiosReturn CheckTaskSched::TaskSchedule(std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf) { 
    8178  typedef checkHolders::CheckContainer<checkHolders::MaxMinBounds<checkHolders::NumericBounds<int, checkHolders::int_handler> > > WMIContainer; 
    8279 
    … …  
    8481  typedef filters::chained_filter<TaskSched::wmi_filter,TaskSched::result> filter_chain; 
    8582  filter_chain chain; 
    86   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    87   if (args.empty()) { 
     83  if (arguments.empty()) { 
    8884    message = _T("Missing argument(s)."); 
    8985    return NSCAPI::returnCRIT; 
    … …  
    9692  WMIContainer result_query; 
    9793  try { 
    98     MAP_OPTIONS_BEGIN(args) 
     94    MAP_OPTIONS_BEGIN(arguments) 
    9995      MAP_OPTIONS_STR2INT(_T("truncate"), truncate) 
    10096      MAP_OPTIONS_STR(_T("Alias"), alias) 
    … …  
    164160} 
    165161 
    166 NSCAPI::nagiosReturn CheckTaskSched::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) { 
     162NSCAPI::nagiosReturn CheckTaskSched::handleCommand(const strEx::wci_string command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf) { 
    167163  if (command == _T("CheckTaskSched")) 
    168     return TaskSchedule(argLen, char_args, msg, perf); 
     164    return TaskSchedule(arguments, message, perf); 
    169165  return NSCAPI::returnIgnored; 
    170166} 
    … …  
    191187 
    192188 
     189NSC_WRAP_DLL(); 
    193190NSC_WRAPPERS_MAIN_DEF(gCheckTaskSched); 
    194191NSC_WRAPPERS_IGNORE_MSG_DEF(); 
    195192NSC_WRAPPERS_HANDLE_CMD_DEF(gCheckTaskSched); 
    196 NSC_WRAPPERS_CLI_DEF(gCheckTaskSched); 
     193//NSC_WRAPPERS_CLI_DEF(gCheckTaskSched); 

  • modules/CheckTaskSched/CheckTaskSched.def

    r367bf20 r1ecd26f  
    44  NSModuleHelperInit 
    55  NSLoadModule 
     6  NSLoadModuleEx 
    67  NSGetModuleName 
    78  NSGetModuleVersion 
    … …  
    1213  NSUnloadModule 
    1314  NSGetModuleDescription 
    14   NSCommandLineExec 
    15  
     15  NSDeleteBuffer 

  • modules/CheckTaskSched/CheckTaskSched.h

    r739db5a r1ecd26f  
    2828#include "TaskSched.h" 
    2929 
    30 class CheckTaskSched { 
     30class CheckTaskSched : public nscapi::impl::SimpleCommand, public nscapi::impl::simple_plugin { 
    3131private: 
    3232  std::wstring syntax; 
    … …  
    3434public: 
    3535  // Module calls 
    36   bool loadModule(NSCAPI::moduleLoadMode mode); 
     36  bool loadModule(); 
     37  bool loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode); 
    3738  bool unloadModule(); 
    3839 
    … …  
    4344    return _T("CheckTaskSched can check various file and disk related things.\nThe current version has commands to check Size of hard drives and directories."); 
    4445  } 
    45   NSCModuleWrapper::module_version getModuleVersion() { 
    46     NSCModuleWrapper::module_version version = {0, 0, 1 }; 
     46  nscapi::plugin_wrapper::module_version getModuleVersion() { 
     47    nscapi::plugin_wrapper::module_version version = {0, 0, 1 }; 
    4748    return version; 
    4849  } 
    … …  
    5051  bool hasCommandHandler(); 
    5152  bool hasMessageHandler(); 
    52   NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     53  NSCAPI::nagiosReturn handleCommand(const strEx::wci_string command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5354  int CheckTaskSched::commandLineExec(const TCHAR* command,const unsigned int argLen,TCHAR** args); 
    5455 
    5556  // Check commands 
    56   NSCAPI::nagiosReturn TaskSchedule(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     57  NSCAPI::nagiosReturn TaskSchedule(std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5758 
    5859 

  • modules/CheckTaskSched/stdafx.h

    r7f9c823 r1ecd26f  
    3434 
    3535#include <NSCAPI.h> 
    36 #include <NSCHelper.h> 
    37 #include <nsc_module_wrapper.hpp> 
     36#include <nscapi/plugin.hpp> 
     37#include <nscapi/nscapi_plugin_wrapper.hpp> 
    3838#include <checkHelpers.hpp> 
    3939#include <filter_framework.hpp> 

  • modules/CheckWMI/CheckWMI.cpp

    r5da0459 r1ecd26f  
    3030CheckWMI gCheckWMI; 
    3131 
    32 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) 
    33 { 
    34   NSCModuleWrapper::wrapDllMain(hModule, ul_reason_for_call); 
    35   return TRUE; 
    36 } 
    37  
    3832CheckWMI::CheckWMI() { 
    3933} 
    … …  
    4236 
    4337 
    44 bool CheckWMI::loadModule(NSCAPI::moduleLoadMode mode) { 
    45   try { 
    46     NSCModuleHelper::registerCommand(_T("CheckWMIValue"), _T("Run a WMI query and check the resulting value (the values of each row determin the state).")); 
    47     NSCModuleHelper::registerCommand(_T("CheckWMI"), _T("Run a WMI query and check the resulting rows (the number of hits determine state).")); 
    48   } catch (NSCModuleHelper::NSCMHExcpetion &e) { 
     38bool CheckWMI::loadModule() { 
     39  return false; 
     40} 
     41bool CheckWMI::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) { 
     42  try { 
     43    get_core()->registerCommand(_T("CheckWMIValue"), _T("Run a WMI query and check the resulting value (the values of each row determin the state).")); 
     44    get_core()->registerCommand(_T("CheckWMI"), _T("Run a WMI query and check the resulting rows (the number of hits determine state).")); 
     45  } catch (nscapi::nscapi_exception &e) { 
    4946    NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_); 
    5047  } catch (...) { 
    … …  
    7976  MAP_CHAINED_FILTER(value, numeric) 
    8077 
    81 NSCAPI::nagiosReturn CheckWMI::CheckSimpleWMI(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
     78NSCAPI::nagiosReturn CheckWMI::CheckSimpleWMI(std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf) { 
    8279  typedef checkHolders::CheckContainer<checkHolders::MaxMinBounds<checkHolders::NumericBounds<int, checkHolders::int_handler> > > WMIContainer; 
    8380 
    … …  
    8582  typedef filters::chained_filter<WMIQuery::wmi_filter,WMIQuery::wmi_row> filter_chain; 
    8683  filter_chain chain; 
    87   std::list<std::wstring> args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    88   if (args.empty()) { 
     84  if (arguments.empty()) { 
    8985    message = _T("Missing argument(s)."); 
    9086    return NSCAPI::returnCRIT; 
    … …  
    9995  WMIContainer result_query; 
    10096  try { 
    101     MAP_OPTIONS_BEGIN(args) 
     97    MAP_OPTIONS_BEGIN(arguments) 
    10298    MAP_OPTIONS_STR(_T("Query"), query) 
    10399    MAP_OPTIONS_STR2INT(_T("truncate"), truncate) 
    … …  
    169165} 
    170166 
    171 NSCAPI::nagiosReturn CheckWMI::CheckSimpleWMIValue(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf) { 
     167NSCAPI::nagiosReturn CheckWMI::CheckSimpleWMIValue(std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf) { 
    172168  typedef checkHolders::CheckContainer<checkHolders::MaxMinBounds<checkHolders::NumericBounds<long long, checkHolders::int64_handler> > > WMIContainer; 
    173   std::list<std::wstring> stl_args = arrayBuffer::arrayBuffer2list(argLen, char_args); 
    174   if (stl_args.empty()) { 
     169  if (arguments.empty()) { 
    175170    message = _T("ERROR: Missing argument exception."); 
    176171    return NSCAPI::returnUNKNOWN; 
    … …  
    188183  // MaxWarnNumeric:ID=>5 
    189184  try { 
    190     MAP_OPTIONS_BEGIN(stl_args) 
     185    MAP_OPTIONS_BEGIN(arguments) 
    191186      MAP_OPTIONS_SHOWALL(tmpObject) 
    192187      MAP_OPTIONS_NUMERIC_ALL(tmpObject, _T("")) 
    … …  
    269264 
    270265 
    271 NSCAPI::nagiosReturn CheckWMI::handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &msg, std::wstring &perf) { 
     266NSCAPI::nagiosReturn CheckWMI::handleCommand(const strEx::wci_string command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf) { 
    272267  if (command == _T("CheckWMI")) { 
    273     return CheckSimpleWMI(argLen, char_args, msg, perf); 
     268    return CheckSimpleWMI(arguments, message, perf); 
    274269  } else if (command == _T("CheckWMIValue")) { 
    275     return CheckSimpleWMIValue(argLen, char_args, msg, perf); 
     270    return CheckSimpleWMIValue(arguments, message, perf); 
    276271  }  
    277272  return NSCAPI::returnIgnored; 
    … …  
    340335 
    341336 
     337NSC_WRAP_DLL(); 
    342338NSC_WRAPPERS_MAIN_DEF(gCheckWMI); 
    343339NSC_WRAPPERS_IGNORE_MSG_DEF(); 
    344340NSC_WRAPPERS_HANDLE_CMD_DEF(gCheckWMI); 
    345 NSC_WRAPPERS_CLI_DEF(gCheckWMI); 
     341//NSC_WRAPPERS_CLI_DEF(gCheckWMI); 

  • modules/CheckWMI/CheckWMI.def

    r22d2739 r1ecd26f  
    44  NSModuleHelperInit 
    55  NSLoadModule 
     6  NSLoadModuleEx 
    67  NSGetModuleName 
    78  NSGetModuleVersion 
    … …  
    1213  NSUnloadModule 
    1314  NSGetModuleDescription 
    14   NSCommandLineExec 
    15  
     15  NSDeleteBuffer 

  • modules/CheckWMI/CheckWMI.h

    r5da0459 r1ecd26f  
    2828#include "WMIQuery.h" 
    2929 
    30 class CheckWMI { 
     30class CheckWMI : public nscapi::impl::SimpleCommand, public nscapi::impl::simple_plugin { 
    3131public: 
    3232  CheckWMI(); 
    3333  virtual ~CheckWMI(); 
    3434  // Module calls 
    35   bool loadModule(NSCAPI::moduleLoadMode mode); 
     35  bool loadModule(); 
     36  bool loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode); 
    3637  bool unloadModule(); 
    3738 
    … …  
    4243    return _T("CheckWMI can check various file and disk related things.\nThe current version has commands to check Size of hard drives and directories."); 
    4344  } 
    44   NSCModuleWrapper::module_version getModuleVersion() { 
    45     NSCModuleWrapper::module_version version = {0, 0, 1 }; 
     45  nscapi::plugin_wrapper::module_version getModuleVersion() { 
     46    nscapi::plugin_wrapper::module_version version = {0, 0, 1 }; 
    4647    return version; 
    4748  } 
    … …  
    4950  bool hasCommandHandler(); 
    5051  bool hasMessageHandler(); 
    51   NSCAPI::nagiosReturn handleCommand(const strEx::blindstr command, const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     52  NSCAPI::nagiosReturn handleCommand(const strEx::wci_string command, std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5253  int CheckWMI::commandLineExec(const TCHAR* command,const unsigned int argLen,TCHAR** args); 
    5354 
    5455  // Check commands 
    55   NSCAPI::nagiosReturn CheckSimpleWMI(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
    56   NSCAPI::nagiosReturn CheckSimpleWMIValue(const unsigned int argLen, TCHAR **char_args, std::wstring &message, std::wstring &perf); 
     56  NSCAPI::nagiosReturn CheckSimpleWMI(std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
     57  NSCAPI::nagiosReturn CheckSimpleWMIValue(std::list<std::wstring> arguments, std::wstring &message, std::wstring &perf); 
    5758 
    5859 

  • modules/CheckWMI/stdafx.h

    r7f9c823 r1ecd26f  
    3434 
    3535#include <NSCAPI.h> 
    36 #include <NSCHelper.h> 
    37 #include <nsc_module_wrapper.hpp> 
     36#include <nscapi/plugin.hpp> 
     37#include <nscapi/nscapi_plugin_wrapper.hpp> 
    3838#include <checkHelpers.hpp> 
    3939#include <filter_framework.hpp> 

  • modules/FileLogger/CMakeLists.txt

    rc0d7e82 r1ecd26f  
    3030  ${NSCP_DEF_PLUGIN_LIB} 
    3131) 
     32INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/FileLogger/FileLogger.cpp

    rf7663c9 r1ecd26f  
    136136  NSC_LOG_MESSAGE_STD(_T("Using logmask: ") + nscapi::logging::to_string(log_mask_)); 
    137137  init_ = true; 
    138   std::wstring hello = _T("Starting to log for: ") + GET_CORE()->getApplicationName() + _T(" - ") + GET_CORE()->getApplicationVersionString(); 
    139   handleMessage(NSCAPI::log, __FILEW__, __LINE__, hello.c_str()); 
    140   NSC_LOG_MESSAGE_STD(_T("Log path is: ") + to_wstring(file_)); 
     138  std::string hello = "Starting to log for: " + to_string(GET_CORE()->getApplicationName()) + " - " + to_string(GET_CORE()->getApplicationVersionString()); 
     139  handleMessage(NSCAPI::log, __FILE__, __LINE__, hello); 
     140  handleMessage(NSCAPI::log, __FILE__, __LINE__, "Log path is: " + file_); 
    141141  return true; 
    142142} 
    … …  
    173173*/ 
    174174 
    175 void FileLogger::handleMessage(int msgType, const wchar_t* file, int line, const TCHAR* message) { 
     175void FileLogger::handleMessage(int msgType, const std::string file, int line, std::string message) { 
    176176  if (!init_) { 
    177     std::wcout << _T("Discarding: ") << message << std::endl; 
     177    std::wcout << _T("Discarding: ") << to_wstring(message) << std::endl; 
    178178    return; 
    179179  } 
    … …  
    183183  std::ofstream stream(file_.c_str(), std::ios::out|std::ios::app|std::ios::ate); 
    184184  if (!stream) { 
    185     std::wcout << _T("File could not be opened, Discarding: ") << message << std::endl; 
     185    std::wcout << _T("File could not be opened, Discarding: ") << to_wstring(message) << std::endl; 
    186186  } 
    187187  stream << to_string(get_formated_date())  
    188188    << (": ") << to_string(nscapi::plugin_helper::translateMessageType(msgType)) 
    189     << (":") << to_string(std::wstring(file)) 
    190     <<(":") << to_string(line)  
    191     << (": ") << to_string(std::wstring(message)) << std::endl; 
     189    << (":") << file 
     190    <<(":") << line 
     191    << (": ") << message << std::endl; 
    192192} 
    193193 

  • modules/FileLogger/FileLogger.h

    r5e12ba6 r1ecd26f  
    2323NSC_WRAPPERS_MAIN(); 
    2424 
    25 class FileLogger : public nscapi::impl::simple_plugin { 
     25class FileLogger : public nscapi::impl::simple_plugin, public nscapi::impl::simple_log_handler { 
    2626private: 
    2727  std::string file_; 
    … …  
    5555  bool hasCommandHandler(); 
    5656  bool hasMessageHandler(); 
    57   void handleMessage(int msgType, const wchar_t* file, int line, const TCHAR* message); 
     57  void handleMessage(int msgType, const std::string file, int line, std::string message); 
    5858  int handleCommand(TCHAR* command, TCHAR **argument, TCHAR *returnBuffer, int returnBufferLen); 
    5959  //void writeEntry(std::wstring line); 

  • modules/NRPEClient/CMakeLists.txt

    r294b37b r1ecd26f  
    3636  ${OPENSSL_LIBRARIES} 
    3737) 
    38  
    39  
    40 #INSTALL(FILES ${PROJECT_SOURCE_DIR}/cmake/FindWt.cmake DESTINATION 
    41 #    ${CMAKE_INSTALL_PREFIX}/${WT_CMAKE_FINDER_INSTALL_DIR} ) 
    42  
     38INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/NRPEClient/NRPEClient.cpp

    r497b779 r1ecd26f  
    3131#include <nrpe/client/socket.hpp> 
    3232 
     33namespace sh = nscapi::settings_helper; 
    3334 
    3435NRPEClient gNRPEClient; 
    … …  
    4546 
    4647bool NRPEClient::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) { 
    47   std::list<std::wstring> commands; 
    48   buffer_length_ = SETTINGS_GET_INT(nrpe::PAYLOAD_LENGTH); 
    49   try { 
    50     SETTINGS_REG_PATH(nrpe::CH_SECTION); 
    51     commands = GET_CORE()->getSettingsSection(setting_keys::nrpe::CH_SECTION_PATH); 
    52   } catch (nscapi::nscapi_exception &e) { 
    53     NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_); 
    54   } catch (...) { 
    55     NSC_LOG_ERROR_STD(_T("Failed to register command.")); 
    56   } 
     48  std::map<std::wstring,std::wstring> commands; 
     49 
     50  try { 
     51 
     52    //"/settings/NRPE/client/handlers" 
     53    sh::settings_registry settings(nscapi::plugin_singleton->get_core()); 
     54    settings.set_alias(_T("NRPE"), alias, _T("client")); 
     55 
     56    settings.alias().add_path_to_settings() 
     57      (_T("EXTERNAL SCRIPT SECTION"), _T("Section for external scripts configuration options (CheckExternalScripts).")) 
     58 
     59      (_T("handlers"), sh::fun_values_path(boost::bind(&NRPEClient::addCommand, this, _1, _2)),  
     60      _T("CLIENT HANDLER SECTION"), _T("")) 
     61 
     62      ; 
     63 
     64    settings.alias().add_key_to_settings() 
     65 
     66      (_T("payload length"),  sh::uint_key(&buffer_length_, 1024), 
     67      _T("PAYLOAD LENGTH"), _T("Length of payload to/from the NRPE agent. This is a hard specific value so you have to \"configure\" (read recompile) your NRPE agent to use the same value for it to work.")) 
     68 
     69      ; 
     70 
     71 
     72    settings.register_all(); 
     73    settings.notify(); 
     74 
     75  } catch (...) { 
     76    NSC_LOG_ERROR_STD(_T("Exception caught: <UNKNOWN EXCEPTION>")); 
     77    return false; 
     78  } 
     79  return true; 
    5780 
    5881  boost::filesystem::wpath p = GET_CORE()->getBasePath() + std::wstring(_T("/security/nrpe_dh_512.pem")); 
    … …  
    6487  } 
    6588 
    66  
    67   for (std::list<std::wstring>::const_iterator it = commands.begin(); it != commands.end(); ++it) { 
    68     NSC_DEBUG_MSG_STD(*it); 
    69     std::wstring s = GET_CORE()->getSettingsString(setting_keys::nrpe::CH_SECTION_PATH, (*it), _T("")); 
    70     if (s.empty()) { 
    71       NSC_LOG_ERROR_STD(_T("Invalid NRPE-client entry: ") + (*it)); 
    72     } else { 
    73       addCommand((*it).c_str(), s); 
    74     } 
    75   } 
    7689  return true; 
    7790} 
    … …  
    91104 
    92105 
    93 void NRPEClient::addCommand(strEx::blindstr key, std::wstring args) { 
     106void NRPEClient::addCommand(std::wstring key, std::wstring args) { 
    94107  try { 
    95108 
    … …  
    119132 
    120133    NSC_DEBUG_MSG_STD(_T("Added NRPE Client: ") + key.c_str() + _T(" = ") + command_data.toString()); 
    121     commands[key] = command_data; 
     134    commands[key.c_str()] = command_data; 
    122135 
    123136    GET_CORE()->registerCommand(key.c_str(), command_data.toString()); 

  • modules/NRPEClient/NRPEClient.h

    r497b779 r1ecd26f  
    133133 
    134134private: 
    135   void addCommand(strEx::blindstr key, std::wstring args); 
     135  void addCommand(std::wstring key, std::wstring args); 
    136136 
    137137}; 

  • modules/NRPEServer/CMakeLists.txt

    r294b37b r1ecd26f  
    5050  ${OPENSSL_LIBRARIES} 
    5151) 
    52  
    53  
    54 #INSTALL(FILES ${PROJECT_SOURCE_DIR}/cmake/FindWt.cmake DESTINATION 
    55 #    ${CMAKE_INSTALL_PREFIX}/${WT_CMAKE_FINDER_INSTALL_DIR} ) 
    56  
     52INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/NRPEServer/handler_impl.hpp

    r497b779 r1ecd26f  
    3636  } 
    3737 
    38   void log_debug(std::wstring file, int line, std::wstring msg) { 
     38  void log_debug(std::string file, int line, std::wstring msg) { 
    3939    GET_CORE()->Message(NSCAPI::debug, file, line, msg); 
    4040  } 
    41   void log_error(std::wstring file, int line, std::wstring msg) { 
     41  void log_error(std::string file, int line, std::wstring msg) { 
    4242    GET_CORE()->Message(NSCAPI::error, file, line, msg); 
    4343  } 

  • modules/NSCAAgent/CMakeLists.txt

    r86632db r1ecd26f  
    4545  ${EXTRA_LIBS} 
    4646) 
     47INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 

  • modules/Scheduler/CMakeLists.txt

    r3080680 r1ecd26f  
    3232  ${NSCP_DEF_PLUGIN_LIB} 
    3333) 
     34INCLUDE(${BUILD_CMAKE_FOLDER}/module.cmake) 
Note: See TracChangeset for help on using the changeset viewer.