Changeset e396b2f in nscp

Timestamp:

02/05/12 22:37:50 (16 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

0f7b655

Parents:

a8c6e93

Message:

• Refactored the targets concept internally to be simpler to use (less code)
• Fixed issue with reloading plugins
• Fixed target handling in NRPE Client, will add NSCA client tomorrow...

Files:

• changelog (modified) (1 diff)
• include/client/command_line_parser.cpp (modified) (2 diffs)
• include/net/net.hpp (modified) (1 diff)
• include/nrpe/server/connection.cpp (modified) (1 diff)
• include/nrpe/server/parser.hpp (modified) (1 diff)
• include/nrpe/server/ssl_connection.cpp (modified) (1 diff)
• include/nscapi/functions.hpp (modified) (9 diffs)
• include/nscapi/targets.cpp (modified) (1 diff)
• include/nscapi/targets.hpp (modified) (2 diffs)
• include/settings/client/settings_client.hpp (modified) (5 diffs)
• include/settings/settings_http.hpp (modified) (1 diff)
• include/settings/settings_interface_impl.hpp (modified) (7 diffs)
• modules/NRPEClient/NRPEClient.cpp (modified) (9 diffs)
• modules/NRPEClient/NRPEClient.h (modified) (5 diffs)
• modules/NSCAClient/NSCAClient.cpp (modified) (4 diffs)
• modules/NSCAClient/NSCAClient.h (modified) (4 diffs)
• modules/NSCPClient/NSCPClient.cpp (modified) (3 diffs)
• modules/NSCPClient/NSCPClient.h (modified) (5 diffs)
• modules/SMTPClient/SMTPClient.cpp (modified) (2 diffs)
• modules/SMTPClient/SMTPClient.h (modified) (4 diffs)
• modules/Scheduler/Scheduler.cpp (modified) (2 diffs)
• modules/Scheduler/simple_scheduler.hpp (modified) (4 diffs)
• modules/SyslogClient/SyslogClient.cpp (modified) (2 diffs)
• modules/SyslogClient/SyslogClient.h (modified) (4 diffs)
• scripts/python/test_nrpe.py (modified) (5 diffs)
• scripts/python/test_nsca.py (modified) (2 diffs)
• service/NSCPlugin.cpp (modified) (1 diff)
• service/NSCPlugin.h (modified) (2 diffs)
• service/NSClient++.cpp (modified) (3 diffs)

changelog

@@ -5 +5 @@
  * Fixa dependonservice LanManWorkStation (old win)
  * Fix RtlStringFromGUID problem on NT4
+
+
+2012-02-05 MickeM
+ * Refactored the targets concept internally to be simpler to use (less code)
+ * Fixed issue with reloading plugins
+ * Fixed target handling in NRPE Client, will add NSCA client tomorrow...
 
 2012-02-02 MickeM

include/client/command_line_parser.cpp

@@ -1 +1 @@
 #include <client/command_line_parser.hpp>
 #include <nscapi/functions.hpp>
+#include <boost/bind.hpp>
 
 namespace po = boost::program_options;
@@ -6 +7 @@
 void client::command_line_parser::add_common_options(po::options_description &desc, data_type command_data) {
   desc.add_options()
-    ("host,H", po::value<std::string>(&command_data->recipient.address), "The address of the host running the server")
+    ("host,H", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_host, &command_data->recipient, _1)), 
+    "The host of the host running the server")
+    ("port,P", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_port, &command_data->recipient, _1)), 
+    "The port of the host running the server")
+    ("address", po::value<std::string>()->notifier(boost::bind(&nscapi::functions::destination_container::set_address, &command_data->recipient, _1)), 
+    "The address (host:port) of the host running the server")
     ("timeout,T", po::value<int>(&command_data->timeout), "Number of seconds before connection times out (default=10)")
     ("target,t", po::wvalue<std::wstring>(&command_data->target_id), "Target to use (lookup connection info from config)")

include/net/net.hpp

