tyler.durden/icinga2
1
0
Fork 0
mirror of https://github.com/Icinga/icinga2.git synced 2025-07-27 07:34:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Refactor the stack frame handling for scripts

Browse Source 
fixes #7748
This commit is contained in:
Gunnar Beutner 2014-11-22 12:21:28 +01:00 committed by Gunnar Beutner
parent 307db672c1
commit f5766f9118
26 changed files with 453 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/base/scriptutils.cpp
View File

@ -139,7 +139,7 @@ void ScriptUtils::Log(const std::vector<Value>& arguments)
message = arguments[2]; message = arguments[2];
} }
if (message.IsString()) if (message.IsString() || !message.IsObjectType<Array>() && !message.IsObjectType<Dictionary>())
::Log(severity, facility, message); ::Log(severity, facility, message);
else else
::Log(severity, facility, JsonEncode(message)); ::Log(severity, facility, JsonEncode(message));

5
lib/cli/daemoncommand.cpp
View File

@ -64,10 +64,9 @@ static String LoadAppType(const String& typeSpec)
static void ExecuteExpression(Expression *expression) static void ExecuteExpression(Expression *expression)
{ {
Dictionary::Ptr context = new Dictionary();
try { try {
expression->Evaluate(context); VMFrame frame;
expression->Evaluate(frame);
} catch (const ConfigError& ex) { } catch (const ConfigError& ex) {
const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex); const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex);
ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo()); ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo());

10
lib/config/applyrule.cpp
View File

@ -29,7 +29,7 @@ ApplyRule::TypeMap ApplyRule::m_Types;
ApplyRule::ApplyRule(const String& targetType, const String& name, const boost::shared_ptr<Expression>& expression, ApplyRule::ApplyRule(const String& targetType, const String& name, const boost::shared_ptr<Expression>& expression,
const boost::shared_ptr<Expression>& filter, const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm, const boost::shared_ptr<Expression>& filter, const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm,
const DebugInfo& di, const Object::Ptr& scope) const DebugInfo& di, const Dictionary::Ptr& scope)
: m_TargetType(targetType), m_Name(name), m_Expression(expression), m_Filter(filter), m_FKVar(fkvar), : m_TargetType(targetType), m_Name(name), m_Expression(expression), m_Filter(filter), m_FKVar(fkvar),
m_FVVar(fvvar), m_FTerm(fterm), m_DebugInfo(di), m_Scope(scope), m_HasMatches(false) m_FVVar(fvvar), m_FTerm(fterm), m_DebugInfo(di), m_Scope(scope), m_HasMatches(false)
{ } { }
@ -74,21 +74,21 @@ DebugInfo ApplyRule::GetDebugInfo(void) const
return m_DebugInfo; return m_DebugInfo;
} }
Object::Ptr ApplyRule::GetScope(void) const Dictionary::Ptr ApplyRule::GetScope(void) const
{ {
return m_Scope; return m_Scope;
} }
void ApplyRule::AddRule(const String& sourceType, const String& targetType, const String& name, void ApplyRule::AddRule(const String& sourceType, const String& targetType, const String& name,
const boost::shared_ptr<Expression>& expression, const boost::shared_ptr<Expression>& filter, const String& fkvar, const boost::shared_ptr<Expression>& expression, const boost::shared_ptr<Expression>& filter, const String& fkvar,
const String& fvvar, const boost::shared_ptr<Expression>& fterm, const DebugInfo& di, const Object::Ptr& scope) const String& fvvar, const boost::shared_ptr<Expression>& fterm, const DebugInfo& di, const Dictionary::Ptr& scope)
{ {
m_Rules[sourceType].push_back(ApplyRule(targetType, name, expression, filter, fkvar, fvvar, fterm, di, scope)); m_Rules[sourceType].push_back(ApplyRule(targetType, name, expression, filter, fkvar, fvvar, fterm, di, scope));
} }
bool ApplyRule::EvaluateFilter(const Object::Ptr& scope) const bool ApplyRule::EvaluateFilter(VMFrame& frame) const
{ {
return m_Filter->Evaluate(scope).ToBool(); return m_Filter->Evaluate(frame).ToBool();
} }
void ApplyRule::RegisterType(const String& sourceType, const std::vector<String>& targetTypes) void ApplyRule::RegisterType(const String& sourceType, const std::vector<String>& targetTypes)

10
lib/config/applyrule.hpp
View File

@ -45,14 +45,14 @@ public:
String GetFVVar(void) const; String GetFVVar(void) const;
boost::shared_ptr<Expression> GetFTerm(void) const; boost::shared_ptr<Expression> GetFTerm(void) const;
DebugInfo GetDebugInfo(void) const; DebugInfo GetDebugInfo(void) const;
Object::Ptr GetScope(void) const; Dictionary::Ptr GetScope(void) const;
void AddMatch(void); void AddMatch(void);
bool HasMatches(void) const; bool HasMatches(void) const;
bool EvaluateFilter(const Object::Ptr& scope) const; bool EvaluateFilter(VMFrame& frame) const;
static void AddRule(const String& sourceType, const String& targetType, const String& name, const boost::shared_ptr<Expression>& expression, static void AddRule(const String& sourceType, const String& targetType, const String& name, const boost::shared_ptr<Expression>& expression,
const boost::shared_ptr<Expression>& filter, const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm, const DebugInfo& di, const Object::Ptr& scope); const boost::shared_ptr<Expression>& filter, const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm, const DebugInfo& di, const Dictionary::Ptr& scope);
static std::vector<ApplyRule>& GetRules(const String& type); static std::vector<ApplyRule>& GetRules(const String& type);
static void RegisterType(const String& sourceType, const std::vector<String>& targetTypes); static void RegisterType(const String& sourceType, const std::vector<String>& targetTypes);
@ -72,7 +72,7 @@ private:
String m_FVVar; String m_FVVar;
boost::shared_ptr<Expression> m_FTerm; boost::shared_ptr<Expression> m_FTerm;
DebugInfo m_DebugInfo; DebugInfo m_DebugInfo;
Object::Ptr m_Scope; Dictionary::Ptr m_Scope;
bool m_HasMatches; bool m_HasMatches;
static TypeMap m_Types; static TypeMap m_Types;
@ -80,7 +80,7 @@ private:
ApplyRule(const String& targetType, const String& name, const boost::shared_ptr<Expression>& expression, ApplyRule(const String& targetType, const String& name, const boost::shared_ptr<Expression>& expression,
const boost::shared_ptr<Expression>& filter, const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm, const boost::shared_ptr<Expression>& filter, const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm,
const DebugInfo& di, const Object::Ptr& scope); const DebugInfo& di, const Dictionary::Ptr& scope);
}; };
} }

2
lib/config/config_lexer.ll
View File

@ -238,6 +238,8 @@ null return T_NULL;
true { yylval->num = 1; return T_NUMBER; } true { yylval->num = 1; return T_NUMBER; }
false { yylval->num = 0; return T_NUMBER; } false { yylval->num = 0; return T_NUMBER; }
const return T_CONST; const return T_CONST;
local return T_LOCAL;
use return T_USE;
apply return T_APPLY; apply return T_APPLY;
to return T_TO; to return T_TO;
where return T_WHERE; where return T_WHERE;

105
lib/config/config_parser.yy
View File

