Changeset 2906cda in nscp

Timestamp:

02/13/12 22:50:59 (16 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

c710cc7

Parents:

76540c3

Message:

• Fixed installer issue (could not start service)
• Did some refactoring in the distributed client

Files:

• changelog (modified) (1 diff)
• helpers/installers/installer/Product.wxs (modified) (3 diffs)
• modules/DistributedClient/DistributedClient.cpp (modified) (10 diffs)
• modules/DistributedClient/DistributedClient.h (modified) (6 diffs)
• modules/NSCPClient/NSCPClient.h (modified) (1 diff)
• version.hpp (modified) (1 diff)
• version.txt (modified) (1 diff)

changelog

@@ -2 +2 @@
  * Process times and similar ?
  * Fix configuration GUI (low priority)
- * Add API for rehashing the daemon (or implement it the API is there but does nothing)
  * Fixa dependonservice LanManWorkStation (old win)
  * Fix RtlStringFromGUID problem on NT4
+
+2012-02-13 MickeM
+ * Fixed installer issue (could not start service)
 
 2012-02-12 MickeM

helpers/installers/installer/Product.wxs

@@ -43 +43 @@
               <Shortcut Id="StartmenuNSClientTest" Directory="ProgramMenuDir"
                 Name="$(var.App.Title) ($(var.arch), test)" WorkingDirectory="INSTALLDIR" Icon="nscp.exe"
-                Advertise="yes" IconIndex="0" Arguments="--test" Description="Run $(var.App.Title) in test mode" />
+                Advertise="yes" IconIndex="0" Arguments="test" Description="Run $(var.App.Title) in test mode" />
               <fire:FirewallException Id="FWX1" Name="NSClient++ Monitoring Agent" Scope="any" IgnoreFailure="yes" />
             </File>
@@ -50 +50 @@
               Type="ownProcess" Start="auto" ErrorControl="normal" Interactive="no"
               Description="Monitoring agent for nagios (and others) used to respond to status queries"
-              Arguments="--service --run --name [SERVICE_NAME]" />
+              Arguments="service --run --name [SERVICE_NAME]" />
             <ServiceControl Id="StartSWCNSCP" Name="[SERVICE_NAME]" Start="install" Stop="both" Wait="yes" Remove="uninstall" />
             <RemoveFolder Id="RemoveMenuShortcuts" Directory="ProgramMenuDir" On="uninstall" />
@@ -57 +57 @@
             <Shortcut Id="StartmenuNSClientStart" Directory="ProgramMenuDir" Name="Start $(var.App.Title) ($(var.arch))"
                   WorkingDirectory='INSTALLDIR' Icon="nscp.exe" IconIndex="0"
-                  Arguments="--service --name [SERVICE_NAME] --start" Description="Start the $(var.App.Title) service" />
+                  Arguments="service --name [SERVICE_NAME] --start" Description="Start the $(var.App.Title) service" />
             <Shortcut Id="StartmenuNSClientStop" Directory="ProgramMenuDir" Name="Stop $(var.App.Title) ($(var.arch))"
                   WorkingDirectory='INSTALLDIR' Icon="nscp.exe" IconIndex="0"
-                  Arguments="--service --name [SERVICE_NAME] --stop" Description="Stop the $(var.App.Title) service" />
+                  Arguments="service --name [SERVICE_NAME] --stop" Description="Stop the $(var.App.Title) service" />
             <Shortcut Id="StarmentNSCHelp" Directory="ProgramMenuDir" Name="Documentation"
                   Target="[HELP_LINK]" Icon="doc.ico"

modules/DistributedClient/DistributedClient.cpp

@@ -35 +35 @@
 namespace sh = nscapi::settings_helper;
 
+const std::wstring DistributedClient::command_prefix = _T("dnscp");
 /**
 * Default c-tor
@@ -59 +60 @@
   std::map<std::wstring,std::wstring> commands;
 
-  std::wstring certificate;
-  unsigned int timeout = 30, buffer_length = 1024;
-  bool use_ssl = true;
   try {
 
-    register_command(_T("query_dist"), _T("Submit a query to a remote host via NSCP"));
-    register_command(_T("submit_dist"), _T("Submit a query to a remote host via NSCP"));
-    register_command(_T("exec_dist"), _T("Execute remote command on a remote host via NSCP"));
 
     sh::settings_registry settings(get_settings_proxy());
@@ -89 +84 @@
       ;
 
-    settings.alias().add_key_to_settings(_T("targets/default"))
-
-      (_T("timeout"), sh::uint_key(&timeout, 30),
-      _T("TIMEOUT"), _T("Timeout when reading/writing packets to/from sockets."))
-
-      (_T("use ssl"), sh::bool_key(&use_ssl, true),
-      _T("ENABLE SSL ENCRYPTION"), _T("This option controls if SSL should be enabled."))
-
-      (_T("certificate"), sh::wpath_key(&certificate, _T("${certificate-path}/nrpe_dh_512.pem")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("payload length"),  sh::uint_key(&buffer_length, 1024),
-      _T("PAYLOAD LENGTH"), _T("Length of payload to/from the NRPE agent. This is a hard specific value so you have to \"configure\" (read recompile) your NRPE agent to use the same value for it to work."))
-      ;
-
     settings.register_all();
     settings.notify();
 
+    targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
+
+
     get_core()->registerSubmissionListener(get_id(), channel_);
-
-    if (!targets.has_target(_T("default"))) {
-      add_target(_T("default"), _T("default"));
-      targets.rebuild();
-    }
-    nscapi::target_handler::optarget t = targets.find_target(_T("default"));
-    if (t) {
-      if (!t->has_option("certificate"))
-        t->options[_T("certificate")] = certificate;
-      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(buffer_length);
-      if (!t->has_option("ssl"))
-        t->options[_T("ssl")] = use_ssl?_T("true"):_T("false");
-      targets.add(*t);
-    } else {
-      NSC_LOG_ERROR(_T("Default target not found!"));
-    }
+    register_command(_T("dnscp_query"), _T("Submit a query to a remote host via NSCP"));
+    register_command(_T("dnscp_forward"), _T("Forward query to remote NSCP host"));
+    register_command(_T("dnscp_submit"), _T("Submit a query to a remote host via NSCP"));
+    register_command(_T("dnscp_exec"), _T("Execute remote command on a remote host via NSCP"));
+    register_command(_T("dnscp_help"), _T("Help on using NSCP Client"));
 
   } catch (nscapi::nscapi_exception &e) {
@@ -154 +123 @@
 void DistributedClient::add_target(std::wstring key, std::wstring arg) {
   try {
-    nscapi::target_handler::target t = targets.add(get_settings_proxy(), target_path , key, arg);
-    if (t.has_option(_T("certificate"))) {
-      boost::filesystem::wpath p = t.options[_T("certificate")];
-      if (!boost::filesystem::is_regular(p)) {
-        p = get_core()->getBasePath() / p;
-        t.options[_T("certificate")] = utf8::cvt<std::wstring>(p.string());
-        targets.add(t);
-      }
-      if (boost::filesystem::is_regular(p)) {
-        NSC_DEBUG_MSG_STD(_T("Using certificate: ") + p.string());
-      } else {
-        NSC_LOG_ERROR_STD(_T("Certificate not found: ") + p.string());
-      }
-    }
+    targets.add(get_settings_proxy(), target_path , key, arg);
+  } catch (const std::exception &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
   } catch (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -195 +153 @@
 
 NSCAPI::nagiosReturn DistributedClient::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("syslog"));
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::QueryRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  if (!client::command_line_parser::is_command(cmd))
-    return client::command_line_parser::do_execute_command_as_query(config, cmd, data.args, request, result);
-  return commands.exec_simple(config, data.target, char_command, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_query(cmd, config, message, result);
 }
 
 int DistributedClient::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
-  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("syslog"));
-  if (!client::command_line_parser::is_command(cmd))
-    return NSCAPI::returnIgnored;
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, command_prefix);
+
+  Plugin::ExecuteRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_execute_command_as_exec(config, cmd, data.args, result);
+  setup(config, message.header());
+
+  return commands.process_exec(cmd, config, message, result);
 }
 
 NSCAPI::nagiosReturn DistributedClient::handleRAWNotification(const wchar_t* channel, std::string request, std::string &result) {
+  Plugin::SubmitRequestMessage message;
+  message.ParseFromString(request);
+
   client::configuration config;
-  setup(config);
-  return client::command_line_parser::do_relay_submit(config, request, result);
+  setup(config, message.header());
+
+  return client::command_line_parser::do_relay_submit(config, message, result);
 }
 
@@ -236 +202 @@
 }
 
-void DistributedClient::setup(client::configuration &config) {
+void DistributedClient::setup(client::configuration &config, const ::Plugin::Common_Header& header) {
   boost::shared_ptr<clp_handler_impl> handler = boost::shared_ptr<clp_handler_impl>(new clp_handler_impl(this));
   add_local_options(config.local, config.data);
 
-  net::wurl url;
-  url.protocol = _T("dnscp");
-  url.port = 5669;
-  nscapi::target_handler::optarget opt = targets.find_target(_T("default"));
+  config.data->recipient.id = header.recipient_id();
+  std::wstring recipient = utf8::cvt<std::wstring>(config.data->recipient.id);
+  if (!targets.has_object(recipient)) {
+    NSC_LOG_ERROR(_T("Target not found (using default): ") + recipient);
+    recipient = _T("default");
+  }
+  nscapi::targets::optional_target_object opt = targets.find_object(recipient);
+
   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 (...) {}
-    }
-    std::string keys[] = {"certificate", "timeout", "payload length", "ssl"};
-    BOOST_FOREACH(std::string s, keys) {
-      config.data->recipient.data[s] = utf8::cvt<std::string>(t.options[utf8::cvt<std::wstring>(s)]);
-    }
-  }
-  config.data->recipient.id = "default";
-  config.data->recipient.address = utf8::cvt<std::string>(url.to_string());
+    nscapi::targets::target_object t = *opt;
+    nscapi::functions::destination_container def = t.to_destination_container();
+    config.data->recipient.apply(def);
+  }
   config.data->host_self.id = "self";
   //config.data->host_self.host = hostname_;
@@ -266 +226 @@
 }
 
-DistributedClient::connection_data DistributedClient::parse_header(const ::Plugin::Common_Header &header) {
+DistributedClient::connection_data DistributedClient::parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data) {
   nscapi::functions::destination_container recipient;
   nscapi::functions::parse_destination(header, header.recipient_id(), recipient, true);
-  return connection_data(recipient);
+  return connection_data(recipient, data->recipient);
 }
 
@@ -286 +246 @@
   return ret;
 }
-int DistributedClient::clp_handler_impl::query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int DistributedClient::clp_handler_impl::query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
   int ret = NSCAPI::returnUNKNOWN;
-  Plugin::QueryRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+  connection_data con = parse_header(request_header, data);
 
   Plugin::QueryResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nscp::packet> chunks;
   chunks.push_back(nscp::factory::create_envelope_request(1));
-  chunks.push_back(nscp::factory::create_payload(nscp::data::command_request, request, 0));
+  chunks.push_back(nscp::factory::create_payload(nscp::data::command_request, request_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
   BOOST_FOREACH(nscp::packet &chunk, chunks) {
@@ -316 +275 @@
 }
 
-int DistributedClient::clp_handler_impl::submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int DistributedClient::clp_handler_impl::submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
   int ret = NSCAPI::returnUNKNOWN;
-  Plugin::SubmitRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+  connection_data con = parse_header(request_header, data);
   Plugin::SubmitResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nscp::packet> chunks;
-  chunks.push_back(nscp::factory::create_payload(nscp::data::command_response, request, 0));
+  chunks.push_back(nscp::factory::create_payload(nscp::data::command_response, request_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
   BOOST_FOREACH(nscp::packet &chunk, chunks) {
@@ -344 +302 @@
 }
 
-int DistributedClient::clp_handler_impl::exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply) {
+int DistributedClient::clp_handler_impl::exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply) {
+  const ::Plugin::Common_Header& request_header = request_message.header();
   int ret = NSCAPI::returnOK;
-  Plugin::ExecuteRequestMessage request_message;
-  request_message.ParseFromString(request);
-  connection_data con = parse_header(*header);
+  connection_data con = parse_header(request_header, data);
 
   Plugin::ExecuteResponseMessage response_message;
-  nscapi::functions::make_return_header(response_message.mutable_header(), *header);
+  nscapi::functions::make_return_header(response_message.mutable_header(), request_header);
 
   std::list<nscp::packet> chunks;
   chunks.push_back(nscp::factory::create_envelope_request(1));
-  chunks.push_back(nscp::factory::create_payload(nscp::data::exec_request, request, 0));
+  chunks.push_back(nscp::factory::create_payload(nscp::data::exec_request, request_message.SerializeAsString(), 0));
   chunks = instance->send(con, chunks);
   BOOST_FOREACH(nscp::packet &chunk, chunks) {

modules/DistributedClient/DistributedClient.h

@@ -22 +22 @@
 
 #include <boost/tuple/tuple.hpp>
+#include <boost/filesystem.hpp>
 
 #include <client/command_line_parser.hpp>
@@ -37 +38 @@
 
 namespace po = boost::program_options;
-
+namespace sh = nscapi::settings_helper;
 
 class DistributedClient : public nscapi::impl::simple_plugin {
@@ -44 +45 @@
   std::wstring channel_;
   std::wstring target_path;
+  const static std::wstring command_prefix;
 
-  nscapi::target_handler targets;
+  struct custom_reader {
+    typedef nscapi::targets::target_object object_type;
+    typedef nscapi::targets::target_object target_object;
+
+    static void init_default(target_object &target) {
+      target.set_property_int(_T("timeout"), 30);
+      target.set_property_bool(_T("ssl"), true);
+      target.set_property_string(_T("certificate"), _T("${certificate-path}/nrpe_dh_512.pem"));
+      target.set_property_int(_T("payload length"), 1024);
+    }
+
+    static void add_custom_keys(sh::settings_registry &settings, boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
+      settings.path(object.path).add_key()
+
+        (_T("timeout"), sh::int_fun_key<int>(boost::bind(&object_type::set_property_int, &object, _T("timeout"), _1), 30),
+        _T("TIMEOUT"), _T("Timeout when reading/writing packets to/from sockets."))
+
+        ;
+    }
+
+    static void post_process_target(target_object &target) {
+      nscapi::core_wrapper* core = GET_CORE();
+      if (core == NULL) {
+        NSC_LOG_ERROR_STD(_T("Invalid core"));
+        return;
+      }
+      if (target.has_option(_T("certificate"))) {
+        std::wstring value = target.options[_T("certificate")];
+        boost::filesystem::wpath p = value;
+        if (!boost::filesystem::is_regular(p)) {
+          p = core->getBasePath() / p;
+          if (boost::filesystem::is_regular(p)) {
+            value = p.string();
+          } else {
+            value = core->expand_path(value);
+          }
+          target.options[_T("certificate")] = value;
+        }
+        if (boost::filesystem::is_regular(p)) {
+          NSC_DEBUG_MSG_STD(_T("Using certificate: ") + p.string());
+        } else {
+          NSC_LOG_ERROR_STD(_T("Certificate not found: ") + p.string());
+        }
+      }
+    }
+
+  };
+
+  nscapi::targets::handler<custom_reader> targets;
   client::command_manager commands;
 
@@ -51 +101 @@
     std::string address;
     int timeout;
-    int buffer_length;
-    bool use_ssl;
 
-    connection_data(nscapi::functions::destination_container recipient) {
-      timeout = recipient.get_int_data("timeout", 30);
-
-      address = recipient.address;
+    connection_data(nscapi::functions::destination_container arguments, nscapi::functions::destination_container target) {
+      arguments.import(target);
+      timeout = arguments.get_int_data("timeout", 30);
+      address = arguments.address.to_string();
     }
 
@@ -73 +121 @@
     clp_handler_impl(DistributedClient *instance) : instance(instance) {}
 
-    int query(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int submit(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
-    int exec(client::configuration::data_type data, ::Plugin::Common_Header* header, const std::string &request, std::string &reply);
+    int query(client::configuration::data_type data, const Plugin::QueryRequestMessage &request_message, std::string &reply);
+    int submit(client::configuration::data_type data, const Plugin::SubmitRequestMessage &request_message, std::string &reply);
+    int exec(client::configuration::data_type data, const Plugin::ExecuteRequestMessage &request_message, std::string &reply);
 
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
+      nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
+      if (opt)
+        return opt->to_destination_container();
       nscapi::functions::destination_container ret;
-      nscapi::target_handler::optarget t = instance->targets.find_target(id);
-      if (t) {
-        if (!t->alias.empty())
-          ret.id = utf8::cvt<std::string>(t->alias);
-        if (!t->host.empty())
-          ret.host = utf8::cvt<std::string>(t->host);
-        if (t->has_option("address"))
-          ret.address = utf8::cvt<std::string>(t->options[_T("address")]);
-        else 
-          ret.address = utf8::cvt<std::string>(t->host);
-        BOOST_FOREACH(const nscapi::target_handler::target::options_type::value_type &kvp, t->options) {
-          ret.data[utf8::cvt<std::string>(kvp.first)] = utf8::cvt<std::string>(kvp.second);
-        }
-      }
       return ret;
     }
@@ -143 +180 @@
   bool submit_nscp(std::list<std::wstring> &arguments, std::wstring &result);
 
-  static connection_data parse_header(const ::Plugin::Common_Header &header);
+  static connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:
   void add_local_options(po::options_description &desc, client::configuration::data_type data);
-  void setup(client::configuration &config);
+  void setup(client::configuration &config, const ::Plugin::Common_Header& header);
   void add_command(std::wstring key, std::wstring args);
   void add_target(std::wstring key, std::wstring args);

modules/NSCPClient/NSCPClient.h

@@ -66 +66 @@
         _T("SSL CERTIFICATE"), _T(""))
 
-        (_T("payload length"),  sh::int_fun_key<int>(boost::bind(&object_type::set_property_int, &object, _T("payload length"), _1), 1024),
-        _T("PAYLOAD LENGTH"), _T("Length of payload to/from the NRPE agent. This is a hard specific value so you have to \"configure\" (read recompile) your NRPE agent to use the same value for it to work."))
         ;
     }

version.hpp

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

version.txt

@@ -1 +1 @@
 version=0.4.0
-build=132
-date=2012-02-12
+build=134
+date=2012-02-13