bool DistributedClient::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
std::map<std::wstring,std::wstring> commands;
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(_T("distributed"), alias, _T("client"));
target_path = settings.alias().get_settings_path(_T("targets"));
settings.alias().add_path_to_settings()
(_T("Distributed NSCP CLIENT SECTION"), _T("Section for NSCP active/passive check module."))
(_T("handlers"), sh::fun_values_path(boost::bind(&DistributedClient::add_command, this, _1, _2)),
_T("CLIENT HANDLER SECTION"), _T(""))
(_T("targets"), sh::fun_values_path(boost::bind(&DistributedClient::add_target, this, _1, _2)),
_T("REMOTE TARGET DEFINITIONS"), _T(""))
;
settings.alias().add_key_to_settings()
(_T("channel"), sh::wstring_key(&channel_, _T("DNSCP")),
_T("CHANNEL"), _T("The channel to listen to."))
;
settings.register_all();
settings.notify();
targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
get_core()->registerSubmissionListener(get_id(), channel_);
register_command(_T("dnscp_query"), _T("Submit a query to a remote host via NSCP"));
register_command(_T("dnscp_forward"), _T("Forward query to remote NSCP host"));
register_command(_T("dnscp_submit"), _T("Submit a query to a remote host via NSCP"));
register_command(_T("dnscp_exec"), _T("Execute remote command on a remote host via NSCP"));
register_command(_T("dnscp_help"), _T("Help on using NSCP Client"));
} catch (nscapi::nscapi_exception &e) {
NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
return false;
} catch (std::exception &e) {
NSC_LOG_ERROR_STD(_T("Exception caught: ") + utf8::to_unicode(e.what()));
return false;
} catch (...) {
NSC_LOG_ERROR_STD(_T("Exception caught: <UNKNOWN EXCEPTION>"));
return false;
}
return true;
}
bool CheckWMI::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
sh::settings_registry settings(get_settings_proxy());
//settings.set_alias(_T("targets"));
settings.add_path_to_settings()
("targets", sh::fun_values_path(boost::bind(&target_helper::add_target, &targets, get_settings_proxy(), _1, _2)),
"TARGET LIST SECTION", "A list of available remote target systems",
"TARGET DEFENTION", "For more configuration options add a dedicated section")
;
settings.register_all();
settings.notify();
return true;
}
bool NSCPClient::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode ) {
std::map<std::wstring,std::wstring> commands;
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("nscp", alias, "client");
target_path = settings.alias().get_settings_path("targets");
settings.alias().add_path_to_settings()
("NSCP CLIENT SECTION", "Section for NSCP active/passive check module.")
("handlers", sh::fun_values_path(boost::bind(&NSCPClient::add_command, this, _1, _2)),
"CLIENT HANDLER SECTION", "",
"CLIENT HANDLER", "For more configuration options add a dedicated section")
("targets", sh::fun_values_path(boost::bind(&NSCPClient::add_target, this, _1, _2)),
"REMOTE TARGET DEFINITIONS", "",
"TARGET", "For more configuration options add a dedicated section")
;
settings.alias().add_key_to_settings()
("channel", sh::string_key(&channel_, "NSCP"),
"CHANNEL", "The channel to listen to.")
;
settings.register_all();
settings.notify();
targets.add_samples(get_settings_proxy(), target_path);
targets.add_missing(get_settings_proxy(), target_path, "default", "", true);
nscapi::core_helper::core_proxy core(get_core(), get_id());
core.register_channel(channel_);
} catch (nscapi::nscapi_exception &e) {
NSC_LOG_ERROR_EXR("load", e);
return false;
} catch (std::exception &e) {
NSC_LOG_ERROR_EXR("load", e);
return false;
} catch (...) {
NSC_LOG_ERROR_EX("load");
return false;
}
return true;
}
void SyslogClient::add_target(std::wstring key, std::wstring arg) {
try {
targets.add(get_settings_proxy(), target_path , key, arg);
} catch (const std::exception &e) {
NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key + _T(", ") + utf8::to_unicode(e.what()));
} catch (...) {
NSC_LOG_ERROR_STD(_T("Failed to add target: ") + key);
}
}
bool CheckNSCP::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
start_ = boost::posix_time::microsec_clock::local_time();
std::string path;
sh::settings_registry settings(get_settings_proxy());
crashFolder = get_core()->expand_path(CRASH_ARCHIVE_FOLDER);
NSC_DEBUG_MSG_STD("Crash folder is: " + crashFolder.string());
return true;
}
void SyslogClient::add_target(std::string key, std::string arg) {
try {
client_.add_target(get_settings_proxy(), key, arg);
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("Failed to add target: " + key, e);
} catch (...) {
NSC_LOG_ERROR_EX("Failed to add target: " + key);
}
}
void CheckMKClient::add_target(std::string key, std::string arg) {
try {
targets.add(get_settings_proxy(), target_path , key, arg);
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("Failed to add target: " + key, e);
} catch (...) {
NSC_LOG_ERROR_EX("Failed to add target: " + key);
}
}
void CheckExternalScripts::add_alias(std::string key, std::string arg) {
try {
aliases_.add(get_settings_proxy(), key, arg);
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("Failed to add: " + key, e);
} catch (...) {
NSC_LOG_ERROR_EX("Failed to add: " + key);
}
}
void Scheduler::add_schedule(std::string key, std::string arg) {
try {
schedules_.add(get_settings_proxy(), key, arg, key == "default");
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("Failed to add target: " + key, e);
} catch (...) {
NSC_LOG_ERROR_EX("Failed to add target: " + key);
}
}
bool SMTPClient::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
std::wstring template_string, sender, recipient;
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("SMTP", alias, "client");
client_.set_path(settings.alias().get_settings_path("targets"));
settings.alias().add_path_to_settings()
("SMTP CLIENT SECTION", "Section for SMTP passive check module.")
("handlers", sh::fun_values_path(boost::bind(&SMTPClient::add_command, this, _1, _2)),
"CLIENT HANDLER SECTION", "",
"CLIENT HANDLER", "For more configuration options add a dedicated section")
("targets", sh::fun_values_path(boost::bind(&SMTPClient::add_target, this, _1, _2)),
"REMOTE TARGET DEFINITIONS", "",
"TARGET", "For more configuration options add a dedicated section")
;
settings.alias().add_key_to_settings()
("channel", sh::string_key(&channel_, "SMTP"),
"CHANNEL", "The channel to listen to.")
;
settings.register_all();
settings.notify();
client_.finalize(get_settings_proxy());
nscapi::core_helper core(get_core(), get_id());
core.register_channel(channel_);
} catch (const nsclient::nsclient_exception &e) {
NSC_LOG_ERROR_EXR("load", e);
return false;
} catch (std::exception &e) {
NSC_LOG_ERROR_EXR("NSClient API exception: ", e);
return false;
} catch (...) {
NSC_LOG_ERROR_EX("NSClient API exception: ");
return false;
}
return true;
}
bool LUAScript::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
//std::wstring appRoot = file_helpers::folders::get_local_appdata_folder(SZAPPNAME);
try {
root_ = get_core()->getBasePath();
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, _T("lua"));
settings.alias().add_path_to_settings()
(_T("LUA SCRIPT SECTION"), _T("Section for the LUAScripts module."))
(_T("scripts"), sh::fun_values_path(boost::bind(&LUAScript::loadScript, this, _1, _2)),
_T("LUA SCRIPTS SECTION"), _T("A list of scripts available to run from the LuaSCript module."))
;
settings.register_all();
settings.notify();
// if (!scriptDirectory_.empty()) {
// addAllScriptsFrom(scriptDirectory_);
// }
BOOST_FOREACH(script_container &script, scripts_) {
try {
instances_.push_back(script_wrapper::lua_script::create_instance(get_core(), get_id(), registry, script.alias, script.script.string()));
} catch (const lua_wrappers::LUAException &e) {
NSC_LOG_ERROR_STD(_T("Could not load script ") + script.to_wstring() + _T(": ") + e.getMessage());
} catch (const std::exception &e) {
NSC_LOG_ERROR_STD(_T("Could not load script ") + script.to_wstring() + _T(": ") + utf8::to_unicode(e.what()));
}
}
// } catch (nrpe::server::nrpe_exception &e) {
// NSC_LOG_ERROR_STD(_T("Exception caught: ") + e.what());
// return false;
} catch (const std::exception &e) {
NSC_LOG_ERROR_STD(_T("Exception caught: ") + utf8::to_unicode(e.what()));
return false;
} catch (...) {
NSC_LOG_ERROR_STD(_T("Exception caught: <UNKNOWN EXCEPTION>"));
return false;
}
// std::list<std::wstring>::const_iterator it;
// for (it = commands.begin(); it != commands.end(); ++it) {
// loadScript((*it));
// }
return true;
}
/**
* New version of the load call.
* Start the background collector thread and let it run until unloadModule() is called.
* @return true
*/
bool CheckSystem::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("system", alias, "unix");
std::string counter_path = settings.alias().get_settings_path("counters");
// collector.filters_path_ = settings.alias().get_settings_path("real-time/checks");
//filters::filter_config_handler::add_samples(get_settings_proxy(), collector.filters_path_);
return true;
}
bool NRPEClient::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("NRPE", alias, "client");
target_path = settings.alias().get_settings_path("targets");
settings.alias().add_path_to_settings()
("NRPE CLIENT SECTION", "Section for NRPE active/passive check module.")
("handlers", sh::fun_values_path(boost::bind(&NRPEClient::add_command, this, _1, _2)),
"CLIENT HANDLER SECTION", "")
("targets", sh::fun_values_path(boost::bind(&NRPEClient::add_target, this, _1, _2)),
"REMOTE TARGET DEFINITIONS", "")
;
settings.alias().add_key_to_settings()
("channel", sh::string_key(&channel_, "NRPE"),
"CHANNEL", "The channel to listen to.")
;
settings.register_all();
settings.notify();
nscapi::core_helper::core_proxy core(get_core(), get_id());
targets.add_samples(get_settings_proxy(), target_path);
targets.ensure_default(get_settings_proxy(), target_path);
core.register_channel(channel_);
} catch (std::exception &e) {
NSC_LOG_ERROR_EXR("loading", e);
return false;
} catch (...) {
NSC_LOG_ERROR_EX("loading");
return false;
}
return true;
}
bool NSCPServer::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("nscp", alias, "server");
settings.alias().add_path_to_settings()
("NSCP SERVER SECTION", "Section for NSCP (NSCPListener.dll) (check_nscp) protocol options.")
;
settings.alias().add_key_to_settings()
("port", sh::string_key(&info_.port_, "5668"),
"PORT NUMBER", "Port to use for NSCP.")
("allow arguments", sh::bool_fun_key<bool>(boost::bind(&handler_impl::set_allow_arguments, handler_, _1), false),
"COMMAND ARGUMENT PROCESSING", "This option determines whether or not the we will allow clients to specify arguments to commands that are executed.")
;
socket_helpers::settings_helper::add_core_server_opts(settings, info_);
socket_helpers::settings_helper::add_ssl_server_opts(settings, info_, true);
settings.register_all();
settings.notify();
#ifndef USE_SSL
if (info_.use_ssl) {
NSC_LOG_ERROR_STD(_T("SSL not avalible! (not compiled with openssl support)"));
return false;
}
#endif
boost::asio::io_service io_service_;
if (mode == NSCAPI::normalStart) {
NSC_LOG_ERROR_LISTS(info_.validate());
std::list<std::string> errors;
info_.allowed_hosts.refresh(errors);
NSC_LOG_ERROR_LISTS(errors);
NSC_DEBUG_MSG_STD("Allowed hosts definition: " + info_.allowed_hosts.to_string());
server_.reset(new nscp::server::server(info_, handler_));
if (!server_) {
NSC_LOG_ERROR_STD("Failed to create server instance!");
return false;
}
server_->start();
}
return true;
}
void CheckExternalScripts::add_command(std::string key, std::string arg) {
try {
commands_.add(get_settings_proxy(), commands_path, key, arg, key == "default");
if (arg.find("$ARG") != std::string::npos) {
if (!allowArgs_) {
NSC_DEBUG_MSG_STD("Detected a $ARG??$ expression with allowed arguments flag set to false (perhaps this is not the intent)");
}
}
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("Failed to add: " + key, e);
} catch (...) {
NSC_LOG_ERROR_EX("Failed to add: " + key);
}
}
bool CheckLogFile::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
thread_.reset(new real_time_thread);
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, "logfile");
thread_->filters_path_ = settings.alias().get_settings_path("real-time/checks");
settings.alias().add_path_to_settings()
("LOG FILE SECTION", "Section for log file checker")
("real-time", "CONFIGURE REALTIME CHECKING", "A set of options to configure the real time checks")
("real-time/checks", sh::fun_values_path(boost::bind(&real_time_thread::add_realtime_filter, thread_, get_settings_proxy(), _1, _2)),
"REALTIME FILTERS", "A set of filters to use in real-time mode",
"REALTIME FILTER DEFENTION", "For more configuration options add a dedicated section"
)
;
settings.alias().add_key_to_settings("real-time")
("enabled", sh::bool_fun_key<bool>(boost::bind(&real_time_thread::set_enabled, thread_, _1), false),
"REAL TIME CHECKING", "Spawns a background thread which waits for file changes.")
;
settings.register_all();
settings.notify();
filters::filter_config_handler::add_samples(get_settings_proxy(), thread_->filters_path_);
if (mode == NSCAPI::normalStart) {
if (!thread_->start())
NSC_LOG_ERROR_STD("Failed to start collection thread");
}
return true;
}
bool DistributedServer::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
std::wstring host, suffix, server_mode;
unsigned int thread_count;
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(_T("distributed"), alias, _T("server"));
settings.alias().add_path_to_settings()
(_T("DISTRIBUTED NSCP SERVER SECTION"), _T("Section for Distributed NSCP (DistributedServer) (check_nscp) protocol options."))
;
settings.alias().add_key_to_settings()
(_T("host"), sh::wstring_key(&host, _T("tcp://*:5555")),
_T("HOST TO BIND/CONNECT TO"), _T("The host to bind/connect to"))
(_T("suffix"), sh::wstring_key(&suffix, _T("ncsp.dist")),
_T("SUFFIX FOR INTERNAL CHANNELS"), _T("Has to be uniq on each server"))
(_T("worker pool size"), sh::uint_key(&thread_count, 10),
_T("WORKER POOL SIZE"), _T("Number of threads to spawn for the worker pool"))
(_T("mode"), sh::wstring_key(&server_mode, _T("master")),
_T("OPERATION MODE"), _T("Mode of operation can only be master now but will add more later on (such as slave)"))
;
settings.register_all();
settings.notify();
if (mode == NSCAPI::normalStart) {
context = new zmq::context_t(2);
zeromq_queue::connection_info queue_info(to_string(host), to_string(suffix));
zeromq_queue::queue_manager queue;
queue.start(context, threads, queue_info);
zeromq_worker::connection_info worker_info(queue_info.get_backend(), to_string(suffix), thread_count);
zeromq_worker::worker_manager workers;
workers.start(context, threads, worker_info);
}
} catch (std::exception &e) {
NSC_LOG_ERROR_STD(_T("Exception caught: ") + to_wstring(e.what()));
return false;
} catch (...) {
NSC_LOG_ERROR_STD(_T("Exception caught: <UNKNOWN EXCEPTION>"));
return false;
}
return true;
}
bool NSClientServer::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("NSClient", alias, "server");
settings.alias().add_path_to_settings()
("NSCLIENT SERVER SECTION", "Section for NSClient (NSClientServer.dll) (check_nt) protocol options.")
;
settings.alias().add_key_to_settings()
("performance data", sh::bool_fun_key<bool>(boost::bind(&NSClientServer::set_perf_data, this, _1), true),
"PERFORMANCE DATA", "Send performance data back to Nagios (set this to 0 to remove all performance data).")
;
socket_helpers::settings_helper::add_port_server_opts(settings, info_, "12489");
socket_helpers::settings_helper::add_ssl_server_opts(settings, info_, false);
socket_helpers::settings_helper::add_core_server_opts(settings, info_);
settings.alias().add_parent("/settings/default").add_key_to_settings()
("password", sh::string_fun_key<std::string>(boost::bind(&NSClientServer::set_password, this, _1), ""),
"PASSWORD", "Password used to authenticate against server")
;
settings.register_all();
settings.notify();
#ifndef USE_SSL
if (info_.use_ssl) {
NSC_LOG_ERROR_STD(_T("SSL not avalible! (not compiled with openssl support)"));
}
#endif
NSC_LOG_ERROR_LISTS(info_.validate());
std::list<std::string> errors;
info_.allowed_hosts.refresh(errors);
BOOST_FOREACH(const std::string &e, errors) {
NSC_LOG_ERROR_STD(e);
}
bool LUAScript::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
try {
root_ = get_base_path();
nscp_runtime_.reset(new scripts::nscp::nscp_runtime_impl(get_id(), get_core()));
lua_runtime_.reset(new lua::lua_runtime(utf8::cvt<std::string>(root_.string())));
scripts_.reset(new scripts::script_manager<lua::lua_traits>(lua_runtime_, nscp_runtime_, get_id(), utf8::cvt<std::string>(alias)));
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, "lua");
settings.alias().add_path_to_settings()
("LUA SCRIPT SECTION", "Section for the LUAScripts module.")
("scripts", sh::fun_values_path(boost::bind(&LUAScript::loadScript, this, _1, _2)),
"LUA SCRIPTS SECTION", "A list of scripts available to run from the LuaSCript module.",
"SCRIPT DEFENTION", "For more configuration options add a dedicated section")
;
settings.register_all();
settings.notify();
// if (!scriptDirectory_.empty()) {
// addAllScriptsFrom(scriptDirectory_);
// }
scripts_->load_all();
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("load", e);
return false;
} catch (...) {
NSC_LOG_ERROR_EX("load");
return false;
}
return true;
}
bool CheckMKClient::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
std::map<std::wstring,std::wstring> commands;
try {
root_ = get_base_path();
nscp_runtime_.reset(new scripts::nscp::nscp_runtime_impl(get_id(), get_core()));
lua_runtime_.reset(new lua::lua_runtime(utf8::cvt<std::string>(root_.string())));
lua_runtime_->register_plugin(boost::shared_ptr<check_mk::check_mk_plugin>(new check_mk::check_mk_plugin()));
scripts_.reset(new scripts::script_manager<lua::lua_traits>(lua_runtime_, nscp_runtime_, get_id(), utf8::cvt<std::string>(alias)));
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("check_mk", alias, "client");
target_path = settings.alias().get_settings_path("targets");
settings.alias().add_path_to_settings()
("CHECK MK CLIENT SECTION", "Section for NSCP active/passive check module.")
("handlers", sh::fun_values_path(boost::bind(&CheckMKClient::add_command, this, _1, _2)),
"CLIENT HANDLER SECTION", "",
"CLIENT", "For more configuration options add a dedicated section")
("targets", sh::fun_values_path(boost::bind(&CheckMKClient::add_target, this, _1, _2)),
"REMOTE TARGET DEFINITIONS", "",
"TARGET", "For more configuration options add a dedicated section")
("scripts", sh::fun_values_path(boost::bind(&CheckMKClient::add_script, this, _1, _2)),
"REMOTE TARGET DEFINITIONS", "",
"SCRIPT", "For more configuration options add a dedicated section")
;
settings.alias().add_key_to_settings()
("channel", sh::string_key(&channel_, "CheckMK"),
"CHANNEL", "The channel to listen to.")
;
settings.register_all();
settings.notify();
targets.add_samples(get_settings_proxy(), target_path);
targets.add_missing(get_settings_proxy(), target_path, "default", "", true);
if (scripts_->empty()) {
add_script("default", "default_check_mk.lua");
}
nscapi::core_helper core(get_core(), get_id());
core.register_channel(channel_);
scripts_->load_all();
} catch (nscapi::nscapi_exception &e) {
NSC_LOG_ERROR_EXR("Load", e);
return false;
} catch (std::exception &e) {
NSC_LOG_ERROR_EXR("Load", e);
return false;
} catch (...) {
NSC_LOG_ERROR_EX("Load");
return false;
}
return true;
}
bool CheckExternalScripts::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, "external scripts");
aliases_.set_path(settings.alias().get_settings_path("alias"));
std::string wrappings_path = settings.alias().get_settings_path("wrappings");
boost::filesystem::path scriptRoot;
std::string scriptDirectory;
std::map<std::string, std::string> wrappings;
settings.alias().add_path_to_settings()
("wrappings", sh::string_map_path(&wrappings)
, "Script wrappings", "A list of templates for defining script commands.\nEnter any command line here and they will be expanded by scripts placed under the wrapped scripts section. %SCRIPT% will be replaced by the actual script an %ARGS% will be replaced by any given arguments.",
"WRAPPING", "An external script wrapping")
("alias", sh::fun_values_path(boost::bind(&CheckExternalScripts::add_alias, this, _1, _2)),
"Command aliases", "A list of aliases for already defined commands (with arguments).\n"
"An alias is an internal command that has been predefined to provide a single command without arguments. Be careful so you don't create loops (ie check_loop=check_a, check_a=check_loop)",
"ALIAS", "Query alias")
;
settings.register_all();
settings.notify();
settings.clear();
if (wrappings.find("ps1") == wrappings.end()) {
wrappings["ps1"] = "cmd /c echo If (-Not (Test-Path \"scripts\\%SCRIPT%\") ) { Write-Host \"UNKNOWN: Script `\"%SCRIPT%`\" not found.\"; exit(3) }; scripts\\%SCRIPT% $ARGS$; exit($lastexitcode) | powershell.exe /noprofile -command -";
settings.register_key(wrappings_path, "ps1", NSCAPI::key_string, "POWERSHELL WRAPPING", "Command line used for executing wrapped ps1 (powershell) scripts", "cmd /c echo If (-Not (Test-Path \"scripts\\%SCRIPT%\") ) { Write-Host \"UNKNOWN: Script `\"%SCRIPT%`\" not found.\"; exit(3) }; scripts\\%SCRIPT% $ARGS$; exit($lastexitcode) | powershell.exe /noprofile -command -", false);
settings.set_static_key(wrappings_path, "ps1", wrappings["ps1"]);
}
if (wrappings.find("vbs") == wrappings.end()) {
wrappings["vbs"] = "cscript.exe //T:30 //NoLogo scripts\\\\lib\\\\wrapper.vbs %SCRIPT% %ARGS%";
settings.register_key(wrappings_path, "vbs", NSCAPI::key_string, "Visual basic script", "Command line used for wrapped vbs scripts", "cscript.exe //T:30 //NoLogo scripts\\\\lib\\\\wrapper.vbs %SCRIPT% %ARGS%", false);
settings.set_static_key(wrappings_path, "vbs", wrappings["vbs"]);
}
if (wrappings.find("bat") == wrappings.end()) {
wrappings["bat"] = "scripts\\\\%SCRIPT% %ARGS%";
settings.register_key(wrappings_path, "bat", NSCAPI::key_string, "Batch file", "Command used for executing wrapped batch files", "scripts\\\\%SCRIPT% %ARGS%", false);
settings.set_static_key(wrappings_path, "bat", wrappings["bat"]);
}
if (aliases_.empty()) {
NSC_DEBUG_MSG("No aliases found (adding default)");
add_alias("alias_cpu", "check_cpu");
add_alias("alias_cpu_ex", "check_cpu \"warn=load > $ARG1$\" \"crit=load > $ARG2$\" time=5m time=1m time=30s");
add_alias("alias_mem", "check_memory");
add_alias("alias_up", "check_uptime");
add_alias("alias_disk", "check_drivesize");
add_alias("alias_disk_loose", "check_drivesize");
add_alias("alias_volumes", "check_drivesize");
add_alias("alias_volumes_loose", "check_drivesize");
add_alias("alias_service", "check_service");
add_alias("alias_service_ex", "check_service \"exclude=Net Driver HPZ12\" \"exclude=Pml Driver HPZ12\" exclude=stisvc");
add_alias("alias_process", "check_process \"process=$ARG1$\" \"crit=state != 'started'\"");
add_alias("alias_process_stopped", "check_process \"process=$ARG1$\" \"crit=state != 'stopped'\"");
add_alias("alias_process_count", "check_process \"process=$ARG1$\" \"warn=count > $ARG2$\" \"crit=count > $ARG3$\"");
add_alias("alias_process_hung", "check_process \"filter=is_hung\" \"crit=count>0\"");
add_alias("alias_event_log", "check_eventlog");
add_alias("alias_file_size", "check_files \"path=$ARG1$\" \"crit=size > $ARG2$\" \"top-syntax=${list}\" \"detail-syntax=${filename] ${size}\" max-dir-depth=10");
add_alias("alias_file_age", "check_files \"path=$ARG1$\" \"crit=written > $ARG2$\" \"top-syntax=${list}\" \"detail-syntax=${filename] ${written}\" max-dir-depth=10");
add_alias("alias_sched_all", "check_tasksched show-all \"syntax=${title}: ${exit_code}\" \"crit=exit_code ne 0\"");
add_alias("alias_sched_long", "check_tasksched \"filter=status = 'running'\" \"detail-syntax=${title} (${most_recent_run_time})\" \"crit=most_recent_run_time < -$ARG1$\"");
add_alias("alias_sched_task", "check_tasksched show-all \"filter=title eq '$ARG1$'\" \"detail-syntax=${title} (${exit_code})\" \"crit=exit_code ne 0\"");
// add_alias("alias_updates", "check_updates -warning 0 -critical 0");
}
settings.alias().add_key_to_settings()
("timeout", sh::uint_key(&timeout, 60),
"Command timeout", "The maximum time in seconds that a command can execute. (if more then this execution will be aborted). NOTICE this only affects external commands not internal ones.")
("allow arguments", sh::bool_key(&allowArgs_, false),
"Allow arguments when executing external scripts", "This option determines whether or not the we will allow clients to specify arguments to commands that are executed.")
("allow nasty characters", sh::bool_key(&allowNasty_, false),
"Allow certain potentially dangerous characters in arguments", "This option determines whether or not the we will allow clients to specify nasty (as in |`&><'\"\\[]{}) characters in arguments.")
("script path", sh::string_key(&scriptDirectory),
"Load all scripts in a given folder", "Load all scripts in a given directory and use them as commands.")
("script root", sh::path_key(&scriptRoot, "${scripts}"),
"Script root folder", "Root path where all scripts are contained (You can not upload/download scripts outside this folder).")
;
settings.register_all();
settings.notify();
settings.clear();
provider_.reset(new script_provider(get_id(), get_core(), settings.alias().get_settings_path("scripts"), scriptRoot, wrappings));
settings.alias().add_path_to_settings()
("External script settings", "General settings for the external scripts module (CheckExternalScripts).")
("scripts", sh::fun_values_path(boost::bind(&CheckExternalScripts::add_command, this, _1, _2)),
"External scripts", "A list of scripts available to run from the CheckExternalScripts module. Syntax is: `command=script arguments`",
"SCRIPT", "For more configuration options add a dedicated section (if you add a new section you can customize the user and various other advanced features)")
("wrapped scripts", sh::fun_values_path(boost::bind(&CheckExternalScripts::add_wrapping, this, _1, _2)),
"Wrapped scripts", "A list of wrapped scripts (ie. script using a template mechanism).\nThe template used will be defined by the extension of the script. Thus a foo.ps1 will use the ps1 wrapping from the wrappings section.",
"WRAPPED SCRIPT", "A wrapped script definitions")
;
settings.alias().add_templates()
("scripts", "plus", "Add a simple script",
"Add binding for a simple script",
"{"
"\"fields\": [ "
" { \"id\": \"alias\", \"title\" : \"Alias\", \"type\" : \"input\", \"desc\" : \"This will identify the command\"} , "
" { \"id\": \"script\", \"title\" : \"Script\", \"type\" : \"data-choice\", \"desc\" : \"The name of the script\",\"exec\" : \"CheckExternalScripts list --json\" } , "
" { \"id\": \"args\", \"title\" : \"Arguments\", \"type\" : \"input\", \"desc\" : \"Command line arguments for the script use $ARG1$ to specify arguments\" } , "
" { \"id\": \"cmd\", \"key\" : \"command\", \"title\" : \"A\", \"type\" : \"hidden\", \"desc\" : \"A\" } "
" ], "
"\"events\": { "
"\"onSave\": \"(function (node) { node.save_path = self.path; var f = node.get_field('cmd'); f.key = node.get_field('alias').value(); var val = node.get_field('script').value(); if (node.get_field('args').value()) { val += ' ' + node.get_field('args').value(); }; f.value(val)})\""
"}"
"}")
("alias", "plus", "Add an alias",
"Add binding for an alias",
"{"
"\"fields\": [ "
" { \"id\": \"alias\", \"title\" : \"Alias\", \"type\" : \"input\", \"desc\" : \"This will identify the command\"} , "
" { \"id\": \"command\", \"title\" : \"Command\", \"type\" : \"data-choice\", \"desc\" : \"The name of the command to execute\",\"exec\" : \"CheckExternalScripts list --json --query\" } , "
" { \"id\": \"args\", \"title\" : \"Arguments\", \"type\" : \"input\", \"desc\" : \"Command line arguments for the command. use $ARG1$ to specify arguments\" } , "
" { \"id\": \"cmd\", \"key\" : \"command\", \"title\" : \"A\", \"type\" : \"hidden\", \"desc\" : \"A\" } "
" ], "
"\"events\": { "
"\"onSave\": \"(function (node) { node.save_path = self.path; \nvar f = node.get_field('cmd'); \nf.key = node.get_field('alias').value(); \nvar val = node.get_field('command').value(); \nif (node.get_field('args').value()) { \nval += ' ' + node.get_field('args').value(); }; \nf.value(val)})\""
"}"
"}")
;
settings.register_all();
settings.notify();
if (!scriptDirectory.empty()) {
addAllScriptsFrom(scriptDirectory);
}
aliases_.add_samples(get_settings_proxy());
aliases_.add_missing(get_settings_proxy(), "default", "");
root_ = get_base_path();
nscapi::core_helper core(get_core(), get_id());
BOOST_FOREACH(const boost::shared_ptr<alias::command_object> &o, aliases_.get_object_list()) {
core.register_alias(o->get_alias(), "Alias for: " + o->command);
}
} catch (...) {
NSC_LOG_ERROR_EX("loading");
return false;
}
return true;
}
bool SyslogClient::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("syslog", alias, "client");
target_path = settings.alias().get_settings_path("targets");
settings.alias().add_path_to_settings()
("SYSLOG CLIENT SECTION", "Section for SYSLOG passive check module.")
("handlers", sh::fun_values_path(boost::bind(&SyslogClient::add_command, this, _1, _2)),
"CLIENT HANDLER SECTION", "",
"CLIENT", "For more configuration options add a dedicated section")
("targets", sh::fun_values_path(boost::bind(&SyslogClient::add_target, this, _1, _2)),
"REMOTE TARGET DEFINITIONS", "",
"TARGET", "For more configuration options add a dedicated section")
;
settings.alias().add_key_to_settings()
("hostname", sh::string_key(&hostname_, "auto"),
"HOSTNAME", "The host name of the monitored computer.\nSet this to auto (default) to use the windows name of the computer.\n\n"
"auto\tHostname\n"
"${host}\tHostname\n"
"${host_lc}\nHostname in lowercase\n"
"${host_uc}\tHostname in uppercase\n"
"${domain}\tDomainname\n"
"${domain_lc}\tDomainname in lowercase\n"
"${domain_uc}\tDomainname in uppercase\n"
)
("channel", sh::string_key(&channel_, "syslog"),
"CHANNEL", "The channel to listen to.")
;
settings.register_all();
settings.notify();
client_.finalize(get_settings_proxy());
nscapi::core_helper core(get_core(), get_id());
core.register_channel(channel_);
if (hostname_ == "auto") {
hostname_ = boost::asio::ip::host_name();
} else if (hostname_ == "auto-lc") {
hostname_ = boost::asio::ip::host_name();
std::transform(hostname_.begin(), hostname_.end(), hostname_.begin(), ::tolower);
} else if (hostname_ == "auto-uc") {
hostname_ = boost::asio::ip::host_name();
std::transform(hostname_.begin(), hostname_.end(), hostname_.begin(), ::toupper);
} else {
strEx::s::token dn = strEx::s::getToken(boost::asio::ip::host_name(), '.');
try {
boost::asio::io_service svc;
boost::asio::ip::tcp::resolver resolver (svc);
boost::asio::ip::tcp::resolver::query query (boost::asio::ip::host_name(), "");
boost::asio::ip::tcp::resolver::iterator iter = resolver.resolve (query), end;
std::string s;
while (iter != end) {
s += iter->host_name();
s += " - ";
s += iter->endpoint().address().to_string();
iter++;
}
} catch (const std::exception& e) {
NSC_LOG_ERROR_EXR("Failed to resolve: ", e);
}
strEx::replace(hostname_, "${host}", dn.first);
strEx::replace(hostname_, "${domain}", dn.second);
std::transform(dn.first.begin(), dn.first.end(), dn.first.begin(), ::toupper);
std::transform(dn.second.begin(), dn.second.end(), dn.second.begin(), ::toupper);
strEx::replace(hostname_, "${host_uc}", dn.first);
strEx::replace(hostname_, "${domain_uc}", dn.second);
std::transform(dn.first.begin(), dn.first.end(), dn.first.begin(), ::tolower);
std::transform(dn.second.begin(), dn.second.end(), dn.second.begin(), ::tolower);
strEx::replace(hostname_, "${host_lc}", dn.first);
strEx::replace(hostname_, "${domain_lc}", dn.second);
}
} catch (nscapi::nscapi_exception &e) {
NSC_LOG_ERROR_EXR("NSClient API exception: ", e);
return false;
} catch (std::exception &e) {
NSC_LOG_ERROR_EXR("NSClient API exception: ", e);
return false;
} catch (...) {
NSC_LOG_ERROR_EX("NSClient API exception: ");
return false;
}
return true;
}
bool SimpleFileWriter::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
std::string primary_key;
std::string channel;
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, "writers/file");
settings.alias().add_path_to_settings()
("FILE WRITER", "Section for simple file writer module (SimpleFileWriter.dll).")
;
settings.alias().add_key_to_settings()
("syntax", sh::string_key(&primary_key, "${alias-or-command} ${result} ${message}"),
"MESSAGE SYNTAX", "The syntax of the message to write to the line.\nCan be any arbitrary string as well as include any of the following special keywords:"
"${command} = The command name, ${host} the host, ${channel} the recieving channel, ${alias} the alias for the command, ${alias-or-command} = alias if set otherweise command, ${message} = the message data (no escape), ${result} = The result status (number).")
("file", sh::path_key(&filename_, "output.txt"),
"FILE TO WRITE TO", "The filename to write output to.")
("channel", sh::string_key(&channel, "FILE"),
"CHANNEL", "The channel to listen to.")
;
settings.register_all();
settings.notify();
nscapi::core_helper::core_proxy core(get_core(), get_id());
core.register_channel(channel);
parsers::simple_expression parser;
parsers::simple_expression::result_type result;
if (!parser.parse(primary_key, result)) {
NSC_LOG_ERROR_STD("Failed to parse primary key: " + primary_key)
}
BOOST_FOREACH(parsers::simple_expression::entry &e, result) {
if (!e.is_variable) {
index_lookup_.push_back(simple_string_functor(e.name));
} else if (e.name == "command") {
index_lookup_.push_back(payload_command_functor());
} else if (e.name == "host") {
index_lookup_.push_back(header_host_functor());
} else if (e.name == "channel") {
index_lookup_.push_back(channel_functor());
} else if (e.name == "alias") {
index_lookup_.push_back(payload_alias_functor());
} else if (e.name == "alias-or-command") {
index_lookup_.push_back(payload_alias_or_command_functor());
} else if (e.name == "message") {
index_lookup_.push_back(payload_message_functor());
} else if (e.name == "result") {
index_lookup_.push_back(payload_result_functor());
} else {
NSC_LOG_ERROR_STD("Invalid index: " + e.name);
}
}
} catch (nscapi::nscapi_exception &e) {
NSC_LOG_ERROR_EXR("Failed to register command: ", e);
return false;
} catch (std::exception &e) {
NSC_LOG_ERROR_EXR("load", e);
return false;
} catch (...) {
NSC_LOG_ERROR_EX("load");
return false;
}
return true;
}
bool CheckMKServer::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
root_ = get_base_path();
nscp_runtime_.reset(new scripts::nscp::nscp_runtime_impl(get_id(), get_core()));
lua_runtime_.reset(new lua::lua_runtime(utf8::cvt<std::string>(root_.string())));
lua_runtime_->register_plugin(boost::shared_ptr<check_mk::check_mk_plugin>(new check_mk::check_mk_plugin()));
scripts_.reset(new scripts::script_manager<lua::lua_traits>(lua_runtime_, nscp_runtime_, get_id(), utf8::cvt<std::string>(alias)));
handler_.reset(new handler_impl(scripts_));
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("check_mk", alias, "server");
settings.alias().add_path_to_settings()
("CHECK MK SERVER SECTION", "Section for check_mk (CheckMKServer.dll) protocol options.")
("scripts", sh::fun_values_path(boost::bind(&CheckMKServer::add_script, this, _1, _2)),
"REMOTE TARGET DEFINITIONS", "",
"TARGET", "For more configuration options add a dedicated section")
;
settings.alias().add_key_to_settings()
("port", sh::string_key(&info_.port_, "6556"),
"PORT NUMBER", "Port to use for check_mk.")
;
socket_helpers::settings_helper::add_core_server_opts(settings, info_);
socket_helpers::settings_helper::add_ssl_server_opts(settings, info_, false);
settings.register_all();
settings.notify();
if (scripts_->empty()) {
add_script("default", "default_check_mk.lua");
}
#ifndef USE_SSL
if (info_.use_ssl) {
NSC_LOG_ERROR_STD(_T("SSL not avalible! (not compiled with openssl support)"));
return false;
}
#endif
NSC_LOG_ERROR_LISTS(info_.validate());
std::list<std::string> errors;
info_.allowed_hosts.refresh(errors);
NSC_LOG_ERROR_LISTS(errors);
NSC_DEBUG_MSG_STD("Allowed hosts definition: " + info_.allowed_hosts.to_string());
boost::asio::io_service io_service_;
scripts_->load_all();
if (mode == NSCAPI::normalStart) {
server_.reset(new check_mk::server::server(info_, handler_));
if (!server_) {
NSC_LOG_ERROR_STD("Failed to create server instance!");
return false;
}
server_->start();
}
return true;
}
bool SyslogClient::loadModuleEx(std::wstring alias, NSCAPI::moduleLoadMode mode) {
facilities["kernel"] = 0;
facilities["user"] = 1;
facilities["mail"] = 2;
facilities["system"] = 3;
facilities["security"] = 4;
facilities["internal"] = 5;
facilities["printer"] = 6;
facilities["news"] = 7;
facilities["UUCP"] = 8;
facilities["clock"] = 9;
facilities["authorization"] = 10;
facilities["FTP"] = 11;
facilities["NTP"] = 12;
facilities["audit"] = 13;
facilities["alert"] = 14;
facilities["clock"] = 15;
facilities["local0"] = 16;
facilities["local1"] = 17;
facilities["local2"] = 18;
facilities["local3"] = 19;
facilities["local4"] = 20;
facilities["local5"] = 21;
facilities["local6"] = 22;
facilities["local7"] = 23;
severities["emergency"] = 0;
severities["alert"] = 1;
severities["critical"] = 2;
severities["error"] = 3;
severities["warning"] = 4;
severities["notice"] = 5;
severities["informational"] = 6;
severities["debug"] = 7;
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(_T("syslog"), alias, _T("client"));
target_path = settings.alias().get_settings_path(_T("targets"));
settings.alias().add_path_to_settings()
(_T("SYSLOG CLIENT SECTION"), _T("Section for SYSLOG passive check module."))
(_T("handlers"), sh::fun_values_path(boost::bind(&SyslogClient::add_command, this, _1, _2)),
_T("CLIENT HANDLER SECTION"), _T(""))
(_T("targets"), sh::fun_values_path(boost::bind(&SyslogClient::add_target, this, _1, _2)),
_T("REMOTE TARGET DEFINITIONS"), _T(""))
;
settings.alias().add_key_to_settings()
(_T("hostname"), sh::string_key(&hostname_),
_T("HOSTNAME"), _T("The host name of this host if set to blank (default) the windows name of the computer will be used."))
(_T("channel"), sh::wstring_key(&channel_, _T("syslog")),
_T("CHANNEL"), _T("The channel to listen to."))
;
settings.register_all();
settings.notify();
targets.add_missing(get_settings_proxy(), target_path, _T("default"), _T(""), true);
get_core()->registerSubmissionListener(get_id(), channel_);
register_command(_T("syslog_query"), _T("Check remote NRPE host"));
register_command(_T("syslog_submit"), _T("Submit (via query) remote NRPE host"));
register_command(_T("syslog_forward"), _T("Forward query to remote NRPE host"));
register_command(_T("syslog_exec"), _T("Execute (via query) remote NRPE host"));
register_command(_T("syslog_help"), _T("Help on using NRPE Client"));
} catch (nscapi::nscapi_exception &e) {
NSC_LOG_ERROR_STD(_T("NSClient API exception: ") + utf8::to_unicode(e.what()));
return false;
} catch (std::exception &e) {
NSC_LOG_ERROR_STD(_T("Exception caught: ") + utf8::to_unicode(e.what()));
return false;
} catch (...) {
NSC_LOG_ERROR_STD(_T("Exception caught: <UNKNOWN EXCEPTION>"));
return false;
}
return true;
}
bool NSCAServer::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
try {
if (server_) {
server_->stop();
server_.reset();
}
} catch (...) {
NSC_LOG_ERROR_STD("Failed to stop server");
return false;
}
sh::settings_registry settings(get_settings_proxy());
settings.set_alias("NSCA", alias, "server");
settings.alias().add_path_to_settings()
("NSCA SERVER SECTION", "Section for NSCA (NSCAServer) (check_nsca) protocol options.")
;
settings.alias().add_key_to_settings()
("port", sh::string_key(&info_.port_, "5667"),
"PORT NUMBER", "Port to use for NSCA.")
("payload length", sh::uint_key(&payload_length_, 512),
"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 agent to use the same value for it to work.")
("performance data", sh::bool_fun_key<bool>(boost::bind(&NSCAServer::set_perf_data, this, _1), true),
"PERFORMANCE DATA", "Send performance data back to nagios (set this to false to remove all performance data).")
("encryption", sh::string_fun_key<std::string>(boost::bind(&NSCAServer::set_encryption, this, _1), "aes"),
"ENCRYPTION", std::string("Name of encryption algorithm to use.\nHas to be the same as your agent i using or it wont work at all."
"This is also independent of SSL and generally used instead of SSL.\nAvailable encryption algorithms are:\n") + nscp::encryption::helpers::get_crypto_string("\n"))
;
socket_helpers::settings_helper::add_core_server_opts(settings, info_);
socket_helpers::settings_helper::add_ssl_server_opts(settings, info_, false);
settings.alias().add_parent("/settings/default").add_key_to_settings()
("password", sh::string_key(&password_, ""),
"PASSWORD", "Password to use")
("inbox", sh::string_key(&channel_, "inbox"),
"INBOX", "The default channel to post incoming messages on")
;
settings.register_all();
settings.notify();
#ifndef USE_SSL
if (info_.ssl.enabled) {
NSC_LOG_ERROR_STD(_T("SSL not avalible! (not compiled with openssl support)"));
return false;
}
#endif
if (payload_length_ != 512)
NSC_DEBUG_MSG_STD("Non-standard buffer length (hope you have recompiled check_nsca changing #define MAX_PACKETBUFFER_LENGTH = " + strEx::s::xtos(payload_length_));
NSC_LOG_ERROR_LISTS(info_.validate());
std::list<std::string> errors;
info_.allowed_hosts.refresh(errors);
NSC_LOG_ERROR_LISTS(errors);
NSC_DEBUG_MSG_STD("Allowed hosts definition: " + info_.allowed_hosts.to_string());
if (mode == NSCAPI::normalStart || mode == NSCAPI::reloadStart) {
server_.reset(new nsca::server::server(info_, this));
if (!server_) {
NSC_LOG_ERROR_STD("Failed to create server instance!");
return false;
}
server_->start();
}
return true;
}
bool Scheduler::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
if (mode == NSCAPI::reloadStart) {
scheduler_.unset_handler();
scheduler_.clear();
}
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, "scheduler");
schedules_.set_path(settings.alias().get_settings_path("schedules"));
settings.alias().add_path_to_settings()
("SCHEDULER SECTION", "Section for the Scheduler module.")
;
settings.alias().add_key_to_settings()
("threads", sh::int_fun_key<unsigned int>(boost::bind(&schedules::scheduler::set_threads, &scheduler_, _1), 5),
"THREAD COUNT", "Number of threads to use.")
;
settings.alias().add_path_to_settings()
("schedules", sh::fun_values_path(boost::bind(&Scheduler::add_schedule, this, _1, _2)),
"SCHEDULER SECTION", "Section for the Scheduler module.",
"SCHEDULE", "For more configuration options add a dedicated section")
;
settings.alias().add_templates()
("schedules", "plus", "Add a simple schedule",
"Add a simple scheduled job for passive monitoring",
"{"
"\"fields\": [ "
" { \"id\": \"alias\", \"title\" : \"Alias\", \"type\" : \"input\", \"desc\" : \"This will identify the command\"} , "
" { \"id\": \"command\", \"title\" : \"Command\", \"type\" : \"data-choice\", \"desc\" : \"The name of the command to execute\",\"exec\" : \"CheckExternalScripts list --json --query\" } , "
" { \"id\": \"args\", \"title\" : \"Arguments\", \"type\" : \"input\", \"desc\" : \"Command line arguments for the command\" } , "
" { \"id\": \"cmd\", \"key\" : \"command\", \"title\" : \"A\", \"type\" : \"hidden\", \"desc\" : \"A\" } "
" ], "
"\"events\": { "
"\"onSave\": \"(function (node) { node.save_path = self.path; var f = node.get_field('cmd'); f.key = node.get_field('alias').value(); var val = node.get_field('command').value(); if (node.get_field('args').value()) { val += ' ' + node.get_field('args').value(); }; f.value(val)})\""
"}"
"}")
;
settings.register_all();
settings.notify();
schedules_.ensure_default();
BOOST_FOREACH(const schedules::schedule_handler::object_list_type::value_type &o, schedules_.get_object_list()) {
if (o->duration && (*o->duration).total_seconds() == 0) {
NSC_LOG_ERROR("WE cant add schedules with 0 duration: " + o->to_string());
continue;
}
if (o->duration && o->schedule) {
NSC_LOG_ERROR("WE cant add schedules with both duration and schedule: " + o->to_string());
continue;
}
if (!o->duration && !o->schedule) {
NSC_LOG_ERROR("WE need wither duration or schedule: " + o->to_string());
continue;
}
NSC_DEBUG_MSG("Adding scheduled item: " + o->to_string());
scheduler_.add_task(o);
}
if (mode == NSCAPI::normalStart) {
scheduler_.set_handler(this);
scheduler_.start();
}
if (mode == NSCAPI::reloadStart) {
scheduler_.set_handler(this);
scheduler_.start();
}
return true;
}
bool CheckEventLog::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode mode) {
eventlog::api::load_procs();
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, "eventlog");
thread_.reset(new real_time_thread(get_core(), get_id()));
if (!thread_) {
NSC_LOG_ERROR_STD("Failed to create thread container");
return false;
}
thread_->set_path(settings.alias().get_settings_path("real-time/filters"));
settings.alias().add_path_to_settings()
("Eventlog configuration", "Section for the EventLog Checker (CheckEventLog.dll).")
("real-time", "Real-time monitoring", "A set of options to configure the real time checks")
("real-time/filters", sh::fun_values_path(boost::bind(&real_time_thread::add_realtime_filter, thread_, get_settings_proxy(), _1, _2)),
"Real-time filters", "A set of filters to use in real-time mode",
"FILTER DEFENITION", "For more configuration options add a dedicated section")
;
settings.alias().add_key_to_settings()
("debug", sh::bool_key(&debug_, false),
"DEBUG", "Log more information when filtering (useful to detect issues with filters) not useful in production as it is a bit of a resource hog.")
("lookup names", sh::bool_key(&lookup_names_, true),
"LOOKUP NAMES", "Lookup the names of eventlog files")
("syntax", sh::string_key(&syntax_),
"SYNTAX", "Set this to use a specific syntax string for all commands (that don't specify one).")
("buffer size", sh::int_key(&buffer_length_, 128 * 1024),
"BUFFER_SIZE", "The size of the buffer to use when getting messages this affects the speed and maximum size of messages you can recieve.")
;
settings.alias().add_key_to_settings("real-time")
("enabled", sh::bool_fun_key(boost::bind(&real_time_thread::set_enabled, thread_, _1), false),
"REAL TIME CHECKING", "Spawns a background thread which detects issues and reports them back instantly.")
("startup age", sh::string_fun_key(boost::bind(&real_time_thread::set_start_age, thread_, _1), "30m"),
"STARTUP AGE", "The initial age to scan when starting NSClient++")
("log", sh::string_key(&thread_->logs_, "application,system"),
"LOGS TO CHECK", "Comma separated list of logs to check")
("debug", sh::bool_key(&thread_->debug_, false),
"DEBUG", "Log missed records (useful to detect issues with filters) not useful in production as it is a bit of a resource hog.")
;
std::string filter_path = settings.alias().get_settings_path("real-time/filters");
settings.register_all();
settings.notify();
thread_->filters_.add_samples(get_settings_proxy());
thread_->filters_.add_missing(get_settings_proxy(), "default", "");
if (mode == NSCAPI::normalStart) {
nscapi::core_helper core(get_core(), get_id());
BOOST_FOREACH(const nscapi::core_helper::storage_map::value_type &e, core.get_storage_strings("eventlog.bookmarks")) {
bookmarks_.add(e.first, e.second);
}
if (!thread_->start())
NSC_LOG_ERROR_STD("Failed to start collection thread");
}
bool CheckExternalScripts::loadModuleEx(std::string alias, NSCAPI::moduleLoadMode) {
try {
sh::settings_registry settings(get_settings_proxy());
settings.set_alias(alias, "external scripts");
commands_path = settings.alias().get_settings_path("scripts");
aliases_path = settings.alias().get_settings_path("alias");
std::string wrappings_path = settings.alias().get_settings_path("wrappings");
settings.alias().add_path_to_settings()
("wrappings", sh::string_map_path(&wrappings_)
, "EXTERNAL SCRIPT WRAPPINGS SECTION", "A list of templates for wrapped scripts.\n%SCRIPT% will be replaced by the actual script an %ARGS% will be replaced by any given arguments.",
"WRAPPING", "An external script wrapping")
("alias", sh::fun_values_path(boost::bind(&CheckExternalScripts::add_alias, this, _1, _2)),
"ALIAS SECTION", "A list of aliases available.\n"
"An alias is an internal command that has been predefined to provide a single command without arguments. Be careful so you don't create loops (ie check_loop=check_a, check_a=check_loop)",
"ALIAS", "Query alias")
;
settings.register_all();
settings.notify();
settings.clear();
if (wrappings_.find("ps1") == wrappings_.end()) {
wrappings_["ps1"] = "cmd /c echo scripts\\\\%SCRIPT% %ARGS%; exit($lastexitcode) | powershell.exe -command -";
settings.register_key(wrappings_path, "ps1", NSCAPI::key_string, "POWERSHELL WRAPPING", "", "", false);
settings.set_static_key(wrappings_path, "ps1", wrappings_["ps1"]);
}
if (wrappings_.find("vbs") == wrappings_.end()) {
wrappings_["vbs"] = "cscript.exe //T:30 //NoLogo scripts\\\\lib\\\\wrapper.vbs %SCRIPT% %ARGS%";
settings.register_key(wrappings_path, "vbs", NSCAPI::key_string, "VISUAL BASIC WRAPPING", "", "", false);
settings.set_static_key(wrappings_path, "vbs", wrappings_["vbs"]);
}
if (wrappings_.find("bat") == wrappings_.end()) {
wrappings_["bat"] = "scripts\\\\%SCRIPT% %ARGS%";
settings.register_key(wrappings_path, "bat", NSCAPI::key_string, "BATCH FILE WRAPPING", "", "", false);
settings.set_static_key(wrappings_path, "bat", wrappings_["bat"]);
}
if (aliases_.empty()) {
NSC_DEBUG_MSG("No aliases found (adding default)");
add_alias("alias_cpu", "check_cpu");
add_alias("alias_cpu_ex", "check_cpu \"warn=load > $ARG1$\" \"crit=load > $ARG2$\" time=5m time=1m time=30s");
add_alias("alias_mem", "check_memory");
add_alias("alias_up", "check_uptime");
add_alias("alias_disk", "check_drivesize");
add_alias("alias_disk_loose", "check_drivesize");
add_alias("alias_volumes", "check_drivesize");
add_alias("alias_volumes_loose", "check_drivesize");
add_alias("alias_service", "check_service");
add_alias("alias_service_ex", "check_service \"exclude=Net Driver HPZ12\" \"exclude=Pml Driver HPZ12\" exclude=stisvc");
add_alias("alias_process", "check_process \"process=$ARG1$\" \"crit=state != 'started'\"");
add_alias("alias_process_stopped", "check_process \"process=$ARG1$\" \"crit=state != 'stopped'\"");
add_alias("alias_process_count", "check_process \"process=$ARG1$\" \"warn=count > $ARG2$\" \"crit=count > $ARG3$\"");
add_alias("alias_process_hung", "check_process \"filter=is_hung\" \"crit=count>0\"");
add_alias("alias_event_log", "check_eventlog");
add_alias("alias_file_size", "check_files \"path=$ARG1$\" \"crit=size > $ARG2$\" \"top-syntax=${list}\" \"detail-syntax=${filename] ${size}\" max-dir-depth=10");
add_alias("alias_file_age", "check_files \"path=$ARG1$\" \"crit=written > $ARG2$\" \"top-syntax=${list}\" \"detail-syntax=${filename] ${written}\" max-dir-depth=10");
add_alias("alias_sched_all", "check_tasksched show-all \"syntax=${title}: ${exit_code}\" \"crit=exit_code ne 0\"");
add_alias("alias_sched_long", "check_tasksched \"filter=status = 'running'\" \"detail-syntax=${title} (${most_recent_run_time})\" \"crit=most_recent_run_time < -$ARG1$\"");
add_alias("alias_sched_task", "check_tasksched show-all \"filter=title eq '$ARG1$'\" \"detail-syntax=${title} (${exit_code})\" \"crit=exit_code ne 0\"");
// add_alias("alias_updates", "check_updates -warning 0 -critical 0");
}
settings.alias().add_path_to_settings()
("EXTERNAL SCRIPT SECTION", "Section for external scripts configuration options (CheckExternalScripts).")
("scripts", sh::fun_values_path(boost::bind(&CheckExternalScripts::add_command, this, _1, _2)),
"SCRIPT SECTION", "A list of scripts available to run from the CheckExternalScripts module. Syntax is: <command>=<script> <arguments>",
"SCRIPT", "For more configuration options add a dedicated section (if you add a new section you can customize the user and various other advanced features)")
("wrapped scripts", sh::fun_values_path(boost::bind(&CheckExternalScripts::add_wrapping, this, _1, _2)),
"WRAPPED SCRIPTS SECTION", "A list of wrapped scripts (ie. scruts using a template mechanism). The template used will be defined by the extension of the script.",
"WRAPPED SCRIPT", "A wrapped script defenitions")
;
settings.alias().add_key_to_settings()
("timeout", sh::uint_key(&timeout, 60),
"COMMAND TIMEOUT", "The maximum time in seconds that a command can execute. (if more then this execution will be aborted). NOTICE this only affects external commands not internal ones.")
("allow arguments", sh::bool_key(&allowArgs_, false),
"COMMAND ARGUMENT PROCESSING", "This option determines whether or not the we will allow clients to specify arguments to commands that are executed.")
("allow nasty characters", sh::bool_key(&allowNasty_, false),
"COMMAND ALLOW NASTY META CHARS", "This option determines whether or not the we will allow clients to specify nasty (as in |`&><'\"\\[]{}) characters in arguments.")
("script path", sh::string_key(&scriptDirectory_),
"SCRIPT DIRECTORY", "Load all scripts in a directory and use them as commands. Probably dangerous but useful if you have loads of scripts :)")
;
settings.register_all();
settings.notify();
if (!scriptDirectory_.empty()) {
addAllScriptsFrom(scriptDirectory_);
}
root_ = get_base_path();
nscapi::core_helper core(get_core(), get_id());
BOOST_FOREACH(const commands::command_handler::object_list_type::value_type &o, commands_.object_list) {
core.register_alias(o.second.tpl.alias, "External script: " + o.second.command);
}
BOOST_FOREACH(const alias::command_handler::object_list_type::value_type &o, aliases_.object_list) {
core.register_alias(o.second.tpl.alias, "Alias for: " + o.second.command);
}
} catch (...) {
NSC_LOG_ERROR_EX("loading");
return false;
}
return true;
}