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

Implement modified attributes v2 

refs #9081
refs #9093
This commit is contained in:
Michael Friedrich 2015-08-04 14:47:44 +02:00 committed by Gunnar Beutner
parent 80584f81f1
commit d7970f5bb1
112 changed files with 1218 additions and 1526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lib/base/CMakeLists.txt
View File

@ -23,15 +23,19 @@ mkclass_target(streamlogger.ti streamlogger.tcpp streamlogger.thpp)
mkclass_target(sysloglogger.ti sysloglogger.tcpp sysloglogger.thpp)
set(base_SOURCES
application.cpp application.thpp application-version.cpp array.cpp array-script.cpp boolean.cpp boolean-script.cpp console.cpp context.cpp
convert.cpp debuginfo.cpp dictionary.cpp dictionary-script.cpp dynamicobject.cpp dynamicobject.thpp dynamictype.cpp
exception.cpp fifo.cpp filelogger.cpp filelogger.thpp initialize.cpp json.cpp json-script.cpp loader.cpp logger.cpp logger.thpp math-script.cpp
netstring.cpp networkstream.cpp number.cpp number-script.cpp object.cpp object-script.cpp primitivetype.cpp process.cpp
ringbuffer.cpp scriptframe.cpp function.cpp function-script.cpp functionwrapper.cpp scriptglobal.cpp
application.cpp application.thpp application-version.cpp array.cpp
array-script.cpp boolean.cpp boolean-script.cpp console.cpp context.cpp
convert.cpp debuginfo.cpp dictionary.cpp dictionary-script.cpp
dynamicobject.cpp dynamicobject.thpp dynamicobject-script.cpp dynamictype.cpp
exception.cpp fifo.cpp filelogger.cpp filelogger.thpp initialize.cpp json.cpp
json-script.cpp loader.cpp logger.cpp logger.thpp math-script.cpp
netstring.cpp networkstream.cpp number.cpp number-script.cpp object.cpp
object-script.cpp primitivetype.cpp process.cpp ringbuffer.cpp scriptframe.cpp
function.cpp function-script.cpp functionwrapper.cpp scriptglobal.cpp
scriptutils.cpp serializer.cpp socket.cpp socketevents.cpp stacktrace.cpp
statsfunction.cpp stdiostream.cpp stream.cpp streamlogger.cpp streamlogger.thpp string.cpp string-script.cpp
sysloglogger.cpp sysloglogger.thpp tcpsocket.cpp thinmutex.cpp threadpool.cpp timer.cpp
tlsstream.cpp tlsutility.cpp type.cpp unixsocket.cpp utility.cpp value.cpp
tlsstream.cpp tlsutility.cpp type.cpp typetype-script.cpp unixsocket.cpp utility.cpp value.cpp
value-operators.cpp workqueue.cpp
)

2
lib/base/application.ti
View File

@ -19,6 +19,8 @@
#include "base/dynamicobject.hpp"
library base;
namespace icinga
{

54
lib/base/dynamicobject-script.cpp Normal file
View File

@ -0,0 +1,54 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "base/dynamicobject.hpp"
#include "base/dictionary.hpp"
#include "base/function.hpp"
#include "base/functionwrapper.hpp"
#include "base/scriptframe.hpp"
using namespace icinga;
static void DynamicObjectModifyAttribute(const String& attr, const Value& value)
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
DynamicObject::Ptr self = vframe->Self;
return self->ModifyAttribute(attr, value);
}
static void DynamicObjectRestoreAttribute(const String& attr)
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
DynamicObject::Ptr self = vframe->Self;
return self->RestoreAttribute(attr);
}
Object::Ptr DynamicObject::GetPrototype(void)
{
static Dictionary::Ptr prototype;
if (!prototype) {
prototype = new Dictionary();
prototype->Set("modify_attribute", new Function(WrapFunction(DynamicObjectModifyAttribute), false));
prototype->Set("restore_attribute", new Function(WrapFunction(DynamicObjectRestoreAttribute), false));
}
return prototype;
}

71
lib/base/dynamicobject.cpp
View File

@ -41,12 +41,8 @@
using namespace icinga;
REGISTER_TYPE(DynamicObject);
REGISTER_TYPE_WITH_PROTOTYPE(DynamicObject, DynamicObject::GetPrototype());
boost::signals2::signal<void (const DynamicObject::Ptr&)> DynamicObject::OnStarted;
boost::signals2::signal<void (const DynamicObject::Ptr&)> DynamicObject::OnStopped;
boost::signals2::signal<void (const DynamicObject::Ptr&)> DynamicObject::OnPaused;
boost::signals2::signal<void (const DynamicObject::Ptr&)> DynamicObject::OnResumed;
boost::signals2::signal<void (const DynamicObject::Ptr&)> DynamicObject::OnStateChanged;
DynamicObject::DynamicObject(void)
@ -99,6 +95,59 @@ void DynamicObject::ClearExtension(const String& key)
extensions->Remove(key);
}
void DynamicObject::ModifyAttribute(const String& attr, const Value& value)
{
Dictionary::Ptr original_attributes = GetOriginalAttributes();
bool updated_original_attributes = false;
Type::Ptr type = GetReflectionType();
int fid = type->GetFieldId(attr);
Field field = type->GetFieldInfo(fid);
if (field.Attributes & FAConfig) {
if (!original_attributes) {
original_attributes = new Dictionary();
SetOriginalAttributes(original_attributes, true);
}
Value attrVal = GetField(fid);
if (!original_attributes->Contains(attr)) {
updated_original_attributes = true;
original_attributes->Set(attr, attrVal);
}
}
//TODO: validation, vars.os
SetField(fid, value);
if (updated_original_attributes)
NotifyOriginalAttributes();
}
void DynamicObject::RestoreAttribute(const String& attr)
{
Dictionary::Ptr original_attributes = GetOriginalAttributes();
if (!original_attributes || !original_attributes->Contains(attr))
return;
Value attrVal = original_attributes->Get(attr);
SetField(GetReflectionType()->GetFieldId(attr), attrVal);
original_attributes->Remove(attr);
}
bool DynamicObject::IsAttributeModified(const String& attr) const
{
Dictionary::Ptr original_attributes = GetOriginalAttributes();
if (!original_attributes)
return false;
return original_attributes->Contains(attr);
}
void DynamicObject::Register(void)
{
ASSERT(!OwnsLock());
@ -128,12 +177,12 @@ void DynamicObject::Activate(void)
{
ObjectLock olock(this);
ASSERT(!IsActive());
SetActive(true);
SetActive(true, true);
}
OnStarted(this);
SetAuthority(true);
NotifyActive();
}
void DynamicObject::Stop(void)
@ -158,14 +207,14 @@ void DynamicObject::Deactivate(void)
if (!IsActive())
return;
SetActive(false);
SetActive(false, true);
}
Stop();
ASSERT(GetStopCalled());
OnStopped(this);
NotifyActive();
}
void DynamicObject::OnConfigLoaded(void)
@ -205,13 +254,11 @@ void DynamicObject::SetAuthority(bool authority)
Resume();
ASSERT(GetResumeCalled());
SetPaused(false);
OnResumed(this);
} else if (!authority && !GetPaused()) {
SetPauseCalled(false);
Pause();
ASSERT(GetPauseCalled());
SetPaused(true);
OnPaused(this);
}
}

10
lib/base/dynamicobject.hpp
View File

@ -42,10 +42,6 @@ class I2_BASE_API DynamicObject : public ObjectImpl<DynamicObject>
public:
DECLARE_OBJECT(DynamicObject);
static boost::signals2::signal<void (const DynamicObject::Ptr&)> OnStarted;
static boost::signals2::signal<void (const DynamicObject::Ptr&)> OnStopped;
static boost::signals2::signal<void (const DynamicObject::Ptr&)> OnPaused;
static boost::signals2::signal<void (const DynamicObject::Ptr&)> OnResumed;
static boost::signals2::signal<void (const DynamicObject::Ptr&)> OnStateChanged;
intrusive_ptr<DynamicType> GetType(void) const;
@ -57,6 +53,10 @@ public:
Value GetExtension(const String& key);
void ClearExtension(const String& key);
void ModifyAttribute(const String& attr, const Value& value);
void RestoreAttribute(const String& attr);
bool IsAttributeModified(const String& attr) const;
void Register(void);
void Activate(void);
@ -86,6 +86,8 @@ public:
static void RestoreObjects(const String& filename, int attributeTypes = FAState);
static void StopObjects(void);
static Object::Ptr GetPrototype(void);
protected:
explicit DynamicObject(void);

11
lib/base/dynamicobject.ti
View File

@ -19,6 +19,8 @@
#include "base/debuginfo.hpp"
library base;
namespace icinga
{
@ -75,14 +77,15 @@ abstract class DynamicObject : DynamicObjectBase
[get_protected] bool paused {
default {{{ return true; }}}
};
[get_protected] bool start_called;
[get_protected] bool stop_called;
[get_protected] bool pause_called;
[get_protected] bool resume_called;
[get_protected, internal] bool start_called;
[get_protected, internal] bool stop_called;
[get_protected, internal] bool pause_called;
[get_protected, internal] bool resume_called;
[enum] HAMode ha_mode (HAMode);
[protected] Dictionary::Ptr extensions;
[protected] bool state_loaded;
Dictionary::Ptr original_attributes;
};
}

2
lib/base/filelogger.ti
View File

@ -19,6 +19,8 @@
#include "base/streamlogger.hpp"
library base;
namespace icinga
{

2
lib/base/logger.ti
View File

@ -19,6 +19,8 @@
#include "base/dynamicobject.hpp"
library base;
namespace icinga
{

8
lib/base/object-script.cpp
View File

@ -32,6 +32,13 @@ static String ObjectToString(void)
return self->ToString();
}
static void ObjectNotifyAttribute(const String& attribute)
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Object::Ptr self = static_cast<Object::Ptr>(vframe->Self);
self->NotifyField(self->GetReflectionType()->GetFieldId(attribute));
}
Object::Ptr Object::GetPrototype(void)
{
static Dictionary::Ptr prototype;
@ -39,6 +46,7 @@ Object::Ptr Object::GetPrototype(void)
if (!prototype) {
prototype = new Dictionary();
prototype->Set("to_string", new Function(WrapFunction(ObjectToString), true));
prototype->Set("notify_attribute", new Function(WrapFunction(ObjectNotifyAttribute), false));
}
return prototype;

6
lib/base/object.cpp
View File

@ -76,7 +76,7 @@ void Object::InflateMutex(void)
m_Mutex.Inflate();
}
void Object::SetField(int id, const Value&)
void Object::SetField(int id, const Value&, bool, const Value&)
{
if (id == 0)
BOOST_THROW_EXCEPTION(std::runtime_error("Prototype field cannot be set."));
@ -92,3 +92,7 @@ Value Object::GetField(int id) const
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid field ID."));
}
void Object::NotifyField(int id, const Value& cookie)
{
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid field ID."));
}

5
lib/base/object.hpp
View File

@ -49,6 +49,8 @@ class Object;
class Type;
class String;
extern I2_BASE_API Value Empty;
#define DECLARE_PTR_TYPEDEFS(klass) \
typedef intrusive_ptr<klass> Ptr
@ -96,8 +98,9 @@ public:
virtual String ToString(void) const;
virtual void SetField(int id, const Value& value);
virtual void SetField(int id, const Value& value, bool suppress_events = false, const Value& cookie = Empty);
virtual Value GetField(int id) const;
virtual void NotifyField(int id, const Value& cookie = Empty);
#ifdef I2_DEBUG
bool OwnsLock(void) const;

2
lib/base/streamlogger.ti
View File

