Changeset 523576e in nscp

Timestamp:

02/19/12 22:44:34 (15 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

72eea1f

Parents:

c710cc7

Message:

• Added new unit context on command line for running simple unit test cases: nscp unit --language python --script test_nsca
• Added dependency on Tcpip
• Dropped OS bit-match requirement so now you can install any version on x64 plattform.
• Added so you can specify multiple counters for CheckCounter and poll them all in one go (#387)
• Added test cases (a bit flaky) for counters.
• Added ${host} and ${domain} to hostname settings option which might be used to construct your own hostname. (#428) Not 100% sure about domain as on my box the "hostname" is only a name ie. has no domain...
• Fixed so too long log messages are trunacated instead of discarded
• Added option to truncate logfile if to large (#358) logger max size = 1000
• Added keyword to reload (settings) to reload settings store (ie. flushing the cache) (#249).
• Added ability to load all files in a given directory (#366)
• Tweaked a bit in regards to ExternalScripts? so it works better and handles errors better (#367)
• Fixed default report mode in 0.4.0 (#290)
• Made NSCA Client handle timestamps like send_nsca (ie. ignoring local time)

Files:

• changelog (modified) (1 diff)
• helpers/installers/installer/Product.wxs (modified) (2 diffs)
• include/execute_process_w32.hpp (modified) (1 diff)
• include/nsca/nsca_packet.hpp (modified) (2 diffs)
• include/nsca/nsca_socket.hpp (modified) (3 diffs)
• include/nscapi/functions.hpp (modified) (1 diff)
• include/pdh/enumerations.hpp (modified) (2 diffs)
• include/settings/settings_ini.hpp (modified) (3 diffs)
• include/strEx.h (modified) (1 diff)
• modules/CheckExternalScripts/CheckExternalScripts.cpp (modified) (4 diffs)
• modules/CheckExternalScripts/CheckExternalScripts.h (modified) (1 diff)
• modules/CheckExternalScripts/commands.hpp (modified) (1 diff)
• modules/CheckSystem/CheckSystem.cpp (modified) (11 diffs)
• modules/CheckSystem/CheckSystem.def (modified) (1 diff)
• modules/CheckSystem/CheckSystem.h (modified) (2 diffs)
• modules/FileLogger/FileLogger.cpp (modified) (10 diffs)
• modules/FileLogger/FileLogger.h (modified) (3 diffs)
• modules/NSCAClient/NSCAClient.cpp (modified) (1 diff)
• modules/Scheduler/Scheduler.cpp (modified) (1 diff)
• modules/Scheduler/schedules.hpp (modified) (1 diff)
• scripts/python/test_w32_system.py (modified) (3 diffs)
• service/NSClient++.cpp (modified) (1 diff)
• service/cli_parser.hpp (modified) (7 diffs)
• service/logger.hpp (modified) (7 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-02-19 MickeM
+ * Added new unit context on command line for running simple unit test cases:
+   nscp unit --language python --script test_nsca
+ * Added dependency on Tcpip
+ * Dropped OS bit-match requirement so now you can install any version on x64 plattform.
+ * Added so you can specify multiple counters for CheckCounter and poll them all in one go (#387)
+ * Added test cases (a bit flaky) for counters.
+ * Added ${host} and ${domain} to hostname settings option which might be used to construct your own hostname. (#428)
+   Not 100% sure about domain as on my box the "hostname" is only a name ie. has no domain...
+
+2012-02-18 MickeM
+ * Fixed so too long log messages are trunacated instead of discarded
+ * Added option to truncate logfile if to large (#358)
+   [/settings/file logger]
+   max size = 1000
+ * Added keyword to reload (settings) to reload settings store (ie. flushing the cache) (#249).
+ * Added ability to load all files in a given directory (#366)
+
+2012-02-17 MickeM
+ * Tweaked a bit in regards to ExternalScripts so it works better and handles errors better (#367)
+ * Fixed default report mode in 0.4.0 (#290)
+ * Made NSCA Client handle timestamps like send_nsca (ie. ignoring local time)
 
 2012-02-16 MickeM

helpers/installers/installer/Product.wxs

@@ -30 +30 @@
 
     <?if "$(var.arch)" = "x64"?>
-      <Condition Message="Win32 bit version not supported (by installer) on x64 bit platform (get x64 bit version instead)">VersionNT64</Condition>
-    <?else?>
       <Condition Message="x64 bit version not supported (by installer) on Win32 bit platform (get Win32 bit version instead)">NOT VersionNT64</Condition>
     <?endif?>
@@ -50 +48 @@
               Type="ownProcess" Start="auto" ErrorControl="normal" Interactive="no"
               Description="Monitoring agent for nagios (and others) used to respond to status queries"
-              Arguments="service --run --name [SERVICE_NAME]" />
+              Arguments="service --run --name [SERVICE_NAME]">
+        <ServiceDependency Id="Tcpip" />
+      </ServiceInstall>
             <ServiceControl Id="StartSWCNSCP" Name="[SERVICE_NAME]" Start="install" Stop="both" Wait="yes" Remove="uninstall" />
             <RemoveFolder Id="RemoveMenuShortcuts" Directory="ProgramMenuDir" On="uninstall" />

include/execute_process_w32.hpp

@@ -111 +111 @@
 
       dwAvail = 0;
-      if (!::PeekNamedPipe(hChildOutR, NULL, 0, NULL, &dwAvail, NULL))
-        NSC_LOG_ERROR_STD(_T("Failed to peek buffer: ") + error::lookup::last_error());
-      if (dwAvail > 0)
+      if (::PeekNamedPipe(hChildOutR, NULL, 0, NULL, &dwAvail, NULL) && dwAvail > 0)
         str += readFromFile(buffer, hChildOutR);
       msg = strEx::string_to_wstring(str);

include/nsca/nsca_packet.hpp

@@ -165 +165 @@
     }
 
-    void get_buffer(std::string &buffer) const {
+    void get_buffer(std::string &buffer, int servertime=0) const {
       nsca::data::data_packet *data = reinterpret_cast<nsca::data::data_packet*>(&*buffer.begin());
       if (buffer.size() < get_packet_length())
@@ -171 +171 @@
 
       data->packet_version=swap_bytes::hton<int16_t>(nsca::data::version3);
-      data->timestamp=swap_bytes::hton<u_int32_t>(time);
+      if (servertime != 0)
+        data->timestamp=swap_bytes::hton<u_int32_t>(servertime);
+      else
+        data->timestamp=swap_bytes::hton<u_int32_t>(time);
       data->return_code = swap_bytes::hton<int16_t>(code);
       data->crc32_value= swap_bytes::hton<u_int32_t>(0);

include/nsca/nsca_socket.hpp

@@ -18 +18 @@
     boost::asio::io_service &io_service_;
     nsca_encrypt crypt_inst;
+    int time;
   public:
     typedef boost::asio::basic_socket<tcp,boost::asio::stream_socket_service<tcp> >  basic_socket_type;
 
   public:
-    socket(boost::asio::io_service &io_service) : io_service_(io_service) {
+    socket(boost::asio::io_service &io_service) : io_service_(io_service), time(0) {
       socket_.reset(new tcp::socket(io_service_));
     }
@@ -72 +73 @@
       }
       std::string buffer = crypt_inst.get_rand_buffer(packet.get_packet_length());
-      packet.get_buffer(buffer);
+      packet.get_buffer(buffer, time);
       crypt_inst.encrypt_buffer(buffer);
       NSC_DEBUG_MSG(_T("Sending data: ") + strEx::itos(buffer.size()));
@@ -90 +91 @@
       nsca::iv_packet iv_packet(std::string(buf.begin(), buf.end()));
       std::string iv = iv_packet.get_iv();
+      time = iv_packet.get_time();
       NSC_DEBUG_MSG(_T("Encrypting using when sending: ") + utf8::cvt<std::wstring>(nsca::nsca_encrypt::helpers::encryption_to_string(encryption_method)) + _T(" and ") + utf8::cvt<std::wstring>(password));
       crypt_inst.encrypt_init(password, encryption_method, iv);

include/nscapi/functions.hpp

@@ -885 +885 @@
           Plugin::Common_PerformanceData_FloatValue fval = perfData.float_value();
 
-          ss << fval.value();
+          ss << strEx::s::itos_non_sci(fval.value());
           if (fval.has_unit())
             ss << fval.unit();

include/pdh/enumerations.hpp

@@ -43 +43 @@
     struct Object {
       std::wstring name;
+      std::string error;
       Instances instances;
       Counters counters;
@@ -71 +72 @@
       delete [] szObjectBuffer;
 
-      for (Objects::iterator it = ret.begin(); it != ret.end(); ++it) {
+      BOOST_FOREACH(Object &o, ret) {
         DWORD dwCounterBufLen = 0;
         TCHAR* szCounterBuffer = NULL;
         DWORD dwInstanceBufLen = 0;
         TCHAR* szInstanceBuffer = NULL;
-        status = PDH::PDHFactory::get_impl()->PdhEnumObjectItems(NULL, NULL, (*it).name.c_str(), szCounterBuffer, &dwCounterBufLen, szInstanceBuffer, &dwInstanceBufLen, dwDetailLevel, 0);
-        if (!status.is_more_data()) {
-          szCounterBuffer = new TCHAR[dwCounterBufLen+1024];
-          szInstanceBuffer = new TCHAR[dwInstanceBufLen+1024];
+        try {
+          status = PDH::PDHFactory::get_impl()->PdhEnumObjectItems(NULL, NULL, o.name.c_str(), szCounterBuffer, &dwCounterBufLen, szInstanceBuffer, &dwInstanceBufLen, dwDetailLevel, 0);
+          if (status.is_more_data()) {
+            szCounterBuffer = new TCHAR[dwCounterBufLen+1024];
+            szInstanceBuffer = new TCHAR[dwInstanceBufLen+1024];
 
-          status = PDH::PDHFactory::get_impl()->PdhEnumObjectItems(NULL, NULL, (*it).name.c_str(), szCounterBuffer, &dwCounterBufLen, szInstanceBuffer, &dwInstanceBufLen, dwDetailLevel, 0);
-          if (status.is_error()) {
+            status = PDH::PDHFactory::get_impl()->PdhEnumObjectItems(NULL, NULL, o.name.c_str(), szCounterBuffer, &dwCounterBufLen, szInstanceBuffer, &dwInstanceBufLen, dwDetailLevel, 0);
+            if (status.is_error()) {
+              delete [] szCounterBuffer;
+              delete [] szInstanceBuffer;
+              throw PDHException(_T("PdhEnumObjectItems failed when trying to retrieve buffer for ") + o.name, status);
+            }
+
+            if (dwCounterBufLen > 0) {
+              cp=szCounterBuffer;
+              while(*cp != '\0') {
+                Counter c;
+                c.name = cp;
+                o.counters.push_back(c);
+                cp += lstrlen(cp)+1;
+              }
+            }
+            if (dwInstanceBufLen > 0) {
+              cp=szInstanceBuffer;
+              while(*cp != '\0') {
+                Instance i;
+                i.name = cp;
+                o.instances.push_back(i);
+                cp += lstrlen(cp)+1;
+              }
+            }
             delete [] szCounterBuffer;
             delete [] szInstanceBuffer;
-            throw PDHException(_T("PdhEnumObjectItems failed when trying to retrieve buffer for ") + (*it).name, status);
           }
-
-          if (dwCounterBufLen > 0) {
-            cp=szCounterBuffer;
-            while(*cp != '\0') {
-              Counter o;
-              o.name = cp;
-              (*it).counters.push_back(o);
-              cp += lstrlen(cp)+1;
-            }
-          }
-          if (dwInstanceBufLen > 0) {
-            cp=szInstanceBuffer;
-            while(*cp != '\0') {
-              Instance o;
-              o.name = cp;
-              (*it).instances.push_back(o);
-              cp += lstrlen(cp)+1;
-            }
-          }
-          delete [] szCounterBuffer;
-          delete [] szInstanceBuffer;
+        } catch (std::exception &e) {
+          o.error = e.what();
+        } catch (...) {
+          o.error = "Exception fetching data";
         }
       }

include/settings/settings_ini.hpp

@@ -218 +218 @@
       if (is_loaded_)
         return;
+      if (boost::filesystem::is_directory(get_file_name())) {
+
+        boost::filesystem::wdirectory_iterator it(get_file_name()), eod;
+
+        BOOST_FOREACH(boost::filesystem::wpath const &p, std::make_pair(it, eod)) {
+          add_child(_T("ini:///") + p.string());
+        }
+      }
       if (!file_exists()) {
         is_loaded_ = true;
@@ -249 +257 @@
       if (filename_.empty()) {
         filename_ = get_file_from_context();
-        //filename_ = get_core()->get_base() / boost::filesystem::wpath(get_core()->get_boot_string(get_context(), _T("file"), _T("nsclient.ini")));
+        if (filename_.size() > 0) {
+          if (boost::filesystem::is_regular(filename_)) {
+          } else if (boost::filesystem::is_regular(filename_.substr(1))) {
+            filename_ = filename_.substr(1);
+          } else if (boost::filesystem::is_directory(filename_)) {
+          } else if (boost::filesystem::is_directory(filename_.substr(1))) {
+            filename_ = filename_.substr(1);
+          }
+        }
         get_core()->get_logger()->debug(__FILE__, __LINE__, _T("Reading INI settings from: ") + filename_);
       }
@@ -265 +281 @@
       std::wstring file = url.host + url.path;
       std::wstring tmp = core->expand_path(file);
-      return boost::filesystem::is_regular(tmp);
+      if (tmp.size()>1 && tmp[0] == '/') {
+        if (boost::filesystem::is_regular(tmp) || boost::filesystem::is_directory(tmp))
+          return true;
+        tmp = tmp.substr(1);
+      }
+      return boost::filesystem::is_regular(tmp) || boost::filesystem::is_directory(tmp);
     }
 

include/strEx.h

@@ -271 +271 @@
       return ss.str();
     }
+    inline std::string itos_non_sci(double i) {
+      std::stringstream ss;
+      if (i < 10)
+        ss.precision(20);
+      ss << std::noshowpoint << std::fixed << i;
+      std::string s = ss.str();
+      std::string::size_type pos = s.find_last_not_of('0');
+      if (pos == std::wstring::npos)
+        return s;
+      if (s[pos] != '.')
+        pos++;
+      return s.substr(0, pos);
+    }
   }
 

modules/CheckExternalScripts/CheckExternalScripts.cpp

@@ -81 +81 @@
 
     settings.alias().add_path_to_settings()
+
+      (_T("wrappings"), sh::wstring_map_path(&wrappings_)
+      , _T("EXTERNAL SCRIPT WRAPPINGS SECTION"), _T("A list of templates for wrapped scripts"))
+
+      ;
+
+    settings.register_all();
+    settings.notify();
+    settings.clear();
+
+    settings.alias().add_path_to_settings()
       (_T("EXTERNAL SCRIPT SECTION"), _T("Section for external scripts configuration options (CheckExternalScripts)."))
 
@@ -86 +97 @@
       _T("EXTERNAL SCRIPT SCRIPT SECTION"), _T("A list of scripts available to run from the CheckExternalScripts module. Syntax is: <command>=<script> <arguments>"))
 
-      (_T("wrappings"), sh::wstring_map_path(&wrappings_)
-      , _T("EXTERNAL SCRIPT WRAPPINGS SECTION"), _T("A list of templates for wrapped scripts"))
-
       (_T("alias"), sh::fun_values_path(boost::bind(&CheckExternalScripts::add_alias, this, _1, _2)), 
       _T("EXTERNAL SCRIPT ALIAS SECTION"), _T("A list of aliases available. An alias is an internal command that has been \"wrapped\" (to add arguments). Be careful so you don't create loops (ie check_loop=check_a, check_a=check_loop)"))
+
+      (_T("wrapped scripts"), sh::fun_values_path(boost::bind(&CheckExternalScripts::add_wrapping, this, _1, _2)), 
+      _T("EXTERNAL SCRIPT WRAPPED SCRIPTS SECTION"), _T("A list of wrappped scripts (ie. using the template mechanism)"))
 
       ;
@@ -108 +119 @@
       ;
 
-    settings.register_all();
-    settings.notify();
-    settings.clear();
-
-    settings.alias().add_path_to_settings()
-
-      (_T("wrapped scripts"), sh::fun_values_path(boost::bind(&CheckExternalScripts::add_wrapping, this, _1, _2)), 
-      _T("EXTERNAL SCRIPT WRAPPED SCRIPTS SECTION"), _T("A list of wrappped scripts (ie. using the template mechanism)"))
-
-      ;
     settings.register_all();
     settings.notify();
@@ -201 +202 @@
       }
     }
+  } else if (!allowArgs_ && data.args.size() > 0) {
+    NSC_LOG_ERROR_STD(_T("Arguments not allowed in CheckExternalScripts set /settings/external scripts/allow arguments=true"))
   }
 

modules/CheckExternalScripts/CheckExternalScripts.h

@@ -90 +90 @@
 
     std::wstring tpl = wrappings_[type];
+    if (tpl.empty() && type == _T("vbs"))
+      tpl = _T("cscript.exe //T:30 //NoLogo scripts\\lib\\wrapper.vbs %SCRIPT% %ARGS%");
+    else if (tpl.empty() && type == _T("ps1"))
+      tpl = _T("cmd /c echo scripts\\%SCRIPT% %ARGS%; exit($lastexitcode) | powershell.exe -command -");
+    else if (tpl.empty() && type == _T("bat"))
+      tpl = _T("scripts\\%SCRIPT% %ARGS%");
+    if (tpl.empty()) {
+      NSC_LOG_ERROR(_T("Failed to find wrapping for type: ") + type);
+    } else {
+      strEx::replace(tpl, _T("%SCRIPT%"), tok.first);
+      strEx::replace(tpl, _T("%ARGS%"), tok.second);
 
-    strEx::replace(tpl, _T("%SCRIPT%"), tok.first);
-    strEx::replace(tpl, _T("%ARGS%"), tok.second);
-
-    add_command(key,tpl);
+      add_command(key,tpl);
+    }
   }
 };

modules/CheckExternalScripts/commands.hpp

@@ -89 +89 @@
         NSC_LOG_ERROR(_T("Failed to parse arguments for command '") + alias + _T("', using old split string method: ") + utf8::to_unicode(e.what()));
         strEx::splitList list = strEx::splitEx(str, _T(" "));
+        if (list.size() > 0) {
+          command = list.front();
+          list.pop_front();
+        }
+        arguments.clear();
         BOOST_FOREACH(std::wstring s, list) {
           arguments.push_back(s);

modules/CheckSystem/CheckSystem.cpp

@@ -205 +205 @@
 }
 
-int CheckSystem::commandLineExec(const wchar_t* command,const unsigned int argLen,wchar_t** args) {
-  if (command == NULL) {
+int CheckSystem::commandLineExec(const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &result) {
+  if (command == _T("help")) {
     std::wcerr << _T("Usage: ... CheckSystem <command>") << std::endl;
     std::wcerr << _T("Commands: debugpdh, listpdh, pdhlookup, pdhmatch, pdhobject") << std::endl;
     return -1;
   }
-  if (_wcsicmp(command, _T("debugpdh")) == 0) {
+  if (command == _T("debugpdh")) {
     PDH::Enumerations::Objects lst;
     try {
@@ -334 +334 @@
       }
     }
-  } else if (_wcsicmp(command, _T("listpdh")) == 0) {
+  } else if (command == _T("listpdh")) {
+    bool porcelain = arguments.size() > 0 && arguments.front() == _T("--porcelain");
     PDH::Enumerations::Objects lst;
     try {
       lst = PDH::Enumerations::EnumObjects();
     } catch (const PDH::PDHException e) {
-      std::wcout << _T("Service enumeration failed: ") << e.getError();
-      return 0;
-    }
-    for (PDH::Enumerations::Objects::iterator it = lst.begin();it!=lst.end();++it) {
-      if ((*it).instances.size() > 0) {
-        for (PDH::Enumerations::Instances::const_iterator it2 = (*it).instances.begin();it2!=(*it).instances.end();++it2) {
-          for (PDH::Enumerations::Counters::const_iterator it3 = (*it).counters.begin();it3!=(*it).counters.end();++it3) {
-            std::wcout << _T("\\") << (*it).name << _T("(") << (*it2).name << _T(")\\") << (*it3).name << std::endl;;
+      result = _T("ERROR: Service enumeration failed: ") + e.getError();
+      return NSCAPI::returnUNKNOWN;
+    }
+    std::wstringstream ss;
+    BOOST_FOREACH(PDH::Enumerations::Object &obj, lst) {
+      if (!obj.error.empty()) {
+        ss << "error," << obj.name << "," << utf8::to_unicode(obj.error) << _T("\n");
+      } else if (obj.instances.size() > 0) {
+        BOOST_FOREACH(const PDH::Enumerations::Instance &inst, obj.instances) {
+          BOOST_FOREACH(const PDH::Enumerations::Counter &count, obj.counters) {
+            if (porcelain) 
+              ss << "counter," << obj.name << _T(",") << inst.name << _T(",") << count.name << _T("\n");
+            else
+              ss << _T("\\") << obj.name << _T("(") << inst.name << _T(")\\") << count.name << _T("\n");
           }
         }
       } else {
-        for (PDH::Enumerations::Counters::const_iterator it2 = (*it).counters.begin();it2!=(*it).counters.end();++it2) {
-          std::wcout << _T("\\") << (*it).name << _T("\\") << (*it2).name << std::endl;;
+        BOOST_FOREACH(const PDH::Enumerations::Counter &count, obj.counters) {
+          if (porcelain) 
+            ss << obj.name << _T(",") << count.name << _T("\n");
+          else
+            ss << _T("\\") << obj.name << _T("\\") << count.name << _T("\n");
         }
       }
     }
-  } else if (_wcsicmp(command, _T("pdhlookup")) == 0) {
+    result = ss.str();
+    return NSCAPI::returnOK;
+  } else if (command == _T("pdhlookup")) {
     try {
-      std::wstring name = array_buffer::arrayBuffer2string(args, argLen, _T(" "));
-      if (name.empty()) {
+      if (arguments.size() == 0) {
         NSC_LOG_ERROR_STD(_T("Need to specify counter index name!"));
         return 0;
       }
+      std::wstring name = arguments.front();
       DWORD dw = PDH::PDHResolver::lookupIndex(name);
       NSC_LOG_MESSAGE_STD(_T("--+--[ Lookup Result ]----------------------------------------"));
@@ -370 +382 @@
       return 0;
     }
-  } else if (_wcsicmp(command, _T("pdhmatch")) == 0) {
+  } else if (command == _T("pdhmatch")) {
     try {
-      std::wstring name = array_buffer::arrayBuffer2string(args, argLen, _T(" "));
-      if (name.empty()) {
-        NSC_LOG_ERROR_STD(_T("Need to specify counter pattern!"));
+      if (arguments.size() == 0) {
+        NSC_LOG_ERROR_STD(_T("Need to specify counter index name!"));
         return 0;
       }
+      std::wstring name = arguments.front();
       std::list<std::wstring> list = PDH::PDHResolver::PdhExpandCounterPath(name.c_str());
       NSC_LOG_MESSAGE_STD(_T("--+--[ Lookup Result ]----------------------------------------"));
@@ -387 +399 @@
       return 0;
     }
-  } else if (_wcsicmp(command, _T("pdhobject")) == 0) {
+  } else if (command == _T("pdhobject")) {
     try {
-      std::wstring name = array_buffer::arrayBuffer2string(args, argLen, _T(" "));
-      if (name.empty()) {
-        NSC_LOG_ERROR_STD(_T("Need to specify counter pattern!"));
+      if (arguments.size() == 0) {
+        NSC_LOG_ERROR_STD(_T("Need to specify counter index name!"));
         return 0;
       }
+      std::wstring name = arguments.front();
       PDH::Enumerations::pdh_object_details list = PDH::Enumerations::EnumObjectInstances(name.c_str());
       NSC_LOG_MESSAGE_STD(_T("--+--[ Lookup Result ]----------------------------------------"));
@@ -1195 +1207 @@
 }
 
+template<class T>
+class PerfDataContainer : public checkHolders::CheckContainer<T> {
+private:
+  typedef PDHCollectors::StaticPDHCounterListener<double, PDH_FMT_DOUBLE> counter_type;
+  typedef boost::shared_ptr<counter_type> ptr_lsnr_type;
+  ptr_lsnr_type cDouble;
+public:
+
+  PerfDataContainer() : CheckContainer<T>() {}
+
+  PerfDataContainer(const PerfDataContainer &other) : CheckContainer<T>(other), cDouble(other.cDouble) {}
+  const PerfDataContainer& operator =(const PerfDataContainer &other) {
+    *((CheckContainer<T>*)this) = other;
+    cDouble = other.cDouble;
+    return *this;
+  }
+  ptr_lsnr_type get_listener() {
+    if (!cDouble)
+      cDouble = ptr_lsnr_type(new counter_type());
+    return cDouble;
+  }
+};
 
 /**
@@ -1210 +1244 @@
 NSCAPI::nagiosReturn CheckSystem::checkCounter(std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf)
 {
-  typedef checkHolders::CheckContainer<checkHolders::MaxMinBoundsDouble> CounterContainer;
+  typedef PerfDataContainer<checkHolders::MaxMinBoundsDouble> CounterContainer;
 
   if (arguments.empty()) {
@@ -1260 +1294 @@
     return NSCAPI::returnUNKNOWN;
   }
-
-  for (std::list<CounterContainer>::const_iterator cit = counters.begin(); cit != counters.end(); ++cit) {
-    CounterContainer counter = (*cit);
+  PDH::PDHQuery pdh;
+
+  bool has_counter = false;
+  BOOST_FOREACH(CounterContainer &counter, counters) {
     try {
-
-
-      double value  = 0;
       if (counter.data.find('\\') == std::wstring::npos) {
-        PDHCollector *pObject = pdhThread.getThread();
-        if (!pObject) {
-          msg = _T("ERROR: PDH Collection thread not running.");
-          return NSCAPI::returnUNKNOWN;
-        }
+        /*
         value = pObject->get_double(counter.data);
         if (value == -1) {
@@ -1278 +1306 @@
           return NSCAPI::returnUNKNOWN;
         }
+        */
       } else {
         std::wstring tstr;
@@ -1293 +1322 @@
           }
         }
-        PDH::PDHQuery pdh;
-        typedef boost::shared_ptr<PDHCollectors::StaticPDHCounterListener<double, PDH_FMT_DOUBLE> > ptr_lsnr_type;
-        ptr_lsnr_type cDouble(new PDHCollectors::StaticPDHCounterListener<double, PDH_FMT_DOUBLE>());
-        //boost::shared_ptr<PDHCollectors::StaticPDHCounterListener<double, PDH_FMT_DOUBLE> > cDouble;
         if (!extra_format.empty()) {
           boost::char_separator<wchar_t> sep(_T(","));
@@ -1313 +1338 @@
             }
           }
-          cDouble->set_extra_format(flags);
+          counter.get_listener()->set_extra_format(flags);
         }
-        pdh.addCounter(counter.data, cDouble);
-        pdh.open();
-        if (bCheckAverages) {
-          pdh.collect();
-          Sleep(1000);
+        pdh.addCounter(counter.data, counter.get_listener());
+        has_counter = true;
+      }
+    } catch (const PDH::PDHException e) {
+      NSC_LOG_ERROR_STD(_T("ERROR: ") + e.getError() + _T(" (") + counter.getAlias() + _T("|") + counter.data + _T(")"));
+      if (bNSClient)
+        msg = _T("0");
+      else
+        msg = static_cast<std::wstring>(_T("ERROR: ")) + e.getError()+ _T(" (") + counter.getAlias() + _T("|") + counter.data + _T(")");
+      return NSCAPI::returnUNKNOWN;
+    }
+  }
+  if (has_counter) {
+    try {
+      pdh.open();
+      if (bCheckAverages) {
+        pdh.collect();
+        Sleep(1000);
+      }
+      pdh.collect();
+      pdh.gatherData();
+      pdh.close();
+    } catch (const PDH::PDHException e) {
+      NSC_LOG_ERROR_STD(_T("ERROR: ") + e.getError());
+      if (bNSClient)
+        msg = _T("0");
+      else
+        msg = _T("ERROR: ") + e.getError();
+      return NSCAPI::returnUNKNOWN;
+    }
+  }
+  BOOST_FOREACH(CounterContainer &counter, counters) {
+    try {
+      double value = 0;
+      if (counter.data.find('\\') == std::wstring::npos) {
+        PDHCollector *pObject = pdhThread.getThread();
+        if (!pObject) {
+          msg = _T("ERROR: PDH Collection thread not running.");
+          return NSCAPI::returnUNKNOWN;
         }
-        pdh.gatherData();
-        pdh.close();
-        value = cDouble->getValue();
-      }
-
+        value = pObject->get_double(counter.data);
+        if (value == -1) {
+          msg = _T("ERROR: Failed to get counter value: ") + counter.data;
+          return NSCAPI::returnUNKNOWN;
+        }
+      } else {
+        value = counter.get_listener()->getValue();
+      }
 
       if (bNSClient) {
@@ -1752 +1814 @@
 NSC_WRAPPERS_IGNORE_MSG_DEF();
 NSC_WRAPPERS_HANDLE_CMD_DEF();
-//NSC_WRAPPERS_CLI_DEF(gCheckSystem);
-
+NSC_WRAPPERS_CLI_DEF();

modules/CheckSystem/CheckSystem.def

@@ -13 +13 @@
   NSUnloadModule
   NSGetModuleDescription
+  NSCommandLineExec
   NSDeleteBuffer

modules/CheckSystem/CheckSystem.h

@@ -28 +28 @@
 NSC_WRAPPERS_CLI();
 
-class CheckSystem : public nscapi::impl::simple_command_handler, public nscapi::impl::simple_plugin {
+class CheckSystem : public nscapi::impl::simple_command_handler, public nscapi::impl::simple_plugin, public nscapi::impl::simple_command_line_exec {
 private:
   CheckMemory memoryChecker;
@@ -77 +77 @@
   bool hasMessageHandler();
   NSCAPI::nagiosReturn handleCommand(const std::wstring &target, const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &message, std::wstring &perf);
-  int commandLineExec(const wchar_t* command,const unsigned int argLen,wchar_t** args);
+  NSCAPI::nagiosReturn commandLineExec(const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &result);
 
   NSCAPI::nagiosReturn checkCPU(std::list<std::wstring> arguments, std::wstring &msg, std::wstring &perf);

modules/FileLogger/FileLogger.cpp

@@ -27 +27 @@
 
 #include <boost/date_time.hpp>
+#include <boost/filesystem.hpp>
 
 #include "FileLogger.h"
@@ -34 +35 @@
 #include <settings/client/settings_client.hpp>
 #include <settings/macros.h>
+#include <protobuf/plugin.pb.h>
 
 namespace sh = nscapi::settings_helper;
@@ -40 +42 @@
 }
 FileLogger::~FileLogger() {
-}
-namespace setting_keys {
-
-  namespace log {
-    DEFINE_PATH(SECTION, LOG_SECTION);
-    //DESCRIBE_SETTING_ADVANCED(SECTION, "LOG SECTION", "Configure loggning properties.");
-
-    DEFINE_SETTING_S(FILENAME, LOG_SECTION, "file", "nsclient.log");
-    //DESCRIBE_SETTING_ADVANCED(FILENAME, "SYNTAX", "The file to write log data to. If no directory is used this is relative to the NSClient++ binary.");
-
-    DEFINE_SETTING_S(ROOT, LOG_SECTION, "root", "auto");
-    //DESCRIBE_SETTING_ADVANCED(ROOT, "TODO", "TODO");
-
-    DEFINE_SETTING_S(DATEMASK, LOG_SECTION, "date format", "%Y-%m-%d %H:%M:%S");
-    //DESCRIBE_SETTING_ADVANCED(DATEMASK, "DATEMASK", "The date format used when logging to a file.");
-
-    DEFINE_SETTING_S(LOG_MASK, LOG_SECTION, "log mask", "normal");
-    //DESCRIBE_SETTING_ADVANCED(LOG_MASK, "LOG MASK", "The log mask information, error, warning, critical, debug");
-
-    DEFINE_SETTING_B(DEBUG_LOG, LOG_SECTION, "debug", false);
-    //DESCRIBE_SETTING_ADVANCED(DEBUG_LOG, "DEBUG LOGGING", "Enable debug logging can help track down errors and find problems but will impact overall perfoamnce negativly.");
-  }
 }
 
@@ -101 +81 @@
     file_ = utf8::cvt<std::string>(cfg_file_);
     if (file_.empty())
-      file_ = utf8::cvt<std::string>(setting_keys::log::FILENAME_DEFAULT);
+      file_ = "nsclient.log";
     if (file_.find("\\") == std::wstring::npos) {
       std::string root = utf8::cvt<std::string>(getFolder(cfg_root_));
@@ -123 +103 @@
 
     sh::settings_registry settings(get_settings_proxy());
-    settings.set_alias(_T("log"), alias);
+    settings.set_alias(_T("file logger"), alias);
 
     settings.alias().add_path_to_settings()
@@ -129 +109 @@
       ;
 
-    settings.alias().add_key_to_settings()
-      //(_T("debug"), sh::bool_key(&debug_, false),
-      //_T("DEBUG LOGGING"), _T("Enable debug logging can help track down errors and find problems but will impact overall performance negativly."))
-
-      (_T("log mask"), sh::wstring_key(&log_mask, _T("false")),
-      _T("LOG MASK"), _T("The log mask information, error, warning, critical, debug"))
+    settings.alias().add_parent(_T("/settings/log")).add_key_to_settings()
+      (_T("level"), sh::wstring_key(&log_mask, _T("info")),
+      _T("LOG LEVEL"), _T("The log level info, error, warning, critical, debug"))
 
       (_T("root"), sh::wstring_key(&cfg_root_, _T("auto")),
@@ -144 +121 @@
       (_T("date format"), sh::string_key(&format_, "%Y-%m-%d %H:%M:%S"),
       _T("DATEMASK"), _T("The size of the buffer to use when getting messages this affects the speed and maximum size of messages you can recieve."))
+
+      (_T("max size"), sh::int_key(&max_size_, 0),
+      _T("MAXIMUM FILE SIZE"), _T("When file size reaches this it will be truncated to 50% if set to 0 (default) truncation will be disabled"))
       ;
 
@@ -166 +146 @@
   init_ = true;
   std::string hello = "Starting to log for: " + utf8::cvt<std::string>(GET_CORE()->getApplicationName()) + " - " + utf8::cvt<std::string>(GET_CORE()->getApplicationVersionString());
-  handleMessage(NSCAPI::log_level::log, __FILE__, __LINE__, hello);
-  handleMessage(NSCAPI::log_level::log, __FILE__, __LINE__, "Log path is: " + file_);
+  log(NSCAPI::log_level::log, __FILE__, __LINE__, hello);
   return true;
 }
@@ -202 +181 @@
 */
 
-void FileLogger::handleMessage(int msgType, const std::string file, int line, std::string message) {
+void FileLogger::handleMessageRAW(std::string data) {
+  try {
+    Plugin::LogEntry message;
+    message.ParseFromString(data);
+
+    for (int i=0;i<message.entry_size();i++) {
+      Plugin::LogEntry::Entry msg = message.entry(i);
+      log(msg.level(), msg.file(), msg.line(), msg.message());
+    }
+  } catch (std::exception &e) {
+    std::cout << "Failed to parse data from: " << strEx::strip_hex(data) << e.what() <<  std::endl;;
+  } catch (...) {
+    std::cout << "Failed to parse data from: " << strEx::strip_hex(data) << std::endl;;
+  }
+}
+void FileLogger::log(int msgType, const std::string file, int line, std::string message) {
   if (!init_) {
     std::wcout << _T("Discarding: ") << utf8::cvt<std::wstring>(message) << std::endl;
@@ -210 +204 @@
     return;
 
+  if (max_size_ != 0 &&  boost::filesystem::exists(file_.c_str()) && boost::filesystem::file_size(file_.c_str()) > max_size_) {
+    int target_size = max_size_*0.7;
+    char *tmpBuffer = new char[target_size+1];
+    try {
+      std::ifstream ifs(file_.c_str());
+      ifs.seekg(-target_size, std::ios_base::end);  // One call to find it. . .
+      ifs.read(tmpBuffer, target_size);
+      ifs.close();
+      std::ofstream ofs(file_.c_str(), std::ios::trunc);
+      ofs.write(tmpBuffer, target_size);
+    } catch (...) {
+      std::cout << "Failed to truncate log file: " << file_ << std::endl;;
+    }
+    delete [] tmpBuffer;
+  }
   std::ofstream stream(file_.c_str(), std::ios::out|std::ios::app|std::ios::ate);
   if (!stream) {

modules/FileLogger/FileLogger.h

@@ -25 +25 @@
 NSC_WRAPPERS_MAIN();
 
-class FileLogger : public nscapi::impl::simple_plugin, public nscapi::impl::simple_log_handler {
+class FileLogger : public nscapi::impl::simple_plugin {
 private:
   std::string file_;
@@ -33 +33 @@
   std::wstring cfg_file_;
   std::wstring cfg_root_;
+  int max_size_;
 
 public:
@@ -57 +58 @@
   bool hasCommandHandler();
   bool hasMessageHandler();
-  void handleMessage(int msgType, const std::string file, int line, std::string message);
+  void handleMessageRAW(std::string data);
+  void log(int msgType, const std::string file, int line, std::string message);
   int handleCommand(wchar_t* command, wchar_t **argument, wchar_t *returnBuffer, int returnBufferLen);
   //void writeEntry(std::wstring line);

modules/NSCAClient/NSCAClient.cpp

@@ -100 +100 @@
     if (hostname_ == "auto") {
       hostname_ = boost::asio::ip::host_name();
+    } else {
+      std::pair<std::string,std::string> dn = strEx::split<std::string>(boost::asio::ip::host_name(), ".");
+
+      try {
+        boost::asio::io_service svc;
+        boost::asio::ip::tcp::resolver resolver (svc);
+        boost::asio::ip::tcp::resolver::query query (boost::asio::ip::host_name(), "");
+        boost::asio::ip::tcp::resolver::iterator iter = resolver.resolve (query), end;
+
+        std::string s;
+        while (iter != end) {
+          s += iter->host_name();
+          s += " - ";
+          s += iter->endpoint().address().to_string();
+          iter++;
+        }
+      } catch (exception& e) {
+        cerr << "Error: " << e.what() << endl;
+      }
+
+
+      strEx::replace(hostname_, "${host}", dn.first);
+      strEx::replace(hostname_, "${domain}", dn.second);
     }
   } catch (nscapi::nscapi_exception &e) {

modules/Scheduler/Scheduler.cpp

@@ -130 +130 @@
       std::string result;
       get_core()->submit_message(item.channel, response, result);
+    } else {
+      NSC_DEBUG_MSG(_T("Filter not matched for: ") + item.alias + _T(" so nothing is reported"));
     }
   } catch (nscapi::nscapi_exception &e) {

modules/Scheduler/schedules.hpp

@@ -110 +110 @@
     static void read_object(boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
       object.set_command(object.value);
-      if (object.alias == _T("default"))
+      if (object.alias == _T("default")) {
         object.set_duration(_T("5m"));
+        object.set_report(_T("all"));
+      }
 
       nscapi::settings_helper::settings_registry settings(proxy);

scripts/python/test_w32_system.py

@@ +1 @@
+from NSCP import Settings, Registry, Core, log, status, log_error, sleep
 from NSCP import Settings, Registry, Core, log, status, log_error, sleep
 from test_helper import BasicTest, TestResult, Callable, setup_singleton, install_testcases, init_testcases, shutdown_testcases
 from types import *
+import random
 import subprocess
 
@@ -47 +49 @@
     return result
     
-  def test_one_proc(self):
+  def run_test_proc(self):
     result = TestResult('Checking CheckProcState')
     
@@ -67 +69 @@
     return result
     
+  def run_test_counters(self):
+    result = TestResult('Checking CheckCounter')
+    (result_code, result_message) = core.simple_exec('any', 'listpdh', ['--porcelain'])
+    count = 0
+    data = []
+    for m in result_message:
+      data = m.splitlines()
+      count = len(data)
+    result.add_message(count > 0, 'Managed to retrieve counters: %d'%count)
+      
+    counters = []
+    for x in range(1,10):
+      str = random.choice(data)
+      lst = str.split(',')
+      found = True
+      if len(lst) == 4:
+        counter = '\\%s(%s)\\%s'%(lst[1], lst[2], lst[3])
+      elif len(lst) == 3:
+        counter = '\\%s\\%s'%(lst[1], lst[2])
+      else:
+        result.add_message(False, 'Invalid counter found: %s'%lst)
+        found = False
+      if found:
+        (retcode, retmessage, retperf) = core.simple_query('CheckCounter', ['ShowAll', 'MaxWarn=10', 'Counter:001=%s'%counter])
+        result.add_message(retcode != status.UNKNOWN, 'Queried normal: %s'%counter)
+        result.add_message(len(retmessage) > 0, 'Queried normal (got message): %s'%retmessage)
+        result.add_message(len(retperf) > 0, 'Queried normal (got perf): %s'%retperf)
+        if retcode != status.UNKNOWN:
+          counters.append('Counter:%d=%s'%(x, counter))
+        
+    args = ['ShowAll', 'MaxWarn=10']
+    args.extend(counters)
+    (retcode, retmessage, retperf) = core.simple_query('CheckCounter', args)
+    result.add_message(retcode != status.UNKNOWN, 'Queried normal list of %d counters'%len(counters))
+    result.add_message(len(retmessage) > 0, 'Queried normal (got message): %s'%retmessage)
+    result.add_message(len(retperf) > 0, 'Queried normal (got perf): %s'%retperf)
+    result.add_message(len(counters) == len(retperf.split(' ')), 'Got all responses: %d'%len(counters))
+    return result
+    
   def run_test(self):
-    result = TestResult('Testing process checks on windows 32 bit systems')
-    result.extend(self.test_one_proc())
+    result = TestResult('Testing W32 systems')
+    #result.add(self.run_test_proc())
+    result.add(self.run_test_counters())
     return result
 

service/NSClient++.cpp

@@ -954 +954 @@
 
 NSCAPI::errorReturn NSClientT::reload(const std::wstring module) {
-  if (module == _T("service")) {
+  if (module == _T("settings")) {
+    try {
+      settings_manager::get_settings()->clear_cache();
+      return NSCAPI::isSuccess;
+    } catch(const std::exception &e) {
+      LOG_ERROR_CORE_STD(_T("Exception raised when reloading: ") + utf8::to_unicode(e.what()));
+    } catch(...) {
+      LOG_ERROR_CORE_STD(_T("Exception raised when reloading: UNKNOWN"));
+    }
+  } else if (module == _T("service")) {
     try {
       stop_unload_plugins_pre();

service/cli_parser.hpp

@@ -14 +14 @@
   po::options_description client;
   po::options_description common;
+  po::options_description unittest;
 
   bool help;
@@ -28 +29 @@
     , service("Service Options")
     , client("Client Options")
+    , unittest("Unittest Options")
     , help(false)
     , version(false)
@@ -33 +35 @@
     root.add_options()
       ("help", po::bool_switch(&help), "produce help message")
-      /*
-      ("settings-help", "Produce help message for the various settings related options")
-      ("service-help", "Produce help message for the various settings related service management")
-      ("client-help", "Produce help message for the various settings related client")
-      ("test-help", "Produce help message for the various settings related client")
-      */
-/*
-      ("settings", "Enter settings mode and handle settings related commands")
-      ("service", "Enter service mode and handle service related commands")
-      ("client", "Enter client mode and handle client related commands")
-      ("test", "Start test and debug mode")
-      */
       ("version", po::bool_switch(&version), "Show version information")
       ;
@@ -88 +78 @@
       ("raw-argument", po::wvalue<std::vector<std::wstring> >(), "List of arguments (does not get -- prefixed)")
       ;
+    unittest.add_options()
+      ("language,l", po::value<std::wstring>()->implicit_value(_T("")), "Language tests are written in")
+      ("argument,a", po::wvalue<std::vector<std::wstring> >(), "List of arguments (gets -- prefixed automatically)")
+      ("raw-argument", po::wvalue<std::vector<std::wstring> >(), "List of arguments (does not get -- prefixed)")
+      ;
 
   }
@@ -120 +115 @@
     handlers["test"] = boost::bind(&cli_parser::parse_test, this, _1, _2);
     handlers["help"] = boost::bind(&cli_parser::parse_help, this, _1, _2);
+    handlers["unit"] = boost::bind(&cli_parser::parse_unittest, this, _1, _2);
     return handlers;
   }
@@ -340 +336 @@
   }
 
-  int parse_client(int argc, wchar_t* argv[], std::wstring module = _T("")) {
-    try {
-      po::options_description all("Allowed options (client)");
-      all.add(common).add(client);
-
-      po::positional_options_description p;
-      p.add("arguments", -1);
-
-      po::variables_map vm;
-      po::wparsed_options parsed = 
-        po::wcommand_line_parser(argc, argv).options(all).allow_unregistered().run();
-      po::store(parsed, vm);
-      po::notify(vm);
-
-      if (process_common_options("client", all))
-        return 1;
-
-      std::wstring command, combined_query;
-      enum modes { exec, query, submit, none, combined};
-      modes mode = none;
-
-      if (vm.count("exec")) {
-        command = vm["exec"].as<std::wstring>();
-        mode = exec;
-        if (vm.count("query")) {
-          combined_query = vm["query"].as<std::wstring>();
-          mode = combined;
-        }
-      } else if (vm.count("query")) {
-        command = vm["query"].as<std::wstring>();
-        mode = query;
-      } else if (vm.count("submit")) {
-        command = vm["submit"].as<std::wstring>();
-        mode = submit;
-      }
-
-      if (vm.count("module"))
-        module = vm["module"].as<std::wstring>();
-
-      bool boot = false;
-      if (vm.count("boot"))
-        boot = true;
-
-      std::vector<std::wstring> kvp_args;
-      if (vm.count("argument"))
-        kvp_args = vm["argument"].as<std::vector<std::wstring> >();
-
-      std::vector<std::wstring> arguments = po::collect_unrecognized(parsed.options, po::include_positional);
-
-      BOOST_FOREACH(std::wstring s, kvp_args) {
-        std::wstring::size_type pos = s.find(L'=');
-        if (pos == std::wstring::npos)
-          arguments.push_back(_T("--") + s);
-        else {
-          arguments.push_back(_T("--") + s.substr(0,pos));
-          arguments.push_back(s.substr(pos+1));
-        }
-      }
-
-      if (vm.count("raw-argument"))
-        kvp_args = vm["raw-argument"].as<std::vector<std::wstring> >();
-      BOOST_FOREACH(std::wstring s, kvp_args) {
-        std::wstring::size_type pos = s.find(L'=');
-        if (pos == std::wstring::npos)
-          arguments.push_back(s);
-        else {
-          arguments.push_back(s.substr(0,pos));
-          arguments.push_back(s.substr(pos+1));
-        }
-      }
-
+  struct client_arguments {
+    std::wstring command, combined_query, module;
+    std::vector<std::wstring> arguments;
+    enum modes { exec, query, submit, none, combined};
+    modes mode;
+    bool boot;
+    client_arguments() : mode(none), boot(false) {}
+
+    void debug() {
       if (mainClient.should_log(NSCAPI::log_level::debug)) {
         mainClient.log_info(__FILE__, __LINE__, _T("Module: ") + module);
         mainClient.log_info(__FILE__, __LINE__, _T("Command: ") + command);
+        mainClient.log_info(__FILE__, __LINE__, _T("Extra Query: ") + combined_query);
         mainClient.log_info(__FILE__, __LINE__, _T("Mode: ") + strEx::itos(mode));
         mainClient.log_info(__FILE__, __LINE__, _T("Boot: ") + strEx::itos(boot));
@@ -424 +359 @@
       }
 
+    }
+  };
+  int parse_client(int argc, wchar_t* argv[], std::wstring module_ = _T("")) {
+    try {
+      client_arguments args;
+
+      args.module = module_;
+      po::options_description all("Allowed options (client)");
+      all.add(common).add(client);
+
+      po::positional_options_description p;
+      p.add("arguments", -1);
+
+      po::variables_map vm;
+      po::wparsed_options parsed = 
+        po::wcommand_line_parser(argc, argv).options(all).allow_unregistered().run();
+      po::store(parsed, vm);
+      po::notify(vm);
+
+      if (process_common_options("client", all))
+        return 1;
+
+
+      if (vm.count("exec")) {
+        args.command = vm["exec"].as<std::wstring>();
+        args.mode = client_arguments::exec;
+        if (vm.count("query")) {
+          args.combined_query = vm["query"].as<std::wstring>();
+          args.mode = client_arguments::combined;
+        }
+      } else if (vm.count("query")) {
+        args.command = vm["query"].as<std::wstring>();
+        args.mode = client_arguments::query;
+      } else if (vm.count("submit")) {
+        args.command = vm["submit"].as<std::wstring>();
+        args.mode = client_arguments::submit;
+      }
+
+      if (vm.count("module"))
+        args.module = vm["module"].as<std::wstring>();
+
+      if (vm.count("boot"))
+        args.boot = true;
+
+      std::vector<std::wstring> kvp_args;
+      if (vm.count("argument"))
+        kvp_args = vm["argument"].as<std::vector<std::wstring> >();
+
+      args.arguments = po::collect_unrecognized(parsed.options, po::include_positional);
+
+      BOOST_FOREACH(std::wstring s, kvp_args) {
+        std::wstring::size_type pos = s.find(L'=');
+        if (pos == std::wstring::npos)
+          args.arguments.push_back(_T("--") + s);
+        else {
+          args.arguments.push_back(_T("--") + s.substr(0,pos));
+          args.arguments.push_back(s.substr(pos+1));
+        }
+      }
+
+      if (vm.count("raw-argument"))
+        kvp_args = vm["raw-argument"].as<std::vector<std::wstring> >();
+      BOOST_FOREACH(std::wstring s, kvp_args) {
+        std::wstring::size_type pos = s.find(L'=');
+        if (pos == std::wstring::npos)
+          args.arguments.push_back(s);
+        else {
+          args.arguments.push_back(s.substr(0,pos));
+          args.arguments.push_back(s.substr(pos+1));
+        }
+      }
+      return exec_client_mode(args);
+    } catch(const std::exception & e) {
+      std::wcerr << _T("Client: Unable to parse command line: ") << utf8::to_unicode(e.what()) << std::endl;
+      return 1;
+    } catch(...) {
+      std::wcerr << _T("Client: Unable to parse command line: UNKNOWN") << std::endl;
+      return 1;
+    }
+  }
+
+  int parse_unittest(int argc, wchar_t* argv[]) {
+    try {
+      client_arguments args;
+      settings_store = _T("dummy");
+      po::options_description all("Allowed options (client)");
+      all.add(common).add(unittest);
+
+      po::positional_options_description p;
+      p.add("arguments", -1);
+
+      po::variables_map vm;
+      po::wparsed_options parsed = 
+        po::wcommand_line_parser(argc, argv).options(all).allow_unregistered().run();
+      po::store(parsed, vm);
+      po::notify(vm);
+
+      if (process_common_options("unitest", all))
+        return 1;
+
+
+      if (vm.count("language")) {
+        std::wstring lang = vm["language"].as<std::wstring>();
+        if (lang == _T("python") || lang == _T("py")) {
+          args.command = _T("python-script");
+          args.combined_query = _T("py_unittest");
+          args.mode = client_arguments::combined;
+          args.module = _T("PythonScript");
+        } else {
+          std::wcerr << _T("Unknown language: ") << lang << std::endl;
+          return 1;
+        }
+      } else {
+        args.command = _T("python-script");
+        args.combined_query = _T("py_unittest");
+        args.mode = client_arguments::combined;
+        args.module = _T("PythonScript");
+      }
+
+      std::vector<std::wstring> kvp_args;
+      if (vm.count("argument"))
+        kvp_args = vm["argument"].as<std::vector<std::wstring> >();
+
+      args.arguments = po::collect_unrecognized(parsed.options, po::include_positional);
+
+      BOOST_FOREACH(std::wstring s, kvp_args) {
+        std::wstring::size_type pos = s.find(L'=');
+        if (pos == std::wstring::npos)
+          args.arguments.push_back(_T("--") + s);
+        else {
+          args.arguments.push_back(_T("--") + s.substr(0,pos));
+          args.arguments.push_back(s.substr(pos+1));
+        }
+      }
+
+      if (vm.count("raw-argument"))
+        kvp_args = vm["raw-argument"].as<std::vector<std::wstring> >();
+      BOOST_FOREACH(std::wstring s, kvp_args) {
+        std::wstring::size_type pos = s.find(L'=');
+        if (pos == std::wstring::npos)
+          args.arguments.push_back(s);
+        else {
+          args.arguments.push_back(s.substr(0,pos));
+          args.arguments.push_back(s.substr(pos+1));
+        }
+      }
+      return exec_client_mode(args);
+    } catch(const std::exception & e) {
+      std::wcerr << _T("Client: Unable to parse command line: ") << utf8::to_unicode(e.what()) << std::endl;
+      return 1;
+    } catch(...) {
+      std::wcerr << _T("Client: Unable to parse command line: UNKNOWN") << std::endl;
+      return 1;
+    }
+  }
+
+  int exec_client_mode(client_arguments &args) {
+    try {
+      args.debug();
+
       core_->boot_init();
-      if (module.empty())
+      if (args.module.empty())
         core_->boot_load_all_plugins();
       else
-        core_->boot_load_plugin(module);
-      core_->boot_start_plugins(boot);
+        core_->boot_load_plugin(args.module);
+      core_->boot_start_plugins(args.boot);
       int ret = 0;
       std::list<std::wstring> resp;
-      if (mode == none) {
-        mode = exec;
+      if (args.mode == client_arguments::none) {
+        args.mode = client_arguments::exec;
         std::wcerr << _T("Since no mode was specified assuming --exec (other options are --query and --submit)") << std::endl;
       }
-      if (mode == query) {
-        ret = mainClient.simple_query(module, command, arguments, resp);
-      } else if (mode == exec || mode == combined) {
-        ret = mainClient.simple_exec(module, command, arguments, resp);
+      if (args.mode == client_arguments::query) {
+        ret = mainClient.simple_query(args.module, args.command, args.arguments, resp);
+      } else if (args.mode == client_arguments::exec || args.mode == client_arguments::combined) {
+        ret = mainClient.simple_exec(args.module, args.command, args.arguments, resp);
         if (ret == NSCAPI::returnIgnored) {
           ret = 1;
-          std::wcout << _T("Command not found (by module): ") << command << std::endl;
-          resp.push_back(_T("Command not found: ") + command);
-          mainClient.simple_exec(module, _T("help"), arguments, resp);
-        } else if (mode == combined) {
+          std::wcout << _T("Command not found (by module): ") << args.command << std::endl;
+          resp.push_back(_T("Command not found: ") + args.command);
+          mainClient.simple_exec(args.module, _T("help"), args.arguments, resp);
+        } else if (args.mode == client_arguments::combined) {
           if (ret == NSCAPI::returnOK) {
             mainClient.reload(_T("service"));
-            ret = mainClient.simple_query(module, combined_query, arguments, resp);
+            ret = mainClient.simple_query(args.module, args.combined_query, args.arguments, resp);
           } else {
             std::wcerr << _T("Failed to execute command, will not attempt query") << std::endl;
           }
         }
-      } else if (mode == submit) {
+      } else if (args.mode == client_arguments::submit) {
         std::wcerr << _T("--submit is currently not supported (but you can use --exec submit which is technically the same)") << std::endl;
       } else {

service/logger.hpp

@@ -51 +51 @@
         msg->set_line(line);
         msg->set_message(utf8::cvt<std::string>(logMessage));
-        if (!message.SerializeToString(&str)) {
-          return "Failed to generate message";
-        }
-        return str;
+        return message.SerializeAsString();
       } catch (std::exception &e) {
-        return std::string("Failed to generate message: ") + e.what();
+        std::cout << "Failed to generate message: " << e.what() << std::endl;;
       } catch (...) {
-        return "Failed to generate message";
-      }
-//      return to_string(logMessage);
+        std::cout << "Failed to generate message: " << std::endl;;
+      }
+      return "";
     }
   };
@@ -86 +83 @@
 
     public:
-      slave() : mq_(ip::open_only,queue_name.c_str()), plugins_loaded_(false), console_log_(false) {
-#ifdef WIN32
-//        if(!SetConsoleOutputCP(CP_UTF8)) { // 65001
-//          std::cerr << "Failed to set console output mode!\n";
-//        }
-#endif
-      }
+      slave() : mq_(ip::open_only,queue_name.c_str()), plugins_loaded_(false), console_log_(false) {}
 
       void add_plugin(plugin_type plugin) {
@@ -206 +197 @@
 
 #ifdef WIN32
-          s += _T("\n");
+          //s += _T("\n");
+          std::wcout << s << std::endl;
+          /*
           HANDLE const consout = GetStdHandle(STD_OUTPUT_HANDLE);
           DWORD nNumberOfCharsWritten;
@@ -213 +206 @@
             cerr << "WriteConsole failed with << " << err << "!\n";
           }
+          */
 #else
           std::wcout << s << std::endl;
@@ -310 +304 @@
       }
 
+      void truncate_entries(Plugin::LogEntry &message) {
+        if (message.entry_size() == 1)
+          return;
+        Plugin::LogEntry::Entry e = message.entry(0);
+        message.clear_entry();
+        message.add_entry()->CopyFrom(e);
+        //message.mutable_entry()->add(e);
+      }
+
+      void truncate_string(Plugin::LogEntry &message) {
+        if (message.entry_size() == 0)
+          return;
+        std::string str = message.mutable_entry(0)->message();
+        if (str.size() > max_message_size*0.7)
+          str = str.substr(0, max_message_size*0.7);
+        message.mutable_entry(0)->set_message("TRUNCATED(" + str + "...)");
+      }
+
       void log(std::string data) {
         if (!mq_) {
@@ -316 +328 @@
         }
         if (data.size() >= max_message_size) {
-          log_fatal_error("Message to large to fit buffer: " + to_string(data.size()) + " > " + to_string(max_message_size));
-          return;
+          Plugin::LogEntry message;
+          message.ParseFromString(data);
+          truncate_entries(message);
+          data = message.SerializeAsString();
+          if (data.size() >= max_message_size) {
+            truncate_string(message);
+            data = message.SerializeAsString();
+          }
+          if (data.size() >= max_message_size) {
+            log_fatal_error("Message to large to fit buffer: " + to_string(data.size()) + " > " + to_string(max_message_size));
+            return;
+          }
+          data = message.SerializeAsString();
         }
         try {
@@ -330 +353 @@
         OutputDebugString(strEx::string_to_wstring(message).c_str());
 #endif
-        std::cout << "TODO: " << message << std::endl;
+        std::cout << "FATAL ERROR: " << message << std::endl;
       }
 

version.hpp

@@ -1 +1 @@
 #ifndef VERSION_HPP
 #define VERSION_HPP
-#define PRODUCTVER     0,4,0,134
-#define STRPRODUCTVER  "0,4,0,134"
-#define STRPRODUCTDATE "2012-02-13"
+#define PRODUCTVER     0,4,0,135
+#define STRPRODUCTVER  "0,4,0,135"
+#define STRPRODUCTDATE "2012-02-19"
 #endif // VERSION_HPP

version.txt

@@ -1 +1 @@
 version=0.4.0
-build=134
-date=2012-02-13
+build=135
+date=2012-02-19