@@ -4 +4 @@
 
 namespace net {
-  struct url {
-    std::string protocol;
-    std::string host;
-    std::string path;
-    std::string query;
+
+  struct string_traits {
+    static std::string protocol_suffix() {
+      return "://";
+    }
+    static std::string port_prefix() {
+      return ":";
+    }
+  };
+  struct wstring_traits {
+    static std::wstring protocol_suffix() {
+      return _T("://");
+    }
+    static std::wstring port_prefix() {
+      return _T(":");
+    }
+  };
+
+
+  template<class string_type, class stream = std::wstringstream, class traits = wstring_traits>
+  struct base_url {
+    typedef base_url<string_type, stream, traits> my_type;
+    string_type protocol;
+    string_type host;
+    string_type path;
+    string_type query;
     unsigned int port;
-    std::string get_port() {
-      std::stringstream ss;
-      ss << port;
+    base_url() : port(0) {}
+
+    string_type to_string() const {
+      stream ss;
+      ss << protocol << traits::protocol_suffix() << host << traits::port_prefix() << port << path;
       return ss.str();
     }
-    std::string to_string() {
-      std::stringstream ss;
-      ss << protocol << "://" << host << ":" << port << path;
-      return ss.str();
+
+    inline int get_port() const {
+      return port;
+    }
+    inline int get_port(int default_port) const {
+      if (port == 0)
+        return default_port;
+      return port;
+    }
+    inline std::wstring get_whost(std::wstring default_host = _T("127.0.0.1")) const {
+      if (!host.empty())
+        return utf8::cvt<std::wstring>(host);
+      return default_host;
+    }
+    inline std::string get_host(std::string default_host = "127.0.0.1") const {
+      if (!host.empty())
+        return utf8::cvt<std::string>(host);
+      return default_host;
+    }
+    inline std::string get_port_string(std::string default_port) const {
+      if (port != 0)
+        return boost::lexical_cast<std::string>(port);
+      return default_port;
+    }
+    inline std::string get_port_string() const {
+      return boost::lexical_cast<std::string>(port);
+    }
+
+    void import(const base_url &n) {
+
+      if (protocol.empty() && !n.protocol.empty())
+        protocol = n.protocol;
+      if (host.empty() && !n.host.empty())
+        host = n.host;
+      if (port == 0 && n.port != 0)
+        port = n.port;
+      if (path.empty() && !n.path.empty())
+        path = n.path;
+      if (query.empty() && !n.query.empty())
+        query = n.query;
+    }
+    void apply(const base_url &n) {
+      if (!n.protocol.empty())
+        protocol = n.protocol;
+      if (!n.host.empty())
+        host = n.host;
+      if (n.port != 0)
+        port = n.port;
+      if (!n.path.empty())
+        path = n.path;
+      if (!n.query.empty())
+        query = n.query;
     }
   };
-  struct wurl {
-    std::wstring protocol;
-    std::wstring host;
-    std::wstring path;
-    std::wstring query;
-    unsigned int port;
-    std::wstring to_string() {
-      std::wstringstream ss;
-      ss << protocol << _T("://") << host << _T(":") << port << path;
-      return ss.str();
-    }
-    inline url get_url() {
-      url r;
-      r.protocol = utf8::cvt<std::string>(protocol);
-      r.host = utf8::cvt<std::string>(host);
-      r.path = utf8::cvt<std::string>(path);
-      r.query = utf8::cvt<std::string>(query);
-      r.port = port;
-      return r;
-    }
 
-  };
+  typedef public base_url<std::string, std::stringstream, string_traits> url;
+  typedef public base_url<std::wstring, std::wstringstream, wstring_traits> wurl;
+
+  inline wurl url_to_wide(const url &u) {
+    wurl r;
+    r.protocol = utf8::cvt<std::wstring>(u.protocol);
+    r.host = utf8::cvt<std::wstring>(u.host);
+    r.path = utf8::cvt<std::wstring>(u.path);
+    r.query = utf8::cvt<std::wstring>(u.query);
+    r.port = u.port;
+    return r;
+  }
+  inline url wide_to_url(const wurl &u) {
+    url r;
+    r.protocol = utf8::cvt<std::string>(u.protocol);
+    r.host = utf8::cvt<std::string>(u.host);
+    r.path = utf8::cvt<std::string>(u.path);
+    r.query = utf8::cvt<std::string>(u.query);
+    r.port = u.port;
+    return r;
+  }
+
+
   inline wurl parse(const std::wstring& url_s, unsigned int default_port = 80) {
     wurl ret;

include/nrpe/server/connection.cpp

@@ -49 +49 @@
 
     void connection::timeout(const boost::system::error_code& e) {
-      handler_->log_debug(__FILE__, __LINE__, _T("Timeout"));
+      handler_->log_debug(__FILE__, __LINE__, _T("Timeout reading: ") + strEx::itos(parser_.get_payload_length()));
       if (e != boost::asio::error::operation_aborted) {
         handler_->log_debug(__FILE__, __LINE__, _T("Timeout <<<-"));

include/nrpe/server/parser.hpp

@@ -36 +36 @@
         packet_length_ = nrpe::length::get_packet_length(length);
       }
+      unsigned int get_payload_length() const {
+        return payload_length_;
+      }
     };
 

include/nrpe/server/ssl_connection.cpp

@@ -25 +25 @@
 
     void ssl_connection::start() {
+      handler_->log_debug(__FILE__, __LINE__, _T("starting secure data connection"));
       socket_.async_handshake(boost::asio::ssl::stream_base::server,
         strand_.wrap(

include/nscapi/functions.hpp

@@ -25 +25 @@
 #include <string>
 #include <list>
+#include <set>
 #include <iostream>
 
@@ -177 +178 @@
     struct destination_container {
       std::string id;
-      std::string host;
-      std::string address;
+      net::url address;
       std::string comment;
-      std::list<std::string> tags;
+      std::set<std::string> tags;
       typedef std::map<std::string,std::string> data_map;
       data_map data;
-
+      void set_host(std::string value) {
+        address.host = value;
+      }
+      void set_address(std::string value) {
+        address = net::parse(value);
+      }
+      void set_port(std::string value) {
+        address.port = strEx::stoi(value);
+      }
       std::string get_protocol() const {
-        net::url url = get_url();
-        return url.protocol;
+        return address.protocol;
       }
       bool has_protocol() const {
-        return !address.empty();
-      }
+        return !address.protocol.empty();
+      }
+      /*
       net::url get_url(unsigned int port = 80) const {
         return net::parse(address, port);
       }
+      */
       static bool to_bool(std::string value, bool def = false) {
         if (value.empty())
@@ -227 +236 @@
       }
 
+      /*
       inline net::url get_url(int default_port) {
         return net::parse(address, default_port);
       }
+      */
       void set_string_data(std::string key, std::string value) {
         if (key == "host")
-          host = value;
-        else
+          set_host(value);
+        else 
           data[key] = value;
       }
       void set_int_data(std::string key, int value) {
-        data[key] = boost::lexical_cast<std::string>(value);
+        if (key == "port")
+          address.port = value;
+        else 
+          data[key] = boost::lexical_cast<std::string>(value);
       }
       void set_bool_data(std::string key, bool value) {
@@ -246 +260 @@
         std::stringstream ss;
         ss << "id: " << id;
-        ss << ", host: " << host;
-        ss << ", address: " << address;
-//        ss << ", protocol: " << protocol;
+        ss << ", address: " << address.to_string();
         ss << ", comment: " << comment;
         int i=0;
@@ -261 +273 @@
 
       void import(const destination_container &other) {
+        if (id.empty() && !other.id.empty())
+          id = other.id;
+        address.import(other.address);
+        if (comment.empty() && !other.comment.empty())
+          comment = other.comment;
+        BOOST_FOREACH(const std::string &t, other.tags) {
+          tags.insert(t);
+        }
+        BOOST_FOREACH(const data_map::value_type &kvp, other.data) {
+          if (data.find(kvp.first) == data.end())
+            data[kvp.first] = kvp.second;
+        }
+      }
+      void apply(const destination_container &other) {
         if (!other.id.empty())
           id = other.id;
-        if (!other.host.empty())
-          host = other.host;
-        if (!other.address.empty())
-          address = other.address;
-//        if (!other.protocol.empty())
-//          protocol = other.protocol;
+        address.apply(other.address);
         if (!other.comment.empty())
           comment = other.comment;
         BOOST_FOREACH(const std::string &t, other.tags) {
-          tags.push_back(t);
+          tags.insert(t);
         }
         BOOST_FOREACH(const data_map::value_type &kvp, other.data) {
@@ -284 +305 @@
       if (!dst.id.empty())
         host->set_id(dst.id);
-      if (!dst.host.empty())
-        host->set_host(dst.host);
-      if (!dst.address.empty())
-        host->set_address(dst.address);
+      if (!dst.address.host.empty())
+        host->set_address(dst.address.to_string());
       if (!dst.has_protocol())
         host->set_protocol(dst.get_protocol());
@@ -307 +326 @@
         if (host.id() == tag) {
           data.id = tag;
-          if (!host.host().empty())
-            data.host = host.host();
-          if (!host.address().empty())
-            data.address = host.address();
-          if (data.address.empty() && !host.host().empty())
-            data.address = host.host();
-//          if (!host.protocol().empty())
-//            data.protocol = host.protocol();
+          data.address.import(net::parse(host.address()));
           if (!host.comment().empty())
             data.comment = host.comment();
           if (expand_meta) {
             for(int j=0;j<host.tags_size(); ++j) {
-              data.tags.push_back(host.tags(j));
+              data.tags.insert(host.tags(j));
             }
             for(int j=0;j<host.metadata_size(); ++j) {
@@ -333 +345 @@
     //////////////////////////////////////////////////////////////////////////
 
-    static void make_submit_from_query(std::string &message, const std::wstring channel, const std::wstring alias = _T("")) {
+    static void make_submit_from_query(std::string &message, const std::wstring channel, const std::wstring alias = _T(""), const std::wstring target = _T("")) {
       Plugin::QueryResponseMessage response;
       response.ParseFromString(message);
@@ -340 +352 @@
       request.mutable_header()->set_source_id(request.mutable_header()->recipient_id());
       request.set_channel(to_string(channel));
+      if (!target.empty()) {
+        request.mutable_header()->set_recipient_id(to_string(target));
+      }
       for (int i=0;i<response.payload_size();++i) {
         request.add_payload()->CopyFrom(response.payload(i));

include/nscapi/targets.cpp

@@ -1 +1 @@
 #include <nscapi/targets.hpp>
 
-namespace sh = nscapi::settings_helper;
-
-
-nscapi::target_handler::target nscapi::target_handler::read_target(boost::shared_ptr<nscapi::settings_proxy> proxy, std::wstring path, std::wstring alias, std::wstring host) {
-  target t;
-  t.alias = alias;
-  t.host = host;
-  std::wstring tpath = path + _T("/") + alias;
-
-  sh::settings_registry settings(proxy);
-
-  settings.path(path).add_path()
-    (alias, sh::wstring_map_path(&t.options), 
-    _T("TARGET DEFENITION"), _T("Target defnition for: ") + alias)
-
-    ;
-
-  settings.path(tpath).add_key()
-//    (_T("protocol"), sh::wstring_key(&t.protocol, _T("*")),
-//    _T("TARGET PROTOCOL"), _T("The default protocol to use for target"))
-
-    (_T("host"), sh::wstring_key(&t.host, t.host),
-    _T("TARGET HOST"), _T("Target host name"))
-
-    (_T("address"), sh::wstring_key(&t.address, t.address),
-    _T("TARGET ADDRESS"), _T("Target host address"))
-
-    (_T("alias"), sh::wstring_key(&t.alias, t.alias),
-    _T("TARGET ALIAS"), _T("The alias for the target"))
-
-    (_T("parent"), sh::wstring_key(&t.parent, _T("default")),
-    _T("TARGET PARENT"), _T("The parent the target inherits from"))
-
-    ;
-
-  settings.register_all();
-  settings.notify();
-
-  if (!t.parent.empty() && t.parent != alias & t.parent != t.alias) {
-    target p;
-    optarget tmp = find_target(t.parent);
-    if (tmp)
-      p = *tmp;
-    else {
-      p = read_target(proxy, path, t.parent, _T(""));
-      add_template(p);
-    }
-    apply_parent(t, p);
-  }
-  return t;
-}
-
-nscapi::target_handler::optarget nscapi::target_handler::find_target(std::wstring alias) {
-  target_list_type::const_iterator cit = target_list.find(alias);
-  if (cit != target_list.end())
-    return optarget(cit->second);
-  cit = template_list.find(alias);
-  if (cit != template_list.end())
-    return optarget(cit->second);
-  return optarget();
-}
-
-bool nscapi::target_handler::has_target(std::wstring alias) {
-  target_list_type::const_iterator cit = target_list.find(alias);
-  if (cit != target_list.end())
-    return true;
-  cit = template_list.find(alias);
-  if (cit != template_list.end())
-    return true;
-  return false;
-}
-
-void nscapi::target_handler::apply_parent(target &t, target &p) {
-  if (t.host.empty())
-    t.host = p.host;
-  if (t.host.empty())
-    t.host = p.host;
-  BOOST_FOREACH(target::options_type::value_type i, p.options) {
-    if (t.options.find(i.first) != t.options.end())
-      t.options[i.first] = i.second;
-  }
-}
-
-void nscapi::target_handler::rebuild() {
-  // TODO re-build targets since default has changed!
-}
-
-
-std::wstring nscapi::target_handler::to_wstring() {
-  std::wstringstream ss;
-  ss << _T("Targets: ");
-  BOOST_FOREACH(target_list_type::value_type t, target_list) {
-    ss << _T(", ") << t.first << _T(" = {") << t.second.to_wstring() + _T("} ");
-  }
-  ss << _T("Templates: ");
-  BOOST_FOREACH(target_list_type::value_type t, target_list) {
-    ss << _T(", ") << t.first << _T(" = {") << t.second.to_wstring() + _T("} ");
-  }
-  return ss.str();
-}

include/nscapi/targets.hpp

@@ -10 +10 @@
 #include <settings/client/settings_client.hpp>
 #include <nscapi/settings_proxy.hpp>
+#include <nscapi/functions.hpp>
 
 #include <net/net.hpp>
 
 namespace nscapi {
-  struct target_handler {
-
-    struct target {
-      std::wstring host;
+
+  namespace settings_object_helper {
+    class default_object_type {
+      std::wstring path;
       std::wstring alias;
-      //std::wstring protocol;
-      std::wstring address;
+      std::wstring value;
       std::wstring parent;
+    };
+
+    template<class object_type>
+    class default_object_reader {
+      static void read_target(boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {}
+      static void apply_parent(object_type &object, object_type &parent) {}
+      static void post_process_object(object_type &object) {}
+      static void init_default(object_type &object) {}
+    };
+
+
+    template<class object_type = default_object_type, class object_reader = default_object_reader<default_object_type> >
+    struct target_handler : boost::noncopyable {
+      typedef boost::optional<object_type> optional_object;
+      typedef optional_object optarget;
+      typedef object_type target;
+      typedef std::map<std::wstring, object_type> object_list_type;
+      typedef target_handler<object_type, object_reader> my_type;
+
+      object_list_type object_list;
+      object_list_type template_list;
+
+      void add_missing(boost::shared_ptr<nscapi::settings_proxy> proxy, std::wstring path, std::wstring alias, std::wstring value, bool is_template = false) {
+        if (has_object(alias))
+          return;
+        add(proxy, path, alias, value, is_template);
+      }
+
+      object_type add(boost::shared_ptr<nscapi::settings_proxy> proxy, std::wstring path, std::wstring alias, std::wstring value, bool is_template = false) {
+        object_type object;
+        object.alias = alias;
+        object.value = value;
+        object.path = path + _T("/") + alias;
+        object.parent = _T("default");
+
+        object_reader::read_target(proxy, object);
+
+        if (!object.parent.empty() && object.parent != alias & object.parent != object.alias) {
+          object_type parent;
+          optional_object tmp = find_object(object.parent);
+          if (!tmp) {
+            parent = add(proxy, path, object.parent, _T(""));
+            add_template(parent);
+          } else {
+            parent = *tmp;
+          }
+          object_reader::apply_parent(object, parent);
+        }
+        if (is_template)
+          add_template(object);
+        else
+          add_object(object);
+        return object;
+      }
+
+      void rebuild(boost::shared_ptr<nscapi::settings_proxy> proxy) {
+        std::list<object_type> tmp;
+        BOOST_FOREACH(object_list_type::value_type t, object_list) {
+          tmp.push_back(t.second);
+        }
+        object_list.clear();
+        BOOST_FOREACH(const &object_item o, tmp) {
+          std::wstring::size_type pos = o.path.find_last_of(_T("/"));
+          if (pos == std::wstring::npos)
+            continue;
+          add(proxy, o.path.substr(0, pos-1), o.path.substr(pos), o.host);
+        }
+      }
+
+
+      optional_object find_object(std::wstring alias) {
+        object_list_type::const_iterator cit = object_list.find(alias);
+        if (cit != object_list.end())
+          return optional_object(cit->second);
+        cit = template_list.find(alias);
+        if (cit != template_list.end())
+          return optional_object(cit->second);
+        return optional_object();
+      }
+
+      bool has_object(std::wstring alias) {
+        object_list_type::const_iterator cit = object_list.find(alias);
+        if (cit != object_list.end())
+          return true;
+        cit = template_list.find(alias);
+        if (cit != template_list.end())
+          return true;
+        return false;
+      }
+
+
+      std::wstring to_wstring() {
+        std::wstringstream ss;
+        ss << _T("Objects: ");
+        BOOST_FOREACH(object_list_type::value_type t, object_list) {
+          ss << _T(", ") << t.first << _T(" = {") << t.second.to_wstring() + _T("} ");
+        }
+        ss << _T("Templates: ");
+        BOOST_FOREACH(object_list_type::value_type t, template_list) {
+          ss << _T(", ") << t.first << _T(" = {") << t.second.to_wstring() + _T("} ");
+        }
+        return ss.str();
+      }
+
+      void add_object(object_type object) {
+        object_reader::post_process_object(object);
+        object_list_type::iterator cit = template_list.find(object.alias);
+        if (cit != template_list.end())
+          template_list.erase(cit);
+        object_list[object.alias] = object;
+      }
+      void add_template(object_type object) {
+        object_list_type::const_iterator cit = object_list.find(object.alias);
+        if (cit != object_list.end())
+          return;
+        object_reader::post_process_object(object);
+        template_list[object.alias] = object;
+      }
+    };
+  }
+
+
+  namespace targets {
+    struct target_object {
+
+      std::wstring path;
+      std::wstring alias;
+      std::wstring value;
+      std::wstring parent;
+
+      net::wurl address;
       typedef std::map<std::wstring,std::wstring> options_type;
       options_type options;
 
-      std::wstring to_wstring() {
+      std::wstring to_wstring() const {
         std::wstringstream ss;
         ss << _T("Target: ") << alias;
-        ss << _T(", host: ") << host;
-//        ss << _T(", protocol: ") << protocol;
-        ss << _T(", address: ") << address;
+        ss << _T(", address: ") << get_address();
         ss << _T(", parent: ") << parent;
         BOOST_FOREACH(options_type::value_type o, options) {
@@ -37 +166 @@
         return ss.str();
       }
-
-      bool has_protocol() {
-        return !address.empty();
-      }
-      std::wstring get_protocol() {
-        net::wurl url = net::parse(address);
-        return url.protocol;
-      }
-      bool has_option(std::wstring key) {
+      std::wstring get_address() const {
+        return address.to_string();
+      }
+      void set_address(std::wstring value) {
+        net::wurl n = net::parse(value);
+        address.apply(n);
+      }
+      void set_host(std::wstring value) {
+        address.host = value;
+      }
+      void set_port(int value) {
+        address.host = strEx::itos(value);
+      }
+      bool has_option(std::wstring key) const {
         return options.find(key) != options.end();
       }
-      bool has_option(std::string key) {
+      bool has_option(std::string key) const {
         return has_option(utf8::cvt<std::wstring>(key));
       }
-
-    };
-    typedef boost::optional<target> optarget;
-    typedef std::map<std::wstring, target> target_list_type;
-
-    target_list_type target_list;
-    target_list_type template_list;
-    target add(boost::shared_ptr<nscapi::settings_proxy> proxy, std::wstring path, std::wstring key, std::wstring value) {
-      target t = read_target(proxy, path, key, value);
-      add(t);
-      return t;
-    }
-    void add(target t) {
-      target_list[t.alias] = t;
-    }
-    void add_template(target t) {
-      template_list[t.alias] = t;
-    }
-    target read_target(boost::shared_ptr<nscapi::settings_proxy> proxy, std::wstring path, std::wstring alias, std::wstring host);
-    void rebuild();
-
-    optarget find_target(std::wstring alias);
-    bool has_target(std::wstring alias);
-    static void apply_parent(target &t, target &p);
-    std::wstring to_wstring();
-
-  };
+      void set_property_int(std::wstring key, int value) {
+        if (key == _T("port")) {
+          set_port(value);
+        } else 
+          options[key] = strEx::itos(value);
+      }
+      void set_property_bool(std::wstring key, bool value) {
+        options[key] = value?_T("true"):_T("false");
+      }
+      void set_property_string(std::wstring key, std::wstring value) {
+        if (key == _T("host")) {
+          set_host(value);
+        } else 
+          options[key] = value;
+      }
+
+      nscapi::functions::destination_container to_destination_container() const {
+        nscapi::functions::destination_container ret;
+        if (!alias.empty())
+          ret.id = utf8::cvt<std::string>(alias);
+        ret.address.apply(net::wide_to_url(address));
+        BOOST_FOREACH(const options_type::value_type &kvp, options) {
+          ret.data[utf8::cvt<std::string>(kvp.first)] = utf8::cvt<std::string>(kvp.second);
+        }
+        return ret;
+      }
+
+    };
+    typedef boost::optional<target_object> optional_target_object;
+    typedef std::map<std::wstring,std::wstring> targets_type;
+
+    struct target_object_reader {
+      typedef target_object object_type;
+      static void read_target(boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object);
+      static void apply_parent(object_type &object, object_type &parent);
+    };
+
+    namespace sh = nscapi::settings_helper;
+    struct dummy_custom_reader {
+      typedef target_object object_type;
+      static void add_custom_keys(sh::settings_registry &settings, boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {}
+    };
+
+    template<class custom_reader>
+    struct split_object_reader {
+      typedef target_object object_type;
+
+      static void post_process_object(object_type &object) {
+        custom_reader::post_process_target(object);
+      }
+
+      static void read_target(boost::shared_ptr<nscapi::settings_proxy> proxy, object_type &object) {
+        object.address = net::parse(object.value, 0);
+        if (object.alias == _T("default"))
+          custom_reader::init_default(object);
+
+        nscapi::settings_helper::settings_registry settings(proxy);
+
+        object_type::options_type options;
+        settings.path(object.path).add_path()
+          (object.alias, nscapi::settings_helper::wstring_map_path(&options), 
+          _T("TARGET DEFENITION"), _T("Target definition for: ") + object.alias)
+
+          ;
+
+        settings.path(object.path).add_key()
+
+          (_T("address"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_address, &object, _1)),
+          _T("TARGET ADDRESS"), _T("Target host address"))
+
+          (_T("host"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_host, &object, _1)),
+          _T("TARGET HOST"), _T("The target server to report results to."))
+
+          (_T("port"), sh::int_fun_key<int>(boost::bind(&object_type::set_port, &object, _1)),
+          _T("TARGET PORT"), _T("The target server port"))
+
+          (_T("alias"), nscapi::settings_helper::wstring_key(&object.alias, object.alias),
+          _T("TARGET ALIAS"), _T("The alias for the target"))
+
+          (_T("parent"), nscapi::settings_helper::wstring_key(&object.parent, _T("default")),
+          _T("TARGET PARENT"), _T("The parent the target inherits from"))
+
+          ;
+        custom_reader::add_custom_keys(settings, proxy, object);
+
+        settings.register_all();
+        settings.notify();
+
+        BOOST_FOREACH(const object_type::options_type::value_type &kvp, options) {
+          if (!object.has_option(kvp.first))
+            object.options[kvp.first] = kvp.second;
+        }
+
+      }
+
+      static void apply_parent(object_type &object, object_type &parent) {
+        object.address.import(parent.address);
+        BOOST_FOREACH(object_type::options_type::value_type i, parent.options) {
+          if (object.options.find(i.first) == object.options.end())
+            object.options[i.first] = i.second;
+        }
+      }
+
+    };
+    template<class custom_reader>
+    struct handler : public nscapi::settings_object_helper::target_handler<target_object, split_object_reader<custom_reader > > {};
+
+/*
+    template<class custom_reader>
+    */
+    //typedef nscapi::settings_object_helper::target_handler<target_object, split_object_reader<dummy_custom_reader > > handler;
+
+  }
 }
 

include/settings/client/settings_client.hpp

@@ -67 +67 @@
     };
     template<class T>
+    class typed_string_value_no_default : public typed_key<T> {
+    public:
+      typed_string_value_no_default(const T& v) : typed_key<T>(v) {}
+      virtual NSCAPI::settings_type get_type() const {
+        return NSCAPI::key_string;
+      }
+      virtual void notify(settings_impl_interface_ptr core_, std::wstring path, std::wstring key) const {
+        std::wstring dummy = _T("$$DUMMY_VALUE_DO_NOT_USE$$");
+        std::wstring data = core_->get_string(path, key, dummy);
+        if (data != dummy) {
+          T value = boost::lexical_cast<T>(data);
+          update_target(&value);
+        }
+      }
+      virtual void notify(settings_impl_interface_ptr core_, std::wstring parent, std::wstring path, std::wstring key) const {
+        std::wstring dummy = _T("$$DUMMY_VALUE_DO_NOT_USE$$");
+        std::wstring data = core_->get_string(parent, key, dummy);
+        if (data != dummy) 
+          dummy = data;
+        data = core_->get_string(path, key, dummy);
+        if (data != dummy) {
+          T value = boost::lexical_cast<T>(data);
+          update_target(&value);
+        }
+      }
+    };
+    template<class T>
     class typed_path_value : public typed_key<T> {
     public:
@@ -85 +112 @@
       }
     };
+    
     template<class T>
     class typed_int_value : public typed_key<T> {
@@ -104 +132 @@
         T default_value = static_cast<T>(core_->get_int(parent, key, default_value_as_int_));
         T value = static_cast<T>(core_->get_int(path, key, default_value));
+        update_target(&value);
+      }
+    protected:
+      int default_value_as_int_;
+    };
+    template<class T>
+    class typed_int_value_no_default : public typed_key<T> {
+    public:
+      typed_int_value_no_default(const T& v) : typed_key<T>(v), default_value_as_int_(0) {}
+      typed_key<T>* default_value(const T& v) {
+        typed_key<T>::default_value(v);
+        default_value_as_int_ = boost::lexical_cast<int>(v);
+        return this;
+      }
+      virtual NSCAPI::settings_type get_type() const {
+        return NSCAPI::key_integer;
+      }
+      virtual void notify(settings_impl_interface_ptr core_, std::wstring path, std::wstring key) const {
+        int dummy = -1;
+        int val = core_->get_int(path, key, dummy);
+        if (val == dummy) {
+          dummy = -2;
+          val = core_->get_int(path, key, dummy);
+          if (val == dummy)
+            return;
+        }
+        T value = static_cast<T>(val);
+        update_target(&value);
+      }
+      virtual void notify(settings_impl_interface_ptr core_, std::wstring parent, std::wstring path, std::wstring key) const {
+        int dummy = -1;
+        int defval = core_->get_int(path, key, dummy);
+        if (defval == dummy) {
+          dummy = -2;
+          defval = core_->get_int(path, key, dummy);
+        }
+        if (defval != dummy) {
+          T value = static_cast<T>(core_->get_int(path, key, defval));
+          update_target(&value);
+        }
+        dummy = -1;
+        int val = core_->get_int(path, key, dummy);
+        if (val == dummy) {
+          dummy = -2;
+          val = core_->get_int(path, key, dummy);
+          if (val == dummy)
+            return;
+        }
+        T value = static_cast<T>(val);
         update_target(&value);
       }
@@ -196 +273 @@
     }
     template<class T>
+    boost::shared_ptr<typed_key_fun<T, typed_int_value_no_default<T> > > int_fun_key(boost::function<void (T)> fun) {
+      boost::shared_ptr<typed_key_fun<T, typed_int_value_no_default<T> > > r(new typed_key_fun<T, typed_int_value_no_default<T> >(fun, 0));
+      return r;
+    }
+    template<class T>
     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));
@@ -203 +285 @@
     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;
+    }
+    template<class T>
+    boost::shared_ptr<typed_key_fun<T, typed_string_value_no_default<T> > > string_fun_key(boost::function<void (T)> fun) {
+      boost::shared_ptr<typed_key_fun<T, typed_string_value_no_default<T> > > r(new typed_key_fun<T, typed_string_value_no_default<T> >(fun, T()));
       return r;
     }

include/settings/settings_http.hpp

@@ -22 +22 @@
   public:
     settings_http(settings::settings_core *core, std::wstring context) : settings::SettingsInterfaceImpl(core, context) {
-      net::url url = net::parse(context).get_url();
+      net::url url = net::parse(utf8::cvt<std::string>(context));
       std::wstring path = core->expand_path(DEFAULT_CACHE_PATH);
       if (!file_helpers::checks::is_directory(path)) {

include/settings/settings_interface_impl.hpp

@@ -183 +183 @@
         return get_string(path, key);
       } catch (KeyNotFoundException e) {
-        MUTEX_GUARD();
-        settings_cache_[cache_key_type(path,key)] = def;
+        //MUTEX_GUARD();
+        //settings_cache_[cache_key_type(path,key)] = def;
         return def;
       }
@@ -200 +200 @@
         MUTEX_GUARD();
         settings_cache_[cache_key_type(path,key)] = value;
+        path_cache_.insert(path);
       }
       add_key(path, key);
@@ -269 +270 @@
         return get_int(path, key);
       } catch (KeyNotFoundException e) {
-        MUTEX_GUARD();
-        settings_cache_[cache_key_type(path,key)] = def;
+        //MUTEX_GUARD();
+        //settings_cache_[cache_key_type(path,key)] = def;
         return def;
       }
@@ -286 +287 @@
         MUTEX_GUARD();
         settings_cache_[cache_key_type(path,key)] = value;
+        path_cache_.insert(path);
       }
       add_key(path, key);
@@ -353 +355 @@
         return get_bool(path, key);
       } catch (KeyNotFoundException e) {
-        MUTEX_GUARD();
-        settings_cache_[cache_key_type(path,key)] = def;
+        //MUTEX_GUARD();
+        //settings_cache_[cache_key_type(path,key)] = def;
         return def;
       }
@@ -370 +372 @@
         MUTEX_GUARD();
         settings_cache_[cache_key_type(path,key)] = value;
+        path_cache_.insert(path);
       }
       add_key(path, key);
@@ -406 +409 @@
           }
         }
+        // TODO add support for retrieving all key paths here!
       } else {
         std::wstring::size_type path_len = path.length();

modules/NRPEClient/NRPEClient.cpp

@@ -81 +81 @@
       ;
 
-    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_);
@@ -105 +93 @@
     register_command(_T("nrpe_exec"), _T("Execute (via query) remote NRPE host"));
     register_command(_T("nrpe_help"), _T("Help on using NRPE Client"));
-    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!"));
-    }
-
   } catch (nscapi::nscapi_exception &e) {
     NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
@@ -150 +119 @@
 void NRPEClient::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"))) {
-      std::wstring value = t.options[_T("certificate")];
-      boost::filesystem::wpath p = value;
-      if (!boost::filesystem::is_regular(p)) {
-        p = get_core()->getBasePath() / p;
-        if (boost::filesystem::is_regular(p)) {
-          value = p.string();
-        } else {
-          value = get_core()->expand_path(value);
-        }
-        t.options[_T("certificate")] = value;
-        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());
-      }
-    }
+    nscapi::targets::target_object t = 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()));
@@ -199 +149 @@
 
 NSCAPI::nagiosReturn NRPEClient::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("nrpe"));
+  Plugin::QueryRequestMessage message;
+  message.ParseFromString(request);
+  if (message.payload_size() != 1) {
+    return nscapi::functions::create_simple_query_response_unknown(char_command, _T("Multiple payloads currently not supported"), result);
+  }
+  std::string recipient = message.header().recipient_id();
+  nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(message.payload(0));
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("nrpe"));
   client::configuration config;
+  config.data->recipient.id = recipient;
   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);
