1 /* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
6 #include "config/i2-config.hpp"
7 #include "config/expression.hpp"
8 #include "config/configitembuilder.hpp"
9 #include "config/applyrule.hpp"
10 #include "config/objectrule.hpp"
11 #include "base/debuginfo.hpp"
12 #include "base/array.hpp"
13 #include "base/dictionary.hpp"
14 #include "base/namespace.hpp"
15 #include "base/function.hpp"
16 #include "base/scriptglobal.hpp"
17 #include "base/exception.hpp"
18 #include "base/convert.hpp"
19 #include "base/objectlock.hpp"
29 static inline bool FindVarImportRef(ScriptFrame& frame, const std::vector<Expression::Ptr>& imports, const String& name, Value *result, const DebugInfo& debugInfo = DebugInfo())
31 for (const auto& import : imports) {
32 ExpressionResult res = import->Evaluate(frame);
33 Object::Ptr obj = res.GetValue();
34 if (obj->HasOwnField(name)) {
43 static inline bool FindVarImport(ScriptFrame& frame, const std::vector<Expression::Ptr>& imports, const String& name, Value *result, const DebugInfo& debugInfo = DebugInfo())
47 if (FindVarImportRef(frame, imports, name, &parent, debugInfo)) {
48 *result = GetField(parent, name, frame.Sandboxed, debugInfo);
55 static inline Value ConstructorCall(const Type::Ptr& type, const std::vector<Value>& args, const DebugInfo& debugInfo = DebugInfo())
57 if (type->GetName() == "String") {
60 else if (args.size() == 1)
61 return Convert::ToString(args[0]);
63 BOOST_THROW_EXCEPTION(ScriptError("Too many arguments for constructor."));
64 } else if (type->GetName() == "Number") {
67 else if (args.size() == 1)
68 return Convert::ToDouble(args[0]);
70 BOOST_THROW_EXCEPTION(ScriptError("Too many arguments for constructor."));
71 } else if (type->GetName() == "Boolean") {
74 else if (args.size() == 1)
75 return Convert::ToBool(args[0]);
77 BOOST_THROW_EXCEPTION(ScriptError("Too many arguments for constructor."));
78 } else if (args.size() == 1 && type->IsAssignableFrom(args[0].GetReflectionType()))
81 return type->Instantiate(args);
84 static inline Value FunctionCall(ScriptFrame& frame, const Value& self, const Function::Ptr& func, const std::vector<Value>& arguments)
86 if (!self.IsEmpty() || self.IsString())
87 return func->InvokeThis(self, arguments);
89 return func->Invoke(arguments);
93 static inline Value NewFunction(ScriptFrame& frame, const String& name, const std::vector<String>& argNames,
94 const std::map<String, std::unique_ptr<Expression> >& closedVars, const Expression::Ptr& expression)
96 auto evaluatedClosedVars = EvaluateClosedVars(frame, closedVars);
98 auto wrapper = [argNames, evaluatedClosedVars, expression](const std::vector<Value>& arguments) -> Value {
99 if (arguments.size() < argNames.size())
100 BOOST_THROW_EXCEPTION(std::invalid_argument("Too few arguments for function"));
102 ScriptFrame *frame = ScriptFrame::GetCurrentFrame();
104 frame->Locals = new Dictionary();
106 if (evaluatedClosedVars)
107 evaluatedClosedVars->CopyTo(frame->Locals);
109 for (std::vector<Value>::size_type i = 0; i < std::min(arguments.size(), argNames.size()); i++)
110 frame->Locals->Set(argNames[i], arguments[i]);
112 return expression->Evaluate(*frame);
115 return new Function(name, wrapper, argNames);
118 static inline Value NewApply(ScriptFrame& frame, const String& type, const String& target, const String& name, const Expression::Ptr& filter,
119 const String& package, const String& fkvar, const String& fvvar, const Expression::Ptr& fterm, const std::map<String, std::unique_ptr<Expression> >& closedVars,
120 bool ignoreOnError, const Expression::Ptr& expression, const DebugInfo& debugInfo = DebugInfo())
122 ApplyRule::AddRule(type, target, name, expression, filter, package, fkvar,
123 fvvar, fterm, ignoreOnError, debugInfo, EvaluateClosedVars(frame, closedVars));
128 static inline Value NewObject(ScriptFrame& frame, bool abstract, const Type::Ptr& type, const String& name, const Expression::Ptr& filter,
129 const String& zone, const String& package, bool defaultTmpl, bool ignoreOnError, const std::map<String, std::unique_ptr<Expression> >& closedVars, const Expression::Ptr& expression, const DebugInfo& debugInfo = DebugInfo())
131 ConfigItemBuilder item{debugInfo};
133 String checkName = name;
136 auto *nc = dynamic_cast<NameComposer *>(type.get());
139 checkName = nc->MakeName(name, nullptr);
142 if (!checkName.IsEmpty()) {
143 ConfigItem::Ptr oldItem = ConfigItem::GetByTypeAndName(type, checkName);
146 std::ostringstream msgbuf;
147 msgbuf << "Object '" << name << "' of type '" << type->GetName() << "' re-defined: " << debugInfo << "; previous definition: " << oldItem->GetDebugInfo();
148 BOOST_THROW_EXCEPTION(ScriptError(msgbuf.str(), debugInfo));
152 if (filter && !ObjectRule::IsValidSourceType(type->GetName())) {
153 std::ostringstream msgbuf;
154 msgbuf << "Object '" << name << "' of type '" << type->GetName() << "' must not have 'assign where' and 'ignore where' rules: " << debugInfo;
155 BOOST_THROW_EXCEPTION(ScriptError(msgbuf.str(), debugInfo));
162 item.AddExpression(new ImportDefaultTemplatesExpression());
164 item.AddExpression(new OwnedExpression(expression));
165 item.SetAbstract(abstract);
166 item.SetScope(EvaluateClosedVars(frame, closedVars));
168 item.SetPackage(package);
169 item.SetFilter(filter);
170 item.SetDefaultTemplate(defaultTmpl);
171 item.SetIgnoreOnError(ignoreOnError);
172 item.Compile()->Register();
177 static inline ExpressionResult For(ScriptFrame& frame, const String& fkvar, const String& fvvar, const Value& value, const std::unique_ptr<Expression>& expression, const DebugInfo& debugInfo = DebugInfo())
179 if (value.IsObjectType<Array>()) {
180 if (!fvvar.IsEmpty())
181 BOOST_THROW_EXCEPTION(ScriptError("Cannot use dictionary iterator for array.", debugInfo));
183 Array::Ptr arr = value;
185 for (Array::SizeType i = 0; i < arr->GetLength(); i++) {
186 frame.Locals->Set(fkvar, arr->Get(i));
187 ExpressionResult res = expression->Evaluate(frame);
188 CHECK_RESULT_LOOP(res);
190 } else if (value.IsObjectType<Dictionary>()) {
192 BOOST_THROW_EXCEPTION(ScriptError("Cannot use array iterator for dictionary.", debugInfo));
194 Dictionary::Ptr dict = value;
195 std::vector<String> keys;
198 ObjectLock olock(dict);
199 for (const Dictionary::Pair& kv : dict) {
200 keys.push_back(kv.first);
204 for (const String& key : keys) {
205 frame.Locals->Set(fkvar, key);
206 frame.Locals->Set(fvvar, dict->Get(key));
207 ExpressionResult res = expression->Evaluate(frame);
208 CHECK_RESULT_LOOP(res);
210 } else if (value.IsObjectType<Namespace>()) {
212 BOOST_THROW_EXCEPTION(ScriptError("Cannot use array iterator for namespace.", debugInfo));
214 Namespace::Ptr ns = value;
215 std::vector<String> keys;
218 ObjectLock olock(ns);
219 for (const Namespace::Pair& kv : ns) {
220 keys.push_back(kv.first);
224 for (const String& key : keys) {
225 frame.Locals->Set(fkvar, key);
226 frame.Locals->Set(fvvar, ns->Get(key));
227 ExpressionResult res = expression->Evaluate(frame);
228 CHECK_RESULT_LOOP(res);
231 BOOST_THROW_EXCEPTION(ScriptError("Invalid type in for expression: " + value.GetTypeName(), debugInfo));
236 static inline Value GetField(const Value& context, const String& field, bool sandboxed = false, const DebugInfo& debugInfo = DebugInfo())
238 if (BOOST_UNLIKELY(context.IsEmpty() && !context.IsString()))
241 if (BOOST_UNLIKELY(!context.IsObject()))
242 return GetPrototypeField(context, field, true, debugInfo);
244 Object::Ptr object = context;
246 return object->GetFieldByName(field, sandboxed, debugInfo);
249 static inline void SetField(const Object::Ptr& context, const String& field, const Value& value, bool overrideFrozen, const DebugInfo& debugInfo = DebugInfo())
252 BOOST_THROW_EXCEPTION(ScriptError("Cannot set field '" + field + "' on a value that is not an object.", debugInfo));
254 return context->SetFieldByName(field, value, overrideFrozen, debugInfo);
258 static inline Dictionary::Ptr EvaluateClosedVars(ScriptFrame& frame, const std::map<String, std::unique_ptr<Expression> >& closedVars)
260 if (closedVars.empty())
263 DictionaryData locals;
265 for (const auto& cvar : closedVars)
266 locals.emplace_back(cvar.first, cvar.second->Evaluate(frame));
268 return new Dictionary(std::move(locals));