@ -98,6 +98,8 @@ static void MakeRBinaryOp(Expression** result, Expression *left, Expression *rig
icinga::TypeSpecifier type; icinga::TypeSpecifier type;
std::vector<String> *slist; std::vector<String> *slist;
std::vector<Expression *> *elist; std::vector<Expression *> *elist;
std::pair<String, Expression *> *cvitem;
std::map<String, Expression *> *cvlist;
} }
%token T_NEWLINE "new-line" %token T_NEWLINE "new-line"
@ -133,6 +135,8 @@ static void MakeRBinaryOp(Expression** result, Expression *left, Expression *rig
%token T_GREATER_THAN "> (T_GREATER_THAN)" %token T_GREATER_THAN "> (T_GREATER_THAN)"
%token T_CONST "const (T_CONST)" %token T_CONST "const (T_CONST)"
%token T_LOCAL "local (T_LOCAL)"
%token T_USE "use (T_USE)"
%token <type> T_TYPE_DICTIONARY "dictionary (T_TYPE_DICTIONARY)" %token <type> T_TYPE_DICTIONARY "dictionary (T_TYPE_DICTIONARY)"
%token <type> T_TYPE_ARRAY "array (T_TYPE_ARRAY)" %token <type> T_TYPE_ARRAY "array (T_TYPE_ARRAY)"
%token <type> T_TYPE_NUMBER "number (T_TYPE_NUMBER)" %token <type> T_TYPE_NUMBER "number (T_TYPE_NUMBER)"
@ -184,6 +188,9 @@ static void MakeRBinaryOp(Expression** result, Expression *left, Expression *rig
%type <expr> apply %type <expr> apply
%type <expr> optional_rterm %type <expr> optional_rterm
%type <text> target_type_specifier %type <text> target_type_specifier
%type <cvlist> use_specifier
%type <cvlist> use_specifier_items
%type <cvitem> use_specifier_item
%left T_LOGICAL_OR %left T_LOGICAL_OR
%left T_LOGICAL_AND %left T_LOGICAL_AND
@ -217,8 +224,6 @@ static std::stack<bool> m_Abstract;
static std::stack<TypeRuleList::Ptr> m_RuleLists; static std::stack<TypeRuleList::Ptr> m_RuleLists;
static ConfigType::Ptr m_Type; static ConfigType::Ptr m_Type;
static Dictionary::Ptr m_ModuleScope;
static std::stack<bool> m_Apply; static std::stack<bool> m_Apply;
static std::stack<bool> m_ObjectAssign; static std::stack<bool> m_ObjectAssign;
static std::stack<bool> m_SeenAssign; static std::stack<bool> m_SeenAssign;
@ -231,8 +236,6 @@ static std::stack<std::vector<Expression *> > m_Expressions;
Expression *ConfigCompiler::Compile(void) Expression *ConfigCompiler::Compile(void)
{ {
m_ModuleScope = new Dictionary();
m_Abstract = std::stack<bool>(); m_Abstract = std::stack<bool>();
m_RuleLists = std::stack<TypeRuleList::Ptr>(); m_RuleLists = std::stack<TypeRuleList::Ptr>();
m_Type.reset(); m_Type.reset();
@ -293,7 +296,8 @@ library: T_LIBRARY T_STRING sep
constant: T_CONST identifier T_SET rterm sep constant: T_CONST identifier T_SET rterm sep
{ {
ScriptVariable::Ptr sv = ScriptVariable::Set($2, $4->Evaluate(m_ModuleScope)); VMFrame frame;
ScriptVariable::Ptr sv = ScriptVariable::Set($2, $4->Evaluate(frame));
free($2); free($2);
delete $4; delete $4;
@ -416,7 +420,7 @@ object:
m_Assign.push(NULL); m_Assign.push(NULL);
m_Ignore.push(NULL); m_Ignore.push(NULL);
} }
object_declaration identifier rterm rterm_scope object_declaration identifier rterm use_specifier rterm_scope
{ {
m_ObjectAssign.pop(); m_ObjectAssign.pop();
@ -426,7 +430,7 @@ object:
String type = $3; String type = $3;
free($3); free($3);
DictExpression *exprl = dynamic_cast<DictExpression *>($5); DictExpression *exprl = dynamic_cast<DictExpression *>($6);
exprl->MakeInline(); exprl->MakeInline();
bool seen_assign = m_SeenAssign.top(); bool seen_assign = m_SeenAssign.top();
@ -452,7 +456,7 @@ object:
filter = assign; filter = assign;
} }
$$ = new ObjectExpression(abstract, type, $4, filter, context->GetZone(), exprl, DebugInfoRange(@2, @5)); $$ = new ObjectExpression(abstract, type, $4, filter, context->GetZone(), $5, exprl, DebugInfoRange(@2, @5));
} }
; ;
@ -570,14 +574,20 @@ lterm_items_inner: lterm
} }
; ;
lterm: indexer combined_set_op rterm lterm: T_LOCAL indexer combined_set_op rterm
{ {
$$ = new SetExpression(*$1, $2, $3, DebugInfoRange(@1, @3)); $$ = new SetExpression(*$2, $3, $4, true, DebugInfoRange(@1, @4));
delete $2;
}
| indexer combined_set_op rterm
{
$$ = new SetExpression(*$1, $2, $3, false, DebugInfoRange(@1, @3));
delete $1; delete $1;
} }
| T_INCLUDE rterm sep | T_INCLUDE rterm sep
{ {
$$ = context->HandleInclude($2->Evaluate(m_ModuleScope), false, DebugInfoRange(@1, @2)); VMFrame frame;
$$ = context->HandleInclude($2->Evaluate(frame), false, DebugInfoRange(@1, @2));
delete $2; delete $2;
} }
| T_INCLUDE T_STRING_ANGLE | T_INCLUDE T_STRING_ANGLE
@ -587,19 +597,20 @@ lterm: indexer combined_set_op rterm
} }
| T_INCLUDE_RECURSIVE rterm | T_INCLUDE_RECURSIVE rterm
{ {
$$ = context->HandleIncludeRecursive($2->Evaluate(m_ModuleScope), "*.conf", DebugInfoRange(@1, @2)); VMFrame frame;
$$ = context->HandleIncludeRecursive($2->Evaluate(frame), "*.conf", DebugInfoRange(@1, @2));
delete $2; delete $2;
} }
| T_INCLUDE_RECURSIVE rterm ',' rterm | T_INCLUDE_RECURSIVE rterm ',' rterm
{ {
$$ = context->HandleIncludeRecursive($2->Evaluate(m_ModuleScope), $4->Evaluate(m_ModuleScope), DebugInfoRange(@1, @4)); VMFrame frame;
$$ = context->HandleIncludeRecursive($2->Evaluate(frame), $4->Evaluate(frame), DebugInfoRange(@1, @4));
delete $2; delete $2;
delete $4; delete $4;
} }
| T_IMPORT rterm | T_IMPORT rterm
{ {
Expression *avar = new VariableExpression("type", DebugInfoRange(@1, @2)); $$ = new ImportExpression($2, DebugInfoRange(@1, @2));
$$ = new ImportExpression(avar, $2, DebugInfoRange(@1, @2));
} }
| T_ASSIGN T_WHERE rterm | T_ASSIGN T_WHERE rterm
{ {
@ -631,7 +642,7 @@ lterm: indexer combined_set_op rterm
{ {
std::vector<Expression *> vname; std::vector<Expression *> vname;
vname.push_back(MakeLiteral("__result")); vname.push_back(MakeLiteral("__result"));
$$ = new SetExpression(vname, OpSetLiteral, $2, DebugInfoRange(@1, @2)); $$ = new SetExpression(vname, OpSetLiteral, $2, false, DebugInfoRange(@1, @2));
} }
| apply | apply
{ {
@ -792,21 +803,21 @@ rterm: T_STRING
| rterm T_MINUS rterm { MakeRBinaryOp<SubtractExpression>(&$$, $1, $3, @1, @3); } | rterm T_MINUS rterm { MakeRBinaryOp<SubtractExpression>(&$$, $1, $3, @1, @3); }
| rterm T_MULTIPLY rterm { MakeRBinaryOp<MultiplyExpression>(&$$, $1, $3, @1, @3); } | rterm T_MULTIPLY rterm { MakeRBinaryOp<MultiplyExpression>(&$$, $1, $3, @1, @3); }
| rterm T_DIVIDE_OP rterm { MakeRBinaryOp<DivideExpression>(&$$, $1, $3, @1, @3); } | rterm T_DIVIDE_OP rterm { MakeRBinaryOp<DivideExpression>(&$$, $1, $3, @1, @3); }
| T_FUNCTION identifier '(' identifier_items ')' rterm_scope | T_FUNCTION identifier '(' identifier_items ')' use_specifier rterm_scope
{
DictExpression *aexpr = dynamic_cast<DictExpression *>($7);
aexpr->MakeInline();
$$ = new FunctionExpression($2, *$4, $6, aexpr, DebugInfoRange(@1, @6));
free($2);
delete $4;
}
| T_FUNCTION '(' identifier_items ')' use_specifier rterm_scope
{ {
DictExpression *aexpr = dynamic_cast<DictExpression *>($6); DictExpression *aexpr = dynamic_cast<DictExpression *>($6);
aexpr->MakeInline(); aexpr->MakeInline();
$$ = new FunctionExpression($2, *$4, aexpr, DebugInfoRange(@1, @6)); $$ = new FunctionExpression("", *$3, $5, aexpr, DebugInfoRange(@1, @5));
free($2);
delete $4;
}
| T_FUNCTION '(' identifier_items ')' rterm_scope
{
DictExpression *aexpr = dynamic_cast<DictExpression *>($5);
aexpr->MakeInline();
$$ = new FunctionExpression("", *$3, aexpr, DebugInfoRange(@1, @5));
delete $3; delete $3;
} }
| T_SIGNAL identifier T_SET_ADD rterm | T_SIGNAL identifier T_SET_ADD rterm
@ -837,6 +848,40 @@ target_type_specifier: /* empty */
} }
; ;
use_specifier: /* empty */
{
$$ = NULL;
}
| T_USE '(' use_specifier_items ')'
{
$$ = $3;
}
;
use_specifier_items: use_specifier_item
{
$$ = new std::map<String, Expression *>();
$$->insert(*$1);
delete $1;
}
| use_specifier_items ',' use_specifier_item
{
$$ = $1;
$$->insert(*$3);
delete $3;
}
;
use_specifier_item: identifier
{
$$ = new std::pair<String, Expression *>($1, new VariableExpression($1, @1));
}
| identifier T_SET rterm
{
$$ = new std::pair<String, Expression *>($1, $3);
}
;
apply_for_specifier: /* empty */ apply_for_specifier: /* empty */
| T_APPLY_FOR '(' identifier T_FOLLOWS identifier T_IN rterm ')' | T_APPLY_FOR '(' identifier T_FOLLOWS identifier T_IN rterm ')'
{ {
@ -879,7 +924,7 @@ apply:
m_FVVar.push(""); m_FVVar.push("");
m_FTerm.push(NULL); m_FTerm.push(NULL);
} }
T_APPLY identifier optional_rterm apply_for_specifier target_type_specifier rterm T_APPLY identifier optional_rterm apply_for_specifier target_type_specifier use_specifier rterm
{ {
m_Apply.pop(); m_Apply.pop();
@ -912,7 +957,7 @@ apply:
BOOST_THROW_EXCEPTION(ConfigError("'apply' target type '" + target + "' is invalid") << errinfo_debuginfo(DebugInfoRange(@2, @5))); BOOST_THROW_EXCEPTION(ConfigError("'apply' target type '" + target + "' is invalid") << errinfo_debuginfo(DebugInfoRange(@2, @5)));
} }
DictExpression *exprl = dynamic_cast<DictExpression *>($7); DictExpression *exprl = dynamic_cast<DictExpression *>($8);
exprl->MakeInline(); exprl->MakeInline();
// assign && !ignore // assign && !ignore
@ -945,7 +990,7 @@ apply:
Expression *fterm = m_FTerm.top(); Expression *fterm = m_FTerm.top();
m_FTerm.pop(); m_FTerm.pop();
$$ = new ApplyExpression(type, target, $4, filter, fkvar, fvvar, fterm, exprl, DebugInfoRange(@2, @5)); $$ = new ApplyExpression(type, target, $4, filter, fkvar, fvvar, fterm, $7, exprl, DebugInfoRange(@2, @7));
} }
; ;

15
lib/config/configitem.cpp
View File

