Changeset 230

Timestamp:

01/07/10 08:10:43 (2 years ago)

Author:

mickem

Message:

improved the scheduled module and re-added the settings command line toy (so now you can migrate settings again)
Schedule module is 80% finished but notification channel subsystem is still missing.

Location:

trunk

Files:

• include/settings/Settings.h (modified) (1 diff)
• include/settings/macros.h (modified) (4 diffs)
• include/settings/settings_ini.hpp (modified) (2 diffs)
• include/strEx.h (modified) (1 diff)
• modules/Scheduler/Scheduler.cpp (modified) (1 diff)
• modules/Scheduler/Scheduler.h (modified) (1 diff)
• modules/Scheduler/simple_scheduler.cpp (modified) (1 diff)
• modules/Scheduler/simple_scheduler.hpp (modified) (6 diffs)
• service/CMakeLists.txt (modified) (1 diff)
• service/NSCPlugin.cpp (modified) (1 diff)
• service/NSClient++.cpp (modified) (9 diffs)
• service/NSClient++.h (modified) (1 diff)
• service/settings_client.hpp (added)

trunk/include/settings/Settings.h

@@ -754 +754 @@
                 get()->set_int(*cit, *citk, strEx::stoi(desc.defValue));
               else
-                throw SettingsException(_T("Unknown keytype for: ") + *cit + _T(".") + *citk);
+                get_logger()->err(__FILEW__, __LINE__, _T("Unknown keytype for: ") + *cit + _T(".") + *citk);
             } else {
-              get_logger()->debug(__FILEW__, __LINE__, _T("Skipping (already exists): ") + *cit + _T(".") + *citk);
+              std::wstring val = get()->get_string(*cit, *citk);
+              get_logger()->debug(__FILEW__, __LINE__, _T("Setting old (already exists): ") + *cit + _T(".") + *citk + _T(" = ") + val);
+              if (desc.type == key_string)
+                get()->set_string(*cit, *citk, val);
+              else if (desc.type == key_bool)
+                get()->set_bool(*cit, *citk, val==_T("true"));
+              else if (desc.type == key_integer)
+                get()->set_int(*cit, *citk, strEx::stoi(val));
+              else
+                get_logger()->err(__FILEW__, __LINE__, _T("Unknown keytype for: ") + *cit + _T(".") + *citk);
             }
           } else {

trunk/include/settings/macros.h

@@ -83 +83 @@
 #define CHECK_SYSTEM_SERVICES_SECTION "/settings/system/services"
 #define NSCA_SECTION "/settings/NSCA"
+#define SCHEDULER_SECTION "/settings/scheduler"
+#define SCHEDULER_SECTION_SCH "/settings/scheduler/schedules"
+#define SCHEDULER_SECTION_FAKE "/settings/scheduler/schedules/<schedule name>"
+#define SCHEDULER_SECTION_DEF "/settings/scheduler/default"
 #define NSCA_SERVER_SECTION "/settings/NSCA/server"
 #define NSCA_CMD_SECTION "/settings/NSCA/server/commands"
@@ -310 +314 @@
   }
 
