Adding upstream version 2.14.2.upstream/2.14.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

7 files changed, 946 insertions, 0 deletions

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 <boost/algorithm/string.hpp>
+
+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<CompatLogger>()) {
+		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<CompatLogger>::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<String>& 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<CompatLogger>::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<ServiceState>(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<String>& 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<Host>()) {
+		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<Service>()) {
+		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<String>& lvalue, const ValidationUtils& utils)
+{
+	ObjectImpl<CompatLogger>::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 <fstream>
+
+namespace icinga
+{
+
+/**
+ * An Icinga compat log writer.
+ *
+ * @ingroup compat
+ */
+class CompatLogger final : public ObjectImpl<CompatLogger>
+{
+public:
+	DECLARE_OBJECT(CompatLogger);
+	DECLARE_OBJECTNAME(CompatLogger);
+
+	static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
+
+	void ValidateRotationMethod(const Lazy<String>& 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<String>& 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<ExternalCommandListener>()) {
+		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<ExternalCommandListener>::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<ExternalCommandListener>::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 <thread>
+#include <iostream>
+
+namespace icinga
+{
+
+/**
+ * @ingroup compat
+ */
+class ExternalCommandListener final : public ObjectImpl<ExternalCommandListener>
+{
+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"; }}}
+	};
+};
+
+}