@ -19,6 +19,8 @@
#include "base/logger.hpp"
library base;
namespace icinga
{

2
lib/base/sysloglogger.ti
View File

@ -19,6 +19,8 @@
#include "base/logger.hpp"
library base;
namespace icinga
{

8
lib/base/type.cpp
View File

@ -22,9 +22,12 @@
using namespace icinga;
Type::Ptr Type::TypeInstance;
static void RegisterTypeType(void)
{
Type::Ptr type = new TypeType();
type->SetPrototype(TypeType::GetPrototype());
Type::TypeInstance = type;
Type::Register(type);
}
@ -111,6 +114,11 @@ std::vector<String> Type::GetLoadDependencies(void) const
return std::vector<String>();
}
void Type::RegisterAttributeHandler(int fieldId, const AttributeHandler& callback)
{
throw std::runtime_error("Invalid field ID.");
}
String TypeType::GetName(void) const
{
return "Type";

22
lib/base/type.hpp
View File

@ -24,6 +24,7 @@
#include "base/string.hpp"
#include "base/object.hpp"
#include "base/initialize.hpp"
#include <boost/function.hpp>
#include <vector>
namespace icinga
@ -68,7 +69,7 @@ public:
class I2_BASE_API Type : public Object
{
public:
DECLARE_PTR_TYPEDEFS(Type);
DECLARE_OBJECT(Type);
virtual String ToString(void) const;
@ -95,6 +96,9 @@ public:
virtual Value GetField(int id) const;
virtual std::vector<String> GetLoadDependencies(void) const;
typedef boost::function<void (const Object::Ptr&, const Value&)> AttributeHandler;
virtual void RegisterAttributeHandler(int fieldId, const AttributeHandler& callback);
protected:
virtual ObjectFactory GetFactory(void) const = 0;
@ -114,6 +118,8 @@ public:
virtual int GetFieldId(const String& name) const;
virtual Field GetFieldInfo(int id) const;
virtual int GetFieldCount(void) const;
static Object::Ptr GetPrototype(void);
protected:
virtual ObjectFactory GetFactory(void) const;
@ -137,6 +143,20 @@ class TypeImpl
} } \
DEFINE_TYPE_INSTANCE(type)
#define REGISTER_TYPE_WITH_PROTOTYPE(type, prototype) \
namespace { namespace UNIQUE_NAME(rt) { \
void RegisterType ## type(void) \
{ \
icinga::Type::Ptr t = new TypeImpl<type>(); \
t->SetPrototype(prototype); \
type::TypeInstance = t; \
icinga::Type::Register(t); \
} \
\
INITIALIZE_ONCE_WITH_PRIORITY(RegisterType ## type, 10); \
} } \
DEFINE_TYPE_INSTANCE(type)
#define DEFINE_TYPE_INSTANCE(type) \
Type::Ptr type::TypeInstance

58
lib/base/typetype-script.cpp Normal file
View File

@ -0,0 +1,58 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "base/type.hpp"
#include "base/dictionary.hpp"
#include "base/function.hpp"
#include "base/functionwrapper.hpp"
#include "base/scriptframe.hpp"
using namespace icinga;
static void InvokeAttributeHandlerHelper(const Function::Ptr& callback,
const Object::Ptr& object, const Value& cookie)
{
std::vector<Value> arguments;
arguments.push_back(object);
ScriptFrame frame;
callback->Invoke(arguments);
}
static void TypeRegisterAttributeHandler(const String& fieldName, const Function::Ptr& callback)
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Type::Ptr self = static_cast<Type::Ptr>(vframe->Self);
int fid = self->GetFieldId(fieldName);
self->RegisterAttributeHandler(fid, boost::bind(&InvokeAttributeHandlerHelper, callback, _1, _2));
}
Object::Ptr TypeType::GetPrototype(void)
{
static Dictionary::Ptr prototype;
if (!prototype) {
prototype = new Dictionary();
prototype->Set("register_attribute_handler", new Function(WrapFunction(TypeRegisterAttributeHandler), false));
}
return prototype;
}

2
lib/base/value.cpp
View File

@ -24,7 +24,7 @@
using namespace icinga;
Value Empty;
Value icinga::Empty;
bool Value::ToBool(void) const
{

2
lib/base/value.hpp
View File

@ -245,7 +245,7 @@ private:
}
};
static Value Empty;
extern I2_BASE_API Value Empty;
I2_BASE_API Value operator+(const Value& lhs, const char *rhs);
I2_BASE_API Value operator+(const char *lhs, const Value& rhs);

1
lib/checker/CMakeLists.txt
View File

@ -32,6 +32,7 @@ target_link_libraries(checker ${Boost_LIBRARIES} base config icinga remote)
set_target_properties (
checker PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_CHECKER_BUILD
FOLDER Components
)

6
lib/checker/checkercomponent.cpp
View File

@ -66,10 +66,8 @@ CheckerComponent::CheckerComponent(void)
void CheckerComponent::OnConfigLoaded(void)
{
DynamicObject::OnStarted.connect(bind(&CheckerComponent::ObjectHandler, this, _1));
DynamicObject::OnStopped.connect(bind(&CheckerComponent::ObjectHandler, this, _1));
DynamicObject::OnPaused.connect(bind(&CheckerComponent::ObjectHandler, this, _1));
DynamicObject::OnResumed.connect(bind(&CheckerComponent::ObjectHandler, this, _1));
DynamicObject::OnActiveChanged.connect(bind(&CheckerComponent::ObjectHandler, this, _1));
DynamicObject::OnPausedChanged.connect(bind(&CheckerComponent::ObjectHandler, this, _1));
Checkable::OnNextCheckChanged.connect(bind(&CheckerComponent::NextCheckChangedHandler, this, _1));
}

2
lib/checker/checkercomponent.ti
View File

