Changeset b38e845 in nscp for modules

Timestamp:

08/24/11 18:37:39 (21 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

d7e265d

Parents:

0b8df3e

Message:

• Sever refactoring of the new API (there is now two pb files ipc for NSCP protocol and plugin for plugin communication)
• Cleaned up API helper functions

Location:

modules

Files:

• CheckExternalScripts/CheckExternalScripts.cpp (modified) (3 diffs)
• NSCPClient/NSCPClient.cpp (modified) (4 diffs)
• NSCPClient/NSCPClient.h (modified) (1 diff)
• NSCPServer/handler_impl.cpp (modified) (2 diffs)
• NSCPServer/handler_impl.hpp (modified) (1 diff)
• PythonScript/PythonScript.cpp (modified) (3 diffs)

modules/CheckExternalScripts/CheckExternalScripts.cpp

@@ -138 +138 @@
 
 NSCAPI::nagiosReturn CheckExternalScripts::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &response) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::process_simple_command_request(char_command, request);
+  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
 
   command_list::const_iterator cit = commands.find(data.command);
@@ -158 +158 @@
         if (first && !isAlias && !allowNasty_) {
           if (str.find_first_of(NASTY_METACHARS) != std::wstring::npos) {
-            return nscapi::functions::process_simple_command_result(data.command, NSCAPI::returnUNKNOWN, _T("Request contained illegal characters!"), _T(""), response);
+            return nscapi::functions::create_simple_query_response_unknown(_T("Request contained illegal characters!"), _T(""), response, data.command);
+
           }
         }
@@ -190 +191 @@
     int result = process::executeProcess(process::exec_arguments(root_, cd.command + _T(" ") + xargs, timeout), message, perf);
     if (!nscapi::plugin_helper::isNagiosReturnCode(result)) {
-      return nscapi::functions::process_simple_command_result(data.command, NSCAPI::returnUNKNOWN, _T("The command (") + cd.command + _T(") returned an invalid return code: ") + strEx::itos(result), _T(""), response);
-    }
-    return nscapi::functions::process_simple_command_result(data.command, nscapi::plugin_helper::int2nagios(result), message, perf, response);
+      nscapi::functions::create_simple_query_response(NSCAPI::returnUNKNOWN, _T("The command (") + cd.command + _T(") returned an invalid return code: ") + strEx::itos(result), _T(""), response, data.command);
+      return NSCAPI::returnUNKNOWN;
+    }
+    nscapi::functions::create_simple_query_response(nscapi::plugin_helper::int2nagios(result), message, perf, response, data.command);
+    return result;
   }
 }

modules/NSCPClient/NSCPClient.cpp

