Changeset 8988f9e in nscp

Timestamp:

08/01/10 13:55:49 (3 years ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

294b37b

Parents:

fe9cc46

Message:

Added in performance e data for NRPE and NSCA as well as added in debug build for the protocol buffer library lookup thingy

Files:

• CMakeLists.txt (modified) (1 diff)
• cmake/NSCPPBuffer.cmake (modified) (1 diff)
• include/nscapi/nscapi_core_wrapper.cpp (modified) (2 diffs)
• include/nscapi/nscapi_plugin_wrapper.hpp (modified) (3 diffs)
• include/strEx.h (modified) (1 diff)
• libs/protobuf/plugin.proto (modified) (2 diffs)
• modules/NRPEServer/NRPEServer.h (modified) (1 diff)
• modules/NRPEServer/nrpe_handler.cpp (modified) (2 diffs)
• modules/NRPEServer/nrpe_handler.hpp (modified) (1 diff)
• modules/NRPEServer/nrpe_server.cpp (modified) (3 diffs)
• modules/NSCAAgent/NSCAAgent.cpp (modified) (2 diffs)

CMakeLists.txt

@@ -38 +38 @@
 IF(WIN32 AND MSVC)
   SET(PROTOBUF_INCLUDE_DIR "${PROTOBUF_DIR}/src" "Path to google protocol buffer source")
-  SET(PROTOBUF_LIBRARYDIR "${PROTOBUF_DIR}/vsprojects/x64/Release")
+  SET(PROTOBUF_LIBRARYDIR_RELEASE "${PROTOBUF_DIR}/vsprojects/x64/Release")
+  SET(PROTOBUF_LIBRARYDIR_DEBUG "${PROTOBUF_DIR}/vsprojects/x64/Debug")
   SET(PROTOBUF_BINARYDIR "${PROTOBUF_DIR}/vsprojects/debug")
 ELSE(WIN32 AND MSVC)

cmake/NSCPPBuffer.cmake

@@ -33 +33 @@
   )
 
-  FIND_LIBRARY(PROTOBUF_LIBRARY NAMES protobuf libprotobuf
+  FIND_LIBRARY(PROTOBUF_LIBRARY_RELEASE 
+  NAMES protobuf libprotobuf
     PATHS
     ${GNUWIN32_DIR}/lib
+  ${PROTOBUF_LIBRARYDIR_RELEASE}
   ${PROTOBUF_LIBRARYDIR}
   )
-
+  FIND_LIBRARY(PROTOBUF_LIBRARY_DEBUG 
+  NAMES protobuf libprotobuf
+    PATHS
+    ${GNUWIN32_DIR}/lib
+  ${PROTOBUF_LIBRARYDIR_DEBUG}
+  ${PROTOBUF_LIBRARYDIR}
+  )
+  SET(PROTOBUF_LIBRARY
+    debug ${PROTOBUF_LIBRARY_DEBUG}
+    optimized ${PROTOBUF_LIBRARY_RELEASE}
+  )
+  
+  
   FIND_PROGRAM(PROTOBUF_PROTOC_EXECUTABLE protoc)
   IF(NOT PROTOBUF_PROTOC_EXECUTABLE)

include/nscapi/nscapi_core_wrapper.cpp

@@ -24 +24 @@
 
 #include <nscapi/nscapi_core_wrapper.hpp>
+#include <nscapi/nscapi_plugin_wrapper.hpp>
 #include <settings/macros.h>
 #include <arrayBuffer.h>
@@ -134 +135 @@
       return NSCAPI::returnUNKNOWN;
     }
-    msg = to_wstring(rsp_msg.payload(0).message());
+    ::PluginCommand::Response payload = rsp_msg.payload(0);
+    msg = to_wstring(payload.message());
+    CORE_LOG_ERROR_STD(_T("Attempting to parse perf data"));
+    perf = to_wstring(::nscapi::functions::build_performance_data(payload));
+    CORE_LOG_ERROR_STD(_T("Attempting to parse perf data: '") + perf + _T("'"));
   }
   return ret;