+  return commands.exec_simple(config, data.target, cmd, data.args, result);
 }
 
@@ -245 +202 @@
   add_local_options(config.local, config.data);
 
-  net::wurl url;
-  url.protocol = _T("nrpe");
-  url.port = 5666;
-  nscapi::target_handler::optarget opt = targets.find_target(_T("default"));
+  config.data->recipient.address = net::parse("nrpe://localhost:5666");
+  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)]);
-    }
+    nscapi::targets::target_object t = *opt;
+    nscapi::functions::destination_container def = t.to_destination_container();
+    config.data->recipient.apply(def);
   }
   config.data->recipient.id = "default";
-  config.data->recipient.address = utf8::cvt<std::string>(url.to_string());
   config.data->host_self.id = "self";
   //config.data->host_self.host = hostname_;
@@ -271 +223 @@
 }
 
-NRPEClient::connection_data NRPEClient::parse_header(const ::Plugin::Common_Header &header) {
+NRPEClient::connection_data NRPEClient::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, targets.find_target(_T("default")));
+  return connection_data(recipient, data->recipient);
 }
 
@@ -284 +236 @@
   Plugin::QueryRequestMessage request_message;
   request_message.ParseFromString(request);
-  connection_data con = this->instance->parse_header(*header);
+  connection_data con = this->instance->parse_header(*header, data);
 
   Plugin::QueryResponseMessage response_message;
