{
m_Endpoint = Endpoint::MakeEndpoint("checker", false);
- /* dummy registration so the delegation module knows this is a checker
- TODO: figure out a better way for this */
- m_Endpoint->RegisterSubscription("checker");
+ {
+ ObjectLock olock(m_Endpoint);
+
+ /* dummy registration so the delegation module knows this is a checker
+ TODO: figure out a better way for this */
+ m_Endpoint->RegisterSubscription("checker");
+ }
Service::OnCheckerChanged.connect(bind(&CheckerComponent::CheckerChangedHandler, this, _1));
Service::OnNextCheckChanged.connect(bind(&CheckerComponent::NextCheckChangedHandler, this, _1));
void CheckerComponent::Stop(void)
{
- m_Endpoint->Unregister();
+ {
+ ObjectLock olock(m_Endpoint);
+ m_Endpoint->Unregister();
+ }
{
boost::mutex::scoped_lock lock(m_Mutex);
CheckTimeView::iterator it = idx.begin();
Service::Ptr service = *it;
+ ObjectLock olock(service); /* also required for the key extractor. */
+
if (!service->IsRegistered()) {
idx.erase(it);
continue;
}
- ObjectLock olock(service); /* also required for the key extractor. */
double wait;
{
try {
olock.Unlock();
- Service::BeginExecuteCheck(service, boost::bind(&CheckerComponent::CheckCompletedHandler, static_cast<CheckerComponent::Ptr>(GetSelf()), service));
+
+ CheckerComponent::Ptr self;
+
+ {
+ ObjectLock olock(this);
+ self = GetSelf();
+ }
+
+ Service::BeginExecuteCheck(service, boost::bind(&CheckerComponent::CheckCompletedHandler, static_cast<CheckerComponent::Ptr>(self), service));
} catch (const exception& ex) {
olock.Lock();
Logger::Write(LogCritical, "checker", "Exception occured while checking service '" + service->GetName() + "': " + diagnostic_information(ex));
ObjectLock olock(service); /* also required for the key extractor */
String checker = service->GetCurrentChecker();
- if (checker == EndpointManager::GetInstance()->GetIdentity() || checker == m_Endpoint->GetName()) {
+ EndpointManager::Ptr em = EndpointManager::GetInstance();
+
+ String identity;
+
+ {
+ ObjectLock elock(em);
+ identity = em->GetIdentity();
+ }
+
+ if (checker == identity || Endpoint::GetByName(checker) == m_Endpoint) {
if (m_PendingServices.find(service) != m_PendingServices.end())
return;
*/
String CompatComponent::GetStatusPath(void) const
{
- Value statusPath = GetConfig()->Get("status_path");
+ DynamicObject::Ptr config = GetConfig();
+
+ ObjectLock olock(config);
+
+ Value statusPath = config->Get("status_path");
if (statusPath.IsEmpty())
return Application::GetLocalStateDir() + "/cache/icinga2/status.dat";
else
*/
String CompatComponent::GetObjectsPath(void) const
{
- Value objectsPath = GetConfig()->Get("objects_path");
+ DynamicObject::Ptr config = GetConfig();
+
+ ObjectLock olock(config);
+
+ Value objectsPath = config->Get("objects_path");
if (objectsPath.IsEmpty())
return Application::GetLocalStateDir() + "/cache/icinga2/objects.cache";
else
*/
String CompatComponent::GetLogPath(void) const
{
- Value logPath = GetConfig()->Get("log_path");
+ DynamicObject::Ptr config = GetConfig();
+
+ ObjectLock olock(config);
+
+ Value logPath = config->Get("log_path");
if (logPath.IsEmpty())
return Application::GetLocalStateDir() + "/log/icinga2/compat";
else
*/
String CompatComponent::GetCommandPath(void) const
{
- Value commandPath = GetConfig()->Get("command_path");
+ DynamicObject::Ptr config = GetConfig();
+
+ ObjectLock olock(config);
+
+ Value commandPath = config->Get("command_path");
if (commandPath.IsEmpty())
return Application::GetLocalStateDir() + "/run/icinga.cmd";
else
void CompatComponent::DumpDowntimes(ostream& fp, const Service::Ptr& owner, CompatObjectType type)
{
- ObjectLock olock(owner);
+ Dictionary::Ptr downtimes;
+ String short_name, host_name;
+ Host::Ptr host;
- Dictionary::Ptr downtimes = owner->GetDowntimes();
+ {
+ ObjectLock olock(owner);
+
+ downtimes = owner->GetDowntimes();
+ short_name = owner->GetShortName();
+ host = owner->GetHost();
+ }
+
+ {
+ ObjectLock olock(host);
+ host_name = host->GetName();
+ }
if (!downtimes)
return;
+ ObjectLock dlock(downtimes);
+
String id;
Dictionary::Ptr downtime;
BOOST_FOREACH(tie(id, downtime), downtimes) {
if (Service::IsDowntimeExpired(downtime))
continue;
+ ObjectLock olock(downtime);
+
if (type == CompatTypeHost)
fp << "hostdowntime {" << "\n";
else
fp << "servicedowntime {" << "\n"
- << "\t" << "service_description=" << owner->GetShortName() << "\n";
+ << "\t" << "service_description=" << short_name << "\n";
Dictionary::Ptr triggeredByObj = Service::GetDowntimeByID(downtime->Get("triggered_by"));
int triggeredByLegacy = 0;
if (triggeredByObj)
triggeredByLegacy = triggeredByObj->Get("legacy_id");
- fp << "\t" << "host_name=" << owner->GetHost()->GetName() << "\n"
+ fp << "\t" << "host_name=" << host_name << "\n"
<< "\t" << "downtime_id=" << static_cast<String>(downtime->Get("legacy_id")) << "\n"
<< "\t" << "entry_time=" << static_cast<double>(downtime->Get("entry_time")) << "\n"
<< "\t" << "start_time=" << static_cast<double>(downtime->Get("start_time")) << "\n"
}
if (cr) {
+ ObjectLock olock(cr);
+
output = cr->Get("output");
schedule_end = cr->Get("schedule_end");
perfdata = cr->Get("performance_data_raw");
void DelegationComponent::Start(void)
{
m_DelegationTimer = boost::make_shared<Timer>();
+
// TODO: implement a handler for config changes for the delegation_interval variable
- m_DelegationTimer->SetInterval(GetDelegationInterval());
+ m_DelegationTimer->SetInterval(30);
m_DelegationTimer->OnTimerExpired.connect(boost::bind(&DelegationComponent::DelegationTimerHandler, this));
m_DelegationTimer->Start();
m_DelegationTimer->Reschedule(Utility::GetTime() + 10);
}
-double DelegationComponent::GetDelegationInterval(void) const
-{
- Value interval = GetConfig()->Get("delegation_interval");
- if (interval.IsEmpty())
- return 30;
- else
- return interval;
-}
-
bool DelegationComponent::IsEndpointChecker(const Endpoint::Ptr& endpoint)
{
return (endpoint->HasSubscription("checker"));
Endpoint::Ptr endpoint;
int count;
BOOST_FOREACH(tie(endpoint, count), histogram) {
+ ObjectLock olock(endpoint);
+
stringstream msgbuf;
msgbuf << "histogram: " << endpoint->GetName() << " - " << count;
Logger::Write(LogInformation, "delegation", msgbuf.str());
set<Endpoint::Ptr> GetCheckerCandidates(const Service::Ptr& service) const;
static bool IsEndpointChecker(const Endpoint::Ptr& endpoint);
-
- double GetDelegationInterval(void) const;
};
}
{
m_Endpoint = Endpoint::MakeEndpoint("notification", false);
- ObjectLock olock(m_Endpoint);
- m_Endpoint->RegisterTopicHandler("icinga::SendNotifications",
- boost::bind(&NotificationComponent::SendNotificationsRequestHandler, this, _2,
- _3));
+ {
+ ObjectLock olock(m_Endpoint);
+ m_Endpoint->RegisterTopicHandler("icinga::SendNotifications",
+ boost::bind(&NotificationComponent::SendNotificationsRequestHandler, this, _2,
+ _3));
+ }
m_NotificationTimer = boost::make_shared<Timer>();
m_NotificationTimer->SetInterval(5);
// TODO: sanitize update, disallow __local
if (!object) {
- object = dtype->CreateObject(update);
+ object = DynamicType::CreateObject(dtype, update);
if (source == EndpointManager::GetInstance()->GetIdentity()) {
/* the peer sent us an object that was originally created by us -
*
* @returns The application object.
*/
-Application::Ptr Application::GetInstance(void)
+Application *Application::GetInstance(void)
{
- if (m_Instance)
- return m_Instance->GetSelf();
- else
- return Application::Ptr();
+ return m_Instance;
}
int Application::GetArgC(void)
void Application::ShutdownTimerHandler(void)
{
if (m_ShuttingDown) {
+ Logger::Write(LogInformation, "base", "Shutting down Icinga...");
Application::GetInstance()->OnShutdown();
DynamicObject::DeactivateObjects();
GetEQ().Stop();
m_ShuttingDown = true;
}
-/**
- * Terminates the application.
- */
-void Application::Terminate(int exitCode)
-{
- _exit(exitCode);
-}
-
/**
* Retrieves the full path of the executable.
*
{
assert(signum == SIGINT);
- Application::Ptr instance = Application::GetInstance();
+ Application *instance = Application::GetInstance();
if (!instance)
return;
*/
BOOL WINAPI Application::CtrlHandler(DWORD type)
{
- Application::Ptr instance = Application::GetInstance();
+ Application *instance = Application::GetInstance();
if (!instance)
return TRUE;
- instance->GetInstance()->RequestShutdown();
+ instance->RequestShutdown();
SetConsoleCtrlHandler(NULL, FALSE);
return TRUE;
Application(const Dictionary::Ptr& serializedUpdate);
~Application(void);
- static Application::Ptr GetInstance(void);
+ static Application *GetInstance(void);
int Run(void);
static void InstallExceptionHandlers(void);
static void RequestShutdown(void);
- static void Terminate(int exitCode);
static void SetDebugging(bool debug);
static bool IsDebugging(void);
/**
* Starts the async task. The caller must hold a reference to the AsyncTask
* object until the completion callback is invoked.
+ *
+ * @threadsafety Always.
*/
void Start(const CompletionCallback& completionCallback = CompletionCallback())
{
+ assert(!OwnsLock());
+ boost::mutex::scoped_lock lock(m_Mutex);
+
m_CompletionCallback = completionCallback;
Utility::QueueAsyncCallback(boost::bind(&AsyncTask<TClass, TResult>::RunInternal, this));
}
/**
* Checks whether the task is finished.
+ *
+ * @threadsafety Always.
*/
bool IsFinished(void) const
{
+ assert(!OwnsLock());
boost::mutex::scoped_lock lock(m_Mutex);
return m_Finished;
}
/**
- * Retrieves the result of the task. Throws an exception if one is stored in
+ * Blocks until the task is completed and retrieves the result. Throws an exception if one is stored in
* the AsyncTask object.
*
* @returns The task's result.
+ * @threadsafety Always.
*/
TResult GetResult(void)
{
- if (!m_Finished)
- BOOST_THROW_EXCEPTION(runtime_error("GetResult called on an unfinished AsyncTask"));
+ assert(!OwnsLock());
+ boost::mutex::scoped_lock lock(m_Mutex);
+
+ while (!m_Finished)
+ m_CV.wait(lock);
if (m_ResultRetrieved)
BOOST_THROW_EXCEPTION(runtime_error("GetResult called on an AsyncTask whose result was already retrieved."));
* Finishes the task using an exception.
*
* @param ex The exception.
+ * @threadsafety Always.
*/
void FinishException(const boost::exception_ptr& ex)
{
+ assert(!OwnsLock());
+ boost::mutex::scoped_lock lock(m_Mutex);
+
m_Exception = ex;
FinishInternal();
}
* Finishes the task using an ordinary result.
*
* @param result The result.
+ * @threadsafety Always.
*/
void FinishResult(const TResult& result)
{
+ assert(!OwnsLock());
+ boost::mutex::scoped_lock lock(m_Mutex);
+
m_Result = result;
FinishInternal();
}
- /**
- * Blocks until the task is completed.
- */
- void Wait(void)
- {
- boost::mutex::scoped_lock lock(m_Mutex);
- while (!m_Finished)
- m_CV.wait(lock);
- }
-
protected:
/**
* Begins executing the task. The Run method must ensure
/**
* Finishes the task and causes the completion callback to be invoked. This
* function must be called before the object is destroyed.
+ *
+ * @threadsafety Caller must hold m_Mutex.
*/
void FinishInternal(void)
{
- CompletionCallback callback;
-
- {
- boost::mutex::scoped_lock lock(m_Mutex);
- assert(!m_Finished);
+ assert(!m_Finished);
+ m_Finished = true;
+ m_CV.notify_all();
- m_Finished = true;
-
- m_CV.notify_all();
+ if (!m_CompletionCallback.empty()) {
+ CompletionCallback callback;
m_CompletionCallback.swap(callback);
- }
- if (!callback.empty())
Utility::QueueAsyncCallback(boost::bind(callback, GetSelf()));
+ }
}
/**
using namespace icinga;
-REGISTER_TYPE(Component, NULL);
+REGISTER_TYPE(Component);
map<String, Component::Factory> Component::m_Factories;
*/
Dictionary::Iterator Dictionary::Begin(void)
{
+ assert(OwnsLock());
+
return m_Data.begin();
}
*/
Dictionary::Iterator Dictionary::End(void)
{
+ assert(OwnsLock());
+
return m_Data.end();
}
*/
void Dictionary::Remove(Dictionary::Iterator it)
{
+ ObjectLock olock(this);
+
String key = it->first;
m_Data.erase(it);
}
*/
void Dictionary::Seal(void)
{
+ ObjectLock olock(this);
+
m_Sealed = true;
}
+/**
+ * Checks whether the dictionary is sealed.
+ *
+ * @returns true if the dictionary is sealed, false otherwise.
+ */
+bool Dictionary::IsSealed(void) const
+{
+ ObjectLock olock(this);
+
+ return m_Sealed;
+}
+
/**
* Makes a shallow copy of a dictionary.
*
dictionary->Set(i->string, Value::FromJson(i));
}
+ dictionary->Seal();
+
return dictionary;
}
void Set(const String& key, const Value& value);
String Add(const Value& value);
bool Contains(const String& key) const;
+
void Seal(void);
+ bool IsSealed(void) const;
Iterator Begin(void);
Iterator End(void);
RegisterAttribute("__source", Attribute_Local, &m_Source);
RegisterAttribute("methods", Attribute_Config, &m_Methods);
- {
- ObjectLock olock(serializedObject);
-
- if (!serializedObject->Contains("configTx"))
- BOOST_THROW_EXCEPTION(invalid_argument("Serialized object must contain a config snapshot."));
- }
+ if (!serializedObject->Contains("configTx"))
+ BOOST_THROW_EXCEPTION(invalid_argument("Serialized object must contain a config snapshot."));
/* apply config state from the config item/remote update;
* The DynamicType::CreateObject function takes care of restoring
* non-config state after the object has been fully constructed */
- {
- ObjectLock olock(this);
- ApplyUpdate(serializedObject, Attribute_Config);
- }
+ ApplyUpdate(serializedObject, Attribute_Config);
boost::call_once(m_TransactionOnce, &DynamicObject::Initialize);
}
Dictionary::Ptr DynamicObject::BuildUpdate(double sinceTx, int attributeTypes) const
{
+ assert(OwnsLock());
+
DynamicObject::AttributeConstIterator it;
Dictionary::Ptr attrs = boost::make_shared<Dictionary>();
void DynamicObject::ApplyUpdate(const Dictionary::Ptr& serializedUpdate,
int allowedTypes)
{
- Dictionary::Ptr attrs;
+ assert(OwnsLock());
+ assert(serializedUpdate->IsSealed());
- {
- ObjectLock olock(serializedUpdate);
+ Value configTxValue = serializedUpdate->Get("configTx");
- double configTx = 0;
- if ((allowedTypes & Attribute_Config) != 0 &&
- serializedUpdate->Contains("configTx")) {
- configTx = serializedUpdate->Get("configTx");
-
- if (configTx > m_ConfigTx)
- ClearAttributesByType(Attribute_Config);
- }
+ if ((allowedTypes & Attribute_Config) != 0 && !configTxValue.IsEmpty()) {
+ double configTx = configTxValue;
- attrs = serializedUpdate->Get("attrs");
+ if (configTx > m_ConfigTx)
+ ClearAttributesByType(Attribute_Config);
}
+ Dictionary::Ptr attrs = serializedUpdate->Get("attrs");
+
+ assert(attrs->IsSealed());
+
{
ObjectLock olock(attrs);
continue;
Dictionary::Ptr attr = it->second;
- ObjectLock alock(attr);
+
+ assert(attr->IsSealed());
int type = attr->Get("type");
void DynamicObject::RegisterAttribute(const String& name,
AttributeType type, AttributeBase *boundAttribute)
{
+ assert(OwnsLock());
+
AttributeHolder attr(type, boundAttribute);
pair<DynamicObject::AttributeIterator, bool> tt;
}
}
+/**
+ * @threadsafety Always.
+ */
void DynamicObject::Set(const String& name, const Value& data)
{
InternalSetAttribute(name, data, GetCurrentTx());
}
+/**
+ * @threadsafety Always.
+ */
void DynamicObject::Touch(const String& name)
{
InternalSetAttribute(name, InternalGetAttribute(name), GetCurrentTx());
}
+/**
+ * @threadsafety Always.
+ */
Value DynamicObject::Get(const String& name) const
{
return InternalGetAttribute(name);
}
+/**
+ * @threadsafety Always.
+ */
void DynamicObject::InternalSetAttribute(const String& name, const Value& data,
double tx, bool allowEditConfig)
{
+ ObjectLock olock(this);
+
DynamicObject::AttributeIterator it;
it = m_Attributes.find(name);
m_ModifiedAttributes.insert(make_pair(name, oldValue));
}
+/**
+ * @threadsafety Always.
+ */
Value DynamicObject::InternalGetAttribute(const String& name) const
{
+ ObjectLock olock(this);
+
DynamicObject::AttributeConstIterator it;
it = m_Attributes.find(name);
return it->second.GetValue();
}
+/**
+ * @threadsafety Always.
+ */
bool DynamicObject::HasAttribute(const String& name) const
{
+ ObjectLock olock(this);
+
return (m_Attributes.find(name) != m_Attributes.end());
}
void DynamicObject::ClearAttributesByType(AttributeType type)
{
+ assert(OwnsLock());
+
DynamicObject::AttributeIterator at;
for (at = m_Attributes.begin(); at != m_Attributes.end(); at++) {
if (at->second.GetType() != type)
}
}
+/**
+ * @threadsafety Always.
+ */
DynamicType::Ptr DynamicObject::GetType(void) const
{
+ ObjectLock olock(this);
+
return DynamicType::GetByName(m_Type);
}
+/**
+ * @threadsafety Always.
+ */
String DynamicObject::GetName(void) const
{
+ ObjectLock olock(this);
+
return m_Name;
}
+/**
+ * @threadsafety Always.
+ */
bool DynamicObject::IsLocal(void) const
{
+ ObjectLock olock(this);
+
return m_Local;
}
+/**
+ * @threadsafety Always.
+ */
bool DynamicObject::IsAbstract(void) const
{
+ ObjectLock olock(this);
+
return m_Abstract;
}
+/**
+ * @threadsafety Always.
+ */
bool DynamicObject::IsRegistered(void) const
{
+ ObjectLock olock(this);
+
return m_Registered;
}
+/**
+ * @threadsafety Always.
+ */
void DynamicObject::SetSource(const String& value)
{
+ ObjectLock olock(this);
+
m_Source = value;
Touch("__source");
}
+/**
+ * @threadsafety Always.
+ */
String DynamicObject::GetSource(void) const
{
+ ObjectLock olock(this);
+
return m_Source;
}
void DynamicObject::Register(void)
{
+ assert(OwnsLock());
+
/* It's now safe to send us attribute events. */
SetEventSafe(true);
void DynamicObject::Start(void)
{
+ assert(OwnsLock());
+
/* Nothing to do here. */
}
void DynamicObject::Unregister(void)
{
+ assert(OwnsLock());
+
DynamicType::Ptr dtype = GetType();
ObjectLock olock(dtype);
ScriptTask::Ptr DynamicObject::MakeMethodTask(const String& method,
const vector<Value>& arguments)
{
- String funcName;
+ assert(OwnsLock());
Dictionary::Ptr methods = m_Methods;
- {
- ObjectLock olock(methods);
- if (!methods->Contains(method))
- return ScriptTask::Ptr();
+ String funcName = methods->Get(method);
- funcName = methods->Get(method);
- }
+ if (funcName.IsEmpty())
+ return ScriptTask::Ptr();
ScriptFunction::Ptr func = ScriptFunction::GetByName(funcName);
StdioStream::Ptr sfp = boost::make_shared<StdioStream>(&fp, false);
sfp->Start();
- ;
BOOST_FOREACH(const DynamicType::Ptr& type, DynamicType::GetTypes()) {
+ String type_name;
+
+ {
+ ObjectLock olock(type);
+ type_name = type->GetName();
+ }
+
BOOST_FOREACH(const DynamicObject::Ptr& object, type->GetObjects()) {
+ ObjectLock olock(object);
+
if (object->IsLocal())
continue;
Dictionary::Ptr persistentObject = boost::make_shared<Dictionary>();
- persistentObject->Set("type", object->GetType()->GetName());
+ persistentObject->Set("type", type_name);
persistentObject->Set("name", object->GetName());
int types = Attribute_Local | Attribute_Replicated;
while (NetString::ReadStringFromStream(sfp, &message)) {
Dictionary::Ptr persistentObject = Value::Deserialize(message);
+ assert(persistentObject->IsSealed());
+
String type = persistentObject->Get("type");
String name = persistentObject->Get("name");
Dictionary::Ptr update = persistentObject->Get("update");
bool hasConfig = update->Contains("configTx");
DynamicType::Ptr dt = DynamicType::GetByName(type);
- ObjectLock dlock(dt);
if (!dt)
BOOST_THROW_EXCEPTION(invalid_argument("Invalid type: " + type));
DynamicObject::Ptr object = dt->GetObject(name);
if (hasConfig && !object) {
- object = dt->CreateObject(update);
+ object = DynamicType::CreateObject(dt, update);
+ ObjectLock olock(object);
object->Register();
} else if (object) {
+ ObjectLock olock(object);
object->ApplyUpdate(update, Attribute_All);
}
void DynamicObject::DeactivateObjects(void)
{
BOOST_FOREACH(const DynamicType::Ptr& dt, DynamicType::GetTypes()) {
- set<DynamicObject::Ptr> objects;
-
- {
- ObjectLock olock(dt);
- objects = dt->GetObjects();
- }
-
- BOOST_FOREACH(const DynamicObject::Ptr& object, objects) {
+ BOOST_FOREACH(const DynamicObject::Ptr& object, dt->GetObjects()) {
ObjectLock olock(object);
object->Unregister();
}
continue;
map<String, Value, string_iless> attrs;
+ bool event_safe;
{
ObjectLock olock(object);
attrs.swap(object->m_ModifiedAttributes);
+ event_safe = object->GetEventSafe();
}
- /* Check if it's safe to send events. */
- if (object->GetEventSafe()) {
+ /* Send attribute events if it's safe to do so. */
+ if (event_safe) {
map<String, Value, string_iless>::iterator it;
for (it = attrs.begin(); it != attrs.end(); it++)
object->OnAttributeChanged(it->first, it->second);
DynamicObject::Ptr DynamicObject::GetObject(const String& type, const String& name)
{
DynamicType::Ptr dtype = DynamicType::GetByName(type);
-
- {
- ObjectLock olock(dtype);
- return dtype->GetObject(name);
- }
+ return dtype->GetObject(name);
}
const DynamicObject::AttributeMap& DynamicObject::GetAttributes(void) const
{
+ assert(OwnsLock());
+
return m_Attributes;
}
void DynamicObject::SetEventSafe(bool safe)
{
+ assert(OwnsLock());
+
m_EventSafe = safe;
}
bool DynamicObject::GetEventSafe(void) const
{
+ assert(OwnsLock());
+
return m_EventSafe;
}
set<DynamicObject::Ptr> DynamicType::GetObjects(const String& type)
{
DynamicType::Ptr dt = GetByName(type);
- ObjectLock olock(dt);
return dt->GetObjects();
}
set<DynamicObject::Ptr> DynamicType::GetObjects(void) const
{
+ ObjectLock olock(this);
+
return m_ObjectSet; /* Making a copy of the set here. */
}
String DynamicType::GetName(void) const
{
+ ObjectLock olock(this);
+
return m_Name;
}
void DynamicType::RegisterObject(const DynamicObject::Ptr& object)
{
- String name;
-
- {
- ObjectLock olock(object);
- name = object->GetName();
- }
+ String name = object->GetName();
+ assert(OwnsLock());
ObjectMap::iterator it = m_ObjectMap.find(name);
if (it != m_ObjectMap.end()) {
ObjectLock olock(object);
object->SetEventSafe(false);
+ assert(OwnsLock());
m_ObjectMap.erase(object->GetName());
m_ObjectSet.erase(object);
}
+/**
+ * @threadsafety Always.
+ */
DynamicObject::Ptr DynamicType::GetObject(const String& name) const
{
+ ObjectLock olock(this);
+
DynamicType::ObjectMap::const_iterator nt = m_ObjectMap.find(name);
if (nt == m_ObjectMap.end())
InternalGetTypeSet().insert(type);
}
-DynamicObject::Ptr DynamicType::CreateObject(const Dictionary::Ptr& serializedUpdate) const
+DynamicObject::Ptr DynamicType::CreateObject(const DynamicType::Ptr& self, const Dictionary::Ptr& serializedUpdate)
{
- DynamicObject::Ptr object = m_ObjectFactory(serializedUpdate);
+ ObjectFactory factory;
{
- ObjectLock olock(object);
+ ObjectLock olock(self);
+ factory = self->m_ObjectFactory;
+ }
+
+ DynamicObject::Ptr object = factory(serializedUpdate);
- /* register attributes */
- String name;
- AttributeType type;
- BOOST_FOREACH(tuples::tie(name, type), m_Attributes)
- object->RegisterAttribute(name, type);
+ {
+ ObjectLock olock(object);
/* apply the object's non-config attributes */
object->ApplyUpdate(serializedUpdate, Attribute_All & ~Attribute_Config);
return object;
}
-/**
- * @threadsafety Always.
- */
-bool DynamicType::TypeExists(const String& name)
-{
- return (GetByName(name));
-}
-
-void DynamicType::AddAttribute(const String& name, AttributeType type)
-{
- m_Attributes[name] = type;
-}
-
-void DynamicType::RemoveAttribute(const String& name)
-{
- m_Attributes.erase(name);
-}
-
-bool DynamicType::HasAttribute(const String& name)
-{
- return (m_Attributes.find(name) != m_Attributes.end());
-}
-
-void DynamicType::AddAttributes(const AttributeDescription *attributes, int attributeCount)
-{
- for (int i = 0; i < attributeCount; i++)
- AddAttribute(attributes[i].Name, attributes[i].Type);
-}
-
boost::mutex& DynamicType::GetStaticMutex(void)
{
static boost::mutex mutex;
namespace icinga
{
-struct AttributeDescription
-{
- String Name;
- AttributeType Type;
-};
-
class I2_BASE_API DynamicType : public Object
{
public:
static DynamicType::Ptr GetByName(const String& name);
static void RegisterType(const DynamicType::Ptr& type);
- static bool TypeExists(const String& name);
- DynamicObject::Ptr CreateObject(const Dictionary::Ptr& serializedUpdate) const;
+ static DynamicObject::Ptr CreateObject(const DynamicType::Ptr& self, const Dictionary::Ptr& serializedUpdate);
DynamicObject::Ptr GetObject(const String& name) const;
void RegisterObject(const DynamicObject::Ptr& object);
static set<DynamicObject::Ptr> GetObjects(const String& type);
- void AddAttribute(const String& name, AttributeType type);
- void RemoveAttribute(const String& name);
- bool HasAttribute(const String& name);
-
- void AddAttributes(const AttributeDescription *attributes, int attributeCount);
-
private:
String m_Name;
ObjectFactory m_ObjectFactory;
- map<String, AttributeType> m_Attributes;
typedef map<String, DynamicObject::Ptr, string_iless> ObjectMap;
typedef set<DynamicObject::Ptr> ObjectSet;
class RegisterTypeHelper
{
public:
- RegisterTypeHelper(const String& name, const DynamicType::ObjectFactory& factory, const AttributeDescription* attributes, int attributeCount)
+ RegisterTypeHelper(const String& name, const DynamicType::ObjectFactory& factory)
{
- if (!DynamicType::TypeExists(name)) {
- DynamicType::Ptr type = boost::make_shared<DynamicType>(name, factory);
- type->AddAttributes(attributes, attributeCount);
- DynamicType::RegisterType(type);
- }
+ DynamicType::Ptr type = boost::make_shared<DynamicType>(name, factory);
+ DynamicType::RegisterType(type);
}
};
return boost::make_shared<T>(serializedUpdate);
}
-#define REGISTER_TYPE_ALIAS(type, alias, attributeDesc) \
- static RegisterTypeHelper g_RegisterDT_ ## type(alias, DynamicObjectFactory<type>, attributeDesc, (attributeDesc == NULL) ? 0 : sizeof(attributeDesc) / sizeof((static_cast<AttributeDescription *>(attributeDesc))[0]))
+#define REGISTER_TYPE_ALIAS(type, alias) \
+ static RegisterTypeHelper g_RegisterDT_ ## type(alias, DynamicObjectFactory<type>)
-#define REGISTER_TYPE(type, attributeDesc) \
- REGISTER_TYPE_ALIAS(type, #type, attributeDesc)
+#define REGISTER_TYPE(type) \
+ REGISTER_TYPE_ALIAS(type, #type)
}
using namespace icinga;
-REGISTER_TYPE(Logger, NULL);
+REGISTER_TYPE(Logger);
/**
* Constructor for the Logger class.
if (!IsLocal())
BOOST_THROW_EXCEPTION(runtime_error("Logger objects must be local."));
+}
+void Logger::Start(void)
+{
String type = m_Type;
if (type.IsEmpty())
BOOST_THROW_EXCEPTION(runtime_error("Logger objects must have a 'type' property."));
BOOST_THROW_EXCEPTION(runtime_error("Unknown log type: " + type));
}
- impl->m_Config = this;
+ impl->m_Config = GetSelf();
m_Impl = impl;
+
}
/**
*/
DynamicObject::Ptr ILogger::GetConfig(void) const
{
- return m_Config->GetSelf();
+ return m_Config.lock();
}
DynamicObject::Ptr GetConfig(void) const;
private:
- DynamicObject *m_Config;
+ DynamicObject::WeakPtr m_Config;
friend class Logger;
};
LogSeverity GetMinSeverity(void) const;
+protected:
+ virtual void Start(void);
+
private:
Attribute<String> m_Type;
Attribute<String> m_Path;
using namespace icinga;
+boost::mutex Object::m_DebugMutex;
+
/**
* Default constructor for the Object class.
*/
Object::Object(void)
+ : m_LockCount(0)
{ }
/**
*/
Object::SharedPtrHolder Object::GetSelf(void)
{
+ ObjectLock olock(this);
+
return Object::SharedPtrHolder(shared_from_this());
}
/**
- * Returns the mutex that must be held while calling non-static methods
- * which have not been explicitly marked as thread-safe.
+ * Checks if the calling thread owns the lock on this object or is currently
+ * in the constructor or destructor and therefore implicitly owns the lock.
*
- * @returns The object's mutex.
- * @threadsafety Always.
+ * @returns True if the calling thread owns the lock, false otherwise.
*/
-recursive_mutex& Object::GetMutex(void) const
+bool Object::OwnsLock(void) const
{
- return m_Mutex;
+ boost::mutex::scoped_lock lock(m_DebugMutex);
+
+ if (m_LockCount == 0 || m_LockOwner != boost::this_thread::get_id()) {
+ try {
+ shared_from_this();
+ } catch (const boost::bad_weak_ptr& ex) {
+ /* There's no shared_ptr to this object. Either someone created the object
+ * directly (e.g. on the stack) or we're in the constructor or destructor. Not holding the lock is ok here. */
+ return true;
+ }
+
+ return false;
+ }
+
+ return true;
}
holder instance */
};
- SharedPtrHolder GetSelf(void);
-
- recursive_mutex& GetMutex(void) const;
+ void VerifyLocked(void) const;
+ void WarnIfLocked(void) const;
protected:
Object(void);
virtual ~Object(void);
+ SharedPtrHolder GetSelf(void);
+
+ bool OwnsLock(void) const;
+
private:
Object(const Object& other);
Object& operator=(const Object& rhs);
mutable recursive_mutex m_Mutex;
+ mutable unsigned int m_LockCount;
+ mutable boost::thread::id m_LockOwner;
+
+ static boost::mutex m_DebugMutex;
+
+ friend class ObjectLock;
};
/**
: m_Object(NULL), m_Lock()
{ }
+ObjectLock::~ObjectLock(void)
+{
+ Unlock();
+}
+
ObjectLock::ObjectLock(const Object::Ptr& object)
: m_Object(object.get()), m_Lock()
{
{
assert(!m_Lock.owns_lock() && m_Object != NULL);
- m_Lock = recursive_mutex::scoped_lock(m_Object->GetMutex());
+ m_Lock = recursive_mutex::scoped_lock(m_Object->m_Mutex);
+
+ {
+ boost::mutex::scoped_lock lock(Object::m_DebugMutex);
+ m_Object->m_LockCount++;
+ m_Object->m_LockOwner = boost::this_thread::get_id();
+ }
}
void ObjectLock::Unlock(void)
{
+ {
+ boost::mutex::scoped_lock lock(Object::m_DebugMutex);
+
+ if (m_Lock.owns_lock())
+ m_Object->m_LockCount--;
+ }
+
m_Lock = recursive_mutex::scoped_lock();
}
ObjectLock(void);
ObjectLock(const Object::Ptr& object);
ObjectLock(const Object *object);
+ ~ObjectLock(void);
void Lock(void);
void Unlock(void);
if (fd >= 0)
tasks[fd] = task;
} catch (...) {
- ObjectLock olock(task);
task->FinishException(boost::current_exception());
}
}
prev = it;
tasks.erase(prev);
- ObjectLock olock(task);
task->FinishResult(task->m_Result);
}
}
envp[i] = strdup(environ[i]);
if (m_ExtraEnvironment) {
+ ObjectLock olock(m_ExtraEnvironment);
+
String key;
Value value;
int index = envc;
if (command.IsObjectType<Dictionary>()) {
Dictionary::Ptr dict = command;
+ ObjectLock olock(dict);
+
Value arg;
BOOST_FOREACH(tie(tuples::ignore, arg), dict) {
args.push_back(arg);
using namespace icinga;
RingBuffer::RingBuffer(RingBuffer::SizeType slots)
- : m_Slots(slots, 0), m_TimeValue(0)
+ : Object(), m_Slots(slots, 0), m_TimeValue(0)
{ }
+/**
+ * @threadsafety Always.
+ */
RingBuffer::SizeType RingBuffer::GetLength(void) const
{
+ ObjectLock olock(this);
+
return m_Slots.size();
}
+/**
+ * @threadsafety Always.
+ */
void RingBuffer::InsertValue(RingBuffer::SizeType tv, int num)
{
+ ObjectLock olock(this);
+
vector<int>::size_type offsetTarget = tv % m_Slots.size();
if (tv > m_TimeValue) {
m_Slots[offsetTarget] += num;
}
+/**
+ * @threadsafety Always.
+ */
int RingBuffer::GetValues(RingBuffer::SizeType span) const
{
+ ObjectLock olock(this);
+
if (span > m_Slots.size())
span = m_Slots.size();
*
* @ingroup base
*/
-class I2_BASE_API RingBuffer
+class I2_BASE_API RingBuffer : public Object
{
public:
+ typedef shared_ptr<RingBuffer> Ptr;
+ typedef weak_ptr<RingBuffer> WeakPtr;
+
typedef vector<int>::size_type SizeType;
RingBuffer(SizeType slots);
using namespace icinga;
-REGISTER_TYPE(Script, NULL);
+REGISTER_TYPE(Script);
/**
* Constructor for the Script class.
void Script::Start(void)
{
+ assert(OwnsLock());
+
SpawnInterpreter();
}
String Script::GetLanguage(void) const
{
+ ObjectLock olock(this);
+
return m_Language;
}
String Script::GetCode(void) const
{
+ ObjectLock olock(this);
+
return m_Code;
}
void ScriptFunction::Register(const String& name, const ScriptFunction::Ptr& function)
{
- GetFunctions()[name] = function;
+ boost::mutex::scoped_lock lock(GetMutex());
+ InternalGetFunctions()[name] = function;
OnRegistered(name, function);
}
void ScriptFunction::Unregister(const String& name)
{
- GetFunctions().erase(name);
+ boost::mutex::scoped_lock lock(GetMutex());
+ InternalGetFunctions().erase(name);
OnUnregistered(name);
}
{
map<String, ScriptFunction::Ptr>::iterator it;
- it = GetFunctions().find(name);
+ boost::mutex::scoped_lock lock(GetMutex());
+ it = InternalGetFunctions().find(name);
- if (it == GetFunctions().end())
+ if (it == InternalGetFunctions().end())
return ScriptFunction::Ptr();
return it->second;
void ScriptFunction::Invoke(const ScriptTask::Ptr& task, const vector<Value>& arguments)
{
+ ObjectLock olock(this);
+
m_Callback(task, arguments);
}
-map<String, ScriptFunction::Ptr>& ScriptFunction::GetFunctions(void)
+map<String, ScriptFunction::Ptr> ScriptFunction::GetFunctions(void)
+{
+ boost::mutex::scoped_lock lock(GetMutex());
+ return InternalGetFunctions(); /* makes a copy of the map */
+}
+
+/**
+ * @threadsafety Caller must hold the mutex returned by GetMutex().
+ */
+map<String, ScriptFunction::Ptr>& ScriptFunction::InternalGetFunctions(void)
{
static map<String, ScriptFunction::Ptr> functions;
return functions;
}
+
+boost::mutex& ScriptFunction::GetMutex(void)
+{
+ static boost::mutex mtx;
+ return mtx;
+}
void Invoke(const shared_ptr<ScriptTask>& task, const vector<Value>& arguments);
- /* TODO(thread) make private */ static map<String, ScriptFunction::Ptr>& GetFunctions(void);
+ static map<String, ScriptFunction::Ptr> GetFunctions(void);
static signals2::signal<void (const String&, const ScriptFunction::Ptr&)> OnRegistered;
static signals2::signal<void (const String&)> OnUnregistered;
private:
Callback m_Callback;
+
+ static map<String, ScriptFunction::Ptr>& InternalGetFunctions(void);
+ static boost::mutex& GetMutex(void);
};
/**
void ScriptInterpreter::SubscribeFunction(const String& name)
{
+ ObjectLock olock(this);
+
m_SubscribedFunctions.insert(name);
ScriptFunction::Ptr sf = boost::make_shared<ScriptFunction>(boost::bind(&ScriptInterpreter::ProcessCall, this, _1, name, _2));
void ScriptInterpreter::UnsubscribeFunction(const String& name)
{
+ ObjectLock olock(this);
+
m_SubscribedFunctions.erase(name);
ScriptFunction::Unregister(name);
}
void ScriptTask::Run(void)
{
- m_Function->Invoke(GetSelf(), m_Arguments);
+ ScriptTask::Ptr self;
+
+ {
+ ObjectLock olock(this);
+ self = GetSelf();
+ }
+
+ m_Function->Invoke(self, m_Arguments);
}
size_t StdioStream::GetAvailableBytes(void) const
{
+ ObjectLock olock(this);
+
if (m_InnerStream->eof() && m_ReadAheadBuffer->GetAvailableBytes() == 0)
return 0;
else
size_t StdioStream::Read(void *buffer, size_t size)
{
+ ObjectLock olock(this);
+
size_t peek_len, read_len;
peek_len = m_ReadAheadBuffer->GetAvailableBytes();
size_t StdioStream::Peek(void *buffer, size_t size)
{
+ ObjectLock olock(this);
+
size_t peek_len, read_len;
peek_len = m_ReadAheadBuffer->GetAvailableBytes();
void StdioStream::Write(const void *buffer, size_t size)
{
+ ObjectLock olock(this);
+
m_InnerStream->write(static_cast<const char *>(buffer), size);
}
void StdioStream::Close(void)
{
+ ObjectLock olock(this);
+
if (m_OwnsStream)
delete m_InnerStream;
*
* @threadsafety Always.
*/
-void Timer::Call(void)
+void Timer::Call(const Timer::Ptr& self)
{
- OnTimerExpired(GetSelf());
+ self->OnTimerExpired(self);
/* Re-enable the timer so it can be called again. */
- m_Started = true;
- Reschedule();
+ self->Start();
}
/**
*/
void Timer::SetInterval(double interval)
{
+ assert(!OwnsLock());
+
boost::mutex::scoped_lock lock(m_Mutex);
m_Interval = interval;
}
*/
double Timer::GetInterval(void) const
{
+ assert(!OwnsLock());
+
boost::mutex::scoped_lock lock(m_Mutex);
return m_Interval;
}
*/
void Timer::Start(void)
{
- m_Started = true;
+ assert(!OwnsLock());
+
+ {
+ boost::mutex::scoped_lock lock(m_Mutex);
+ m_Started = true;
+ }
Reschedule();
}
*/
void Timer::Stop(void)
{
+ assert(!OwnsLock());
+
boost::mutex::scoped_lock lock(m_Mutex);
m_Started = false;
*/
void Timer::Reschedule(double next)
{
+ assert(!OwnsLock());
+
boost::mutex::scoped_lock lock(m_Mutex);
if (next < 0) {
*/
double Timer::GetNext(void) const
{
+ assert(!OwnsLock());
+
boost::mutex::scoped_lock lock(m_Mutex);
return m_Next;
}
static bool m_StopThread;
static TimerSet m_Timers;
- void Call(void);
+ static void Call(const Timer::Ptr& self);
static void TimerThreadProc(void);
BOOST_THROW_EXCEPTION(domain_error(message.str()));
}
+ ObjectLock olock(parent);
parent->InternalLink(dictionary);
}
m_Items[ikey] = self;
}
- if (!dobj) {
- ObjectLock olock(dtype);
+ if (!dobj)
dobj = dtype->GetObject(name);
- }
/* Register this item with its parents. */
BOOST_FOREACH(const String& parentName, parents) {
* DynamicObject::ApplyUpdate expects. */
Dictionary::Ptr attrs = boost::make_shared<Dictionary>();
- String key;
- Value data;
- BOOST_FOREACH(tie(key, data), properties) {
- Dictionary::Ptr attr = boost::make_shared<Dictionary>();
- attr->Set("data", data);
- attr->Set("type", Attribute_Config);
- attr->Set("tx", DynamicObject::GetCurrentTx());
- attrs->Set(key, attr);
+ double tx = DynamicObject::GetCurrentTx();
+
+ {
+ ObjectLock olock(properties);
+
+ String key;
+ Value data;
+ BOOST_FOREACH(tie(key, data), properties) {
+ Dictionary::Ptr attr = boost::make_shared<Dictionary>();
+ attr->Set("data", data);
+ attr->Set("type", Attribute_Config);
+ attr->Set("tx", tx);
+ attr->Seal();
+
+ attrs->Set(key, attr);
+ }
}
+ attrs->Seal();
+
Dictionary::Ptr update = boost::make_shared<Dictionary>();
update->Set("attrs", attrs);
update->Set("configTx", DynamicObject::GetCurrentTx());
+ update->Seal();
/* Update or create the object and apply the configuration settings. */
bool was_null = false;
if (!dobj) {
- ObjectLock dlock(dtype);
- dobj = dtype->CreateObject(update);
+ dobj = DynamicType::CreateObject(dtype, update);
was_null = true;
}
void ConfigType::ValidateItem(const ConfigItem::Ptr& item) const
{
- Dictionary::Ptr attrs = item->Link();
+ String type, name;
+ Dictionary::Ptr attrs;
+
+ {
+ ObjectLock olock(item);
+ attrs = item->Link();
+ type = item->GetType();
+ name = item->GetName();
+ }
+
+ ObjectLock olock(attrs);
/* Don't validate abstract items. */
if (attrs->Get("__abstract"))
return;
vector<String> locations;
- locations.push_back("Object '" + item->GetName() + "' (Type: '" + item->GetType() + "')");
+ locations.push_back("Object '" + name + "' (Type: '" + type + "')");
ConfigType::Ptr parent;
if (m_Parent.IsEmpty()) {
}
vector<TypeRuleList::Ptr> ruleLists;
- if (parent)
+ if (parent) {
+ ObjectLock plock(parent);
ruleLists.push_back(parent->m_RuleList);
+ }
ruleLists.push_back(m_RuleList);
ScriptTask::Ptr task = boost::make_shared<ScriptTask>(func, arguments);
task->Start();
- task->Wait();
-
- {
- ObjectLock olock(task);
- task->GetResult();
- }
+ task->GetResult();
}
}
+ ObjectLock olock(dictionary);
+
String key;
Value value;
BOOST_FOREACH(tie(key, value), dictionary) {
case OperatorSet:
if (valueExprl) {
+ ObjectLock olock(valueExprl);
dict = boost::make_shared<Dictionary>();
valueExprl->Execute(dict);
newValue = dict;
break;
case OperatorPlus:
- oldValue = dictionary->Get(m_Key);
+ {
+ ObjectLock olock(dictionary);
+ oldValue = dictionary->Get(m_Key);
+ }
if (oldValue.IsObjectType<Dictionary>())
dict = oldValue;
newValue = dict;
if (valueExprl) {
+ ObjectLock olock(valueExprl);
+
valueExprl->Execute(dict);
} else if (valueDict) {
+ ObjectLock olock(valueDict);
+ ObjectLock dlock(dict);
+
String key;
Value value;
BOOST_FOREACH(tie(key, value), valueDict) {
BOOST_THROW_EXCEPTION(runtime_error("Not yet implemented."));
}
+ ObjectLock olock(dictionary);
if (m_Key.IsEmpty())
dictionary->Add(newValue);
else
using namespace icinga;
-boost::mutex CIB::m_Mutex;
RingBuffer CIB::m_ActiveChecksStatistics(15 * 60);
RingBuffer CIB::m_PassiveChecksStatistics(15 * 60);
*/
void CIB::UpdateActiveChecksStatistics(long tv, int num)
{
- boost::mutex::scoped_lock lock(m_Mutex);
m_ActiveChecksStatistics.InsertValue(tv, num);
}
*/
int CIB::GetActiveChecksStatistics(long timespan)
{
- boost::mutex::scoped_lock lock(m_Mutex);
return m_ActiveChecksStatistics.GetValues(timespan);
}
*/
void CIB::UpdatePassiveChecksStatistics(long tv, int num)
{
- boost::mutex::scoped_lock lock(m_Mutex);
m_PassiveChecksStatistics.InsertValue(tv, num);
}
*/
int CIB::GetPassiveChecksStatistics(long timespan)
{
- boost::mutex::scoped_lock lock(m_Mutex);
return m_PassiveChecksStatistics.GetValues(timespan);
}
REGISTER_SCRIPTFUNCTION("ValidateServiceDictionary", &Host::ValidateServiceDictionary);
-REGISTER_TYPE(Host, NULL);
+REGISTER_TYPE(Host);
Host::Host(const Dictionary::Ptr& properties)
: DynamicObject(properties)
template<bool copyServiceAttrs, typename TDict>
static void CopyServiceAttributes(TDict serviceDesc, const ConfigItemBuilder::Ptr& builder)
{
+ ObjectLock olock(serviceDesc);
+
/* TODO: we only need to copy macros if this is an inline definition,
* i.e. "typeid(serviceDesc)" != Service, however for now we just
* copy them anyway. */
}
newServices = boost::make_shared<Dictionary>();
+ ObjectLock nlock(newServices);
DebugInfo debug_info;
}
if (serviceDescs) {
+ ObjectLock olock(serviceDescs);
String svcname;
Value svcdesc;
BOOST_FOREACH(tie(svcname, svcdesc), serviceDescs) {
} else if (svcdesc.IsObjectType<Dictionary>()) {
Dictionary::Ptr service = svcdesc;
- Dictionary::Ptr templates = service->Get("templates");
+ Dictionary::Ptr templates;
+
+ {
+ ObjectLock olock(service);
+ templates = service->Get("templates");
+ }
if (templates) {
+ ObjectLock olock(templates);
+
String tmpl;
BOOST_FOREACH(tie(tuples::ignore, tmpl), templates) {
builder->AddParent(tmpl);
}
if (oldServices) {
+ ObjectLock olock(oldServices);
+
ConfigItem::Ptr service;
BOOST_FOREACH(tie(tuples::ignore, service), oldServices) {
if (!service)
newServices->Seal();
+ ObjectLock olock(self);
self->Set("slave_services", newServices);
}
if (name == "hostgroups")
HostGroup::InvalidateMembersCache();
else if (name == "services") {
- UpdateSlaveServices(GetSelf());
+ Host::Ptr self;
+
+ {
+ ObjectLock olock(this);
+ self = GetSelf();
+ }
+
+ UpdateSlaveServices(self);
} else if (name == "notifications") {
set<Service::Ptr> services;
String location = arguments[0];
Dictionary::Ptr attrs = arguments[1];
+ ObjectLock olock(attrs);
String key;
Value value;
} else if (value.IsObjectType<Dictionary>()) {
Dictionary::Ptr serviceDesc = value;
- if (serviceDesc->Contains("service"))
- name = serviceDesc->Get("service");
- else
+ name = serviceDesc->Get("service");
+
+ if (name.IsEmpty())
name = key;
} else {
continue;
Dictionary::Ptr Host::CalculateDynamicMacros(const Host::Ptr& self)
{
Dictionary::Ptr macros = boost::make_shared<Dictionary>();
+ ObjectLock mlock(macros);
{
ObjectLock olock(self);
map<String, vector<Host::WeakPtr> > HostGroup::m_MembersCache;
bool HostGroup::m_MembersCacheValid = true;
-REGISTER_TYPE(HostGroup, NULL);
+REGISTER_TYPE(HostGroup);
HostGroup::HostGroup(const Dictionary::Ptr& properties)
: DynamicObject(properties)
using namespace icinga;
-REGISTER_TYPE(IcingaApplication, NULL);
+REGISTER_TYPE(IcingaApplication);
#ifndef _WIN32
# include "icinga-version.h"
Dictionary::Ptr IcingaApplication::CalculateDynamicMacros(const IcingaApplication::Ptr& self)
{
Dictionary::Ptr macros = boost::make_shared<Dictionary>();
+ ObjectLock mlock(macros);
double now = Utility::GetTime();
using namespace icinga;
-REGISTER_TYPE(Notification, NULL);
+REGISTER_TYPE(Notification);
Notification::Notification(const Dictionary::Ptr& properties)
: DynamicObject(properties)
Dictionary::Ptr users = m_Users;
if (users) {
+ ObjectLock olock(users);
+
String name;
BOOST_FOREACH(tie(tuples::ignore, name), users) {
User::Ptr user = User::GetByName(name);
Dictionary::Ptr groups = m_Groups;
if (groups) {
+ ObjectLock olock(groups);
+
String name;
BOOST_FOREACH(tie(tuples::ignore, name), groups) {
UserGroup::Ptr ug = UserGroup::GetByName(name);
m_Tasks.erase(task);
try {
- {
- ObjectLock tlock(task);
- (void) task->GetResult();
- }
+ task->GetResult();
Logger::Write(LogInformation, "icinga", "Completed sending notification for service '" + GetService()->GetName() + "'");
} catch (const exception& ex) {
using namespace icinga;
-REGISTER_TYPE(PerfdataWriter, NULL);
+REGISTER_TYPE(PerfdataWriter);
PerfdataWriter::PerfdataWriter(const Dictionary::Ptr& properties)
: DynamicObject(properties)
{
ObjectLock olock(m_Endpoint);
+
m_Endpoint->RegisterTopicHandler("checker::CheckResult",
boost::bind(&PerfdataWriter::CheckResultRequestHandler, this, _3));
}
ProcessResult pr;
try {
- ObjectLock olock(ct.m_Process);
pr = ct.m_Process->GetResult();
} catch (...) {
- ObjectLock olock(ct.m_Task);
ct.m_Task->FinishException(boost::current_exception());
return;
result->Set("execution_start", pr.ExecutionStart);
result->Set("execution_end", pr.ExecutionEnd);
- ObjectLock olock(ct.m_Task);
ct.m_Task->FinishResult(result);
}
try {
{
- ObjectLock tlock(ct.m_Process);
pr = ct.m_Process->GetResult();
}
Logger::Write(LogWarning, "icinga", msgbuf.str());
}
- {
- ObjectLock olock(ct.m_Task);
- ct.m_Task->FinishResult(Empty);
- }
+ ct.m_Task->FinishResult(Empty);
} catch (...) {
- {
- ObjectLock olock(ct.m_Task);
- ct.m_Task->FinishException(boost::current_exception());
- }
+ ct.m_Task->FinishException(boost::current_exception());
return;
}
/* keep track of scheduling info in case the check type doesn't provide its own information */
Dictionary::Ptr checkInfo = boost::make_shared<Dictionary>();
- checkInfo->Set("schedule_start", self->GetNextCheck());
- checkInfo->Set("execution_start", Utility::GetTime());
+
+ {
+ ObjectLock olock(checkInfo);
+ checkInfo->Set("schedule_start", self->GetNextCheck());
+ checkInfo->Set("execution_start", Utility::GetTime());
+ }
vector<Dictionary::Ptr> macroDicts;
macroDicts.push_back(self->GetMacros());
{
checkInfo->Set("execution_end", Utility::GetTime());
checkInfo->Set("schedule_end", Utility::GetTime());
+ checkInfo->Seal();
Dictionary::Ptr result;
try {
- Value vresult;
-
- {
- ObjectLock tlock(task);
- vresult = task->GetResult();
- }
+ Value vresult = task->GetResult();
if (vresult.IsObjectType<Dictionary>())
result = vresult;
result->Set("current_checker", em->GetIdentity());
}
+
+ result->Seal();
}
{
template<typename TDict>
static void CopyNotificationAttributes(TDict notificationDesc, const ConfigItemBuilder::Ptr& builder)
{
+ ObjectLock olock(notificationDesc);
+
/* TODO: we only need to copy macros if this is an inline definition,
* i.e. "typeid(notificationDesc)" != Notification, however for now we just
* copy them anyway. */
Dictionary::Ptr newNotifications;
newNotifications = boost::make_shared<Dictionary>();
+ ObjectLock nlock(newNotifications);
+
String host_name;
{
Dictionary::Ptr templates = notification->Get("templates");
if (templates) {
+ ObjectLock tlock(templates);
+
String tmpl;
BOOST_FOREACH(tie(tuples::ignore, tmpl), templates) {
builder->AddParent(tmpl);
}
if (oldNotifications) {
+ ObjectLock olock(oldNotifications);
+
ConfigItem::Ptr notification;
BOOST_FOREACH(tie(tuples::ignore, notification), oldNotifications) {
if (!notification)
using namespace icinga;
-REGISTER_TYPE(Service, NULL);
+REGISTER_TYPE(Service);
Service::Service(const Dictionary::Ptr& serializedObject)
: DynamicObject(serializedObject)
void Service::OnAttributeChanged(const String& name, const Value& oldValue)
{
+ Service::Ptr self;
+ String service_name;
+ bool abstract;
+
+ {
+ ObjectLock olock(this);
+ self = GetSelf();
+ service_name = GetName();
+ abstract = IsAbstract();
+ }
+
if (name == "current_checker")
- OnCheckerChanged(GetSelf(), oldValue);
+ OnCheckerChanged(self, oldValue);
else if (name == "next_check")
- OnNextCheckChanged(GetSelf(), oldValue);
+ OnNextCheckChanged(self, oldValue);
else if (name == "servicegroups")
ServiceGroup::InvalidateMembersCache();
else if (name == "host_name" || name == "short_name") {
Host::InvalidateServicesCache();
- UpdateSlaveNotifications(GetSelf());
+ UpdateSlaveNotifications(self);
} else if (name == "downtimes")
Service::InvalidateDowntimesCache();
else if (name == "comments")
Service::InvalidateCommentsCache();
else if (name == "notifications")
- UpdateSlaveNotifications(GetSelf());
+ UpdateSlaveNotifications(self);
else if (name == "check_interval") {
- ObjectLock(this);
- ConfigItem::Ptr item = ConfigItem::GetObject("Service", GetName());
+ ObjectLock olock(this);
+ ConfigItem::Ptr item = ConfigItem::GetObject("Service", service_name);
/* update the next check timestamp if we're the owner of this service */
- if (item && !IsAbstract())
+ if (item && !abstract)
UpdateNextCheck();
}
}
Dictionary::Ptr Service::CalculateDynamicMacros(const Service::Ptr& self)
{
Dictionary::Ptr macros = boost::make_shared<Dictionary>();
+ ObjectLock mlock(macros);
Dictionary::Ptr cr;
map<String, vector<Service::WeakPtr> > ServiceGroup::m_MembersCache;
bool ServiceGroup::m_MembersCacheValid = true;
-REGISTER_TYPE(ServiceGroup, NULL);
+REGISTER_TYPE(ServiceGroup);
ServiceGroup::ServiceGroup(const Dictionary::Ptr& properties)
: DynamicObject(properties)
using namespace icinga;
-REGISTER_TYPE(User, NULL);
+REGISTER_TYPE(User);
User::User(const Dictionary::Ptr& properties)
: DynamicObject(properties)
map<String, vector<User::WeakPtr> > UserGroup::m_MembersCache;
bool UserGroup::m_MembersCacheValid = true;
-REGISTER_TYPE(UserGroup, NULL);
+REGISTER_TYPE(UserGroup);
UserGroup::UserGroup(const Dictionary::Ptr& properties)
: DynamicObject(properties)
using namespace icinga;
-REGISTER_TYPE(Endpoint, NULL);
+REGISTER_TYPE(Endpoint);
signals2::signal<void (const Endpoint::Ptr&)> Endpoint::OnConnected;
signals2::signal<void (const Endpoint::Ptr&)> Endpoint::OnDisconnected;
if (!subscriptions)
subscriptions = boost::make_shared<Dictionary>();
+ ObjectLock olock(subscriptions);
+
if (!subscriptions->Contains(topic)) {
Dictionary::Ptr newSubscriptions = subscriptions->ShallowClone();
+ ObjectLock nlock(newSubscriptions);
newSubscriptions->Set(topic, topic);
SetSubscriptions(newSubscriptions);
}
{
Dictionary::Ptr subscriptions = GetSubscriptions();
- if (subscriptions && subscriptions->Contains(topic)) {
+ if (!subscriptions)
+ return;
+
+ ObjectLock olock(subscriptions);
+
+ if (subscriptions->Contains(topic)) {
Dictionary::Ptr newSubscriptions = subscriptions->ShallowClone();
+ ObjectLock nlock(newSubscriptions);
newSubscriptions->Remove(topic);
SetSubscriptions(newSubscriptions);
}
newSubscriptions = GetSubscriptions();
+ ObjectLock olock(oldSubscriptions);
+ ObjectLock nlock(newSubscriptions);
+
if (oldSubscriptions) {
String subscription;
BOOST_FOREACH(tie(tuples::ignore, subscription), oldSubscriptions) {
if (!endpoint->IsLocalEndpoint() || endpoint == m_Endpoint)
continue;
- if (endpoint->GetSubscriptions()) {
+ Dictionary::Ptr endpointSubscriptions = endpoint->GetSubscriptions();
+
+ if (endpointSubscriptions) {
+ ObjectLock olock(endpointSubscriptions);
+
String topic;
BOOST_FOREACH(tie(tuples::ignore, topic), endpoint->GetSubscriptions()) {
subscriptions->Set(topic, topic);
projects / icinga2 / commitdiff