+
   namespace nsca {
     DEFINE_PATH(SECTION, NSCA_SECTION);
@@ -349 +354 @@
     DEFINE_SETTING_S(TIME_DELTA_DEFAULT, NSCA_SECTION, "delay", "0");
     DESCRIBE_SETTING(TIME_DELTA_DEFAULT, "TODO", "TODO");
-    
+
     DEFINE_SETTING_I(PAYLOAD_LENGTH, NSCA_SECTION, "payload length", 512);
     DESCRIBE_SETTING_ADVANCED(PAYLOAD_LENGTH, "PAYLOAD LENGTH", "Length of payload to/from the NSCA agent. This is a hard specific value so you have to \"configure\" (read recompile) your NSCA server to use the same value for it to work.");
@@ -355 +360 @@
     DEFINE_SETTING_I(READ_TIMEOUT, NSCA_SERVER_SECTION, GENERIC_KEY_SOCK_READ_TIMEOUT, 30);
     DESCRIBE_SETTING(READ_TIMEOUT, "SOCKET TIMEOUT", "Timeout when reading packets on incoming sockets. If the data has not arrived withint this time we will bail out.");
+
+  }
+
+  namespace scheduler {
+    DEFINE_PATH(SECTION, SCHEDULER_SECTION);
+    DESCRIBE_SETTING(SECTION, "SCHEDULER SECTION", "Section for the Scheduler module.");
+
+    DEFINE_PATH(SCHEDULES_SECTION, SCHEDULER_SECTION_SCH);
+    DESCRIBE_SETTING(SCHEDULES_SECTION, "SCHEDULES SECTION", "Section for defining schedules for the Scheduler module.");
+
+    DEFINE_PATH(DEFAULT_SCHEDULE_SECTION, SCHEDULER_SECTION_DEF);
+    DESCRIBE_SETTING(DEFAULT_SCHEDULE_SECTION, "DEFAULT SCHEDULER SECTION", "Default settings for all scheduled commands");
+
+    DEFINE_SETTING_I(THREADS, SCHEDULER_SECTION, "debug threads", 1);
+    DESCRIBE_SETTING_ADVANCED(THREADS, "THREADS", "Number of threads to use int he thread pool (increase if you have many scheduled items)");
+
+    DEFINE_SETTING_S(INTERVAL, SCHEDULER_SECTION_FAKE, "interval", "5m");
+    DESCRIBE_SETTING(INTERVAL, "SCHEDULE INTERVAL", "Time in seconds between each check");
+
+    DEFINE_SETTING_S(COMMAND, SCHEDULER_SECTION_FAKE, "command", "check_ok");
+    DESCRIBE_SETTING(COMMAND, "SCHEDULE COMMAND", "Command to run");
+
+    DEFINE_SETTING_S(CHANNEL, SCHEDULER_SECTION_FAKE, "channel", "NSCA");
+    DESCRIBE_SETTING(CHANNEL, "SCHEDULE CHANNEL", "Channel to send results on");
+
+    DEFINE_SETTING_S(REPORT_MODE, SCHEDULER_SECTION_FAKE, "report", "all");
+    DESCRIBE_SETTING(REPORT_MODE, "REPORT MODE", "What to report to the server (any of the following: all, critical, warning, unknown, ok)");
+
+    DEFINE_SETTING_S(INTERVAL_D, SCHEDULER_SECTION_DEF, "interval", "5m");
+    DESCRIBE_SETTING(INTERVAL_D, "SCHEDULE INTERVAL", "Time in seconds between each check");
+
+    DEFINE_SETTING_S(COMMAND_D, SCHEDULER_SECTION_DEF, "command", "check_ok");
+    DESCRIBE_SETTING(COMMAND_D, "SCHEDULE COMMAND", "Command to run");
+
+    DEFINE_SETTING_S(CHANNEL_D, SCHEDULER_SECTION_DEF, "channel", "NSCA");
+    DESCRIBE_SETTING(CHANNEL_D, "SCHEDULE CHANNEL", "Channel to send results on");
+
+    DEFINE_SETTING_S(REPORT_MODE_D, SCHEDULER_SECTION_DEF, "report", "all");
+    DESCRIBE_SETTING(REPORT_MODE_D, "REPORT MODE", "What to report to the server (any of the following: all, critical, warning, unknown, ok)");
 
   }

trunk/include/settings/settings_ini.hpp

@@ -78 +78 @@
     /// @author mickem
     virtual bool has_real_key(SettingsCore::key_path_type key) {
-      return false;
+      return ini.GetValue(key.first.c_str(), key.second.c_str()) != NULL;
     }
     //////////////////////////////////////////////////////////////////////////
@@ -115 +115 @@
         strEx::replace(comment, _T("\n"), _T(" "));
         get_core()->get_logger()->quick_debug(_T("saving: ") + key.first + _T("//") + key.second);
