Changeset 74e060a in nscp

Timestamp:

03/19/12 07:46:22 (14 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

822454f

Parents:

c88cf98

Message:

• Added new command to EventLog? CheckEventlogCached? which checks result caught by the real-time process. CheckEventLogCACHE warn=gt:1 crit=gt:5 Requires a configured real-time checker to work.
• Fixed issue in installer and "Make file writable" by everyone now uses Users SID.
• Fixed issue in installer and "Default plugins" now correctly sets them to 1.
• Removed dependency on tcpip from the service and the installer
• Added a series of keywords to EventLog? check to facilitate better checking
• Added a set of aliases to make EventLog? behave more like Wdinwos Eventlog viewer.
• Added a lot of unit test cases to the Eventlog checker.
• Fixed issue with default schedule beeing added as an item and not a template

Files:

• changelog (modified) (1 diff)
• helpers/installer-dlls/main_dll/main_dll.cpp (modified) (4 diffs)
• helpers/installer-dlls/main_dll/main_dll.def (modified) (1 diff)
• helpers/installers/installer/Product.wxs (modified) (4 diffs)
• include/nscapi/settings_object.hpp (modified) (1 diff)
• include/pdh/collectors.hpp (modified) (1 diff)
• include/pdh/counters.hpp (modified) (1 diff)
• libs/dotnet-plugin-api/CMakeLists.txt (modified) (2 diffs)
• modules/CheckEventLog/CheckEventLog.cpp (modified) (11 diffs)
• modules/CheckEventLog/CheckEventLog.h (modified) (4 diffs)
• modules/CheckEventLog/eventlog_record.hpp (modified) (4 diffs)
• modules/CheckEventLog/filter.cpp (modified) (4 diffs)
• modules/CheckEventLog/filter.hpp (modified) (1 diff)
• modules/DotnetPlugins/CMakeLists.txt (modified) (2 diffs)
• modules/GraphiteClient/GraphiteClient.cpp (modified) (16 diffs)
• modules/GraphiteClient/GraphiteClient.def (modified) (1 diff)
• modules/GraphiteClient/GraphiteClient.h (modified) (7 diffs)
• modules/GraphiteClient/module.cmake (modified) (1 diff)
• scripts/python/test_eventlog.py (modified) (5 diffs)
• version.hpp (modified) (1 diff)
• version.txt (modified) (1 diff)

changelog

@@ -4 +4 @@
  * Fixa dependonservice LanManWorkStation (old win)
  * Fix RtlStringFromGUID problem on NT4
+
+2012-03-19 MickeM
+ * Fixed issue in installer and "Make file writable" by everyone now uses Users SID.
+ * Fixed issue in installer and "Default plugins" now correctly sets them to 1.
+ 
+2012-03-18 MickeM
+ * Removed dependency on tcpip from the service and the installer
+ * Added new command to EventLog CheckEventlogCached which checks result caught by the real-time process.
+   CheckEventLogCACHE warn=gt:1 crit=gt:5
+   Requires a configured real-time checker to work.
+ * Added a series of keywords to EventLog check to facilitate better checking
+ * Added a set of aliases to make EventLog behave more like Wdinwos Eventlog viewer.
+ * Added a lot of unit test cases to the Eventlog checker.
+ * Fixed issue with default schedule beeing added as an item and not a template
 
 2012-03-11 MickeM

helpers/installer-dlls/main_dll/main_dll.cpp

@@ +1 @@
+#define _WIN32_WINNT 0x0500
 #include <windows.h>
 #include <msi.h>
@@ -10 +11 @@
 #include <file_helpers.hpp>
 #include "installer_helper.hpp"
+#include <Sddl.h>
 #include "../../settings_manager/settings_manager_impl.h"
 
@@ -305 +307 @@
 
     if (h.propertyTouched(_T("CONF_CHECKS"))) {
+      modval = h.getPropery(_T("CONF_CHECKS"));
       write_key(data, 1, modpath, _T("CheckSystem"), modval);
       write_key(data, 1, modpath, _T("CheckDisk"), modval);
@@ -459 +462 @@
   return ERROR_SUCCESS;
 };
+
+
+extern "C" UINT __stdcall TranslateSid (MSIHANDLE hInstall) {
+  TCHAR szSid[MAX_PATH] = {0};
+  TCHAR szSidProperty[MAX_PATH] = {0};
+  TCHAR szName[MAX_PATH] = {0};
+  DWORD size = MAX_PATH;
+  UINT ret = 0;
+  ret = MsiGetProperty (hInstall, _T("TRANSLATE_SID"), szSid, &size);
+
+  if(ret != ERROR_SUCCESS) {
+    return 4444;
+  }
+
+  size = MAX_PATH;
+  ret = MsiGetProperty (hInstall, _T("TRANSLATE_SID_PROPERTY"), szSidProperty, &size);
+
+  if(ret != ERROR_SUCCESS) {
+    return 4445;
+  }
+
+  PSID pSID = NULL;
+
+  if(!ConvertStringSidToSid(szSid, &pSID)) {
+    return 4446;
+  }
+
+  size = MAX_PATH;
+  TCHAR szRefDomain[MAX_PATH] = {0};
+  SID_NAME_USE nameUse;
+  DWORD refSize = MAX_PATH;
+  if(!LookupAccountSid(NULL, pSID, szName, &size, szRefDomain, &refSize, &nameUse)) {
+    if(pSID != NULL) {
+      LocalFree(pSID);
+    }
+    return 4447;
+  }
+
+  ret = MsiSetProperty (hInstall, szSidProperty, szName);
+  if(!ConvertStringSidToSid(szSid, &pSID)) {
+    if(pSID != NULL) {
+      LocalFree(pSID);
+    }
+    return 4448;
+  }
+
+  if(pSID != NULL) {
+    LocalFree(pSID);
+  }
+  return ERROR_SUCCESS;
+}
+

helpers/installer-dlls/main_dll/main_dll.def

@@ -6 +6 @@
   ExecWriteConfig
   NeedUninstall
+  TranslateSid

helpers/installers/installer/Product.wxs

@@ -50 +50 @@
               Description="Monitoring agent for nagios (and others) used to respond to status queries"
               Arguments="service --run --name [SERVICE_NAME]">
+              <!--
               <ServiceDependency Id="Tcpip" />
+                  -->
             </ServiceInstall>
             <ServiceControl Id="StartSWCNSCP" Name="[SERVICE_NAME]" Start="install" Stop="both" Wait="yes" Remove="uninstall" />
@@ -81 +83 @@
           <Component Id="SampleConfigUser" Guid="AA636DB0-A0B9-4dd2-B74C-$(var.Postfix.GUID)" Win64="$(var.Win64)">
             <File Id="NSClientINIUser" Name="nsclient.ini" DiskId="1" Source="$(var.Path.ini)/nsclient.dist" Vital="no" PatchIgnore="yes">
-              <Permission User="Everyone" GenericRead="yes" Read="yes" GenericWrite="yes" Write="yes"/>
+              <Permission User="[USERGROUP_USERS]" GenericRead="yes" Read="yes" GenericWrite="yes" Write="yes"/>
             </File>
             <RemoveFile Id="PurgeConfigFilesUser" Name="*.ini" On="uninstall" />
@@ -300 +302 @@
     <CustomAction Id="GenConfig" BinaryKey="WixCA" DllEntry="CAQuietExec" Impersonate="no" Return="ignore" Execute="deferred"/>
 
-    <Binary Id='InstallerHelper' SourceFile='$(var.Helpers)/main_dll.dll' />
+    <CustomAction Id="SetUserGroupUsers" Property="TRANSLATE_SID" Value="S-1-5-32-545" Return="check" />
+    <CustomAction Id="SetUserGroupUsersProp" Property="TRANSLATE_SID_PROPERTY" Value="USERGROUP_USERS" Return="check" />
+    <CustomAction Id="TranslateUserGroupUsers" BinaryKey="InstallerHelper" DllEntry="TranslateSid"/>
+
+    <Binary Id='InstallerHelper' SourceFile='$(var.Helpers)/main_dll.dll' />
 
     <InstallExecuteSequence>
@@ -308 +314 @@
       <Custom Action="GenConfig.Command" After="ScheduleWriteConfig">NOT REMOVE AND INSTALL_SAMPLE_CONFIG = 1</Custom>
       <Custom Action="GenConfig" After="GenConfig.Command">NOT REMOVE AND INSTALL_SAMPLE_CONFIG = 1</Custom>
-    </InstallExecuteSequence>
+
+      <Custom Action="SetUserGroupUsers" After="LaunchConditions">NOT Installed</Custom>
+      <Custom Action="SetUserGroupUsersProp" After="SetUserGroupUsers">NOT Installed</Custom>
+      <Custom Action="TranslateUserGroupUsers" After="SetUserGroupUsersProp">NOT Installed</Custom>
+
+    </InstallExecuteSequence>
 
     <InstallUISequence>

include/nscapi/settings_object.hpp

@@ -65 +65 @@
           optional_object tmp = find_object(object.parent);
           if (!tmp) {
-            parent = add(proxy, path, object.parent, _T(""));
-            add_template(parent);
+            parent = add(proxy, path, object.parent, _T(""), true);
           } else {
             parent = *tmp;

include/pdh/collectors.hpp

@@ -299 +299 @@
     DWORD extra_format;
     RoundINTPDHBufferListenerImpl() : buffer(NULL), length(0), current(0), hasValue_(false), parent_(NULL), extra_format(0) {}
-    RoundINTPDHBufferListenerImpl(int length_) : buffer(NULL), length(0), current(0), hasValue_(false), parent_(NULL) {
+    RoundINTPDHBufferListenerImpl(int length_) : buffer(NULL), length(0), current(0), hasValue_(false), parent_(NULL), extra_format(0) {
       resize(length_);
     }

include/pdh/counters.hpp

@@ -107 +107 @@
       if (!listener_)
         return;
-      PDH::PDHError status = PDH::PDHFactory::get_impl()->PdhGetFormattedCounterValue(hCounter_, listener_->getFormat(), NULL, &data_);
+      DWORD format = listener_->getFormat();
+      PDH::PDHError status = PDH::PDHFactory::get_impl()->PdhGetFormattedCounterValue(hCounter_, format, NULL, &data_);
       if (status.is_error()) {
-        throw PDHException(name_, _T("PdhGetFormattedCounterValue failed"), status);
+        throw PDHException(name_, _T("PdhGetFormattedCounterValue failed {format: ") + strEx::itos(format) + _T("}"), status);
       }
       listener_->collect(*this);

libs/dotnet-plugin-api/CMakeLists.txt

@@ -14 +14 @@
   STRING(REPLACE "/EHsc" "/EHa" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
   STRING(REPLACE "/MT" "/MD" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+  STRING(REPLACE "/MT" "/MD" CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
+  STRING(REPLACE "/MT" "/MD" CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_CXX_FLAGS_MINSIZEREL})
   STRING(REPLACE "/MTd" "/MDd" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
   STRING(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
@@ -22 +24 @@
   MESSAGE(STATUS "---> DOT NET FLAGS: ${CMAKE_CXX_FLAGS_DEBUG}")
   MESSAGE(STATUS "---> DOT NET FLAGS: ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
+  MESSAGE(STATUS "---> DOT NET FLAGS: ${CMAKE_CXX_FLAGS_MINSIZEREL}")
   
   ADD_LIBRARY(NSCPDOTNET MODULE ${SRCS})

modules/CheckEventLog/CheckEventLog.cpp

@@ -160 +160 @@
     NSC_LOG_ERROR(_T("Failed to submit evenhtlog result: ") + response);
   }
+
+  if (cache_) {
+    boost::unique_lock<boost::timed_mutex> lock(cache_mutex_, boost::get_system_time() + boost::posix_time::seconds(5));
+    if (!lock.owns_lock()) {
+      NSC_LOG_ERROR(_T("ERROR: Could not get CheckEventLogCache mutex."));
+      return;
+    }
+    hit_cache_.push_back(message);
+  }
+}
+bool real_time_thread::check_cache(unsigned long &count, std::wstring &messages) {
+  if (!cache_) {
+    messages = _T("ERROR: Cache is not enabled!");
+    NSC_LOG_ERROR(messages);
+    return false;
+  }
+  boost::unique_lock<boost::timed_mutex> lock(cache_mutex_, boost::get_system_time() + boost::posix_time::seconds(5));
+  if (!lock.owns_lock()) {
+    messages = _T("ERROR: Could not get CheckEventLogCache mutex.");
+    NSC_LOG_ERROR(messages);
+    return false;
+  }
+  BOOST_FOREACH(const std::wstring &s, hit_cache_) {
+    if (!messages.empty())
+      messages += _T(", ");
+    messages += s;
+  }
+  count = hit_cache_.size();
+  hit_cache_.clear();
+  return true;
+}
+void real_time_thread::debug_miss(const EventLogRecord &record) {
+  std::wstring message = record.render(true, info.syntax, DATE_FORMAT, info.dwLang);
+  NSC_DEBUG_MSG_STD(_T("No filter matched: ") + message);
 }
 
 void real_time_thread::thread_proc() {
-  if (filters_.size() != 1) {
-    NSC_LOG_ERROR_STD(_T("Invalid filter size (for now)..."));
-    return;
-  }
-
-  eventlog_filter::filter_argument fargs = eventlog_filter::factories::create_argument(info.syntax, DATE_FORMAT);
-  fargs->filter = *filters_.begin();
-  fargs->debug = true;
-  eventlog_filter::filter_engine engine = eventlog_filter::factories::create_engine(fargs);
-
-
-
-  if (!engine) {
-    NSC_LOG_ERROR_STD(_T("No filter subsystem available"));
-    return;
-  }
-
-  if (!engine->boot()) {
-    NSC_LOG_ERROR_STD(_T("Error booting filters"));
-    return;
-  }
-
-  std::wstring message;
-  if (!engine->validate(message)) {
-    NSC_LOG_ERROR_STD(_T("Error validating session: ") + message);
-    return;
-  }
+
+  std::list<eventlog_filter::filter_engine> filters;
+  BOOST_FOREACH(std::wstring filter, filters_) {
+    eventlog_filter::filter_argument fargs = eventlog_filter::factories::create_argument(info.syntax, DATE_FORMAT);
+    fargs->filter = filter;
+    fargs->debug = true;
+    eventlog_filter::filter_engine engine = eventlog_filter::factories::create_engine(fargs);
+
+    if (!engine) {
+      NSC_LOG_ERROR_STD(_T("Invalid filter: ") + filter);
+      continue;
+    }
+
+    if (!engine->boot()) {
+      NSC_LOG_ERROR_STD(_T("Error booting filter: ") + filter);
+      continue;
+    }
+
+    std::wstring message;
+    if (!engine->validate(message)) {
+      NSC_LOG_ERROR_STD(_T("Error validating filter: ") + message);
+      continue;
+    }
+    filters.push_back(engine);
+  }
+
 
 
@@ -240 +273 @@
         EventLogRecord elr(el->get_name(), pevlr, ltime);
         boost::shared_ptr<eventlog_filter::filter_obj> arg = boost::shared_ptr<eventlog_filter::filter_obj>(new eventlog_filter::filter_obj(elr));
-
-        if (engine->match(arg)) {
-          process_record(elr);
-        } else if (fargs->debug) {
-          // TODO: Decrease timeout here so we get "ok" every x seconds even if we have ok results...
-          NSC_DEBUG_MSG(_T("Ignored record: ") + elr.render(true, fargs->syntax));
+        bool matched = false;
+
+        BOOST_FOREACH(eventlog_filter::filter_engine engine, filters) {
+          if (engine->match(arg)) {
+            process_record(elr);
+            matched = true;
+          }
         }
+        if (debug_ && !matched)
+          debug_miss(elr);
+
         pevlr = el->read_record_with_buffer();
       }
@@ -293 +330 @@
   try {
     register_command(_T("CheckEventLog"), _T("Check for errors in the event logger!"));
-    register_command(_T("check_event_log"), _T("Check for errors in the event logger!"));
     register_command(_T("check_eventlog"), _T("Check for errors in the event logger!"));
+    register_command(_T("checkeventlogcache"), _T("Check for errors in the event logger!"));
+    register_command(_T("check_eventlog_cache"), _T("Check for errors in the event logger!"));
 
     sh::settings_registry settings(get_settings_proxy());
     settings.set_alias(alias, _T("eventlog"));
+    
 
     settings.alias().add_path_to_settings()
@@ -304 +343 @@
       (_T("real-time"), _T("CONFIGURE REALTIME CHECKING"), _T("A set of options to configure the real time checks"))
 
-      (_T("real-time/filters"), sh::fun_values_path(boost::bind(&real_time_thread::add_realtime_filter, thread_, _1, _2)),  
+      (_T("real-time/filters"), sh::fun_values_path(boost::bind(&real_time_thread::add_realtime_filter, &thread_, _1, _2)),  
       _T("REALTIME FILTERS"), _T("A set of filters to use in real-time mode"))
       ;
@@ -348 +387 @@
       (_T("log"), sh::string_fun_key<std::wstring>(boost::bind(&real_time_thread::set_eventlog, &thread_, _1), _T("application")),
       _T("LOGS TO CHECK"), _T("Coma separated list of logs to check"))
+
+      (_T("debug"), sh::bool_key(&thread_.debug_, false),
+      _T("DEBUG"), _T("Log missed records (usefull to detect issues with filters) not usefull in production as it is a bit of a resource hog."))
+
+      (_T("enable active"), sh::bool_key(&thread_.cache_, false),
+      _T("ENABLE ACTIVE MONITORING"), _T("This will store all matches so you can use real-time filters from active monitoring (use CheckEventlogCache)."))
 
       ;
@@ -416 +461 @@
   }
 };
+typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsULongInteger> EventLogQuery1Container;
+typedef checkHolders::CheckContainer<checkHolders::ExactBoundsULongInteger> EventLogQuery2Container;
+
+NSCAPI::nagiosReturn CheckEventLog::checkCache(std::list<std::wstring> &arguments, std::wstring &message, std::wstring &perf) {
+
+  EventLogQuery1Container query1;
+  EventLogQuery2Container query2;
+  bool bPerfData = true;
+  unsigned int truncate = 0;
+  NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
+
+  try {
+    MAP_OPTIONS_BEGIN(arguments)
+      MAP_OPTIONS_NUMERIC_ALL(query1, _T(""))
+      MAP_OPTIONS_EXACT_NUMERIC_ALL(query2, _T(""))
+      MAP_OPTIONS_STR2INT(_T("truncate"), truncate)
+      MAP_OPTIONS_BOOL_FALSE(IGNORE_PERFDATA, bPerfData)
+      MAP_OPTIONS_MISSING(message, _T("Unknown argument: "))
+    MAP_OPTIONS_END()
+  } catch (checkHolders::parse_exception e) {
+    message = e.getMessage();
+    return NSCAPI::returnUNKNOWN;
+  } catch (...) {
+    message = _T("Invalid command line!");
+    return NSCAPI::returnUNKNOWN;
+  }
+
+  unsigned long count = 0;
+  if (!thread_.check_cache(count, message)) {
+    return NSCAPI::returnUNKNOWN;
+  }
+
+  if (!bPerfData) {
+    query1.perfData = false;
+    query2.perfData = false;
+  }
+  if (query1.alias.empty())
+    query1.alias = _T("eventlog");
+  if (query2.alias.empty())
+    query2.alias = _T("eventlog");
+  if (query1.hasBounds())
+    query1.runCheck(count, returnCode, message, perf);
+  else if (query2.hasBounds())
+    query2.runCheck(count, returnCode, message, perf);
+  else {
+    message = _T("No bounds specified!");
+    return NSCAPI::returnUNKNOWN;
+  }
+  if ((truncate > 0) && (message.length() > (truncate-4)))
+    message = message.substr(0, truncate-4) + _T("...");
+  if (message.empty())
+    message = _T("Eventlog check ok");
+  return returnCode;
+}
 
 NSCAPI::nagiosReturn CheckEventLog::handleCommand(const std::wstring &target, const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &message, std::wstring &perf) {
-  if (command != _T("checkeventlog"))
+  if (command == _T("checkeventlogcache") || command == _T("check_eventlog_cache"))
+    return checkCache(arguments, message, perf);
+  if (command != _T("checkeventlog") && command != _T("check_eventlog"))
     return NSCAPI::returnIgnored;
   simple_timer time;
-  typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsULongInteger> EventLogQuery1Container;
-  typedef checkHolders::CheckContainer<checkHolders::ExactBoundsULongInteger> EventLogQuery2Container;
   
   NSCAPI::nagiosReturn returnCode = NSCAPI::returnOK;
@@ -633 +732 @@
 
     bool help = false;
-    std::wstring type, category, severity, source_name;
+    std::wstring type, severity, source_name;
     std::vector<std::wstring> strings;
-    WORD wEventID;
+    WORD wEventID = 0, category = 0, customer = 0;
     WORD facility = 0;
     po::options_description desc("Allowed options");
@@ -642 +741 @@
       ("source,s", po::wvalue<std::wstring>(&source_name)->default_value(_T("Application Error")), "source to use")
       ("type,t", po::wvalue<std::wstring>(&type), "Event type")
-      ("facility,f", po::value<WORD>(&facility), "Facility")
+      ("level,l", po::wvalue<std::wstring>(&type), "Event level (type)")
+      ("facility,f", po::value<WORD>(&facility), "Facility/Qualifier")
+      ("qualifier,q", po::value<WORD>(&facility), "Facility/Qualifier")
       ("severity", po::wvalue<std::wstring>(&severity), "Event severity")
-      ("category,c", po::wvalue<std::wstring>(&category), "Event category")
+      ("category,c", po::value<WORD>(&category), "Event category")
+      ("customer", po::value<WORD>(&customer), "Customer bit 0,1")
       ("arguments,a", po::wvalue<std::vector<std::wstring> >(&strings), "Message arguments (strings)")
       ("eventlog-arguments", po::wvalue<std::vector<std::wstring> >(&strings), "Message arguments (strings)")
@@ -667 +769 @@
       WORD dwType = EventLogRecord::translateType(type);
       WORD wSeverity = EventLogRecord::translateSeverity(severity);
-      WORD dwCategory = EventLogRecord::translateType(category);
-      DWORD tID = (wEventID&0xffff) | (wSeverity<<30) | (facility<<16);
+      DWORD tID = (wEventID&0xffff) | ((facility&0xfff)<<16) | ((customer&0x1)<<29) | ((wSeverity&0x3)<<30);
 
       int size = 0;
@@ -680 +781 @@
       }
 
-      if (!ReportEvent(source, dwType, dwCategory, tID, NULL, strings.size(), 0, string_data, NULL)) {
+      if (!ReportEvent(source, dwType, category, tID, NULL, strings.size(), 0, string_data, NULL)) {
         message = _T("Could not report the event"); 
         return NSCAPI::hasFailed;
@@ -691 +792 @@
     NSC_LOG_ERROR_STD(_T("Failed to parse command line: ") + utf8::cvt<std::wstring>(e.what()));
   }
-
-
   return NSCAPI::returnIgnored;
 }

modules/CheckEventLog/CheckEventLog.h

@@ -53 +53 @@
   HANDLE stop_event_;
   std::list<std::wstring> lists_;
+  std::list<std::wstring> hit_cache_;
+  boost::timed_mutex cache_mutex_;
 
-  real_time_thread() : enabled_(false), start_age_(0), max_age_(0) {
+  bool cache_;
+  bool debug_;
+
+  real_time_thread() : enabled_(false), start_age_(0), max_age_(0), debug_(false), cache_(false) {
     set_start_age(_T("30m"));
     set_max_age(_T("5m"));
@@ -77 +82 @@
   void set_language(std::string lang);
   void set_filter(std::wstring flt) {
-    if (!flt.empty())
-      add_realtime_filter(_T("filter"), flt);
+    add_realtime_filter(_T("filter"), flt);
   }
   bool has_filters() {
@@ -86 +90 @@
   bool stop();
 
+  bool check_cache(unsigned long &count, std::wstring &messages);
+
   void thread_proc();
 //  void process_events(eventlog_filter::filter_engine engine, eventlog_wrapper &eventlog);
   void process_no_events();
   void process_record(const EventLogRecord &record);
+  void debug_miss(const EventLogRecord &record);
 //  void process_event(eventlog_filter::filter_engine engine, const EVENTLOGRECORD* record);
 };
@@ -125 +132 @@
   bool hasMessageHandler();
   NSCAPI::nagiosReturn handleCommand(const std::wstring &target, const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &message, std::wstring &perf);
+  NSCAPI::nagiosReturn checkCache(std::list<std::wstring> &arguments, std::wstring &message, std::wstring &perf);
   NSCAPI::nagiosReturn commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &response);
   NSCAPI::nagiosReturn insert_eventlog(std::vector<std::wstring> arguments, std::wstring &message);

modules/CheckEventLog/eventlog_record.hpp

@@ -24 +24 @@
     return pevlr_->TimeWritten;
   }
+  inline WORD category() const {
+    return pevlr_->EventCategory;
+  }
   inline std::wstring get_source() const {
     return reinterpret_cast<const WCHAR*>(reinterpret_cast<const BYTE*>(pevlr_) + sizeof(EVENTLOGRECORD));
@@ -35 +38 @@
   }
   inline DWORD severity() const {
-    return (pevlr_->EventID>>30);
+    return (pevlr_->EventID>>30) & 0x3;
+  }
+  inline DWORD facility() const {
+    return (pevlr_->EventID>>16) & 0xfff;
+  }
+  inline WORD customer() const {
+    return (pevlr_->EventID>>29) & 0x1;
+  }
+  inline DWORD raw_id() const {
+    return pevlr_->EventID;
   }
 
@@ -274 +286 @@
     return get_time(pevlr_->TimeWritten);
   }
+  inline std::wstring get_log() {
+    return file_;
+  }
 
   std::wstring render(bool propper, std::wstring syntax, std::wstring date_format = DATE_FORMAT, DWORD langId = 0) const {
@@ -290 +305 @@
     strEx::replace(syntax, _T("%written-raw%"), strEx::itos(pevlr_->TimeWritten));
     strEx::replace(syntax, _T("%type%"), translateType(eventType()));
+    strEx::replace(syntax, _T("%category%"), strEx::itos(pevlr_->EventCategory));
+    strEx::replace(syntax, _T("%facility%"), strEx::itos(facility()));
+    strEx::replace(syntax, _T("%qualifier%"), strEx::itos(facility()));
+    strEx::replace(syntax, _T("%customer%"), strEx::itos(customer()));
+    strEx::replace(syntax, _T("%rawid%"), strEx::itos(raw_id()));
     strEx::replace(syntax, _T("%severity%"), translateSeverity(severity()));
     strEx::replace(syntax, _T("%strings%"), enumStrings());
+    strEx::replace(syntax, _T("%log%"), file_);
+    strEx::replace(syntax, _T("%file%"), file_);
     strEx::replace(syntax, _T("%id%"), strEx::itos(eventID()));
     strEx::replace(syntax, _T("%user%"), userSID());

modules/CheckEventLog/filter.cpp

@@ -48 +48 @@
     (_T("id"), (type_int))
     (_T("source"), (type_string))
+    (_T("file"), (type_string))
+    (_T("log"), (type_string))
     (_T("type"), (type_custom_type))
+    (_T("level"), (type_custom_type))
     (_T("severity"), (type_custom_severity))
+    (_T("category"), (type_int))
+    (_T("qualifier"), (type_int))
+    (_T("facility"), (type_int))
+    (_T("customer"), (type_int))
+    (_T("rawid"), (type_int))
     (_T("message"), (type_string))
     (_T("strings"), (type_string))
@@ -83 +91 @@
   else if (key == _T("computer"))
     ret = &filter_obj::get_computer;
+  else if (key == _T("log"))
+    ret = &filter_obj::get_log;
+  else if (key == _T("file"))
+    ret = &filter_obj::get_log;
   else
     NSC_DEBUG_MSG_STD(_T("Failed to bind (string): ") + key);
@@ -93 +105 @@
   else if (key == _T("type"))
     ret = &filter_obj::get_el_type;
+  else if (key == _T("level"))
+    ret = &filter_obj::get_el_type;
   else if (key == _T("severity"))
     ret = &filter_obj::get_severity;
@@ -99 +113 @@
   else if (key == _T("written"))
     ret = &filter_obj::get_written;
+  else if (key == _T("category"))
+    ret = &filter_obj::get_category;
+  else if (key == _T("qualifier"))
+    ret = &filter_obj::get_facility;
+  else if (key == _T("facility"))
+    ret = &filter_obj::get_facility;
+  else if (key == _T("customer"))
+    ret = &filter_obj::get_customer;
+  else if (key == _T("rawid"))
+    ret = &filter_obj::get_raw_id;
   else
     NSC_DEBUG_MSG_STD(_T("Failed to bind (int): ") + key);

modules/CheckEventLog/filter.hpp

@@ -50 +50 @@
       return record.enumStrings(); 
     }
+    std::wstring get_log() {
+      return record.get_log(); 
+    }
     long long get_written() {
       return record.written(); 
+    }
+    long long get_category() {
+      return record.category(); 
+    }
+    long long get_facility() {
+      return record.facility(); 
+    }
+    long long get_customer() {
+      return record.customer(); 
+    }
+    long long get_raw_id() {
+      return record.raw_id(); 
     }
     long long get_generated() {

modules/DotnetPlugins/CMakeLists.txt

@@ -33 +33 @@
 STRING(REPLACE "/EHsc" "/EHa" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 STRING(REPLACE "/MT" "/MD" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+STRING(REPLACE "/MT" "/MD" CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
+STRING(REPLACE "/MT" "/MD" CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_CXX_FLAGS_MINSIZEREL})
 STRING(REPLACE "/MTd" "/MDd" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
 STRING(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
@@ -38 +40 @@
 STRING(REPLACE "/GZ" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /clr /FU ${BUILD_TARGET_EXE_PATH}/NSCPDOTNET.dll")
+
 ADD_LIBRARY(${TARGET} MODULE ${SRCS})
 

modules/GraphiteClient/GraphiteClient.cpp

@@ -20 +20 @@
 ***************************************************************************/
 #include "stdafx.h"
-#include "NSCAClient.h"
+#include "GraphiteClient.h"
 
 #include <utils.h>
 #include <strEx.h>
 
-#include <nsca/nsca_enrypt.hpp>
-#include <nsca/nsca_packet.hpp>
-#include <nsca/nsca_socket.hpp>
-
 #include <settings/client/settings_client.hpp>
+#include <nscapi/nscapi_protobuf_functions.hpp>
 
 namespace sh = nscapi::settings_helper;
 
+const std::wstring GraphiteClient::command_prefix = _T("graphite");
 /**
  * Default c-tor
  * @return 
  */
-NSCAAgent::NSCAAgent() {}
+GraphiteClient::GraphiteClient() {}
 
 /**
@@ -43 +41 @@
  * @return 
  */
-NSCAAgent::~NSCAAgent() {}
+GraphiteClient::~GraphiteClient() {}
 
 /**
@@ -50 +48 @@
  * @return true
  */
-bool NSCAAgent::loadModule() {
+bool GraphiteClient::loadModule() {
   return false;
 }
-/*
-DEFINE_SETTING_S(REPORT_MODE, NSCA_SERVER_SECTION, "report", "all");
-DESCRIBE_SETTING(REPORT_MODE, "REPORT MODE", "What to report to the server (any of the following: all, critical, warning, unknown, ok)");
-*/
-
-bool NSCAAgent::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
-
-
-  std::wstring encryption, password, nscahost;
-  std::string delay;
-  unsigned int timeout = 30, payload_length = 512, nscaport = 5666;
+
+bool GraphiteClient::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
+
   try {
+
     sh::settings_registry settings(get_settings_proxy());
-    settings.set_alias(_T("NSCA"), alias, _T("client"));
+    settings.set_alias(_T("graphite"), alias, _T("client"));
     target_path = settings.alias().get_settings_path(_T("targets"));
 
     settings.alias().add_path_to_settings()
-      (_T("NSCA CLIENT SECTION"), _T("Section for NSCA passive check module."))
-
-      (_T("handlers"), sh::fun_values_path(boost::bind(&NSCAAgent::add_command, this, _1, _2)), 
+      (_T("GRAPHITE CLIENT SECTION"), _T("Section for graphite passive check module."))
+
+      (_T("handlers"), sh::fun_values_path(boost::bind(&GraphiteClient::add_command, this, _1, _2)), 
       _T("CLIENT HANDLER SECTION"), _T(""))
 
-      (_T("targets"), sh::fun_values_path(boost::bind(&NSCAAgent::add_target, this, _1, _2)), 
+      (_T("targets"), sh::fun_values_path(boost::bind(&GraphiteClient::add_target, this, _1, _2)), 
       _T("REMOTE TARGET DEFINITIONS"), _T(""))
       ;
 
     settings.alias().add_key_to_settings()
-      (_T("hostname"), sh::string_key(&hostname_),
-      _T("HOSTNAME"), _T("The host name of this host if set to blank (default) the windows name of the computer will be used."))
-
       (_T("channel"), sh::wstring_key(&channel_, _T("NSCA")),
       _T("CHANNEL"), _T("The channel to listen to."))
-
-      (_T("delay"), sh::string_fun_key<std::wstring>(boost::bind(&NSCAAgent::set_delay, this, _1), _T("0")),
-      _T("DELAY"), _T(""))
       ;
 
@@ -94 +79 @@
       ;
 
-    settings.alias().add_key_to_settings(_T("targets/default"))
-
-      (_T("timeout"), sh::uint_key(&timeout, 30),
-      _T("TIMEOUT"), _T("Timeout when reading packets on incoming sockets. If the data has not arrived withint this time we will bail out."))
-
-      (_T("host"), sh::wstring_key(&nscahost),
-      _T("NSCA HOST"), _T("The NSCA server to report results to."))
-
-      (_T("port"), sh::uint_key(&nscaport, 5667),
-      _T("NSCA PORT"), _T("The NSCA server port"))
-
-      (_T("encryption"), sh::wstring_key(&encryption, _T("aes")),
-      _T("ENCRYPTION METHOD"), _T("Number corresponding to the various encryption algorithms (see the wiki). Has to be the same as the server or it wont work at all."))
-
-      (_T("password"), sh::wstring_key(&password),
-      _T("PASSWORD"), _T("The password to use. Again has to be the same as the server or it wont work at all."))
-
-      (_T("payload length"), sh::uint_key(&payload_length, 512),
-      _T("PAYLOAD LENGTH"), _T("Length of payload to/from the NSCA agent. This is a hard specific value so you have to \"configure\" (read recompile) your NSCA agent to use the same value for it to work."))
-
-      (_T("time offset"), sh::string_key(&delay, "0"),
-      _T("TIME OFFSET"), _T("Time offset."))
-      ;
-
     settings.register_all();
     settings.notify();
 
+    targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
+
+
     get_core()->registerSubmissionListener(get_id(), channel_);
 
-    if (!targets.has_target(_T("default"))) {
-      add_target(_T("default"), _T("default"));
-      targets.rebuild();
-    }
-    nscapi::target_handler::optarget t = targets.find_target(_T("default"));
-    if (t) {
-      if (!t->has_option("encryption"))
-        t->options[_T("encryption")] = encryption;
-      if (!t->has_option("timeout"))
-        t->options[_T("timeout")] = strEx::itos(timeout);
-      if (!t->has_option("payload length"))
-        t->options[_T("payload length")] = strEx::itos(payload_length);
-      if (!t->has_option("time offset"))
-        t->options[_T("time offset")] = utf8::cvt<std::wstring>(delay);
-      if (!t->has_option("password"))
-        t->options[_T("password")] = password;
-      if (!t->address.empty())
-        t->address = _T("nsca://") + nscahost + _T(":") + strEx::itos(nscaport);
-      targets.add(*t);
-    } else {
-      NSC_LOG_ERROR(_T("Default target not found!"));
-    }
+    register_command(_T("nsca_query"), _T("Check remote NRPE host"));
+    register_command(_T("nsca_submit"), _T("Submit (via query) remote NRPE host"));
+    register_command(_T("nsca_forward"), _T("Forward query to remote NRPE host"));
+    register_command(_T("nsca_exec"), _T("Execute (via query) remote NRPE host"));
+    register_command(_T("nsca_help"), _T("Help on using NRPE Client"));
+
 
   } catch (nscapi::nscapi_exception &e) {
@@ -159 +107 @@
 }
 
-std::wstring NSCAAgent::getCryptos() {
-  std::wstring ret = _T("{");
-  for (int i=0;i<LAST_ENCRYPTION_ID;i++) {
-    if (nsca::nsca_encrypt::hasEncryption(i)) {
-      std::wstring name;
-      try {
-        nsca::nsca_encrypt::any_encryption *core = nsca::nsca_encrypt::get_encryption_core(i);
-        if (core == NULL)
-          name = _T("Broken<NULL>");
-        else
-          name = utf8::to_unicode(core->getName());
-      } catch (nsca::nsca_encrypt::encryption_exception &e) {
-        name = utf8::to_unicode(e.what());
-      }
-      if (ret.size() > 1)
-        ret += _T(", ");
-      ret += strEx::itos(i) + _T("=") + name;
-    }
-  }
-  return ret + _T("}");
-}
-
 std::string get_command(std::string alias, std::string command = "") {
   if (!alias.empty())
@@ -193 +119 @@
 //
 
-void NSCAAgent::add_target(std::wstring key, std::wstring arg) {
+void GraphiteClient::add_target(std::wstring key, std::wstring arg) {
   try {
     targets.add(get_settings_proxy(), target_path , key, arg);
+  } catch (const std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
   } catch (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -201 +129 @@
 }
 
-void NSCAAgent::add_command(std::wstring name, std::wstring args) {
+void GraphiteClient::add_command(std::wstring name, std::wstring args) {
   try {
     std::wstring key = commands.add_command(name, args);
@@ -218 +146 @@
  * @return true if successfully, false if not (if not things might be bad)
  */
-bool NSCAAgent::unloadModule() {
+bool GraphiteClient::unloadModule() {
   return true;
 }
 
-NSCAPI::nagiosReturn NSCAAgent::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("syslog"));
+NSCAPI::nagiosReturn GraphiteClient::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::QueryRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  if (!client::command_line_parser::is_command(cmd))
-    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, result);
-  return commands.exec_simple(config, data.target, char_command, data.args, result);
-}
-
-NSCAPI::nagiosReturn NSCAAgent::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("syslog"));
-  if (!client::command_line_parser::is_command(cmd))
-    return NSCAPI::returnIgnored;
+  setup(config, message.header());
+
+  return commands.process_query(cmd, config, message, result);
+}
+
+NSCAPI::nagiosReturn GraphiteClient::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::ExecuteRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
-}
-
-NSCAPI::nagiosReturn NSCAAgent::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  setup(config, message.header());
+
+  return commands.process_exec(cmd, config, message, result);
+}
+
+NSCAPI::nagiosReturn GraphiteClient::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  Plugin::SubmitRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_relay_submit(config, request, result);
+  setup(config, message.header());
+
+  return client::command_line_parser::do_relay_submit(config, message, result);
 }
 
@@ -252 +188 @@
 //
 
-void NSCAAgent::add_local_options(po::options_description &desc, client::configuration::data_type data) {
+void GraphiteClient::add_local_options(po::options_description &desc, client::configuration::data_type data) {
   desc.add_options()
     ("encryption,e", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_string_data, &data->recipient, "encryption", _1)), 
@@ -271 +207 @@
 }
 
-void NSCAAgent::setup(client::configuration &config) {
-  boost::shared_ptr<clp_handler_impl> handler = boost::shared_ptr<clp_handler_impl>(new clp_handler_impl(this));
+void GraphiteClient::setup(client::configuration &config, const ::Plugin::Common_Header& header) {
+  boost::shared_ptr<clp_handler_impl> handler(new clp_handler_impl(this));
   add_local_options(config.local, config.data);
 
-  net::wurl url;
-  url.protocol = _T("nsca");
-  url.port = 5667;
-  nscapi::target_handler::optarget opt = targets.find_target(_T("default"));
+  config.data->recipient.id = header.recipient_id();
+  std::wstring recipient = utf8::cvt<std::wstring>(config.data->recipient.id);
+  if (!targets.has_object(recipient)) {
+    NSC_LOG_ERROR(_T("Target not found (using default): ") + recipient);
+    recipient = _T("default");
+  }
+  nscapi::targets::optional_target_object opt = targets.find_object(recipient);
+
   if (opt) {
-    nscapi::target_handler::target t = *opt;
-    url.host = t.host;
-    if (t.has_option("port")) {
-      try {
-        url.port = strEx::stoi(t.options[_T("port")]);
-      } catch (...) {}
+    nscapi::targets::target_object t = *opt;
+    nscapi::functions::destination_container def = t.to_destination_container();
+    config.data->recipient.apply(def);
     }
-    std::string keys[] = {"encryption", "timeout", "payload length", "password", "time offset"};
-    BOOST_FOREACH(std::string s, keys) {
-      config.data->recipient.data[s] = utf8::cvt<std::string>(t.options[utf8::cvt<std::wstring>(s)]);
-    }
-  }
-  config.data->recipient.id = "default";
-  config.data->recipient.address = utf8::cvt<std::string>(url.to_string());
   config.data->host_self.id = "self";
-  config.data->host_self.host = hostname_;
+  config.data->host_self.address.host = hostname_;
 
   config.target_lookup = handler;
@@ -301 +231 @@
 }
 
-NSCAAgent::connection_data NSCAAgent::parse_header(const ::Plugin::Common_Header &header) {
+GraphiteClient::connection_data GraphiteClient::parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data) {
   nscapi::functions::destination_container recipient, sender;
   nscapi::functions::parse_destination(header, header.recipient_id(), recipient, true);
   nscapi::functions::parse_destination(header, header.sender_id(), sender, true);
-  return connection_data(recipient, sender);
+  return connection_data(recipient, data->recipient, sender);
 }
 
@@ -312 +242 @@
 //
 
-int NSCAAgent::clp_handler_impl::query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::QueryRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+int GraphiteClient::clp_handler_impl::query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
 
   Plugin::QueryResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
-
-  std::list<nsca::packet> list;
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
+
+  std::list<g_data> list;
   for (int i=0;i < request_message.payload_size(); ++i) {
-    nsca::packet packet(con.sender_hostname, con.buffer_length, con.time_delta);
-    nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(request_message.payload(i));
-    packet.code = 0;
-    packet.result = utf8::cvt<std::string>(data.command);
-    list.push_back(packet);
+    g_data d;
+    d.path = "aaa";
+    d.value = "123";
+    list.push_back(d);
   }
 
@@ -336 +264 @@
 }
 
-int NSCAAgent::clp_handler_impl::submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::SubmitRequestMessage message;
-  message.ParseFromString(request);
-  connection_data con = parse_header(*header);
-  std::wstring channel = utf8::cvt<std::wstring>(message.channel());
+int GraphiteClient::clp_handler_impl::submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
+  std::wstring channel = utf8::cvt<std::wstring>(request_message.channel());
 
   Plugin::SubmitResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
-
-  std::list<nsca::packet> list;
-
-  for (int i=0;i < message.payload_size(); ++i) {
-    nsca::packet packet(con.sender_hostname, con.buffer_length, con.time_delta);
-    std::wstring alias, msg;
-    packet.code = nscapi::functions::parse_simple_submit_request_payload(message.payload(i), alias, msg);
-    if (alias != _T("host_check"))
-      packet.service = utf8::cvt<std::string>(alias);
-    packet.result = utf8::cvt<std::string>(msg);
-    list.push_back(packet);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
+
+  std::list<g_data> list;
+  for (int i=0;i < request_message.payload_size(); ++i) {
+    g_data d;
+    d.path = "aaa";
+    d.value = "123";
+    list.push_back(d);
   }
 
@@ -363 +286 @@
 }
 
-int NSCAAgent::clp_handler_impl::exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
-  Plugin::ExecuteRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+int GraphiteClient::clp_handler_impl::exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
+  connection_data con = parse_header(request_header, data);
 
   Plugin::ExecuteResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
-
-  std::list<nsca::packet> list;
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
+
+  std::list<g_data> list;
   for (int i=0;i < request_message.payload_size(); ++i) {
-    nsca::packet packet(con.sender_hostname, con.buffer_length, con.time_delta);
-    nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request_payload(request_message.payload(i));
-    packet.code = 0;
-    if (data.command != _T("host_check"))
-      packet.service = utf8::cvt<std::string>(data.command);
-    //packet.result = data.;
-    list.push_back(packet);
+    g_data d;
+    d.path = "aaa";
+    d.value = "123";
+    list.push_back(d);
   }
   boost::tuple<int,std::wstring> ret = instance->send(con, list);
@@ -391 +310 @@
 //
 
-boost::tuple<int,std::wstring> NSCAAgent::send(connection_data data, const std::list<nsca::packet> packets) {
+boost::tuple<int,std::wstring> GraphiteClient::send(connection_data data, const std::list<g_data> payload) {
   try {
     NSC_DEBUG_MSG_STD(_T("Connection details: ") + data.to_wstring());
+    
     boost::asio::io_service io_service;
-    nsca::socket socket(io_service);
-    socket.connect(data.host, data.port);
-    if (!socket.recv_iv(data.password, data.get_encryption(), boost::posix_time::seconds(data.timeout<5?30:data.timeout))) {
-      NSC_LOG_ERROR_STD(_T("Failed to read iv"));
-      return NSCAPI::hasFailed;
+    boost::asio::ip::tcp::resolver resolver(io_service);
+    boost::asio::ip::tcp::resolver::query query(data.host, data.port);
+    boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
+    boost::asio::ip::tcp::resolver::iterator end;
+
+    boost::asio::ip::tcp::socket socket(io_service);
+    boost::system::error_code error = boost::asio::error::host_not_found;
+    while(error && endpoint_iterator != end) {
+      socket.close();
+      socket.connect(*endpoint_iterator++, error);
     }
-    NSC_DEBUG_MSG_STD(_T("Got IV sending data: ") + strEx::itos(packets.size()));
-    BOOST_FOREACH(const nsca::packet &packet, packets) {
-      NSC_DEBUG_MSG_STD(_T("Sending: ") + utf8::cvt<std::wstring>(packet.to_string()));
-      socket.send_nsca(packet, boost::posix_time::seconds(data.timeout));
+    if(error)
+      throw boost::system::system_error(error);
+
+    boost::posix_time::ptime time_t_epoch(boost::gregorian::date(1970,1,1)); 
+    boost::posix_time::ptime now = boost::posix_time::microsec_clock::local_time();
+    boost::posix_time::time_duration diff = now - time_t_epoch;
+    int x = diff.total_milliseconds();
+
+    BOOST_FOREACH(const g_data &d, payload) {
+      std::string msg = d.path + " " +d.value + " " + boost::lexical_cast<std::string>(x) + "\n";
+      NSC_DEBUG_MSG_STD(_T("Sending: ") + utf8::cvt<std::wstring>(msg));
+      socket.send(boost::asio::buffer(msg));
     }
+    //socket.shutdown();
     return boost::make_tuple(NSCAPI::returnUNKNOWN, _T(""));
-  } catch (nsca::nsca_encrypt::encryption_exception &e) {
-    NSC_LOG_ERROR_STD(_T("NSCA Error: ") + utf8::to_unicode(e.what()));
-    return boost::make_tuple(NSCAPI::returnUNKNOWN, _T("NSCA error: ") + utf8::to_unicode(e.what()));
-  } catch (std::runtime_error &e) {
+  } catch (const std::runtime_error &e) {
     NSC_LOG_ERROR_STD(_T("Socket error: ") + utf8::to_unicode(e.what()));
     return boost::make_tuple(NSCAPI::returnUNKNOWN, _T("Socket error: ") + utf8::to_unicode(e.what()));
-  } catch (std::exception &e) {
+  } catch (const std::exception &e) {
     NSC_LOG_ERROR_STD(_T("Error: ") + utf8::to_unicode(e.what()));
     return boost::make_tuple(NSCAPI::returnUNKNOWN, _T("Error: ") + utf8::to_unicode(e.what()));
   } catch (...) {
+    NSC_LOG_ERROR_STD(_T("Unknown exception when sending NSCA data: "));
     return boost::make_tuple(NSCAPI::returnUNKNOWN, _T("Unknown error -- REPORT THIS!"));
   }
@@ -422 +354 @@
 
 NSC_WRAP_DLL();
-NSC_WRAPPERS_MAIN_DEF(NSCAAgent);
+NSC_WRAPPERS_MAIN_DEF(GraphiteClient);
 NSC_WRAPPERS_IGNORE_MSG_DEF();
 NSC_WRAPPERS_HANDLE_CMD_DEF();

modules/GraphiteClient/GraphiteClient.def

@@ -1 @@
-LIBRARY NSCAClient
+LIBRARY GraphiteClient
 
 EXPORTS

modules/GraphiteClient/GraphiteClient.h

@@ -25 +25 @@
 #include <client/command_line_parser.hpp>
 #include <nscapi/targets.hpp>
-
-#include <nsca/nsca_packet.hpp>
+#include <nscapi/nscapi_protobuf_types.hpp>
 
 NSC_WRAPPERS_MAIN();
@@ -33 +32 @@
 
 namespace po = boost::program_options;
-
-class NSCAAgent : public nscapi::impl::simple_plugin {
+namespace sh = nscapi::settings_helper;
+
+class GraphiteClient : public nscapi::impl::simple_plugin {
 private:
 
   std::wstring channel_;
   std::wstring target_path;
+  const static std::wstring command_prefix;
   std::string hostname_;
   bool cacheNscaHost_;
   long time_delta_;
 
-  nscapi::target_handler targets;
+  struct g_data {
+    std::string path;
+    std::string value;
+  };
+
+  struct custom_reader {
+    typedef nscapi::targets::target_object object_type;
+    typedef nscapi::targets::target_object target_object;
+
+    static void init_default(target_object &target) {
+      target.set_property_int(_T("timeout"), 30);
+      target.set_property_string(_T("encryption"), _T("ase"));
+      target.set_property_int(_T("payload length"), 512);
+    }
+
+    static void add_custom_keys(sh::settings_registry &settings, boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
+      settings.path(object.path).add_key()
+
+        (_T("timeout"), sh::int_fun_key<int>(boost::bind(&object_type::set_property_int, &object, _T("timeout"), _1), 30),
+        _T("TIMEOUT"), _T("Timeout when reading/writing packets to/from sockets."))
+
+        (_T("payload length"),  sh::int_fun_key<int>(boost::bind(&object_type::set_property_int, &object, _T("payload length"), _1), 512),
+        _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."))
+
+        (_T("encryption"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("encryption"), _1), _T("aes")),
+        _T("ENCRYPTION METHOD"), _T("Number corresponding to the various encryption algorithms (see the wiki). Has to be the same as the server or it wont work at all."))
+
+        (_T("password"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("password"), _1), _T("")),
+        _T("PASSWORD"), _T("The password to use. Again has to be the same as the server or it wont work at all."))
+
+        (_T("time offset"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("delay"), _1), _T("0")),
+        _T("TIME OFFSET"), _T("Time offset."))
+        ;
+    }
+    static void post_process_target(target_object &target) {
+    }
+  };
+
+  nscapi::targets::handler<custom_reader> targets;
   client::command_manager commands;
 
@@ -55 +94 @@
     int time_delta;
 
-    connection_data(nscapi::functions::destination_container recipient, nscapi::functions::destination_container sender) {
+    connection_data(nscapi::protobuf::types::destination_container recipient, nscapi::protobuf::types::destination_container target, nscapi::protobuf::types::destination_container sender) {
+      recipient.import(target);
       timeout = recipient.get_int_data("timeout", 30);
       buffer_length = recipient.get_int_data("payload length", 512);
       password = recipient.get_string_data("password");
       encryption = recipient.get_string_data("encryption");
+      std::string tmp = recipient.get_string_data("time offset");
+      if (!tmp.empty())
       time_delta = strEx::stol_as_time_sec(recipient.get_string_data("time offset"));
-      net::url url = recipient.get_url(5667);
-      host = url.host;
-      port = url.get_port();
+      else
+        time_delta = 0;
+      host = recipient.address.get_host();
+      port = strEx::s::itos(recipient.address.get_port(5667));
+      sender_hostname = sender.address.host;
+      if (sender.has_data("host"))
       sender_hostname = sender.get_string_data("host");
-    }
-    unsigned int get_encryption() {
-      return nsca::nsca_encrypt::helpers::encryption_to_int(encryption);
     }
 
@@ -85 +127 @@
   struct clp_handler_impl : public client::clp_handler, client::target_lookup_interface {
 
-    NSCAAgent *instance;
-    clp_handler_impl(NSCAAgent *instance) : instance(instance) {}
-
-    int query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-
-    virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
-      nscapi::functions::destination_container ret;
-      nscapi::target_handler::optarget t = instance->targets.find_target(id);
-      if (t) {
-        if (!t->alias.empty())
-          ret.id = utf8::cvt<std::string>(t->alias);
-        if (!t->host.empty())
-          ret.host = utf8::cvt<std::string>(t->host);
-        if (t->has_option("address"))
-          ret.address = utf8::cvt<std::string>(t->options[_T("address")]);
-        else 
-          ret.address = utf8::cvt<std::string>(t->host);
-        BOOST_FOREACH(const nscapi::target_handler::target::options_type::value_type &kvp, t->options) {
-          ret.data[utf8::cvt<std::string>(kvp.first)] = utf8::cvt<std::string>(kvp.second);
-        }
-      }
+    GraphiteClient *instance;
+    clp_handler_impl(GraphiteClient *instance) : instance(instance) {}
+
+    int query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply);
+    int submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply);
+    int exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply);
+
+    virtual nscapi::protobuf::types::destination_container lookup_target(std::wstring &id) {
+      nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
+      if (opt)
+        return opt->to_destination_container();
+      nscapi::protobuf::types::destination_container ret;
       return ret;
     }
@@ -114 +145 @@
 
 public:
-  NSCAAgent();
-  virtual ~NSCAAgent();
+  GraphiteClient();
+  virtual ~GraphiteClient();
   // Module calls
   bool loadModule();
@@ -141 +172 @@
   }
   static std::wstring getModuleDescription() {
-    return std::wstring(_T("Passive check support (needs NSCA on nagios server).\nAvalible crypto are: ")) + getCryptos();
+    return std::wstring(_T("Graphite client"));
   }
 
@@ -152 +183 @@
 
 private:
-  boost::tuple<int,std::wstring> send(connection_data data, const std::list<nsca::packet> packets);
+  boost::tuple<int,std::wstring> send(connection_data data, const std::list<g_data> payload);
   void add_options(po::options_description &desc, connection_data &command_data);
-  static connection_data parse_header(const ::Plugin::Common_Header &header);
+  static connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:
   void add_local_options(po::options_description &desc, client::configuration::data_type data);
-  void setup(client::configuration &config);
+  void setup(client::configuration &config, const ::Plugin::Common_Header& header);
   void add_command(std::wstring key, std::wstring args);
   void add_target(std::wstring key, std::wstring args);

modules/GraphiteClient/module.cmake

@@ -1 @@
-SET (BUILD_MODULE 0)
+SET (BUILD_MODULE 1)
 
 

scripts/python/test_eventlog.py

@@ -17 +17 @@
   last_perfdata = None
   got_simple_response = None
+  message_count = 0
   
   class SingletonHelper:
@@ -51 +52 @@
     self.last_status = status
     self.last_message = message
+    self.message_count = self.message_count + 1
     self.last_perfdata = perf
     return True
@@ -57 +59 @@
     None
 
-  def test_create(self, source, id, severity, category, arguments):
+  def test_create(self, source, id, level, severity, category, facility, arguments):
     self.last_message = None
+    self.message_count = 0
     args = ['--source', source, 
           '--id', id,
+          '--level', level,
           '--severity', severity,
-          '--category', category
+          '--category', category,
+          '--facility', facility
           ]
     for f in arguments:
@@ -69 +74 @@
     (ret, msg) = Core.get().simple_exec('any', 'insert-eventlog', args)
     return ret == 0
+    
+    
+  def test_w_expected(self, filter, syntax, expected):
+    result = TestResult('Validating filter: %s'%filter)
+    (res, msg, perf) = Core.get().simple_query('CheckEventLog', ['file=Application', 'debug=true', 'warn=ne:%d'%expected, 'crit=ne:%d'%expected, 'filter=%s'%filter, 'syntax=%s'%syntax])
+    result.assert_equals(res, status.OK, "Validate status OK for %s"%filter)
+    (res, msg, perf) = Core.get().simple_query('CheckEventLog', ['file=Application', 'debug=true', 'warn=eq:%d'%expected, 'crit=ne:%d'%expected, 'filter=%s'%filter, 'syntax=%s'%syntax])
+    result.assert_equals(res, status.WARNING, "Validate status OK for %s"%filter)
+    (res, msg, perf) = Core.get().simple_query('CheckEventLog', ['file=Application', 'debug=true', 'warn=eq:%d'%expected, 'crit=eq:%d'%expected, 'filter=%s'%filter, 'syntax=%s'%syntax])
+    result.assert_equals(res, status.CRITICAL, "Validate status CRIT for %s"%filter)
+    return result
 
+  def test_syntax(self, filter, syntax, expected):
+    result = TestResult('Validating syntax: %s'%syntax)
+    (res, msg, perf) = Core.get().simple_query('CheckEventLog', ['file=Application', 'warn=ne:1', 'filter=%s'%filter, 'syntax=%s'%syntax, 'descriptions'])
+    result.assert_equals(msg, expected, "Validate message rendering syntax: %s"%msg)
+    return result
+    
   def run_test(self):
-    result = TestResult()
-    result.add_message(self.test_create('Application Error', 1000, '0', 'error', ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']), 'Testing to create a log message')
+    result = TestResult('Checking CheckEventLog')
+    cache = TestResult('Checking CheckEventLog CACHE')
+    
+    (res, msg, perf) = Core.get().simple_query('CheckEventLogCACHE', ['warn=eq:1', 'crit=eq:2'])
+    cache.assert_equals(res, status.OK, "Validate cache is empty")
+    cache.assert_equals(msg, 'Eventlog check ok', "Validate cache is ok: %s"%msg)
+    
+    
+    a_list = ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
+    result.add_message(self.test_create('Application Error', 1000, 'error', 0, 0, 0, a_list), 'Testing to create a log message')
     sleep(500)
-    log(self.last_message)
-    log('%s'%self.last_message)
     result.assert_equals(self.last_message, 'error Application Error: ', 'Verify that message is sent through')
+    result.assert_equals(self.message_count, 1, 'Verify that onlyt one message is sent through')
+
+    result.add_message(self.test_create('Application Error', 1000, 'info', 2, 1, 5, a_list), 'Testing to create a log message')
+    sleep(500)
+    result.assert_equals(self.last_message, 'info Application Error: ', 'Verify that message is sent through')
+    result.assert_equals(self.message_count, 1, 'Verify that onlyt one message is sent through')
+
+    (res, msg, perf) = Core.get().simple_query('CheckEventLogCACHE', ['warn=eq:1', 'crit=eq:2'])
+    cache.assert_equals(res, status.CRITICAL, "Validate cache has items")
+    cache.assert_equals(msg, 'error Application Error: , info Application Error: , eventlog: 2 = critical', "Validate cache is ok: %s"%msg)
+    cache.assert_equals(perf, "'eventlog'=2;1;2", "Validate cache is ok: %s"%msg)
+    (res, msg, perf) = Core.get().simple_query('CheckEventLogCACHE', ['warn=eq:1', 'crit=eq:2'])
+    cache.assert_equals(res, status.OK, "Validate cache is empty (again)")
+    cache.assert_equals(msg, 'Eventlog check ok', "Validate cache is ok: %s"%msg)
     
-    (res, msg, perf) = Core.get().simple_query('CheckEventLog', ['file=Application', 'debug=true', 'warn=gt:1', 'filter=generated gt -2h', 'syntax=:%computer%:, %source%', 'descriptions'])
-    log('===>> %s <==='%msg)
-    result.add_message(self.test_create('Application Error', 1000, '0', 'error', ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']), 'Testing to create a log message')
+    result.add(cache)
     
+    r = TestResult('Checking filters')
+    r.add(self.test_w_expected('id = 1000 and generated gt 1m', '%generated%', 0))
+    r.add(self.test_w_expected('id = 1000 and generated gt -1m', '%generated%', 2))
+    r.add(self.test_w_expected('id = 1000 and generated gt -1m and id = 1000', '%generated%: %id%, %category%', 2))
+    r.add(self.test_w_expected('id = 1000 and generated gt -1m and category = 1', '%category%', 1))
+    r.add(self.test_w_expected('id = 1000 and generated gt -1m and category = 0', '%category%', 1))
+    r.add(self.test_w_expected("id = 1000 and generated gt -1m and level = 'error'", '%level%', 1))
+    r.add(self.test_w_expected("id = 1000 and generated gt -1m and level = 'info'", '%level%', 1))
+    result.add(r)
+    
+    r = TestResult('Checking syntax')
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 0', '%source% - %type% - %category%', 'Application Error - error - 0'))
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 1', '%source% - %type% - %category%', 'Application Error - info - 1'))
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 0', '%facility% - %qualifier% - %customer%', '0 - 0 - 0'))
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 1', '%facility% - %qualifier% - %customer%', '5 - 5 - 0'))
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 0', '%rawid% - %severity% - %log%', '1000 - success - Application'))
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 1', '%rawid% - %severity% - %log%', '2147812328 - warning - Application'))
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 0', '%id% - %strings%', '1000 - a, a, a, a, a, a, a, a, a, a, a, a, a, '))
+    r.add(self.test_syntax('id = 1000 and generated gt -2m and category = 1', '%id% - %strings%', '1000 - a, a, a, a, a, a, a, a, a, a, a, a, a, '))
+    result.add(r)
+
     return result
 
@@ -92 +153 @@
     
     conf.set_string('/settings/pytest_eventlog/real-time', 'enabled', 'true')
-    #conf.set_string('/settings/pytest_eventlog/real-time', 'filter', 'generated gt -2h')
+    conf.set_string('/settings/pytest_eventlog/real-time', 'filter', 'id = 1000 and category = 0')
+    conf.set_string('/settings/pytest_eventlog/real-time/filters', 'test', 'id = 1000 and category = 1')
     conf.set_string('/settings/pytest_eventlog/real-time', 'maximum age', '5s')
     conf.set_string('/settings/pytest_eventlog/real-time', 'destination', 'pytest_evlog')
     conf.set_string('/settings/pytest_eventlog/real-time', 'language', 'english')
+    conf.set_string('/settings/pytest_eventlog/real-time', 'debug', 'true')
+    conf.set_string('/settings/pytest_eventlog/real-time', 'enable active', 'true')
     
     conf.save()

version.hpp

@@ -1 +1 @@
 #ifndef VERSION_HPP
 #define VERSION_HPP
-#define PRODUCTVER     0,4,0,140
-#define STRPRODUCTVER  "0,4,0,140"
-#define STRPRODUCTDATE "2012-02-22"
+#define PRODUCTVER     0,4,0,145
+#define STRPRODUCTVER  "0,4,0,145"
+#define STRPRODUCTDATE "2012-03-18"
 #endif // VERSION_HPP

version.txt

@@ -1 +1 @@
 version=0.4.0
-build=140
-date=2012-02-22
+build=145
+date=2012-03-18