double CompatUtility::GetCheckableStaleness(const Checkable::Ptr& checkable)
{
if (checkable->HasBeenChecked() && checkable->GetLastCheck() > 0)
return (Utility::GetTime() - checkable->GetLastCheck()) / (checkable->GetCheckInterval() * 3600);
return 0.0;
}
Dictionary::Ptr ApiActions::ProcessCheckResult(const ConfigObject::Ptr& object,
const Dictionary::Ptr& params)
{
Checkable::Ptr checkable = static_pointer_cast<Checkable>(object);
if (!checkable)
return ApiActions::CreateResult(404,
"Cannot process passive check result for non-existent object.");
if (!checkable->GetEnablePassiveChecks())
return ApiActions::CreateResult(403, "Passive checks are disabled for object '" + checkable->GetName() + "'.");
Host::Ptr host;
Service::Ptr service;
tie(host, service) = GetHostService(checkable);
if (!params->Contains("exit_status"))
return ApiActions::CreateResult(403, "Parameter 'exit_status' is required.");
int exitStatus = HttpUtility::GetLastParameter(params, "exit_status");
ServiceState state;
if (!service) {
if (exitStatus == 0)
state = ServiceOK;
else if (exitStatus == 1)
state = ServiceCritical;
else
return ApiActions::CreateResult(403, "Invalid 'exit_status' for Host "
+ checkable->GetName() + ".");
} else {
state = PluginUtility::ExitStatusToState(exitStatus);
}
if (!params->Contains("plugin_output"))
return ApiActions::CreateResult(403, "Parameter 'plugin_output' is required");
CheckResult::Ptr cr = new CheckResult();
cr->SetOutput(HttpUtility::GetLastParameter(params, "plugin_output"));
cr->SetState(state);
cr->SetCheckSource(HttpUtility::GetLastParameter(params, "check_source"));
cr->SetPerformanceData(params->Get("performance_data"));
cr->SetCommand(params->Get("check_command"));
checkable->ProcessCheckResult(cr);
/* Reschedule the next check. The side effect of this is that for as long
* as we receive passive results for a service we won't execute any
* active checks. */
checkable->SetNextCheck(Utility::GetTime() + checkable->GetCheckInterval());
return ApiActions::CreateResult(200, "Successfully processed check result for object '" + checkable->GetName() + "'.");
}
int CompatUtility::GetCheckableFreshnessThreshold(const Checkable::Ptr& checkable)
{
return static_cast<int>(checkable->GetCheckInterval());
}
int CompatUtility::GetCheckableFreshnessChecksEnabled(const Checkable::Ptr& checkable)
{
return (checkable->GetCheckInterval() > 0 ? 1 : 0);
}
double CompatUtility::GetCheckableCheckInterval(const Checkable::Ptr& checkable)
{
return checkable->GetCheckInterval() / 60.0;
}
void CheckResultReader::ProcessCheckResultFile(const String& path) const
{
CONTEXT("Processing check result file '" + path + "'");
String crfile = String(path.Begin(), path.End() - 3); /* Remove the ".ok" extension. */
std::ifstream fp;
fp.exceptions(std::ifstream::badbit);
fp.open(crfile.CStr());
std::map<String, String> attrs;
while (fp.good()) {
std::string line;
std::getline(fp, line);
if (line.empty() || line[0] == '#')
continue; /* Ignore comments and empty lines. */
size_t pos = line.find_first_of('=');
if (pos == std::string::npos)
continue; /* Ignore invalid lines. */
String key = line.substr(0, pos);
String value = line.substr(pos + 1);
attrs[key] = value;
}
/* Remove the checkresult files. */
if (unlink(path.CStr()) < 0)
BOOST_THROW_EXCEPTION(posix_error()
<< boost::errinfo_api_function("unlink")
<< boost::errinfo_errno(errno)
<< boost::errinfo_file_name(path));
if (unlink(crfile.CStr()) < 0)
BOOST_THROW_EXCEPTION(posix_error()
<< boost::errinfo_api_function("unlink")
<< boost::errinfo_errno(errno)
<< boost::errinfo_file_name(crfile));
Checkable::Ptr checkable;
Host::Ptr host = Host::GetByName(attrs["host_name"]);
if (!host) {
Log(LogWarning, "CheckResultReader")
<< "Ignoring checkresult file for host '" << attrs["host_name"] << "': Host does not exist.";
return;
}
if (attrs.find("service_description") != attrs.end()) {
Service::Ptr service = host->GetServiceByShortName(attrs["service_description"]);
if (!service) {
Log(LogWarning, "CheckResultReader")
<< "Ignoring checkresult file for host '" << attrs["host_name"]
<< "', service '" << attrs["service_description"] << "': Service does not exist.";
return;
}
checkable = service;
} else
checkable = host;
CheckResult::Ptr result = new CheckResult();
String output = CompatUtility::UnEscapeString(attrs["output"]);
std::pair<String, Value> co = PluginUtility::ParseCheckOutput(output);
result->SetOutput(co.first);
result->SetPerformanceData(PluginUtility::SplitPerfdata(co.second));
result->SetState(PluginUtility::ExitStatusToState(Convert::ToLong(attrs["return_code"])));
if (attrs.find("start_time") != attrs.end())
result->SetExecutionStart(Convert::ToDouble(attrs["start_time"]));
else
result->SetExecutionStart(Utility::GetTime());
if (attrs.find("finish_time") != attrs.end())
result->SetExecutionEnd(Convert::ToDouble(attrs["finish_time"]));
else
result->SetExecutionEnd(result->GetExecutionStart());
checkable->ProcessCheckResult(result);
Log(LogDebug, "CheckResultReader")
<< "Processed checkresult file for object '" << checkable->GetName() << "'";
/* Reschedule the next check. The side effect of this is that for as long
* as we receive check result files for a host/service we won't execute any
* active checks. */
checkable->SetNextCheck(Utility::GetTime() + checkable->GetCheckInterval());
}
void StatusDataWriter::DumpCheckableStatusAttrs(std::ostream& fp, const Checkable::Ptr& checkable)
{
CheckResult::Ptr cr = checkable->GetLastCheckResult();
EventCommand::Ptr eventcommand = checkable->GetEventCommand();
CheckCommand::Ptr checkcommand = checkable->GetCheckCommand();
fp << "\t" << "check_command=" << CompatUtility::GetCommandName(checkcommand) << "!" << CompatUtility::GetCheckableCommandArgs(checkable) << "\n"
"\t" "event_handler=" << CompatUtility::GetCommandName(eventcommand) << "\n"
"\t" "check_interval=" << (checkable->GetCheckInterval() / 60.0) << "\n"
"\t" "retry_interval=" << (checkable->GetRetryInterval() / 60.0) << "\n"
"\t" "has_been_checked=" << Convert::ToLong(checkable->HasBeenChecked()) << "\n"
"\t" "should_be_scheduled=" << checkable->GetEnableActiveChecks() << "\n"
"\t" "event_handler_enabled=" << Convert::ToLong(checkable->GetEnableEventHandler()) << "\n";
TimePeriod::Ptr checkPeriod = checkable->GetCheckPeriod();
if (checkPeriod)
fp << "\t" "check_period" "\t" << checkPeriod->GetName() << "\n";
if (cr) {
fp << "\t" << "check_execution_time=" << Convert::ToString(cr->CalculateExecutionTime()) << "\n"
"\t" "check_latency=" << Convert::ToString(cr->CalculateLatency()) << "\n";
}
Host::Ptr host;
Service::Ptr service;
tie(host, service) = GetHostService(checkable);
if (service) {
fp << "\t" "current_state=" << service->GetState() << "\n"
"\t" "last_hard_state=" << service->GetLastHardState() << "\n"
"\t" "last_time_ok=" << static_cast<int>(service->GetLastStateOK()) << "\n"
"\t" "last_time_warn=" << static_cast<int>(service->GetLastStateWarning()) << "\n"
"\t" "last_time_critical=" << static_cast<int>(service->GetLastStateCritical()) << "\n"
"\t" "last_time_unknown=" << static_cast<int>(service->GetLastStateUnknown()) << "\n";
} else {
int currentState = host->GetState();
if (currentState != HostUp && !host->IsReachable())
currentState = 2; /* hardcoded compat state */
fp << "\t" "current_state=" << currentState << "\n"
"\t" "last_hard_state=" << host->GetLastHardState() << "\n"
"\t" "last_time_up=" << static_cast<int>(host->GetLastStateUp()) << "\n"
"\t" "last_time_down=" << static_cast<int>(host->GetLastStateDown()) << "\n";
}
fp << "\t" "state_type=" << checkable->GetStateType() << "\n"
"\t" "last_check=" << static_cast<long>(host->GetLastCheck()) << "\n";
if (cr) {
fp << "\t" "plugin_output=" << CompatUtility::GetCheckResultOutput(cr) << "\n"
"\t" "long_plugin_output=" << CompatUtility::GetCheckResultLongOutput(cr) << "\n"
"\t" "performance_data=" << PluginUtility::FormatPerfdata(cr->GetPerformanceData()) << "\n";
}
fp << "\t" << "next_check=" << static_cast<long>(checkable->GetNextCheck()) << "\n"
"\t" "current_attempt=" << checkable->GetCheckAttempt() << "\n"
"\t" "max_attempts=" << checkable->GetMaxCheckAttempts() << "\n"
"\t" "last_state_change=" << static_cast<long>(checkable->GetLastStateChange()) << "\n"
"\t" "last_hard_state_change=" << static_cast<long>(checkable->GetLastHardStateChange()) << "\n"
"\t" "last_update=" << static_cast<long>(Utility::GetTime()) << "\n"
"\t" "notifications_enabled=" << Convert::ToLong(checkable->GetEnableNotifications()) << "\n"
"\t" "active_checks_enabled=" << Convert::ToLong(checkable->GetEnableActiveChecks()) << "\n"
"\t" "passive_checks_enabled=" << Convert::ToLong(checkable->GetEnablePassiveChecks()) << "\n"
"\t" "flap_detection_enabled=" << Convert::ToLong(checkable->GetEnableFlapping()) << "\n"
"\t" "is_flapping=" << Convert::ToLong(checkable->IsFlapping()) << "\n"
"\t" "percent_state_change=" << checkable->GetFlappingCurrent() << "\n"
"\t" "problem_has_been_acknowledged=" << (checkable->GetAcknowledgement() != AcknowledgementNone ? 1 : 0) << "\n"
"\t" "acknowledgement_type=" << checkable->GetAcknowledgement() << "\n"
"\t" "acknowledgement_end_time=" << checkable->GetAcknowledgementExpiry() << "\n"
"\t" "scheduled_downtime_depth=" << checkable->GetDowntimeDepth() << "\n"
"\t" "last_notification=" << CompatUtility::GetCheckableNotificationLastNotification(checkable) << "\n"
"\t" "next_notification=" << CompatUtility::GetCheckableNotificationNextNotification(checkable) << "\n"
"\t" "current_notification_number=" << CompatUtility::GetCheckableNotificationNotificationNumber(checkable) << "\n"
"\t" "is_reachable=" << Convert::ToLong(checkable->IsReachable()) << "\n";
}