From 56ae875861ab260b80a030f50c4aff9f9dc8fff0 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 13 Apr 2024 13:32:39 +0200 Subject: Adding upstream version 2.14.2. Signed-off-by: Daniel Baumann --- lib/compat/CMakeLists.txt | 38 ++ lib/compat/compatlogger.cpp | 614 +++++++++++++++++++++++++++++++++ lib/compat/compatlogger.hpp | 60 ++++ lib/compat/compatlogger.ti | 23 ++ lib/compat/externalcommandlistener.cpp | 150 ++++++++ lib/compat/externalcommandlistener.hpp | 41 +++ lib/compat/externalcommandlistener.ti | 20 ++ 7 files changed, 946 insertions(+) create mode 100644 lib/compat/CMakeLists.txt create mode 100644 lib/compat/compatlogger.cpp create mode 100644 lib/compat/compatlogger.hpp create mode 100644 lib/compat/compatlogger.ti create mode 100644 lib/compat/externalcommandlistener.cpp create mode 100644 lib/compat/externalcommandlistener.hpp create mode 100644 lib/compat/externalcommandlistener.ti (limited to 'lib/compat') diff --git a/lib/compat/CMakeLists.txt b/lib/compat/CMakeLists.txt new file mode 100644 index 0000000..f7d032f --- /dev/null +++ b/lib/compat/CMakeLists.txt @@ -0,0 +1,38 @@ +# Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ + +mkclass_target(compatlogger.ti compatlogger-ti.cpp compatlogger-ti.hpp) +mkclass_target(externalcommandlistener.ti externalcommandlistener-ti.cpp externalcommandlistener-ti.hpp) + +set(compat_SOURCES + compatlogger.cpp compatlogger.hpp compatlogger-ti.hpp + externalcommandlistener.cpp externalcommandlistener.hpp externalcommandlistener-ti.hpp +) + +if(ICINGA2_UNITY_BUILD) + mkunity_target(compat compat compat_SOURCES) +endif() + +add_library(compat OBJECT ${compat_SOURCES}) + +add_dependencies(compat base config icinga) + +set_target_properties ( + compat PROPERTIES + FOLDER Components +) + +install_if_not_exists( + ${PROJECT_SOURCE_DIR}/etc/icinga2/features-available/command.conf + ${ICINGA2_CONFIGDIR}/features-available +) + +install_if_not_exists( + ${PROJECT_SOURCE_DIR}/etc/icinga2/features-available/compatlog.conf + ${ICINGA2_CONFIGDIR}/features-available +) + +install(CODE "file(MAKE_DIRECTORY \"\$ENV{DESTDIR}${ICINGA2_FULL_LOGDIR}/compat/archives\")") +install(CODE "file(MAKE_DIRECTORY \"\$ENV{DESTDIR}${ICINGA2_FULL_SPOOLDIR}\")") +install(CODE "file(MAKE_DIRECTORY \"\$ENV{DESTDIR}${ICINGA2_FULL_INITRUNDIR}/cmd\")") + +set(CPACK_NSIS_EXTRA_INSTALL_COMMANDS "${CPACK_NSIS_EXTRA_INSTALL_COMMANDS}" PARENT_SCOPE) diff --git a/lib/compat/compatlogger.cpp b/lib/compat/compatlogger.cpp new file mode 100644 index 0000000..95ca830 --- /dev/null +++ b/lib/compat/compatlogger.cpp @@ -0,0 +1,614 @@ +/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */ + +#include "compat/compatlogger.hpp" +#include "compat/compatlogger-ti.cpp" +#include "icinga/service.hpp" +#include "icinga/checkcommand.hpp" +#include "icinga/eventcommand.hpp" +#include "icinga/notification.hpp" +#include "icinga/macroprocessor.hpp" +#include "icinga/externalcommandprocessor.hpp" +#include "icinga/compatutility.hpp" +#include "base/configtype.hpp" +#include "base/objectlock.hpp" +#include "base/logger.hpp" +#include "base/exception.hpp" +#include "base/convert.hpp" +#include "base/application.hpp" +#include "base/utility.hpp" +#include "base/statsfunction.hpp" +#include + +using namespace icinga; + +REGISTER_TYPE(CompatLogger); + +REGISTER_STATSFUNCTION(CompatLogger, &CompatLogger::StatsFunc); + +void CompatLogger::StatsFunc(const Dictionary::Ptr& status, const Array::Ptr&) +{ + DictionaryData nodes; + + for (const CompatLogger::Ptr& compat_logger : ConfigType::GetObjectsByType()) { + nodes.emplace_back(compat_logger->GetName(), 1); // add more stats + } + + status->Set("compatlogger", new Dictionary(std::move(nodes))); +} + +/** + * @threadsafety Always. + */ +void CompatLogger::Start(bool runtimeCreated) +{ + ObjectImpl::Start(runtimeCreated); + + Log(LogInformation, "CompatLogger") + << "'" << GetName() << "' started."; + + Log(LogWarning, "CompatLogger") + << "This feature is DEPRECATED and may be removed in future releases. Check the roadmap at https://github.com/Icinga/icinga2/milestones"; + + Checkable::OnNewCheckResult.connect([this](const Checkable::Ptr& checkable, const CheckResult::Ptr& cr, const MessageOrigin::Ptr&) { + CheckResultHandler(checkable, cr); + }); + Checkable::OnNotificationSentToUser.connect([this](const Notification::Ptr& notification, const Checkable::Ptr& checkable, + const User::Ptr& user, const NotificationType& type, const CheckResult::Ptr& cr, const String& author, + const String& commentText, const String& commandName, const MessageOrigin::Ptr&) { + NotificationSentHandler(notification, checkable, user, type, cr, author, commentText, commandName); + }); + + Downtime::OnDowntimeTriggered.connect([this](const Downtime::Ptr& downtime) { TriggerDowntimeHandler(downtime); }); + Downtime::OnDowntimeRemoved.connect([this](const Downtime::Ptr& downtime) { RemoveDowntimeHandler(downtime); }); + Checkable::OnEventCommandExecuted.connect([this](const Checkable::Ptr& checkable) { EventCommandHandler(checkable); }); + + Checkable::OnFlappingChanged.connect([this](const Checkable::Ptr& checkable, const Value&) { FlappingChangedHandler(checkable); }); + Checkable::OnEnableFlappingChanged.connect([this](const Checkable::Ptr& checkable, const Value&) { EnableFlappingChangedHandler(checkable); }); + + ExternalCommandProcessor::OnNewExternalCommand.connect([this](double, const String& command, const std::vector& arguments) { + ExternalCommandHandler(command, arguments); + }); + + m_RotationTimer = Timer::Create(); + m_RotationTimer->OnTimerExpired.connect([this](const Timer * const&) { RotationTimerHandler(); }); + m_RotationTimer->Start(); + + ReopenFile(false); + ScheduleNextRotation(); +} + +/** + * @threadsafety Always. + */ +void CompatLogger::Stop(bool runtimeRemoved) +{ + m_RotationTimer->Stop(true); + + Log(LogInformation, "CompatLogger") + << "'" << GetName() << "' stopped."; + + ObjectImpl::Stop(runtimeRemoved); +} + +/** + * @threadsafety Always. + */ +void CompatLogger::CheckResultHandler(const Checkable::Ptr& checkable, const CheckResult::Ptr &cr) +{ + Host::Ptr host; + Service::Ptr service; + tie(host, service) = GetHostService(checkable); + + Dictionary::Ptr vars_after = cr->GetVarsAfter(); + + long state_after = vars_after->Get("state"); + long stateType_after = vars_after->Get("state_type"); + long attempt_after = vars_after->Get("attempt"); + bool reachable_after = vars_after->Get("reachable"); + + Dictionary::Ptr vars_before = cr->GetVarsBefore(); + + if (vars_before) { + long state_before = vars_before->Get("state"); + long stateType_before = vars_before->Get("state_type"); + long attempt_before = vars_before->Get("attempt"); + bool reachable_before = vars_before->Get("reachable"); + + if (state_before == state_after && stateType_before == stateType_after && + attempt_before == attempt_after && reachable_before == reachable_after) + return; /* Nothing changed, ignore this checkresult. */ + } + + String output; + if (cr) + output = CompatUtility::GetCheckResultOutput(cr); + + std::ostringstream msgbuf; + + if (service) { + msgbuf << "SERVICE ALERT: " + << host->GetName() << ";" + << service->GetShortName() << ";" + << Service::StateToString(service->GetState()) << ";" + << Service::StateTypeToString(service->GetStateType()) << ";" + << attempt_after << ";" + << output << "" + << ""; + } else { + String state = Host::StateToString(Host::CalculateState(static_cast(state_after))); + + msgbuf << "HOST ALERT: " + << host->GetName() << ";" + << GetHostStateString(host) << ";" + << Host::StateTypeToString(host->GetStateType()) << ";" + << attempt_after << ";" + << output << "" + << ""; + + } + + { + ObjectLock olock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +/** + * @threadsafety Always. + */ +void CompatLogger::TriggerDowntimeHandler(const Downtime::Ptr& downtime) +{ + Host::Ptr host; + Service::Ptr service; + tie(host, service) = GetHostService(downtime->GetCheckable()); + + if (!downtime) + return; + + std::ostringstream msgbuf; + + if (service) { + msgbuf << "SERVICE DOWNTIME ALERT: " + << host->GetName() << ";" + << service->GetShortName() << ";" + << "STARTED" << "; " + << "Checkable has entered a period of scheduled downtime." + << ""; + } else { + msgbuf << "HOST DOWNTIME ALERT: " + << host->GetName() << ";" + << "STARTED" << "; " + << "Checkable has entered a period of scheduled downtime." + << ""; + } + + { + ObjectLock oLock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +/** + * @threadsafety Always. + */ +void CompatLogger::RemoveDowntimeHandler(const Downtime::Ptr& downtime) +{ + Host::Ptr host; + Service::Ptr service; + tie(host, service) = GetHostService(downtime->GetCheckable()); + + if (!downtime) + return; + + String downtime_output; + String downtime_state_str; + + if (downtime->GetWasCancelled()) { + downtime_output = "Scheduled downtime for service has been cancelled."; + downtime_state_str = "CANCELLED"; + } else { + downtime_output = "Checkable has exited from a period of scheduled downtime."; + downtime_state_str = "STOPPED"; + } + + std::ostringstream msgbuf; + + if (service) { + msgbuf << "SERVICE DOWNTIME ALERT: " + << host->GetName() << ";" + << service->GetShortName() << ";" + << downtime_state_str << "; " + << downtime_output + << ""; + } else { + msgbuf << "HOST DOWNTIME ALERT: " + << host->GetName() << ";" + << downtime_state_str << "; " + << downtime_output + << ""; + } + + { + ObjectLock oLock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +/** + * @threadsafety Always. + */ +void CompatLogger::NotificationSentHandler(const Notification::Ptr& notification, const Checkable::Ptr& checkable, + const User::Ptr& user, NotificationType notification_type, CheckResult::Ptr const& cr, + const String& author, const String& comment_text, const String& command_name) +{ + Host::Ptr host; + Service::Ptr service; + tie(host, service) = GetHostService(checkable); + + String notification_type_str = Notification::NotificationTypeToStringCompat(notification_type); + + /* override problem notifications with their current state string */ + if (notification_type == NotificationProblem) { + if (service) + notification_type_str = Service::StateToString(service->GetState()); + else + notification_type_str = GetHostStateString(host); + } + + String author_comment = ""; + if (notification_type == NotificationCustom || notification_type == NotificationAcknowledgement) { + author_comment = author + ";" + comment_text; + } + + if (!cr) + return; + + String output; + if (cr) + output = CompatUtility::GetCheckResultOutput(cr); + + std::ostringstream msgbuf; + + if (service) { + msgbuf << "SERVICE NOTIFICATION: " + << user->GetName() << ";" + << host->GetName() << ";" + << service->GetShortName() << ";" + << notification_type_str << ";" + << command_name << ";" + << output << ";" + << author_comment + << ""; + } else { + msgbuf << "HOST NOTIFICATION: " + << user->GetName() << ";" + << host->GetName() << ";" + << notification_type_str << " " + << "(" << GetHostStateString(host) << ");" + << command_name << ";" + << output << ";" + << author_comment + << ""; + } + + { + ObjectLock oLock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +/** + * @threadsafety Always. + */ +void CompatLogger::FlappingChangedHandler(const Checkable::Ptr& checkable) +{ + Host::Ptr host; + Service::Ptr service; + tie(host, service) = GetHostService(checkable); + + String flapping_state_str; + String flapping_output; + + if (checkable->IsFlapping()) { + flapping_output = "Checkable appears to have started flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change >= " + Convert::ToString(checkable->GetFlappingThresholdHigh()) + "% threshold)"; + flapping_state_str = "STARTED"; + } else { + flapping_output = "Checkable appears to have stopped flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change < " + Convert::ToString(checkable->GetFlappingThresholdLow()) + "% threshold)"; + flapping_state_str = "STOPPED"; + } + + std::ostringstream msgbuf; + + if (service) { + msgbuf << "SERVICE FLAPPING ALERT: " + << host->GetName() << ";" + << service->GetShortName() << ";" + << flapping_state_str << "; " + << flapping_output + << ""; + } else { + msgbuf << "HOST FLAPPING ALERT: " + << host->GetName() << ";" + << flapping_state_str << "; " + << flapping_output + << ""; + } + + { + ObjectLock oLock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +void CompatLogger::EnableFlappingChangedHandler(const Checkable::Ptr& checkable) +{ + Host::Ptr host; + Service::Ptr service; + tie(host, service) = GetHostService(checkable); + + if (checkable->GetEnableFlapping()) + return; + + String flapping_output = "Flap detection has been disabled"; + String flapping_state_str = "DISABLED"; + + std::ostringstream msgbuf; + + if (service) { + msgbuf << "SERVICE FLAPPING ALERT: " + << host->GetName() << ";" + << service->GetShortName() << ";" + << flapping_state_str << "; " + << flapping_output + << ""; + } else { + msgbuf << "HOST FLAPPING ALERT: " + << host->GetName() << ";" + << flapping_state_str << "; " + << flapping_output + << ""; + } + + { + ObjectLock oLock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +void CompatLogger::ExternalCommandHandler(const String& command, const std::vector& arguments) +{ + std::ostringstream msgbuf; + msgbuf << "EXTERNAL COMMAND: " + << command << ";" + << boost::algorithm::join(arguments, ";") + << ""; + + { + ObjectLock oLock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +void CompatLogger::EventCommandHandler(const Checkable::Ptr& checkable) +{ + Host::Ptr host; + Service::Ptr service; + tie(host, service) = GetHostService(checkable); + + EventCommand::Ptr event_command = checkable->GetEventCommand(); + String event_command_name = event_command->GetName(); + long current_attempt = checkable->GetCheckAttempt(); + + std::ostringstream msgbuf; + + if (service) { + msgbuf << "SERVICE EVENT HANDLER: " + << host->GetName() << ";" + << service->GetShortName() << ";" + << Service::StateToString(service->GetState()) << ";" + << Service::StateTypeToString(service->GetStateType()) << ";" + << current_attempt << ";" + << event_command_name; + } else { + msgbuf << "HOST EVENT HANDLER: " + << host->GetName() << ";" + << GetHostStateString(host) << ";" + << Host::StateTypeToString(host->GetStateType()) << ";" + << current_attempt << ";" + << event_command_name; + } + + { + ObjectLock oLock(this); + WriteLine(msgbuf.str()); + Flush(); + } +} + +String CompatLogger::GetHostStateString(const Host::Ptr& host) +{ + if (host->GetState() != HostUp && !host->IsReachable()) + return "UNREACHABLE"; /* hardcoded compat state */ + + return Host::StateToString(host->GetState()); +} + +void CompatLogger::WriteLine(const String& line) +{ + ASSERT(OwnsLock()); + + if (!m_OutputFile.good()) + return; + + m_OutputFile << "[" << (long)Utility::GetTime() << "] " << line << "\n"; +} + +void CompatLogger::Flush() +{ + ASSERT(OwnsLock()); + + if (!m_OutputFile.good()) + return; + + m_OutputFile << std::flush; +} + +/** + * @threadsafety Always. + */ +void CompatLogger::ReopenFile(bool rotate) +{ + ObjectLock olock(this); + + String tempFile = GetLogDir() + "/icinga.log"; + + if (m_OutputFile) { + m_OutputFile.close(); + + if (rotate) { + String archiveFile = GetLogDir() + "/archives/icinga-" + Utility::FormatDateTime("%m-%d-%Y-%H", Utility::GetTime()) + ".log"; + + Log(LogNotice, "CompatLogger") + << "Rotating compat log file '" << tempFile << "' -> '" << archiveFile << "'"; + + (void) rename(tempFile.CStr(), archiveFile.CStr()); + } + } + + m_OutputFile.open(tempFile.CStr(), std::ofstream::app); + + if (!m_OutputFile) { + Log(LogWarning, "CompatLogger") + << "Could not open compat log file '" << tempFile << "' for writing. Log output will be lost."; + + return; + } + + WriteLine("LOG ROTATION: " + GetRotationMethod()); + WriteLine("LOG VERSION: 2.0"); + + for (const Host::Ptr& host : ConfigType::GetObjectsByType()) { + String output; + CheckResult::Ptr cr = host->GetLastCheckResult(); + + if (cr) + output = CompatUtility::GetCheckResultOutput(cr); + + std::ostringstream msgbuf; + msgbuf << "CURRENT HOST STATE: " + << host->GetName() << ";" + << GetHostStateString(host) << ";" + << Host::StateTypeToString(host->GetStateType()) << ";" + << host->GetCheckAttempt() << ";" + << output << ""; + + WriteLine(msgbuf.str()); + } + + for (const Service::Ptr& service : ConfigType::GetObjectsByType()) { + Host::Ptr host = service->GetHost(); + + String output; + CheckResult::Ptr cr = service->GetLastCheckResult(); + + if (cr) + output = CompatUtility::GetCheckResultOutput(cr); + + std::ostringstream msgbuf; + msgbuf << "CURRENT SERVICE STATE: " + << host->GetName() << ";" + << service->GetShortName() << ";" + << Service::StateToString(service->GetState()) << ";" + << Service::StateTypeToString(service->GetStateType()) << ";" + << service->GetCheckAttempt() << ";" + << output << ""; + + WriteLine(msgbuf.str()); + } + + Flush(); +} + +void CompatLogger::ScheduleNextRotation() +{ + auto now = (time_t)Utility::GetTime(); + String method = GetRotationMethod(); + + tm tmthen; + +#ifdef _MSC_VER + tm *temp = localtime(&now); + + if (!temp) { + BOOST_THROW_EXCEPTION(posix_error() + << boost::errinfo_api_function("localtime") + << boost::errinfo_errno(errno)); + } + + tmthen = *temp; +#else /* _MSC_VER */ + if (!localtime_r(&now, &tmthen)) { + BOOST_THROW_EXCEPTION(posix_error() + << boost::errinfo_api_function("localtime_r") + << boost::errinfo_errno(errno)); + } +#endif /* _MSC_VER */ + + tmthen.tm_min = 0; + tmthen.tm_sec = 0; + + if (method == "HOURLY") { + tmthen.tm_hour++; + } else if (method == "DAILY") { + tmthen.tm_mday++; + tmthen.tm_hour = 0; + } else if (method == "WEEKLY") { + tmthen.tm_mday += 7 - tmthen.tm_wday; + tmthen.tm_hour = 0; + } else if (method == "MONTHLY") { + tmthen.tm_mon++; + tmthen.tm_mday = 1; + tmthen.tm_hour = 0; + } + + time_t ts = mktime(&tmthen); + + Log(LogNotice, "CompatLogger") + << "Rescheduling rotation timer for compat log '" + << GetName() << "' to '" << Utility::FormatDateTime("%Y/%m/%d %H:%M:%S %z", ts) << "'"; + + m_RotationTimer->Reschedule(ts); +} + +/** + * @threadsafety Always. + */ +void CompatLogger::RotationTimerHandler() +{ + try { + ReopenFile(true); + } catch (...) { + ScheduleNextRotation(); + + throw; + } + + ScheduleNextRotation(); +} + +void CompatLogger::ValidateRotationMethod(const Lazy& lvalue, const ValidationUtils& utils) +{ + ObjectImpl::ValidateRotationMethod(lvalue, utils); + + if (lvalue() != "HOURLY" && lvalue() != "DAILY" && + lvalue() != "WEEKLY" && lvalue() != "MONTHLY" && lvalue() != "NONE") { + BOOST_THROW_EXCEPTION(ValidationError(this, { "rotation_method" }, "Rotation method '" + lvalue() + "' is invalid.")); + } +} diff --git a/lib/compat/compatlogger.hpp b/lib/compat/compatlogger.hpp new file mode 100644 index 0000000..9fb0b29 --- /dev/null +++ b/lib/compat/compatlogger.hpp @@ -0,0 +1,60 @@ +/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */ + +#ifndef COMPATLOGGER_H +#define COMPATLOGGER_H + +#include "compat/compatlogger-ti.hpp" +#include "icinga/service.hpp" +#include "base/timer.hpp" +#include + +namespace icinga +{ + +/** + * An Icinga compat log writer. + * + * @ingroup compat + */ +class CompatLogger final : public ObjectImpl +{ +public: + DECLARE_OBJECT(CompatLogger); + DECLARE_OBJECTNAME(CompatLogger); + + static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata); + + void ValidateRotationMethod(const Lazy& lvalue, const ValidationUtils& utils) override; + +protected: + void Start(bool runtimeCreated) override; + void Stop(bool runtimeRemoved) override; + +private: + void WriteLine(const String& line); + void Flush(); + + void CheckResultHandler(const Checkable::Ptr& service, const CheckResult::Ptr& cr); + void NotificationSentHandler(const Notification::Ptr& notification, const Checkable::Ptr& service, + const User::Ptr& user, NotificationType notification_type, CheckResult::Ptr const& cr, + const String& author, const String& comment_text, const String& command_name); + void FlappingChangedHandler(const Checkable::Ptr& checkable); + void EnableFlappingChangedHandler(const Checkable::Ptr& checkable); + void TriggerDowntimeHandler(const Downtime::Ptr& downtime); + void RemoveDowntimeHandler(const Downtime::Ptr& downtime); + void ExternalCommandHandler(const String& command, const std::vector& arguments); + void EventCommandHandler(const Checkable::Ptr& service); + + static String GetHostStateString(const Host::Ptr& host); + + Timer::Ptr m_RotationTimer; + void RotationTimerHandler(); + void ScheduleNextRotation(); + + std::ofstream m_OutputFile; + void ReopenFile(bool rotate); +}; + +} + +#endif /* COMPATLOGGER_H */ diff --git a/lib/compat/compatlogger.ti b/lib/compat/compatlogger.ti new file mode 100644 index 0000000..56431ec --- /dev/null +++ b/lib/compat/compatlogger.ti @@ -0,0 +1,23 @@ +/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */ + +#include "base/configobject.hpp" +#include "base/application.hpp" + +library compat; + +namespace icinga +{ + +class CompatLogger : ConfigObject +{ + activation_priority 100; + + [config] String log_dir { + default {{{ return Configuration::LogDir + "/compat"; }}} + }; + [config] String rotation_method { + default {{{ return "HOURLY"; }}} + }; +}; + +} diff --git a/lib/compat/externalcommandlistener.cpp b/lib/compat/externalcommandlistener.cpp new file mode 100644 index 0000000..b61813b --- /dev/null +++ b/lib/compat/externalcommandlistener.cpp @@ -0,0 +1,150 @@ +/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */ + +#include "compat/externalcommandlistener.hpp" +#include "compat/externalcommandlistener-ti.cpp" +#include "icinga/externalcommandprocessor.hpp" +#include "base/configtype.hpp" +#include "base/logger.hpp" +#include "base/exception.hpp" +#include "base/application.hpp" +#include "base/statsfunction.hpp" + +using namespace icinga; + +REGISTER_TYPE(ExternalCommandListener); + +REGISTER_STATSFUNCTION(ExternalCommandListener, &ExternalCommandListener::StatsFunc); + +void ExternalCommandListener::StatsFunc(const Dictionary::Ptr& status, const Array::Ptr&) +{ + DictionaryData nodes; + + for (const ExternalCommandListener::Ptr& externalcommandlistener : ConfigType::GetObjectsByType()) { + nodes.emplace_back(externalcommandlistener->GetName(), 1); //add more stats + } + + status->Set("externalcommandlistener", new Dictionary(std::move(nodes))); +} + +/** + * Starts the component. + */ +void ExternalCommandListener::Start(bool runtimeCreated) +{ + ObjectImpl::Start(runtimeCreated); + + Log(LogInformation, "ExternalCommandListener") + << "'" << GetName() << "' started."; + + Log(LogWarning, "ExternalCommandListener") + << "This feature is DEPRECATED and may be removed in future releases. Check the roadmap at https://github.com/Icinga/icinga2/milestones"; +#ifndef _WIN32 + String path = GetCommandPath(); + m_CommandThread = std::thread([this, path]() { CommandPipeThread(path); }); + m_CommandThread.detach(); +#endif /* _WIN32 */ +} + +/** + * Stops the component. + */ +void ExternalCommandListener::Stop(bool runtimeRemoved) +{ + Log(LogInformation, "ExternalCommandListener") + << "'" << GetName() << "' stopped."; + + ObjectImpl::Stop(runtimeRemoved); +} + +#ifndef _WIN32 +void ExternalCommandListener::CommandPipeThread(const String& commandPath) +{ + Utility::SetThreadName("Command Pipe"); + + struct stat statbuf; + bool fifo_ok = false; + + if (lstat(commandPath.CStr(), &statbuf) >= 0) { + if (S_ISFIFO(statbuf.st_mode) && access(commandPath.CStr(), R_OK) >= 0) { + fifo_ok = true; + } else { + Utility::Remove(commandPath); + } + } + + mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP; + + if (!fifo_ok && mkfifo(commandPath.CStr(), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) < 0) { + Log(LogCritical, "ExternalCommandListener") + << "mkfifo() for fifo path '" << commandPath << "' failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\""; + return; + } + + /* mkfifo() uses umask to mask off some bits, which means we need to chmod() the + * fifo to get the right mask. */ + if (chmod(commandPath.CStr(), mode) < 0) { + Log(LogCritical, "ExternalCommandListener") + << "chmod() on fifo '" << commandPath << "' failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\""; + return; + } + + for (;;) { + int fd = open(commandPath.CStr(), O_RDWR | O_NONBLOCK); + + if (fd < 0) { + Log(LogCritical, "ExternalCommandListener") + << "open() for fifo path '" << commandPath << "' failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\""; + return; + } + + FIFO::Ptr fifo = new FIFO(); + Socket::Ptr sock = new Socket(fd); + StreamReadContext src; + + for (;;) { + sock->Poll(true, false); + + char buffer[8192]; + size_t rc; + + try { + rc = sock->Read(buffer, sizeof(buffer)); + } catch (const std::exception& ex) { + /* We have read all data. */ + if (errno == EAGAIN) + continue; + + Log(LogWarning, "ExternalCommandListener") + << "Cannot read from command pipe." << DiagnosticInformation(ex); + break; + } + + /* Empty pipe (EOF) */ + if (rc == 0) + continue; + + fifo->Write(buffer, rc); + + for (;;) { + String command; + StreamReadStatus srs = fifo->ReadLine(&command, src); + + if (srs != StatusNewItem) + break; + + try { + Log(LogInformation, "ExternalCommandListener") + << "Executing external command: " << command; + + ExternalCommandProcessor::Execute(command); + } catch (const std::exception& ex) { + Log(LogWarning, "ExternalCommandListener") + << "External command failed: " << DiagnosticInformation(ex, false); + Log(LogNotice, "ExternalCommandListener") + << "External command failed: " << DiagnosticInformation(ex, true); + } + } + } + } +} +#endif /* _WIN32 */ diff --git a/lib/compat/externalcommandlistener.hpp b/lib/compat/externalcommandlistener.hpp new file mode 100644 index 0000000..895531f --- /dev/null +++ b/lib/compat/externalcommandlistener.hpp @@ -0,0 +1,41 @@ +/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */ + +#ifndef EXTERNALCOMMANDLISTENER_H +#define EXTERNALCOMMANDLISTENER_H + +#include "compat/externalcommandlistener-ti.hpp" +#include "base/objectlock.hpp" +#include "base/timer.hpp" +#include "base/utility.hpp" +#include +#include + +namespace icinga +{ + +/** + * @ingroup compat + */ +class ExternalCommandListener final : public ObjectImpl +{ +public: + DECLARE_OBJECT(ExternalCommandListener); + DECLARE_OBJECTNAME(ExternalCommandListener); + + static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata); + +protected: + void Start(bool runtimeCreated) override; + void Stop(bool runtimeRemoved) override; + +private: +#ifndef _WIN32 + std::thread m_CommandThread; + + void CommandPipeThread(const String& commandPath); +#endif /* _WIN32 */ +}; + +} + +#endif /* EXTERNALCOMMANDLISTENER_H */ diff --git a/lib/compat/externalcommandlistener.ti b/lib/compat/externalcommandlistener.ti new file mode 100644 index 0000000..5b52944 --- /dev/null +++ b/lib/compat/externalcommandlistener.ti @@ -0,0 +1,20 @@ +/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */ + +#include "base/configobject.hpp" +#include "base/application.hpp" + +library compat; + +namespace icinga +{ + +class ExternalCommandListener : ConfigObject +{ + activation_priority 100; + + [config] String command_path { + default {{{ return Configuration::InitRunDir + "/cmd/icinga2.cmd"; }}} + }; +}; + +} -- cgit v1.2.3