@ -59,7 +59,7 @@ ConfigItem::ItemList ConfigItem::m_CommittedItems;
ConfigItem::ConfigItem(const String& type, const String& name, ConfigItem::ConfigItem(const String& type, const String& name,
bool abstract, const boost::shared_ptr<Expression>& exprl, bool abstract, const boost::shared_ptr<Expression>& exprl,
const boost::shared_ptr<Expression>& filter, const boost::shared_ptr<Expression>& filter,
const DebugInfo& debuginfo, const Object::Ptr& scope, const DebugInfo& debuginfo, const Dictionary::Ptr& scope,
const String& zone) const String& zone)
: m_Type(type), m_Name(name), m_Abstract(abstract), : m_Type(type), m_Name(name), m_Abstract(abstract),
m_Expression(exprl), m_Filter(filter), m_Expression(exprl), m_Filter(filter),
@ -107,7 +107,7 @@ DebugInfo ConfigItem::GetDebugInfo(void) const
return m_DebugInfo; return m_DebugInfo;
} }
Object::Ptr ConfigItem::GetScope(void) const Dictionary::Ptr ConfigItem::GetScope(void) const
{ {
return m_Scope; return m_Scope;
} }
@ -159,19 +159,14 @@ DynamicObject::Ptr ConfigItem::Commit(bool discard)
dobj->SetDebugInfo(m_DebugInfo); dobj->SetDebugInfo(m_DebugInfo);
dobj->SetTypeName(m_Type); dobj->SetTypeName(m_Type);
dobj->SetZone(m_Zone); dobj->SetZone(m_Zone);
Dictionary::Ptr locals = new Dictionary();
locals->Set("__parent", m_Scope);
dobj->SetParentScope(locals);
locals.reset();
dobj->SetName(m_Name); dobj->SetName(m_Name);
DebugHint debugHints; DebugHint debugHints;
try { try {
m_Expression->Evaluate(dobj, &debugHints); VMFrame frame(dobj);
frame.Locals = m_Scope;
m_Expression->Evaluate(frame, &debugHints);
} catch (const ConfigError& ex) { } catch (const ConfigError& ex) {
const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex); const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex);
ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo()); ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo());

6
lib/config/configitem.hpp
View File

@ -42,7 +42,7 @@ public:
const boost::shared_ptr<Expression>& exprl, const boost::shared_ptr<Expression>& exprl,
const boost::shared_ptr<Expression>& filter, const boost::shared_ptr<Expression>& filter,
const DebugInfo& debuginfo, const DebugInfo& debuginfo,
const Object::Ptr& scope, const String& zone); const Dictionary::Ptr& scope, const String& zone);
String GetType(void) const; String GetType(void) const;
String GetName(void) const; String GetName(void) const;
@ -57,7 +57,7 @@ public:
void Register(void); void Register(void);
DebugInfo GetDebugInfo(void) const; DebugInfo GetDebugInfo(void) const;
Object::Ptr GetScope(void) const; Dictionary::Ptr GetScope(void) const;
String GetZone(void) const; String GetZone(void) const;
@ -78,7 +78,7 @@ private:
boost::shared_ptr<Expression> m_Expression; boost::shared_ptr<Expression> m_Expression;
boost::shared_ptr<Expression> m_Filter; boost::shared_ptr<Expression> m_Filter;
DebugInfo m_DebugInfo; /**< Debug information. */ DebugInfo m_DebugInfo; /**< Debug information. */
Object::Ptr m_Scope; /**< variable scope. */ Dictionary::Ptr m_Scope; /**< variable scope. */
String m_Zone; /**< The zone. */ String m_Zone; /**< The zone. */
DynamicObject::Ptr m_Object; DynamicObject::Ptr m_Object;

4
lib/config/configitembuilder.cpp
View File

@ -55,7 +55,7 @@ void ConfigItemBuilder::SetAbstract(bool abstract)
m_Abstract = abstract; m_Abstract = abstract;
} }
void ConfigItemBuilder::SetScope(const Object::Ptr& scope) void ConfigItemBuilder::SetScope(const Dictionary::Ptr& scope)
{ {
m_Scope = scope; m_Scope = scope;
} }
@ -104,7 +104,7 @@ ConfigItem::Ptr ConfigItemBuilder::Compile(void)
indexer.push_back(new LiteralExpression("templates")); indexer.push_back(new LiteralExpression("templates"));
exprs.push_back(new SetExpression(indexer, OpSetAdd, exprs.push_back(new SetExpression(indexer, OpSetAdd,
new LiteralExpression(templateArray), m_DebugInfo)); new LiteralExpression(templateArray), false, m_DebugInfo));
DictExpression *dexpr = new DictExpression(m_Expressions, m_DebugInfo); DictExpression *dexpr = new DictExpression(m_Expressions, m_DebugInfo);
dexpr->MakeInline(); dexpr->MakeInline();

4
lib/config/configitembuilder.hpp
View File

@ -45,7 +45,7 @@ public:
void SetType(const String& type); void SetType(const String& type);
void SetName(const String& name); void SetName(const String& name);
void SetAbstract(bool abstract); void SetAbstract(bool abstract);
void SetScope(const Object::Ptr& scope); void SetScope(const Dictionary::Ptr& scope);
void SetZone(const String& zone); void SetZone(const String& zone);
void AddExpression(Expression *expr); void AddExpression(Expression *expr);
@ -60,7 +60,7 @@ private:
std::vector<Expression *> m_Expressions; /**< Expressions for this item. */ std::vector<Expression *> m_Expressions; /**< Expressions for this item. */
boost::shared_ptr<Expression> m_Filter; /**< Filter expression. */ boost::shared_ptr<Expression> m_Filter; /**< Filter expression. */
DebugInfo m_DebugInfo; /**< Debug information. */ DebugInfo m_DebugInfo; /**< Debug information. */
Object::Ptr m_Scope; /**< variable scope. */ Dictionary::Ptr m_Scope; /**< variable scope. */
String m_Zone; /**< The zone. */ String m_Zone; /**< The zone. */
}; };

4
lib/config/expression-codegen.cpp
View File

