Changeset 8013c0c in nscp

Timestamp:

01/23/12 07:41:06 (17 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

6a30f44

Parents:

28f6a64

Message:

• Fixed so NSCAClient parses address correctly
• settings exception is now derived from exception meaning it will show up more with details (instead of unknown)
• Added API for handling log level (replaces older debug flag)
• Added options for settings debug level
• Changed to --settings is a global argument (meaning you can use it in any mode)
• Added arguments parsing to test: so you can use global arguments such as --log and --settings.
• Removed memory leak in settings parsing interface

Files:

• changelog (modified) (1 diff)
• helpers/settings_manager/settings_manager_impl.cpp (modified) (1 diff)
• include/NSCAPI.h (modified) (2 diffs)
• include/nscapi/functions.hpp (modified) (2 diffs)
• include/nscapi/macros.hpp (modified) (1 diff)
• include/nscapi/nscapi_core_wrapper.cpp (modified) (7 diffs)
• include/nscapi/nscapi_core_wrapper.hpp (modified) (4 diffs)
• include/nscapi/nscapi_helper.cpp (modified) (2 diffs)
• include/nscapi/nscapi_helper.hpp (modified) (1 diff)
• include/nscapi/nscapi_plugin_wrapper.cpp (modified) (1 diff)
• include/nscapi/settings_proxy.hpp (modified) (1 diff)
• include/settings/client/settings_client.cpp (modified) (1 diff)
• include/settings/client/settings_client.hpp (modified) (9 diffs)
• include/settings/settings_core.hpp (modified) (3 diffs)
• modules/CheckNSCP/CheckNSCP.cpp (modified) (1 diff)
• modules/CheckSystem/PDHCollector.cpp (modified) (2 diffs)
• modules/DistributedServer/handler_impl.hpp (modified) (1 diff)
• modules/FileLogger/FileLogger.cpp (modified) (1 diff)
• modules/LUAScript/script_wrapper.hpp (modified) (1 diff)
• modules/NRPEServer/handler_impl.hpp (modified) (1 diff)
• modules/NSCAClient/NSCAClient.cpp (modified) (4 diffs)
• modules/NSCAServer/handler_impl.hpp (modified) (1 diff)
• modules/NSCPServer/handler_impl.hpp (modified) (1 diff)
• modules/NSClientServer/handler_impl.hpp (modified) (1 diff)
• modules/Scheduler/simple_scheduler.cpp (modified) (1 diff)
• scripts/python/lib/test_helper.py (modified) (10 diffs)
• service/CMakeLists.txt (modified) (1 diff)
• service/NSClient++.cpp (modified) (3 diffs)
• service/NSClient++.h (modified) (4 diffs)
• service/cli_parser.hpp (modified) (11 diffs)
• service/core_api.cpp (modified) (3 diffs)
• service/core_api.h (modified) (1 diff)
• service/logger.hpp (modified) (1 diff)
• service/settings_logger_impl.cpp (modified) (4 diffs)
• service/simple_client.hpp (modified) (2 diffs)
• version.hpp (modified) (1 diff)
• version.txt (modified) (1 diff)

changelog

@@ -5 +5 @@
  * Fixa dependonservice LanManWorkStation (old win)
  * Fix RtlStringFromGUID problem on NT4
+
+2012-01-22 MickeM
+ * Fixed so NSCAClient parses address correctly
+ * setings exception is now derived from exception meaning it will show up more with details (instead of unknown)
+ * Added API for handling log level (replaces older debug flag)
+ * Added options for settings debug level
+ * Changed to --settings is a global argument (meaning you canuse it in any mode)
+ * Added arguments parsing to test: so you can use global arguments such as --log and --settings.
+ * Removed memory leak in settings parsing interface
 
 2012-01-20 MickeM

helpers/settings_manager/settings_manager_impl.cpp

@@ -24 +24 @@
   inline NSCSettingsImpl* internal_get() {
     if (settings_impl == NULL)
-      throw "Settings has not been initiated!";
+      throw settings::settings_exception(_T("Settings has not been initiated!"));
     return settings_impl;
   }

include/NSCAPI.h

@@ -96 +96 @@
 
   // Various message Types
-  const int log = 1;        // Log message
-  const int error = -1;     // Error (non critical)
-  const int critical = -10;   // Critical error
-  const int warning = 2;      // Warning
-  const int debug = 10;     // Debug message
-
-  typedef int messageTypes;   // Message type
+  namespace log_level {
+    typedef int level;
+    const int critical = 1; // Critical error
+    const int error = 10; // Error
+    const int warning = 50; // Warning      <<< Default for command line interface
+    const int log = 100;  // Log message    <<< Default for service
+    const int info = 150; // information
+    const int debug = 500;  // Debug messages <<< Default for test
+    const int trace = 1000; // Trace messages
+  }
+
+  typedef log_level::level messageTypes;    // Message type
 
   struct plugin_info {
@@ -175 +180 @@
     typedef NSCAPI::errorReturn (*lpNSAPIRegisterRoutingListener)(unsigned int plugin_id, const wchar_t* channel);
     typedef NSCAPI::errorReturn (*lpNSAPIReload)(const wchar_t* module);
+    typedef NSCAPI::log_level::level (*lpNSAPIGetLoglevel)();
 
   }

include/nscapi/functions.hpp

@@ -118 +118 @@
     
     static Plugin::LogEntry::Entry::Level log_to_gpb(NSCAPI::messageTypes ret) {
-      if (ret == NSCAPI::critical)
+      if (ret == NSCAPI::log_level::critical)
         return Plugin::LogEntry_Entry_Level_LOG_CRITICAL;
-      if (ret == NSCAPI::debug)
+      if (ret == NSCAPI::log_level::debug)
         return Plugin::LogEntry_Entry_Level_LOG_DEBUG;
-      if (ret == NSCAPI::error)
+      if (ret == NSCAPI::log_level::error)
         return Plugin::LogEntry_Entry_Level_LOG_ERROR;
-      if (ret == NSCAPI::log)
+      if (ret == NSCAPI::log_level::log)
         return Plugin::LogEntry_Entry_Level_LOG_INFO;
-      if (ret == NSCAPI::warning)
+      if (ret == NSCAPI::log_level::info)
+        return Plugin::LogEntry_Entry_Level_LOG_INFO;
+      if (ret == NSCAPI::log_level::warning)
         return Plugin::LogEntry_Entry_Level_LOG_WARNING;
       return Plugin::LogEntry_Entry_Level_LOG_ERROR;
@@ -132 +134 @@
     static NSCAPI::messageTypes gpb_to_log(Plugin::LogEntry::Entry::Level ret) {
       if (ret == Plugin::LogEntry_Entry_Level_LOG_CRITICAL)
-        return NSCAPI::critical;
+        return NSCAPI::log_level::critical;
       if (ret == Plugin::LogEntry_Entry_Level_LOG_DEBUG)
-        return NSCAPI::debug;
+        return NSCAPI::log_level::debug;
       if (ret == Plugin::LogEntry_Entry_Level_LOG_ERROR)
-        return NSCAPI::error;
+        return NSCAPI::log_level::error;
       if (ret == Plugin::LogEntry_Entry_Level_LOG_INFO)
-        return NSCAPI::log;
+        return NSCAPI::log_level::info;
       if (ret == Plugin::LogEntry_Entry_Level_LOG_WARNING)
-        return NSCAPI::warning;
-      return NSCAPI::error;
+        return NSCAPI::log_level::warning;
+      return NSCAPI::log_level::error;
     }
 

include/nscapi/macros.hpp

@@ -35 +35 @@
 // Logging calls for the core wrapper 
 
-#define NSC_LOG_ERROR_STD(msg) NSC_LOG_ERROR(((std::wstring)msg).c_str())
-#define NSC_LOG_ERROR(msg) NSC_ANY_MSG(msg,NSCAPI::error)
+#define NSC_LOG_ERROR_STD(msg) if (GET_CORE()->should_log(NSCAPI::log_level::error)) { NSC_ANY_MSG((std::wstring)msg, NSCAPI::log_level::error); }
+#define NSC_LOG_ERROR(msg) if (GET_CORE()->should_log(NSCAPI::log_level::error)) { NSC_ANY_MSG(msg, NSCAPI::log_level::error); }
 
-#define NSC_LOG_CRITICAL_STD(msg) NSC_LOG_CRITICAL(((std::wstring)msg).c_str())
-#define NSC_LOG_CRITICAL(msg) NSC_ANY_MSG(msg,NSCAPI::critical)
+#define NSC_LOG_CRITICAL_STD(msg) if (GET_CORE()->should_log(NSCAPI::log_level::critical)) { NSC_ANY_MSG((std::wstring)msg, NSCAPI::log_level::critical); }
+#define NSC_LOG_CRITICAL(msg) if (GET_CORE()->should_log(NSCAPI::log_level::critical)) { NSC_ANY_MSG(msg, NSCAPI::log_level::critical); }
 
-#define NSC_LOG_MESSAGE_STD(msg) NSC_LOG_MESSAGE(((std::wstring)msg).c_str())
-#define NSC_LOG_MESSAGE(msg) NSC_ANY_MSG(msg,NSCAPI::log)
+#define NSC_LOG_MESSAGE_STD(msg) if (GET_CORE()->should_log(NSCAPI::log_level::info)) { NSC_ANY_MSG((std::wstring)msg, NSCAPI::log_level::info); }
+#define NSC_LOG_MESSAGE(msg) if (GET_CORE()->should_log(NSCAPI::log_level::info)) { NSC_ANY_MSG(msg, NSCAPI::log_level::info); }
 
-#define NSC_DEBUG_MSG_STD(msg) NSC_DEBUG_MSG((std::wstring)msg)
-#define NSC_DEBUG_MSG(msg) NSC_ANY_MSG(msg,NSCAPI::debug)
+#define NSC_DEBUG_MSG_STD(msg) if (GET_CORE()->should_log(NSCAPI::log_level::debug)) { NSC_ANY_MSG((std::wstring)msg, NSCAPI::log_level::debug); }
+#define NSC_DEBUG_MSG(msg) if (GET_CORE()->should_log(NSCAPI::log_level::debug)) { NSC_ANY_MSG(msg, NSCAPI::log_level::debug); }
 
 #define NSC_ANY_MSG(msg, type) GET_CORE()->log(type, __FILE__, __LINE__, msg)
-/*
-#define NSC_LOG_ERROR_STD(msg) 
-#define NSC_LOG_ERROR(msg) 
-
-#define NSC_LOG_CRITICAL_STD(msg) 
-#define NSC_LOG_CRITICAL(msg) 
-
-#define NSC_LOG_MESSAGE_STD(msg) 
-#define NSC_LOG_MESSAGE(msg) 
-
-#define NSC_DEBUG_MSG_STD(msg)
-#define NSC_DEBUG_MSG(msg)
-
-#define NSC_ANY_MSG(msg, type)
-*/
 
 //////////////////////////////////////////////////////////////////////////

include/nscapi/nscapi_core_wrapper.cpp

@@ -35 +35 @@
 using namespace nscp::helpers;
 
-#define CORE_LOG_ERROR_STD(msg) CORE_LOG_ERROR(((std::wstring)msg).c_str())
-#define CORE_LOG_ERROR(msg) CORE_ANY_MSG(msg,NSCAPI::error)
-
-#define CORE_LOG_CRITICAL_STD(msg) CORE_LOG_CRITICAL(((std::wstring)msg).c_str())
-#define CORE_LOG_CRITICAL(msg) CORE_ANY_MSG(msg,NSCAPI::critical)
-
-#define CORE_LOG_MESSAGE_STD(msg) CORE_LOG_MESSAGE(((std::wstring)msg).c_str())
-#define CORE_LOG_MESSAGE(msg) CORE_ANY_MSG(msg,NSCAPI::log)
-
-#define CORE_DEBUG_MSG_STD(msg) CORE_DEBUG_MSG((std::wstring)msg)
-#define CORE_DEBUG_MSG(msg) CORE_ANY_MSG(msg,NSCAPI::debug)
-
-#define CORE_ANY_MSG(msg, type) log(type, __FILE__, __LINE__, msg)
+
+#define CORE_LOG_ERROR_STD(msg) if (should_log(NSCAPI::log_level::error)) { log(NSCAPI::log_level::error, __FILE__, __LINE__, (std::wstring)msg); }
+#define CORE_LOG_ERROR(msg) if (should_log(NSCAPI::log_level::error)) { log(NSCAPI::log_level::error, __FILE__, __LINE__, msg); }
+
+//#define CORE_LOG_CRITICAL_STD(msg) if (matches(NSCAPI::critical)) { CORE_ANY_MSG(NSCAPI::critical, __FILE__, __LINE__, (std::wstring)msg) }
+//#define CORE_LOG_CRITICAL(msg) if (matches(NSCAPI::critical)) { CORE_ANY_MSG(NSCAPI::critical, __FILE__, __LINE__, msg) }
+
+//#define CORE_LOG_MESSAGE_STD(msg) if (matches(NSCAPI::info)) { CORE_ANY_MSG(NSCAPI::info, __FILE__, __LINE__, (std::wstring)msg) }
+//#define CORE_LOG_MESSAGE(msg) if (matches(NSCAPI::info)) { CORE_ANY_MSG(NSCAPI::info, __FILE__, __LINE__, msg) }
+
+//#define CORE_DEBUG_MSG_STD(msg) if (matches(NSCAPI::debug)) { CORE_ANY_MSG(NSCAPI::debug, __FILE__, __LINE__, (std::wstring)msg) }
+//#define CORE_DEBUG_MSG(msg) if (matches(NSCAPI::debug)) { CORE_ANY_MSG(NSCAPI::debug, __FILE__, __LINE__, msg) }
+
+//#define CORE_ANY_MSG(msg, type) log(type, __FILE__, __LINE__, msg)
 
 
@@ -53 +54 @@
 // Callbacks into the core
 //////////////////////////////////////////////////////////////////////////
+
+bool nscapi::core_wrapper::should_log(NSCAPI::nagiosReturn msgType) {
+  enum log_status {unknown, set };
+  static NSCAPI::log_level::level level = NSCAPI::log_level::log;
+  static log_status status = unknown;
+  if (status == unknown) {
+    level = get_loglevel();
+    status = set;
+  }
+  return nscapi::logging::matches(level, msgType);
+}
+
 
 /**
@@ -63 +76 @@
  * @throws nscapi::nscapi_exception When core pointer set is unavailable.
  */
-void nscapi::core_wrapper::log(int msgType, std::string file, int line, std::wstring logMessage) {
-  if (fNSAPIMessage) {
-    if ((msgType == NSCAPI::debug) && (!logDebug()))
-      return;
-    std::string str;
-    try {
-      Plugin::LogEntry message;
-      Plugin::LogEntry::Entry *msg = message.add_entry();
-      msg->set_level(nscapi::functions::log_to_gpb(msgType));
-      msg->set_file(file);
-      msg->set_line(line);
-      msg->set_message(utf8::cvt<std::string>(logMessage));
-      if (!message.SerializeToString(&str)) {
-        std::cout << "Failed to generate message";
-      }
-      return fNSAPIMessage(str.c_str(), str.size());
-    } catch (...) {
-      std::wcout << _T("Failed to generate message: ");
+void nscapi::core_wrapper::log(NSCAPI::nagiosReturn msgType, std::string file, int line, std::wstring logMessage) {
+  if (!should_log(msgType))
+    return;
+  if (!fNSAPIMessage) {
+    std::wcout << _T("*** *** *** NSCore not loaded, dumping log: ") << to_wstring(file) << _T(":") << line << _T(": ") << std::endl << logMessage << std::endl;
+    return;
+  }
+  std::string str;
+  try {
+    Plugin::LogEntry message;
+    Plugin::LogEntry::Entry *msg = message.add_entry();
+    msg->set_level(nscapi::functions::log_to_gpb(msgType));
+    msg->set_file(file);
+    msg->set_line(line);
+    msg->set_message(utf8::cvt<std::string>(logMessage));
+    if (!message.SerializeToString(&str)) {
+      std::wcout << _T("Failed to generate message: SERIALIZATION ERROR");
     }
-//    return fNSAPIMessage(to_string(logMessage).c_str(), logMessage.size());
-  }
-  else
-    std::wcout << _T("*** *** *** NSCore not loaded, dumping log: ") << to_wstring(file) << _T(":") << line << _T(": ") << std::endl << logMessage << std::endl;
-}
-void nscapi::core_wrapper::log(int msgType, std::string file, int line, std::string message) {
-  if ((msgType == NSCAPI::debug) && (!logDebug()))
+    return fNSAPIMessage(str.c_str(), str.size());
+  } catch (const std::exception &e) {
+    std::wcout << _T("Failed to generate message: ") << utf8::to_unicode(e.what());
+  } catch (...) {
+    std::wcout << _T("Failed to generate message: UNKNOWN");
+  }
+}
+void nscapi::core_wrapper::log(NSCAPI::nagiosReturn msgType, std::string file, int line, std::string message) {
+  if (!should_log(msgType))
     return;
   log(msgType, file, line, utf8::cvt<std::wstring>(message));
 }
+
+NSCAPI::log_level::level nscapi::core_wrapper::get_loglevel() {
+  if (!fNSAPIGetLoglevel) {
+    return NSCAPI::log_level::debug;
+  }
+  return fNSAPIGetLoglevel();
+}
+
 
 /**
@@ -237 +259 @@
   switch (retC) {
     case NSCAPI::returnIgnored:
-      CORE_LOG_MESSAGE_STD(_T("No handler for command '") + command + _T("'."));
+      CORE_LOG_ERROR_STD(_T("No handler for command '") + command + _T("'."));
       break;
     case NSCAPI::returnOK:
@@ -273 +295 @@
   switch (retC) {
     case NSCAPI::returnIgnored:
-      CORE_LOG_MESSAGE_STD(_T("No handler for command '") + command + _T("'."));
+      CORE_LOG_ERROR_STD(_T("No handler for command '") + command + _T("'."));
       break;
     case NSCAPI::returnOK:
@@ -475 +497 @@
 }
 
-
-bool nscapi::core_wrapper::logDebug() {
-  enum status {unknown, debug, nodebug };
-  static status d = unknown;
-  if (d == unknown) {
-    if (checkLogMessages(debug)== NSCAPI::istrue)
-      d = debug;
-    else
-      d = nodebug;
-  }
-  return (d == debug);
-}
 
 std::wstring nscapi::core_wrapper::Encrypt(std::wstring str, unsigned int algorithm) {
@@ -698 +708 @@
   fNSAPIRegisterSubmissionListener = (nscapi::core_api::lpNSAPIRegisterSubmissionListener)f(_T("NSAPIRegisterSubmissionListener"));
   fNSAPIRegisterRoutingListener = (nscapi::core_api::lpNSAPIRegisterRoutingListener)f(_T("NSAPIRegisterRoutingListener"));
+  fNSAPIGetLoglevel = (nscapi::core_api::lpNSAPIGetLoglevel)f(_T("NSAPIGetLoglevel"));
 
   return true;

include/nscapi/nscapi_core_wrapper.hpp

@@ -73 +73 @@
     nscapi::core_api::lpNSAPIRegisterSubmissionListener fNSAPIRegisterSubmissionListener;
     nscapi::core_api::lpNSAPIRegisterRoutingListener fNSAPIRegisterRoutingListener;
+    nscapi::core_api::lpNSAPIGetLoglevel fNSAPIGetLoglevel;
 
   public:
@@ -118 +119 @@
       , fNSAPISettingsSave(NULL)
       , fNSAPIExpandPath(NULL)
+      , fNSAPIGetLoglevel(NULL)
     {}
 
@@ -133 +135 @@
     void settings_save();
 
-    void log(int msgType, std::string file, int line, std::wstring message);
-    void log(int msgType, std::string file, int line, std::string message);
+    void log(NSCAPI::nagiosReturn msgType, std::string file, int line, std::wstring message);
+    void log(NSCAPI::nagiosReturn msgType, std::string file, int line, std::string message);
+    bool should_log(NSCAPI::nagiosReturn msgType);
+    NSCAPI::log_level::level get_loglevel();
     void DestroyBuffer(char**buffer);
     NSCAPI::nagiosReturn query(const wchar_t* command, const char *request, const unsigned int request_len, char **response, unsigned int *response_len);
@@ -153 +157 @@
     void Exit(void);
     std::wstring getBasePath();
-    bool logDebug();
     bool checkLogMessages(int type);
     std::wstring Encrypt(std::wstring str, unsigned int algorithm = NSCAPI::encryption_xor);

include/nscapi/nscapi_helper.cpp

@@ -85 +85 @@
 }
 
-#define LOG_CRIT  0x10
-#define LOG_ERROR 0x08
-#define LOG_WARNING 0x04
-#define LOG_MSG   0x02
-#define LOG_DEBUG 0x01
-
-unsigned int nscapi::logging::parse(std::wstring str) {
-  unsigned int report = 0;
+#define PARSE_LOGLEVEL_BEGIN() if (false) {}
+#define PARSE_LOGLEVEL(key_str, value)  else if (*key == _T(key_str) && level < value) { level = value; }
+#define PARSE_LOGLEVEL_END() 
+
+NSCAPI::log_level::level nscapi::logging::parse(std::wstring str) {
+  unsigned int level = 0;
   strEx::splitList lst = strEx::splitEx(str, _T(","));
-
   for (strEx::splitList::const_iterator key = lst.begin(); key != lst.end(); ++key) {
-    if (*key == _T("all")) {
-      report |= LOG_MSG|LOG_ERROR|LOG_CRIT|LOG_WARNING|LOG_DEBUG;
-    } else if (*key == _T("normal")) {
-        report |= LOG_MSG|LOG_ERROR|LOG_CRIT|LOG_WARNING;
-    } else if (*key == _T("log") || *key == _T("message") || *key == _T("info") || *key == _T("INFO")) {
-      report |= LOG_MSG;
-    } else if (*key == _T("error") || *key == _T("ERROR")) {
-      report |= LOG_ERROR;
-    } else if (*key == _T("critical") || *key == _T("CRITICAL")) {
-      report |= LOG_CRIT;
-    } else if (*key == _T("warning") || *key == _T("WARN")) {
-      report |= LOG_WARNING;
-    } else if (*key == _T("debug") || *key == _T("DEBUG")) {
-      report |= LOG_DEBUG;
-    }
-  }
-  return report;
-}
-bool nscapi::logging::matches(unsigned int report, NSCAPI::nagiosReturn code) {
-  return (
-    (code == NSCAPI::critical && ((report&LOG_CRIT)==LOG_CRIT) ) ||
-    (code == NSCAPI::error && ((report&LOG_ERROR)==LOG_ERROR) ) ||
-    (code == NSCAPI::warning && ((report&LOG_WARNING)==LOG_WARNING) ) ||
-    (code == NSCAPI::log && ((report&LOG_MSG)==LOG_MSG) ) ||
-    (code == NSCAPI::debug && ((report&LOG_DEBUG)==LOG_DEBUG) ) ||
-    ( (code != NSCAPI::critical) && (code != NSCAPI::error) && (code != NSCAPI::warning) && (code != NSCAPI::log) && (code != NSCAPI::debug) )
-    );
-}
-
-std::wstring nscapi::logging::to_string(unsigned int report) {
-  std::wstring ret;
-  if ((report&LOG_CRIT)!=0) {
-    if (!ret.empty()) ret += _T(",");
-    ret += _T("critical");
-  }
-  if ((report&LOG_ERROR)!=0) {
-    if (!ret.empty()) ret += _T(",");
-    ret += _T("error");
-  }
-  if ((report&LOG_WARNING)!=0) {
-    if (!ret.empty()) ret += _T(",");
-    ret += _T("warning");
-  }
-  if ((report&LOG_MSG)!=0) {
-    if (!ret.empty()) ret += _T(",");
-    ret += _T("message");
-  }
-  if ((report&LOG_DEBUG)!=0) {
-    if (!ret.empty()) ret += _T(",");
-    ret += _T("debug");
-  }
-  return ret;
+    PARSE_LOGLEVEL_BEGIN()
+      PARSE_LOGLEVEL("all",   NSCAPI::log_level::trace)
+      PARSE_LOGLEVEL("normal",  NSCAPI::log_level::info)
+      PARSE_LOGLEVEL("service", NSCAPI::log_level::log)
+      PARSE_LOGLEVEL("log",   NSCAPI::log_level::log)
+      PARSE_LOGLEVEL("message", NSCAPI::log_level::info)
+      PARSE_LOGLEVEL("error",   NSCAPI::log_level::error)
+      PARSE_LOGLEVEL("critical",  NSCAPI::log_level::critical)
+      PARSE_LOGLEVEL("debug",   NSCAPI::log_level::debug)
+      PARSE_LOGLEVEL("trace",   NSCAPI::log_level::trace)
+      PARSE_LOGLEVEL("info",    NSCAPI::log_level::info)
+      PARSE_LOGLEVEL("warning", NSCAPI::log_level::warning)
+    PARSE_LOGLEVEL_END()
+  }
+  return level;
+}
+bool nscapi::logging::matches(NSCAPI::log_level::level level, NSCAPI::nagiosReturn code) {
+  return code <= level;
+}
+
+#define RENDER_LOGLEVEL_BEGIN() 
+#define RENDER_LOGLEVEL(key_str, value)  if (level == value) { return _T(key_str); }
+#define RENDER_LOGLEVEL_END() 
+
+std::wstring nscapi::logging::to_string(NSCAPI::log_level::level level) {
+  RENDER_LOGLEVEL_BEGIN()
+    RENDER_LOGLEVEL("all",    NSCAPI::log_level::trace)
+    RENDER_LOGLEVEL("normal", NSCAPI::log_level::info)
+    RENDER_LOGLEVEL("log",    NSCAPI::log_level::log)
+    RENDER_LOGLEVEL("message",  NSCAPI::log_level::info)
+    RENDER_LOGLEVEL("error",    NSCAPI::log_level::error)
+    RENDER_LOGLEVEL("critical", NSCAPI::log_level::critical)
+    RENDER_LOGLEVEL("debug",    NSCAPI::log_level::debug)
+    RENDER_LOGLEVEL("trace",    NSCAPI::log_level::trace)
+    RENDER_LOGLEVEL("info",   NSCAPI::log_level::info)
+    RENDER_LOGLEVEL("warning",  NSCAPI::log_level::warning)
+  RENDER_LOGLEVEL_END()
+  return strEx::itos(level);
 }
 
@@ -198 +181 @@
 std::wstring nscapi::plugin_helper::translateMessageType(NSCAPI::messageTypes msgType) {
   switch (msgType) {
-    case NSCAPI::error:
+    case NSCAPI::log_level::error:
       return _T("error");
-    case NSCAPI::critical:
+    case NSCAPI::log_level::critical:
       return _T("critical");
-    case NSCAPI::warning:
+    case NSCAPI::log_level::warning:
       return _T("warning");
-    case NSCAPI::log:
+    case NSCAPI::log_level::log:
       return _T("message");
-    case NSCAPI::debug:
+    case NSCAPI::log_level::debug:
       return _T("debug");
   }

include/nscapi/nscapi_helper.hpp

@@ -48 +48 @@
   }
   namespace logging {
-    unsigned int parse(std::wstring str);
-    bool matches(unsigned int report, NSCAPI::nagiosReturn code);
-    std::wstring to_string(unsigned int report);
+    NSCAPI::log_level::level parse(std::wstring str);
+    bool matches(NSCAPI::log_level::level level, NSCAPI::nagiosReturn code);
+    std::wstring to_string(NSCAPI::log_level::level level);
   }
 };

include/nscapi/nscapi_plugin_wrapper.cpp

@@ -119 +119 @@
     nscapi::functions::create_simple_submit_response(channel, command, ret, _T(""), response);
   } catch (std::exception &e) {
-    nscapi::plugin_singleton->get_core()->log(NSCAPI::error, __FILE__, __LINE__, utf8::cvt<std::wstring>("Failed to parse data from: " + strEx::strip_hex(request) + ": " + e.what()));
+    nscapi::plugin_singleton->get_core()->log(NSCAPI::log_level::error, __FILE__, __LINE__, utf8::cvt<std::wstring>("Failed to parse data from: " + strEx::strip_hex(request) + ": " + e.what()));
   } catch (...) {
-    nscapi::plugin_singleton->get_core()->log(NSCAPI::error, __FILE__, __LINE__, utf8::cvt<std::wstring>("Failed to parse data from: " + strEx::strip_hex(request)));
+    nscapi::plugin_singleton->get_core()->log(NSCAPI::log_level::error, __FILE__, __LINE__, utf8::cvt<std::wstring>("Failed to parse data from: " + strEx::strip_hex(request)));
   }
   return NSCAPI::returnIgnored;

include/nscapi/settings_proxy.hpp

@@ -52 +52 @@
 
     virtual void err(std::string file, int line, std::wstring message) {
-      core_->log(NSCAPI::error, file, line, message);
+      core_->log(NSCAPI::log_level::error, file, line, message);
     }
     virtual void warn(std::string file, int line, std::wstring message) {
-      core_->log(NSCAPI::warning, file, line, message);
+      core_->log(NSCAPI::log_level::warning, file, line, message);
     }
     virtual void info(std::string file, int line, std::wstring message)  {
-      core_->log(NSCAPI::log, file, line, message);
+      core_->log(NSCAPI::log_level::log, file, line, message);
     }
     virtual void debug(std::string file, int line, std::wstring message)  {
-      core_->log(NSCAPI::debug, file, line, message);
+      core_->log(NSCAPI::log_level::debug, file, line, message);
     }
   };

include/settings/client/settings_client.cpp

@@ -11 +11 @@
     }
 */
-    wstring_key_type* wstring_key(std::wstring *val, std::wstring def) {
-      wstring_key_type* r = new wstring_key_type(val, def);
+    boost::shared_ptr<wstring_key_type> wstring_key(std::wstring *val, std::wstring def) {
+      boost::shared_ptr<wstring_key_type> r(new wstring_key_type(val, def));
       return r;
     }
-    wpath_key_type* wpath_key(std::wstring *val, std::wstring def) {
-      wpath_key_type* r = new wpath_key_type(val, def);
+    boost::shared_ptr<wpath_key_type> wpath_key(std::wstring *val, std::wstring def) {
+      boost::shared_ptr<wpath_key_type> r(new wpath_key_type(val, def));
       return r;
     }
-    string_key_type* string_key(std::string *val, std::string def) {
-      string_key_type* r = new string_key_type(val, def);
+    boost::shared_ptr<string_key_type> string_key(std::string *val, std::string def) {
+      boost::shared_ptr<string_key_type> r(new string_key_type(val, def));
       return r;
     }
-    int_key_type* int_key(int *val, int def) {
-      int_key_type* r = new int_key_type(val, def);
+    boost::shared_ptr<int_key_type> int_key(int *val, int def) {
+      boost::shared_ptr<int_key_type> r(new int_key_type(val, def));
       return r;
     }
-    uint_key_type* uint_key(unsigned int *val, unsigned int def) {
-      uint_key_type* r = new uint_key_type(val, def);
+    boost::shared_ptr<uint_key_type> uint_key(unsigned int *val, unsigned int def) {
+      boost::shared_ptr<uint_key_type> r(new uint_key_type(val, def));
       return r;
     }
-    bool_key_type* bool_key(bool *val, bool def) {
-      bool_key_type* r = new bool_key_type(val, def);
+    boost::shared_ptr<bool_key_type> bool_key(bool *val, bool def) {
+      boost::shared_ptr<bool_key_type> r(new bool_key_type(val, def));
       return r;
     }
 
 
-    typed_path_fun* fun_path(boost::function<void (std::wstring)> fun) {
-      typed_path_fun* r = new typed_path_fun(fun);
+    boost::shared_ptr<typed_path_fun> fun_path(boost::function<void (std::wstring)> fun) {
+      boost::shared_ptr<typed_path_fun> r(new typed_path_fun(fun));
       return r;
     }
-    typed_path_fun_value* fun_values_path(boost::function<void (std::wstring,std::wstring)> fun) {
-      typed_path_fun_value* r = new typed_path_fun_value(fun);
+    boost::shared_ptr<typed_path_fun_value> fun_values_path(boost::function<void (std::wstring,std::wstring)> fun) {
+      boost::shared_ptr<typed_path_fun_value> r(new typed_path_fun_value(fun));
       return r;
     }
-    typed_path_map<>* wstring_map_path(std::map<std::wstring,std::wstring> *val) {
-      typed_path_map<>* r = new typed_path_map<>(val);
+    boost::shared_ptr<typed_path_map<> > wstring_map_path(std::map<std::wstring,std::wstring> *val) {
+      boost::shared_ptr<typed_path_map<> > r(new typed_path_map<>(val));
       return r;
     }
-    typed_path_list* wstring_list_path(std::list<std::wstring> *val) {
-      typed_path_list* r = new typed_path_list(val);
+    boost::shared_ptr<typed_path_list> wstring_list_path(std::list<std::wstring> *val) {
+      boost::shared_ptr<typed_path_list> r(new typed_path_list(val));
       return r;
     }

include/settings/client/settings_client.hpp

@@ -167 +167 @@
 
     template<typename T>
-    typed_key_entry_in_vector<std::wstring, T, typed_string_value<std::wstring> >* wstring_vector_key(T *val, typename T::key_type key, std::wstring def) {
-      typed_key_entry_in_vector<std::wstring, T, typed_string_value<std::wstring> >* r = new typed_key_entry_in_vector<std::wstring, T, typed_string_value<std::wstring> >(val, key, def);
+    boost::shared_ptr<typed_key_entry_in_vector<std::wstring, T, typed_string_value<std::wstring> > > wstring_vector_key(T *val, typename T::key_type key, std::wstring def) {
+      boost::shared_ptr<typed_key_entry_in_vector<std::wstring, T, typed_string_value<std::wstring> > > r(new typed_key_entry_in_vector<std::wstring, T, typed_string_value<std::wstring> >(val, key, def));
       return r;
     }
@@ -183 +183 @@
     typed_key_entry_in_vector<std::wstring, T, typed_string_value<std::wstring> >* wstring_vector_key(T *val, typename T::key_type key, std::wstring def);
     */
-    wstring_key_type* wstring_key(std::wstring *val, std::wstring def = _T(""));
-    string_key_type* string_key(std::string *val, std::string def = "");
-    int_key_type* int_key(int *val, int def = 0);
-    uint_key_type* uint_key(unsigned int *val, unsigned int def = 0);
-    bool_key_type* bool_key(bool *val, bool def = false);
-    wpath_key_type* wpath_key(std::wstring *val, std::wstring def = _T(""));
-
-    template<class T>
-    typed_key_fun<T, typed_int_value<T> >* int_fun_key(boost::function<void (T)> fun, T def) {
-      typed_key_fun<T, typed_int_value<T> >* r = new typed_key_fun<T, typed_int_value<T> >(fun, def);
+    boost::shared_ptr<wstring_key_type> wstring_key(std::wstring *val, std::wstring def = _T(""));
+    boost::shared_ptr<string_key_type> string_key(std::string *val, std::string def = "");
+    boost::shared_ptr<int_key_type> int_key(int *val, int def = 0);
+    boost::shared_ptr<uint_key_type> uint_key(unsigned int *val, unsigned int def = 0);
+    boost::shared_ptr<bool_key_type> bool_key(bool *val, bool def = false);
+    boost::shared_ptr<wpath_key_type> wpath_key(std::wstring *val, std::wstring def = _T(""));
+
+    template<class T>
+    boost::shared_ptr<typed_key_fun<T, typed_int_value<T> > > int_fun_key(boost::function<void (T)> fun, T def) {
+      boost::shared_ptr<typed_key_fun<T, typed_int_value<T> > > r(new typed_key_fun<T, typed_int_value<T> >(fun, def));
       return r;
     }
     template<class T>
-    typed_key_fun<T, typed_bool_value<T> >* bool_fun_key(boost::function<void (T)> fun, T def) {
-      typed_key_fun<T, typed_bool_value<T> >* r = new typed_key_fun<T, typed_bool_value<T> >(fun, def);
+    boost::shared_ptr<typed_key_fun<T, typed_bool_value<T> > > bool_fun_key(boost::function<void (T)> fun, T def) {
+      boost::shared_ptr<typed_key_fun<T, typed_bool_value<T> > > r(new typed_key_fun<T, typed_bool_value<T> >(fun, def));
       return r;
     }
     template<class T>
-    typed_key_fun<T, typed_string_value<T> >* string_fun_key(boost::function<void (T)> fun, T def) {
-      typed_key_fun<T, typed_string_value<T> >* r = new typed_key_fun<T, typed_string_value<T> >(fun, def);
+    boost::shared_ptr<typed_key_fun<T, typed_string_value<T> > > string_fun_key(boost::function<void (T)> fun, T def) {
+      boost::shared_ptr<typed_key_fun<T, typed_string_value<T> > > r(new typed_key_fun<T, typed_string_value<T> >(fun, def));
       return r;
     }
@@ -285 +285 @@
 
 
-    typed_path_fun* fun_path(boost::function<void (std::wstring)> fun);
-    typed_path_fun_value* fun_values_path(boost::function<void (std::wstring,std::wstring)> fun);
-    typed_path_map<>* wstring_map_path(std::map<std::wstring,std::wstring> *val);
-    typed_path_list* wstring_list_path(std::list<std::wstring> *val);
+    boost::shared_ptr<typed_path_fun> fun_path(boost::function<void (std::wstring)> fun);
+    boost::shared_ptr<typed_path_fun_value> fun_values_path(boost::function<void (std::wstring,std::wstring)> fun);
+    boost::shared_ptr<typed_path_map<> > wstring_map_path(std::map<std::wstring,std::wstring> *val);
+    boost::shared_ptr<typed_path_list> wstring_list_path(std::list<std::wstring> *val);
 
     struct description_container {
@@ -328 +328 @@
       description_container description;
 
-      key_info(std::wstring path_, std::wstring key_name_, key_interface* key, description_container description_) 
+      key_info(std::wstring path_, std::wstring key_name_, boost::shared_ptr<key_interface> key, description_container description_) 
         : path(path_)
         , key_name(key_name_)
@@ -359 +359 @@
 
       path_info(std::wstring path_name, description_container description_) : path_name(path_name), description(description_) {}
-      path_info(std::wstring path_name, path_interface* path, description_container description_) : path_name(path_name), path(path), description(description_) {}
+      path_info(std::wstring path_name, boost::shared_ptr<path_interface> path, description_container description_) : path_name(path_name), path(path), description(description_) {}
 
       path_info(const path_info& obj) : path_name(obj.path_name), description(obj.description), path(obj.path) {}
@@ -377 +377 @@
       settings_paths_easy_init(std::wstring path, settings_registry* owner) : path_(path), owner(owner) {}
 
-      settings_paths_easy_init& operator()(path_interface *value, std::wstring title, std::wstring description) {
+      settings_paths_easy_init& operator()(boost::shared_ptr<path_interface> value, std::wstring title, std::wstring description) {
         boost::shared_ptr<path_info> d(new path_info(path_, value, description_container(title, description)));
         add(d);
@@ -394 +394 @@
         return *this;
       }
-      settings_paths_easy_init& operator()(std::wstring path, path_interface *value, std::wstring title, std::wstring description) {
+      settings_paths_easy_init& operator()(std::wstring path, boost::shared_ptr<path_interface> value, std::wstring title, std::wstring description) {
         if (!path_.empty())
           path = path_ + _T("/") + path;
@@ -415 +415 @@
       settings_keys_easy_init(std::wstring path, std::wstring parent, settings_registry* owner_) : owner(owner_), path_(path), parent_(parent) {}
 
-      settings_keys_easy_init& operator()(std::wstring path, std::wstring key_name, key_interface *value, std::wstring title, std::wstring description) {
+      settings_keys_easy_init& operator()(std::wstring path, std::wstring key_name, boost::shared_ptr<key_interface> value, std::wstring title, std::wstring description) {
         boost::shared_ptr<key_info> d(new key_info(path, key_name, value, description_container(title, description)));
         if (!parent_.empty())
@@ -423 +423 @@
       }
 
-      settings_keys_easy_init& operator()(std::wstring key_name, key_interface* value, std::wstring title, std::wstring description) {
+      settings_keys_easy_init& operator()(std::wstring key_name, boost::shared_ptr<key_interface> value, std::wstring title, std::wstring description) {
         boost::shared_ptr<key_info> d(new key_info(path_, key_name, value, description_container(title, description)));
         if (!parent_.empty())

include/settings/settings_core.hpp

@@ -36 +36 @@
 
 
-  class settings_exception {
-    std::wstring error_;
+  class settings_exception : std::exception {
+    std::string error_;
   public:
     //////////////////////////////////////////////////////////////////////////
@@ -44 +44 @@
     ///
     /// @author mickem
-    settings_exception(std::wstring error) : error_(error) {}
+    settings_exception(std::wstring error) : error_(utf8::cvt<std::string>(error)) {}
+    settings_exception(std::string error) : error_(utf8::cvt<std::string>(error)) {}
+    ~settings_exception() throw() {}
 
     //////////////////////////////////////////////////////////////////////////
@@ -51 +53 @@
     ///
     /// @author mickem
-    std::wstring getError() const { return error_; }
-    std::wstring getMessage() const { return error_; }
+    std::wstring getError() const { return wwhat(); }
+    std::wstring getMessage() const { return wwhat(); }
+    const char* what() const throw() {
+      return error_.c_str();
+    }
+    const std::wstring wwhat() const throw() {
+      return utf8::to_unicode(error_);
+    }
   };
   class KeyNotFoundException : public settings_exception {

modules/CheckNSCP/CheckNSCP.cpp

@@ -76 +76 @@
 }
 void CheckNSCP::handleMessage(int msgType, const std::string file, int line, std::string message) {
-  if (msgType != NSCAPI::error||msgType != NSCAPI::critical)
+  if (msgType > NSCAPI::log_level::error)
     return;
   std::string err = render(msgType, file, line, message);

modules/CheckSystem/PDHCollector.cpp

@@ -123 +123 @@
       {
         ReadLock lock(&mutex_, true, 5000);
-        if (!lock.IsLocked()) 
+        if (!lock.IsLocked()) {
           NSC_LOG_ERROR(_T("Failed to get Mutex!"));
-        else {
+        } else {
           try {
             pdh.gatherData();
@@ -204 +204 @@
 */
 void PDHCollector::exitThread(void) {
-  if (hStopEvent_ == NULL)
+  if (hStopEvent_ == NULL) {
     NSC_LOG_ERROR(_T("Stop event is not created!"));
-  else if (!SetEvent(hStopEvent_)) {
+  } else if (!SetEvent(hStopEvent_)) {
       NSC_LOG_ERROR_STD(_T("SetStopEvent failed"));
   }

modules/DistributedServer/handler_impl.hpp

@@ -36 +36 @@
 
   void log_debug(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::debug, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
+      GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
+    }
   }
   void log_error(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::error, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
+      GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);
+    }
   }
 };

modules/FileLogger/FileLogger.cpp

@@ -166 +166 @@
   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, __FILE__, __LINE__, hello);
-  handleMessage(NSCAPI::log, __FILE__, __LINE__, "Log path is: " + file_);
+  handleMessage(NSCAPI::log_level::log, __FILE__, __LINE__, hello);
+  handleMessage(NSCAPI::log_level::log, __FILE__, __LINE__, "Log path is: " + file_);
   return true;
 }

modules/LUAScript/script_wrapper.hpp

@@ -261 +261 @@
     }
     static int info (lua_State *L) {
-      return log_any(L, NSCAPI::log);
+      return log_any(L, NSCAPI::log_level::info);
     }
     static int error (lua_State *L) {
-      return log_any(L, NSCAPI::error);
+      return log_any(L, NSCAPI::log_level::error);
     }
     static int log_any(lua_State *L, int mode) {

modules/NRPEServer/handler_impl.hpp

@@ -39 +39 @@
 
   void log_debug(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::debug, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
+      GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
+    }
   }
   void log_error(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::error, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
+      GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);
+    }
   }
 };

modules/NSCAClient/NSCAClient.cpp

@@ -125 +125 @@
     if (hostname_ == "auto") {
       hostname_ = boost::asio::ip::host_name();
-
     }
 
@@ -134 +133 @@
     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);
+      nscapi::target_handler::target target = *t;
+      if (!target.has_option("encryption"))
+        target.options[_T("encryption")] = encryption;
+      if (!target.has_option("timeout"))
+        target.options[_T("timeout")] = strEx::itos(timeout);
+      if (!target.has_option("payload length"))
+        target.options[_T("payload length")] = strEx::itos(payload_length);
+      if (!target.has_option("time offset"))
+        target.options[_T("time offset")] = utf8::cvt<std::wstring>(delay);
+      if (!target.has_option("password"))
+        target.options[_T("password")] = password;
+      if (target.address.empty())
+        target.address = _T("nsca://") + nscahost + _T(":") + strEx::itos(nscaport);
+      targets.add(target);
     } else {
       NSC_LOG_ERROR(_T("Default target not found!"));
@@ -170 +170 @@
       std::wstring name;
       try {
-        nsca::nsca_encrypt::any_encryption *core = nsca::nsca_encrypt::get_encryption_core(i);
+        boost::shared_ptr<nsca::nsca_encrypt::any_encryption> core(nsca::nsca_encrypt::get_encryption_core(i));
         if (core == NULL)
           name = _T("Broken<NULL>");
@@ -292 +292 @@
   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 (...) {}
+    if (t.address.empty()) {
+      if (t.host.empty())
+        url.host = t.host;
+      if (t.has_option("port")) {
+        try {
+          url.port = strEx::stoi(t.options[_T("port")]);
+        } catch (...) {}
+      }
+    } else {
+      url = net::parse(t.address);
     }
     std::string keys[] = {"encryption", "timeout", "payload length", "password", "time offset"};

modules/NSCAServer/handler_impl.hpp

@@ -54 +54 @@
 
   void log_debug(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::debug, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
+      GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
+    }
   }
   void log_error(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::error, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
+      GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);
+    }
   }
 };

modules/NSCPServer/handler_impl.hpp

@@ -36 +36 @@
 
   void log_debug(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::debug, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
+      GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
+    }
   }
   void log_error(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::error, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
+      GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);
+    }
   }
 };

modules/NSClientServer/handler_impl.hpp

@@ -31 +31 @@
 
   void log_debug(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::debug, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::debug)) {
+      GET_CORE()->log(NSCAPI::log_level::debug, file, line, msg);
+    }
   }
   void log_error(std::string file, int line, std::wstring msg) {
-    GET_CORE()->log(NSCAPI::error, file, line, msg);
+    if (GET_CORE()->should_log(NSCAPI::log_level::error)) {
+      GET_CORE()->log(NSCAPI::log_level::error, file, line, msg);
+    }
   }
 

modules/Scheduler/simple_scheduler.cpp

@@ -67 +67 @@
           log_error(_T("NOONE IS HANDLING scheduled item ") + to_wstring((*instance).schedule_id) + _T(" ") + to_wstring(off.total_seconds()) + _T(" seconds to late from thread ") + to_wstring(id));
         }
-      } else {
-        log_error(_T("Nothing is scheduled to run"));
+//      } else {
+//        log_error(_T("Nothing is scheduled to run"));
       }
 

scripts/python/lib/test_helper.py

@@ -1 @@
-from NSCP import Settings, Registry, Core, log, log_error, status
+from NSCP import Settings, Registry, Core, log, log_debug, log_error, status
 import os
 import inspect
@@ -33 +33 @@
   global test_manager
   if not test_manager:
-    log('=== Creating new Test manager ===')
     test_manager = TestManager(plugin_id, plugin_alias, script_alias)
     
@@ -43 +42 @@
 
     reg.simple_function('py_unittest', run_tests, 'Run python unit test suite')
-  else:
-    log('=== Reusing existing testmanager ===')
   
   return test_manager
@@ -82 +79 @@
 def setup_singleton(klass, src = None):
   klass.getInstance = SingletonHelper(klass)
-  log('Setting path: %s'%src)
   if not src:
     cf = inspect.currentframe()
@@ -90 +86 @@
         src = bf.f_code.co_filename
   klass.__source__ = src
-  log('==>%s'%src)
 
 class BasicTest(object):
@@ -118 +113 @@
     conf = Settings.get()
     conf.set_string('/modules', 'pytest', 'PythonScript')
-    log('==> %s'%self.__source__)
     fn = os.path.basename(self.__source__)
     (sn, ext) = os.path.splitext(fn)
@@ -152 +146 @@
   def log(self, prefix = '', indent = 0):
     if self.status:
-      log('%s%s%s'%(prefix, ''.rjust(indent, ' '), self))
+      log_debug('%s%s%s'%(prefix, ''.rjust(indent, ' '), self))
     else:
       log_error('%s%s%s'%(prefix, ''.rjust(indent, ' '), self))
@@ -189 +183 @@
     start = '%s%s'%(prefix, ''.rjust(indent, ' '))
     if self.status:
-      log('%s%s'%(start, self))
+      log_debug('%s%s'%(start, self))
     else:
       log_error('%s%s'%(start, self))
@@ -199 +193 @@
 
   def count(self):
-    total_count = 1
+    total_count = 0
     ok_count = 0
-    if self.status:
-      ok_count = 1
+    #if self.status:
+    # ok_count = 1
 
     for c in self.children:
@@ -278 +272 @@
   def return_nagios(self):
     (total, ok) = self.count()
-    log(' | Test result log (only summary will be returned to query)')
+    log_debug(' | Test result log (only summary will be returned to query)')
     self.log(' | ')
     if total == ok:

service/CMakeLists.txt

@@ -102 +102 @@
 # SET_TARGET_PROPERTIES(${TARGET} PROPERTIES LINK_FLAGS "/MANIFESTUAC:\"level='requireAdministrator' uiAccess='false'\" /SUBSYSTEM:WINDOWS")
 #ENDIF(WIN32)
-#INSTALL(TARGETS ${TARGET} RUNTIME DESTINATION .)
-
-#INSTALL(CODE "SET(PDB_FULL_PATH ${BUILD_TARGET_EXE_PATH}/${TARGET}.pdb)")
-#INSTALL(CODE "FILE(INSTALL DESTINATION \${CMAKE_INSTALL_PREFIX} TYPE EXECUTABLE FILES \${PDB_FULL_PATH})")
+INSTALL(TARGETS ${TARGET} RUNTIME DESTINATION .)
+INSTALL(CODE "SET(PDB_FULL_PATH ${BUILD_TARGET_EXE_PATH}/${TARGET}.pdb)")
+INSTALL(CODE "FILE(INSTALL DESTINATION \${CMAKE_INSTALL_PREFIX} TYPE EXECUTABLE FILES \${PDB_FULL_PATH})")
 
 SOURCE_GROUP("NSCP API" REGULAR_EXPRESSION .*include/nscapi/.*)

service/NSClient++.cpp

@@ -73 +73 @@
 }
 
-#define LOG_CRITICAL_CORE(msg) { std::string s = nsclient::logger_helper::create_error(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
+#define LOG_CRITICAL_CORE(msg) if (mainClient.should_log(NSCAPI::log_level::critical)) { std::string s = nsclient::logger_helper::create_error(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
 #define LOG_CRITICAL_CORE_STD(msg) LOG_CRITICAL_CORE(std::wstring(msg))
-#define LOG_ERROR_CORE(msg) { std::string s = nsclient::logger_helper::create_error(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
+#define LOG_ERROR_CORE(msg) if (mainClient.should_log(NSCAPI::log_level::error)) { std::string s = nsclient::logger_helper::create_error(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
 #define LOG_ERROR_CORE_STD(msg) LOG_ERROR_CORE(std::wstring(msg))
-#define LOG_INFO_CORE(msg) { std::string s = nsclient::logger_helper::create_info(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
+#define LOG_INFO_CORE(msg) if (mainClient.should_log(NSCAPI::log_level::info)) { std::string s = nsclient::logger_helper::create_info(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
 #define LOG_INFO_CORE_STD(msg) LOG_INFO_CORE(std::wstring(msg))
-#define LOG_DEBUG_CORE(msg) { if (mainClient.logDebug()) { std::string s = nsclient::logger_helper::create_debug(__FILE__, __LINE__, msg); mainClient.reportMessage(s); } }
+#define LOG_DEBUG_CORE(msg) if (mainClient.should_log(NSCAPI::log_level::debug)) { std::string s = nsclient::logger_helper::create_debug(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
 #define LOG_DEBUG_CORE_STD(msg) LOG_DEBUG_CORE(std::wstring(msg))
+#define LOG_TRACE_CORE(msg) if (mainClient.should_log(NSCAPI::log_level::trace)) { std::string s = nsclient::logger_helper::create_debug(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
+#define LOG_TRACE_CORE_STD(msg) LOG_DEBUG_CORE(std::wstring(msg))
 
 /**
@@ -1111 +1113 @@
 NSCAPI::nagiosReturn NSClientT::injectRAW(const wchar_t* raw_command, std::string &request, std::string &response) {
   std::wstring cmd = nsclient::commands::make_key(raw_command);
-  if (logDebug()) {
-    LOG_DEBUG_CORE_STD(_T("Injecting: ") + cmd + _T("..."));
-  }
+  LOG_DEBUG_CORE_STD(_T("Injecting: ") + cmd + _T("..."));
   /*if (shared_client_.get() != NULL && shared_client_->hasMaster()) {
     try {
@@ -1431 +1431 @@
 }
 
-bool NSClientT::logDebug() {
-  if (debug_ == log_state_unknown) {
-    debug_ = log_state_looking;
+NSCAPI::log_level::level NSClientT::get_loglevel() {
+  if (log_status_ == log_state_unknown) {
+    log_status_ = log_state_looking;
     try {
-      if (settings_manager::get_settings_no_wait()->get_bool(_T("log"), _T("debug"), false) == 1)
-        debug_ = log_state_debug;
-      else
-        debug_ = log_state_nodebug;
+      if (settings_manager::get_settings_no_wait()->get_bool(_T("log"), _T("debug"), false) == 1) {
+        log_level_ = nscapi::logging::parse(_T("debug"));
+        log_status_ = log_state_set;
+      } else {
+        std::wstring level = settings_manager::get_settings_no_wait()->get_string(_T("log"), _T("level"), _T("service"));
+        log_level_ = nscapi::logging::parse(level);
+        log_status_ = log_state_set;
+      }
     } catch (settings::settings_exception e) {
-      debug_ = log_state_unknown;
-      return false;
-    }
-  } else if (debug_ == log_state_looking) 
-    return false;
-  return (debug_ == log_state_debug);
+      log_status_ = log_state_unknown;
+    }
+  }
+  return log_level_;
+}
+
+bool NSClientT::should_log(NSCAPI::nagiosReturn level) {
+  return nscapi::logging::matches(get_loglevel(), level);
+}
+void NSClientT::set_loglevel(std::wstring level) {
+  log_status_ = log_state_set;
+  NSCAPI::log_level::level new_log_level = nscapi::logging::parse(level);
+  if (new_log_level != log_level_) {
+    //update_log_level() TODO
+    log_level_ = new_log_level;
+  }
 }
 

service/NSClient++.h

@@ -24 +24 @@
 #include <com_helpers.hpp>
 #endif
+
 
 #include <types.hpp>
@@ -97 +98 @@
   //boost::shared_mutex m_mutexRWcmdDescriptions;
   //cmdMap cmdDescriptions_;
-  enum log_status {log_state_unknown, log_state_looking, log_state_debug, log_state_nodebug };
-  log_status debug_;
+  enum log_status {log_state_unknown, log_state_looking, log_state_set };
+  log_status log_status_;
+  NSCAPI::log_level::level log_level_;
   std::wstring context_;
 #ifdef WIN32
@@ -119 +121 @@
   typedef std::multimap<std::wstring,std::wstring> plugin_alias_list_type;
   // c-tor, d-tor
-  NSClientT(void) : debug_(log_state_unknown), enable_shared_session_(false), commands_(this), channels_(this), routers_(this), next_plugin_id_(0), service_name_(DEFAULT_SERVICE_NAME) {
+  NSClientT(void) : log_status_(log_state_unknown), log_level_(NSCAPI::log_level::log), enable_shared_session_(false), commands_(this), channels_(this), routers_(this), next_plugin_id_(0), service_name_(DEFAULT_SERVICE_NAME) {
     logger_master_.start_slave();
   }
   virtual ~NSClientT(void) {}
-  void enableDebug(bool debug = true) {
-    if (debug)
-      debug_ = log_state_debug;
-    else
-      debug_ = log_state_nodebug;
-  }
+  NSCAPI::log_level::level get_loglevel();
+  void set_loglevel(std::wstring level);
 
   // Service helper functions
@@ -213 +211 @@
   void startTrayIcon(DWORD dwSessionId);
 
-  bool logDebug();
+  bool should_log(NSCAPI::nagiosReturn level);
   void listPlugins();
   plugin_info_list get_all_plugins();

service/cli_parser.hpp

@@ -15 +15 @@
   po::options_description common;
 
-  bool debug;
   bool help;
   bool version;
+  std::wstring log_level;
+  std::wstring settings_store;
 
 public:
@@ -27 +28 @@
     , service("Service Options")
     , client("Client Options")
-    , debug(false)
     , help(false)
     , version(false)
@@ -37 +37 @@
       ("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")
       ;
     common.add_options()
+      ("settings", po::value<std::wstring>(&settings_store), "Override (temporarily) settings subsystem to use")
       ("help", po::bool_switch(&help), "produce help message")
-      ("debug", po::bool_switch(&debug), "Show debug information")
+      ("debug", "Set log level to debug (and show debug information)")
+      ("log", po::value<std::wstring>(&log_level), "The log level to use")
       ("version", po::bool_switch(&version), "Show version information")
       ;
 
     settings.add_options()
-      ("settings", po::value<std::wstring>(), "Override (temporarily) settings subsystem to use")
       ("migrate-to", po::value<std::wstring>(), "Migrate (copy) settings from current store to target store")
       ("migrate-from", po::value<std::wstring>(), "Migrate (copy) settings from current store to target store")
@@ -80 +82 @@
       ("query,q", po::value<std::wstring>(), "Run a query with a given name")
       ("submit,s", po::value<std::wstring>(), "Name of query to ask")
-      ("settings", po::value<std::wstring>(), "Override (temporarily) settings subsystem to use")
       ("module,M", po::value<std::wstring>(), "Name of module to load (if not specified all modules in ini file will be loaded)")
       ("argument,a", po::wvalue<std::vector<std::wstring> >(), "List of arguments (gets -- prefixed automatically)")
@@ -90 +91 @@
   bool process_common_options(std::string context, po::options_description &desc) {
     core_->set_console_log();
-    if (debug) {
-      core_->enableDebug(true);
-      core_->log_debug(__FILE__, __LINE__, _T("Enabling debug mode"));
-    }
+    if (!log_level.empty())
+      core_->set_loglevel(log_level);
+    if (!settings_store.empty())
+      core_->set_settings_context(settings_store);
 
     if (help) {
@@ -184 +185 @@
 
     core_->set_console_log();
-    core_->enableDebug(true);
-
-//    if (argc > 2 && wcscasecmp( _T("server"), argv[2] ) == 0 ) {
-//      server = true;
-//    }
-//    std::wcout << "Launching test mode - " << (server?_T("server mode"):_T("client mode")) << std::endl;
-//    LOG_MESSAGE_STD(_T("Booting: ") SZSERVICEDISPLAYNAME );
-    nsclient::simple_client client(core_);
-    client.start();
-    return 0;
+    core_->set_loglevel(_T("debug"));
+
+
+    try {
+      po::options_description all("Allowed options (settings)");
+      all.add(common).add(settings);
+
+      po::variables_map vm;
+      po::store(po::parse_command_line(argc, argv, all), vm);
+      po::notify(vm);
+
+      if (process_common_options("settings", all))
+        return 1;
+
+      nsclient::simple_client client(core_);
+      client.start();
+      return 0;
+    } catch(std::exception & e) {
+      mainClient.log_error(__FILE__, __LINE__, std::string("Unable to parse command line (settings): ") + e.what());
+      return 1;
+    }
   }
 
@@ -287 +299 @@
         mainClient.log_info(__FILE__, __LINE__, _T("TODO retrieve name from service here"));
       }
-      if (debug) {
+      if (mainClient.should_log(NSCAPI::log_level::debug)) {
         mainClient.log_info(__FILE__, __LINE__, _T("Service name: ") + name);
         mainClient.log_info(__FILE__, __LINE__, _T("Service description: ") + desc);
@@ -294 +306 @@
       if (vm.count("run")) {
         try {
-          mainClient.enableDebug(true);
           mainClient.start_and_wait(name);
         } catch (...) {
@@ -395 +406 @@
       }
 
-      if (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);
@@ -407 +418 @@
         mainClient.log_info(__FILE__, __LINE__, _T("Arguments: ") + args);
       }
-      if (vm.count("settings"))
-        core_->set_settings_context(vm["settings"].as<std::wstring>());
 
       core_->boot_init();
@@ -453 +462 @@
       }
       return ret;
-    } catch(std::exception & e) {
+    } catch(const std::exception & e) {
       std::wcerr << _T("Client: Unable to parse command line: ") << utf8::to_unicode(e.what()) << std::endl;
       return 1;

service/core_api.cpp

@@ -169 +169 @@
 
 NSCAPI::boolReturn NSAPICheckLogMessages(int messageType) {
-  if (mainClient.logDebug())
-    return NSCAPI::istrue;
-  return NSCAPI::isfalse;
+  return mainClient.should_log(messageType);
 }
 
@@ -513 +511 @@
   if (wcscasecmp(buffer, _T("NSAPIReload")) == 0)
     return reinterpret_cast<LPVOID>(&NSAPIReload);
+  if (wcscasecmp(buffer, _T("NSAPIGetLoglevel")) == 0)
+    return reinterpret_cast<LPVOID>(&NSAPIGetLoglevel);
 
   LOG_ERROR_STD(_T("Function not found: ") + buffer);
@@ -541 +541 @@
   delete [] *buffer;
 }
+
+NSCAPI::log_level::level NSAPIGetLoglevel() {
+  return mainClient.get_loglevel();
+}

service/core_api.h

@@ -67 +67 @@
 NSCAPI::errorReturn NSAPIRegisterRoutingListener(unsigned int plugin_id, const wchar_t* channel);
 NSCAPI::errorReturn NSAPIReload(const wchar_t*);
+NSCAPI::log_level::level NSAPIGetLoglevel();

service/logger.hpp

@@ -151 +151 @@
         int code = nscapi::functions::gpb_to_log(l);
         switch (code) {
-          case NSCAPI::critical:
+          case NSCAPI::log_level::critical:
             return _T("c");
-          case NSCAPI::warning:
+          case NSCAPI::log_level::warning:
             return _T("w");
-          case NSCAPI::error:
+          case NSCAPI::log_level::error:
             return _T("e");
-          case NSCAPI::log:
+          case NSCAPI::log_level::log:
             return _T("l");
-          case NSCAPI::debug:
+          case NSCAPI::log_level::debug:
             return _T("d");
           default:

service/settings_logger_impl.cpp

@@ -11 +11 @@
 /// @author mickem
 void settings_logger::err(std::string file, int line, std::wstring message) {
+  if (!mainClient.should_log(NSCAPI::log_level::error))
+    return;
   std::string s = nsclient::logger_helper::create_error(file.c_str(), line, message.c_str());
   mainClient.reportMessage(s);
@@ -23 +25 @@
 /// @author mickem
 void settings_logger::warn(std::string file, int line, std::wstring message) {
+  if (!mainClient.should_log(NSCAPI::log_level::warning))
+    return;
   std::string s = nsclient::logger_helper::create_warning(file.c_str(), line, message.c_str());
   mainClient.reportMessage(s);
@@ -35 +39 @@
 /// @author mickem
 void settings_logger::info(std::string file, int line, std::wstring message) {
+  if (!mainClient.should_log(NSCAPI::log_level::info))
+    return;
   std::string s = nsclient::logger_helper::create_info(file.c_str(), line, message.c_str());
   mainClient.reportMessage(s);
@@ -47 +53 @@
 /// @author mickem
 void settings_logger::debug(std::string file, int line, std::wstring message) {
-  if (!mainClient.logDebug())
+  if (!mainClient.should_log(NSCAPI::log_level::debug))
     return;
   std::string s = nsclient::logger_helper::create_debug(file.c_str(), line, message.c_str());

service/simple_client.hpp

@@ -14 +14 @@
     }
     void start() {
-      core_->enableDebug(true);
       if (!core_->boot_init()) {
         core_->log_error(__FILE__, __LINE__, _T("Service failed to init"));
@@ -58 +57 @@
           for (std::list<std::wstring>::const_iterator cit = lst.begin(); cit!=lst.end();++cit)
             log(_T("| ") + *cit + _T(": ") + core_->describeCommand(*cit));
-        } else if (s == _T("debug off")) {
-          log(_T("Setting debug log off..."));
-          core_->enableDebug(false);
-        } else if (s == _T("debug on")) {
-          log(_T("Setting debug log on..."));
-          core_->enableDebug(true);
+        } else if (s.size() > 4 && s.substr(0,3) == _T("log")) {
+          log(_T("Setting log to: ") + s.substr(4));
+          core_->set_loglevel(s.substr(4));
         } else if (s == _T("reattach")) {
           log(_T("Reattaching to session 0"));

version.hpp

@@ -1 +1 @@
 #ifndef VERSION_HPP
 #define VERSION_HPP
-#define PRODUCTVER     0,4,0,126
-#define STRPRODUCTVER  "0,4,0,126"
-#define STRPRODUCTDATE "2012-01-20"
+#define PRODUCTVER     0,4,0,129
+#define STRPRODUCTVER  "0,4,0,129"
+#define STRPRODUCTDATE "2012-01-21"
 #endif // VERSION_HPP

version.txt

@@ -1 +1 @@
 version=0.4.0
-build=126
-date=2012-01-20
+build=129
+date=2012-01-21