include/nscapi/nscapi_plugin_wrapper.hpp

@@ -94 +94 @@
   extern helper_singleton* plugin_singleton;
 
+  class functions {
+  public:
+    static PluginCommand::Response_Code nagios_to_gpb(int ret) {
+      if (ret == NSCAPI::returnOK)
+        return PluginCommand::Response_Code_OK;
+      if (ret == NSCAPI::returnWARN)
+        return PluginCommand::Response_Code_WARNING;
+      if (ret == NSCAPI::returnCRIT)
+        return PluginCommand::Response_Code_CRITCAL;
+      return PluginCommand::Response_Code_UNKNOWN;
+    }
+
+    static double trim_to_double(std::wstring s) {
+      std::wstring::size_type pend = s.find_first_not_of(_T("0123456789,."));
+      if (pend != std::wstring::npos)
+        s = s.substr(0,pend);
+      strEx::replace(s, _T(","), _T("."));
+      return strEx::stod(s);
+    }
+
+    static void parse_performance_data(PluginCommand::Response *resp, std::wstring &perf) {
+      strEx::splitList items = strEx::splitEx(perf, _T(" "));
+      for (strEx::splitList::const_iterator cit = items.begin(); cit != items.end(); ++cit) {
+        strEx::splitVector items = strEx::splitV(*cit, _T(";"));
+        if (items.size() < 3)
+          break;
+
+        ::PluginCommand::PerformanceData* perfData = resp->add_perf();
+        perfData->set_type(PluginCommand::PerformanceData_Type_FLOAT);
+        std::pair<std::wstring,std::wstring> fitem = strEx::split(items[0], _T("="));
+        perfData->set_alias(to_string(fitem.first));
+        ::PluginCommand::PerformanceData_FloatValue* floatPerfData = perfData->mutable_float_value();
+
+        std::wstring::size_type pend = fitem.second.find_first_not_of(_T("0123456789,."));
+        if (pend == std::wstring::npos) {
+          floatPerfData->set_value(trim_to_double(fitem.second.c_str()));
+        } else {
+          floatPerfData->set_value(trim_to_double(fitem.second.substr(0,pend).c_str()));
+          floatPerfData->set_unit(to_string(fitem.second.substr(pend)));
+        }
+        floatPerfData->set_warning(trim_to_double(items[1]));
+        floatPerfData->set_critical(trim_to_double(items[2]));
+        if (items.size() >= 5) {
+          floatPerfData->set_minimum(trim_to_double(items[3]));
+          floatPerfData->set_maximum(trim_to_double(items[4]));
+        }
+      }
+    }
+    static std::string build_performance_data(::PluginCommand::Response &payload) {
+      std::string ret;
+      for (int i=0;i<payload.perf_size();i++) {
+        ::PluginCommand::PerformanceData perfData = payload.perf(i);
+        if (!ret.empty())
+          ret += " ";
+        ret += perfData.alias() + "=";
+        if (perfData.has_float_value()) {
+          ::PluginCommand::PerformanceData_FloatValue fval = perfData.float_value();
+          ret += to_string(fval.value());
+          if (fval.has_unit())
+            ret += fval.unit();
+          if (!fval.has_warning())  continue;
+          ret += ";" + to_string(fval.warning());
+          if (!fval.has_critical()) continue;
+          ret += ";" + to_string(fval.critical());
+          if (!fval.has_minimum())  continue;
+          ret += ";" + to_string(fval.minimum());
+          if (!fval.has_maximum())  continue;
+          ret += ";" + to_string(fval.maximum());
+        }
+      }
+      return ret;
+    }
+  };
+
   namespace impl {
 
@@ -108 +182 @@
 
           ::PluginCommand::Response payload = message.payload().Get(0);
+          
           std::list<std::wstring> args;
           for (int i=0;i<payload.arguments_size();i++) {
             args.push_back(to_wstring(payload.arguments(i)));
           }
-          std::wstring msg = to_wstring(payload.message()), perf;
+          std::wstring msg = to_wstring(payload.message());
+          std::wstring perf = to_wstring(::nscapi::functions::build_performance_data(payload));
           NSCAPI::nagiosReturn ret = handleSimpleNotification(channel, command, code, msg, perf);
         } catch (std::exception &e) {
@@ -155 +231 @@
         resp->set_command(to_string(command));
         resp->set_message(to_string(msg));
+        ::nscapi::functions::parse_performance_data(resp, perf);
+
         resp->set_version(PluginCommand::Response_Version_VERSION_1);
-        if (ret == NSCAPI::returnOK)
-          resp->set_result(PluginCommand::Response_Code_OK);
-        else if (ret == NSCAPI::returnWARN)
-          resp->set_result(PluginCommand::Response_Code_WARNING);
-        else if (ret == NSCAPI::returnCRIT)
-          resp->set_result(PluginCommand::Response_Code_CRITCAL);
-        else 
-          resp->set_result(PluginCommand::Response_Code_UNKNOWN);
-
+        resp->set_result(nscapi::functions::nagios_to_gpb(ret));
         response_message.SerializeToString(&response);
         return ret;

include/strEx.h

@@ -552 +552 @@
 
   typedef std::list<std::wstring> splitList;
-  inline splitList splitEx(std::wstring str, std::wstring key) {
+  inline splitList splitEx(const std::wstring str, const std::wstring key) {
     splitList ret;
+    std::wstring::size_type pos = 0, lpos = 0;
+    while ((pos = str.find(key, pos)) !=  std::wstring::npos) {
+      ret.push_back(str.substr(lpos, pos-lpos));
+      lpos = ++pos;
+    }
+    if (lpos < str.size())
+      ret.push_back(str.substr(lpos));
+    return ret;
+  }
+  typedef std::vector<std::wstring> splitVector;
+  inline splitVector splitV(const std::wstring str, const std::wstring key) {
+    splitVector ret;
     std::wstring::size_type pos = 0, lpos = 0;
     while ((pos = str.find(key, pos)) !=  std::wstring::npos) {

libs/protobuf/plugin.proto

@@ -37 +37 @@
   message IntValue {
     required int64 value = 1;
-    required int64 maximum = 2;
-    required int64 minimum = 3;
-    required string unit = 4;
+    optional string unit = 2;
+    optional int64 warning = 3;
+    optional int64 critical = 4;
+    optional int64 minimum = 6;
+    optional int64 maximum = 7;
   }
   message StringValue {
@@ -45 +47 @@
   }
   message FloatValue {
-    required float value = 1;
-    required float maximum = 2;
-    required float minimum = 3;
-    required string unit = 4;
+    required double value = 1;
+    optional string unit = 2;
+    optional double warning = 3;
+    optional double critical = 4;
+    optional double minimum = 6;
+    optional double maximum = 7;
   }
   required string alias = 1;

modules/NRPEServer/NRPEServer.h

@@ -54 +54 @@
   std::wstring getModuleName() {
 #ifdef USE_SSL
-    return _T("NRPE server (w/ SSL)");
+    return _T("NRPE server");
 #else
-    return _T("NRPE server");
+    return _T("NRPE server (no SSL)");
 #endif
   }

modules/NRPEServer/nrpe_handler.cpp

@@ -33 +33 @@
       NSCAPI::nagiosReturn ret = -3;
       try {
+        NSC_DEBUG_MSG_STD(_T("Running command: ") + cmd.first);
         ret = nscapi::plugin_singleton->get_core()->InjectSplitAndCommand(cmd.first, cmd.second, '!', msg, perf);
+        NSC_DEBUG_MSG_STD(_T("Running command: ") + cmd.first + _T(" = ") + msg);
       } catch (...) {
         return nrpe::packet::create_response(NSCAPI::returnUNKNOWN, _T("UNKNOWN: Internal exception"), p.get_payload_length());
@@ -50 +52 @@
         return nrpe::packet::create_response(NSCAPI::returnUNKNOWN, _T("UNKNOWN: Internal error."), p.get_payload_length());
       }
-      if (msg.length() >= p.get_payload_length()-1) {
+      std::wstring data = msg;
+      if (!perf.empty()&&!noPerfData_) {
+        data += _T("|") + perf;
+      }
+      if (data.length() >= p.get_payload_length()-1) {
         NSC_LOG_ERROR(_T("Truncating returndata as it is bigger then NRPE allowes :("));
-        msg = msg.substr(0,p.get_payload_length()-2);
+        data = data.substr(0,p.get_payload_length()-2);
       }
-      if (perf.empty()||noPerfData_) {
-        return nrpe::packet::create_response(ret, msg, p.get_payload_length());
-      } else {
-        return nrpe::packet::create_response(ret, msg + _T("|") + perf, p.get_payload_length());
-      }
+      return nrpe::packet::create_response(ret, data, p.get_payload_length());
     }
   }

modules/NRPEServer/nrpe_handler.hpp

@@ -11 +11 @@
     public:
       handler(unsigned int payload_length) 
-        : payload_length_(payload_length)
+        : payload_length_(payload_length), noPerfData_(false)
       {}
       handler(const handler &other) {

modules/NRPEServer/nrpe_server.cpp

@@ -7 +7 @@
 #include <vector>
 
+
 namespace nrpe {
   namespace server {
+
+    namespace ip = boost::asio::ip;
+
     server::server(const std::string& address, const std::string& port,
       const std::string& doc_root, std::size_t thread_pool_size)
@@ -18 +22 @@
     {
       // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
-      boost::asio::ip::tcp::resolver resolver(io_service_);
-      boost::asio::ip::tcp::resolver::query query(address, port);
-      boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
-      boost::asio::ip::tcp::resolver::iterator end;
+      ip::tcp::resolver resolver(io_service_);
+      ip::tcp::resolver::iterator endpoint_iterator;
+      if (address.empty()) {
+        endpoint_iterator = resolver.resolve(ip::tcp::resolver::query(port));
+      } else {
+        endpoint_iterator = resolver.resolve(ip::tcp::resolver::query(address, port));
+      }
+      ip::tcp::resolver::iterator end;
       if (endpoint_iterator == end) {
         std::cout << "Failed to lookup: " << address << ":" << port << std::endl;
       }
-      boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
+      ip::tcp::endpoint endpoint = *endpoint_iterator;
       std::cout << "Binding to: " << address << ":" << port << std::endl;
       acceptor_.open(endpoint.protocol());
-      acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
+      acceptor_.set_option(ip::tcp::acceptor::reuse_address(true));
       acceptor_.bind(endpoint);
       acceptor_.listen();
@@ -63 +71 @@
       std::cout << "accept: " << e.message() << std::endl;
       if (!e) {
+        std::string s = new_connection_->socket().remote_endpoint().address().to_string();
+        std::cout << "Connecting from: " << s <<std::endl;
+
         new_connection_->start();
         new_connection_.reset(new connection(io_service_, request_handler_));

modules/NSCAAgent/NSCAAgent.cpp

@@ -116 +116 @@
     boost::asio::io_service io_service;
     NSC_DEBUG_MSG_STD(_T("* * *NSCA * * * message: ") + msg);
+    NSC_DEBUG_MSG_STD(_T("* * *NSCA * * * påerformance: ") + perf);
     nsca::socket socket(io_service);
     socket.connect(nscahost_, nscaport_);
@@ -121 +122 @@
     packet.code = code;
     packet.host = "hello";
-    packet.result = to_string(msg);
+    packet.result = to_string(msg) + "|" + to_string(perf);
     socket.recv_iv(password_, encryption_method_, boost::posix_time::seconds(timeout_));
     socket.send_nsca(packet, boost::posix_time::seconds(timeout_));