@ -418,9 +418,7 @@ void ImportExpression::GenerateCode(DefinitionMap& definitions, std::ostream& fp
<< " String name = ("; << " String name = (";
m_Name->GenerateCode(definitions, df); m_Name->GenerateCode(definitions, df);
df << ");" << "\n" df << ");" << "\n"
<< " String type = ("; << " String type = VMOps::GetField(context, \"type\");" << "\n"
m_Type->GenerateCode(definitions, df);
df << ");" << "\n"
<< "\n" << "\n"
<< " ConfigItem::Ptr item = ConfigItem::GetObject(type, name);" << "\n" << " ConfigItem::Ptr item = ConfigItem::GetObject(type, name);" << "\n"
<< "\n" << "\n"

190
lib/config/expression.cpp
View File

@ -34,7 +34,7 @@ using namespace icinga;
Expression::~Expression(void) Expression::~Expression(void)
{ } { }
Value Expression::Evaluate(const Object::Ptr& context, DebugHint *dhint) const Value Expression::Evaluate(VMFrame& frame, DebugHint *dhint) const
{ {
try { try {
#ifdef _DEBUG #ifdef _DEBUG
@ -44,7 +44,7 @@ Value Expression::Evaluate(const Object::Ptr& context, DebugHint *dhint) const
<< "Executing:\n" << msgbuf.str();*/ << "Executing:\n" << msgbuf.str();*/
#endif /* _DEBUG */ #endif /* _DEBUG */
return DoEvaluate(context, dhint); return DoEvaluate(frame, dhint);
} catch (const std::exception& ex) { } catch (const std::exception& ex) {
if (boost::get_error_info<boost::errinfo_nested_exception>(ex)) if (boost::get_error_info<boost::errinfo_nested_exception>(ex))
throw; throw;
@ -77,7 +77,7 @@ LiteralExpression::LiteralExpression(const Value& value)
: m_Value(value) : m_Value(value)
{ } { }
Value LiteralExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value LiteralExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Value; return m_Value;
} }
@ -87,174 +87,175 @@ const DebugInfo& DebuggableExpression::GetDebugInfo(void) const
return m_DebugInfo; return m_DebugInfo;
} }
Value VariableExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value VariableExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return VMOps::Variable(context, m_Variable); return VMOps::Variable(frame, m_Variable);
} }
Value NegateExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value NegateExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return ~(long)m_Operand->Evaluate(context); return ~(long)m_Operand->Evaluate(frame);
} }
Value LogicalNegateExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value LogicalNegateExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return !m_Operand->Evaluate(context).ToBool(); return !m_Operand->Evaluate(frame).ToBool();
} }
Value AddExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value AddExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) + m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) + m_Operand2->Evaluate(frame);
} }
Value SubtractExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value SubtractExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) - m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) - m_Operand2->Evaluate(frame);
} }
Value MultiplyExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value MultiplyExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) * m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) * m_Operand2->Evaluate(frame);
} }
Value DivideExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value DivideExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) / m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) / m_Operand2->Evaluate(frame);
} }
Value BinaryAndExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value BinaryAndExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) & m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) & m_Operand2->Evaluate(frame);
} }
Value BinaryOrExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value BinaryOrExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) | m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) | m_Operand2->Evaluate(frame);
} }
Value ShiftLeftExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value ShiftLeftExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) << m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) << m_Operand2->Evaluate(frame);
} }
Value ShiftRightExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value ShiftRightExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) >> m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) >> m_Operand2->Evaluate(frame);
} }
Value EqualExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value EqualExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) == m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) == m_Operand2->Evaluate(frame);
} }
Value NotEqualExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value NotEqualExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) != m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) != m_Operand2->Evaluate(frame);
} }
Value LessThanExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value LessThanExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) < m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) < m_Operand2->Evaluate(frame);
} }
Value GreaterThanExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value GreaterThanExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) > m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) > m_Operand2->Evaluate(frame);
} }
Value LessThanOrEqualExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value LessThanOrEqualExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) <= m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) <= m_Operand2->Evaluate(frame);
} }
Value GreaterThanOrEqualExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value GreaterThanOrEqualExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context) >= m_Operand2->Evaluate(context); return m_Operand1->Evaluate(frame) >= m_Operand2->Evaluate(frame);
} }
Value InExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value InExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
Value right = m_Operand2->Evaluate(context); Value right = m_Operand2->Evaluate(frame);
if (right.IsEmpty()) if (right.IsEmpty())
return false; return false;
else if (!right.IsObjectType<Array>()) else if (!right.IsObjectType<Array>())
BOOST_THROW_EXCEPTION(ConfigError("Invalid right side argument for 'in' operator: " + JsonEncode(right))); BOOST_THROW_EXCEPTION(ConfigError("Invalid right side argument for 'in' operator: " + JsonEncode(right)));
Value left = m_Operand1->Evaluate(context); Value left = m_Operand1->Evaluate(frame);
Array::Ptr arr = right; Array::Ptr arr = right;
return arr->Contains(left); return arr->Contains(left);
} }
Value NotInExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value NotInExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
Value right = m_Operand2->Evaluate(context); Value right = m_Operand2->Evaluate(frame);
if (right.IsEmpty()) if (right.IsEmpty())
return false; return false;
else if (!right.IsObjectType<Array>()) else if (!right.IsObjectType<Array>())
BOOST_THROW_EXCEPTION(ConfigError("Invalid right side argument for 'in' operator: " + JsonEncode(right))); BOOST_THROW_EXCEPTION(ConfigError("Invalid right side argument for 'in' operator: " + JsonEncode(right)));
Value left = m_Operand1->Evaluate(context); Value left = m_Operand1->Evaluate(frame);
Array::Ptr arr = right; Array::Ptr arr = right;
return !arr->Contains(left); return !arr->Contains(left);
} }
Value LogicalAndExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value LogicalAndExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context).ToBool() && m_Operand2->Evaluate(context).ToBool(); return m_Operand1->Evaluate(frame).ToBool() && m_Operand2->Evaluate(frame).ToBool();
} }
Value LogicalOrExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value LogicalOrExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Operand1->Evaluate(context).ToBool() || m_Operand2->Evaluate(context).ToBool(); return m_Operand1->Evaluate(frame).ToBool() || m_Operand2->Evaluate(frame).ToBool();
} }
Value FunctionCallExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value FunctionCallExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
Value funcName = m_FName->Evaluate(context); Value funcName = m_FName->Evaluate(frame);
std::vector<Value> arguments; std::vector<Value> arguments;
BOOST_FOREACH(Expression *arg, m_Args) { BOOST_FOREACH(Expression *arg, m_Args) {
arguments.push_back(arg->Evaluate(context)); arguments.push_back(arg->Evaluate(frame));
} }
return VMOps::FunctionCall(context, funcName, arguments); return VMOps::FunctionCall(frame, funcName, arguments);
} }
Value ArrayExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value ArrayExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
Array::Ptr result = new Array(); Array::Ptr result = new Array();
BOOST_FOREACH(Expression *aexpr, m_Expressions) { BOOST_FOREACH(Expression *aexpr, m_Expressions) {
result->Add(aexpr->Evaluate(context)); result->Add(aexpr->Evaluate(frame));
} }
return result; return result;
} }
Value DictExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value DictExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
Dictionary::Ptr result = new Dictionary(); VMFrame *dframe;
VMFrame rframe;
result->Set("__parent", context); if (!m_Inline) {
dframe = &rframe;
BOOST_FOREACH(Expression *aexpr, m_Expressions) { rframe.Locals = frame.Locals;
Object::Ptr acontext = m_Inline ? context : result; rframe.Self = new Dictionary();
aexpr->Evaluate(acontext, dhint); } else {
dframe = &frame;
if (VMOps::HasField(acontext, "__result"))
break;
} }
Dictionary::Ptr xresult = result->ShallowClone(); BOOST_FOREACH(Expression *aexpr, m_Expressions) {
xresult->Remove("__parent"); aexpr->Evaluate(*dframe, dhint);
return xresult; }
return dframe->Self;
} }
Value SetExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value SetExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
DebugHint *psdhint = dhint; DebugHint *psdhint = dhint;
DebugHint sdhint; DebugHint sdhint;
@ -264,7 +265,7 @@ Value SetExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) co
for (Array::SizeType i = 0; i < m_Indexer.size(); i++) { for (Array::SizeType i = 0; i < m_Indexer.size(); i++) {
Expression *indexExpr = m_Indexer[i]; Expression *indexExpr = m_Indexer[i];
String tempindex = indexExpr->Evaluate(context, dhint); String tempindex = indexExpr->Evaluate(frame, dhint);
if (psdhint) { if (psdhint) {
sdhint = psdhint->GetChild(tempindex); sdhint = psdhint->GetChild(tempindex);
@ -272,7 +273,7 @@ Value SetExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) co
} }
if (i == 0) if (i == 0)
parent = context; parent = m_Local ? frame.Locals : frame.Self;
else else
parent = object; parent = object;
@ -284,7 +285,7 @@ Value SetExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) co
break; break;
} }
object = VMOps::Indexer(context, parent, tempindex); object = VMOps::Indexer(frame, parent, tempindex);
if (i != m_Indexer.size() - 1 && object.IsEmpty()) { if (i != m_Indexer.size() - 1 && object.IsEmpty()) {
object = new Dictionary(); object = new Dictionary();
@ -293,7 +294,7 @@ Value SetExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) co
} }
} }
Value right = m_Operand2->Evaluate(context, dhint); Value right = m_Operand2->Evaluate(frame, dhint);
if (m_Op != OpSetLiteral) { if (m_Op != OpSetLiteral) {
Expression *lhs = MakeLiteral(object); Expression *lhs = MakeLiteral(object);
@ -301,16 +302,16 @@ Value SetExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) co
switch (m_Op) { switch (m_Op) {
case OpSetAdd: case OpSetAdd:
right = AddExpression(lhs, rhs, m_DebugInfo).Evaluate(context, dhint); right = AddExpression(lhs, rhs, m_DebugInfo).Evaluate(frame, dhint);
break; break;
case OpSetSubtract: case OpSetSubtract:
right = SubtractExpression(lhs, rhs, m_DebugInfo).Evaluate(context, dhint); right = SubtractExpression(lhs, rhs, m_DebugInfo).Evaluate(frame, dhint);
break; break;
case OpSetMultiply: case OpSetMultiply:
right = MultiplyExpression(lhs, rhs, m_DebugInfo).Evaluate(context, dhint); right = MultiplyExpression(lhs, rhs, m_DebugInfo).Evaluate(frame, dhint);
break; break;
case OpSetDivide: case OpSetDivide:
right = DivideExpression(lhs, rhs, m_DebugInfo).Evaluate(context, dhint); right = DivideExpression(lhs, rhs, m_DebugInfo).Evaluate(frame, dhint);
break; break;
default: default:
VERIFY(!"Invalid opcode."); VERIFY(!"Invalid opcode.");
@ -325,56 +326,57 @@ Value SetExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) co
return right; return right;
} }
Value IndexerExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value IndexerExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return VMOps::Indexer(context, m_Operand1->Evaluate(context), m_Operand2->Evaluate(context)); return VMOps::Indexer(frame, m_Operand1->Evaluate(frame), m_Operand2->Evaluate(frame));
} }
Value ImportExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value ImportExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
Value type = m_Type->Evaluate(context); String type = VMOps::GetField(frame.Self, "type");
Value name = m_Name->Evaluate(context); Value name = m_Name->Evaluate(frame);
ConfigItem::Ptr item = ConfigItem::GetObject(type, name); ConfigItem::Ptr item = ConfigItem::GetObject(type, name);
if (!item) if (!item)
BOOST_THROW_EXCEPTION(ConfigError("Import references unknown template: '" + name + "'")); BOOST_THROW_EXCEPTION(ConfigError("Import references unknown template: '" + name + "'"));
item->GetExpression()->Evaluate(context, dhint); item->GetExpression()->Evaluate(frame, dhint);
return Empty; return Empty;
} }
Value FunctionExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value FunctionExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return VMOps::NewFunction(context, m_Name, m_Args, m_Expression); return VMOps::NewFunction(frame, m_Name, m_Args, m_ClosedVars, m_Expression);
} }
Value SlotExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value SlotExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return VMOps::NewSlot(context, m_Signal, m_Slot->Evaluate(context)); return VMOps::NewSlot(frame, m_Signal, m_Slot->Evaluate(frame));
} }
Value ApplyExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value ApplyExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return VMOps::NewApply(context, m_Type, m_Target, m_Name->Evaluate(context), m_Filter, m_FKVar, m_FVVar, m_FTerm, m_Expression, m_DebugInfo); return VMOps::NewApply(frame, m_Type, m_Target, m_Name->Evaluate(frame), m_Filter,
m_FKVar, m_FVVar, m_FTerm, m_ClosedVars, m_Expression, m_DebugInfo);
} }
Value ObjectExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value ObjectExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
String name; String name;
if (m_Name) if (m_Name)
name = m_Name->Evaluate(context, dhint); name = m_Name->Evaluate(frame, dhint);
return VMOps::NewObject(context, m_Abstract, m_Type, name, m_Filter, m_Zone, return VMOps::NewObject(frame, m_Abstract, m_Type, name, m_Filter, m_Zone,
m_Expression, m_DebugInfo); m_ClosedVars, m_Expression, m_DebugInfo);
} }
Value ForExpression::DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const Value ForExpression::DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
Value value = m_Value->Evaluate(context, dhint); Value value = m_Value->Evaluate(frame, dhint);
return VMOps::For(context, m_FKVar, m_FVVar, m_Value->Evaluate(context), m_Expression, m_DebugInfo); return VMOps::For(frame, m_FKVar, m_FVVar, m_Value->Evaluate(frame), m_Expression, m_DebugInfo);
} }

112
lib/config/expression.hpp
View File

