void JSONTest::testStringElement()
{
std::string json = "[ \"value\" ]";
Parser parser;
Var result;
try
{
DefaultHandler handler;
parser.setHandler(&handler);
parser.parse(json);
result = handler.result();
}
catch(JSONException& jsone)
{
std::cout << jsone.message() << std::endl;
assert(false);
}
assert(result.type() == typeid(Array::Ptr));
Array::Ptr array = result.extract<Array::Ptr>();
Var test = array->get(0);
assert(test.isString());
std::string value = test.convert<std::string>();
assert(value.compare("value") == 0);
}
bool Value::ToBool(void) const
{
switch (GetType()) {
case ValueNumber:
return static_cast<bool>(boost::get<double>(m_Value));
case ValueBoolean:
return boost::get<bool>(m_Value);
case ValueString:
return !boost::get<String>(m_Value).IsEmpty();
case ValueObject:
if (IsObjectType<Dictionary>()) {
Dictionary::Ptr dictionary = *this;
return dictionary->GetLength() > 0;
} else if (IsObjectType<Array>()) {
Array::Ptr array = *this;
return array->GetLength() > 0;
} else {
return true;
}
case ValueEmpty:
return false;
default:
BOOST_THROW_EXCEPTION(std::runtime_error("Invalid variant type."));
}
}
bool HostGroup::ResolveGroupMembership(const Host::Ptr& host, bool add, int rstack) {
if (add && rstack > 20) {
Log(LogWarning, "HostGroup")
<< "Too many nested groups for group '" << GetName() << "': Host '"
<< host->GetName() << "' membership assignment failed.";
return false;
}
Array::Ptr groups = GetGroups();
if (groups && groups->GetLength() > 0) {
ObjectLock olock(groups);
for (const String& name : groups) {
HostGroup::Ptr group = HostGroup::GetByName(name);
if (group && !group->ResolveGroupMembership(host, add, rstack + 1))
return false;
}
}
if (add)
AddMember(host);
else
RemoveMember(host);
return true;
}
void TimePeriod::PurgeSegments(double end)
{
ASSERT(OwnsLock());
Log(LogDebug, "TimePeriod")
<< "Purging segments older than '" << Utility::FormatDateTime("%c", end)
<< "' from TimePeriod '" << GetName() << "'";
if (GetValidBegin().IsEmpty() || end < GetValidBegin())
return;
SetValidBegin(end);
Array::Ptr segments = GetSegments();
if (!segments)
return;
Array::Ptr newSegments = new Array();
/* Remove old segments. */
ObjectLock dlock(segments);
for (const Dictionary::Ptr& segment : segments) {
if (segment->Get("end") >= end)
newSegments->Add(segment);
}
SetSegments(newSegments);
}
void JSONTest::testNullElement()
{
std::string json = "[ null ]";
Parser parser;
Var result;
try
{
DefaultHandler handler;
parser.setHandler(&handler);
parser.parse(json);
result = handler.result();
}
catch(JSONException& jsone)
{
std::cout << jsone.message() << std::endl;
assert(false);
}
assert(result.type() == typeid(Array::Ptr));
Array::Ptr array = result.extract<Array::Ptr>();
assert(array->isNull(0));
Var test = array->get(0);
assert(test.isEmpty());
}
void JSONTest::testEmptyObjectElement()
{
std::string json = "[{}]";
Parser parser;
Var result;
try
{
DefaultHandler handler;
parser.setHandler(&handler);
parser.parse(json);
result = handler.result();
}
catch(JSONException& jsone)
{
std::cout << jsone.message() << std::endl;
assert(false);
}
assert(result.type() == typeid(Array::Ptr));
Array::Ptr array = result.extract<Array::Ptr>();
Object::Ptr object = array->getObject(0);
assert(object->size() == 0);
}
Array::Ptr ScriptUtils::Range(const std::vector<Value>& arguments)
{
double start, end, increment;
switch (arguments.size()) {
case 1:
start = 0;
end = arguments[0];
increment = 1;
break;
case 2:
start = arguments[0];
end = arguments[1];
increment = 1;
break;
case 3:
start = arguments[0];
end = arguments[1];
increment = arguments[2];
break;
default:
BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid number of arguments for range()"));
}
Array::Ptr result = new Array();
if ((start < end && increment <= 0) ||
(start > end && increment >= 0))
return result;
for (double i = start; (increment > 0 ? i < end : i > end); i += increment)
result->Add(i);
return result;
}
/**
* Executes the auto completion script via HTTP and returns HTTP and user errors.
*
* @param session Local session handler.
* @param command The auto completion string.
* @param sandboxed Whether to run this sandboxed.
* @return Result value, also contains user errors.
*/
Array::Ptr ConsoleCommand::AutoCompleteScript(const String& session, const String& command, bool sandboxed)
{
/* Extend the url parameters for the request. */
l_Url->SetPath({ "v1", "console", "auto-complete-script" });
l_Url->SetQuery({
{"session", session},
{"command", command},
{"sandboxed", sandboxed ? "1" : "0"}
});
Dictionary::Ptr jsonResponse = SendRequest();
/* Extract the result, and handle user input errors too. */
Array::Ptr results = jsonResponse->Get("results");
Array::Ptr suggestions;
if (results && results->GetLength() > 0) {
Dictionary::Ptr resultInfo = results->Get(0);
if (resultInfo->Get("code") >= 200 && resultInfo->Get("code") <= 299) {
suggestions = resultInfo->Get("suggestions");
} else {
String errorMessage = resultInfo->Get("status");
BOOST_THROW_EXCEPTION(ScriptError(errorMessage));
}
}
return suggestions;
}
void JSONTest::testDoubleElement()
{
std::string json = "[ 123.45 ]";
Parser parser;
Var result;
try
{
DefaultHandler handler;
parser.setHandler(&handler);
parser.parse(json);
result = handler.result();
}
catch(JSONException& jsone)
{
std::cout << jsone.message() << std::endl;
assert(false);
}
assert(result.type() == typeid(Array::Ptr));
Array::Ptr array = result.extract<Array::Ptr>();
Var test = array->get(0);
assert(test.isNumeric());
double value = test;
assert(value == 123.45);
}
char *ConsoleCommand::ConsoleCompleteHelper(const char *word, int state)
{
static std::vector<String> matches;
if (state == 0) {
if (!l_Url)
matches = ConsoleHandler::GetAutocompletionSuggestions(word, *l_ScriptFrame);
else {
Array::Ptr suggestions;
/* Remote debug console. */
try {
suggestions = AutoCompleteScript(l_Session, word, l_ScriptFrame->Sandboxed);
} catch (...) {
return nullptr; //Errors are just ignored here.
}
matches.clear();
ObjectLock olock(suggestions);
std::copy(suggestions->Begin(), suggestions->End(), std::back_inserter(matches));
}
}
if (state >= static_cast<int>(matches.size()))
return nullptr;
return strdup(matches[state].CStr());
}
void ParseHandler::startArray()
{
Array::Ptr newArr = new Array();
if ( _stack.empty() ) // The first array
{
_result = newArr;
}
else
{
Var parent = _stack.top();
if ( parent.type() == typeid(Array::Ptr) )
{
Array::Ptr arr = parent.extract<Array::Ptr>();
arr->add(newArr);
}
else if ( parent.type() == typeid(Object::Ptr) )
{
poco_assert_dbg(!_key.empty());
Object::Ptr obj = parent.extract<Object::Ptr>();
obj->set(_key, newArr);
_key.clear();
}
}
_stack.push(newArr);
}
Value ApiEvents::CheckResultAPIHandler(const MessageOrigin& origin, const Dictionary::Ptr& params)
{
if (!origin.FromClient->GetEndpoint())
return Empty;
if (!params)
return Empty;
CheckResult::Ptr cr = make_shared<CheckResult>();
Dictionary::Ptr vcr = params->Get("cr");
Array::Ptr vperf = vcr->Get("performance_data");
vcr->Remove("performance_data");
Deserialize(cr, params->Get("cr"), true);
Array::Ptr rperf = make_shared<Array>();
ObjectLock olock(vperf);
BOOST_FOREACH(const Value& vp, vperf) {
Value p;
if (vp.IsObjectType<Dictionary>()) {
PerfdataValue::Ptr val = make_shared<PerfdataValue>();
Deserialize(val, vp, true);
rperf->Add(val);
} else
rperf->Add(vp);
}
bool ConsoleHandler::AutocompleteScriptHelper(HttpRequest& request, HttpResponse& response,
const String& command, const String& session, bool sandboxed)
{
Log(LogInformation, "Console")
<< "Auto-completing expression: " << command;
ApiScriptFrame& lsf = l_ApiScriptFrames[session];
lsf.Seen = Utility::GetTime();
if (!lsf.Locals)
lsf.Locals = new Dictionary();
Array::Ptr results = new Array();
Dictionary::Ptr resultInfo = new Dictionary();
ScriptFrame frame;
frame.Locals = lsf.Locals;
frame.Self = lsf.Locals;
frame.Sandboxed = sandboxed;
resultInfo->Set("code", 200);
resultInfo->Set("status", "Auto-completed successfully.");
resultInfo->Set("suggestions", Array::FromVector(GetAutocompletionSuggestions(command, frame)));
results->Add(resultInfo);
Dictionary::Ptr result = new Dictionary();
result->Set("results", results);
response.SetStatus(200, "OK");
HttpUtility::SendJsonBody(response, result);
return true;
}
ConfigItem::Ptr ConfigItemBuilder::Compile(void)
{
if (m_Type.IsEmpty()) {
std::ostringstream msgbuf;
msgbuf << "The type name of an object may not be empty: " << m_DebugInfo;
BOOST_THROW_EXCEPTION(std::invalid_argument(msgbuf.str()));
}
if (!DynamicType::GetByName(m_Type)) {
std::ostringstream msgbuf;
msgbuf << "The type '" + m_Type + "' is unknown: " << m_DebugInfo;
BOOST_THROW_EXCEPTION(std::invalid_argument(msgbuf.str()));
}
std::vector<Expression *> exprs;
Array::Ptr templateArray = new Array();
templateArray->Add(m_Name);
exprs.push_back(new SetExpression(MakeIndexer(ScopeThis, "templates"), OpSetAdd,
new LiteralExpression(templateArray), m_DebugInfo));
DictExpression *dexpr = new DictExpression(m_Expressions, m_DebugInfo);
dexpr->MakeInline();
exprs.push_back(dexpr);
boost::shared_ptr<DictExpression> exprl = boost::make_shared<DictExpression>(exprs, m_DebugInfo);
exprl->MakeInline();
return new ConfigItem(m_Type, m_Name, m_Abstract, exprl, m_Filter,
m_DebugInfo, m_Scope, m_Zone);
}
bool ServiceGroup::EvaluateObjectRule(const Service::Ptr& service, const ConfigItem::Ptr& group)
{
String group_name = group->GetName();
CONTEXT("Evaluating rule for group '" + group_name + "'");
Host::Ptr host = service->GetHost();
ScriptFrame frame;
if (group->GetScope())
group->GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("host", host);
frame.Locals->Set("service", service);
if (!group->GetFilter()->Evaluate(frame).GetValue().ToBool())
return false;
Log(LogDebug, "ServiceGroup")
<< "Assigning membership for group '" << group_name << "' to service '" << service->GetName() << "'";
Array::Ptr groups = service->GetGroups();
groups->Add(group_name);
return true;
}
Value CommandsTable::CustomVariableNamesAccessor(const Value& row)
{
Command::Ptr command = static_cast<Command::Ptr>(row);
if (!command)
return Empty;
Dictionary::Ptr vars;
{
ObjectLock olock(command);
vars = CompatUtility::GetCustomAttributeConfig(command);
}
if (!vars)
return Empty;
Array::Ptr cv = new Array();
String key;
Value value;
ObjectLock xlock(vars);
BOOST_FOREACH(tie(key, value), vars) {
cv->Add(key);
}
static inline ExpressionResult For(ScriptFrame& frame, const String& fkvar, const String& fvvar, const Value& value, Expression *expression, const DebugInfo& debugInfo = DebugInfo())
{
if (value.IsObjectType<Array>()) {
if (!fvvar.IsEmpty())
BOOST_THROW_EXCEPTION(ScriptError("Cannot use dictionary iterator for array.", debugInfo));
Array::Ptr arr = value;
for (Array::SizeType i = 0; i < arr->GetLength(); i++) {
frame.Locals->Set(fkvar, arr->Get(i));
ExpressionResult res = expression->Evaluate(frame);
CHECK_RESULT_LOOP(res);
}
} else if (value.IsObjectType<Dictionary>()) {
if (fvvar.IsEmpty())
BOOST_THROW_EXCEPTION(ScriptError("Cannot use array iterator for dictionary.", debugInfo));
Dictionary::Ptr dict = value;
std::vector<String> keys;
{
ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
keys.push_back(kv.first);
}
}
BOOST_FOREACH(const String& key, keys) {
frame.Locals->Set(fkvar, key);
frame.Locals->Set(fvvar, dict->Get(key));
ExpressionResult res = expression->Evaluate(frame);
CHECK_RESULT_LOOP(res);
}
void TimePeriod::PurgeSegments(double end)
{
ASSERT(OwnsLock());
Log(LogDebug, "icinga", "Purging segments older than '" + Utility::FormatDateTime("%c", end) + "' from TimePeriod '" + GetName() + "'");
if (GetValidBegin().IsEmpty() || end < GetValidBegin())
return;
SetValidBegin(end);
Array::Ptr segments = GetSegments();
if (!segments)
return;
Array::Ptr newSegments = make_shared<Array>();
/* Remove old segments. */
ObjectLock dlock(segments);
BOOST_FOREACH(const Dictionary::Ptr& segment, segments) {
if (segment->Get("end") >= end)
newSegments->Add(segment);
}
SetSegments(newSegments);
}
Var Query::find(const std::string& path) const
{
Var result = _source;
StringTokenizer tokenizer(path, ".");
for(StringTokenizer::Iterator token = tokenizer.begin(); token != tokenizer.end(); token++)
{
if ( !result.isEmpty() )
{
std::vector<int> indexes;
RegularExpression::MatchVec matches;
int firstOffset = -1;
int offset = 0;
RegularExpression regex("\\[([0-9]+)\\]");
while(regex.match(*token, offset, matches) > 0 )
{
if ( firstOffset == -1 )
{
firstOffset = static_cast<int>(matches[0].offset);
}
std::string num = token->substr(matches[1].offset, matches[1].length);
indexes.push_back(NumberParser::parse(num));
offset = static_cast<int>(matches[0].offset + matches[0].length);
}
std::string name(*token);
if ( firstOffset != -1 )
{
name = name.substr(0, firstOffset);
}
if ( name.length() > 0 )
{
if ( result.type() == typeid(Object::Ptr) )
{
Object::Ptr o = result.extract<Object::Ptr>();
result = o->get(name);
}
}
if ( !result.isEmpty()
&& !indexes.empty() )
{
for(std::vector<int>::iterator it = indexes.begin(); it != indexes.end(); ++it )
{
if ( result.type() == typeid(Array::Ptr) )
{
Array::Ptr array = result.extract<Array::Ptr>();
result = array->get(*it);
if ( result.isEmpty() )
{
break;
}
}
}
}
}
}
return result;
}
/**
* Makes a deep clone of an array
* and its elements.
*
* @returns a copy of the array.
*/
Object::Ptr Array::Clone(void) const
{
Array::Ptr arr = new Array();
ObjectLock olock(this);
BOOST_FOREACH(const Value& val, m_Data) {
arr->Add(val.Clone());
}
static Array::Ptr DictionaryKeys(void)
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
Dictionary::Ptr self = static_cast<Dictionary::Ptr>(vframe->Self);
Array::Ptr keys = new Array();
ObjectLock olock(self);
BOOST_FOREACH(const Dictionary::Pair& kv, self) {
keys->Add(kv.first);
}
bool ConfigObjectUtility::DeleteObjectHelper(const ConfigObject::Ptr& object, bool cascade, const Array::Ptr& errors)
{
std::vector<Object::Ptr> parents = DependencyGraph::GetParents(object);
Type::Ptr type = object->GetReflectionType();
if (!parents.empty() && !cascade) {
if (errors)
errors->Add("Object '" + object->GetName() + "' of type '" + type->GetName() +
"' cannot be deleted because other objects depend on it. "
"Use cascading delete to delete it anyway.");
return false;
}
for (const Object::Ptr& pobj : parents) {
ConfigObject::Ptr parentObj = dynamic_pointer_cast<ConfigObject>(pobj);
if (!parentObj)
continue;
DeleteObjectHelper(parentObj, cascade, errors);
}
ConfigItem::Ptr item = ConfigItem::GetByTypeAndName(type, object->GetName());
try {
/* mark this object for cluster delete event */
object->SetExtension("ConfigObjectDeleted", true);
/* triggers signal for DB IDO and other interfaces */
object->Deactivate(true);
if (item)
item->Unregister();
else
object->Unregister();
} catch (const std::exception& ex) {
if (errors)
errors->Add(DiagnosticInformation(ex));
return false;
}
String path = GetObjectConfigPath(object->GetReflectionType(), object->GetName());
if (Utility::PathExists(path)) {
if (unlink(path.CStr()) < 0 && errno != ENOENT) {
BOOST_THROW_EXCEPTION(posix_error()
<< boost::errinfo_api_function("unlink")
<< boost::errinfo_errno(errno)
<< boost::errinfo_file_name(path));
}
}
return true;
}
static Array::Ptr SerializeArray(const Array::Ptr& input, int attributeTypes)
{
Array::Ptr result = new Array();
ObjectLock olock(input);
BOOST_FOREACH(const Value& value, input) {
result->Add(Serialize(value, attributeTypes));
}
bool Dependency::EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyRule& rule)
{
DebugInfo di = rule.GetDebugInfo();
std::ostringstream msgbuf;
msgbuf << "Evaluating 'apply' rule (" << di << ")";
CONTEXT(msgbuf.str());
Host::Ptr host;
Service::Ptr service;
tie(host, service) = GetHostService(checkable);
ScriptFrame frame;
if (rule.GetScope())
rule.GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("host", host);
if (service)
frame.Locals->Set("service", service);
Value vinstances;
if (rule.GetFTerm()) {
try {
vinstances = rule.GetFTerm()->Evaluate(frame);
} catch (const std::exception&) {
/* Silently ignore errors here and assume there are no instances. */
return false;
}
} else {
Array::Ptr instances = new Array();
instances->Add("");
vinstances = instances;
}
bool match = false;
if (vinstances.IsObjectType<Array>()) {
if (!rule.GetFVVar().IsEmpty())
BOOST_THROW_EXCEPTION(ScriptError("Array iterator requires value to be an array.", di));
Array::Ptr arr = vinstances;
Array::Ptr arrclone = arr->ShallowClone();
ObjectLock olock(arrclone);
BOOST_FOREACH(const Value& instance, arrclone) {
String name = rule.GetName();
if (!rule.GetFKVar().IsEmpty()) {
frame.Locals->Set(rule.GetFKVar(), instance);
name += instance;
}
if (EvaluateApplyRuleInstance(checkable, name, frame, rule))
match = true;
}
} else if (vinstances.IsObjectType<Dictionary>()) {
void TimePeriod::AddSegment(double begin, double end)
{
ASSERT(OwnsLock());
Log(LogDebug, "TimePeriod")
<< "Adding segment '" << Utility::FormatDateTime("%c", begin) << "' <-> '"
<< Utility::FormatDateTime("%c", end) << "' to TimePeriod '" << GetName() << "'";
if (GetValidBegin().IsEmpty() || begin < GetValidBegin())
SetValidBegin(begin);
if (GetValidEnd().IsEmpty() || end > GetValidEnd())
SetValidEnd(end);
Array::Ptr segments = GetSegments();
if (segments) {
/* Try to merge the new segment into an existing segment. */
ObjectLock dlock(segments);
for (const Dictionary::Ptr& segment : segments) {
if (segment->Get("begin") <= begin && segment->Get("end") >= end)
return; /* New segment is fully contained in this segment. */
if (segment->Get("begin") >= begin && segment->Get("end") <= end) {
segment->Set("begin", begin);
segment->Set("end", end); /* Extend an existing segment to both sides */
return;
}
if (segment->Get("end") >= begin && segment->Get("end") <= end) {
segment->Set("end", end); /* Extend an existing segment to right. */
return;
}
if (segment->Get("begin") >= begin && segment->Get("begin") <= end) {
segment->Set("begin", begin); /* Extend an existing segment to left. */
return;
}
}
}
/* Create new segment if we weren't able to merge this into an existing segment. */
Dictionary::Ptr segment = new Dictionary();
segment->Set("begin", begin);
segment->Set("end", end);
if (!segments) {
segments = new Array();
SetSegments(segments);
}
segments->Add(segment);
}
static Array::Ptr StringSplit(const String& delims)
{
ScriptFrame *vframe = ScriptFrame::GetCurrentFrame();
String self = vframe->Self;
std::vector<String> tokens;
boost::algorithm::split(tokens, self, boost::is_any_of(delims));
Array::Ptr result = new Array();
BOOST_FOREACH(const String& token, tokens) {
result->Add(token);
}
/**
* Converts a JSON object to an array.
*
* @param json The JSON object.
* @returns An array that is equivalent to the JSON object.
*/
Array::Ptr Array::FromJson(cJSON *json)
{
Array::Ptr array = make_shared<Array>();
ASSERT(json->type == cJSON_Array);
for (cJSON *i = json->child; i != NULL; i = i->next) {
array->Add(Value::FromJson(i));
}
return array;
}
void Notification::Validate(int types, const ValidationUtils& utils)
{
ObjectImpl<Notification>::Validate(types, utils);
if (!(types & FAConfig))
return;
Array::Ptr users = GetUsersRaw();
Array::Ptr groups = GetUserGroupsRaw();
if ((!users || users->GetLength() == 0) && (!groups || groups->GetLength() == 0))
BOOST_THROW_EXCEPTION(ValidationError(this, std::vector<String>(), "Validation failed: No users/user_groups specified."));
}
void ScriptFrame::AddImport(const Object::Ptr& import)
{
Array::Ptr imports;
if (!m_Imports)
imports = new Array();
else
imports = m_Imports->ShallowClone();
imports->Add(import);
m_Imports = imports;
}
Array::Ptr ScriptUtils::Keys(const Dictionary::Ptr& dict)
{
Array::Ptr result = new Array();
if (dict) {
ObjectLock olock(dict);
for (const Dictionary::Pair& kv : dict) {
result->Add(kv.first);
}
}
return result;
}