tyler.durden
/
icinga2
mirror of https://github.com/Icinga/icinga2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

git ls-files -z |xargs -0 perl -pi -e 's/RedisWriter/IcingaDB/g'

This commit is contained in:
Alexander Aleksandrovič Klimov 2019-10-29 17:32:29 +01:00 committed by Michael Friedrich
parent c7e9997294
commit f51454af65
9 changed files with 129 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
etc/icinga2/features-available/redis.conf
View File

@ -7,7 +7,7 @@
library "redis"
object RedisWriter "redis" {
object IcingaDB "redis" {
//host = "127.0.0.1"
//port = 6379
//password = "xxx"

4
lib/icinga/compatutility.cpp
View File

@ -249,7 +249,7 @@ std::set<UserGroup::Ptr> CompatUtility::GetCheckableNotificationUserGroups(const
return usergroups;
}
/* Used in DB IDO, StatusDataWriter, Livestatus, CompatLogger, GelfWriter, RedisWriter. */
/* Used in DB IDO, StatusDataWriter, Livestatus, CompatLogger, GelfWriter, IcingaDB. */
String CompatUtility::GetCheckResultOutput(const CheckResult::Ptr& cr)
{
if (!cr)
@ -264,7 +264,7 @@ String CompatUtility::GetCheckResultOutput(const CheckResult::Ptr& cr)
return raw_output.SubStr(0, line_end);
}
/* Used in DB IDO, StatusDataWriter and Livestatus, RedisWriter. */
/* Used in DB IDO, StatusDataWriter and Livestatus, IcingaDB. */
String CompatUtility::GetCheckResultLongOutput(const CheckResult::Ptr& cr)
{
if (!cr)

26
lib/redis/redisconnection.cpp
View File

@ -88,7 +88,7 @@ void LogQuery(RedisConnection::Query& query, Log& msg)
void RedisConnection::FireAndForgetQuery(RedisConnection::Query query)
{
{
Log msg (LogNotice, "RedisWriter", "Firing and forgetting query:");
Log msg (LogNotice, "IcingaDB", "Firing and forgetting query:");
LogQuery(query, msg);
}
@ -103,7 +103,7 @@ void RedisConnection::FireAndForgetQuery(RedisConnection::Query query)
void RedisConnection::FireAndForgetQueries(RedisConnection::Queries queries)
{
for (auto& query : queries) {
Log msg (LogNotice, "RedisWriter", "Firing and forgetting query:");
Log msg (LogNotice, "IcingaDB", "Firing and forgetting query:");
LogQuery(query, msg);
}
@ -118,7 +118,7 @@ void RedisConnection::FireAndForgetQueries(RedisConnection::Queries queries)
RedisConnection::Reply RedisConnection::GetResultOfQuery(RedisConnection::Query query)
{
{
Log msg (LogNotice, "RedisWriter", "Executing query:");
Log msg (LogNotice, "IcingaDB", "Executing query:");
LogQuery(query, msg);
}
@ -139,7 +139,7 @@ RedisConnection::Reply RedisConnection::GetResultOfQuery(RedisConnection::Query
RedisConnection::Replies RedisConnection::GetResultsOfQueries(RedisConnection::Queries queries)
{
for (auto& query : queries) {
Log msg (LogNotice, "RedisWriter", "Executing query:");
Log msg (LogNotice, "IcingaDB", "Executing query:");
LogQuery(query, msg);
}
@ -161,7 +161,7 @@ void RedisConnection::Connect(asio::yield_context& yc)
{
Defer notConnecting ([this]() { m_Connecting.store(m_Connected.load()); });
Log(LogInformation, "RedisWriter", "Trying to connect to Redis server (async)");
Log(LogInformation, "IcingaDB", "Trying to connect to Redis server (async)");
try {
if (m_Path.IsEmpty()) {
@ -176,11 +176,11 @@ void RedisConnection::Connect(asio::yield_context& yc)
m_Connected.store(true);
Log(LogInformation, "RedisWriter", "Connected to Redis server");
Log(LogInformation, "IcingaDB", "Connected to Redis server");
} catch (const boost::coroutines::detail::forced_unwind&) {
throw;
} catch (const std::exception& ex) {
Log(LogCritical, "RedisWriter")
Log(LogCritical, "IcingaDB")
<< "Cannot connect to " << m_Host << ":" << m_Port << ": " << ex.what();
}
}
@ -203,11 +203,11 @@ void RedisConnection::ReadLoop(asio::yield_context& yc)
} catch (const boost::coroutines::detail::forced_unwind&) {
throw;
} catch (const std::exception& ex) {
Log(LogCritical, "RedisWriter")
Log(LogCritical, "IcingaDB")
<< "Error during receiving the response to a query which has been fired and forgotten: " << ex.what();
continue;
} catch (...) {
Log(LogCritical, "RedisWriter")
Log(LogCritical, "IcingaDB")
<< "Error during receiving the response to a query which has been fired and forgotten";
continue;
}
@ -276,12 +276,12 @@ void RedisConnection::WriteLoop(asio::yield_context& yc)
} catch (const boost::coroutines::detail::forced_unwind&) {
throw;
} catch (const std::exception& ex) {
Log msg (LogCritical, "RedisWriter", "Error during sending query");
Log msg (LogCritical, "IcingaDB", "Error during sending query");
LogQuery(item, msg);
msg << " which has been fired and forgotten: " << ex.what();
continue;
} catch (...) {
Log msg (LogCritical, "RedisWriter", "Error during sending query");
Log msg (LogCritical, "IcingaDB", "Error during sending query");
LogQuery(item, msg);
msg << " which has been fired and forgotten";
continue;
@ -308,12 +308,12 @@ void RedisConnection::WriteLoop(asio::yield_context& yc)
} catch (const boost::coroutines::detail::forced_unwind&) {
throw;
} catch (const std::exception& ex) {
Log msg (LogCritical, "RedisWriter", "Error during sending query");
Log msg (LogCritical, "IcingaDB", "Error during sending query");
LogQuery(item[i], msg);
msg << " which has been fired and forgotten: " << ex.what();
continue;
} catch (...) {
Log msg (LogCritical, "RedisWriter", "Error during sending query");
Log msg (LogCritical, "IcingaDB", "Error during sending query");
LogQuery(item[i], msg);
msg << " which has been fired and forgotten";
continue;

120
lib/redis/rediswriter-objects.cpp
View File

@ -65,49 +65,49 @@ return id
)EOF";
INITIALIZE_ONCE(&RedisWriter::ConfigStaticInitialize);
INITIALIZE_ONCE(&IcingaDB::ConfigStaticInitialize);
void RedisWriter::ConfigStaticInitialize()
void IcingaDB::ConfigStaticInitialize()
{
/* triggered in ProcessCheckResult(), requires UpdateNextCheck() to be called before */
Checkable::OnStateChange.connect([](const Checkable::Ptr& checkable, const CheckResult::Ptr& cr, StateType type, const MessageOrigin::Ptr&) {
RedisWriter::StateChangeHandler(checkable, cr, type);
IcingaDB::StateChangeHandler(checkable, cr, type);
});
/* triggered when acknowledged host/service goes back to ok and when the acknowledgement gets deleted */
Checkable::OnAcknowledgementCleared.connect([](const Checkable::Ptr& checkable, const MessageOrigin::Ptr&) {
RedisWriter::StateChangeHandler(checkable);
IcingaDB::StateChangeHandler(checkable);
});
/* triggered on create, update and delete objects */
ConfigObject::OnActiveChanged.connect([](const ConfigObject::Ptr& object, const Value&) {
RedisWriter::VersionChangedHandler(object);
IcingaDB::VersionChangedHandler(object);
});
ConfigObject::OnVersionChanged.connect([](const ConfigObject::Ptr& object, const Value&) {
RedisWriter::VersionChangedHandler(object);
IcingaDB::VersionChangedHandler(object);
});
/* fixed/flexible downtime add */
Downtime::OnDowntimeAdded.connect(&RedisWriter::DowntimeAddedHandler);
Downtime::OnDowntimeAdded.connect(&IcingaDB::DowntimeAddedHandler);
/* fixed downtime start */
Downtime::OnDowntimeStarted.connect(&RedisWriter::DowntimeStartedHandler);
Downtime::OnDowntimeStarted.connect(&IcingaDB::DowntimeStartedHandler);
/* flexible downtime start */
Downtime::OnDowntimeTriggered.connect(&RedisWriter::DowntimeStartedHandler);
Downtime::OnDowntimeTriggered.connect(&IcingaDB::DowntimeStartedHandler);
/* fixed/flexible downtime end or remove */
Downtime::OnDowntimeRemoved.connect(&RedisWriter::DowntimeRemovedHandler);
Downtime::OnDowntimeRemoved.connect(&IcingaDB::DowntimeRemovedHandler);
Checkable::OnNotificationSentToAllUsers.connect([](
const Notification::Ptr& notification, const Checkable::Ptr& checkable, const std::set<User::Ptr>& users,
const NotificationType& type, const CheckResult::Ptr& cr, const String& author, const String& text,
const MessageOrigin::Ptr&
) {
RedisWriter::NotificationSentToAllUsersHandler(notification, checkable, users, type, cr, author, text);
IcingaDB::NotificationSentToAllUsersHandler(notification, checkable, users, type, cr, author, text);
});
Comment::OnCommentAdded.connect(&RedisWriter::CommentAddedHandler);
Comment::OnCommentRemoved.connect(&RedisWriter::CommentRemovedHandler);
Comment::OnCommentAdded.connect(&IcingaDB::CommentAddedHandler);
Comment::OnCommentRemoved.connect(&IcingaDB::CommentRemovedHandler);
Checkable::OnFlappingChanged.connect(&RedisWriter::FlappingChangedHandler);
Checkable::OnFlappingChanged.connect(&IcingaDB::FlappingChangedHandler);
}
static std::pair<String, String> SplitOutput(String output)
@ -123,13 +123,13 @@ static std::pair<String, String> SplitOutput(String output)
return {std::move(output), std::move(longOutput)};
}
void RedisWriter::UpdateAllConfigObjects()
void IcingaDB::UpdateAllConfigObjects()
{
double startTime = Utility::GetTime();
// Use a Workqueue to pack objects in parallel
WorkQueue upq(25000, Configuration::Concurrency);
upq.SetName("RedisWriter:ConfigDump");
upq.SetName("IcingaDB:ConfigDump");
typedef std::pair<ConfigType *, String> TypePair;
std::vector<TypePair> types;
@ -162,7 +162,7 @@ void RedisWriter::UpdateAllConfigObjects()
auto objectChunks (ChunkObjects(type.first->GetObjects(), 500));
WorkQueue upqObjectType(25000, Configuration::Concurrency);
upqObjectType.SetName("RedisWriter:ConfigDump:" + lcType);
upqObjectType.SetName("IcingaDB:ConfigDump:" + lcType);
upqObjectType.ParallelFor(objectChunks, [this, &type, &lcType](decltype(objectChunks)::const_reference chunk) {
std::map<String, std::vector<String>> hMSets, publishes;
@ -250,7 +250,7 @@ void RedisWriter::UpdateAllConfigObjects()
m_Rcon->FireAndForgetQueries(std::move(transaction));
}
Log(LogNotice, "RedisWriter")
Log(LogNotice, "IcingaDB")
<< "Dumped " << bulkCounter << " objects of type " << type.second;
});
@ -276,7 +276,7 @@ void RedisWriter::UpdateAllConfigObjects()
boost::rethrow_exception(exc);
}
} catch(const std::exception& e) {
Log(LogCritical, "RedisWriter")
Log(LogCritical, "IcingaDB")
<< "Exception during ConfigDump: " << e.what();
}
}
@ -284,11 +284,11 @@ void RedisWriter::UpdateAllConfigObjects()
m_Rcon->FireAndForgetQuery({"XADD", "icinga:dump", "*", "type", "*", "state", "done"});
Log(LogInformation, "RedisWriter")
Log(LogInformation, "IcingaDB")
<< "Initial config/status dump finished in " << Utility::GetTime() - startTime << " seconds.";
}
std::vector<std::vector<intrusive_ptr<ConfigObject>>> RedisWriter::ChunkObjects(std::vector<intrusive_ptr<ConfigObject>> objects, size_t chunkSize) {
std::vector<std::vector<intrusive_ptr<ConfigObject>>> IcingaDB::ChunkObjects(std::vector<intrusive_ptr<ConfigObject>> objects, size_t chunkSize) {
std::vector<std::vector<intrusive_ptr<ConfigObject>>> chunks;
auto offset (objects.begin());
auto end (objects.end());
@ -308,7 +308,7 @@ std::vector<std::vector<intrusive_ptr<ConfigObject>>> RedisWriter::ChunkObjects(
return std::move(chunks);
}
void RedisWriter::DeleteKeys(const std::vector<String>& keys) {
void IcingaDB::DeleteKeys(const std::vector<String>& keys) {
std::vector<String> query = {"DEL"};
for (auto& key : keys) {
query.emplace_back(key);
@ -317,7 +317,7 @@ void RedisWriter::DeleteKeys(const std::vector<String>& keys) {
m_Rcon->FireAndForgetQuery(std::move(query));
}
std::vector<String> RedisWriter::GetTypeObjectKeys(const String& type)
std::vector<String> IcingaDB::GetTypeObjectKeys(const String& type)
{
std::vector<String> keys = {
m_PrefixConfigObject + type,
@ -361,7 +361,7 @@ static ConfigObject::Ptr GetObjectByName(const String& name)
return ConfigObject::GetObject<ConfigType>(name);
}
void RedisWriter::InsertObjectDependencies(const ConfigObject::Ptr& object, const String typeName, std::map<String, std::vector<String>>& hMSets,
void IcingaDB::InsertObjectDependencies(const ConfigObject::Ptr& object, const String typeName, std::map<String, std::vector<String>>& hMSets,
std::map<String, std::vector<String>>& publishes, bool runtimeUpdate)
{
String objectKey = GetObjectIdentifier(object);
@ -780,7 +780,7 @@ void RedisWriter::InsertObjectDependencies(const ConfigObject::Ptr& object, cons
}
}
void RedisWriter::UpdateState(const Checkable::Ptr& checkable)
void IcingaDB::UpdateState(const Checkable::Ptr& checkable)
{
Dictionary::Ptr stateAttrs = SerializeState(checkable);
@ -788,7 +788,7 @@ void RedisWriter::UpdateState(const Checkable::Ptr& checkable)
}
// Used to update a single object, used for runtime updates
void RedisWriter::SendConfigUpdate(const ConfigObject::Ptr& object, bool runtimeUpdate)
void IcingaDB::SendConfigUpdate(const ConfigObject::Ptr& object, bool runtimeUpdate)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -836,7 +836,7 @@ void RedisWriter::SendConfigUpdate(const ConfigObject::Ptr& object, bool runtime
// Takes object and collects IcingaDB relevant attributes and computes checksums. Returns whether the object is relevant
// for IcingaDB.
bool RedisWriter::PrepareObject(const ConfigObject::Ptr& object, Dictionary::Ptr& attributes, Dictionary::Ptr& checksums)
bool IcingaDB::PrepareObject(const ConfigObject::Ptr& object, Dictionary::Ptr& attributes, Dictionary::Ptr& checksums)
{
attributes->Set("name_checksum", CalculateCheckSumString(object->GetName()));
attributes->Set("environment_id", CalculateCheckSumString(GetEnvironment()));
@ -1093,7 +1093,7 @@ bool RedisWriter::PrepareObject(const ConfigObject::Ptr& object, Dictionary::Ptr
* icinga:config:object:downtime) need to be prepended. There is nothing to indicate success or failure.
*/
void
RedisWriter::CreateConfigUpdate(const ConfigObject::Ptr& object, const String typeName, std::map<String, std::vector<String>>& hMSets,
IcingaDB::CreateConfigUpdate(const ConfigObject::Ptr& object, const String typeName, std::map<String, std::vector<String>>& hMSets,
std::map<String, std::vector<String>>& publishes, bool runtimeUpdate)
{
/* TODO: This isn't essentially correct as we don't keep track of config objects ourselves. This would avoid duplicated config updates at startup.
@ -1128,7 +1128,7 @@ RedisWriter::CreateConfigUpdate(const ConfigObject::Ptr& object, const String ty
}
}
void RedisWriter::SendConfigDelete(const ConfigObject::Ptr& object)
void IcingaDB::SendConfigDelete(const ConfigObject::Ptr& object)
{
String typeName = object->GetReflectionType()->GetName().ToLower();
String objectKey = GetObjectIdentifier(object);
@ -1152,7 +1152,7 @@ unsigned short GetPreviousHardState(const Checkable::Ptr& checkable, const Servi
}
}
void RedisWriter::SendStatusUpdate(const ConfigObject::Ptr& object, const CheckResult::Ptr& cr, StateType type)
void IcingaDB::SendStatusUpdate(const ConfigObject::Ptr& object, const CheckResult::Ptr& cr, StateType type)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -1228,7 +1228,7 @@ void RedisWriter::SendStatusUpdate(const ConfigObject::Ptr& object, const CheckR
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
void RedisWriter::SendSentNotification(
void IcingaDB::SendSentNotification(
const Notification::Ptr& notification, const Checkable::Ptr& checkable, size_t users,
NotificationType type, const CheckResult::Ptr& cr, const String& author, const String& text
)
@ -1276,7 +1276,7 @@ void RedisWriter::SendSentNotification(
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
void RedisWriter::SendAddedDowntime(const Downtime::Ptr& downtime)
void IcingaDB::SendAddedDowntime(const Downtime::Ptr& downtime)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -1343,7 +1343,7 @@ void RedisWriter::SendAddedDowntime(const Downtime::Ptr& downtime)
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
void RedisWriter::SendStartedDowntime(const Downtime::Ptr& downtime)
void IcingaDB::SendStartedDowntime(const Downtime::Ptr& downtime)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -1412,7 +1412,7 @@ void RedisWriter::SendStartedDowntime(const Downtime::Ptr& downtime)
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
void RedisWriter::SendRemovedDowntime(const Downtime::Ptr& downtime)
void IcingaDB::SendRemovedDowntime(const Downtime::Ptr& downtime)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -1480,7 +1480,7 @@ void RedisWriter::SendRemovedDowntime(const Downtime::Ptr& downtime)
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
void RedisWriter::SendAddedComment(const Comment::Ptr& comment)
void IcingaDB::SendAddedComment(const Comment::Ptr& comment)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -1524,7 +1524,7 @@ void RedisWriter::SendAddedComment(const Comment::Ptr& comment)
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
void RedisWriter::SendRemovedComment(const Comment::Ptr& comment)
void IcingaDB::SendRemovedComment(const Comment::Ptr& comment)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -1569,7 +1569,7 @@ void RedisWriter::SendRemovedComment(const Comment::Ptr& comment)
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
void RedisWriter::SendFlappingChanged(const Checkable::Ptr& checkable, const Value& value)
void IcingaDB::SendFlappingChanged(const Checkable::Ptr& checkable, const Value& value)
{
if (!m_Rcon || !m_Rcon->IsConnected())
return;
@ -1611,7 +1611,7 @@ void RedisWriter::SendFlappingChanged(const Checkable::Ptr& checkable, const Val
m_Rcon->FireAndForgetQuery(std::move(xAdd));
}
Dictionary::Ptr RedisWriter::SerializeState(const Checkable::Ptr& checkable)
Dictionary::Ptr IcingaDB::SerializeState(const Checkable::Ptr& checkable)
{
Dictionary::Ptr attrs = new Dictionary();
@ -1709,7 +1709,7 @@ Dictionary::Ptr RedisWriter::SerializeState(const Checkable::Ptr& checkable)
}
std::vector<String>
RedisWriter::UpdateObjectAttrs(const ConfigObject::Ptr& object, int fieldType,
IcingaDB::UpdateObjectAttrs(const ConfigObject::Ptr& object, int fieldType,
const String& typeNameOverride)
{
Type::Ptr type = object->GetReflectionType();
@ -1751,73 +1751,73 @@ RedisWriter::UpdateObjectAttrs(const ConfigObject::Ptr& object, int fieldType,
//m_Rcon->FireAndForgetQuery({"HSET", keyPrefix + typeName, GetObjectIdentifier(object), JsonEncode(attrs)});
}
void RedisWriter::StateChangeHandler(const ConfigObject::Ptr& object)
void IcingaDB::StateChangeHandler(const ConfigObject::Ptr& object)
{
auto checkable (dynamic_pointer_cast<Checkable>(object));
if (checkable) {
RedisWriter::StateChangeHandler(object, checkable->GetLastCheckResult(), checkable->GetStateType());
IcingaDB::StateChangeHandler(object, checkable->GetLastCheckResult(), checkable->GetStateType());
}
}
void RedisWriter::StateChangeHandler(const ConfigObject::Ptr& object, const CheckResult::Ptr& cr, StateType type)
void IcingaDB::StateChangeHandler(const ConfigObject::Ptr& object, const CheckResult::Ptr& cr, StateType type)
{
for (const RedisWriter::Ptr& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (const IcingaDB::Ptr& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
rw->m_WorkQueue.Enqueue([rw, object, cr, type]() { rw->SendStatusUpdate(object, cr, type); });
}
}
void RedisWriter::VersionChangedHandler(const ConfigObject::Ptr& object)
void IcingaDB::VersionChangedHandler(const ConfigObject::Ptr& object)
{
Type::Ptr type = object->GetReflectionType();
if (object->IsActive()) {
// Create or update the object config
for (const RedisWriter::Ptr& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (const IcingaDB::Ptr& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
if (rw)
rw->m_WorkQueue.Enqueue([rw, object]() { rw->SendConfigUpdate(object, true); });
}
} else if (!object->IsActive() &&
object->GetExtension("ConfigObjectDeleted")) { // same as in apilistener-configsync.cpp
// Delete object config
for (const RedisWriter::Ptr& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (const IcingaDB::Ptr& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
if (rw)
rw->m_WorkQueue.Enqueue([rw, object]() { rw->SendConfigDelete(object); });
}
}
}
void RedisWriter::DowntimeAddedHandler(const Downtime::Ptr& downtime)
void IcingaDB::DowntimeAddedHandler(const Downtime::Ptr& downtime)
{
for (auto& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (auto& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
rw->m_WorkQueue.Enqueue([rw, downtime]() { rw->SendAddedDowntime(downtime); });
}
}
void RedisWriter::DowntimeStartedHandler(const Downtime::Ptr& downtime)
void IcingaDB::DowntimeStartedHandler(const Downtime::Ptr& downtime)
{
StateChangeHandler(downtime->GetCheckable());
for (auto& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (auto& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
rw->m_WorkQueue.Enqueue([rw, downtime]() { rw->SendStartedDowntime(downtime); });
}
}
void RedisWriter::DowntimeRemovedHandler(const Downtime::Ptr& downtime)
void IcingaDB::DowntimeRemovedHandler(const Downtime::Ptr& downtime)
{
StateChangeHandler(downtime->GetCheckable());
for (auto& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (auto& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
rw->m_WorkQueue.Enqueue([rw, downtime]() { rw->SendRemovedDowntime(downtime); });
}
}
void RedisWriter::NotificationSentToAllUsersHandler(
void IcingaDB::NotificationSentToAllUsersHandler(
const Notification::Ptr& notification, const Checkable::Ptr& checkable, const std::set<User::Ptr>& users,
NotificationType type, const CheckResult::Ptr& cr, const String& author, const String& text
)
{
auto rws (ConfigType::GetObjectsByType<RedisWriter>());
auto rws (ConfigType::GetObjectsByType<IcingaDB>());
if (!rws.empty()) {
auto usersAmount (users.size());
@ -1831,23 +1831,23 @@ void RedisWriter::NotificationSentToAllUsersHandler(
}
}
void RedisWriter::CommentAddedHandler(const Comment::Ptr& comment)
void IcingaDB::CommentAddedHandler(const Comment::Ptr& comment)
{
for (auto& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (auto& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
rw->m_WorkQueue.Enqueue([rw, comment]() { rw->SendAddedComment(comment); });
}
}
void RedisWriter::CommentRemovedHandler(const Comment::Ptr& comment)
void IcingaDB::CommentRemovedHandler(const Comment::Ptr& comment)
{
for (auto& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (auto& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
rw->m_WorkQueue.Enqueue([rw, comment]() { rw->SendRemovedComment(comment); });
}
}
void RedisWriter::FlappingChangedHandler(const Checkable::Ptr& checkable, const Value& value)
void IcingaDB::FlappingChangedHandler(const Checkable::Ptr& checkable, const Value& value)
{
for (auto& rw : ConfigType::GetObjectsByType<RedisWriter>()) {
for (auto& rw : ConfigType::GetObjectsByType<IcingaDB>()) {
rw->m_WorkQueue.Enqueue([rw, checkable, value]() { rw->SendFlappingChanged(checkable, value); });
}
}

2
lib/redis/rediswriter-stats.cpp
View File

@ -26,7 +26,7 @@
using namespace icinga;
Dictionary::Ptr RedisWriter::GetStats()
Dictionary::Ptr IcingaDB::GetStats()
{
Dictionary::Ptr stats = new Dictionary();

28
lib/redis/rediswriter-utility.cpp
View File

@ -41,7 +41,7 @@
using namespace icinga;
String RedisWriter::FormatCheckSumBinary(const String& str)
String IcingaDB::FormatCheckSumBinary(const String& str)
{
char output[20*2+1];
for (int i = 0; i < 20; i++)
@ -50,7 +50,7 @@ String RedisWriter::FormatCheckSumBinary(const String& str)
return output;
}
String RedisWriter::FormatCommandLine(const Value& commandLine)
String IcingaDB::FormatCommandLine(const Value& commandLine)
{
String result;
if (commandLine.IsObjectType<Array>()) {
@ -77,12 +77,12 @@ String RedisWriter::FormatCommandLine(const Value& commandLine)
return result;
}
String RedisWriter::GetEnvironment()
String IcingaDB::GetEnvironment()
{
return ConfigType::GetObjectsByType<IcingaApplication>()[0]->GetEnvironment();
}
String RedisWriter::GetObjectIdentifier(const ConfigObject::Ptr& object)
String IcingaDB::GetObjectIdentifier(const ConfigObject::Ptr& object)
{
Type::Ptr type = object->GetReflectionType();
@ -92,12 +92,12 @@ String RedisWriter::GetObjectIdentifier(const ConfigObject::Ptr& object)
return HashValue((Array::Ptr)new Array({GetEnvironment(), object->GetName()}));
}
String RedisWriter::CalculateCheckSumString(const String& str)
String IcingaDB::CalculateCheckSumString(const String& str)
{
return SHA1(str);
}
String RedisWriter::CalculateCheckSumArray(const Array::Ptr& arr)
String IcingaDB::CalculateCheckSumArray(const Array::Ptr& arr)
{
/* Ensure that checksums happen in a defined order. */
Array::Ptr tmpArr = arr->ShallowClone();
@ -107,7 +107,7 @@ String RedisWriter::CalculateCheckSumArray(const Array::Ptr& arr)
return SHA1(PackObject(tmpArr));
}
String RedisWriter::CalculateCheckSumProperties(const ConfigObject::Ptr& object, const std::set<String>& propertiesBlacklist)
String IcingaDB::CalculateCheckSumProperties(const ConfigObject::Ptr& object, const std::set<String>& propertiesBlacklist)
{
//TODO: consider precision of 6 for double values; use specific config fields for hashing?
return HashValue(object, propertiesBlacklist);
@ -115,12 +115,12 @@ String RedisWriter::CalculateCheckSumProperties(const ConfigObject::Ptr& object,
static const std::set<String> metadataWhitelist ({"package", "source_location", "templates"});
String RedisWriter::CalculateCheckSumMetadata(const ConfigObject::Ptr& object)
String IcingaDB::CalculateCheckSumMetadata(const ConfigObject::Ptr& object)
{
return HashValue(object, metadataWhitelist, true);
}
String RedisWriter::CalculateCheckSumVars(const CustomVarObject::Ptr& object)
String IcingaDB::CalculateCheckSumVars(const CustomVarObject::Ptr& object)
{
Dictionary::Ptr vars = object->GetVars();
@ -169,7 +169,7 @@ String RedisWriter::CalculateCheckSumVars(const CustomVarObject::Ptr& object)
*
* @return JSON-like data structure for Redis
*/
Dictionary::Ptr RedisWriter::SerializeVars(const CustomVarObject::Ptr& object)
Dictionary::Ptr IcingaDB::SerializeVars(const CustomVarObject::Ptr& object)
{
Dictionary::Ptr vars = object->GetVars();
@ -199,12 +199,12 @@ Dictionary::Ptr RedisWriter::SerializeVars(const CustomVarObject::Ptr& object)
static const std::set<String> propertiesBlacklistEmpty;
String RedisWriter::HashValue(const Value& value)
String IcingaDB::HashValue(const Value& value)
{
return HashValue(value, propertiesBlacklistEmpty);
}
String RedisWriter::HashValue(const Value& value, const std::set<String>& propertiesBlacklist, bool propertiesWhitelist)
String IcingaDB::HashValue(const Value& value, const std::set<String>& propertiesBlacklist, bool propertiesWhitelist)
{
Value temp;
bool mutabl;
@ -252,11 +252,11 @@ String RedisWriter::HashValue(const Value& value, const std::set<String>& proper
return SHA1(PackObject(temp));
}
String RedisWriter::GetLowerCaseTypeNameDB(const ConfigObject::Ptr& obj)
String IcingaDB::GetLowerCaseTypeNameDB(const ConfigObject::Ptr& obj)
{
return obj->GetReflectionType()->GetName().ToLower();
}
long long RedisWriter::TimestampToMilliseconds(double timestamp) {
long long IcingaDB::TimestampToMilliseconds(double timestamp) {
return static_cast<long long>(timestamp * 1000);
}

66
lib/redis/rediswriter.cpp
View File

@ -35,14 +35,14 @@ using namespace icinga;
//TODO Make configurable and figure out a sane default
#define MAX_EVENTS_DEFAULT 5000
REGISTER_TYPE(RedisWriter);
REGISTER_TYPE(IcingaDB);
RedisWriter::RedisWriter()
IcingaDB::IcingaDB()
: m_Rcon(nullptr)
{
m_Rcon = nullptr;
m_WorkQueue.SetName("RedisWriter");
m_WorkQueue.SetName("IcingaDB");
m_PrefixConfigObject = "icinga:config:";
m_PrefixConfigCheckSum = "icinga:checksum:";
@ -52,11 +52,11 @@ RedisWriter::RedisWriter()
/**
* Starts the component.
*/
void RedisWriter::Start(bool runtimeCreated)
void IcingaDB::Start(bool runtimeCreated)
{
ObjectImpl<RedisWriter>::Start(runtimeCreated);
ObjectImpl<IcingaDB>::Start(runtimeCreated);
Log(LogInformation, "RedisWriter")
Log(LogInformation, "IcingaDB")
<< "'" << GetName() << "' started.";
m_ConfigDumpInProgress = false;
@ -83,27 +83,27 @@ void RedisWriter::Start(bool runtimeCreated)
m_StatsTimer->OnTimerExpired.connect([this](const Timer * const&) { PublishStatsTimerHandler(); });
m_StatsTimer->Start();
m_WorkQueue.SetName("RedisWriter");
m_WorkQueue.SetName("IcingaDB");
boost::thread thread(&RedisWriter::HandleEvents, this);
boost::thread thread(&IcingaDB::HandleEvents, this);
thread.detach();
}
void RedisWriter::ExceptionHandler(boost::exception_ptr exp)
void IcingaDB::ExceptionHandler(boost::exception_ptr exp)
{
Log(LogCritical, "RedisWriter", "Exception during redis query. Verify that Redis is operational.");
Log(LogCritical, "IcingaDB", "Exception during redis query. Verify that Redis is operational.");
Log(LogDebug, "RedisWriter")
Log(LogDebug, "IcingaDB")
<< "Exception during redis operation: " << DiagnosticInformation(exp);
}
void RedisWriter::ReconnectTimerHandler()
void IcingaDB::ReconnectTimerHandler()
{
m_WorkQueue.Enqueue([this]() { TryToReconnect(); });
}
void RedisWriter::TryToReconnect()
void IcingaDB::TryToReconnect()
{
AssertOnWorkQueue();
@ -131,16 +131,16 @@ void RedisWriter::TryToReconnect()
m_ConfigDumpInProgress = false;
}
void RedisWriter::UpdateSubscriptionsTimerHandler()
void IcingaDB::UpdateSubscriptionsTimerHandler()
{
m_WorkQueue.Enqueue([this]() { UpdateSubscriptions(); });
}
void RedisWriter::UpdateSubscriptions()
void IcingaDB::UpdateSubscriptions()
{
AssertOnWorkQueue();
Log(LogInformation, "RedisWriter", "Updating Redis subscriptions");
Log(LogInformation, "IcingaDB", "Updating Redis subscriptions");
/* TODO:
* Silently return in this case. Usually the RedisConnection checks for connectivity and logs in failure case.
@ -168,8 +168,8 @@ void RedisWriter::UpdateSubscriptions()
RedisSubscriptionInfo rsi;
if (!RedisWriter::GetSubscriptionTypes(key, rsi)) {
Log(LogInformation, "RedisWriter")
if (!IcingaDB::GetSubscriptionTypes(key, rsi)) {
Log(LogInformation, "IcingaDB")
<< "Subscription \"" << key << "\" has no types listed.";
} else {
m_Subscriptions[key.SubStr(keyPrefix.GetLength())] = rsi;
@ -177,11 +177,11 @@ void RedisWriter::UpdateSubscriptions()
}
} while (cursor != "0");
Log(LogInformation, "RedisWriter")
Log(LogInformation, "IcingaDB")
<< "Current Redis event subscriptions: " << m_Subscriptions.size();
}
bool RedisWriter::GetSubscriptionTypes(String key, RedisSubscriptionInfo& rsi)
bool IcingaDB::GetSubscriptionTypes(String key, RedisSubscriptionInfo& rsi)
{
try {
Array::Ptr redisReply = m_Rcon->GetResultOfQuery({ "SMEMBERS", key });
@ -197,11 +197,11 @@ bool RedisWriter::GetSubscriptionTypes(String key, RedisSubscriptionInfo& rsi)
}
}
Log(LogInformation, "RedisWriter")
Log(LogInformation, "IcingaDB")
<< "Subscriber Info - Key: " << key << " Value: " << Value(Array::FromSet(rsi.EventTypes));
} catch (const std::exception& ex) {
Log(LogWarning, "RedisWriter")
Log(LogWarning, "IcingaDB")
<< "Invalid Redis subscriber info for subscriber '" << key << "': " << DiagnosticInformation(ex);
return false;
@ -210,12 +210,12 @@ bool RedisWriter::GetSubscriptionTypes(String key, RedisSubscriptionInfo& rsi)
return true;
}
void RedisWriter::PublishStatsTimerHandler(void)
void IcingaDB::PublishStatsTimerHandler(void)
{
m_WorkQueue.Enqueue([this]() { PublishStats(); });
}
void RedisWriter::PublishStats()
void IcingaDB::PublishStats()
{
AssertOnWorkQueue();
@ -229,7 +229,7 @@ void RedisWriter::PublishStats()
m_Rcon->FireAndForgetQuery({ "PUBLISH", "icinga:stats", jsonStats });
}
void RedisWriter::HandleEvents()
void IcingaDB::HandleEvents()
{
String queueName = Utility::NewUniqueID();
EventQueue::Ptr queue = new EventQueue(queueName);
@ -265,7 +265,7 @@ void RedisWriter::HandleEvents()
EventQueue::UnregisterIfUnused(queueName, queue);
}
void RedisWriter::HandleEvent(const Dictionary::Ptr& event)
void IcingaDB::HandleEvent(const Dictionary::Ptr& event)
{
AssertOnWorkQueue();
@ -284,7 +284,7 @@ void RedisWriter::HandleEvent(const Dictionary::Ptr& event)
if (maxExists != 0) {
String redisReply = m_Rcon->GetResultOfQuery({ "GET", "icinga:subscription:" + name + ":limit"});
Log(LogInformation, "RedisWriter")
Log(LogInformation, "IcingaDB")
<< "Got limit " << redisReply << " for " << name;
maxEvents = Convert::ToLong(redisReply);
@ -298,7 +298,7 @@ void RedisWriter::HandleEvent(const Dictionary::Ptr& event)
}
}
void RedisWriter::SendEvent(const Dictionary::Ptr& event)
void IcingaDB::SendEvent(const Dictionary::Ptr& event)
{
AssertOnWorkQueue();
@ -347,7 +347,7 @@ void RedisWriter::SendEvent(const Dictionary::Ptr& event)
String body = JsonEncode(event);
// Log(LogInformation, "RedisWriter")
// Log(LogInformation, "IcingaDB")
// << "Sending event \"" << body << "\"";
m_Rcon->FireAndForgetQueries({
@ -355,15 +355,15 @@ void RedisWriter::SendEvent(const Dictionary::Ptr& event)
{ "PUBLISH", "icinga:event:" + event->Get("type"), body }});
}
void RedisWriter::Stop(bool runtimeRemoved)
void IcingaDB::Stop(bool runtimeRemoved)
{
Log(LogInformation, "RedisWriter")
Log(LogInformation, "IcingaDB")
<< "'" << GetName() << "' stopped.";
ObjectImpl<RedisWriter>::Stop(runtimeRemoved);
ObjectImpl<IcingaDB>::Stop(runtimeRemoved);
}
void RedisWriter::AssertOnWorkQueue()
void IcingaDB::AssertOnWorkQueue()
{
ASSERT(m_WorkQueue.IsWorkerThread());
}

8
lib/redis/rediswriter.hpp
View File

@ -42,13 +42,13 @@ struct RedisSubscriptionInfo
/**
* @ingroup redis
*/
class RedisWriter : public ObjectImpl<RedisWriter>
class IcingaDB : public ObjectImpl<IcingaDB>
{
public:
DECLARE_OBJECT(RedisWriter);
DECLARE_OBJECTNAME(RedisWriter);
DECLARE_OBJECT(IcingaDB);
DECLARE_OBJECTNAME(IcingaDB);
RedisWriter();
IcingaDB();
static void ConfigStaticInitialize();

2
lib/redis/rediswriter.ti
View File

@ -24,7 +24,7 @@ library redis;
namespace icinga
{
class RedisWriter : ConfigObject
class IcingaDB : ConfigObject
{
[config] String host {
default {{{ return "127.0.0.1"; }}}