@ -21,6 +21,7 @@
#define EXPRESSION_H #define EXPRESSION_H
#include "config/i2-config.hpp" #include "config/i2-config.hpp"
#include "config/vmframe.hpp"
#include "base/debuginfo.hpp" #include "base/debuginfo.hpp"
#include "base/array.hpp" #include "base/array.hpp"
#include "base/dictionary.hpp" #include "base/dictionary.hpp"
@ -110,9 +111,9 @@ class I2_CONFIG_API Expression
public: public:
virtual ~Expression(void); virtual ~Expression(void);
Value Evaluate(const Object::Ptr& context, DebugHint *dhint = NULL) const; Value Evaluate(VMFrame& frame, DebugHint *dhint = NULL) const;
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const = 0; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const = 0;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const = 0; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const = 0;
virtual const DebugInfo& GetDebugInfo(void) const; virtual const DebugInfo& GetDebugInfo(void) const;
}; };
@ -127,9 +128,9 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Expression->DoEvaluate(context, dhint); return m_Expression->DoEvaluate(frame, dhint);
} }
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const
@ -149,16 +150,16 @@ private:
class I2_CONFIG_API NativeExpression : public Expression class I2_CONFIG_API NativeExpression : public Expression
{ {
public: public:
typedef Value (*Callback)(const Object::Ptr& context); typedef Value (*Callback)(VMFrame& frame);
NativeExpression(Callback callback) NativeExpression(Callback callback)
: m_Callback(callback) : m_Callback(callback)
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const
{ {
return m_Callback(context); return m_Callback(frame);
} }
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const
@ -176,7 +177,7 @@ public:
LiteralExpression(const Value& value = Value()); LiteralExpression(const Value& value = Value());
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fp) const;
private: private:
@ -244,7 +245,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
@ -259,7 +260,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -271,7 +272,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -283,7 +284,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -295,7 +296,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -307,7 +308,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -319,7 +320,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -331,7 +332,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -343,7 +344,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -355,7 +356,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -367,7 +368,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -379,7 +380,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -391,7 +392,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -403,7 +404,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -415,7 +416,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -427,7 +428,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -439,7 +440,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -451,7 +452,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -463,7 +464,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -475,7 +476,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -487,7 +488,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
@ -507,7 +508,7 @@ public:
} }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
public: public:
@ -529,7 +530,7 @@ public:
} }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
@ -552,7 +553,7 @@ public:
void MakeInline(void); void MakeInline(void);
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
@ -563,8 +564,8 @@ private:
class I2_CONFIG_API SetExpression : public DebuggableExpression class I2_CONFIG_API SetExpression : public DebuggableExpression
{ {
public: public:
SetExpression(const std::vector<Expression *>& indexer, CombinedSetOp op, Expression *operand2, const DebugInfo& debugInfo = DebugInfo()) SetExpression(const std::vector<Expression *>& indexer, CombinedSetOp op, Expression *operand2, bool local, const DebugInfo& debugInfo = DebugInfo())
: DebuggableExpression(debugInfo), m_Op(op), m_Indexer(indexer), m_Operand2(operand2) : DebuggableExpression(debugInfo), m_Op(op), m_Indexer(indexer), m_Operand2(operand2), m_Local(local)
{ } { }
~SetExpression(void) ~SetExpression(void)
@ -576,13 +577,14 @@ public:
} }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
CombinedSetOp m_Op; CombinedSetOp m_Op;
std::vector<Expression *> m_Indexer; std::vector<Expression *> m_Indexer;
Expression *m_Operand2; Expression *m_Operand2;
bool m_Local;
}; };
@ -594,29 +596,27 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
}; };
class I2_CONFIG_API ImportExpression : public DebuggableExpression class I2_CONFIG_API ImportExpression : public DebuggableExpression
{ {
public: public:
ImportExpression(Expression *type, Expression *name, const DebugInfo& debugInfo = DebugInfo()) ImportExpression(Expression *name, const DebugInfo& debugInfo = DebugInfo())
: DebuggableExpression(debugInfo), m_Type(type), m_Name(name) : DebuggableExpression(debugInfo), m_Name(name)
{ } { }
~ImportExpression(void) ~ImportExpression(void)
{ {
delete m_Type;
delete m_Name; delete m_Name;
} }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
Expression *m_Type;
Expression *m_Name; Expression *m_Name;
}; };
@ -625,17 +625,19 @@ I2_CONFIG_API String CodeGenExpression(DefinitionMap& definitions, Expression *e
class I2_CONFIG_API FunctionExpression : public DebuggableExpression class I2_CONFIG_API FunctionExpression : public DebuggableExpression
{ {
public: public:
FunctionExpression(const String& name, const std::vector<String>& args, Expression *expression, const DebugInfo& debugInfo = DebugInfo()) FunctionExpression(const String& name, const std::vector<String>& args,
: DebuggableExpression(debugInfo), m_Name(name), m_Args(args), m_Expression(expression) std::map<String, Expression *> *closedVars, Expression *expression, const DebugInfo& debugInfo = DebugInfo())
: DebuggableExpression(debugInfo), m_Name(name), m_Args(args), m_ClosedVars(closedVars), m_Expression(expression)
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
String m_Name; String m_Name;
std::vector<String> m_Args; std::vector<String> m_Args;
std::map<String, Expression *> *m_ClosedVars;
boost::shared_ptr<Expression> m_Expression; boost::shared_ptr<Expression> m_Expression;
}; };
@ -647,7 +649,7 @@ public:
{ } { }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
@ -660,10 +662,11 @@ class I2_CONFIG_API ApplyExpression : public DebuggableExpression
public: public:
ApplyExpression(const String& type, const String& target, Expression *name, ApplyExpression(const String& type, const String& target, Expression *name,
Expression *filter, const String& fkvar, const String& fvvar, Expression *filter, const String& fkvar, const String& fvvar,
Expression *fterm, Expression *expression, const DebugInfo& debugInfo = DebugInfo()) Expression *fterm, std::map<String, Expression *> *closedVars,
Expression *expression, const DebugInfo& debugInfo = DebugInfo())
: DebuggableExpression(debugInfo), m_Type(type), m_Target(target), : DebuggableExpression(debugInfo), m_Type(type), m_Target(target),
m_Name(name), m_Filter(filter), m_FKVar(fkvar), m_FVVar(fvvar), m_Name(name), m_Filter(filter), m_FKVar(fkvar), m_FVVar(fvvar),
m_FTerm(fterm), m_Expression(expression) m_FTerm(fterm), m_ClosedVars(closedVars), m_Expression(expression)
{ } { }
~ApplyExpression(void) ~ApplyExpression(void)
@ -672,7 +675,7 @@ public:
} }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
@ -683,14 +686,18 @@ private:
String m_FKVar; String m_FKVar;
String m_FVVar; String m_FVVar;
boost::shared_ptr<Expression> m_FTerm; boost::shared_ptr<Expression> m_FTerm;
std::map<String, Expression *> *m_ClosedVars;
boost::shared_ptr<Expression> m_Expression; boost::shared_ptr<Expression> m_Expression;
}; };
class I2_CONFIG_API ObjectExpression : public DebuggableExpression class I2_CONFIG_API ObjectExpression : public DebuggableExpression
{ {
public: public:
ObjectExpression(bool abstract, const String& type, Expression *name, Expression *filter, const String& zone, Expression *expression, const DebugInfo& debugInfo = DebugInfo()) ObjectExpression(bool abstract, const String& type, Expression *name, Expression *filter,
: DebuggableExpression(debugInfo), m_Abstract(abstract), m_Type(type), m_Name(name), m_Filter(filter), m_Zone(zone), m_Expression(expression) const String& zone, std::map<String, Expression *> *closedVars,
Expression *expression, const DebugInfo& debugInfo = DebugInfo())
: DebuggableExpression(debugInfo), m_Abstract(abstract), m_Type(type),
m_Name(name), m_Filter(filter), m_Zone(zone), m_ClosedVars(closedVars), m_Expression(expression)
{ } { }
~ObjectExpression(void) ~ObjectExpression(void)
@ -699,7 +706,7 @@ public:
} }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:
@ -708,6 +715,7 @@ private:
Expression *m_Name; Expression *m_Name;
boost::shared_ptr<Expression> m_Filter; boost::shared_ptr<Expression> m_Filter;
String m_Zone; String m_Zone;
std::map<String, Expression *> *m_ClosedVars;
boost::shared_ptr<Expression> m_Expression; boost::shared_ptr<Expression> m_Expression;
}; };
@ -725,7 +733,7 @@ public:
} }
protected: protected:
virtual Value DoEvaluate(const Object::Ptr& context, DebugHint *dhint) const; virtual Value DoEvaluate(VMFrame& frame, DebugHint *dhint) const;
virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const; virtual void GenerateCode(DefinitionMap& definitions, std::ostream& fpg) const;
private: private:

46
lib/config/vmframe.hpp Normal file
View File

@ -0,0 +1,46 @@
/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012-2014 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 VMFRAME_H
#define VMFRAME_H
#include "config/i2-config.hpp"
#include "base/dictionary.hpp"
namespace icinga
{
struct VMFrame
{
Dictionary::Ptr Locals;
Object::Ptr Self;
Value Result;
VMFrame(void)
: Locals(new Dictionary()), Self(Locals)
{ }
VMFrame(const Object::Ptr& self)
: Locals(new Dictionary()), Self(self)
{ }
};
}
#endif /* VMOPS_H */

95
lib/config/vmops.hpp
View File