@@ -306 +258 @@
   Plugin::SubmitRequestMessage request_message;
   request_message.ParseFromString(request);
-  connection_data con = this->instance->parse_header(*header);
+  connection_data con = this->instance->parse_header(*header, data);
   std::wstring channel = utf8::cvt<std::wstring>(request_message.channel());
   
@@ -328 +280 @@
   Plugin::ExecuteRequestMessage request_message;
   request_message.ParseFromString(request);
-  connection_data con = this->instance->parse_header(*header);
+  connection_data con = this->instance->parse_header(*header, data);
 
   Plugin::ExecuteResponseMessage response_message;

modules/NRPEClient/NRPEClient.h

@@ -33 +33 @@
 
 namespace po = boost::program_options;
+namespace sh = nscapi::settings_helper;
 
 class NRPEClient : public nscapi::impl::simple_plugin {
@@ -40 +41 @@
   std::wstring target_path;
 
-  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."))
+
+        (_T("use ssl"), sh::bool_fun_key<bool>(boost::bind(&object_type::set_property_bool, &object, _T("ssl"), _1), true),
+        _T("ENABLE SSL ENCRYPTION"), _T("This option controls if SSL should be enabled."))
+
+        (_T("certificate"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("certificate"), _1), _T("${certificate-path}/nrpe_dh_512.pem")),
+        _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."))
+        ;
+    }
+
+    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 +108 @@
     bool use_ssl;
 
