Changeset 8840f09 in nscp

Timestamp:

08/26/11 13:40:23 (21 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

60e6c18

Parents:

d7e265d

Message:

• Fixed some issues in the NSCPClient
• Fixed debug log issue in core
• Added support for "pushing" passive checks via NSCP

Files:

• changelog (modified) (2 diffs)
• include/nscapi/macros.hpp (modified) (1 diff)
• include/nscp/client/socket.hpp (modified) (4 diffs)
• include/nscp/packet.hpp (modified) (3 diffs)
• include/nscp/server/connection.cpp (modified) (3 diffs)
• modules/NSCPClient/NSCPClient.cpp (modified) (13 diffs)
• modules/NSCPClient/NSCPClient.h (modified) (4 diffs)
• modules/NSCPServer/handler_impl.cpp (modified) (2 diffs)
• service/NSClient++.cpp (modified) (1 diff)

changelog

@@ -6 +6 @@
  * Fix RtlStringFromGUID problem on NT4
 
+2011-08-25 MickeM
+ * Fixed some issues in the NSCPClient
+ * Fixed debug log issue in core
+ * Added support for "pushing" passive checks via NSCP
+
 2011-08-24 MickeM
  * Sever refactoring of the new API (there is now two pb files ipc for NSCP protocol and plugin for plugin communication)
@@ -11 +16 @@
  * Fixed client argument for "client mode" to allow arbitrary arguments
  * Cleaned up the argument processor code now requires "mode" to be first argument
- * Fixed some issues in the NSCPClient
 
 2011-08-23 MickeM

include/nscapi/macros.hpp

@@ -216 +216 @@
     NSCAPI::nagiosReturn retCode = (&toObject)->commandRAWLineExec(command, request, response); \
     return GET_PLUGIN()->wrapCommandLineExec(retCode, response, response_buffer, response_len); \
+    } catch (const std::exception &e) { \
+    NSC_LOG_CRITICAL(_T("Exception in: commandLineExec(...)") + utf8::cvt<std::wstring>(e.what())); \
+      std::wcerr << _T("Exception in: commandLineExec(...)") << utf8::cvt<std::wstring>(e.what()) << std::endl; \
+      return NSCAPI::hasFailed; \
     } catch (...) { \
       NSC_LOG_CRITICAL(_T("Unknown exception in: commandLineExec(...)")); \

include/nscp/client/socket.hpp

@@ -62 +62 @@
       writer->start_timer(timeout);
       BOOST_FOREACH(const nscp::packet &chunk, chunks) {
+        std::wcout << _T(">>>") << chunk.signature.to_wstring() << std::endl;
         if (!writer->write_and_wait(*socket_, get_socket(), boost::asio::buffer(chunk.to_buffer()))) {
           std::cout << "FaILED TO SEND DATA..." << std::endl;
@@ -84 +85 @@
         }
         chunk.read_signature(buf);
-        std::wcout << chunk.signature.to_wstring() << std::endl;
+        std::wcout << _T("<<<") << chunk.signature.to_wstring() << std::endl;
         buf.resize(chunk.signature.payload_length);
 
@@ -138 +139 @@
       writer->start_timer(timeout);
       BOOST_FOREACH(const nscp::packet &chunk, chunks) {
+        std::wcout << _T(">>>") << chunk.signature.to_wstring() << std::endl;
         if (!writer->write_and_wait(*ssl_socket_, get_socket(), boost::asio::buffer(chunk.to_buffer()))) {
           std::cout << "FaILED TO SEND DATA..." << std::endl;
@@ -161 +163 @@
         }
         chunk.read_signature(buf);
-        std::wcout << chunk.signature.to_wstring() << std::endl;
+        std::wcout << _T("<<<") <<  chunk.signature.to_wstring() << std::endl;
         buf.resize(chunk.signature.payload_length);
 

include/nscp/packet.hpp

@@ -81 +81 @@
       }
 
-      std::wstring to_wstring() {
+      std::wstring to_wstring() const {
         std::wstringstream ss;
         ss << _T("version: ") << version 
@@ -179 +179 @@
     }
 
+    static packet build_envelope_response(unsigned long additionl_packets) {
+      nscp::data::signature_packet signature;
+      signature.header_length = 0;
+      signature.header_type = 0;
+
+      signature.additional_packet_count = additionl_packets;
+      signature.version = nscp::data::version_1;
+
+      std::string buffer;
+      NSCPIPC::RequestEnvelope request_envelope;
+      request_envelope.set_version(NSCPIPC::Common_Version_VERSION_1);
+      request_envelope.set_max_supported_version(NSCPIPC::Common_Version_VERSION_1);
+      request_envelope.SerializeToString(&buffer);
+
+      signature.payload_length = buffer.size();
+      signature.payload_type = nscp::data::envelope_response;
+
+      return packet(signature, "", buffer);
+    }
+
     static nscp::data::signature_packet create_simple_sig(int payload_type, std::string::size_type size) {
       nscp::data::signature_packet signature;
@@ -228 +248 @@
       return packet(signature, "", buffer);
     }
-    bool is_command_request() {
+    bool is_envelope_request() {
+      return signature.payload_type == nscp::data::envelope_request;
+    }
+    bool is_envelope_response() {
+      return signature.payload_type == nscp::data::envelope_response;
+    }
+    bool is_query_request() {
       return signature.payload_type == nscp::data::command_request;
     }
-    bool is_command_response() {
+    bool is_query_response() {
+      return signature.payload_type == nscp::data::command_response;
+    }
+    bool is_submit_message() {
       return signature.payload_type == nscp::data::command_response;
     }

include/nscp/server/connection.cpp

@@ -87 +87 @@
           start_read_request(buffer_, 30, helper);
         } else {
-          if (outbound_queue_.size() > 0)
-            outbound_queue_.push_front(nscp::packet::build_envelope_request(1));
-
           unsigned int count = outbound_queue_.size();
-          handler_->log_debug(__FILE__, __LINE__, _T("Sending responses: ") + strEx::itos(count));
+          outbound_queue_.push_front(nscp::packet::build_envelope_response(count));
           BOOST_FOREACH(nscp::packet &chunk, outbound_queue_) {
-            chunk.signature.additional_packet_count = --count;
+            chunk.signature.additional_packet_count = count--;
             std::string s = chunk.to_buffer();
-            handler_->log_debug(__FILE__, __LINE__, _T("Sending: ") + chunk.signature.to_wstring());
-            handler_->log_debug(__FILE__, __LINE__, _T("Sending: ") + utf8::cvt<std::wstring>(strEx::format_buffer(s.c_str(), s.size())));
-/*
-            std::vector<boost::asio::const_buffer> buffers;
-            response_buffers_.push_back(buf(s));
-            start_write_request(buffers);
-
-*/
+            handler_->log_debug(__FILE__, __LINE__, _T(">>>") + chunk.signature.to_wstring());
             response_buffers_.push_back(buf(s));
           }
@@ -116 +106 @@
       sig = parser_.parse_signature();
 
-      handler_->log_debug(__FILE__, __LINE__, _T("Got signature with: ") + strEx::itos(sig.payload_length));
+      handler_->log_debug(__FILE__, __LINE__, _T("<<<") + sig.to_wstring());
       if (sig.header_length > 0) {
         // @todo read header
@@ -125 +115 @@
 
     boost::tuple<bool, connection::process_helper> connection::process_payload() {
-      nscp::packet chunk(sig);
-      parser_.parse_payload(chunk);
-      handler_->log_debug(__FILE__, __LINE__, _T("Processing: ") + chunk.to_wstring());
-      std::list<nscp::packet> result = handler_->process(chunk);
-      outbound_queue_.insert(outbound_queue_.end(), result.begin(), result.end());
-      /*
+      nscp::packet packet(sig);
+      parser_.parse_payload(packet);
       if (sig.payload_type == nscp::data::envelope_request) {
-        NSCPEnvelope::Request envelope;
-        envelope.ParseFromString(result);
-        handler_->log_debug(__FILE__, __LINE__, _T("Got envelope: ") + strEx::itos(envelope.version()));
-      } else if (sig.payload_type == nscp::data::command_request) {
-        PluginCommand::RequestMessage msg;
-        msg.ParseFromString(result);
-        handler_->log_debug(__FILE__, __LINE__, _T("Proessing command: ") + utf8::cvt<std::wstring>(msg.payload(0).command()));
-        outbound_queue_.push_back(nscp::packet::build_payload(nscp::data::command_response, handler_->process(result), 0));
+        NSCPIPC::RequestEnvelope envelope;
+        envelope.ParseFromString(packet.payload);
       } else {
-        handler_->log_error(__FILE__, __LINE__, _T("Unhandled packet: ") + strEx::itos(sig.payload_type));
+        std::list<nscp::packet> result = handler_->process(packet);
+        outbound_queue_.insert(outbound_queue_.end(), result.begin(), result.end());
       }
-      */
       return boost::make_tuple(sig.additional_packet_count > 0, process_helper(&nscp::server::parser::digest_signature, &connection::process_signature));
     }

modules/NSCPClient/NSCPClient.cpp

@@ -54 +54 @@
 
     get_core()->registerCommand(_T("query_nscp"), _T("Submit a query to a remote host via NSCP"));
+    get_core()->registerCommand(_T("submit_nscp"), _T("Submit a query to a remote host via NSCP"));
     //"/settings/NSCP/client/handlers"
     sh::settings_registry settings(get_settings_proxy());
@@ -95 +96 @@
 }
 
-void NSCPClient::add_options(po::options_description &desc, nscp_connection_data &command_data) {
+void NSCPClient::add_common_options(po::options_description &desc, nscp_connection_data &command_data) {
   desc.add_options()
     ("host,H", po::wvalue<std::wstring>(&command_data.host), "The address of the host running the NSCP daemon")
     ("port,p", po::value<int>(&command_data.port), "The port on which the daemon is running (default=5668)")
+    ("timeout,t", po::value<int>(&command_data.timeout), "Number of seconds before connection times out (default=10)")
+    ("no-ssl,n", po::value<bool>(&command_data.no_ssl)->zero_tokens()->default_value(false), "Do not initial an ssl handshake with the server, talk in plain text.")
+    ("query,q", po::bool_switch(&command_data.query), "Force query mode (only useful when this is not obvious)")
+    ("submit,s", po::bool_switch(&command_data.submit), "Force submit mode (only useful when this is not obvious)")
+    ;
+}
+void NSCPClient::add_query_options(po::options_description &desc, nscp_connection_data &command_data) {
+  desc.add_options()
     ("command,c", po::wvalue<std::wstring>(&command_data.command), "The name of the command that the remote daemon should run")
-    ("timeout,t", po::value<int>(&command_data.timeout), "Number of seconds before connection times out (default=10)")
-    ("no-ssl,n", po::value<bool>(&command_data.no_ssl)->zero_tokens()->default_value(false), "Do not initial an ssl handshake with the server, talk in plaintext.")
     ("arguments,a", po::wvalue<std::vector<std::wstring> >(&command_data.arguments), "list of arguments")
     ;
 }
+void NSCPClient::add_submit_options(po::options_description &desc, nscp_connection_data &command_data) {
+  desc.add_options()
+    ("command,c", po::wvalue<std::wstring>(&command_data.command), "The name of the command that the remote daemon should run")
+    ("message,m", po::wvalue<std::wstring>(&command_data.message), "Message")
+    ("result,r", po::value<unsigned int>(&command_data.result), "Result code")
+    ;
+}
 
 void NSCPClient::add_server(std::wstring key, std::wstring args) {
@@ -115 +129 @@
     boost::program_options::variables_map vm;
 
-    po::options_description desc("Allowed options");
-    add_options(desc, command_data);
+    po::options_description common("Common options");
+    add_common_options(common, command_data);
+    po::options_description query("Query options");
+    add_query_options(query, command_data);
+    po::options_description submit("Submit options");
+    add_submit_options(submit, command_data);
 
     po::positional_options_description p;
@@ -130 +148 @@
     }
 
+    po::options_description desc("Availible options");
+    desc.add(common).add(query).add(submit);
     po::wparsed_options parsed = po::basic_command_line_parser<wchar_t>(list).options(desc).positional(p).run();
     po::store(parsed, vm);
@@ -169 +189 @@
       std::string line = payload.message();
 
-      // @todo: Add performance data parsin here!
+      // @todo: Add performance data parsing here!
       //nscapi::functions::parse_performance_data(payload, perf);
       //if (!payload.perf().empty())
@@ -182 +202 @@
 NSCAPI::nagiosReturn NSCPClient::handleCommand(const std::wstring &target, const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &message, std::wstring &perf) {
   if (command == _T("query_nscp")) {
+    return query_nscp(arguments, message, perf);
+  }
+  if (command == _T("submit_nscp")) {
     return query_nscp(arguments, message, perf);
   }
@@ -205 +228 @@
     boost::program_options::variables_map vm;
 
+    po::options_description common("Common options");
+    add_common_options(common, command_data);
+    po::options_description query("Query options");
+    add_query_options(query, command_data);
+
     po::options_description desc("Allowed options");
-    add_options(desc, command_data);
+    desc.add(common).add(query);
 
     std::vector<std::wstring> vargs(arguments.begin(), arguments.end());
@@ -235 +263 @@
 }
 
-int NSCPClient::commandLineExec(const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &result) {
-  if (command != _T("query_nscp") && command != _T("help"))
-    return NSCAPI::returnIgnored;
+bool NSCPClient::submit_nscp(std::list<std::wstring> &arguments, std::wstring &result) {
   try {
     NSCPClient::nscp_connection_data command_data;
     boost::program_options::variables_map vm;
 
+    po::options_description common("Common options");
+    add_common_options(common, command_data);
+    po::options_description submit("Submit options");
+    add_submit_options(submit, command_data);
+
     po::options_description desc("Allowed options");
-    add_options(desc, command_data);
+    desc.add(common).add(submit);
 
     std::vector<std::wstring> vargs(arguments.begin(), arguments.end());
@@ -252 +283 @@
     po::notify(vm);
 
-    if (command == _T("help")) {
-      std::stringstream ss;
-      ss << "NSCPClient Command line syntax for command: query" << std::endl;;
-      ss << desc;
-      result = utf8::cvt<std::wstring>(ss.str());
-      return NSCAPI::returnOK;
-    }
+
+    std::string buffer;
+    nscapi::functions::create_simple_query_response(command_data.command, command_data.result, command_data.message, _T(""), buffer);
+    std::list<std::string> errors = submit_nscp_command(command_data, buffer);
+    
+    BOOST_FOREACH(std::string e, errors) {
+      result += utf8::cvt<std::wstring>(e) + _T("\n");
+    }
+  } catch (boost::program_options::validation_error &e) {
+    result = _T("Error: ") + utf8::cvt<std::wstring>(e.what());
+    return false;
+  } catch (...) {
+    result = _T("Unknown exception parsing command line");
+    return false;
+  }
+  return true;
+}
+
+
+int NSCPClient::commandLineExec(const std::wstring &command, std::list<std::wstring> &arguments, std::wstring &result) {
+  NSCPClient::nscp_connection_data command_data;
+  if (command == _T("help")) {
+    po::options_description common("Common options");
+    add_common_options(common, command_data);
+    po::options_description query("Query NSCP options");
+    add_query_options(query, command_data);
+    po::options_description submit("Submit NSCP options");
+    add_submit_options(submit, command_data);
+    po::options_description desc("Allowed options");
+    desc.add(common).add(query).add(submit);
+
+    std::stringstream ss;
+    ss << "NSCPClient Command line syntax for command: query_nscp and submit_nscp" << std::endl;;
+    ss << desc;
+    result = utf8::cvt<std::wstring>(ss.str());
+    return NSCAPI::returnOK;
+  } else if (command == _T("query_nscp")) {
+    boost::program_options::variables_map vm;
+
+    po::options_description common("Common options");
+    add_common_options(common, command_data);
+    po::options_description query("Query NSCP options");
+    add_query_options(query, command_data);
+    po::options_description desc("Allowed options");
+    desc.add(common).add(query);
+
+    std::vector<std::wstring> vargs(arguments.begin(), arguments.end());
+    po::positional_options_description p;
+    p.add("arguments", -1);
+    po::wparsed_options parsed = po::basic_command_line_parser<wchar_t>(vargs).options(desc).positional(p).run();
+    po::store(parsed, vm);
+    po::notify(vm);
 
     std::string buffer;
@@ -264 +340 @@
     std::list<std::string> payloads = execute_nscp_command(command_data, buffer);
     int ret = NSCAPI::returnUNKNOWN;
-    BOOST_FOREACH(std::string p, collect_result(payloads, ret)) {
+    std::list<std::string> strings = collect_result(payloads, ret);
+    BOOST_FOREACH(std::string p, strings) {
       result += utf8::cvt<std::wstring>(p) + _T("\n");
     }
     return ret;
-  } catch (std::exception &e) {
-    result = _T("Error: ") + utf8::cvt<std::wstring>(e.what());
-    return NSCAPI::returnUNKNOWN;
-  } catch (...) {
-    result = _T("Unknown exception processing request");
-    return NSCAPI::returnUNKNOWN;
-  }
-  return NSCAPI::returnUNKNOWN;
+  } else if (command == _T("submit_nscp")) {
+    boost::program_options::variables_map vm;
+
+    po::options_description common("Common options");
+    add_common_options(common, command_data);
+    po::options_description submit("Submit  NSCP options");
+    add_submit_options(submit, command_data);
+    po::options_description desc("Allowed options");
+    desc.add(common).add(submit);
+
+    std::vector<std::wstring> vargs(arguments.begin(), arguments.end());
+    po::positional_options_description p;
+    p.add("arguments", -1);
+    po::wparsed_options parsed = po::basic_command_line_parser<wchar_t>(vargs).options(desc).positional(p).run();
+    po::store(parsed, vm);
+    po::notify(vm);
+
+    std::string buffer;
+    nscapi::functions::create_simple_query_response(command_data.command, command_data.result, command_data.message, _T(""), buffer);
+    std::list<std::string> errors = submit_nscp_command(command_data, buffer);
+    BOOST_FOREACH(std::string p, errors) {
+      result += utf8::cvt<std::wstring>(p) + _T("\n");
+    }
+    return NSCAPI::returnOK;
+  }
+  return NSCAPI::returnIgnored;
 }
 std::list<std::string> NSCPClient::execute_nscp_command(nscp_connection_data con, std::string buffer) {
@@ -285 +380 @@
     chunks = send(con, chunks);
     BOOST_FOREACH(nscp::packet &chunk, chunks) {
-      if (chunk.is_command_response()) {
+      if (chunk.is_query_response()) {
         result.push_back(chunk.payload);
       } else if (chunk.is_error()) {
@@ -305 +400 @@
 }
 
-std::list<nscp::packet> NSCPClient::send(nscp_connection_data &con, const std::list<nscp::packet> &chunks) {
-  std::list<nscp::packet> result;
+std::list<std::string> NSCPClient::submit_nscp_command(nscp_connection_data con, std::string buffer) {
+  std::list<std::string> result;
+  try {
+    std::list<nscp::packet> chunks;
+    chunks.push_back(nscp::packet::create_payload(nscp::data::command_response, buffer, 0));
+    chunks = send(con, chunks);
+    BOOST_FOREACH(nscp::packet &chunk, chunks) {
+      if (chunk.is_query_response()) {
+        result.push_back(chunk.payload);
+      } else if (chunk.is_error()) {
+        NSCPIPC::ErrorMessage message;
+        message.ParseFromString(chunk.payload);
+        for (int i=0;i<message.error_size();i++) {
+          result.push_back("Error: " + message.error(i).message());
+        }
+      } else {
+        NSC_LOG_ERROR_STD(_T("Unsupported message type: ") + strEx::itos(chunk.signature.payload_type));
+      }
+      //NSC_DEBUG_MSG_STD(_T("Found chunk: ") + utf8::cvt<std::wstring>(strEx::format_buffer(chunk.payload.c_str(), chunk.payload.size())));
+    }
+    return result;
+  } catch (std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Exception: ") + utf8::cvt<std::wstring>(e.what()));
+    return result;
+  }
+}
+
+std::list<nscp::packet> NSCPClient::send(nscp_connection_data &con, std::list<nscp::packet> &chunks) {
+  chunks.push_front(nscp::packet::build_envelope_request(1));
+  std::list<nscp::packet> tmp, result;
   if (!con.no_ssl) {
 #ifdef USE_SSL
-    result = send_ssl(con.host, con.port, con.timeout, chunks);
+    tmp = send_ssl(con.host, con.port, con.timeout, chunks);
 #else
     NSC_LOG_ERROR_STD(_T("SSL not avalible (not compiled with USE_SSL)"));
@@ -315 +438 @@
 #endif
   } else {
-    result = send_nossl(con.host, con.port, con.timeout, chunks);
+    tmp = send_nossl(con.host, con.port, con.timeout, chunks);
+  }
+  BOOST_FOREACH(nscp::packet &p, tmp) {
+    if (p.is_envelope_response()) {
+      std::cout << "Got envelope" << std::endl;
+    } else {
+      result.push_back(p);
+    }
   }
   return result;

modules/NSCPClient/NSCPClient.h

@@ -34 +34 @@
     std::wstring command;
     std::wstring command_line;
+    std::wstring message;
+    unsigned int result;
+    bool submit;
+    bool query;
     std::vector<std::wstring> arguments;
     int port;
@@ -42 +46 @@
       port(5668), 
       timeout(10), 
-      no_ssl(false)
+      no_ssl(false),
+      submit(false),
+      query(false)
     {}
     std::wstring toString() {
@@ -51 +57 @@
       ss << _T(", no_ssl: ") << no_ssl;
       ss << _T(", command: ") << command;
+      ss << _T(", message: ") << message;
+      ss << _T(", result: ") << result;
       int i=0;
       BOOST_FOREACH(std::wstring a, arguments) {
@@ -98 +106 @@
 
 private:
+  std::list<std::string> submit_nscp_command(nscp_connection_data con, std::string buffer);
   std::list<std::string> execute_nscp_command(nscp_connection_data con, std::string buffer);
-  std::list<nscp::packet> send(nscp_connection_data &con, const std::list<nscp::packet> &chunks);
+  std::list<nscp::packet> send(nscp_connection_data &con, std::list<nscp::packet> &chunks);
   std::list<nscp::packet> send_nossl(std::wstring host, int port, int timeout, const std::list<nscp::packet> &chunks);
   std::list<nscp::packet> send_ssl(std::wstring host, int port, int timeout, const std::list<nscp::packet> &chunks);
-  void add_options(po::options_description &desc, nscp_connection_data &command_data);
+  void add_common_options(po::options_description &desc, nscp_connection_data &command_data);
+  void add_query_options(po::options_description &desc, nscp_connection_data &command_data);
+  void add_submit_options(po::options_description &desc, nscp_connection_data &command_data);
 
   NSCAPI::nagiosReturn query_nscp(std::list<std::wstring> &arguments, std::wstring &message, std::wstring perf);
+  bool submit_nscp(std::list<std::wstring> &arguments, std::wstring &result);
 
 private:

modules/NSCPServer/handler_impl.cpp

@@ -12 +12 @@
   Plugin::Common::Header hdr;
 
-  if (packet.is_command_request()) {
+  if (packet.is_query_request()) {
     Plugin::QueryRequestMessage msg;
     msg.ParseFromString(packet.payload);
@@ -55 +55 @@
       result.push_back(nscp::packet::create_query_response(outBuffer));
     }
+  } else if (packet.is_query_response()) {
+
+    // @todo handle submission here
+
   } else {
     NSC_LOG_ERROR(_T("Unknown packet: ") + packet.to_wstring());

service/NSClient++.cpp

@@ -79 +79 @@
 #define LOG_INFO_CORE(msg) { 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) { std::string s = nsclient::logger_helper::create_debug(__FILE__, __LINE__, msg); mainClient.reportMessage(s); }
+#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_STD(msg) LOG_DEBUG_CORE(std::wstring(msg))