@ -44,21 +44,20 @@ namespace icinga
class VMOps class VMOps
{ {
public: public:
static inline Value Variable(const Object::Ptr& context, const String& name) static inline Value Variable(VMFrame& frame, const String& name)
{ {
Object::Ptr scope = context; if (name == "this")
return frame.Self;
while (scope) {
if (HasField(scope, name))
return GetField(scope, name);
scope = GetField(scope, "__parent");
}
if (frame.Locals && frame.Locals->Contains(name))
return frame.Locals->Get(name);
else if (frame.Locals != frame.Self && HasField(frame.Self, name))
return GetField(frame.Self, name);
else
return ScriptVariable::Get(name); return ScriptVariable::Get(name);
} }
static inline Value FunctionCall(const Object::Ptr& context, const Value& funcName, const std::vector<Value>& arguments) static inline Value FunctionCall(VMFrame& frame, const Value& funcName, const std::vector<Value>& arguments)
{ {
ScriptFunction::Ptr func; ScriptFunction::Ptr func;
@ -73,7 +72,7 @@ public:
return func->Invoke(arguments); return func->Invoke(arguments);
} }
static inline Value Indexer(const Object::Ptr& context, const Value& value, const String& index) static inline Value Indexer(VMFrame& frame, const Value& value, const String& index)
{ {
if (value.IsObjectType<Dictionary>()) { if (value.IsObjectType<Dictionary>()) {
Dictionary::Ptr dict = value; Dictionary::Ptr dict = value;
@ -101,9 +100,11 @@ public:
} }
} }
static inline Value NewFunction(const Object::Ptr& context, const String& name, const std::vector<String>& args, const boost::shared_ptr<Expression>& expression) static inline Value NewFunction(VMFrame& frame, const String& name, const std::vector<String>& args,
std::map<String, Expression *> *closedVars, const boost::shared_ptr<Expression>& expression)
{ {
ScriptFunction::Ptr func = new ScriptFunction(boost::bind(&FunctionWrapper, _1, args, expression, context)); ScriptFunction::Ptr func = new ScriptFunction(boost::bind(&FunctionWrapper, _1, args,
EvaluateClosedVars(frame, closedVars), expression));
if (!name.IsEmpty()) if (!name.IsEmpty())
ScriptFunction::Register(name, func); ScriptFunction::Register(name, func);
@ -111,7 +112,7 @@ public:
return func; return func;
} }
static inline Value NewSlot(const Object::Ptr& context, const String& signal, const Value& slot) static inline Value NewSlot(VMFrame& frame, const String& signal, const Value& slot)
{ {
ScriptSignal::Ptr sig = ScriptSignal::GetByName(signal); ScriptSignal::Ptr sig = ScriptSignal::GetByName(signal);
@ -123,17 +124,18 @@ public:
return Empty; return Empty;
} }
static inline Value NewApply(const Object::Ptr& context, const String& type, const String& target, const String& name, const boost::shared_ptr<Expression>& filter, static inline Value NewApply(VMFrame& frame, const String& type, const String& target, const String& name, const boost::shared_ptr<Expression>& filter,
const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm, const String& fkvar, const String& fvvar, const boost::shared_ptr<Expression>& fterm, std::map<String, Expression *> *closedVars,
const boost::shared_ptr<Expression>& expression, const DebugInfo& debugInfo = DebugInfo()) const boost::shared_ptr<Expression>& expression, const DebugInfo& debugInfo = DebugInfo())
{ {
ApplyRule::AddRule(type, target, name, expression, filter, fkvar, fvvar, fterm, debugInfo, context); ApplyRule::AddRule(type, target, name, expression, filter, fkvar,
fvvar, fterm, debugInfo, EvaluateClosedVars(frame, closedVars));
return Empty; return Empty;
} }
static inline Value NewObject(const Object::Ptr& context, bool abstract, const String& type, const String& name, const boost::shared_ptr<Expression>& filter, static inline Value NewObject(VMFrame& frame, bool abstract, const String& type, const String& name, const boost::shared_ptr<Expression>& filter,
const String& zone, const boost::shared_ptr<Expression>& expression, const DebugInfo& debugInfo = DebugInfo()) const String& zone, std::map<String, Expression *> *closedVars, const boost::shared_ptr<Expression>& expression, const DebugInfo& debugInfo = DebugInfo())
{ {
ConfigItemBuilder::Ptr item = new ConfigItemBuilder(debugInfo); ConfigItemBuilder::Ptr item = new ConfigItemBuilder(debugInfo);
@ -170,7 +172,7 @@ public:
item->AddExpression(new OwnedExpression(expression)); item->AddExpression(new OwnedExpression(expression));
item->SetAbstract(abstract); item->SetAbstract(abstract);
item->SetScope(context); item->SetScope(EvaluateClosedVars(frame, closedVars));
item->SetZone(zone); item->SetZone(zone);
item->SetFilter(filter); item->SetFilter(filter);
item->Compile()->Register(); item->Compile()->Register();
@ -178,7 +180,7 @@ public:
return Empty; return Empty;
} }
static inline Value For(const Object::Ptr& context, const String& fkvar, const String& fvvar, const Value& value, Expression *expression, const DebugInfo& debugInfo = DebugInfo()) static inline Value For(VMFrame& frame, const String& fkvar, const String& fvvar, const Value& value, Expression *expression, const DebugInfo& debugInfo = DebugInfo())
{ {
if (value.IsObjectType<Array>()) { if (value.IsObjectType<Array>()) {
if (!fvvar.IsEmpty()) if (!fvvar.IsEmpty())
@ -188,14 +190,10 @@ public:
ObjectLock olock(arr); ObjectLock olock(arr);
BOOST_FOREACH(const Value& value, arr) { BOOST_FOREACH(const Value& value, arr) {
Dictionary::Ptr xcontext = new Dictionary(); frame.Locals->Set(fkvar, value);
xcontext->Set("__parent", context); expression->Evaluate(frame);
xcontext->Set(fkvar, value);
expression->Evaluate(xcontext);
} }
} } else if (value.IsObjectType<Dictionary>()) {
else if (value.IsObjectType<Dictionary>()) {
if (fvvar.IsEmpty()) if (fvvar.IsEmpty())
BOOST_THROW_EXCEPTION(ConfigError("Cannot use array iterator for dictionary.") << errinfo_debuginfo(debugInfo)); BOOST_THROW_EXCEPTION(ConfigError("Cannot use array iterator for dictionary.") << errinfo_debuginfo(debugInfo));
@ -203,12 +201,9 @@ public:
ObjectLock olock(dict); ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) { BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
Dictionary::Ptr xcontext = new Dictionary(); frame.Locals->Set(fkvar, kv.first);
xcontext->Set("__parent", context); frame.Locals->Set(fvvar, kv.second);
xcontext->Set(fkvar, kv.first); expression->Evaluate(frame);
xcontext->Set(fvvar, kv.second);
expression->Evaluate(xcontext);
} }
} }
else else
@ -283,22 +278,24 @@ public:
private: private:
static inline Value FunctionWrapper(const std::vector<Value>& arguments, static inline Value FunctionWrapper(const std::vector<Value>& arguments,
const std::vector<String>& funcargs, const boost::shared_ptr<Expression>& expr, const Object::Ptr& scope) const std::vector<String>& funcargs, const Dictionary::Ptr& closedVars, const boost::shared_ptr<Expression>& expr)
{ {
if (arguments.size() < funcargs.size()) if (arguments.size() < funcargs.size())
BOOST_THROW_EXCEPTION(ConfigError("Too few arguments for function")); BOOST_THROW_EXCEPTION(ConfigError("Too few arguments for function"));
Dictionary::Ptr context = new Dictionary(); VMFrame frame;
context->Set("__parent", scope);
if (closedVars)
closedVars->CopyTo(frame.Locals);
for (std::vector<Value>::size_type i = 0; i < std::min(arguments.size(), funcargs.size()); i++) for (std::vector<Value>::size_type i = 0; i < std::min(arguments.size(), funcargs.size()); i++)
context->Set(funcargs[i], arguments[i]); frame.Locals->Set(funcargs[i], arguments[i]);
expr->Evaluate(context); expr->Evaluate(frame);
return context->Get("__result"); return frame.Result;
} }
static void SlotWrapper(const Value& funcName, const std::vector<Value>& arguments) static inline void SlotWrapper(const Value& funcName, const std::vector<Value>& arguments)
{ {
ScriptFunction::Ptr func; ScriptFunction::Ptr func;
@ -312,6 +309,22 @@ private:
func->Invoke(arguments); func->Invoke(arguments);
} }
static inline Dictionary::Ptr EvaluateClosedVars(VMFrame& frame, std::map<String, Expression *> *closedVars)
{
Dictionary::Ptr locals;
if (closedVars) {
locals = new Dictionary();
typedef std::pair<String, Expression *> ClosedVar;
BOOST_FOREACH(const ClosedVar& cvar, *closedVars) {
locals->Set(cvar.first, cvar.second->Evaluate(frame));
}
}
return locals;
}
}; };
} }

35
lib/icinga/dependency-apply.cpp
View File

@ -42,7 +42,7 @@ void Dependency::RegisterApplyRuleHandler(void)
ApplyRule::RegisterType("Dependency", targets); ApplyRule::RegisterType("Dependency", targets);
} }
void Dependency::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule) void Dependency::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, VMFrame& frame, const ApplyRule& rule)
{ {
DebugInfo di = rule.GetDebugInfo(); DebugInfo di = rule.GetDebugInfo();
@ -52,22 +52,22 @@ void Dependency::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, cons
ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di); ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di);
builder->SetType("Dependency"); builder->SetType("Dependency");
builder->SetName(name); builder->SetName(name);
builder->SetScope(locals); builder->SetScope(frame.Locals);
Host::Ptr host; Host::Ptr host;
Service::Ptr service; Service::Ptr service;
tie(host, service) = GetHostService(checkable); tie(host, service) = GetHostService(checkable);
builder->AddExpression(new SetExpression(MakeIndexer("parent_host_name"), OpSetLiteral, MakeLiteral(host->GetName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("parent_host_name"), OpSetLiteral, MakeLiteral(host->GetName()), false, di));
builder->AddExpression(new SetExpression(MakeIndexer("child_host_name"), OpSetLiteral, MakeLiteral(host->GetName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("child_host_name"), OpSetLiteral, MakeLiteral(host->GetName()), false, di));
if (service) if (service)
builder->AddExpression(new SetExpression(MakeIndexer("child_service_name"), OpSetLiteral, MakeLiteral(service->GetShortName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("child_service_name"), OpSetLiteral, MakeLiteral(service->GetShortName()), false, di));
String zone = checkable->GetZone(); String zone = checkable->GetZone();
if (!zone.IsEmpty()) if (!zone.IsEmpty())
builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), di)); builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), false, di));
builder->AddExpression(new OwnedExpression(rule.GetExpression())); builder->AddExpression(new OwnedExpression(rule.GetExpression()));
@ -87,19 +87,20 @@ bool Dependency::EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyR
Service::Ptr service; Service::Ptr service;
tie(host, service) = GetHostService(checkable); tie(host, service) = GetHostService(checkable);
Dictionary::Ptr locals = new Dictionary(); VMFrame frame;
locals->Set("__parent", rule.GetScope()); if (rule.GetScope())
locals->Set("host", host); rule.GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("host", host);
if (service) if (service)
locals->Set("service", service); frame.Locals->Set("service", service);
if (!rule.EvaluateFilter(locals)) if (!rule.EvaluateFilter(frame))
return false; return false;
Value vinstances; Value vinstances;
if (rule.GetFTerm()) { if (rule.GetFTerm()) {
vinstances = rule.GetFTerm()->Evaluate(locals); vinstances = rule.GetFTerm()->Evaluate(frame);
} else { } else {
Array::Ptr instances = new Array(); Array::Ptr instances = new Array();
instances->Add(""); instances->Add("");
@ -117,11 +118,11 @@ bool Dependency::EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyR
String name = rule.GetName(); String name = rule.GetName();
if (!rule.GetFKVar().IsEmpty()) { if (!rule.GetFKVar().IsEmpty()) {
locals->Set(rule.GetFKVar(), instance); frame.Locals->Set(rule.GetFKVar(), instance);
name += instance; name += instance;
} }
EvaluateApplyRuleInstance(checkable, name, locals, rule); EvaluateApplyRuleInstance(checkable, name, frame, rule);
} }
} else if (vinstances.IsObjectType<Dictionary>()) { } else if (vinstances.IsObjectType<Dictionary>()) {
if (rule.GetFVVar().IsEmpty()) if (rule.GetFVVar().IsEmpty())
@ -131,10 +132,10 @@ bool Dependency::EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyR
ObjectLock olock(dict); ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) { BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
locals->Set(rule.GetFKVar(), kv.first); frame.Locals->Set(rule.GetFKVar(), kv.first);
locals->Set(rule.GetFVVar(), kv.second); frame.Locals->Set(rule.GetFVVar(), kv.second);
EvaluateApplyRuleInstance(checkable, rule.GetName() + kv.first, locals, rule); EvaluateApplyRuleInstance(checkable, rule.GetName() + kv.first, frame, rule);
} }
} }