-    connection_data(nscapi::functions::destination_container recipient, nscapi::target_handler::optarget dt) {
-      cert = recipient.get_string_data("certificate", dt?utf8::cvt<std::string>(dt->options[_T("certificate")]):"");
-      timeout = recipient.get_int_data("timeout", 30);
-      buffer_length = recipient.get_int_data("payload length", 1024);
-      use_ssl = recipient.get_bool_data("ssl");
-      if (recipient.has_data("no ssl"))
-        use_ssl = !recipient.get_bool_data("no ssl");
-      if (recipient.has_data("use ssl"))
-        use_ssl = recipient.get_bool_data("use ssl");
-
-      net::url url = recipient.get_url(5666);
-      host = url.host;
-      port = url.get_port();
+    connection_data(nscapi::functions::destination_container arguments, nscapi::functions::destination_container target) {
+      arguments.import(target);
+      cert = arguments.get_string_data("certificate", "");
+      timeout = arguments.get_int_data("timeout", 30);
+      buffer_length = arguments.get_int_data("payload length", 1024);
+      use_ssl = arguments.get_bool_data("ssl");
+      if (arguments.has_data("no ssl"))
+        use_ssl = !arguments.get_bool_data("no ssl");
+      if (arguments.has_data("use ssl"))
+        use_ssl = arguments.get_bool_data("use ssl");
+
+      host = arguments.address.host;
+      port = arguments.address.get_port_string("5666");
     }
 
@@ -88 +145 @@
 
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
+      nscapi::targets::optional_target_object t = instance->targets.find_object(id);
+      if (t)
+        return t->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;
     }
@@ -155 +201 @@
   static nrpe::packet send_ssl(std::string cert, std::string host, std::string port, int timeout, nrpe::packet packet);
 
-  connection_data parse_header(const ::Plugin::Common_Header &header);
+  connection_data parse_header(const ::Plugin::Common_Header &header, client::configuration::data_type data);
 
 private:

modules/NSCAClient/NSCAClient.cpp

@@ -94 +94 @@
       ;
 