@@ -240 +240 @@
 NSCPClient::nscp_result_data NSCPClient::execute_nscp_command(nscp_connection_data con, std::string buffer) {
   try {
-    std::list<nscp::packet::nscp_chunk> chunks;
+    std::list<nscp::packet> chunks;
     chunks.push_back(nscp::packet::build_envelope_request(1));
-    chunks.push_back(nscp::packet::build_payload(nscp::data::command_request, buffer, 0));
+    chunks.push_back(nscp::packet::create_payload(nscp::data::command_request, buffer, 0));
     if (!con.no_ssl) {
 #ifdef USE_SSL
@@ -253 +253 @@
       chunks = send_nossl(con.host, con.port, con.timeout, chunks);
     }
-    BOOST_FOREACH(nscp::packet::nscp_chunk &chunk, chunks) {
+    BOOST_FOREACH(nscp::packet &chunk, chunks) {
       NSC_DEBUG_MSG_STD(_T("Found chunk: ") + utf8::cvt<std::wstring>(strEx::format_buffer(chunk.payload.c_str(), chunk.payload.size())));
     }
     return nscp_result_data(NSCAPI::returnUNKNOWN, _T("Hello"));
   } catch (nscp::nscp_exception &e) {
-    NSC_LOG_ERROR_STD(_T("Socket error: ") + e.getMessage());
-    return nscp_result_data(NSCAPI::returnUNKNOWN, _T("NSCP Packet error: ") + e.getMessage());
+    NSC_LOG_ERROR_STD(_T("Socket error: ") + utf8::cvt<std::wstring>(e.what()));
+    return nscp_result_data(NSCAPI::returnUNKNOWN, _T("Socket error: ") + utf8::cvt<std::wstring>(e.what()));
   } catch (std::runtime_error &e) {
     NSC_LOG_ERROR_STD(_T("Socket error: ") + utf8::cvt<std::wstring>(e.what()));
@@ -274 +274 @@
 
 #ifdef USE_SSL
-std::list<nscp::packet::nscp_chunk> NSCPClient::send_ssl(std::wstring host, int port, int timeout, std::list<nscp::packet::nscp_chunk> &chunks) {
+std::list<nscp::packet> NSCPClient::send_ssl(std::wstring host, int port, int timeout, std::list<nscp::packet> &chunks) {
   boost::asio::io_service io_service;
   boost::asio::ssl::context ctx(io_service, boost::asio::ssl::context::sslv23);
@@ -286 +286 @@
 #endif
 
-std::list<nscp::packet::nscp_chunk> NSCPClient::send_nossl(std::wstring host, int port, int timeout, std::list<nscp::packet::nscp_chunk> &chunks) {
+std::list<nscp::packet> NSCPClient::send_nossl(std::wstring host, int port, int timeout, std::list<nscp::packet> &chunks) {
   boost::asio::io_service io_service;
   nscp::client::socket socket(io_service, host, port);

modules/NSCPClient/NSCPClient.h

@@ -105 +105 @@
 private:
   nscp_result_data  execute_nscp_command(nscp_connection_data con, std::string buffer);
-  std::list<nscp::packet::nscp_chunk> send_nossl(std::wstring host, int port, int timeout, std::list<nscp::packet::nscp_chunk> &chunks);
-  std::list<nscp::packet::nscp_chunk> send_ssl(std::wstring host, int port, int timeout, std::list<nscp::packet::nscp_chunk> &chunks);
+  std::list<nscp::packet> send_nossl(std::wstring host, int port, int timeout, std::list<nscp::packet> &chunks);
+  std::list<nscp::packet> send_ssl(std::wstring host, int port, int timeout, std::list<nscp::packet> &chunks);
   void add_options(po::options_description &desc, nscp_connection_data &command_data);
 

modules/NSCPServer/handler_impl.cpp

@@ -7 +7 @@
 #include "handler_impl.hpp"
 
-std::string handler_impl::process(std::string &buffer) {
-  std::string ret;
-  PluginCommand::RequestMessage msg;
-  msg.ParseFromString(buffer);
-  if (msg.payload_size() != 1) {
-    NSC_LOG_ERROR(_T("Multiple payloads not currently supported..."));
-    nscapi::functions::create_simple_query_result(NSCAPI::returnUNKNOWN, _T("Multiple payloads not currently supported..."), _T(""), ret);
-    return ret;
-  }
-  std::wstring command = utf8::cvt<std::wstring>(msg.payload(0).command());
-  if (command.empty() || command == _T("_NSCP_CHECK")) {
-    nscapi::functions::create_simple_query_result(NSCAPI::returnOK, _T("I (") + nscapi::plugin_singleton->get_core()->getApplicationVersionString() + _T(") seem to be doing fine..."), _T(""), ret);
-    return ret;
-  }
+std::list<nscp::packet> handler_impl::process(nscp::packet &packet) {
+  std::list<nscp::packet> result;
 
-  // @todo re-add support for nasty arguments / arguments passing
+  Plugin::Common::Header hdr;
+
+  if (packet.is_command_request()) {
+    Plugin::QueryRequestMessage msg;
+    msg.ParseFromString(packet.payload);
+    hdr.CopyFrom(msg.header());
+
+    // @todo: Make split optional
+
+    for (int i=0;i<msg.payload_size();i++) {
+
+        // @todo re-add support for nasty arguments / arguments passing
   /*
   if (!allowNasty_) {
@@ -35 +34 @@
   }
   */
-  try {
-    NSC_DEBUG_MSG_STD(_T("Running command: ") + command);
-    NSCAPI::nagiosReturn returncode = nscapi::plugin_singleton->get_core()->query(command, buffer, ret);
-  } catch (...) {
-    NSC_LOG_ERROR(_T("Internal exception processing request: ") + command);
-    nscapi::functions::create_simple_query_result(NSCAPI::returnUNKNOWN, _T("Internal exception processing request: ") + command, _T(""), ret);
-    return ret;
+
+      std::string outBuffer;
+      std::wstring command = utf8::cvt<std::wstring>(msg.payload(i).command());
+      if (command.empty() || command == _T("_NSCP_CHECK")) {
+        nscapi::functions::create_simple_query_response(NSCAPI::returnOK, _T("I (") + nscapi::plugin_singleton->get_core()->getApplicationVersionString() + _T(") seem to be doing fine..."), _T(""), outBuffer);
+      } else {
+        std::string tmpBuffer;
+        Plugin::QueryRequestMessage tmp;
+        tmp.mutable_header()->CopyFrom(hdr);
+        tmp.add_payload()->CopyFrom(msg.payload(i));
+        tmp.SerializeToString(&tmpBuffer);
+        NSCAPI::nagiosReturn returncode = nscapi::plugin_singleton->get_core()->query(command, tmpBuffer, outBuffer);
+      }
+      result.push_back(nscp::packet::create_query_response(outBuffer));
+    }
+  } else {
+    NSC_LOG_ERROR(_T("Unknown packet: ") + packet.to_wstring());
+    result.push_back(create_error(_T("Unknown packet: ") + packet.to_wstring()));
   }
-  return ret;
+  return result;
 }
 

modules/NSCPServer/handler_impl.hpp

@@ -20 +20 @@
   }
 
-  std::string process(std::string &buffer);
+  std::list<nscp::packet> process(nscp::packet &buffer);
 
   nscp::packet create_error(std::wstring msg) {
-    return nscp::packet::create_response(4, msg, payload_length_);
+    return nscp::packet::create_error(msg);
   }
 

modules/PythonScript/PythonScript.cpp

@@ -274 +274 @@
     std::wstring result;
     NSCAPI::nagiosReturn ret = inst->handle_simple_exec(cmd, data.args, result);
-    return nscapi::functions::create_simple_exec_result(data.command, ret, result, response);
+    nscapi::functions::create_simple_exec_response(data.command, ret, result, response);
+    return ret;
   }
   return NSCAPI::returnIgnored;
@@ -287 +288 @@
   }
   if (inst->has_simple(cmd)) {
-    nscapi::functions::decoded_simple_command_data data = nscapi::functions::process_simple_command_request(command, request);
+    nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(command, request);
     std::wstring msg, perf;
     NSCAPI::nagiosReturn ret = inst->exec_simple(cmd, data.args, msg, perf);
-    return nscapi::functions::process_simple_command_result(data.command, ret, msg, perf, response);
+    nscapi::functions::create_simple_query_response(ret, msg, perf, response, data.command);
+    return ret;
   }
   NSC_LOG_ERROR_STD(_T("Could not find python commands for: ") + command + _T(" (avalible python commands are: ") + inst->get_commands() + _T(")"));
@@ -311 +313 @@
   if (inst->has_simple_message_handler(chnl)) {
     std::wstring msg, perf;
-    nscapi::functions::parse_simple_message(request, msg, perf);
+    nscapi::functions::parse_simple_query_response(request, msg, perf);
     return inst->handle_simple_message(chnl, cmd, code, msg, perf);
   }