3
lib/icinga/dependency.hpp
View File

@ -28,6 +28,7 @@ namespace icinga
{ {
class ApplyRule; class ApplyRule;
class VMFrame;
class Host; class Host;
class Service; class Service;
@ -65,7 +66,7 @@ private:
Checkable::Ptr m_Parent; Checkable::Ptr m_Parent;
Checkable::Ptr m_Child; Checkable::Ptr m_Child;
static void EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule); static void EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, VMFrame& frame, const ApplyRule& rule);
static bool EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyRule& rule); static bool EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyRule& rule);
}; };

9
lib/icinga/hostgroup.cpp
View File

@ -44,11 +44,12 @@ bool HostGroup::EvaluateObjectRule(const Host::Ptr& host, const ConfigItem::Ptr&
CONTEXT("Evaluating rule for group '" + group_name + "'"); CONTEXT("Evaluating rule for group '" + group_name + "'");
Dictionary::Ptr locals = new Dictionary(); VMFrame frame;
locals->Set("__parent", group->GetScope()); if (group->GetScope())
locals->Set("host", host); group->GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("host", host);
if (!group->GetFilter()->Evaluate(locals)) if (!group->GetFilter()->Evaluate(frame))
return false; return false;
Log(LogDebug, "HostGroup") Log(LogDebug, "HostGroup")

33
lib/icinga/notification-apply.cpp
View File

@ -42,7 +42,7 @@ void Notification::RegisterApplyRuleHandler(void)
ApplyRule::RegisterType("Notification", targets); ApplyRule::RegisterType("Notification", targets);
} }
void Notification::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule) void Notification::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, VMFrame& frame, const ApplyRule& rule)
{ {
DebugInfo di = rule.GetDebugInfo(); DebugInfo di = rule.GetDebugInfo();
@ -52,21 +52,21 @@ void Notification::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, co
ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di); ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di);
builder->SetType("Notification"); builder->SetType("Notification");
builder->SetName(name); builder->SetName(name);
builder->SetScope(locals); builder->SetScope(frame.Locals);
Host::Ptr host; Host::Ptr host;
Service::Ptr service; Service::Ptr service;
tie(host, service) = GetHostService(checkable); tie(host, service) = GetHostService(checkable);
builder->AddExpression(new SetExpression(MakeIndexer("host_name"), OpSetLiteral, MakeLiteral(host->GetName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("host_name"), OpSetLiteral, MakeLiteral(host->GetName()), false, di));
if (service) if (service)
builder->AddExpression(new SetExpression(MakeIndexer("service_name"), OpSetLiteral, MakeLiteral(service->GetShortName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("service_name"), OpSetLiteral, MakeLiteral(service->GetShortName()), false, di));
String zone = checkable->GetZone(); String zone = checkable->GetZone();
if (!zone.IsEmpty()) if (!zone.IsEmpty())
builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), di)); builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), false, di));
builder->AddExpression(new OwnedExpression(rule.GetExpression())); builder->AddExpression(new OwnedExpression(rule.GetExpression()));
@ -86,19 +86,20 @@ bool Notification::EvaluateApplyRule(const Checkable::Ptr& checkable, const Appl
Service::Ptr service; Service::Ptr service;
tie(host, service) = GetHostService(checkable); tie(host, service) = GetHostService(checkable);
Dictionary::Ptr locals = new Dictionary(); VMFrame frame;
locals->Set("__parent", rule.GetScope()); if (rule.GetScope())
locals->Set("host", host); rule.GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("host", host);
if (service) if (service)
locals->Set("service", service); frame.Locals->Set("service", service);
if (!rule.EvaluateFilter(locals)) if (!rule.EvaluateFilter(frame))
return false; return false;
Value vinstances; Value vinstances;
if (rule.GetFTerm()) { if (rule.GetFTerm()) {
vinstances = rule.GetFTerm()->Evaluate(locals); vinstances = rule.GetFTerm()->Evaluate(frame);
} else { } else {
Array::Ptr instances = new Array(); Array::Ptr instances = new Array();
instances->Add(""); instances->Add("");
@ -116,11 +117,11 @@ bool Notification::EvaluateApplyRule(const Checkable::Ptr& checkable, const Appl
String name = rule.GetName(); String name = rule.GetName();
if (!rule.GetFKVar().IsEmpty()) { if (!rule.GetFKVar().IsEmpty()) {
locals->Set(rule.GetFKVar(), instance); frame.Locals->Set(rule.GetFKVar(), instance);
name += instance; name += instance;
} }
EvaluateApplyRuleInstance(checkable, name, locals, rule); EvaluateApplyRuleInstance(checkable, name, frame, rule);
} }
} else if (vinstances.IsObjectType<Dictionary>()) { } else if (vinstances.IsObjectType<Dictionary>()) {
if (rule.GetFVVar().IsEmpty()) if (rule.GetFVVar().IsEmpty())
@ -130,10 +131,10 @@ bool Notification::EvaluateApplyRule(const Checkable::Ptr& checkable, const Appl
ObjectLock olock(dict); ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) { BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
locals->Set(rule.GetFKVar(), kv.first); frame.Locals->Set(rule.GetFKVar(), kv.first);
locals->Set(rule.GetFVVar(), kv.second); frame.Locals->Set(rule.GetFVVar(), kv.second);
EvaluateApplyRuleInstance(checkable, rule.GetName() + kv.first, locals, rule); EvaluateApplyRuleInstance(checkable, rule.GetName() + kv.first, frame, rule);
} }
} }

3
lib/icinga/notification.hpp
View File

@ -68,6 +68,7 @@ enum NotificationType
class NotificationCommand; class NotificationCommand;
class Checkable; class Checkable;
class ApplyRule; class ApplyRule;
class VMFrame;
class Host; class Host;
class Service; class Service;
@ -122,7 +123,7 @@ protected:
private: private:
void ExecuteNotificationHelper(NotificationType type, const User::Ptr& user, const CheckResult::Ptr& cr, bool force, const String& author = "", const String& text = ""); void ExecuteNotificationHelper(NotificationType type, const User::Ptr& user, const CheckResult::Ptr& cr, bool force, const String& author = "", const String& text = "");
static void EvaluateApplyRuleInstance(const intrusive_ptr<Checkable>& checkable, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule); static void EvaluateApplyRuleInstance(const intrusive_ptr<Checkable>& checkable, const String& name, VMFrame& frame, const ApplyRule& rule);
static bool EvaluateApplyRule(const intrusive_ptr<Checkable>& checkable, const ApplyRule& rule); static bool EvaluateApplyRule(const intrusive_ptr<Checkable>& checkable, const ApplyRule& rule);
}; };

36
lib/icinga/scheduleddowntime-apply.cpp
View File