@ -19,6 +19,8 @@
#include "base/dynamicobject.hpp"
library checker;
namespace icinga
{

1
lib/compat/CMakeLists.txt
View File

@ -37,6 +37,7 @@ target_link_libraries(compat ${Boost_LIBRARIES} base config icinga)
set_target_properties (
compat PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_COMPAT_BUILD
FOLDER Components
)

2
lib/compat/checkresultreader.ti
View File

@ -20,6 +20,8 @@
#include "base/dynamicobject.hpp"
#include "base/application.hpp"
library compat;
namespace icinga
{

68
lib/compat/compatlogger.cpp
View File

@ -63,10 +63,13 @@ void CompatLogger::Start(void)
Checkable::OnNewCheckResult.connect(bind(&CompatLogger::CheckResultHandler, this, _1, _2));
Checkable::OnNotificationSentToUser.connect(bind(&CompatLogger::NotificationSentHandler, this, _1, _2, _3, _4, _5, _6, _7, _8));
Checkable::OnFlappingChanged.connect(bind(&CompatLogger::FlappingHandler, this, _1, _2));
Checkable::OnDowntimeTriggered.connect(boost::bind(&CompatLogger::TriggerDowntimeHandler, this, _1, _2));
Checkable::OnDowntimeRemoved.connect(boost::bind(&CompatLogger::RemoveDowntimeHandler, this, _1, _2));
Checkable::OnEventCommandExecuted.connect(bind(&CompatLogger::EventCommandHandler, this, _1));
Checkable::OnFlappingChanged.connect(boost::bind(&CompatLogger::FlappingChangedHandler, this, _1));
Checkable::OnEnableFlappingChanged.connect(boost::bind(&CompatLogger::EnableFlappingChangedHandler, this, _1));
ExternalCommandProcessor::OnNewExternalCommand.connect(boost::bind(&CompatLogger::ExternalCommandHandler, this, _2, _3));
m_RotationTimer = new Timer();
@ -294,7 +297,7 @@ void CompatLogger::NotificationSentHandler(const Notification::Ptr& notification
/**
* @threadsafety Always.
*/
void CompatLogger::FlappingHandler(const Checkable::Ptr& checkable, FlappingState flapping_state)
void CompatLogger::FlappingChangedHandler(const Checkable::Ptr& checkable)
{
Host::Ptr host;
Service::Ptr service;
@ -302,24 +305,13 @@ void CompatLogger::FlappingHandler(const Checkable::Ptr& checkable, FlappingStat
String flapping_state_str;
String flapping_output;
switch (flapping_state) {
case FlappingStarted:
flapping_output = "Checkable appears to have started flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change >= " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STARTED";
break;
case FlappingStopped:
flapping_output = "Checkable appears to have stopped flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change < " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STOPPED";
break;
case FlappingDisabled:
flapping_output = "Flap detection has been disabled";
flapping_state_str = "DISABLED";
break;
default:
Log(LogCritical, "CompatLogger")
<< "Unknown flapping state: " << flapping_state;
return;
if (checkable->IsFlapping()) {
flapping_output = "Checkable appears to have started flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change >= " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STARTED";
} else {
flapping_output = "Checkable appears to have stopped flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change < " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STOPPED";
}
std::ostringstream msgbuf;
@ -346,6 +338,42 @@ void CompatLogger::FlappingHandler(const Checkable::Ptr& checkable, FlappingStat
}
}
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;

3
lib/compat/compatlogger.hpp
View File

@ -54,7 +54,8 @@ private:
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 FlappingHandler(const Checkable::Ptr& service, FlappingState flapping_state);
void FlappingChangedHandler(const Checkable::Ptr& checkable);
void EnableFlappingChangedHandler(const Checkable::Ptr& checkable);
void TriggerDowntimeHandler(const Checkable::Ptr& service, const Downtime::Ptr& downtime);
void RemoveDowntimeHandler(const Checkable::Ptr& service, const Downtime::Ptr& downtime);
void ExternalCommandHandler(const String& command, const std::vector<String>& arguments);

2
lib/compat/compatlogger.ti
View File

@ -20,6 +20,8 @@
#include "base/dynamicobject.hpp"
#include "base/application.hpp"
library compat;
namespace icinga
{

2
lib/compat/externalcommandlistener.ti
View File

@ -20,6 +20,8 @@
#include "base/dynamicobject.hpp"
#include "base/application.hpp"
library compat;
namespace icinga
{

2
lib/compat/statusdatawriter.ti
View File

@ -20,6 +20,8 @@
#include "base/dynamicobject.hpp"
#include "base/application.hpp"
library compat;
namespace icinga
{

1
lib/config/configwriter.cpp
View File

@ -23,6 +23,7 @@
#include <boost/foreach.hpp>
#include <boost/regex.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <set>
#include <iterator>
using namespace icinga;

1
lib/config/configwriter.hpp
View File

@ -25,7 +25,6 @@
#include "base/array.hpp"
#include "base/dictionary.hpp"
#include <fstream>
#include <set>
namespace icinga
{

31
lib/db_ido/dbconnection.cpp
View File

@ -61,6 +61,7 @@ void DbConnection::Start(void)
DynamicObject::Start();
DbObject::OnQuery.connect(boost::bind(&DbConnection::ExecuteQuery, this, _1));
DynamicObject::OnActiveChanged.connect(boost::bind(&DbConnection::UpdateObject, this, _1));
}
void DbConnection::Resume(void)
@ -377,20 +378,32 @@ void DbConnection::ExecuteQuery(const DbQuery&)
/* Default handler does nothing. */
}
void DbConnection::UpdateObject(const DynamicObject::Ptr& object)
{
if (!GetConnected())
return;
DbObject::Ptr dbobj = DbObject::GetOrCreateByObject(object);
if (dbobj) {
bool active = object->IsActive();
if (active) {
ActivateObject(dbobj);
dbobj->SendConfigUpdate();
dbobj->SendStatusUpdate();
} else
DeactivateObject(dbobj);
}
}
void DbConnection::UpdateAllObjects(void)
{
DynamicType::Ptr type;
BOOST_FOREACH(const DynamicType::Ptr& dt, DynamicType::GetTypes()) {
BOOST_FOREACH(const DynamicObject::Ptr& object, dt->GetObjects()) {
DbObject::Ptr dbobj = DbObject::GetOrCreateByObject(object);
if (dbobj) {
if (!GetObjectActive(dbobj))
ActivateObject(dbobj);
dbobj->SendConfigUpdate();
dbobj->SendStatusUpdate();
}
UpdateObject(object);
}
}
}

1
lib/db_ido/dbconnection.hpp
View File

@ -90,6 +90,7 @@ protected:
virtual void FillIDCache(const DbType::Ptr& type) = 0;
virtual void NewTransaction(void) = 0;
void UpdateObject(const DynamicObject::Ptr& object);
void UpdateAllObjects(void);
void PrepareDatabase(void);

2
lib/db_ido/dbconnection.ti
View File

@ -20,6 +20,8 @@
#include "db_ido/dbquery.hpp"
#include "base/dynamicobject.hpp"
library db_ido;
namespace icinga
{

191
lib/db_ido/dbevents.cpp
View File

@ -51,15 +51,15 @@ void DbEvents::StaticInitialize(void)
Checkable::OnAcknowledgementSet.connect(boost::bind(&DbEvents::AddAcknowledgement, _1, _4));
Checkable::OnAcknowledgementCleared.connect(boost::bind(&DbEvents::RemoveAcknowledgement, _1));
Checkable::OnNextCheckChanged.connect(boost::bind(&DbEvents::NextCheckChangedHandler, _1, _2));
Checkable::OnFlappingChanged.connect(boost::bind(&DbEvents::FlappingChangedHandler, _1, _2));
Checkable::OnNextCheckChanged.connect(boost::bind(&DbEvents::NextCheckChangedHandler, _1));
Checkable::OnFlappingChanged.connect(boost::bind(&DbEvents::FlappingChangedHandler, _1));
Checkable::OnNotificationSentToAllUsers.connect(boost::bind(&DbEvents::LastNotificationChangedHandler, _1, _2));
Checkable::OnEnableActiveChecksChanged.connect(boost::bind(&DbEvents::EnableActiveChecksChangedHandler, _1, _2));
Checkable::OnEnablePassiveChecksChanged.connect(boost::bind(&DbEvents::EnablePassiveChecksChangedHandler, _1, _2));
Checkable::OnEnableNotificationsChanged.connect(boost::bind(&DbEvents::EnableNotificationsChangedHandler, _1, _2));
Checkable::OnEnablePerfdataChanged.connect(boost::bind(&DbEvents::EnablePerfdataChangedHandler, _1, _2));
Checkable::OnEnableFlappingChanged.connect(boost::bind(&DbEvents::EnableFlappingChangedHandler, _1, _2));
Checkable::OnEnableActiveChecksChanged.connect(boost::bind(&DbEvents::EnableActiveChecksChangedHandler, _1));
Checkable::OnEnablePassiveChecksChanged.connect(boost::bind(&DbEvents::EnablePassiveChecksChangedHandler, _1));
Checkable::OnEnableNotificationsChanged.connect(boost::bind(&DbEvents::EnableNotificationsChangedHandler, _1));
Checkable::OnEnablePerfdataChanged.connect(boost::bind(&DbEvents::EnablePerfdataChangedHandler, _1));
Checkable::OnEnableFlappingChanged.connect(boost::bind(&DbEvents::EnableFlappingChangedHandler, _1));
Checkable::OnReachabilityChanged.connect(boost::bind(&DbEvents::ReachabilityChangedHandler, _1, _2, _3));
@ -74,11 +74,13 @@ void DbEvents::StaticInitialize(void)
Checkable::OnNewCheckResult.connect(boost::bind(&DbEvents::AddCheckResultLogHistory, _1, _2));
Checkable::OnNotificationSentToUser.connect(boost::bind(&DbEvents::AddNotificationSentLogHistory, _1, _2, _3, _4, _5, _6, _7));
Checkable::OnFlappingChanged.connect(boost::bind(&DbEvents::AddFlappingLogHistory, _1, _2));
Checkable::OnFlappingChanged.connect(boost::bind(&DbEvents::AddFlappingChangedLogHistory, _1));
Checkable::OnEnableFlappingChanged.connect(boost::bind(&DbEvents::AddEnableFlappingChangedLogHistory, _1));
Checkable::OnDowntimeTriggered.connect(boost::bind(&DbEvents::AddTriggerDowntimeLogHistory, _1, _2));
Checkable::OnDowntimeRemoved.connect(boost::bind(&DbEvents::AddRemoveDowntimeLogHistory, _1, _2));
Checkable::OnFlappingChanged.connect(boost::bind(&DbEvents::AddFlappingHistory, _1, _2));
Checkable::OnFlappingChanged.connect(boost::bind(&DbEvents::AddFlappingChangedHistory, _1));
Checkable::OnEnableFlappingChanged.connect(boost::bind(&DbEvents::AddEnableFlappingChangedHistory, _1));
Checkable::OnNewCheckResult.connect(boost::bind(&DbEvents::AddCheckableCheckHistory, _1, _2));
Checkable::OnEventCommandExecuted.connect(boost::bind(&DbEvents::AddEventHandlerHistory, _1));
@ -87,7 +89,7 @@ void DbEvents::StaticInitialize(void)
}
/* check events */
void DbEvents::NextCheckChangedHandler(const Checkable::Ptr& checkable, double nextCheck)
void DbEvents::NextCheckChangedHandler(const Checkable::Ptr& checkable)
{
Host::Ptr host;
Service::Ptr service;
@ -105,7 +107,7 @@ void DbEvents::NextCheckChangedHandler(const Checkable::Ptr& checkable, double n
query1.Object = DbObject::GetOrCreateByObject(checkable);
Dictionary::Ptr fields1 = new Dictionary();
fields1->Set("next_check", DbValue::FromTimestamp(nextCheck));
fields1->Set("next_check", DbValue::FromTimestamp(checkable->GetNextCheck()));
query1.Fields = fields1;
@ -120,7 +122,7 @@ void DbEvents::NextCheckChangedHandler(const Checkable::Ptr& checkable, double n
DbObject::OnQuery(query1);
}
void DbEvents::FlappingChangedHandler(const Checkable::Ptr& checkable, FlappingState state)
void DbEvents::FlappingChangedHandler(const Checkable::Ptr& checkable)
{
Host::Ptr host;
Service::Ptr service;
@ -240,32 +242,32 @@ void DbEvents::ReachabilityChangedHandler(const Checkable::Ptr& checkable, const
}
/* enable changed events */
void DbEvents::EnableActiveChecksChangedHandler(const Checkable::Ptr& checkable, bool enabled)
void DbEvents::EnableActiveChecksChangedHandler(const Checkable::Ptr& checkable)
{
EnableChangedHandlerInternal(checkable, enabled, EnableActiveChecks);
EnableChangedHandlerInternal(checkable, "active_checks_enabled", checkable->GetEnableActiveChecks());
}
void DbEvents::EnablePassiveChecksChangedHandler(const Checkable::Ptr& checkable, bool enabled)
void DbEvents::EnablePassiveChecksChangedHandler(const Checkable::Ptr& checkable)
{
EnableChangedHandlerInternal(checkable, enabled, EnablePassiveChecks);
EnableChangedHandlerInternal(checkable, "passive_checks_enabled", checkable->GetEnablePassiveChecks());
}
void DbEvents::EnableNotificationsChangedHandler(const Checkable::Ptr& checkable, bool enabled)
void DbEvents::EnableNotificationsChangedHandler(const Checkable::Ptr& checkable)
{
EnableChangedHandlerInternal(checkable, enabled, EnableNotifications);
EnableChangedHandlerInternal(checkable, "notifications_enabled", checkable->GetEnableNotifications());
}
void DbEvents::EnablePerfdataChangedHandler(const Checkable::Ptr& checkable, bool enabled)
void DbEvents::EnablePerfdataChangedHandler(const Checkable::Ptr& checkable)
{
EnableChangedHandlerInternal(checkable, enabled, EnablePerfdata);
EnableChangedHandlerInternal(checkable, "process_performance_data", checkable->GetEnablePerfdata());
}
void DbEvents::EnableFlappingChangedHandler(const Checkable::Ptr& checkable, bool enabled)
void DbEvents::EnableFlappingChangedHandler(const Checkable::Ptr& checkable)
{
EnableChangedHandlerInternal(checkable, enabled, EnableFlapping);
EnableChangedHandlerInternal(checkable, "flap_detection_enabled", checkable->GetEnableFlapping());
}
void DbEvents::EnableChangedHandlerInternal(const Checkable::Ptr& checkable, bool enabled, EnableType type)
void DbEvents::EnableChangedHandlerInternal(const Checkable::Ptr& checkable, const String& fieldName, bool enabled)
{
Host::Ptr host;
Service::Ptr service;
@ -283,19 +285,7 @@ void DbEvents::EnableChangedHandlerInternal(const Checkable::Ptr& checkable, boo
query1.Object = DbObject::GetOrCreateByObject(checkable);
Dictionary::Ptr fields1 = new Dictionary();
if (type == EnableActiveChecks) {
fields1->Set("active_checks_enabled", enabled ? 1 : 0);
} else if (type == EnablePassiveChecks) {
fields1->Set("passive_checks_enabled", enabled ? 1 : 0);
} else if (type == EnableNotifications) {
fields1->Set("notifications_enabled", enabled ? 1 : 0);
} else if (type == EnablePerfdata) {
fields1->Set("process_performance_data", enabled ? 1 : 0);
} else if (type == EnableFlapping) {
fields1->Set("flap_detection_enabled", enabled ? 1 : 0);
}
fields1->Set(fieldName, enabled);
query1.Fields = fields1;
query1.WhereCriteria = new Dictionary();
@ -309,6 +299,7 @@ void DbEvents::EnableChangedHandlerInternal(const Checkable::Ptr& checkable, boo
DbObject::OnQuery(query1);
}
/* comments */
void DbEvents::AddComments(const Checkable::Ptr& checkable)
{
@ -1174,28 +1165,17 @@ void DbEvents::AddNotificationSentLogHistory(const Notification::Ptr& notificati
AddLogHistory(checkable, msgbuf.str(), LogEntryTypeHostNotification);
}
void DbEvents::AddFlappingLogHistory(const Checkable::Ptr& checkable, FlappingState flapping_state)
void DbEvents::AddFlappingChangedLogHistory(const Checkable::Ptr& checkable)
{
String flapping_state_str;
String flapping_output;
switch (flapping_state) {
case FlappingStarted:
flapping_output = "Service appears to have started flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change >= " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STARTED";
break;
case FlappingStopped:
flapping_output = "Service appears to have stopped flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change < " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STOPPED";
break;
case FlappingDisabled:
flapping_output = "Flap detection has been disabled";
flapping_state_str = "DISABLED";
break;
default:
Log(LogCritical, "DbEvents")
<< "Unknown flapping state: " << flapping_state;
return;
if (checkable->IsFlapping()) {
flapping_output = "Service appears to have started flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change >= " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STARTED";
} else {
flapping_output = "Service appears to have stopped flapping (" + Convert::ToString(checkable->GetFlappingCurrent()) + "% change < " + Convert::ToString(checkable->GetFlappingThreshold()) + "% threshold)";
flapping_state_str = "STOPPED";
}
Host::Ptr host;
@ -1222,6 +1202,38 @@ void DbEvents::AddFlappingLogHistory(const Checkable::Ptr& checkable, FlappingSt
AddLogHistory(checkable, msgbuf.str(), LogEntryTypeInfoMessage);
}
void DbEvents::AddEnableFlappingChangedLogHistory(const Checkable::Ptr& checkable)
{
if (!checkable->GetEnableFlapping())
return;
String flapping_output = "Flap detection has been disabled";
String flapping_state_str = "DISABLED";
Host::Ptr host;
Service::Ptr service;
tie(host, service) = GetHostService(checkable);
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
<< "";
}
AddLogHistory(checkable, msgbuf.str(), LogEntryTypeInfoMessage);
}
void DbEvents::AddLogHistory(const Checkable::Ptr& checkable, String buffer, LogEntryType type)
{
Log(LogDebug, "DbEvents")
@ -1256,7 +1268,7 @@ void DbEvents::AddLogHistory(const Checkable::Ptr& checkable, String buffer, Log
}
/* flappinghistory */
void DbEvents::AddFlappingHistory(const Checkable::Ptr& checkable, FlappingState flapping_state)
void DbEvents::AddFlappingChangedHistory(const Checkable::Ptr& checkable)
{
Log(LogDebug, "DbEvents")
<< "add flapping history for '" << checkable->GetName() << "'";
@ -1274,22 +1286,11 @@ void DbEvents::AddFlappingHistory(const Checkable::Ptr& checkable, FlappingState
fields1->Set("event_time", DbValue::FromTimestamp(time_bag.first));
fields1->Set("event_time_usec", time_bag.second);
switch (flapping_state) {
case FlappingStarted:
fields1->Set("event_type", 1000);
break;
case FlappingStopped:
fields1->Set("event_type", 1001);
fields1->Set("reason_type", 1);
break;
case FlappingDisabled:
fields1->Set("event_type", 1001);
fields1->Set("reason_type", 2);
break;
default:
Log(LogDebug, "DbEvents")
<< "Unhandled flapping state: " << flapping_state;
return;
if (checkable->IsFlapping())
fields1->Set("event_type", 1000);
else {
fields1->Set("event_type", 1001);
fields1->Set("reason_type", 1);
}
Host::Ptr host;
@ -1314,6 +1315,52 @@ void DbEvents::AddFlappingHistory(const Checkable::Ptr& checkable, FlappingState
DbObject::OnQuery(query1);
}
void DbEvents::AddEnableFlappingChangedHistory(const Checkable::Ptr& checkable)
{
Log(LogDebug, "DbEvents")
<< "add flapping history for '" << checkable->GetName() << "'";
double now = Utility::GetTime();
std::pair<unsigned long, unsigned long> time_bag = CompatUtility::ConvertTimestamp(now);
DbQuery query1;
query1.Table = "flappinghistory";
query1.Type = DbQueryInsert;
query1.Category = DbCatFlapping;
Dictionary::Ptr fields1 = new Dictionary();
fields1->Set("event_time", DbValue::FromTimestamp(time_bag.first));
fields1->Set("event_time_usec", time_bag.second);
if (!checkable->GetEnableFlapping())
return;
fields1->Set("event_type", 1001);
fields1->Set("reason_type", 2);
Host::Ptr host;
Service::Ptr service;
tie(host, service) = GetHostService(checkable);
fields1->Set("flapping_type", service ? 1 : 0);
fields1->Set("object_id", checkable);
fields1->Set("percent_state_change", checkable->GetFlappingCurrent());
fields1->Set("low_threshold", checkable->GetFlappingThreshold());
fields1->Set("high_threshold", checkable->GetFlappingThreshold());
fields1->Set("instance_id", 0); /* DbConnection class fills in real ID */
String node = IcingaApplication::GetInstance()->GetNodeName();
Endpoint::Ptr endpoint = Endpoint::GetByName(node);
if (endpoint)
fields1->Set("endpoint_object_id", endpoint);
query1.Fields = fields1;
DbObject::OnQuery(query1);
}
/* servicechecks */
void DbEvents::AddCheckableCheckHistory(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr)
{

32
lib/db_ido/dbevents.hpp
View File

@ -51,15 +51,6 @@ enum LogEntryType
LogEntryTypeServiceNotification = 1048576
};
enum EnableType
{
EnableActiveChecks = 1,
EnablePassiveChecks = 2,
EnableNotifications = 3,
EnablePerfdata = 4,
EnableFlapping = 5
};
/**
* IDO events
*
@ -81,15 +72,15 @@ public:
static void AddLogHistory(const Checkable::Ptr& checkable, String buffer, LogEntryType type);
/* Status */
static void NextCheckChangedHandler(const Checkable::Ptr& checkable, double nextCheck);
static void FlappingChangedHandler(const Checkable::Ptr& checkable, FlappingState state);
static void NextCheckChangedHandler(const Checkable::Ptr& checkable);
static void FlappingChangedHandler(const Checkable::Ptr& checkable);
static void LastNotificationChangedHandler(const Notification::Ptr& notification, const Checkable::Ptr& checkable);
static void EnableActiveChecksChangedHandler(const Checkable::Ptr& checkable, bool enabled);
static void EnablePassiveChecksChangedHandler(const Checkable::Ptr& checkable, bool enabled);
static void EnableNotificationsChangedHandler(const Checkable::Ptr& checkable, bool enabled);
static void EnablePerfdataChangedHandler(const Checkable::Ptr& checkable, bool enabled);
static void EnableFlappingChangedHandler(const Checkable::Ptr& checkable, bool enabled);
static void EnableActiveChecksChangedHandler(const Checkable::Ptr& checkable);
static void EnablePassiveChecksChangedHandler(const Checkable::Ptr& checkable);
static void EnableNotificationsChangedHandler(const Checkable::Ptr& checkable);
static void EnablePerfdataChangedHandler(const Checkable::Ptr& checkable);
static void EnableFlappingChangedHandler(const Checkable::Ptr& checkable);
static void AddComment(const Checkable::Ptr& checkable, const Comment::Ptr& comment);
static void RemoveComment(const Checkable::Ptr& checkable, const Comment::Ptr& comment);
@ -125,10 +116,13 @@ public:
static void AddNotificationSentLogHistory(const Notification::Ptr& notification, const Checkable::Ptr& checkable,
const User::Ptr& user, NotificationType notification_type, const CheckResult::Ptr& cr, const String& author,
const String& comment_text);
static void AddFlappingLogHistory(const Checkable::Ptr& checkable, FlappingState flapping_state);
static void AddFlappingChangedLogHistory(const Checkable::Ptr& checkable);
static void AddEnableFlappingChangedLogHistory(const Checkable::Ptr& checkable);
/* other history */
static void AddFlappingHistory(const Checkable::Ptr& checkable, FlappingState flapping_state);
static void AddFlappingChangedHistory(const Checkable::Ptr& checkable);
static void AddEnableFlappingChangedHistory(const Checkable::Ptr& checkable);
static void AddCheckableCheckHistory(const Checkable::Ptr& checkable, const CheckResult::Ptr &cr);
static void AddEventHandlerHistory(const Checkable::Ptr& checkable);
static void AddExternalCommandHistory(double time, const String& command, const std::vector<String>& arguments);
@ -138,7 +132,7 @@ private:
static void AddCommentInternal(const Checkable::Ptr& checkable, const Comment::Ptr& comment, bool historical);
static void AddDowntimeInternal(const Checkable::Ptr& checkable, const Downtime::Ptr& downtime, bool historical);
static void EnableChangedHandlerInternal(const Checkable::Ptr& checkable, bool enabled, EnableType type);
static void EnableChangedHandlerInternal(const Checkable::Ptr& checkable, const String& fieldName, bool enabled);
};
}

1
lib/db_ido_mysql/CMakeLists.txt
View File

@ -36,6 +36,7 @@ if(MYSQL_FOUND)
set_target_properties (
db_ido_mysql PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_DB_IDO_MYSQL_BUILD
FOLDER Components
)

2
lib/db_ido_mysql/idomysqlconnection.ti
View File

@ -19,6 +19,8 @@
#include "db_ido/dbconnection.hpp"
library db_ido_mysql;
namespace icinga
{

1
lib/db_ido_pgsql/CMakeLists.txt
View File

@ -38,6 +38,7 @@ if(PostgreSQL_FOUND)
set_target_properties (
db_ido_pgsql PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_DB_IDO_PGSQL_BUILD
FOLDER Components
)

2
lib/db_ido_pgsql/idopgsqlconnection.ti
View File

@ -19,6 +19,8 @@
#include "db_ido/dbconnection.hpp"
library db_ido_pgsql;
namespace icinga
{

1
lib/demo/CMakeLists.txt
View File

@ -32,6 +32,7 @@ target_link_libraries(demo ${Boost_LIBRARIES} base config icinga remote)
set_target_properties (
demo PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_DEMO_BUILD
FOLDER Components
)

3
lib/demo/demo.cpp
View File

@ -53,7 +53,8 @@ void Demo::DemoTimerHandler(void)
ApiListener::Ptr listener = ApiListener::GetInstance();
if (listener) {
listener->RelayMessage(MessageOrigin(), DynamicObject::Ptr(), message, true);
MessageOrigin::Ptr origin = new MessageOrigin();
listener->RelayMessage(origin, DynamicObject::Ptr(), message, true);
Log(LogInformation, "Demo", "Sent demo::HelloWorld message");
}
}

2
lib/demo/demo.ti
View File

@ -19,6 +19,8 @@
#include "base/dynamicobject.hpp"
library demo;
namespace icinga
{

1
lib/hello/CMakeLists.txt
View File

@ -34,6 +34,7 @@ target_link_libraries(hello ${Boost_LIBRARIES} base config)
set_target_properties (
hello PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_HELLO_BUILD
FOLDER Lib
)

2
lib/hello/hello.ti
View File

@ -19,6 +19,8 @@
#include "base/application.hpp"
library hello;
namespace icinga
{

375
lib/icinga/apievents.cpp
View File

File diff suppressed because it is too large Load Diff

100
lib/icinga/apievents.hpp
View File

@ -37,84 +37,84 @@ class I2_ICINGA_API ApiEvents
public:
static void StaticInitialize(void);
static void CheckResultHandler(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr, const MessageOrigin& origin);
static Value CheckResultAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void CheckResultHandler(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr, const MessageOrigin::Ptr& origin);
static Value CheckResultAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void NextCheckChangedHandler(const Checkable::Ptr& checkable, double nextCheck, const MessageOrigin& origin);
static Value NextCheckChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void NextCheckChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value NextCheckChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void NextNotificationChangedHandler(const Notification::Ptr& notification, double nextCheck, const MessageOrigin& origin);
static Value NextNotificationChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void NextNotificationChangedHandler(const Notification::Ptr& notification, const MessageOrigin::Ptr& origin);
static Value NextNotificationChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void ForceNextCheckChangedHandler(const Checkable::Ptr& checkable, bool forced, const MessageOrigin& origin);
static Value ForceNextCheckChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void ForceNextCheckChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value ForceNextCheckChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void ForceNextNotificationChangedHandler(const Checkable::Ptr& checkable, bool forced, const MessageOrigin& origin);
static Value ForceNextNotificationChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void ForceNextNotificationChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value ForceNextNotificationChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void EnableActiveChecksChangedHandler(const Checkable::Ptr& checkable, bool enabled, const MessageOrigin& origin);
static Value EnableActiveChecksChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void EnableActiveChecksChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value EnableActiveChecksChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void EnablePassiveChecksChangedHandler(const Checkable::Ptr& checkable, bool enabled, const MessageOrigin& origin);
static Value EnablePassiveChecksChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void EnablePassiveChecksChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value EnablePassiveChecksChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void EnableNotificationsChangedHandler(const Checkable::Ptr& checkable, bool enabled, const MessageOrigin& origin);
static Value EnableNotificationsChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void EnableNotificationsChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value EnableNotificationsChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void EnableFlappingChangedHandler(const Checkable::Ptr& checkable, bool enabled, const MessageOrigin& origin);
static Value EnableFlappingChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void EnableFlappingChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value EnableFlappingChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void EnableEventHandlerChangedHandler(const Checkable::Ptr& checkable, bool enabled, const MessageOrigin& origin);
static Value EnableEventHandlerChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void EnableEventHandlerChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value EnableEventHandlerChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void EnablePerfdataChangedHandler(const Checkable::Ptr& checkable, bool enabled, const MessageOrigin& origin);
static Value EnablePerfdataChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void EnablePerfdataChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value EnablePerfdataChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void CheckIntervalChangedHandler(const Checkable::Ptr& checkable, double interval, const MessageOrigin& origin);
static Value CheckIntervalChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void CheckIntervalChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value CheckIntervalChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void RetryIntervalChangedHandler(const Checkable::Ptr& checkable, double interval, const MessageOrigin& origin);
static Value RetryIntervalChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void RetryIntervalChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value RetryIntervalChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void MaxCheckAttemptsChangedHandler(const Checkable::Ptr& checkable, int attempts, const MessageOrigin& origin);
static Value MaxCheckAttemptsChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void MaxCheckAttemptsChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value MaxCheckAttemptsChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void EventCommandChangedHandler(const Checkable::Ptr& checkable, const EventCommand::Ptr& command, const MessageOrigin& origin);
static Value EventCommandChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void EventCommandChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value EventCommandChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void CheckCommandChangedHandler(const Checkable::Ptr& checkable, const CheckCommand::Ptr& command, const MessageOrigin& origin);
static Value CheckCommandChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void CheckCommandChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value CheckCommandChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void CheckPeriodChangedHandler(const Checkable::Ptr& checkable, const TimePeriod::Ptr& timeperiod, const MessageOrigin& origin);
static Value CheckPeriodChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void CheckPeriodChangedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value CheckPeriodChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void VarsChangedHandler(const CustomVarObject::Ptr& object, const Dictionary::Ptr& vars, const MessageOrigin& origin);
static Value VarsChangedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void VarsChangedHandler(const CustomVarObject::Ptr& object, const MessageOrigin::Ptr& origin);
static Value VarsChangedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void CommentAddedHandler(const Checkable::Ptr& checkable, const Comment::Ptr& comment, const MessageOrigin& origin);
static Value CommentAddedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void CommentAddedHandler(const Checkable::Ptr& checkable, const Comment::Ptr& comment, const MessageOrigin::Ptr& origin);
static Value CommentAddedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void CommentRemovedHandler(const Checkable::Ptr& checkable, const Comment::Ptr& comment, const MessageOrigin& origin);
static Value CommentRemovedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void CommentRemovedHandler(const Checkable::Ptr& checkable, const Comment::Ptr& comment, const MessageOrigin::Ptr& origin);
static Value CommentRemovedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void DowntimeAddedHandler(const Checkable::Ptr& checkable, const Downtime::Ptr& downtime, const MessageOrigin& origin);
static Value DowntimeAddedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void DowntimeAddedHandler(const Checkable::Ptr& checkable, const Downtime::Ptr& downtime, const MessageOrigin::Ptr& origin);
static Value DowntimeAddedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void DowntimeRemovedHandler(const Checkable::Ptr& checkable, const Downtime::Ptr& downtime, const MessageOrigin& origin);
static Value DowntimeRemovedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void DowntimeRemovedHandler(const Checkable::Ptr& checkable, const Downtime::Ptr& downtime, const MessageOrigin::Ptr& origin);
static Value DowntimeRemovedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void AcknowledgementSetHandler(const Checkable::Ptr& checkable, const String& author, const String& comment, AcknowledgementType type,
bool notify, double expiry, const MessageOrigin& origin);
static Value AcknowledgementSetAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
bool notify, double expiry, const MessageOrigin::Ptr& origin);
static Value AcknowledgementSetAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static void AcknowledgementClearedHandler(const Checkable::Ptr& checkable, const MessageOrigin& origin);
static Value AcknowledgementClearedAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static void AcknowledgementClearedHandler(const Checkable::Ptr& checkable, const MessageOrigin::Ptr& origin);
static Value AcknowledgementClearedAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static Value ExecuteCommandAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static Value ExecuteCommandAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static String GetRepositoryDir(void);
static void RepositoryTimerHandler(void);
static Value UpdateRepositoryAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static Value UpdateRepositoryAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static Dictionary::Ptr MakeCheckResultMessage(const Checkable::Ptr& checkable, const CheckResult::Ptr& cr);
};

160
lib/icinga/checkable-check.cpp
View File

@ -35,90 +35,19 @@
using namespace icinga;
boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, const MessageOrigin&)> Checkable::OnNewCheckResult;
boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, StateType, const MessageOrigin&)> Checkable::OnStateChange;
boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, std::set<Checkable::Ptr>, const MessageOrigin&)> Checkable::OnReachabilityChanged;
boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, const MessageOrigin::Ptr&)> Checkable::OnNewCheckResult;
boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, StateType, const MessageOrigin::Ptr&)> Checkable::OnStateChange;
boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, std::set<Checkable::Ptr>, const MessageOrigin::Ptr&)> Checkable::OnReachabilityChanged;
boost::signals2::signal<void (const Checkable::Ptr&, NotificationType, const CheckResult::Ptr&, const String&, const String&)> Checkable::OnNotificationsRequested;
boost::signals2::signal<void (const Checkable::Ptr&, double, const MessageOrigin&)> Checkable::OnNextCheckChanged;
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnForceNextCheckChanged;
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnForceNextNotificationChanged;
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnEnableActiveChecksChanged;
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnEnablePassiveChecksChanged;
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnEnableNotificationsChanged;
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnEnableFlappingChanged;
boost::signals2::signal<void (const Checkable::Ptr&, double, const MessageOrigin&)> Checkable::OnCheckIntervalChanged;
boost::signals2::signal<void (const Checkable::Ptr&, double, const MessageOrigin&)> Checkable::OnRetryIntervalChanged;
boost::signals2::signal<void (const Checkable::Ptr&, const CheckCommand::Ptr&, const MessageOrigin&)> Checkable::OnCheckCommandChanged;
boost::signals2::signal<void (const Checkable::Ptr&, int, const MessageOrigin&)> Checkable::OnMaxCheckAttemptsChanged;
boost::signals2::signal<void (const Checkable::Ptr&, const TimePeriod::Ptr&, const MessageOrigin&)> Checkable::OnCheckPeriodChanged;
boost::signals2::signal<void (const Checkable::Ptr&, FlappingState)> Checkable::OnFlappingChanged;
CheckCommand::Ptr Checkable::GetCheckCommand(void) const
{
String command;
if (!GetOverrideCheckCommand().IsEmpty())
command = GetOverrideCheckCommand();
else
command = GetCheckCommandRaw();
return CheckCommand::GetByName(command);
}
void Checkable::SetCheckCommand(const CheckCommand::Ptr& command, const MessageOrigin& origin)
{
SetOverrideCheckCommand(command->GetName());
OnCheckCommandChanged(this, command, origin);
return CheckCommand::GetByName(GetCheckCommandRaw());
}
TimePeriod::Ptr Checkable::GetCheckPeriod(void) const
{
String tp;
if (!GetOverrideCheckPeriod().IsEmpty())
tp = GetOverrideCheckPeriod();
else
tp = GetCheckPeriodRaw();
return TimePeriod::GetByName(tp);
}
void Checkable::SetCheckPeriod(const TimePeriod::Ptr& tp, const MessageOrigin& origin)
{
SetOverrideCheckPeriod(tp->GetName());
OnCheckPeriodChanged(this, tp, origin);
}
double Checkable::GetCheckInterval(void) const
{
if (!GetOverrideCheckInterval().IsEmpty())
return GetOverrideCheckInterval();
else
return GetCheckIntervalRaw();
}
void Checkable::SetCheckInterval(double interval, const MessageOrigin& origin)
{
SetOverrideCheckInterval(interval);
OnCheckIntervalChanged(this, interval, origin);
}
double Checkable::GetRetryInterval(void) const
{
if (!GetOverrideRetryInterval().IsEmpty())
return GetOverrideRetryInterval();
else
return GetRetryIntervalRaw();
}
void Checkable::SetRetryInterval(double interval, const MessageOrigin& origin)
{
SetOverrideRetryInterval(interval);
OnRetryIntervalChanged(this, interval, origin);
return TimePeriod::GetByName(GetCheckPeriodRaw());
}
void Checkable::SetSchedulingOffset(long offset)
@ -131,18 +60,6 @@ long Checkable::GetSchedulingOffset(void)
return m_SchedulingOffset;
}
void Checkable::SetNextCheck(double nextCheck, const MessageOrigin& origin)
{
SetNextCheckRaw(nextCheck);
OnNextCheckChanged(this, nextCheck, origin);
}
double Checkable::GetNextCheck(void)
{
return GetNextCheckRaw();
}
void Checkable::UpdateNextCheck(void)
{
double interval;
@ -177,64 +94,7 @@ double Checkable::GetLastCheck(void) const
return schedule_end;
}
bool Checkable::GetEnableActiveChecks(void) const
{
if (!GetOverrideEnableActiveChecks().IsEmpty())
return GetOverrideEnableActiveChecks();
else
return GetEnableActiveChecksRaw();
}
void Checkable::SetEnableActiveChecks(bool enabled, const MessageOrigin& origin)
{
SetOverrideEnableActiveChecks(enabled);
OnEnableActiveChecksChanged(this, enabled, origin);
}
bool Checkable::GetEnablePassiveChecks(void) const
{
if (!GetOverrideEnablePassiveChecks().IsEmpty())
return GetOverrideEnablePassiveChecks();
else
return GetEnablePassiveChecksRaw();
}
void Checkable::SetEnablePassiveChecks(bool enabled, const MessageOrigin& origin)
{
SetOverrideEnablePassiveChecks(enabled);
OnEnablePassiveChecksChanged(this, enabled, origin);
}
bool Checkable::GetForceNextCheck(void) const
{
return GetForceNextCheckRaw();
}
void Checkable::SetForceNextCheck(bool forced, const MessageOrigin& origin)
{
SetForceNextCheckRaw(forced);
OnForceNextCheckChanged(this, forced, origin);
}
int Checkable::GetMaxCheckAttempts(void) const
{
if (!GetOverrideMaxCheckAttempts().IsEmpty())
return GetOverrideMaxCheckAttempts();
else
return GetMaxCheckAttemptsRaw();
}
void Checkable::SetMaxCheckAttempts(int attempts, const MessageOrigin& origin)
{
SetOverrideMaxCheckAttempts(attempts);
OnMaxCheckAttemptsChanged(this, attempts, origin);
}
void Checkable::ProcessCheckResult(const CheckResult::Ptr& cr, const MessageOrigin& origin)
void Checkable::ProcessCheckResult(const CheckResult::Ptr& cr, const MessageOrigin::Ptr& origin)
{
{
ObjectLock olock(this);
@ -255,7 +115,7 @@ void Checkable::ProcessCheckResult(const CheckResult::Ptr& cr, const MessageOrig
if (cr->GetExecutionEnd() == 0)
cr->SetExecutionEnd(now);
if (origin.IsLocal())
if (!origin || origin->IsLocal())
cr->SetCheckSource(IcingaApplication::GetInstance()->GetNodeName());
Endpoint::Ptr command_endpoint = GetCommandEndpoint();
@ -487,13 +347,15 @@ void Checkable::ProcessCheckResult(const CheckResult::Ptr& cr, const MessageOrig
Log(LogNotice, "Checkable")
<< "Flapping: Checkable " << GetName() << " started flapping (" << GetFlappingThreshold() << "% < " << GetFlappingCurrent() << "%).";
OnFlappingChanged(this, FlappingStarted);
NotifyFlapping(origin);
} else if (was_flapping && !is_flapping) {
OnNotificationsRequested(this, NotificationFlappingEnd, cr, "", "");
Log(LogNotice, "Checkable")
<< "Flapping: Checkable " << GetName() << " stopped flapping (" << GetFlappingThreshold() << "% >= " << GetFlappingCurrent() << "%).";
OnFlappingChanged(this, FlappingStopped);
NotifyFlapping(origin);
} else if (send_notification)
OnNotificationsRequested(this, recovery ? NotificationRecovery : NotificationProblem, cr, "", "");
}

8
lib/icinga/checkable-comment.cpp
View File

@ -33,8 +33,8 @@ static std::map<int, String> l_LegacyCommentsCache;
static std::map<String, Checkable::Ptr> l_CommentsCache;
static Timer::Ptr l_CommentsExpireTimer;
boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin&)> Checkable::OnCommentAdded;
boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin&)> Checkable::OnCommentRemoved;
boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin::Ptr&)> Checkable::OnCommentAdded;
boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin::Ptr&)> Checkable::OnCommentRemoved;
int Checkable::GetNextCommentID(void)
{
@ -44,7 +44,7 @@ int Checkable::GetNextCommentID(void)
}
String Checkable::AddComment(CommentType entryType, const String& author,
const String& text, double expireTime, const String& id, const MessageOrigin& origin)
const String& text, double expireTime, const String& id, const MessageOrigin::Ptr& origin)
{
String uid;
@ -100,7 +100,7 @@ void Checkable::RemoveAllComments(void)
}
}
void Checkable::RemoveComment(const String& id, const MessageOrigin& origin)
void Checkable::RemoveComment(const String& id, const MessageOrigin::Ptr& origin)
{
Checkable::Ptr owner = GetOwnerByCommentID(id);

8
lib/icinga/checkable-downtime.cpp
View File

@ -34,8 +34,8 @@ static std::map<int, String> l_LegacyDowntimesCache;
static std::map<String, Checkable::Ptr> l_DowntimesCache;
static Timer::Ptr l_DowntimesExpireTimer;
boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin&)> Checkable::OnDowntimeAdded;
boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin&)> Checkable::OnDowntimeRemoved;
boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin::Ptr&)> Checkable::OnDowntimeAdded;
boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin::Ptr&)> Checkable::OnDowntimeRemoved;
boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&)> Checkable::OnDowntimeTriggered;
INITIALIZE_ONCE(&Checkable::StartDowntimesExpiredTimer);
@ -50,7 +50,7 @@ int Checkable::GetNextDowntimeID(void)
String Checkable::AddDowntime(const String& author, const String& comment,
double startTime, double endTime, bool fixed,
const String& triggeredBy, double duration, const String& scheduledBy,
const String& id, const MessageOrigin& origin)
const String& id, const MessageOrigin::Ptr& origin)
{
String uid;
@ -125,7 +125,7 @@ String Checkable::AddDowntime(const String& author, const String& comment,
return uid;
}
void Checkable::RemoveDowntime(const String& id, bool cancelled, const MessageOrigin& origin)
void Checkable::RemoveDowntime(const String& id, bool cancelled, const MessageOrigin::Ptr& origin)
{
Checkable::Ptr owner = GetOwnerByDowntimeID(id);

33
lib/icinga/checkable-event.cpp
View File

@ -28,41 +28,10 @@
using namespace icinga;
boost::signals2::signal<void (const Checkable::Ptr&)> Checkable::OnEventCommandExecuted;
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnEnableEventHandlerChanged;
boost::signals2::signal<void (const Checkable::Ptr&, const EventCommand::Ptr&, const MessageOrigin&)> Checkable::OnEventCommandChanged;
bool Checkable::GetEnableEventHandler(void) const
{
if (!GetOverrideEnableEventHandler().IsEmpty())
return GetOverrideEnableEventHandler();
else
return GetEnableEventHandlerRaw();
}
void Checkable::SetEnableEventHandler(bool enabled, const MessageOrigin& origin)
{
SetOverrideEnableEventHandler(enabled);
OnEnableEventHandlerChanged(this, enabled, origin);
}
EventCommand::Ptr Checkable::GetEventCommand(void) const
{
String command;
if (!GetOverrideEventCommand().IsEmpty())
command = GetOverrideEventCommand();
else
command = GetEventCommandRaw();
return EventCommand::GetByName(command);
}
void Checkable::SetEventCommand(const EventCommand::Ptr& command, const MessageOrigin& origin)
{
SetOverrideEventCommand(command->GetName());
OnEventCommandChanged(this, command, origin);
return EventCommand::GetByName(GetEventCommandRaw());
}
void Checkable::ExecuteEventHandler(const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros)

16
lib/icinga/checkable-flapping.cpp
View File

@ -34,22 +34,6 @@ double Checkable::GetFlappingCurrent(void) const
return 100 * GetFlappingPositive() / (GetFlappingPositive() + GetFlappingNegative());
}
bool Checkable::GetEnableFlapping(void) const
{
if (!GetOverrideEnableFlapping().IsEmpty())
return GetOverrideEnableFlapping();
else
return GetEnableFlappingRaw();
}
void Checkable::SetEnableFlapping(bool enabled, const MessageOrigin& origin)
{
SetOverrideEnableFlapping(enabled);
OnFlappingChanged(this, enabled ? FlappingEnabled : FlappingDisabled);
OnEnableFlappingChanged(this, enabled, origin);
}
void Checkable::UpdateFlappingStatus(bool stateChange)
{
double ts, now;

27
lib/icinga/checkable-notification.cpp
View File

@ -99,30 +99,3 @@ void Checkable::RemoveNotification(const Notification::Ptr& notification)
boost::mutex::scoped_lock lock(m_NotificationMutex);
m_Notifications.erase(notification);
}
bool Checkable::GetEnableNotifications(void) const
{
if (!GetOverrideEnableNotifications().IsEmpty())
return GetOverrideEnableNotifications();
else
return GetEnableNotificationsRaw();
}
void Checkable::SetEnableNotifications(bool enabled, const MessageOrigin& origin)
{
SetOverrideEnableNotifications(enabled);
OnEnableNotificationsChanged(this, enabled, origin);
}
bool Checkable::GetForceNextNotification(void) const
{
return GetForceNextNotificationRaw();
}
void Checkable::SetForceNextNotification(bool forced, const MessageOrigin& origin)
{
SetForceNextNotificationRaw(forced);
OnForceNextNotificationChanged(this, forced, origin);
}

128
lib/icinga/checkable.cpp
View File

@ -31,9 +31,8 @@ using namespace icinga;
REGISTER_TYPE(Checkable);
boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> Checkable::OnEnablePerfdataChanged;
boost::signals2::signal<void (const Checkable::Ptr&, const String&, const String&, AcknowledgementType, bool, double, const MessageOrigin&)> Checkable::OnAcknowledgementSet;
boost::signals2::signal<void (const Checkable::Ptr&, const MessageOrigin&)> Checkable::OnAcknowledgementCleared;
boost::signals2::signal<void (const Checkable::Ptr&, const String&, const String&, AcknowledgementType, bool, double, const MessageOrigin::Ptr&)> Checkable::OnAcknowledgementSet;
boost::signals2::signal<void (const Checkable::Ptr&, const MessageOrigin::Ptr&)> Checkable::OnAcknowledgementCleared;
Checkable::Checkable(void)
: m_CheckRunning(false)
@ -121,7 +120,7 @@ bool Checkable::IsAcknowledged(void)
return GetAcknowledgement() != AcknowledgementNone;
}
void Checkable::AcknowledgeProblem(const String& author, const String& comment, AcknowledgementType type, bool notify, double expiry, const MessageOrigin& origin)
void Checkable::AcknowledgeProblem(const String& author, const String& comment, AcknowledgementType type, bool notify, double expiry, const MessageOrigin::Ptr& origin)
{
SetAcknowledgementRaw(type);
SetAcknowledgementExpiry(expiry);
@ -132,7 +131,7 @@ void Checkable::AcknowledgeProblem(const String& author, const String& comment,
OnAcknowledgementSet(this, author, comment, type, notify, expiry, origin);
}
void Checkable::ClearAcknowledgement(const MessageOrigin& origin)
void Checkable::ClearAcknowledgement(const MessageOrigin::Ptr& origin)
{
SetAcknowledgementRaw(AcknowledgementNone);
SetAcknowledgementExpiry(0);
@ -140,121 +139,16 @@ void Checkable::ClearAcknowledgement(const MessageOrigin& origin)
OnAcknowledgementCleared(this, origin);
}
bool Checkable::GetEnablePerfdata(void) const
{
if (!GetOverrideEnablePerfdata().IsEmpty())
return GetOverrideEnablePerfdata();
else
return GetEnablePerfdataRaw();
}
void Checkable::SetEnablePerfdata(bool enabled, const MessageOrigin& origin)
{
SetOverrideEnablePerfdata(enabled);
OnEnablePerfdataChanged(this, enabled, origin);
}
int Checkable::GetModifiedAttributes(void) const
{
int attrs = 0;
if (!GetOverrideEnableNotifications().IsEmpty())
attrs |= ModAttrNotificationsEnabled;
if (!GetOverrideEnableActiveChecks().IsEmpty())
attrs |= ModAttrActiveChecksEnabled;
if (!GetOverrideEnablePassiveChecks().IsEmpty())
attrs |= ModAttrPassiveChecksEnabled;
if (!GetOverrideEnableFlapping().IsEmpty())
attrs |= ModAttrFlapDetectionEnabled;
if (!GetOverrideEnableEventHandler().IsEmpty())
attrs |= ModAttrEventHandlerEnabled;
if (!GetOverrideEnablePerfdata().IsEmpty())
attrs |= ModAttrPerformanceDataEnabled;
if (!GetOverrideCheckInterval().IsEmpty())
attrs |= ModAttrNormalCheckInterval;
if (!GetOverrideRetryInterval().IsEmpty())
attrs |= ModAttrRetryCheckInterval;
if (!GetOverrideEventCommand().IsEmpty())
attrs |= ModAttrEventHandlerCommand;
if (!GetOverrideCheckCommand().IsEmpty())
attrs |= ModAttrCheckCommand;
if (!GetOverrideMaxCheckAttempts().IsEmpty())
attrs |= ModAttrMaxCheckAttempts;
if (!GetOverrideCheckPeriod().IsEmpty())
attrs |= ModAttrCheckTimeperiod;
if (GetOverrideVars())
attrs |= ModAttrCustomVariable;
// TODO: finish
return attrs;
//TODO-MA
return 0;
}
void Checkable::SetModifiedAttributes(int flags, const MessageOrigin& origin)
void Checkable::SetModifiedAttributes(int flags, const MessageOrigin::Ptr& origin)
{
if ((flags & ModAttrNotificationsEnabled) == 0) {
SetOverrideEnableNotifications(Empty);
OnEnableNotificationsChanged(this, GetEnableNotifications(), origin);
}
if ((flags & ModAttrActiveChecksEnabled) == 0) {
SetOverrideEnableActiveChecks(Empty);
OnEnableActiveChecksChanged(this, GetEnableActiveChecks(), origin);
}
if ((flags & ModAttrPassiveChecksEnabled) == 0) {
SetOverrideEnablePassiveChecks(Empty);
OnEnablePassiveChecksChanged(this, GetEnablePassiveChecks(), origin);
}
if ((flags & ModAttrFlapDetectionEnabled) == 0) {
SetOverrideEnableFlapping(Empty);
OnEnableFlappingChanged(this, GetEnableFlapping(), origin);
}
if ((flags & ModAttrEventHandlerEnabled) == 0)
SetOverrideEnableEventHandler(Empty);
if ((flags & ModAttrPerformanceDataEnabled) == 0) {
SetOverrideEnablePerfdata(Empty);
OnEnablePerfdataChanged(this, GetEnablePerfdata(), origin);
}
if ((flags & ModAttrNormalCheckInterval) == 0)
SetOverrideCheckInterval(Empty);
if ((flags & ModAttrRetryCheckInterval) == 0)
SetOverrideRetryInterval(Empty);
if ((flags & ModAttrEventHandlerCommand) == 0)
SetOverrideEventCommand(Empty);
if ((flags & ModAttrCheckCommand) == 0)
SetOverrideCheckCommand(Empty);
if ((flags & ModAttrMaxCheckAttempts) == 0)
SetOverrideMaxCheckAttempts(Empty);
if ((flags & ModAttrCheckTimeperiod) == 0)
SetOverrideCheckPeriod(Empty);
if ((flags & ModAttrCustomVariable) == 0) {
SetOverrideVars(Empty);
OnVarsChanged(this, GetVars(), origin);
}
//TODO-MA
return;
}
Endpoint::Ptr Checkable::GetCommandEndpoint(void) const
@ -262,9 +156,9 @@ Endpoint::Ptr Checkable::GetCommandEndpoint(void) const
return Endpoint::GetByName(GetCommandEndpointRaw());
}
void Checkable::ValidateCheckIntervalRaw(double value, const ValidationUtils& utils)
void Checkable::ValidateCheckInterval(double value, const ValidationUtils& utils)
{
ObjectImpl<Checkable>::ValidateCheckIntervalRaw(value, utils);
ObjectImpl<Checkable>::ValidateCheckInterval(value, utils);
if (value <= 0)
BOOST_THROW_EXCEPTION(ValidationError(this, boost::assign::list_of("check_interval"), "Interval must be greater than 0."));

107
lib/icinga/checkable.hpp
View File

@ -32,19 +32,6 @@
namespace icinga
{
/**
* The state of service flapping.
*
* @ingroup icinga
*/
enum FlappingState
{
FlappingStarted = 0,
FlappingDisabled = 1,
FlappingStopped = 2,
FlappingEnabled = 3
};
/**
* @ingroup icinga
*/
@ -94,53 +81,30 @@ public:
AcknowledgementType GetAcknowledgement(void);
void AcknowledgeProblem(const String& author, const String& comment, AcknowledgementType type, bool notify = true, double expiry = 0, const MessageOrigin& origin = MessageOrigin());
void ClearAcknowledgement(const MessageOrigin& origin = MessageOrigin());
void AcknowledgeProblem(const String& author, const String& comment, AcknowledgementType type, bool notify = true, double expiry = 0, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
void ClearAcknowledgement(const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
/* Checks */
intrusive_ptr<CheckCommand> GetCheckCommand(void) const;
void SetCheckCommand(const intrusive_ptr<CheckCommand>& command, const MessageOrigin& origin = MessageOrigin());
TimePeriod::Ptr GetCheckPeriod(void) const;
void SetCheckPeriod(const TimePeriod::Ptr& tp, const MessageOrigin& origin = MessageOrigin());
double GetCheckInterval(void) const;
void SetCheckInterval(double interval, const MessageOrigin& origin = MessageOrigin());
double GetRetryInterval(void) const;
void SetRetryInterval(double interval, const MessageOrigin& origin = MessageOrigin());
int GetMaxCheckAttempts(void) const;
void SetMaxCheckAttempts(int attempts, const MessageOrigin& origin = MessageOrigin());
long GetSchedulingOffset(void);
void SetSchedulingOffset(long offset);
void SetNextCheck(double nextCheck, const MessageOrigin& origin = MessageOrigin());
double GetNextCheck(void);
void UpdateNextCheck(void);
bool HasBeenChecked(void) const;
double GetLastCheck(void) const;
bool GetEnableActiveChecks(void) const;
void SetEnableActiveChecks(bool enabled, const MessageOrigin& origin = MessageOrigin());
bool GetEnablePassiveChecks(void) const;
void SetEnablePassiveChecks(bool enabled, const MessageOrigin& origin = MessageOrigin());
bool GetForceNextCheck(void) const;
void SetForceNextCheck(bool forced, const MessageOrigin& origin = MessageOrigin());
static void UpdateStatistics(const CheckResult::Ptr& cr, CheckableType type);
void ExecuteRemoteCheck(const Dictionary::Ptr& resolvedMacros = Dictionary::Ptr());
void ExecuteCheck();
void ProcessCheckResult(const CheckResult::Ptr& cr, const MessageOrigin& origin = MessageOrigin());
void ProcessCheckResult(const CheckResult::Ptr& cr, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
int GetModifiedAttributes(void) const;
void SetModifiedAttributes(int flags, const MessageOrigin& origin = MessageOrigin());
void SetModifiedAttributes(int flags, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
Endpoint::Ptr GetCommandEndpoint(void) const;
@ -149,26 +113,9 @@ public:
static double CalculateExecutionTime(const CheckResult::Ptr& cr);
static double CalculateLatency(const CheckResult::Ptr& cr);
static boost::signals2::signal<void (const Checkable::Ptr&, double, const MessageOrigin&)> OnNextCheckChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnForceNextCheckChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnForceNextNotificationChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnEnableActiveChecksChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnEnablePassiveChecksChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnEnableNotificationsChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnEnableFlappingChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnEnablePerfdataChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, bool, const MessageOrigin&)> OnEnableEventHandlerChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, double, const MessageOrigin&)> OnCheckIntervalChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, double, const MessageOrigin&)> OnRetryIntervalChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, int, const MessageOrigin&)> OnMaxCheckAttemptsChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, const intrusive_ptr<EventCommand>&, const MessageOrigin&)> OnEventCommandChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, const intrusive_ptr<CheckCommand>&, const MessageOrigin&)> OnCheckCommandChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, const TimePeriod::Ptr&, const MessageOrigin&)> OnCheckPeriodChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, const MessageOrigin&)> OnNewCheckResult;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, StateType, const MessageOrigin&)> OnStateChange;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, std::set<Checkable::Ptr>, const MessageOrigin&)> OnReachabilityChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, const MessageOrigin::Ptr&)> OnNewCheckResult;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, StateType, const MessageOrigin::Ptr&)> OnStateChange;
static boost::signals2::signal<void (const Checkable::Ptr&, const CheckResult::Ptr&, std::set<Checkable::Ptr>, const MessageOrigin::Ptr&)> OnReachabilityChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, NotificationType, const CheckResult::Ptr&,
const String&, const String&)> OnNotificationsRequested;
static boost::signals2::signal<void (const Notification::Ptr&, const Checkable::Ptr&, const std::set<User::Ptr>&,
@ -180,15 +127,14 @@ public:
static boost::signals2::signal<void (const Notification::Ptr&, const Checkable::Ptr&, const std::set<User::Ptr>&,
const NotificationType&, const CheckResult::Ptr&, const String&,
const String&)> OnNotificationSentToAllUsers;
static boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin&)> OnCommentAdded;
static boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin&)> OnCommentRemoved;
static boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin&)> OnDowntimeAdded;
static boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin&)> OnDowntimeRemoved;
static boost::signals2::signal<void (const Checkable::Ptr&, FlappingState)> OnFlappingChanged;
static boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin::Ptr&)> OnCommentAdded;
static boost::signals2::signal<void (const Checkable::Ptr&, const Comment::Ptr&, const MessageOrigin::Ptr&)> OnCommentRemoved;
static boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin::Ptr&)> OnDowntimeAdded;
static boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&, const MessageOrigin::Ptr&)> OnDowntimeRemoved;
static boost::signals2::signal<void (const Checkable::Ptr&, const Downtime::Ptr&)> OnDowntimeTriggered;
static boost::signals2::signal<void (const Checkable::Ptr&, const String&, const String&, AcknowledgementType,
bool, double, const MessageOrigin&)> OnAcknowledgementSet;
static boost::signals2::signal<void (const Checkable::Ptr&, const MessageOrigin&)> OnAcknowledgementCleared;
bool, double, const MessageOrigin::Ptr&)> OnAcknowledgementSet;
static boost::signals2::signal<void (const Checkable::Ptr&, const MessageOrigin::Ptr&)> OnAcknowledgementCleared;
static boost::signals2::signal<void (const Checkable::Ptr&)> OnEventCommandExecuted;
/* Downtimes */
@ -200,9 +146,9 @@ public:
double startTime, double endTime, bool fixed,
const String& triggeredBy, double duration,
const String& scheduledBy = String(), const String& id = String(),
const MessageOrigin& origin = MessageOrigin());
const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
static void RemoveDowntime(const String& id, bool cancelled, const MessageOrigin& origin = MessageOrigin());
static void RemoveDowntime(const String& id, bool cancelled, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
void TriggerDowntimes(void);
static void TriggerDowntime(const String& id);
@ -220,29 +166,23 @@ public:
static int GetNextCommentID(void);
String AddComment(CommentType entryType, const String& author,
const String& text, double expireTime, const String& id = String(), const MessageOrigin& origin = MessageOrigin());
const String& text, double expireTime, const String& id = String(), const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
void RemoveAllComments(void);
void RemoveCommentsByType(int type);
static void RemoveComment(const String& id, const MessageOrigin& origin = MessageOrigin());
static void RemoveComment(const String& id, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
static String GetCommentIDFromLegacyID(int id);
static Checkable::Ptr GetOwnerByCommentID(const String& id);
static Comment::Ptr GetCommentByID(const String& id);
/* Notifications */
bool GetEnableNotifications(void) const;
void SetEnableNotifications(bool enabled, const MessageOrigin& origin = MessageOrigin());
void SendNotifications(NotificationType type, const CheckResult::Ptr& cr, const String& author = "", const String& text = "");
std::set<Notification::Ptr> GetNotifications(void) const;
void AddNotification(const Notification::Ptr& notification);
void RemoveNotification(const Notification::Ptr& notification);
void SetForceNextNotification(bool force, const MessageOrigin& origin = MessageOrigin());
bool GetForceNextNotification(void) const;
void ResetNotificationNumbers(void);
/* Event Handler */
@ -250,24 +190,13 @@ public:
bool useResolvedMacros = false);
intrusive_ptr<EventCommand> GetEventCommand(void) const;
void SetEventCommand(const intrusive_ptr<EventCommand>& command, const MessageOrigin& origin = MessageOrigin());
bool GetEnableEventHandler(void) const;
void SetEnableEventHandler(bool enabled, const MessageOrigin& origin = MessageOrigin());
/* Flapping Detection */
double GetFlappingCurrent(void) const;
bool GetEnableFlapping(void) const;
void SetEnableFlapping(bool enabled, const MessageOrigin& origin = MessageOrigin());
bool IsFlapping(void) const;
void UpdateFlappingStatus(bool stateChange);
/* Performance data */
bool GetEnablePerfdata(void) const;
void SetEnablePerfdata(bool enabled, const MessageOrigin& origin = MessageOrigin());
/* Dependencies */
void AddDependency(const intrusive_ptr<Dependency>& dep);
void RemoveDependency(const intrusive_ptr<Dependency>& dep);
@ -277,7 +206,7 @@ public:
void RemoveReverseDependency(const intrusive_ptr<Dependency>& dep);
std::set<intrusive_ptr<Dependency> > GetReverseDependencies(void) const;
virtual void ValidateCheckIntervalRaw(double value, const ValidationUtils& utils) override;
virtual void ValidateCheckInterval(double value, const ValidationUtils& utils) override;
protected:
virtual void Start(void);

45
lib/icinga/checkable.ti
View File

@ -21,6 +21,8 @@
#include "icinga/customvarobject.hpp"
#include "base/array.hpp"
library icinga;
namespace icinga
{
@ -40,15 +42,15 @@ enum AcknowledgementType
abstract class Checkable : CustomVarObject
{
[config, protected, required] name(CheckCommand) check_command (CheckCommandRaw);
[config] int max_check_attempts (MaxCheckAttemptsRaw) {
[config, required] name(CheckCommand) check_command (CheckCommandRaw);
[config] int max_check_attempts {
default {{{ return 3; }}}
};
[config, protected] name(TimePeriod) check_period (CheckPeriodRaw);
[config] double check_interval (CheckIntervalRaw) {
[config] name(TimePeriod) check_period (CheckPeriodRaw);
[config] double check_interval {
default {{{ return 5 * 60; }}}
};
[config] double retry_interval (RetryIntervalRaw) {
[config] double retry_interval {
default {{{ return 60; }}}
};
[config] name(EventCommand) event_command (EventCommandRaw);
@ -56,22 +58,22 @@ abstract class Checkable : CustomVarObject
[config] double flapping_threshold {
default {{{ return 30; }}}
};
[config] bool enable_active_checks (EnableActiveChecksRaw) {
[config] bool enable_active_checks {
default {{{ return true; }}}
};
[config] bool enable_passive_checks (EnablePassiveChecksRaw) {
[config] bool enable_passive_checks {
default {{{ return true; }}}
};
[config] bool enable_event_handler (EnableEventHandlerRaw) {
[config] bool enable_event_handler {
default {{{ return true; }}}
};
[config] bool enable_notifications (EnableNotificationsRaw) {
[config] bool enable_notifications {
default {{{ return true; }}}
};
[config] bool enable_flapping (EnableFlappingRaw) {
[config] bool enable_flapping {
default {{{ return false; }}}
};
[config] bool enable_perfdata (EnablePerfdataRaw) {
[config] bool enable_perfdata {
default {{{ return true; }}}
};
@ -81,7 +83,7 @@ abstract class Checkable : CustomVarObject
[config] String icon_image;
[config] String icon_image_alt;
[state] double next_check (NextCheckRaw);
[state] double next_check;
[state] int check_attempt {
default {{{ return 1; }}}
};
@ -116,7 +118,7 @@ abstract class Checkable : CustomVarObject
[state] double last_state_unknown;
[state] double last_state_unreachable;
[state] bool last_in_downtime;
[state] bool force_next_check (ForceNextCheckRaw);
[state] bool force_next_check;
[state] int acknowledgement (AcknowledgementRaw) {
default {{{ return AcknowledgementNone; }}}
};
@ -127,22 +129,13 @@ abstract class Checkable : CustomVarObject
[state] Dictionary::Ptr downtimes {
default {{{ return new Dictionary(); }}}
};
[state] bool force_next_notification (ForceNextNotificationRaw);
[state] bool force_next_notification;
[state] int flapping_positive;
[state] int flapping_negative;
[state] double flapping_last_change;
[state] Value override_enable_notifications;
[state] Value override_enable_active_checks;
[state] Value override_enable_passive_checks;
[state] Value override_enable_flapping;
[state] Value override_enable_perfdata;
[state] Value override_check_interval;
[state] Value override_retry_interval;
[state] Value override_enable_event_handler;
[state] Value override_event_command;
[state] Value override_check_command;
[state] Value override_max_check_attempts;
[state] Value override_check_period;
[no_storage, protected] bool flapping {
get {{{ return false; }}}
};
[config] name(Endpoint) command_endpoint (CommandEndpointRaw);
};

2
lib/icinga/checkcommand.ti
View File

@ -19,6 +19,8 @@
#include "icinga/command.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/checkresult.ti
View File

@ -17,6 +17,8 @@
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
library icinga;
namespace icinga
{

15
lib/icinga/command.cpp
View File

@ -30,20 +30,13 @@ REGISTER_TYPE(Command);
int Command::GetModifiedAttributes(void) const
{
int attrs = 0;
if (GetOverrideVars())
attrs |= ModAttrCustomVariable;
return attrs;
//TODO-MA
return 0;
}
void Command::SetModifiedAttributes(int flags, const MessageOrigin& origin)
void Command::SetModifiedAttributes(int flags, const MessageOrigin::Ptr& origin)
{
if ((flags & ModAttrCustomVariable) == 0) {
SetOverrideVars(Empty);
OnVarsChanged(this, GetVars(), origin);
}
//TODO-MA
}
void Command::Validate(int types, const ValidationUtils& utils)

2
lib/icinga/command.hpp
View File

@ -42,7 +42,7 @@ public:
virtual void Validate(int types, const ValidationUtils& utils) override;
int GetModifiedAttributes(void) const;
void SetModifiedAttributes(int flags, const MessageOrigin& origin = MessageOrigin());
void SetModifiedAttributes(int flags, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
};
}

2
lib/icinga/command.ti
View File

@ -20,6 +20,8 @@
#include "icinga/customvarobject.hpp"
#include "base/function.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/comment.ti
View File

@ -17,6 +17,8 @@
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
library icinga;
namespace icinga
{

33
lib/icinga/customvarobject.cpp
View File

@ -30,45 +30,24 @@ using namespace icinga;
REGISTER_TYPE(CustomVarObject);
boost::signals2::signal<void (const CustomVarObject::Ptr&, const Dictionary::Ptr& vars, const MessageOrigin&)> CustomVarObject::OnVarsChanged;
Dictionary::Ptr CustomVarObject::GetVars(void) const
{
if (GetOverrideVars())
return GetOverrideVars();
else
return GetVarsRaw();
}
void CustomVarObject::SetVars(const Dictionary::Ptr& vars, const MessageOrigin& origin)
{
SetOverrideVars(vars);
OnVarsChanged(this, vars, origin);
}
int CustomVarObject::GetModifiedAttributes(void) const
{
/* does nothing by default */
//TODO-MA
return 0;
}
void CustomVarObject::SetModifiedAttributes(int, const MessageOrigin&)
void CustomVarObject::SetModifiedAttributes(int, const MessageOrigin::Ptr&)
{
/* does nothing by default */
//TODO-MA
}
bool CustomVarObject::IsVarOverridden(const String& name) const
{
Dictionary::Ptr vars_override = GetOverrideVars();
if (!vars_override)
return false;
return vars_override->Contains(name);
//TODO: implement
return false;
}
void CustomVarObject::ValidateVarsRaw(const Dictionary::Ptr& value, const ValidationUtils& utils)
void CustomVarObject::ValidateVars(const Dictionary::Ptr& value, const ValidationUtils& utils)
{
if (!value)
return;

9
lib/icinga/customvarobject.hpp
View File

@ -59,15 +59,10 @@ class I2_ICINGA_API CustomVarObject : public ObjectImpl<CustomVarObject>
public:
DECLARE_OBJECT(CustomVarObject);
static boost::signals2::signal<void (const CustomVarObject::Ptr&, const Dictionary::Ptr& vars, const MessageOrigin&)> OnVarsChanged;
virtual void ValidateVarsRaw(const Dictionary::Ptr& value, const ValidationUtils& utils) override;
Dictionary::Ptr GetVars(void) const;
void SetVars(const Dictionary::Ptr& vars, const MessageOrigin& origin = MessageOrigin());
virtual void ValidateVars(const Dictionary::Ptr& value, const ValidationUtils& utils) override;
virtual int GetModifiedAttributes(void) const;
virtual void SetModifiedAttributes(int flags, const MessageOrigin& origin = MessageOrigin());
virtual void SetModifiedAttributes(int flags, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
bool IsVarOverridden(const String& name) const;
};

6
lib/icinga/customvarobject.ti
View File

@ -19,14 +19,14 @@
#include "base/dynamicobject.hpp"
library icinga;
namespace icinga
{
abstract class CustomVarObject : DynamicObject
{
[config] Dictionary::Ptr vars (VarsRaw);
[state] Dictionary::Ptr override_vars;
[config] Dictionary::Ptr vars;
};
}

2
lib/icinga/dependency.ti
View File

@ -20,6 +20,8 @@
#include "icinga/customvarobject.hpp"
#include "icinga/checkable.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/downtime.ti
View File

@ -17,6 +17,8 @@
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
library icinga;
namespace icinga
{

3
lib/icinga/eventcommand.ti
View File

@ -19,6 +19,9 @@
#include "icinga/command.hpp"
library icinga;
namespace icinga
{

526
lib/icinga/externalcommandprocessor.cpp
View File

File diff suppressed because it is too large Load Diff

2
lib/icinga/host.ti
View File

@ -20,6 +20,8 @@
#include "icinga/checkable.hpp"
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/hostgroup.ti
View File

@ -19,6 +19,8 @@
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{

72
lib/icinga/icingaapplication.cpp
View File

@ -233,108 +233,60 @@ bool IcingaApplication::ResolveMacro(const String& macro, const CheckResult::Ptr
bool IcingaApplication::GetEnableNotifications(void) const
{
if (!GetOverrideEnableNotifications().IsEmpty())
return GetOverrideEnableNotifications();
else
return ScriptGlobal::Get("EnableNotifications");
return ScriptGlobal::Get("EnableNotifications");
}
void IcingaApplication::SetEnableNotifications(bool enabled)
{
SetOverrideEnableNotifications(enabled);
}
void IcingaApplication::ClearEnableNotifications(void)
{
SetOverrideEnableNotifications(Empty);
ScriptGlobal::Set("EnableNotifications", enabled);
}
bool IcingaApplication::GetEnableEventHandlers(void) const
{
if (!GetOverrideEnableEventHandlers().IsEmpty())
return GetOverrideEnableEventHandlers();
else
return ScriptGlobal::Get("EnableEventHandlers");
return ScriptGlobal::Get("EnableEventHandlers");
}
void IcingaApplication::SetEnableEventHandlers(bool enabled)
{
SetOverrideEnableEventHandlers(enabled);
}
void IcingaApplication::ClearEnableEventHandlers(void)
{
SetOverrideEnableEventHandlers(Empty);
ScriptGlobal::Set("EnableEventHandlers", enabled);
}
bool IcingaApplication::GetEnableFlapping(void) const
{
if (!GetOverrideEnableFlapping().IsEmpty())
return GetOverrideEnableFlapping();
else
return ScriptGlobal::Get("EnableFlapping");
return ScriptGlobal::Get("EnableFlapping");
}
void IcingaApplication::SetEnableFlapping(bool enabled)
{
SetOverrideEnableFlapping(enabled);
}
void IcingaApplication::ClearEnableFlapping(void)
{
SetOverrideEnableFlapping(Empty);
ScriptGlobal::Set("EnableFlapping", enabled);
}
bool IcingaApplication::GetEnableHostChecks(void) const
{
if (!GetOverrideEnableHostChecks().IsEmpty())
return GetOverrideEnableHostChecks();
else
return ScriptGlobal::Get("EnableHostChecks");
return ScriptGlobal::Get("EnableHostChecks");
}
void IcingaApplication::SetEnableHostChecks(bool enabled)
{
SetOverrideEnableHostChecks(enabled);
}
void IcingaApplication::ClearEnableHostChecks(void)
{
SetOverrideEnableHostChecks(Empty);
ScriptGlobal::Set("EnableHostChecks", enabled);
}
bool IcingaApplication::GetEnableServiceChecks(void) const
{
if (!GetOverrideEnableServiceChecks().IsEmpty())
return GetOverrideEnableServiceChecks();
else
return ScriptGlobal::Get("EnableServiceChecks");
return ScriptGlobal::Get("EnableServiceChecks");
}
void IcingaApplication::SetEnableServiceChecks(bool enabled)
{
SetOverrideEnableServiceChecks(enabled);
}
void IcingaApplication::ClearEnableServiceChecks(void)
{
SetOverrideEnableServiceChecks(Empty);
ScriptGlobal::Set("EnableServiceChecks", enabled);
}
bool IcingaApplication::GetEnablePerfdata(void) const
{
if (!GetOverrideEnablePerfdata().IsEmpty())
return GetOverrideEnablePerfdata();
else
return ScriptGlobal::Get("EnablePerfdata");
return ScriptGlobal::Get("EnablePerfdata");
}
void IcingaApplication::SetEnablePerfdata(bool enabled)
{
SetOverrideEnablePerfdata(enabled);
}
void IcingaApplication::ClearEnablePerfdata(void)
{
SetOverrideEnablePerfdata(Empty);
ScriptGlobal::Set("EnablePerfdata", enabled);
}

8
lib/icinga/icingaapplication.ti
View File

@ -19,17 +19,13 @@
#include "base/application.hpp"
library icinga;
namespace icinga
{
class IcingaApplication : Application
{
[state, protected] Value override_enable_notifications;
[state, protected] Value override_enable_event_handlers;
[state, protected] Value override_enable_flapping;
[state, protected] Value override_enable_host_checks;
[state, protected] Value override_enable_service_checks;
[state, protected] Value override_enable_perfdata;
};
}

2
lib/icinga/icingastatuswriter.ti
View File

@ -20,6 +20,8 @@
#include "icinga/customvarobject.hpp"
#include "base/application.hpp"
library icinga;
namespace icinga
{

18
lib/icinga/notification.cpp
View File

@ -35,7 +35,7 @@ using namespace icinga;
REGISTER_TYPE(Notification);
INITIALIZE_ONCE(&Notification::StaticInitialize);
boost::signals2::signal<void (const Notification::Ptr&, double, const MessageOrigin&)> Notification::OnNextNotificationChanged;
boost::signals2::signal<void (const Notification::Ptr&, const MessageOrigin::Ptr&)> Notification::OnNextNotificationChanged;
String NotificationNameComposer::MakeName(const String& shortName, const Object::Ptr& context) const
{
@ -174,22 +174,6 @@ TimePeriod::Ptr Notification::GetPeriod(void) const
return TimePeriod::GetByName(GetPeriodRaw());
}
double Notification::GetNextNotification(void) const
{
return GetNextNotificationRaw();
}
/**
* Sets the timestamp when the next periodical notification should be sent.
* This does not affect notifications that are sent for state changes.
*/
void Notification::SetNextNotification(double time, const MessageOrigin& origin)
{
SetNextNotificationRaw(time);
OnNextNotificationChanged(this, time, origin);
}
void Notification::UpdateNotificationNumber(void)
{
SetNotificationNumber(GetNotificationNumber() + 1);

5
lib/icinga/notification.hpp
View File

@ -91,9 +91,6 @@ public:
std::set<User::Ptr> GetUsers(void) const;
std::set<UserGroup::Ptr> GetUserGroups(void) const;
double GetNextNotification(void) const;
void SetNextNotification(double time, const MessageOrigin& origin = MessageOrigin());
void UpdateNotificationNumber(void);
void ResetNotificationNumber(void);
@ -106,7 +103,7 @@ public:
static String NotificationTypeToString(NotificationType type);
static String NotificationFilterToString(int filter);
static boost::signals2::signal<void (const Notification::Ptr&, double, const MessageOrigin&)> OnNextNotificationChanged;
static boost::signals2::signal<void (const Notification::Ptr&, const MessageOrigin::Ptr&)> OnNextNotificationChanged;
static void RegisterApplyRuleHandler(void);

4
lib/icinga/notification.ti
View File

@ -19,6 +19,8 @@
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{
@ -55,7 +57,7 @@ class Notification : CustomVarObject < NotificationNameComposer
};
[state] double last_notification;
[state, set_protected] double next_notification (NextNotificationRaw);
[state] double next_notification;
[state, set_protected] Value notification_number;
[state] double last_problem_notification;

2
lib/icinga/notificationcommand.ti
View File

@ -19,6 +19,8 @@
#include "icinga/command.hpp"
library icinga;
namespace icinga
{

16
lib/icinga/perfdatavalue.cpp
View File

@ -39,14 +39,14 @@ PerfdataValue::PerfdataValue(String label, double value, bool counter,
const String& unit, const Value& warn, const Value& crit, const Value& min,
const Value& max)
{
SetLabel(label);
SetValue(value);
SetCounter(counter);
SetUnit(unit);
SetWarn(warn);
SetCrit(crit);
SetMin(min);
SetMax(max);
SetLabel(label, true);
SetValue(value, true);
SetCounter(counter, true);
SetUnit(unit, true);
SetWarn(warn, true);
SetCrit(crit, true);
SetMin(min, true);
SetMax(max, true);
}
PerfdataValue::Ptr PerfdataValue::Parse(const String& perfdata)

2
lib/icinga/perfdatavalue.ti
View File

@ -19,6 +19,8 @@
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/scheduleddowntime.ti
View File

@ -19,6 +19,8 @@
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/service.ti
View File

@ -22,6 +22,8 @@
#include "icinga/icingaapplication.hpp"
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/servicegroup.ti
View File

@ -19,6 +19,8 @@
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{

2
lib/icinga/timeperiod.ti
View File

@ -20,6 +20,8 @@
#include "icinga/customvarobject.hpp"
#include "base/function.hpp"
library icinga;
namespace icinga
{

34
lib/icinga/user.cpp
View File

@ -30,8 +30,6 @@ using namespace icinga;
REGISTER_TYPE(User);
boost::signals2::signal<void (const User::Ptr&, bool, const MessageOrigin&)> User::OnEnableNotificationsChanged;
void User::OnConfigLoaded(void)
{
DynamicObject::OnConfigLoaded();
@ -124,34 +122,12 @@ void User::ValidateTypes(const Array::Ptr& value, const ValidationUtils& utils)
int User::GetModifiedAttributes(void) const
{
int attrs = 0;
if (GetOverrideVars())
attrs |= ModAttrCustomVariable;
return attrs;
//TODO-MA
return 0;
}
void User::SetModifiedAttributes(int flags, const MessageOrigin& origin)
void User::SetModifiedAttributes(int flags, const MessageOrigin::Ptr& origin)
{
if ((flags & ModAttrCustomVariable) == 0) {
SetOverrideVars(Empty);
OnVarsChanged(this, GetVars(), origin);
}
//TODO-MA
return;
}
bool User::GetEnableNotifications(void) const
{
if (!GetOverrideEnableNotifications().IsEmpty())
return GetOverrideEnableNotifications();
else
return GetEnableNotificationsRaw();
}
void User::SetEnableNotifications(bool enabled, const MessageOrigin& origin)
{
SetOverrideEnableNotifications(enabled);
OnEnableNotificationsChanged(this, enabled, origin);
}

7
lib/icinga/user.hpp
View File

@ -47,13 +47,8 @@ public:
virtual void ValidateStates(const Array::Ptr& value, const ValidationUtils& utils) override;
virtual void ValidateTypes(const Array::Ptr& value, const ValidationUtils& utils) override;
bool GetEnableNotifications(void) const;
void SetEnableNotifications(bool enabled, const MessageOrigin& origin = MessageOrigin());
int GetModifiedAttributes(void) const;
void SetModifiedAttributes(int flags, const MessageOrigin& origin = MessageOrigin());
static boost::signals2::signal<void (const User::Ptr&, bool, const MessageOrigin&)> OnEnableNotificationsChanged;
void SetModifiedAttributes(int flags, const MessageOrigin::Ptr& origin = MessageOrigin::Ptr());
protected:
virtual void Stop(void);

5
lib/icinga/user.ti
View File

@ -20,6 +20,8 @@
#include "icinga/customvarobject.hpp"
#include "base/array.hpp"
library icinga;
namespace icinga
{
@ -45,11 +47,10 @@ class User : CustomVarObject
[config] String email;
[config] String pager;
[config] bool enable_notifications (EnableNotificationsRaw) {
[config] bool enable_notifications {
default {{{ return true; }}}
};
[state] Value override_enable_notifications;
[state] double last_notification;
};

2
lib/icinga/usergroup.ti
View File

@ -19,6 +19,8 @@
#include "icinga/customvarobject.hpp"
library icinga;
namespace icinga
{

2
lib/livestatus/livestatuslistener.ti
View File

@ -20,6 +20,8 @@
#include "base/dynamicobject.hpp"
#include "base/application.hpp"
library livestatus;
namespace icinga
{

1
lib/notification/CMakeLists.txt
View File

@ -32,6 +32,7 @@ target_link_libraries(notification ${Boost_LIBRARIES} base config icinga)
set_target_properties (
notification PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_NOTIFICATION_BUILD
FOLDER Components
)

2
lib/notification/notificationcomponent.ti
View File

@ -19,6 +19,8 @@
#include "base/dynamicobject.hpp"
library notification;
namespace icinga
{

1
lib/perfdata/CMakeLists.txt
View File

@ -35,6 +35,7 @@ target_link_libraries(perfdata ${Boost_LIBRARIES} base config icinga)
set_target_properties (
perfdata PROPERTIES
INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR}/icinga2
DEFINE_SYMBOL I2_PERFDATA_BUILD
FOLDER Components
)

2
lib/perfdata/gelfwriter.ti
View File

@ -19,6 +19,8 @@
#include "base/dynamicobject.hpp"
library perfdata;
namespace icinga
{

2
lib/perfdata/graphitewriter.ti
View File

@ -19,6 +19,8 @@
#include "base/dynamicobject.hpp"
library perfdata;
namespace icinga
{

21
lib/perfdata/opentsdbwriter.ti
View File

@ -1,5 +1,26 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "base/dynamicobject.hpp"
library perfdata;
namespace icinga
{

2
lib/perfdata/perfdatawriter.ti
View File

@ -20,6 +20,8 @@
#include "base/dynamicobject.hpp"
#include "base/application.hpp"
library perfdata;
namespace icinga
{

2
lib/remote/apifunction.cpp
View File

@ -26,7 +26,7 @@ ApiFunction::ApiFunction(const Callback& function)
: m_Callback(function)
{ }
Value ApiFunction::Invoke(const MessageOrigin& origin, const Dictionary::Ptr& arguments)
Value ApiFunction::Invoke(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& arguments)
{
return m_Callback(origin, arguments);
}

4
lib/remote/apifunction.hpp
View File

@ -41,11 +41,11 @@ class I2_REMOTE_API ApiFunction : public Object
public:
DECLARE_PTR_TYPEDEFS(ApiFunction);
typedef boost::function<Value(const MessageOrigin& origin, const Dictionary::Ptr&)> Callback;
typedef boost::function<Value(const MessageOrigin::Ptr& origin, const Dictionary::Ptr&)> Callback;
ApiFunction(const Callback& function);
Value Invoke(const MessageOrigin& origin, const Dictionary::Ptr& arguments);
Value Invoke(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& arguments);
static ApiFunction::Ptr GetByName(const String& name);
static void Register(const String& name, const ApiFunction::Ptr& function);

4
lib/remote/apilistener-sync.cpp
View File

@ -214,9 +214,9 @@ void ApiListener::SendConfigUpdate(const JsonRpcConnection::Ptr& aclient)
aclient->SendMessage(message);
}
Value ApiListener::ConfigUpdateHandler(const MessageOrigin& origin, const Dictionary::Ptr& params)
Value ApiListener::ConfigUpdateHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params)
{
if (!origin.FromClient->GetEndpoint() || (origin.FromZone && !Zone::GetLocalZone()->IsChildOf(origin.FromZone)))
if (!origin->FromClient->GetEndpoint() || (origin->FromZone && !Zone::GetLocalZone()->IsChildOf(origin->FromZone)))
return Empty;
ApiListener::Ptr listener = ApiListener::GetInstance();

14
lib/remote/apilistener.cpp
View File

@ -508,7 +508,7 @@ void ApiListener::ApiTimerHandler(void)
<< "Connected endpoints: " << Utility::NaturalJoin(names);
}
void ApiListener::RelayMessage(const MessageOrigin& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log)
void ApiListener::RelayMessage(const MessageOrigin::Ptr& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log)
{
m_RelayQueue.Enqueue(boost::bind(&ApiListener::SyncRelayMessage, this, origin, secobj, message, log));
}
@ -557,7 +557,7 @@ void ApiListener::SyncSendMessage(const Endpoint::Ptr& endpoint, const Dictionar
}
void ApiListener::SyncRelayMessage(const MessageOrigin& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log)
void ApiListener::SyncRelayMessage(const MessageOrigin::Ptr& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log)
{
double ts = Utility::GetTime();
message->Set("ts", ts);
@ -568,8 +568,8 @@ void ApiListener::SyncRelayMessage(const MessageOrigin& origin, const DynamicObj
if (log)
PersistMessage(message, secobj);
if (origin.FromZone)
message->Set("originZone", origin.FromZone->GetName());
if (origin && origin->FromZone)
message->Set("originZone", origin->FromZone->GetName());
bool is_master = IsMaster();
Endpoint::Ptr master = GetMaster();
@ -592,13 +592,13 @@ void ApiListener::SyncRelayMessage(const MessageOrigin& origin, const DynamicObj
}
/* don't relay messages back to the endpoint which we got the message from */
if (origin.FromClient && endpoint == origin.FromClient->GetEndpoint()) {
if (origin && origin->FromClient && endpoint == origin->FromClient->GetEndpoint()) {
skippedEndpoints.push_back(endpoint);
continue;
}
/* don't relay messages back to the zone which we got the message from */
if (origin.FromZone && target_zone == origin.FromZone) {
if (origin && origin->FromZone && target_zone == origin->FromZone) {
skippedEndpoints.push_back(endpoint);
continue;
}
@ -926,7 +926,7 @@ std::set<HttpConnection::Ptr> ApiListener::GetHttpClients(void) const
return m_HttpClients;
}
Value ApiListener::HelloAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params)
Value ApiListener::HelloAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params)
{
return Empty;
}

8
lib/remote/apilistener.hpp
View File

@ -60,7 +60,7 @@ public:
static String GetApiDir(void);
void SyncSendMessage(const Endpoint::Ptr& endpoint, const Dictionary::Ptr& message);
void RelayMessage(const MessageOrigin& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log);
void RelayMessage(const MessageOrigin::Ptr& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log);
static void StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata);
std::pair<Dictionary::Ptr, Dictionary::Ptr> GetStatus(void);
@ -73,9 +73,9 @@ public:
void RemoveHttpClient(const HttpConnection::Ptr& aclient);
std::set<HttpConnection::Ptr> GetHttpClients(void) const;
static Value ConfigUpdateHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static Value ConfigUpdateHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
static Value HelloAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params);
static Value HelloAPIHandler(const MessageOrigin::Ptr& origin, const Dictionary::Ptr& params);
protected:
virtual void OnConfigLoaded(void);
virtual void OnAllConfigLoaded(void);
@ -103,7 +103,7 @@ private:
Stream::Ptr m_LogFile;
size_t m_LogMessageCount;
void SyncRelayMessage(const MessageOrigin& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log);
void SyncRelayMessage(const MessageOrigin::Ptr& origin, const DynamicObject::Ptr& secobj, const Dictionary::Ptr& message, bool log);
void PersistMessage(const Dictionary::Ptr& message, const DynamicObject::Ptr& secobj);
void OpenLogFile(void);

Some files were not shown because too many files have changed in this diff Show More