-    settings.alias().add_key_to_settings(_T("targets/default"))
-
-      (_T("timeout"), sh::uint_key(&timeout, 30),
-      _T("TIMEOUT"), _T("Timeout when reading packets on incoming sockets. If the data has not arrived withint this time we will bail out."))
-
-      (_T("host"), sh::wstring_key(&nscahost),
-      _T("NSCA HOST"), _T("The NSCA server to report results to."))
-
-      (_T("port"), sh::uint_key(&nscaport, 5667),
-      _T("NSCA PORT"), _T("The NSCA server port"))
-
-      (_T("encryption"), sh::wstring_key(&encryption, _T("aes")),
-      _T("ENCRYPTION METHOD"), _T("Number corresponding to the various encryption algorithms (see the wiki). Has to be the same as the server or it wont work at all."))
-
-      (_T("password"), sh::wstring_key(&password),
-      _T("PASSWORD"), _T("The password to use. Again has to be the same as the server or it wont work at all."))
-
-      (_T("payload length"), sh::uint_key(&payload_length, 512),
-      _T("PAYLOAD LENGTH"), _T("Length of payload to/from the NSCA agent. This is a hard specific value so you have to \"configure\" (read recompile) your NSCA agent to use the same value for it to work."))
-
-      (_T("time offset"), sh::string_key(&delay, "0"),
-      _T("TIME OFFSET"), _T("Time offset."))
-      ;
-
     settings.register_all();
     settings.notify();
@@ -126 +102 @@
       hostname_ = boost::asio::ip::host_name();
     }
-
-    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) {
-      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!"));
-    }
-
   } catch (nscapi::nscapi_exception &e) {
     NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
@@ -200 +151 @@
 void NSCAAgent::add_target(std::wstring key, std::wstring arg) {
   try {
-    targets.add(get_settings_proxy(), target_path , key, arg);
+    nscapi::targets::target_object t = targets.add(get_settings_proxy(), target_path , key, arg);
   } catch (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -286 +237 @@
   add_local_options(config.local, config.data);
 
-  net::wurl url;
-  url.protocol = _T("nsca");
-  url.port = 5667;
-  nscapi::target_handler::optarget opt = targets.find_target(_T("default"));
+  config.data->recipient.id = "default";
+  config.data->recipient.address = net::parse("nsca://localhost:5667");
+
+  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
   if (opt) {
-    nscapi::target_handler::target t = *opt;
-    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"};
-    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.import(def);
+  }
   config.data->host_self.id = "self";
-  config.data->host_self.host = hostname_;
+  config.data->host_self.address.host = hostname_;
 
   config.target_lookup = handler;

modules/NSCAClient/NSCAClient.h

@@ -33 +33 @@
 
 namespace po = boost::program_options;
+namespace sh = nscapi::settings_helper;
 
 class NSCAAgent : public nscapi::impl::simple_plugin {
@@ -43 +44 @@
   long time_delta_;
 
-  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_string(_T("encryption"), _T("ase"));
+      target.set_property_int(_T("payload length"), 512);
+    }
+    static void post_process_target(target_object &target) {}
+
+    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."))
+
+        (_T("payload length"),  sh::int_fun_key<int>(boost::bind(&object_type::set_property_int, &object, _T("payload length"), _1), 512),
+        _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."))
+
+        (_T("encryption"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("encryption"), _1), _T("aes")),
+        _T("ENCRYPTION METHOD"), _T("Number corresponding to the various encryption algorithms (see the wiki). Has to be the same as the server or it wont work at all."))
+
+        (_T("password"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("password"), _1), _T("")),
+        _T("PASSWORD"), _T("The password to use. Again has to be the same as the server or it wont work at all."))
+
+        (_T("time offset"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("delay"), _1), _T("0")),
+        _T("TIME OFFSET"), _T("Time offset."))
+        ;
+    }
+  };
+
+  nscapi::targets::handler<custom_reader> targets;
   client::command_manager commands;
 
@@ -65 +98 @@
       else
         time_delta = 0;
-      net::url url = recipient.get_url(5667);
-      host = url.host;
-      port = url.get_port();
-      sender_hostname = sender.host;
+      host = recipient.address.get_host();
+      port = strEx::s::itos(recipient.address.get_port(5667));
+      sender_hostname = sender.address.host;
       if (sender.has_data("host"))
         sender_hostname = sender.get_string_data("host");
@@ -100 +132 @@
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
       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);
-        }
-      }
+      nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
+      if (opt)
+        return opt->to_destination_container();
       return ret;
     }

modules/NSCPClient/NSCPClient.cpp

@@ -88 +88 @@
       ;
 
-    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();
 
     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!"));
-    }
 
   } catch (nscapi::nscapi_exception &e) {
@@ -153 +119 @@
 void NSCPClient::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 (...) {
     NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
@@ -239 +192 @@
   add_local_options(config.local, config.data);
 
-  net::wurl url;
-  url.protocol = _T("nscp");
-  url.port = 5668;
-  nscapi::target_handler::optarget opt = targets.find_target(_T("default"));
+  config.data->recipient.id = "default";
+  config.data->recipient.address = net::parse("nscp://localhost:5668");
+  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
   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::functions::destination_container def = opt->to_destination_container();
+    config.data->recipient.import(def);
+  }
   config.data->host_self.id = "self";
   //config.data->host_self.host = hostname_;

modules/NSCPClient/NSCPClient.h

@@ -22 +22 @@
 
 #include <boost/tuple/tuple.hpp>
+#include <boost/filesystem.hpp>
 
 #include <client/command_line_parser.hpp>
@@ -33 +34 @@
 
 namespace po = boost::program_options;
+namespace sh = nscapi::settings_helper;
 
 
@@ -41 +43 @@
   std::wstring target_path;
 
-  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 post_process_target(target_object &target) {}
+
+    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."))
+
+        (_T("use ssl"), sh::bool_fun_key<bool>(boost::bind(&object_type::set_property_bool, &object, _T("ssl"), _1), true),
+        _T("ENABLE SSL ENCRYPTION"), _T("This option controls if SSL should be enabled."))
+
+        (_T("certificate"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("certificate"), _1), _T("${certificate-path}/nrpe_dh_512.pem")),
+        _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."))
+        ;
+    }
+
+    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;
 
@@ -57 +117 @@
       if (recipient.has_data("no ssl"))
         use_ssl = !recipient.get_bool_data("no ssl");
-      net::url url = recipient.get_url(5668);
-      host = url.host;
-      port = url.get_port();
+      host = recipient.address.host;
+      port = recipient.address.get_port(5668);
     }
 
@@ -84 +143 @@
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
       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);
-        }
-      }
+      nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
+      if (opt)
+        return opt->to_destination_container();
       return ret;
     }

modules/SMTPClient/SMTPClient.cpp

@@ -79 +79 @@
 
       ;
-
-    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("sender"), sh::wpath_key(&sender, _T("nscp@localhost")),
-      _T("SENDER"), _T("Sender of email message"))
-
-      (_T("recipient"), sh::wpath_key(&recipient, _T("nscp@localhost")),
-      _T("RECIPIENT"), _T("Recipient of email message"))
-
-      (_T("template"), sh::wpath_key(&template_string, _T("Hello, this is %source% reporting %message%!")),
-      _T("TEMPLATE"), _T("Template for message data"))
-
-      ;
-
     settings.register_all();
     settings.notify();
 
     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("template"))
-        t->options[_T("template")] = template_string;
-      if (!t->has_option("timeout"))
-        t->options[_T("timeout")] = strEx::itos(timeout);
-      if (!t->has_option("recipient"))
-        t->options[_T("recipient")] = recipient;
-      if (!t->has_option("sender"))
-        t->options[_T("sender")] = sender;
-      targets.add(*t);
-    } else {
-      NSC_LOG_ERROR(_T("Default target not found!"));
-    }
-
   } catch (nscapi::nscapi_exception &e) {
     NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
@@ -223 +186 @@
   add_local_options(config.local, config.data);
 
-  net::wurl url;
-  url.protocol = _T("smtp");
-  url.port = 25;
-  nscapi::target_handler::optarget opt = targets.find_target(_T("default"));
+  config.data->recipient.id = "default";
+  config.data->recipient.address = net::parse("smtp://localhost:25");
+  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
   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[] = {"sender", "timeout", "recipient", "template"};
-    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::functions::destination_container def = opt->to_destination_container();
+    config.data->recipient.import(def);
+  }
   config.data->host_self.id = "self";
   //config.data->host_self.host = hostname_;

modules/SMTPClient/SMTPClient.h

@@ -30 +30 @@
 
 namespace po = boost::program_options;
+namespace sh = nscapi::settings_helper;
 
 class SMTPClient : public nscapi::impl::simple_plugin {
@@ -37 +38 @@
   std::wstring target_path;
 
-  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_string(_T("sender"), _T("nscp@localhost"));
+      target.set_property_string(_T("recipient"), _T("nscp@localhost"));
+      target.set_property_string(_T("template"), _T("Hello, this is %source% reporting %message%!"));
+    }
+    static void post_process_target(target_object &target) {}
+
+    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."))
+
+        (_T("sender"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("sender"), _1), _T("nscp@localhost")),
+        _T("SENDER"), _T("Sender of email message"))
+
+        (_T("recipient"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("recipient"), _1), _T("nscp@localhost")),
+        _T("RECIPIENT"), _T("Recipient of email message"))
+
+        (_T("template"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("template"), _1), _T("Hello, this is %source% reporting %message%!")),
+        _T("TEMPLATE"), _T("Template for message data"))
+      ;
+    }
+  };
+
+  nscapi::targets::handler<custom_reader> targets;
   client::command_manager commands;
 
