void CheckSystem::check_uptime(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef check_uptime_filter::filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
std::vector<std::string> times;
filter_type filter;
filter_helper.add_options("uptime < 2d", "uptime < 1d", "", filter.get_filter_syntax(), "ignored");
filter_helper.add_syntax("${status}: ${list}", filter.get_format_syntax(), "uptime: ${uptime}h, boot: ${boot} (UTC)", "uptime", "", "");
if (!filter_helper.parse_options())
return;
if (!filter_helper.build_filter(filter))
return;
double uptime_secs = 0, idle_secs = 0;
get_uptime(uptime_secs, idle_secs);
unsigned long long value = uptime_secs;
boost::posix_time::ptime now = boost::posix_time::second_clock::universal_time();
boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
boost::posix_time::ptime boot = now - boost::posix_time::time_duration(0, 0, value);
long long now_delta = (now-epoch).total_seconds();
long long uptime = static_cast<long long>(value);
boost::shared_ptr<check_uptime_filter::filter_obj> record(new check_uptime_filter::filter_obj(uptime, now_delta, boot));
filter.match(record);
filter_helper.post_process(filter);
}
void CheckSystem::check_os_version(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef os_version_filter::filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
filter_type filter;
filter_helper.add_options("version > 50", "version > 50", "", filter.get_filter_syntax(), "ignored");
filter_helper.add_syntax("${status}: ${list}", filter.get_format_syntax(), "${version} (${major}.${minor}.${build})", "version", "", "");
if (!filter_helper.parse_options())
return;
if (!filter_helper.build_filter(filter))
return;
struct utsname name;
if (uname(&name) == -1)
return nscapi::protobuf::functions::set_response_bad(*response, "Cannot get system name");
boost::shared_ptr<os_version_filter::filter_obj> record(new os_version_filter::filter_obj());
record->kernel_name = name.sysname;
record->nodename = name.nodename;
record->kernel_version = name.version;
record->kernel_release = name.release;
record->machine = name.machine;
filter.match(record);
filter_helper.post_process(filter);
}
void CheckWMI::check_wmi(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef wmi_filter::filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
std::string given_target;
target_helper::target_info target_info;
boost::optional<target_helper::target_info> t;
std::string query, ns = "root\\cimv2";
filter_type filter;
filter_helper.add_options("", "", "", filter.get_filter_syntax(), "ignored");
filter_helper.add_syntax("${list}", filter.get_format_syntax(), "%(line)", "", "", "");
filter_helper.get_desc().add_options()
("target", po::value<std::string>(&given_target), "The target to check (for checking remote machines).")
("user", po::value<std::string>(&target_info.username), "Remote username when checking remote machines.")
("password", po::value<std::string>(&target_info.password), "Remote password when checking remote machines.")
("namespace", po::value<std::string>(&ns)->default_value("root\\cimv2"), "The WMI root namespace to bind to.")
("query", po::value<std::string>(&query), "The WMI query to execute.")
;
if (!filter_helper.parse_options())
return;
if (query.empty())
return nscapi::protobuf::functions::set_response_bad(*response, "No query specified");
if (!given_target.empty()) {
t = targets.find(given_target);
if (t)
target_info.update_from(*t);
else
target_info.hostname = given_target;
}
try {
ns = build_namespace(ns, target_info.hostname);
wmi_impl::query wmiQuery(query, ns, target_info.username, target_info.password);
filter.context->registry_.add_string()
("line", boost::bind(&wmi_filter::filter_obj::get_row, _1), "Get a list of all columns");
BOOST_FOREACH(const std::string &col, wmiQuery.get_columns()) {
filter.context->registry_.add_int()
(col, boost::bind(&wmi_filter::filter_obj::get_int, _1, col), boost::bind(&wmi_filter::filter_obj::get_string, _1, col), "Column: " + col).add_perf("", col, "");
}
if (!filter_helper.build_filter(filter))
return;
wmi_impl::row_enumerator e = wmiQuery.execute();
while (e.has_next()) {
boost::shared_ptr<wmi_filter::filter_obj> record(new wmi_filter::filter_obj(e.get_next()));
filter.match(record);
}
} catch (const wmi_impl::wmi_exception &e) {
return nscapi::protobuf::functions::set_response_bad(*response, "WMIQuery failed: " + e.reason());
}
filter_helper.post_process(filter);
}
void CheckNet::check_ping(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
modern_filter::data_container data;
modern_filter::cli_helper<ping_filter::filter> filter_helper(request, response, data);
std::vector<std::string> hosts;
std::string hosts_string;
bool total = false;
int count = 0;
int timeout = 0;
ping_filter::filter filter;
filter_helper.add_options("time > 60 or loss > 5%", "time > 100 or loss > 10%", "", filter.get_filter_syntax(), "unknown");
filter_helper.add_syntax("${status}: ${problem_count}/${count} (${problem_list})", filter.get_format_syntax(), "${ip} Packet loss = ${loss}%, RTA = ${time}ms", "${host}", "No hosts found", "%(status): All %(count) hosts are ok");
filter_helper.get_desc().add_options()
("host", po::value<std::vector<std::string> >(&hosts),
"The host to check (or multiple hosts).")
("total", po::bool_switch(&total), "Include the total of all matching hosts")
("hosts", po::value<std::string>(&hosts_string),
"The host to check (or multiple hosts).")
("count", po::value<int>(&count)->default_value(1),
"Number of packets to send.")
("timeout", po::value<int>(&timeout)->default_value(500),
"Timeout in milliseconds.")
;
if (!filter_helper.parse_options())
return;
if (!hosts_string.empty())
boost::split(hosts, hosts_string, boost::is_any_of(","));
if (hosts.empty())
return nscapi::protobuf::functions::set_response_bad(*response, "No host specified");
if (hosts.size() == 1)
filter_helper.show_all = true;
if (!filter_helper.build_filter(filter))
return;
boost::shared_ptr<ping_filter::filter_obj> total_obj;
if (total)
total_obj = ping_filter::filter_obj::get_total();
BOOST_FOREACH(const std::string &host, hosts) {
result_container result;
for (int i = 0; i < count; i++) {
boost::asio::io_service io_service;
pinger ping(io_service, result, host.c_str(), timeout);
ping.ping();
io_service.run();
}
boost::shared_ptr<ping_filter::filter_obj> obj = boost::make_shared<ping_filter::filter_obj>(result);
filter.match(obj);
if (total_obj)
total_obj->add(obj);
}
void CheckSystem::check_memory(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef check_mem_filter::filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
std::vector<std::string> types;
filter_type filter;
filter_helper.add_options("used > 80%", "used > 90%", "", filter.get_filter_syntax(), "ignored");
filter_helper.add_syntax("${status}: ${list}", filter.get_format_syntax(), "${type} = ${used}", "${type}", "", "");
filter_helper.get_desc().add_options()
("type", po::value<std::vector<std::string> >(&types), "The type of memory to check (physical = Physical memory (RAM), committed = total memory (RAM+PAGE)")
;
if (!filter_helper.parse_options())
return;
if (types.empty()) {
types.push_back("physical");
types.push_back("cached");
types.push_back("swap");
}
if (!filter_helper.build_filter(filter))
return;
std::list<check_mem_filter::filter_obj> mem_data;
try {
mem_data = get_memory();
} catch (const std::exception &e) {
return nscapi::protobuf::functions::set_response_bad(*response, e.what());
}
BOOST_FOREACH(const std::string &type, types) {
bool found = false;
BOOST_FOREACH(const check_mem_filter::filter_obj &o, mem_data) {
if (o.type == type) {
boost::shared_ptr<check_mem_filter::filter_obj> record(new check_mem_filter::filter_obj(o));
filter.match(record);
found = true;
break;
}
}
if (!found) {
return nscapi::protobuf::functions::set_response_bad(*response, "Invalid type: " + type);
}
}
void check(const nscp_version &version, const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
filter_type filter;
filter_helper.add_options("", "", "", filter.get_filter_syntax(), "ignored");
filter_helper.add_syntax("${status}: ${list}", filter.get_filter_syntax(), "${release}.${major}.${minor}.${build} (${date})", "version", "", "");
if (!filter_helper.parse_options())
return;
if (!filter_helper.build_filter(filter))
return;
boost::shared_ptr<filter_obj> record(new filter_obj(version));
filter.match(record);
filter_helper.post_process(filter);
}
void CheckTaskSched::check_tasksched(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef tasksched_filter::filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
std::vector<std::string> file_list;
std::string files_string;
std::string computer, user, domain, password, folder;
bool recursive = true, old = false;
filter_type filter;
filter_helper.add_options("exit_code != 0", "exit_code < 0", "enabled = 1", filter.get_filter_syntax(), "warning");
filter_helper.add_syntax("${status}: ${problem_list}", filter.get_filter_syntax(), "${folder}/${title}: ${exit_code} != 0", "${title}", "%(status): No tasks found", "%(status): All tasks are ok");
filter_helper.get_desc().add_options()
("force-old", po::bool_switch(&old), "The name of the computer that you want to connect to.")
("computer", po::value<std::string>(&computer), "The name of the computer that you want to connect to.")
("user", po::value<std::string>(&user), "The user name that is used during the connection to the computer.")
("domain", po::value<std::string>(&domain), "The domain of the user specified in the user parameter.")
("password", po::value<std::string>(&password), "The password that is used to connect to the computer. If the user name and password are not specified, then the current token is used.")
("folder", po::value<std::string>(&folder), "The folder in which the tasks to check reside.")
("recursive", po::value<bool>(&recursive), "Recurse sub folder (defaults to true).")
;
if (!filter_helper.parse_options())
return;
if (!filter_helper.build_filter(filter))
return;
try {
TaskSched query;
query.findAll(filter, computer, user, domain, password, folder, recursive, old);
filter_helper.post_process(filter);
} catch (const nsclient::nsclient_exception &e) {
return nscapi::protobuf::functions::set_response_bad(*response, "Failed to fetch tasks: " + e.reason());
}
}
void check::check_pdh(boost::shared_ptr<pdh_thread> &collector, const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
std::vector<std::string> counters;
bool expand_index = false;
bool reload = false;
bool check_average = false;
bool expand_instance = false;
std::string flags;
std::string type;
std::string time;
filter_type filter;
filter_helper.add_options("", "", "", filter.get_filter_syntax(), "Everything looks good");
filter_helper.add_syntax("${status}: ${problem_list}", filter.get_format_syntax(), "${counter} = ${value}", "${alias}");
filter_helper.get_desc().add_options()
("counter", po::value<std::vector<std::string>>(&counters), "Performance counter to check")
("expand-index", po::bool_switch(&expand_index), "Expand indexes in counter strings")
("instances", po::bool_switch(&expand_instance), "Expand wildcards and fetch all instances")
("reload", po::bool_switch(&reload), "Reload counters on errors (useful to check counters which are not added at boot)")
("averages", po::bool_switch(&check_average), "Check average values (ie. wait for 1 second to collecting two samples)")
("time", po::value<std::string>(&time), "Timeframe to use for named rrd counters")
("flags", po::value<std::string>(&flags), "Extra flags to configure the counter (nocap100, 1000, noscale)")
("type", po::value<std::string>(&type)->default_value("large"), "Format of value (double, long, large)")
;
std::vector<std::string> extra;
if (!filter_helper.parse_options(extra))
return;
if (filter_helper.empty() && data.syntax_top == "${problem_list}")
data.syntax_top = "${list}";
if (counters.empty() && extra.empty())
return nscapi::protobuf::functions::set_response_bad(*response, "No counters specified: add counter=<name of counter>");
if (!filter_helper.build_filter(filter))
return;
if (filter_helper.empty()) {
filter.add_manual_perf("value");
}
PDH::PDHQuery pdh;
std::list<PDH::pdh_instance> free_counters;
typedef std::map<std::string,std::string> counter_list;
counter_list named_counters;
bool has_counter = false;
std::list<std::wstring> to_check;
BOOST_FOREACH(std::string &counter, counters) {
try {
if (counter.find('\\') == std::string::npos) {
named_counters[counter] = counter;
} else {
if (expand_index) {
PDH::PDHResolver::expand_index(counter);
}
PDH::pdh_object obj;
if (expand_instance)
obj.set_instances("*");
obj.set_flags(flags);
obj.set_counter(counter);
obj.set_alias(counter);
obj.set_strategy_static();
obj.set_type(type);
PDH::pdh_instance instance = PDH::factory::create(obj);
pdh.addCounter(instance);
free_counters.push_back(instance);
has_counter = true;
}
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("Failed to poll counter", e);
return nscapi::protobuf::functions::set_response_bad(*response, "Failed to add counter: " + utf8::utf8_from_native(e.what()));
}
}
BOOST_FOREACH(const std::string &s, extra) {
try {
std::string counter, alias;
if ((s.size() > 8) && (s.substr(0,8) == "counter:")) {
std::string::size_type pos = s.find('=');
if (pos != std::string::npos) {
alias = s.substr(8,pos-8);
counter = s.substr(pos+1);
} else
return nscapi::protobuf::functions::set_response_bad(*response, "Invalid option: " + s);
} else
return nscapi::protobuf::functions::set_response_bad(*response, "Invalid option: " + s);
if (counter.find('\\') == std::string::npos) {
named_counters[counter] = counter;
} else {
if (expand_index) {
PDH::PDHResolver::expand_index(counter);
}
PDH::pdh_object obj;
obj.set_flags(flags);
obj.set_counter(counter);
obj.set_strategy_static();
obj.set_type(type);
obj.set_alias(alias);
PDH::pdh_instance instance = PDH::factory::create(obj);
pdh.addCounter(instance);
free_counters.push_back(instance);
has_counter = true;
}
} catch (const std::exception &e) {
NSC_LOG_ERROR_EXR("Failed to poll counter", e);
return nscapi::protobuf::functions::set_response_bad(*response, "Failed to add counter: " + utf8::utf8_from_native(e.what()));
}
}
if (!free_counters.empty()) {
try {
pdh.open();
if (check_average) {
pdh.collect();
Sleep(1000);
}
//pdh.collect();
pdh.gatherData(expand_instance);
pdh.close();
} catch (const PDH::pdh_exception &e) {
NSC_LOG_ERROR_EXR("Failed to poll counter", e);
return nscapi::protobuf::functions::set_response_bad(*response, "Failed to poll counter: " + utf8::utf8_from_native(e.what()));
}
}
BOOST_FOREACH(const counter_list::value_type &vc, named_counters) {
try {
typedef std::map<std::string,double> value_list_type;
value_list_type values;
if (time.empty()) {
values = collector->get_value(vc.second);
} else {
values = collector->get_average(vc.second, strEx::stoui_as_time(time)/1000);
}
if (values.empty())
return nscapi::protobuf::functions::set_response_bad(*response, "Failed to get value");
BOOST_FOREACH(const value_list_type::value_type &v, values) {
boost::shared_ptr<filter_obj> record(new filter_obj(vc.first, v.first, v.second));
modern_filter::match_result ret = filter.match(record);
if (ret.is_done) {
break;
}
}
} catch (const PDH::pdh_exception &e) {
NSC_LOG_ERROR_EXR("ERROR", e);
return nscapi::protobuf::functions::set_response_bad(*response, "Failed to get value: " + utf8::utf8_from_native(e.what()));
}
}
BOOST_FOREACH(PDH::pdh_instance &instance, free_counters) {
try {
if (expand_instance) {
BOOST_FOREACH(const PDH::pdh_instance &child, instance->get_instances()) {
boost::shared_ptr<filter_obj> record(new filter_obj(child->get_name(), child->get_counter(), child->get_int_value()));
modern_filter::match_result ret = filter.match(record);
if (ret.is_done)
break;
}
} else {
boost::shared_ptr<filter_obj> record(new filter_obj(instance->get_name(), instance->get_counter(), instance->get_int_value()));
modern_filter::match_result ret = filter.match(record);
if (ret.is_done)
break;
}
} catch (const PDH::pdh_exception &e) {
list_t filter(list_t list, bool (*fn)(int)) {
return filter_helper(reverse(list), fn, list_make());
}
static list_t filter_helper(list_t list, bool (*fn)(int), list_t filteredList) {
if (list_isEmpty(list)) return filteredList;
if (fn(list_first(list))) return filter_helper(list_rest(list),
fn, list_make(list_first(list), filteredList));
return filter_helper(list_rest(list), fn, filteredList);
}
void CheckLogFile::check_logfile(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
typedef logfile_filter::filter filter_type;
modern_filter::data_container data;
modern_filter::cli_helper<filter_type> filter_helper(request, response, data);
std::string regexp, line_split, column_split;
std::vector<std::string> file_list;
std::string files_string;
std::string mode;
filter_type filter;
filter_helper.add_options(filter.get_filter_syntax());
filter_helper.add_syntax("${count}/${total} (${problem_list})", filter.get_format_syntax(), "${column1}", "${column1}");
filter_helper.get_desc().add_options()
// ("regexp", po::value<std::string>(®exp), "Lookup a numeric value in the PDH index table")
("line-split", po::value<std::string>(&line_split)->default_value("\\n"),
"Character string used to split a file into several lines (default \\n)")
("column-split", po::value<std::string>(&column_split)->default_value("\\t"),
"Character string to split a line into several columns (default \\t)")
("split", po::value<std::string>(&column_split), "Alias for split-column")
("file", po::value<std::vector<std::string> >(&file_list), "File to read (can be specified multiple times to check multiple files.\n"
"Notice that specifying multiple files will create an aggregate set it will not check each file individually.\n"
"In other words if one file contains an error the entire check will result in error or if you check the count it is the global count which is used.")
("files", po::value<std::string>(&files_string), "A comma separated list of files to scan (same as file except a list)")
// ("mode", po::value<std::string>(&mode), "Mode of operation: count (count all critical/warning lines), find (find first critical/warning line)")
;
if (!files_string.empty())
boost::split(file_list, files_string, boost::is_any_of(","));
if (!filter_helper.parse_options())
return;
if (column_split.empty())
return nscapi::protobuf::functions::set_response_bad(*response, "No column-split specified");
if (line_split.empty())
return nscapi::protobuf::functions::set_response_bad(*response, "No line-split specified");
if (file_list.empty())
return nscapi::protobuf::functions::set_response_bad(*response, "Need to specify at least one file: file=foo.txt");
strEx::replace(column_split, "\\t", "\t");
strEx::replace(column_split, "\\n", "\n");
strEx::replace(line_split, "\\t", "\t");
strEx::replace(line_split, "\\n", "\n");
if (!filter_helper.build_filter(filter))
return;
BOOST_FOREACH(const std::string &filename, file_list) {
std::ifstream file(filename.c_str());
if (file.is_open()) {
std::string line;
while (file.good()) {
std::getline(file,line, '\n');
std::list<std::string> chunks = strEx::s::splitEx(line, column_split);
boost::shared_ptr<logfile_filter::filter_obj> record(new logfile_filter::filter_obj(filename, line, chunks));
modern_filter::match_result ret = filter.match(record);
if (ret.is_done) {
break;
}
}
file.close();
} else {
return nscapi::protobuf::functions::set_response_bad(*response, "Failed to open file: " + filename);
}
}
