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

Fix race condition in the ConfigItem class 

fixes #10643
This commit is contained in:
Gunnar Beutner 2015-11-19 19:38:20 +01:00
parent 530c7c7fcc
commit 3505ca3c16
10 changed files with 260 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
lib/cli/daemoncommand.cpp
View File

@ -230,7 +230,9 @@ int DaemonCommand::Run(const po::variables_map& vm, const std::vector<std::strin
else if (!vm.count("no-config"))
configs.push_back(Application::GetSysconfDir() + "/icinga2/icinga2.conf");
if (!DaemonUtility::LoadConfigFiles(configs, Application::GetObjectsPath(), Application::GetVarsPath()))
std::vector<ConfigItem::Ptr> newItems;
if (!DaemonUtility::LoadConfigFiles(configs, newItems, Application::GetObjectsPath(), Application::GetVarsPath()))
return EXIT_FAILURE;
if (vm.count("validate")) {
@ -258,11 +260,20 @@ int DaemonCommand::Run(const po::variables_map& vm, const std::vector<std::strin
}
}
/* restore the previous program state */
try {
ConfigObject::RestoreObjects(Application::GetStatePath());
} catch (const std::exception& ex) {
Log(LogCritical, "cli")
<< "Failed to restore state file: " << DiagnosticInformation(ex);
return EXIT_FAILURE;
}
{
WorkQueue upq(25000, Application::GetConcurrency());
// activate config only after daemonization: it starts threads and that is not compatible with fork()
if (!ConfigItem::ActivateItems(upq, true)) {
if (!ConfigItem::ActivateItems(upq, newItems)) {
Log(LogCritical, "cli", "Error activating configuration.");
return EXIT_FAILURE;
}

5
lib/cli/daemonutility.cpp
View File

@ -138,13 +138,16 @@ bool DaemonUtility::ValidateConfigFiles(const std::vector<std::string>& configs,
}
bool DaemonUtility::LoadConfigFiles(const std::vector<std::string>& configs,
std::vector<ConfigItem::Ptr>& newItems,
const String& objectsFile, const String& varsfile)
{
ActivationScope ascope;
if (!DaemonUtility::ValidateConfigFiles(configs, objectsFile))
return false;
WorkQueue upq(25000, Application::GetConcurrency());
bool result = ConfigItem::CommitItems(upq);
bool result = ConfigItem::CommitItems(ascope.GetContext(), upq, newItems);
if (!result)
return false;

4
lib/cli/daemonutility.hpp
View File

@ -21,6 +21,7 @@
#define DAEMONUTILITY_H
#include "cli/i2-cli.hpp"
#include "config/configitem.hpp"
#include "base/string.hpp"
#include <boost/program_options.hpp>
@ -34,7 +35,8 @@ class I2_CLI_API DaemonUtility
{
public:
static bool ValidateConfigFiles(const std::vector<std::string>& configs, const String& objectsFile = String());
static bool LoadConfigFiles(const std::vector<std::string>& configs, const String& objectsFile = String(), const String& varsfile = String());
static bool LoadConfigFiles(const std::vector<std::string>& configs, std::vector<ConfigItem::Ptr>& newItems,
const String& objectsFile = String(), const String& varsfile = String());
};
}

2
lib/config/CMakeLists.txt
View File

@ -34,7 +34,7 @@ add_flex_bison_dependency(config_lexer config_parser)
include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
set(config_SOURCES
applyrule.cpp
activationcontext.cpp applyrule.cpp
configcompilercontext.cpp configcompiler.cpp configitembuilder.cpp
configitem.cpp ${FLEX_config_lexer_OUTPUTS} ${BISON_config_parser_OUTPUTS}
expression.cpp objectrule.cpp

78
lib/config/activationcontext.cpp Normal file
View File

@ -0,0 +1,78 @@
/******************************************************************************
* 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 "config/activationcontext.hpp"
#include "base/exception.hpp"
using namespace icinga;
boost::thread_specific_ptr<std::stack<ActivationContext::Ptr> > ActivationContext::m_ActivationStack;
std::stack<ActivationContext::Ptr>& ActivationContext::GetActivationStack(void)
{
std::stack<ActivationContext::Ptr> *actx = m_ActivationStack.get();
if (!actx) {
actx = new std::stack<ActivationContext::Ptr>();
m_ActivationStack.reset(actx);
}
return *actx;
}
void ActivationContext::PushContext(const ActivationContext::Ptr& context)
{
GetActivationStack().push(context);
}
void ActivationContext::PopContext(void)
{
ASSERT(!GetActivationStack().empty());
GetActivationStack().pop();
}
ActivationContext::Ptr ActivationContext::GetCurrentContext(void)
{
std::stack<ActivationContext::Ptr>& astack = GetActivationStack();
if (astack.empty())
BOOST_THROW_EXCEPTION(std::runtime_error("Objects may not be created outside of an activation context."));
return astack.top();
}
ActivationScope::ActivationScope(const ActivationContext::Ptr& context)
: m_Context(context)
{
if (!m_Context)
m_Context = new ActivationContext();
ActivationContext::PushContext(m_Context);
}
ActivationScope::~ActivationScope(void)
{
ActivationContext::PopContext();
}
ActivationContext::Ptr ActivationScope::GetContext(void) const
{
return m_Context;
}

63
lib/config/activationcontext.hpp Normal file
View File

@ -0,0 +1,63 @@
/******************************************************************************
* 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. *
******************************************************************************/
#ifndef ACTIVATIONCONTEXT_H
#define ACTIVATIONCONTEXT_H
#include "config/i2-config.hpp"
#include "base/object.hpp"
#include <boost/thread/tss.hpp>
#include <stack>
namespace icinga
{
class I2_CONFIG_API ActivationContext : public Object
{
public:
DECLARE_PTR_TYPEDEFS(ActivationContext);
static ActivationContext::Ptr GetCurrentContext(void);
private:
static void PushContext(const ActivationContext::Ptr& context);
static void PopContext(void);
static std::stack<ActivationContext::Ptr>& GetActivationStack(void);
static boost::thread_specific_ptr<std::stack<ActivationContext::Ptr> > m_ActivationStack;
friend class ActivationScope;
};
class I2_CONFIG_API ActivationScope
{
public:
ActivationScope(const ActivationContext::Ptr& context = ActivationContext::Ptr());
~ActivationScope(void);
ActivationContext::Ptr GetContext(void) const;
private:
ActivationContext::Ptr m_Context;
};
}
#endif /* ACTIVATIONCONTEXT_H */

141
lib/config/configitem.cpp
View File

@ -44,9 +44,8 @@ using namespace icinga;
boost::mutex ConfigItem::m_Mutex;
ConfigItem::TypeMap ConfigItem::m_Items;
ConfigItem::ItemList ConfigItem::m_UnnamedItems;
ConfigItem::ItemList ConfigItem::m_CommittedItems;
REGISTER_SCRIPTFUNCTION(commit_objects, &ConfigItem::CommitAndActivate);
REGISTER_SCRIPTFUNCTION(__run_with_activation_context, &ConfigItem::RunWithActivationContext);
/**
* Constructor for the ConfigItem class.
@ -235,11 +234,6 @@ ConfigObject::Ptr ConfigItem::Commit(bool discard)
throw;
}
{
boost::mutex::scoped_lock lock(m_Mutex);
m_CommittedItems.push_back(this);
}
Dictionary::Ptr persistentItem = new Dictionary();
persistentItem->Set("type", GetType());
@ -291,14 +285,15 @@ void ConfigItem::Register(void)
{
Type::Ptr type = Type::GetByName(m_Type);
m_ActivationContext = ActivationContext::GetCurrentContext();
boost::mutex::scoped_lock lock(m_Mutex);
/* If this is a non-abstract object with a composite name
* we register it in m_UnnamedItems instead of m_Items. */
if (!m_Abstract && dynamic_cast<NameComposer *>(type.get())) {
boost::mutex::scoped_lock lock(m_Mutex);
if (!m_Abstract && dynamic_cast<NameComposer *>(type.get()))
m_UnnamedItems.push_back(this);
} else {
boost::mutex::scoped_lock lock(m_Mutex);
else {
ItemMap::const_iterator it = m_Items[m_Type].find(m_Name);
if (it != m_Items[m_Type].end()) {
@ -324,7 +319,6 @@ void ConfigItem::Unregister(void)
boost::mutex::scoped_lock lock(m_Mutex);
m_UnnamedItems.erase(std::remove(m_UnnamedItems.begin(), m_UnnamedItems.end(), this), m_UnnamedItems.end());
m_Items[m_Type].erase(m_Name);
m_CommittedItems.erase(std::remove(m_CommittedItems.begin(), m_CommittedItems.end(), this), m_CommittedItems.end());
}
/**
@ -351,7 +345,7 @@ ConfigItem::Ptr ConfigItem::GetByTypeAndName(const String& type, const String& n
return it2->second;
}
void ConfigItem::OnAllConfigLoadedWrapper(void)
void ConfigItem::OnAllConfigLoadedHelper(void)
{
try {
m_Object->OnAllConfigLoaded();
@ -369,7 +363,13 @@ void ConfigItem::OnAllConfigLoadedWrapper(void)
}
}
bool ConfigItem::CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& newItems)
void ConfigItem::CreateChildObjectsHelper(const Type::Ptr& type)
{
ActivationScope ascope(m_ActivationContext);
m_Object->CreateChildObjects(type);
}
bool ConfigItem::CommitNewItems(const ActivationContext::Ptr& context, WorkQueue& upq, std::vector<ConfigItem::Ptr>& newItems)
{
typedef std::pair<ConfigItem::Ptr, bool> ItemPair;
std::vector<ItemPair> items;
@ -379,17 +379,31 @@ bool ConfigItem::CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& ne
BOOST_FOREACH(const TypeMap::value_type& kv, m_Items) {
BOOST_FOREACH(const ItemMap::value_type& kv2, kv.second) {
if (!kv2.second->m_Abstract && !kv2.second->m_Object)
items.push_back(std::make_pair(kv2.second, false));
if (kv2.second->m_Abstract || kv2.second->m_Object)
continue;
if (kv2.second->m_ActivationContext != context)
continue;
items.push_back(std::make_pair(kv2.second, false));
}
}
ItemList newUnnamedItems;
BOOST_FOREACH(const ConfigItem::Ptr& item, m_UnnamedItems) {
if (!item->m_Abstract && !item->m_Object)
items.push_back(std::make_pair(item, true));
if (item->m_ActivationContext != context) {
newUnnamedItems.push_back(item);
continue;
}
if (item->m_Abstract || item->m_Object)
continue;
items.push_back(std::make_pair(item, true));
}
m_UnnamedItems.clear();
m_UnnamedItems.swap(newUnnamedItems);
}
if (items.empty())
@ -405,13 +419,6 @@ bool ConfigItem::CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& ne
if (upq.HasExceptions())
return false;
std::vector<ConfigItem::Ptr> new_items;
{
boost::mutex::scoped_lock lock(m_Mutex);
new_items.swap(m_CommittedItems);
}
std::set<String> types;
std::vector<Type::Ptr> all_types;
@ -451,12 +458,14 @@ bool ConfigItem::CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& ne
if (unresolved_dep)
continue;
BOOST_FOREACH(const ConfigItem::Ptr& item, new_items) {
BOOST_FOREACH(const ItemPair& ip, items) {
const ConfigItem::Ptr& item = ip.first;
if (!item->m_Object)
continue;
if (item->m_Type == type)
upq.Enqueue(boost::bind(&ConfigItem::OnAllConfigLoadedWrapper, item));
upq.Enqueue(boost::bind(&ConfigItem::OnAllConfigLoadedHelper, item));
}
completed_types.insert(type);
@ -467,12 +476,14 @@ bool ConfigItem::CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& ne
return false;
BOOST_FOREACH(const String& loadDep, ptype->GetLoadDependencies()) {
BOOST_FOREACH(const ConfigItem::Ptr& item, new_items) {
BOOST_FOREACH(const ItemPair& ip, items) {
const ConfigItem::Ptr& item = ip.first;
if (!item->m_Object)
continue;
if (item->m_Type == loadDep)
upq.Enqueue(boost::bind(&ConfigObject::CreateChildObjects, item->m_Object, ptype));
upq.Enqueue(boost::bind(&ConfigItem::CreateChildObjectsHelper, item, ptype));
}
}
@ -481,7 +492,7 @@ bool ConfigItem::CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& ne
if (upq.HasExceptions())
return false;
if (!CommitNewItems(upq, newItems))
if (!CommitNewItems(context, upq, newItems))
return false;
}
}
@ -489,13 +500,11 @@ bool ConfigItem::CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& ne
return true;
}
bool ConfigItem::CommitItems(WorkQueue& upq)
bool ConfigItem::CommitItems(const ActivationContext::Ptr& context, WorkQueue& upq, std::vector<ConfigItem::Ptr>& newItems)
{
Log(LogInformation, "ConfigItem", "Committing config items");
std::vector<ConfigItem::Ptr> newItems;
if (!CommitNewItems(upq, newItems)) {
if (!CommitNewItems(context, upq, newItems)) {
upq.ReportExceptions("config");
BOOST_FOREACH(const ConfigItem::Ptr& item, newItems) {
@ -505,6 +514,8 @@ bool ConfigItem::CommitItems(WorkQueue& upq)
return false;
}
ASSERT(newItems.size() > 0);
ApplyRule::CheckMatches();
/* log stats for external parsers */
@ -525,34 +536,27 @@ bool ConfigItem::CommitItems(WorkQueue& upq)
return true;
}
bool ConfigItem::ActivateItems(WorkQueue& upq, bool restoreState, bool runtimeCreated)
bool ConfigItem::ActivateItems(WorkQueue& upq, const std::vector<ConfigItem::Ptr>& newItems, bool runtimeCreated)
{
static boost::mutex mtx;
boost::mutex::scoped_lock lock(mtx);
if (restoreState) {
/* restore the previous program state */
try {
ConfigObject::RestoreObjects(Application::GetStatePath());
} catch (const std::exception& ex) {
Log(LogCritical, "ConfigItem")
<< "Failed to restore state file: " << DiagnosticInformation(ex);
}
}
Log(LogInformation, "ConfigItem", "Triggering Start signal for config items");
BOOST_FOREACH(const ConfigType::Ptr& type, ConfigType::GetTypes()) {
BOOST_FOREACH(const ConfigObject::Ptr& object, type->GetObjects()) {
if (object->IsActive())
continue;
BOOST_FOREACH(const ConfigItem::Ptr& item, newItems) {
if (!item->m_Object)
continue;
ConfigObject::Ptr object = item->m_Object;
if (object->IsActive())
continue;
#ifdef I2_DEBUG
Log(LogDebug, "ConfigItem")
<< "Activating object '" << object->GetName() << "' of type '" << object->GetType()->GetName() << "'";
Log(LogDebug, "ConfigItem")
<< "Activating object '" << object->GetName() << "' of type '" << object->GetType()->GetName() << "'";
#endif /* I2_DEBUG */
upq.Enqueue(boost::bind(&ConfigObject::Activate, object, runtimeCreated));
}
upq.Enqueue(boost::bind(&ConfigObject::Activate, object, runtimeCreated));
}
upq.Join();
@ -563,10 +567,13 @@ bool ConfigItem::ActivateItems(WorkQueue& upq, bool restoreState, bool runtimeCr
}
#ifdef I2_DEBUG
BOOST_FOREACH(const ConfigType::Ptr& type, ConfigType::GetTypes()) {
BOOST_FOREACH(const ConfigObject::Ptr& object, type->GetObjects()) {
ASSERT(object->IsActive());
}
BOOST_FOREACH(const ConfigItem::Ptr& item, newItems) {
ConfigObject::Ptr object = item->m_Object;
if (item->m_Abstract)
continue;
ASSERT(object && object->IsActive());
}
#endif /* I2_DEBUG */
@ -575,14 +582,22 @@ bool ConfigItem::ActivateItems(WorkQueue& upq, bool restoreState, bool runtimeCr
return true;
}
bool ConfigItem::CommitAndActivate(void)
bool ConfigItem::RunWithActivationContext(const Function::Ptr& function)
{
WorkQueue upq(25000, Application::GetConcurrency());
ActivationScope scope;
if (!CommitItems(upq))
{
ScriptFrame frame;
function->Invoke();
}
WorkQueue upq(25000, Application::GetConcurrency());
std::vector<ConfigItem::Ptr> newItems;
if (!CommitItems(scope.GetContext(), upq, newItems))
return false;
if (!ActivateItems(upq, false))
if (!ActivateItems(upq, newItems))
return false;
return true;

17
lib/config/configitem.hpp
View File

@ -22,12 +22,14 @@
#include "config/i2-config.hpp"
#include "config/expression.hpp"
#include "config/activationcontext.hpp"
#include "base/configobject.hpp"
#include "base/workqueue.hpp"
namespace icinga
{
/**
* A configuration item. Non-abstract configuration items can be used to
* create configuration objects at runtime.
@ -55,7 +57,6 @@ public:
boost::shared_ptr<Expression> GetExpression(void) const;
boost::shared_ptr<Expression> GetFilter(void) const;
ConfigObject::Ptr Commit(bool discard = true);
void Register(void);
void Unregister(void);
@ -67,10 +68,10 @@ public:
static ConfigItem::Ptr GetByTypeAndName(const String& type,
const String& name);
static bool CommitItems(WorkQueue& upq);
static bool ActivateItems(WorkQueue& upq, bool restoreState, bool runtimeCreated = false);
static bool CommitItems(const ActivationContext::Ptr& context, WorkQueue& upq, std::vector<ConfigItem::Ptr>& newItems);
static bool ActivateItems(WorkQueue& upq, const std::vector<ConfigItem::Ptr>& newItems, bool runtimeCreated = false);
static bool CommitAndActivate(void);
static bool RunWithActivationContext(const Function::Ptr& function);
static std::vector<ConfigItem::Ptr> GetItems(const String& type);
@ -86,6 +87,7 @@ private:
Dictionary::Ptr m_Scope; /**< variable scope. */
String m_Zone; /**< The zone. */
String m_Package;
ActivationContext::Ptr m_ActivationContext;
ConfigObject::Ptr m_Object;
@ -102,9 +104,12 @@ private:
static ConfigItem::Ptr GetObjectUnlocked(const String& type,
const String& name);
static bool CommitNewItems(WorkQueue& upq, std::vector<ConfigItem::Ptr>& newItems);
ConfigObject::Ptr Commit(bool discard = true);
void OnAllConfigLoadedWrapper(void);
static bool CommitNewItems(const ActivationContext::Ptr& context, WorkQueue& upq, std::vector<ConfigItem::Ptr>& newItems);
void OnAllConfigLoadedHelper(void);
void CreateChildObjectsHelper(const Type::Ptr& type);
};
}

5
lib/remote/configobjectutility.cpp
View File

@ -121,14 +121,17 @@ bool ConfigObjectUtility::CreateObject(const Type::Ptr& type, const String& full
Expression *expr = ConfigCompiler::CompileFile(path, String(), "_api");
try {
ActivationScope ascope;
ScriptFrame frame;
expr->Evaluate(frame);
delete expr;
expr = NULL;
WorkQueue upq;
std::vector<ConfigItem::Ptr> newItems;
if (!ConfigItem::CommitItems(upq) || !ConfigItem::ActivateItems(upq, false, true)) {
if (!ConfigItem::CommitItems(ascope.GetContext(), upq, newItems) || !ConfigItem::ActivateItems(upq, newItems, true)) {
if (errors) {
if (unlink(path.CStr()) < 0) {
BOOST_THROW_EXCEPTION(posix_error()

7
test/livestatus.cpp
View File

@ -84,11 +84,14 @@ struct GlobalConfigFixture {
std::vector<std::string> configs;
configs.push_back(TestConfig);
DaemonUtility::LoadConfigFiles(configs, "icinga2.debug", "icinga2.vars");
ActivationScope ascope;
std::vector<ConfigItem::Ptr> newItems;
DaemonUtility::LoadConfigFiles(configs, newItems, "icinga2.debug", "icinga2.vars");
/* ignore config errors */
WorkQueue upq;
ConfigItem::ActivateItems(upq, false);
ConfigItem::ActivateItems(upq, newItems);
}
~GlobalConfigFixture()