@@ -54 +86 @@
       template_string = recipient.get_string_data("template");
 
-      net::url url = recipient.get_url(25);
-      host = url.host;
-      port = url.get_port();
+      host = recipient.address.host;
+      port = recipient.address.get_port(25);
     }
 
@@ -82 +113 @@
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
       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);
-        }
-      }
+      nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
+      if (opt)
+        return opt->to_destination_container();
       return ret;
     }

modules/Scheduler/Scheduler.cpp

@@ -118 +118 @@
     _T("REPORT MODE"), _T("What to report to the server (any of the following: all, critical, warning, unknown, ok)"))
 
+    (_T("target"), sh::wstring_key(&item.target_id, def==NULL?_T(""):def->target_id),
+    _T("TARGET"), _T(""))
+
     // TODO: get the proper default value here!
     (_T("interval"), sh::wstring_key(&duration, _T("5s")),
@@ -167 +170 @@
       // @todo: allow renaming of commands here item.alias, 
       // @todo this is broken, fix this (uses the wrong message)
-      nscapi::functions::make_submit_from_query(response, item.channel, item.alias);
+      nscapi::functions::make_submit_from_query(response, item.channel, item.alias, item.target_id);
       std::string result;
       GET_CORE()->submit_message(item.channel, response, result);

modules/Scheduler/simple_scheduler.hpp

@@ -27 +27 @@
     int id;
     std::wstring alias;
+    std::wstring target_id;
 
     std::wstring command;
@@ -46 +47 @@
     target(const target &other) : id(other.id), alias(other.alias)
       , command(other.command), arguments(other.arguments), tag(other.tag)
-      , duration(other.duration), report(other.report), channel(other.channel) {}
+      , duration(other.duration), report(other.report), channel(other.channel), target_id(other.target_id) {}
     target& operator=(target const& other) {
       id = other.id;
@@ -58 +59 @@
       report = other.report;
       channel = other.channel;
+      target_id = other.target_id;
       return *this;
     }
@@ -63 +65 @@
     std::wstring to_string() {
       std::wstringstream ss;
-      ss << alias << _T("[") << id << _T("] = {command: ") << command << _T(", channel") << channel << _T("}");
+      ss << alias << _T("[") << id << _T("] = {command: ") << command << _T(", channel=") << channel << _T(", target_id=") << target_id << _T("}");
       return ss.str();
     }

modules/SyslogClient/SyslogClient.cpp

@@ -114 +114 @@
 
       ;
-
-    settings.alias().add_key_to_settings(_T("targets/default"))
-
-      (_T("severity"), sh::wpath_key(&severity, _T("error")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("facility"), sh::wpath_key(&facility, _T("kernel")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("tag_syntax"), sh::wpath_key(&tag_syntax, _T("NSCP")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("message_syntax"), sh::wpath_key(&message_syntax, _T("%message%")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("ok severity"), sh::wpath_key(&ok_severity, _T("informational")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("warning severity"), sh::wpath_key(&warn_severity, _T("warning")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("critical severity"), sh::wpath_key(&crit_severity, _T("critical")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      (_T("unknown severity"), sh::wpath_key(&unknown_severity, _T("emergency")),
-      _T("SSL CERTIFICATE"), _T(""))
-
-      ;
-
     settings.register_all();
     settings.notify();
 
     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("severity"))
-        t->options[_T("severity")] = severity;
-      if (!t->has_option("facility"))
-        t->options[_T("facility")] = facility;
-      if (!t->has_option("tag syntax"))
-        t->options[_T("tag syntax")] = tag_syntax;
-      if (!t->has_option("message syntax"))
-        t->options[_T("message syntax")] = message_syntax;
-      if (!t->has_option("ok severity"))
-        t->options[_T("ok severity")] = ok_severity;
-      if (!t->has_option("warning severity"))
-        t->options[_T("warning severity")] = warn_severity;
-      if (!t->has_option("critical severity"))
-        t->options[_T("critical severity")] = crit_severity;
-      if (!t->has_option("unknown severity"))
-        t->options[_T("unknown severity")] = unknown_severity;
-      targets.add(*t);
-    } else {
-      NSC_LOG_ERROR(_T("Default target not found!"));
-    }
 
   } catch (nscapi::nscapi_exception &e) {
@@ -284 +228 @@
   add_local_options(config.local, config.data);
 
-  net::wurl url;
-  url.protocol = _T("syslog");
-  url.port = 514;
-  nscapi::target_handler::optarget opt = targets.find_target(_T("default"));
+  config.data->recipient.id = "default";
+  config.data->recipient.address = net::parse("syslog://localhost:514");
+  nscapi::targets::optional_target_object opt = targets.find_object(_T("default"));
   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[] = {"message template", "tag template", "severity", "ok_severity", "warning_severity", "critical_severity", "unknown_severity", "facility"};
-    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::functions::destination_container def = opt->to_destination_container();
+    config.data->recipient.import(def);
+  }
   config.data->host_self.id = "self";
-  config.data->host_self.host = hostname_;
+  config.data->host_self.address.host = hostname_;
 
   config.target_lookup = handler;

modules/SyslogClient/SyslogClient.h

@@ -31 +31 @@
 
 namespace po = boost::program_options;
+namespace sh = nscapi::settings_helper;
 
 class SyslogClient : public nscapi::impl::simple_plugin {
@@ -38 +39 @@
   std::wstring target_path;
 
-  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_string(_T("severity"), _T("error"));
+      target.set_property_string(_T("facility"), _T("kernel"));
+      target.set_property_string(_T("tag syntax"), _T("NSCA"));
+      target.set_property_string(_T("message syntax"), _T("%message%"));
+      target.set_property_string(_T("ok severity"), _T("informational"));
+      target.set_property_string(_T("warning severity"), _T("warning"));
+      target.set_property_string(_T("critical severity"), _T("critical"));
+      target.set_property_string(_T("unknown severity"), _T("emergency"));
+    }
+
+    static void post_process_target(target_object &target) {}
+
+    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("severity"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("severity"), _1), _T("error")),
+        _T("TODO"), _T(""))
+
+        (_T("facility"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("facility"), _1), _T("kernel")),
+        _T("TODO"), _T(""))
+
+        (_T("tag_syntax"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("tag syntax"), _1), _T("NSCA")),
+        _T("TODO"), _T(""))
+
+        (_T("message_syntax"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("message syntax"), _1), _T("%message%")),
+        _T("TODO"), _T(""))
+
+        (_T("ok severity"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("ok severity"), _1), _T("informational")),
+        _T("TODO"), _T(""))
+
+        (_T("warning severity"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("warning severity"), _1), _T("warning")),
+        _T("TODO"), _T(""))
+
+        (_T("critical severity"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("critical severity"), _1), _T("critical")),
+        _T("TODO"), _T(""))
+
+        (_T("unknown severity"), sh::string_fun_key<std::wstring>(boost::bind(&object_type::set_property_string, &object, _T("unknown severity"), _1), _T("emergency")),
+        _T("TODO"), _T(""))
+        ;
+    }
+  };
+
+  nscapi::targets::handler<custom_reader> targets;
   client::command_manager commands;
 
@@ -66 +114 @@
       unknown_severity = recipient.data["unknown severity"];
 
-      net::url url = recipient.get_url(514);
-      host = url.host;
-      port = url.get_port();
+      host = recipient.address.host;
+      port = recipient.address.get_port(514);
     }
 
@@ -94 +141 @@
     virtual nscapi::functions::destination_container lookup_target(std::wstring &id) {
       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);
-        }
-      }
+      nscapi::targets::optional_target_object opt = instance->targets.find_object(id);
+      if (opt)
+        return opt->to_destination_container();
       return ret;
     }

scripts/python/test_nrpe.py

@@ -137 +137 @@
     None
     
-  def submit_payload(self, alias, ssl, length, source, status, msg, perf):
+  def submit_payload(self, alias, ssl, length, source, status, msg, perf, target):
     message = plugin_pb2.QueryRequestMessage()
     
     message.header.version = plugin_pb2.Common.VERSION_1