@ -41,7 +41,7 @@ void ScheduledDowntime::RegisterApplyRuleHandler(void)
ApplyRule::RegisterType("ScheduledDowntime", targets); ApplyRule::RegisterType("ScheduledDowntime", targets);
} }
void ScheduledDowntime::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule) void ScheduledDowntime::EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, VMFrame& frame, const ApplyRule& rule)
{ {
DebugInfo di = rule.GetDebugInfo(); DebugInfo di = rule.GetDebugInfo();
@ -51,22 +51,21 @@ void ScheduledDowntime::EvaluateApplyRuleInstance(const Checkable::Ptr& checkabl
ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di); ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di);
builder->SetType("ScheduledDowntime"); builder->SetType("ScheduledDowntime");
builder->SetName(name); builder->SetName(name);
builder->SetScope(locals); builder->SetScope(frame.Locals);
Host::Ptr host; Host::Ptr host;
Service::Ptr service; Service::Ptr service;
tie(host, service) = GetHostService(checkable); tie(host, service) = GetHostService(checkable);
builder->AddExpression(new SetExpression(MakeIndexer("host_name"), OpSetLiteral, MakeLiteral(host->GetName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("host_name"), OpSetLiteral, MakeLiteral(host->GetName()), false, di));
if (service) if (service)
builder->AddExpression(new SetExpression(MakeIndexer("service_name"), OpSetLiteral, MakeLiteral(service->GetShortName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("service_name"), OpSetLiteral, MakeLiteral(service->GetShortName()), false, di));
String zone = checkable->GetZone(); String zone = checkable->GetZone();
if (!zone.IsEmpty()) { if (!zone.IsEmpty())
builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), di)); builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), false, di));
}
builder->AddExpression(new OwnedExpression(rule.GetExpression())); builder->AddExpression(new OwnedExpression(rule.GetExpression()));
@ -86,19 +85,20 @@ bool ScheduledDowntime::EvaluateApplyRule(const Checkable::Ptr& checkable, const
Service::Ptr service; Service::Ptr service;
tie(host, service) = GetHostService(checkable); tie(host, service) = GetHostService(checkable);
Dictionary::Ptr locals = new Dictionary(); VMFrame frame;
locals->Set("__parent", rule.GetScope()); if (rule.GetScope())
locals->Set("host", host); rule.GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("host", host);
if (service) if (service)
locals->Set("service", service); frame.Locals->Set("service", service);
if (!rule.EvaluateFilter(locals)) if (!rule.EvaluateFilter(frame))
return false; return false;
Value vinstances; Value vinstances;
if (rule.GetFTerm()) { if (rule.GetFTerm()) {
vinstances = rule.GetFTerm()->Evaluate(locals); vinstances = rule.GetFTerm()->Evaluate(frame);
} else { } else {
Array::Ptr instances = new Array(); Array::Ptr instances = new Array();
instances->Add(""); instances->Add("");
@ -116,11 +116,11 @@ bool ScheduledDowntime::EvaluateApplyRule(const Checkable::Ptr& checkable, const
String name = rule.GetName(); String name = rule.GetName();
if (!rule.GetFKVar().IsEmpty()) { if (!rule.GetFKVar().IsEmpty()) {
locals->Set(rule.GetFKVar(), instance); frame.Locals->Set(rule.GetFKVar(), instance);
name += instance; name += instance;
} }
EvaluateApplyRuleInstance(checkable, name, locals, rule); EvaluateApplyRuleInstance(checkable, name, frame, rule);
} }
} else if (vinstances.IsObjectType<Dictionary>()) { } else if (vinstances.IsObjectType<Dictionary>()) {
if (rule.GetFVVar().IsEmpty()) if (rule.GetFVVar().IsEmpty())
@ -130,10 +130,10 @@ bool ScheduledDowntime::EvaluateApplyRule(const Checkable::Ptr& checkable, const
ObjectLock olock(dict); ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) { BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
locals->Set(rule.GetFKVar(), kv.first); frame.Locals->Set(rule.GetFKVar(), kv.first);
locals->Set(rule.GetFVVar(), kv.second); frame.Locals->Set(rule.GetFVVar(), kv.second);
EvaluateApplyRuleInstance(checkable, rule.GetName() + kv.first, locals, rule); EvaluateApplyRuleInstance(checkable, rule.GetName() + kv.first, frame, rule);
} }
} }

3
lib/icinga/scheduleddowntime.hpp
View File

@ -29,6 +29,7 @@ namespace icinga
{ {
class ApplyRule; class ApplyRule;
class VMFrame;
class Host; class Host;
class Service; class Service;
@ -61,7 +62,7 @@ private:
std::pair<double, double> FindNextSegment(void); std::pair<double, double> FindNextSegment(void);
void CreateNextDowntime(void); void CreateNextDowntime(void);
static void EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule); static void EvaluateApplyRuleInstance(const Checkable::Ptr& checkable, const String& name, VMFrame& frame, const ApplyRule& rule);
static bool EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyRule& rule); static bool EvaluateApplyRule(const Checkable::Ptr& checkable, const ApplyRule& rule);
}; };

31
lib/icinga/service-apply.cpp
View File

@ -40,7 +40,7 @@ void Service::RegisterApplyRuleHandler(void)
ApplyRule::RegisterType("Service", targets); ApplyRule::RegisterType("Service", targets);
} }
void Service::EvaluateApplyRuleInstance(const Host::Ptr& host, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule) void Service::EvaluateApplyRuleInstance(const Host::Ptr& host, const String& name, VMFrame& frame, const ApplyRule& rule)
{ {
DebugInfo di = rule.GetDebugInfo(); DebugInfo di = rule.GetDebugInfo();
@ -50,16 +50,16 @@ void Service::EvaluateApplyRuleInstance(const Host::Ptr& host, const String& nam
ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di); ConfigItemBuilder::Ptr builder = new ConfigItemBuilder(di);
builder->SetType("Service"); builder->SetType("Service");
builder->SetName(name); builder->SetName(name);
builder->SetScope(locals); builder->SetScope(frame.Locals);
builder->AddExpression(new SetExpression(MakeIndexer("host_name"), OpSetLiteral, MakeLiteral(host->GetName()), di)); builder->AddExpression(new SetExpression(MakeIndexer("host_name"), OpSetLiteral, MakeLiteral(host->GetName()), false, di));
builder->AddExpression(new SetExpression(MakeIndexer("name"), OpSetLiteral, MakeLiteral(name), di)); builder->AddExpression(new SetExpression(MakeIndexer("name"), OpSetLiteral, MakeLiteral(name), false, di));
String zone = host->GetZone(); String zone = host->GetZone();
if (!zone.IsEmpty()) if (!zone.IsEmpty())
builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), di)); builder->AddExpression(new SetExpression(MakeIndexer("zone"), OpSetLiteral, MakeLiteral(zone), false, di));
builder->AddExpression(new OwnedExpression(rule.GetExpression())); builder->AddExpression(new OwnedExpression(rule.GetExpression()));
@ -75,17 +75,18 @@ bool Service::EvaluateApplyRule(const Host::Ptr& host, const ApplyRule& rule)
msgbuf << "Evaluating 'apply' rule (" << di << ")"; msgbuf << "Evaluating 'apply' rule (" << di << ")";
CONTEXT(msgbuf.str()); CONTEXT(msgbuf.str());
Dictionary::Ptr locals = new Dictionary(); VMFrame frame;
locals->Set("__parent", rule.GetScope()); if (rule.GetScope())
locals->Set("host", host); rule.GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("host", host);
if (!rule.EvaluateFilter(locals)) if (!rule.EvaluateFilter(frame))
return false; return false;
Value vinstances; Value vinstances;
if (rule.GetFTerm()) { if (rule.GetFTerm()) {
vinstances = rule.GetFTerm()->Evaluate(locals); vinstances = rule.GetFTerm()->Evaluate(frame);
} else { } else {
Array::Ptr instances = new Array(); Array::Ptr instances = new Array();
instances->Add(""); instances->Add("");
@ -103,11 +104,11 @@ bool Service::EvaluateApplyRule(const Host::Ptr& host, const ApplyRule& rule)
String name = rule.GetName(); String name = rule.GetName();
if (!rule.GetFKVar().IsEmpty()) { if (!rule.GetFKVar().IsEmpty()) {
locals->Set(rule.GetFKVar(), instance); frame.Locals->Set(rule.GetFKVar(), instance);
name += instance; name += instance;
} }
EvaluateApplyRuleInstance(host, name, locals, rule); EvaluateApplyRuleInstance(host, name, frame, rule);
} }
} else if (vinstances.IsObjectType<Dictionary>()) { } else if (vinstances.IsObjectType<Dictionary>()) {
if (rule.GetFVVar().IsEmpty()) if (rule.GetFVVar().IsEmpty())
@ -117,10 +118,10 @@ bool Service::EvaluateApplyRule(const Host::Ptr& host, const ApplyRule& rule)
ObjectLock olock(dict); ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) { BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
locals->Set(rule.GetFKVar(), kv.first); frame.Locals->Set(rule.GetFKVar(), kv.first);
locals->Set(rule.GetFVVar(), kv.second); frame.Locals->Set(rule.GetFVVar(), kv.second);
EvaluateApplyRuleInstance(host, rule.GetName() + kv.first, locals, rule); EvaluateApplyRuleInstance(host, rule.GetName() + kv.first, frame, rule);
} }
} }

2
lib/icinga/service.hpp
View File

@ -61,7 +61,7 @@ protected:
private: private:
Host::Ptr m_Host; Host::Ptr m_Host;
static void EvaluateApplyRuleInstance(const Host::Ptr& host, const String& name, const Dictionary::Ptr& locals, const ApplyRule& rule); static void EvaluateApplyRuleInstance(const Host::Ptr& host, const String& name, VMFrame& frame, const ApplyRule& rule);
static bool EvaluateApplyRule(const Host::Ptr& host, const ApplyRule& rule); static bool EvaluateApplyRule(const Host::Ptr& host, const ApplyRule& rule);
}; };

11
lib/icinga/servicegroup.cpp
View File

@ -46,12 +46,13 @@ bool ServiceGroup::EvaluateObjectRule(const Service::Ptr& service, const ConfigI
Host::Ptr host = service->GetHost(); Host::Ptr host = service->GetHost();
Dictionary::Ptr locals = new Dictionary(); VMFrame frame;
locals->Set("__parent", group->GetScope()); if (group->GetScope())
locals->Set("host", host); group->GetScope()->CopyTo(frame.Locals);
locals->Set("service", service); frame.Locals->Set("host", host);
frame.Locals->Set("service", service);
if (!group->GetFilter()->Evaluate(locals)) if (!group->GetFilter()->Evaluate(frame))
return false; return false;
Log(LogDebug, "ServiceGroup") Log(LogDebug, "ServiceGroup")

9
lib/icinga/usergroup.cpp
View File

@ -44,11 +44,12 @@ bool UserGroup::EvaluateObjectRule(const User::Ptr& user, const ConfigItem::Ptr&
CONTEXT("Evaluating rule for group '" + group_name + "'"); CONTEXT("Evaluating rule for group '" + group_name + "'");
Dictionary::Ptr locals = new Dictionary(); VMFrame frame;
locals->Set("__parent", group->GetScope()); if (group->GetScope())
locals->Set("user", user); group->GetScope()->CopyTo(frame.Locals);
frame.Locals->Set("user", user);
if (!group->GetFilter()->Evaluate(locals)) if (!group->GetFilter()->Evaluate(frame))
return false; return false;
Log(LogDebug, "UserGroup") Log(LogDebug, "UserGroup")