+        
+        ini.Delete(key.first.c_str(), key.second.c_str());
         ini.SetValue(key.first.c_str(), key.second.c_str(), value.get_string().c_str(), comment.c_str());
       } catch (KeyNotFoundException e) {
-        ini.SetValue(key.first.c_str(), key.second.c_str(), value.get_string().c_str());
+        ini.SetValue(key.first.c_str(), key.second.c_str(), value.get_string().c_str(), _T("; Undocumented key"));
       } catch (SettingsException e) {
         get_core()->get_logger()->err(__FILEW__, __LINE__, std::wstring(_T("Failed to write key: ") + e.getError()));

trunk/include/strEx.h

@@ -366 +366 @@
   inline unsigned stoui_as_time(std::wstring time, unsigned int smallest_unit = 1000) {
     std::wstring::size_type p = time.find_first_of(_T("sSmMhHdDwW"));
-    unsigned int value = boost::lexical_cast<unsigned int>(time.c_str());
+    std::wstring::size_type pend = time.find_first_not_of(_T("0123456789"));
+    unsigned int value = boost::lexical_cast<unsigned int>(pend==std::wstring::npos?time:time.substr(0,pend).c_str());
     if (p == std::wstring::npos)
       return value * smallest_unit;

trunk/modules/Scheduler/Scheduler.cpp

@@ -24 +24 @@
 #include <time.h>
 #include <utils.h>
+#include <settings/macros.h>
 
 Scheduler gInstance;
 
+bool Scheduler::loadModule(NSCAPI::moduleLoadMode mode) {
+  try {
+    SETTINGS_REG_PATH(scheduler::SECTION);
+    SETTINGS_REG_PATH(scheduler::DEFAULT_SCHEDULE_SECTION);
+    SETTINGS_REG_PATH(scheduler::SCHEDULES_SECTION);
 
-bool Scheduler::loadModule(NSCAPI::moduleLoadMode mode) {
-  if (mode == NSCAPI::normalStart) {
-    scheduler_.start();
+    SETTINGS_REG_KEY_S(scheduler::INTERVAL_D);
+    SETTINGS_REG_KEY_S(scheduler::COMMAND_D);
+    SETTINGS_REG_KEY_S(scheduler::CHANNEL_D);
+    SETTINGS_REG_KEY_S(scheduler::REPORT_MODE_D);
+
+    SETTINGS_REG_KEY_I(scheduler::THREADS);
+  } catch (NSCModuleHelper::NSCMHExcpetion &e) {
+    NSC_LOG_ERROR_STD(_T("Failed to register command: ") + e.msg_);
+  } catch (...) {
+    NSC_LOG_ERROR_STD(_T("Failed to register command."));
   }
-  add_schedule(_T("test 001"));
-  add_schedule(_T("test 002"));
+
+
+  try {
+
+    scheduler_.set_threads(SETTINGS_GET_INT(scheduler::THREADS));
+
+    if (mode == NSCAPI::normalStart) {
+      scheduler_.start();
+    }
+
+    bool found = false;
+    scheduler::target def = read_schedule(setting_keys::scheduler::DEFAULT_SCHEDULE_SECTION_PATH);
+    std::list<std::wstring> items = NSCModuleHelper::getSettingsSection(setting_keys::scheduler::SCHEDULES_SECTION_PATH);
+
+    for (std::list<std::wstring>::const_iterator cit = items.begin(); cit != items.end(); ++cit) {
+      found = true;
+      add_schedule(*cit, def);
+    }
+
+    if (!found) {
+      NSC_DEBUG_MSG_STD(_T("No scheduled commands found!"));
+      SETTINGS_REG_KEY_S(scheduler::INTERVAL);
+      SETTINGS_REG_KEY_S(scheduler::COMMAND);
+      SETTINGS_REG_KEY_S(scheduler::CHANNEL);
+      SETTINGS_REG_KEY_S(scheduler::REPORT_MODE);
+
+    }
+/*
+    add_schedule(_T("test: FIRST"));
+    for (int i=0;i<1000;i++)
+      add_schedule(_T("test: ") + to_wstring(i));
+    add_schedule(_T("test: LAST"));
+    */
+  } catch (NSCModuleHelper::NSCMHExcpetion &e) {
+    NSC_LOG_ERROR_STD(_T("Exception in module Scheduler: ") + e.msg_);
+    return false;
+  } catch (...) {
+    NSC_LOG_ERROR_STD(_T("Unknown Exception in module Scheduler!"));
+    return false;
+  }
   return true;
 }
 
+scheduler::target Scheduler::read_schedule(std::wstring path) {
+  scheduler::target item;
+  item.channel = NSCModuleHelper::getSettingsString(path, setting_keys::scheduler::CHANNEL, setting_keys::scheduler::CHANNEL_DEFAULT);
+  item.command = NSCModuleHelper::getSettingsString(path, setting_keys::scheduler::COMMAND, setting_keys::scheduler::COMMAND_PATH);
+  /*
+  std::wstring report = SETTINGS_GET_STRING(scheduler::REPORT_MODE);
+  item.report = parse_report_string(report);
+  */
+  std::wstring duration = NSCModuleHelper::getSettingsString(path, setting_keys::scheduler::INTERVAL, setting_keys::scheduler::INTERVAL_DEFAULT);
+  item.duration = boost::posix_time::seconds(strEx::stoui_as_time(duration));
+  return item;
+}
+scheduler::target Scheduler::read_schedule(std::wstring path, scheduler::target def) {
+  scheduler::target item;
+  
+  item.channel = NSCModuleHelper::getSettingsString(path, setting_keys::scheduler::CHANNEL, def.channel);
+  item.command = NSCModuleHelper::getSettingsString(path, setting_keys::scheduler::COMMAND, def.command);
+  /*
+  std::wstring report = NSCModuleHelper::getSettingsString(path, setting_keys::scheduler::REPORT_MODE, def.report);
+  item.report = parse_report_string(report);
+  */
+  std::wstring duration = NSCModuleHelper::getSettingsString(path, setting_keys::scheduler::INTERVAL, to_wstring(def.duration.total_seconds()) + _T("s"));
+  item.duration = boost::posix_time::seconds(strEx::stoui_as_time(duration));
+  return item;
+}
 
-void Scheduler::add_schedule(std::wstring command) {
-  scheduler::target item;
+void Scheduler::add_schedule(std::wstring command, scheduler::target def) {
+  NSC_DEBUG_MSG_STD(_T("Adding scheduled command: ") + command);
+  scheduler::target item = read_schedule(setting_keys::scheduler::SCHEDULES_SECTION_PATH + _T("/") + command, def);
+
+//  std::wstring report = SETTINGS_GET_STRING(scheduler::REPORT_MODE);
+//  report_ = parse_report_string(report);
+
   item.command = command;
-  item.duration = boost::posix_time::time_duration(0,0,5);
+  item.set_duration(boost::posix_time::seconds(5));
+  scheduler_.add_task(item);
+  /*
   std::wcout << _T("*** DURATION ") << item.duration << _T(" ***") << std::endl;
-  scheduler_.add_task(item);
+  */
 }
 bool Scheduler::unloadModule() {

trunk/modules/Scheduler/Scheduler.h

@@ -39 +39 @@
 
 
-  void add_schedule(std::wstring command);
+  void add_schedule(std::wstring command, scheduler::target def);
+  scheduler::target read_schedule(std::wstring path, scheduler::target def);
+  scheduler::target read_schedule(std::wstring path);
 
   std::wstring getModuleName() {

trunk/modules/Scheduler/simple_scheduler.cpp

@@ -18 +18 @@
     targets_.erase(it);
   }
-  target simple_scheduler::get_task(int id) {
+  boost::optional<target> simple_scheduler::get_task(int id) {
     boost::mutex::scoped_lock l(mutex_);
     target_list_type::iterator it = targets_.find(id);
-    if (it == targets_.end())
-      return target::empty();
-    return (*it).second;
+    if (it == targets_.end())
+      return boost::optional<target>();
+    return boost::optional<target>((*it).second);
   }
 
   void simple_scheduler::start() {
+    running_ = true;
     if (!queue_.empty())
       start_thread();
   }
   void simple_scheduler::stop() {
-    if (thread_)
-      return;
+    running_ = false;
+    //if (!thread_)
+    //  return;
     stop_requested_ = true;
-    thread_->join();
+    threads_.interrupt_all();
+    threads_.join_all();
+    /*
+    if (!threads.join_all(boost::posix_time::seconds(5))) {
+      std::wcout << _T("FAILED TO TERMINATE!!!") << std::endl;
+    } else {
+      std::wcout << _T("THREAD TERMINATED NICELY!") << std::endl;
+    }
+    */
   }
 
   void simple_scheduler::start_thread() {
+    if (!running_)
+      return;
     stop_requested_ = false;
-    thread_ = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&simple_scheduler::thread_proc, this)));
+    int missing_threads = thread_count_ - threads_.size();
+    if (missing_threads > 0 && missing_threads <= thread_count_) {
+      for (int i=0;i<missing_threads;i++) {
+        std::wcout << _T("***START_THREAD***") << std::endl;
+        threads_.create_thread(boost::bind(&simple_scheduler::thread_proc, this));
+      }
+    }
+    //thread_ = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&simple_scheduler::thread_proc, this)));
   }
 
   void simple_scheduler::thread_proc() {
     int iteration = 0;
-    schedule_instance instance;
+    schedule_queue_type::value_type instance;
     while (!stop_requested_) {
-      {
-        boost::mutex::scoped_lock l(mutex_);
-        //std::wcout << _T("#### COUNT: ") << queue_.size() << _T(" ####") << std::endl;
-        if (queue_.empty())
+      instance = queue_.pop();
+      if (!instance)
+        return;
+
+      try {
+
+        boost::posix_time::time_duration off = now() - (*instance).time;
+        if (off.total_seconds() > 0) {
+          std::wcout << _T("MISSED IT!") << off.total_seconds() << std::endl;
+        }
+        boost::thread::sleep((*instance).time);
+      } catch (boost::thread_interrupted  &e) {
+        if (!queue_.push(*instance))
+          std::wcout << _T("ERROR") << std::endl;
+        if (stop_requested_)
           return;
-        instance = queue_.top();
-        queue_.pop();
-      }
-      target item = get_task(instance.schedule_id);
-      //boost::posix_time::ptime delay = now() + instance.time;
-      
-      try {
-        boost::thread::sleep(instance.time);
+        continue;
       } catch (...) {
-        std::wcout << _T("Excepting...") << std::endl;
+        if (!queue_.push(*instance))
+          std::wcout << _T("ERROR") << std::endl;
+        std::wcout << _T("ERROR!!!") << std::endl;
         return;
       }
-      boost::posix_time::ptime ctime = now();
-      execute(item);
-      reschedule(item,ctime);
+
+      boost::posix_time::ptime now_time = now();
+      boost::optional<target> item = get_task((*instance).schedule_id);
+      if (item) {
+        try {
+          execute(*item);
+          reschedule(*item,now_time);
+        } catch (...) {
+          std::wcout << _T("UNKNOWN ERROR RUNING TASK: ") << std::endl;
+          reschedule(*item);
+        }
+      } else {
+        std::wcout << _T("Task not found: ") << (*instance).schedule_id << std::endl;
+      }
     }
   }
 
   void simple_scheduler::reschedule(target item) {
-    reschedule(item, now());
+    reschedule_wnext(item, now() + boost::posix_time::seconds(rand()%item.duration.total_seconds()));
   }
   void simple_scheduler::reschedule(target item, boost::posix_time::ptime now) {
-    boost::mutex::scoped_lock l(mutex_);
+    reschedule_wnext(item, now + item.duration);
+  }
+  void simple_scheduler::reschedule_wnext(target item, boost::posix_time::ptime next) {
     schedule_instance instance;
     instance.schedule_id = item.id;
-    instance.time = now + item.duration;
-    queue_.push(instance);
-    if (!thread_)
-      start_thread();
+    instance.time = next;
+    if (!queue_.push(instance)) {
+      std::wcout << _T("ERROR") << std::endl;
+    }
+    start_thread();
   }
   void simple_scheduler::execute(target item) {
-    std::wcout << _T("Running: ") << item.command << std::endl;
+    //std::wcout << _T("Running: ") << item.command << std::endl;
   }
-
 
 }

trunk/modules/Scheduler/simple_scheduler.hpp

@@ -8 +8 @@
 #include <boost/thread.hpp>
 #include <boost/date_time/local_time/local_time.hpp>
+#include <boost/optional.hpp>
 
 namespace scheduler {
 
+  class task_not_found {
+    int id_;
+  public:
+    task_not_found(int id) : id_(id) {}
+    int get_id() {return id_; }
+  };
   class target {
   public:
@@ -18 +25 @@
     std::wstring tag;
     boost::posix_time::time_duration duration;
+    std::wstring  channel;
+    //std::wstring duration;
 
-    target() {}
-    target(const target &other) : id(other.id), command(other.command), duration(other.duration) {}
+
+    void set_duration(boost::posix_time::time_duration duration_) {
+      duration = duration_;
+      // TODO!
+    }
+
+    target() : duration(boost::posix_time::minutes(0))
+    {}
+    
+    target(const target &other) : id(other.id), command(other.command), duration(other.duration) {}
     target& operator=(target const& other) {
       command = other.command;
@@ -27 +44 @@
       return *this;
     }
-    static target empty() {
-      return target();
-    }
+    ~target() {}
   };
   struct schedule_instance {
@@ -39 +54 @@
   };
 
+  template<typename T>
+  class safe_schedule_queue {
+  public:
+    typedef boost::optional<T> value_type;
+  private:
+    typedef std::priority_queue<T> schedule_queue_type;
+    schedule_queue_type queue_;
+    boost::shared_mutex mutex_;
+  public:
+    bool empty(unsigned int timeout = 5) {
+      boost::shared_lock<boost::shared_mutex> lock(mutex_, boost::get_system_time() + boost::posix_time::seconds(5));
+      if (!lock.owns_lock()) 
+        return false;
+      return queue_.empty();
+    }
+
+    boost::optional<T> top(unsigned int timeout = 5) {
+      boost::shared_lock<boost::shared_mutex> lock(mutex_, boost::get_system_time() + boost::posix_time::seconds(5));
+      if (!lock || queue_.empty())
+        return boost::optional<T>();
+      return boost::optional<T>(queue_.top());
+    }
+
+    boost::optional<T> pop(unsigned int timeout = 5) {
+      boost::unique_lock<boost::shared_mutex> lock(mutex_, boost::get_system_time() + boost::posix_time::seconds(timeout));
+      if (!lock || queue_.empty())
+        return boost::optional<T>();
+      boost::optional<T>  ret = queue_.top();
+      queue_.pop();
+      return ret;
+    }
+
+    bool push(T instance, unsigned int timeout = 5) {
+      boost::unique_lock<boost::shared_mutex> lock(mutex_, boost::get_system_time() + boost::posix_time::seconds(timeout));
+      if (!lock) {
+        return false;
+      }
+      queue_.push(instance);
+      return true;
+    }
+  };
+
   class simple_scheduler {
   private:
     typedef std::map<int,target> target_list_type;
-    typedef std::priority_queue<schedule_instance> schedule_queue_type;
+    typedef safe_schedule_queue<schedule_instance> schedule_queue_type;
     target_list_type targets_;
     unsigned int target_id_;
     schedule_queue_type queue_;
+    unsigned int thread_count_;
 
 
     // thread variables
     volatile bool stop_requested_;
-    boost::shared_ptr<boost::thread> thread_;
+    volatile bool running_;
+    boost::thread_group threads_;
+    //boost::shared_ptr<boost::thread> thread_;
     boost::mutex mutex_;
 
   public:
 
-    simple_scheduler() : target_id_(0) {}
+    simple_scheduler() : target_id_(0), stop_requested_(false), running_(false), thread_count_(10) {}
     ~simple_scheduler() {}
 
@@ -61 +121 @@
     int add_task(target item);
     void remove_task(int id);
-    target get_task(int id);
+    boost::optional<target> get_task(int id);
     
     void start();
     void stop();
+
+    void set_threads(int threads) {
+      thread_count_ = threads;
+      start_thread();
+    }
 
 
@@ -72 +137 @@
     void reschedule(target item);
     void reschedule(target item, boost::posix_time::ptime now);
+    void reschedule_wnext(target item, boost::posix_time::ptime next);
     void execute(target item);
     void start_thread();
 
-    boost::posix_time::ptime now() {
+    inline boost::posix_time::ptime now() {
       return boost::get_system_time();
     }

trunk/service/CMakeLists.txt

@@ -33 +33 @@
     settings_manager_impl.h
     simple_client.hpp
+    settings_client.hpp
     
     commands.hpp

trunk/service/NSCPlugin.cpp

@@ -253 +253 @@
 void NSCPlugin::unload() {
   if (!isLoaded())
-    throw NSPluginException(module_, _T("Library is not loaded"));
+    return;
   bLoaded_ = false;
   if (!fUnLoadModule)

trunk/service/NSClient++.cpp

@@ -37 +37 @@
 #include <NSCHelper.h>
 #include "simple_client.hpp"
+#include "settings_client.hpp"
 #include "service_manager.hpp"
 
@@ -396 +397 @@
       client.start();
       return 0;
+    } else if ( _wcsicmp( _T("settings"), argv[1]+1 ) == 0 ) {
+      nsclient::settings_client client(&mainClient);
+      g_bConsoleLog = true;
+      if (argc > 2)
+        client.parse(argv[2], argc-3, argv+3);
+      else
+        client.help();
+      return 0;
     } else {
       std::wcerr << _T("Usage: -version, -about, -install, -uninstall, -start, -stop, -encrypt -settings") << std::endl;
@@ -491 +500 @@
         } else {
           std::wstring desc;
+          std::wstring name = file.string();
           try {
             NSCPlugin plugin(modPath / file);
+            name = plugin.getModule();
             plugin.load_dll();
             plugin.load_plugin(mode);
@@ -505 +516 @@
             LOG_CRITICAL_STD(_T("Unknown Error loading: ") + file.string());
           }
-          settings_manager::get_core()->register_key(MAIN_MODULES_SECTION, file.string(), Settings::SettingsCore::key_string, desc, desc, _T("disabled"), false);
+          settings_manager::get_core()->register_key(MAIN_MODULES_SECTION, name, Settings::SettingsCore::key_string, desc, desc, _T("disabled"), false);
         }
       }
@@ -643 +654 @@
 
   if (enable_shared_session_) {
-    LOG_MESSAGE_STD(_T("Enabling shared session..."));
+    LOG_DEBUG_STD(_T("Enabling shared session..."));
     if (boot) {
-      LOG_MESSAGE_STD(_T("Starting shared session..."));
+      LOG_MESSAGE_STD(_T("shared session not ported yet!..."));
 //      try {
 //        shared_server_.reset(new nsclient_session::shared_server_session(this));
@@ -662 +673 @@
 //      }
     } else {
-      LOG_MESSAGE_STD(_T("Attaching to shared session..."));
+      LOG_MESSAGE_STD(_T("shared session not ported yet!..."));
 //      try {
 //        std::wstring id = _T("_attached_") + strEx::itos(GetCurrentProcessId()) + _T("_");
@@ -1018 +1029 @@
       try {
         if (!(*it)->load_plugin(NSCAPI::normalStart)) {
+          LOG_ERROR_CORE_STD(_T("Plugin refused to load: ") + (*it)->getModule());
           it = plugins_.erase(it);
-          LOG_ERROR_CORE_STD(_T("Plugin refused to load: ") + (*it)->getModule());
-        }
-        ++it;
+        } else
+          ++it;
       } catch (NSPluginException e) {
         it = plugins_.erase(it);
@@ -1073 +1084 @@
     if (plugin->hasMessageHandler())
       messageHandlers_.insert(messageHandlers_.end(), plugin);
-    settings_manager::get_core()->register_key(_T("/modules"), plugin->getFilename(), Settings::SettingsCore::key_string, plugin->getName(), plugin->getDescription(), _T(""), false);
+    settings_manager::get_core()->register_key(_T("/modules"), plugin->getModule(), Settings::SettingsCore::key_string, plugin->getName(), plugin->getDescription(), _T(""), false);
   }
   return plugin;
@@ -1246 +1257 @@
 #ifdef WIN32
   OutputDebugString(msg.c_str());
+#else
+  std::wcout << _T("--BROKEN MESSAGE: ") << msg << _T("--") << std::endl;
 #endif
-  std::wcout << msg << std::endl;
 }
 /**

trunk/service/NSClient++.h

@@ -201 +201 @@
 
 
-
-private:
-  plugin_type addPlugin(plugin_type plugin);
-  void load_all_plugins(int mode);
+  public:
+    void load_all_plugins(int mode);
+
+
+  private:
+    plugin_type addPlugin(plugin_type plugin);
 };