-    message.header.recipient_id = "test_rp"
+    message.header.recipient_id = target
     host = message.header.hosts.add()
     host.address = "127.0.0.1:15666"
-    host.id = "test_rp"
+    host.id = target
+    if (target == 'valid'):
+      pass
+    else:
+      enc = host.metadata.add()
+      enc.key = "use ssl"
+      enc.value = '%s'%ssl
+      enc = host.metadata.add()
+      enc.key = "payload length"
+      enc.value = '%d'%length
     enc = host.metadata.add()
-    enc.key = "use ssl"
-    enc.value = '%s'%ssl
-    enc = host.metadata.add()
-    enc.key = "payload length"
-    enc.value = '%d'%length
+    enc.key = "timeout"
+    enc.value = '5'
 
     uid = str(uuid.uuid4())
@@ -164 +170 @@
     response_message = plugin_pb2.QueryResponseMessage()
     response_message.ParseFromString(response)
-    result = TestResult()
+    result = TestResult('Testing NRPE: %s for %s'%(alias, target))
     
     found = False
@@ -180 +186 @@
         break
       else:
-        log('Waiting for %s'%uid)
+        log('Waiting for %s (%s/%s)'%(uid,alias,target))
         sleep(1)
     if found:
@@ -187 +193 @@
 
   def test_one(self, ssl=True, length=1024, state = status.UNKNOWN, tag = 'TODO'):
-    r1 = self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '')
-    if r1:
-      return r1
-    result = TestResult()
-    result.add_message(True, '*FAILED* to send message with %s (retrying)'%tag)
-    r2 = self.submit_payload('%s/%s'%(ssl, length), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '')
-    if r2:
-      result.add(r2)
-      return result
-    result.add_message(False, 'Failed to send message with: %s/%s'%(ssl, length))
+    result = TestResult('Testing NRPE: %s/%s/%s with various targets'%(ssl, length, tag))
+    result.add(self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '', "valid"))
+    result.add(self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '', "test_rp"))
+    result.add(self.submit_payload('%s/%s/%s'%(ssl, length, tag), ssl, length, '%ssrc%s'%(tag, tag), state, '%smsg%s'%(tag, tag), '', "invalid"))
     return result
 
@@ -206 +206 @@
     # TODO: conf.set_string('/settings/NRPE/test_nrpe_server', 'certificate', ssl)
     core.reload('test_nrpe_server')
+
+    #                /settings/NRPE/test_nrpe_client/targets/default
+    conf.set_string('/settings/NRPE/test_nrpe_client/targets/default', 'address', 'nrpe://127.0.0.1:35666')
+    conf.set_bool('/settings/NRPE/test_nrpe_client/targets/default', 'use ssl', not ssl)
+    conf.set_int('/settings/NRPE/test_nrpe_client/targets/default', 'payload length', length*3)
+
+    conf.set_string('/settings/NRPE/test_nrpe_client/targets/invalid', 'address', 'nrpe://127.0.0.1:25666')
+    conf.set_bool('/settings/NRPE/test_nrpe_client/targets/invalid', 'use ssl', not ssl)
+    conf.set_int('/settings/NRPE/test_nrpe_client/targets/invalid', 'payload length', length*2)
+
+    conf.set_string('/settings/NRPE/test_nrpe_client/targets/valid', 'address', 'nrpe://127.0.0.1:15666')
+    conf.set_bool('/settings/NRPE/test_nrpe_client/targets/valid', 'use ssl', ssl)
+    conf.set_int('/settings/NRPE/test_nrpe_client/targets/valid', 'payload length', length)
+    core.reload('test_nrpe_client')
+    
     result = TestResult()
     result.add_message(isOpen('127.0.0.1', 15666), 'Checking that port is open (server is up)')

scripts/python/test_nsca.py

@@ -218 +218 @@
       '--encryption', encryption,
       '--password', 'pwd-%s'%encryption,
-      '--host', '127.0.0.1:15667'
+      '--address', '127.0.0.1:15667'
       ]
     (result_code, result_message) = core.simple_exec('any', 'nsca_submit', args)
@@ -225 +225 @@
     result.add_message(result_code == 0, 'Testing to send message using %s/exec:1'%tag)
     result.add_message(len(result_message) == 1, 'Testing to send message using %s/exec:2'%tag, len(result_message))
-    result.add_message(len(result_message[0]) == 0, 'Testing to send message using %s/exec:3'%tag, result_message[0])
-    self.wait_and_validate(uid, result, msg, perf, '%s/exec'%tag)
+    if len(result_message) > 0:
+      result.add_message(len(result_message[0]) == 0, 'Testing to send message using %s/exec:3'%tag, result_message[0])
+      self.wait_and_validate(uid, result, msg, perf, '%s/exec'%tag)
+    else:
+      result.add_message(False, 'Sending faliled: giving up on %s'%tag)
     return result
 

service/NSCPlugin.cpp

@@ -323 +323 @@
     throw NSPluginException(module_, _T("Unhandled exception in fUnLoadModule."));
   }
-  fHandleCommand = NULL;
 }
 void NSCPlugin::unload_dll() {
   if (isLoaded())
     return;
+  fModuleHelperInit = NULL;
+  fLoadModule = NULL;
+  fGetName = NULL;
+  fGetVersion = NULL;
+  fGetDescription = NULL;
+  fHasCommandHandler = NULL;
+  fHasMessageHandler = NULL;
+  fHandleCommand = NULL;
+  fDeleteBuffer = NULL;
+  fHandleMessage = NULL;
+  fUnLoadModule = NULL;
+  fCommandLineExec = NULL;
+  fHasNotificationHandler = NULL;
+  fHandleNotification = NULL;
+  fHasRoutingHandler = NULL;
+  fRouteMessage = NULL;
   module_.unload_library();
 }

service/NSCPlugin.h

@@ -52 +52 @@
  *
  */
-class NSPluginException {
+class NSPluginException : public std::exception {
 public:
   std::wstring file_; // DLL filename (for which the exception was thrown)
   std::wstring error_;  // An error message (human readable format)
+  std::string msg_;
   /**
    * @param file DLL filename (for which the exception is thrown)
@@ -62 +63 @@
   NSPluginException(dll::dll &module, std::wstring error) : error_(error) {
     file_ = module.get_module_name();
-  }
-  std::wstring what() {
-    return error_ + _T(" in file: ") + file_;
-  }
-
-
+    msg_ = utf8::cvt<std::string>(error_ + _T(" in file: ") + file_);
+  }
+
+  ~NSPluginException() throw() {}
+  const char* what() const throw() {
+    return msg_.c_str();
+  }
+  const std::wstring wwhat() const throw() {
+    return utf8::cvt<std::wstring>(msg_);
+  }
 };
 

service/NSClient++.cpp

@@ -463 +463 @@
       try {
         addPlugin(pluginPath / v.second, v.first);
-      } catch (NSPluginException &e) {
-        LOG_CRITICAL_CORE_STD(_T("Failed to register plugin: ") + e.what());
+      } catch (const NSPluginException &e) {
+        LOG_CRITICAL_CORE_STD(_T("Failed to register plugin: ") + e.wwhat());
       } catch (...) {
         LOG_CRITICAL_CORE_STD(_T("Failed to register plugin key: ") + v.second);
@@ -921 +921 @@
           LOG_DEBUG_CORE_STD(_T("Skipping log plugin: ") + p->getModule() + _T("..."));
         }
-      } catch(NSPluginException e) {
+      } catch(const NSPluginException &e) {
         LOG_ERROR_CORE_STD(_T("Exception raised when unloading plugin: ") + e.error_ + _T(" in module: ") + e.file_);
       } catch(...) {
@@ -1139 +1139 @@
       LOG_DEBUG_CORE_STD(_T("Result ") + cmd + _T(": ") + nscapi::plugin_helper::translateReturn(c));
       return c;
-    } catch (nsclient::commands::command_exception &e) {
-      LOG_ERROR_CORE(_T("No handler for command: ") + cmd + _T(": ") + to_wstring(e.what()));
+    } catch (const nsclient::commands::command_exception &e) {
+      LOG_ERROR_CORE(_T("Failed to process command: ") + cmd + _T(": ") + utf8::to_unicode(e.what()));
+      return NSCAPI::returnIgnored;
+    } catch (const std::exception &e) {
+      LOG_ERROR_CORE(_T("Failed to process command: ") + cmd + _T(": ") + utf8::to_unicode(e.what()));
       return NSCAPI::returnIgnored;
     } catch (...) {