def _canonize_parameters(arguments_scheme, args, kwargs):
arg_names = list(arguments_scheme.keys())
parameter_values = utils.filter_parameters_dict(kwargs)
for i, arg in enumerate(args):
name = arg_names[i]
parameter_values[name] = arg
return tuple(), parameter_values
def _canonize_parameters(arguments_scheme, args, kwargs):
arg_names = list(arguments_scheme.keys())
parameter_values = utils.filter_parameters_dict(kwargs)
for i, arg in enumerate(args):
name = arg_names[i]
parameter_values[name] = arg
return tuple(), parameter_values
def instantiate(data, owner, object_store, context, scope_type,
default_type=None):
if data is None:
data = {}
if not isinstance(data, yaqlutils.MappingType):
raise ValueError('Incorrect object initialization format')
default_type = resolve_type(default_type, scope_type)
if len(data) == 1:
key = next(iter(data.keys()))
ns_resolver = scope_type.namespace_resolver
if ns_resolver.is_typename(key, False) or isinstance(
key, (dsl_types.MuranoTypeReference, dsl_types.MuranoType)):
type_obj = resolve_type(key, scope_type)
props = yaqlutils.filter_parameters_dict(data[key] or {})
props = evaluate(props, context, freeze=False)
return type_obj.new(
owner, object_store, object_store.executor)(
context, **props)
data = evaluate(data, context, freeze=False)
if '?' not in data:
if not default_type:
raise ValueError('Type information is missing')
data.update({'?': {
'type': default_type.name,
'classVersion': str(default_type.version)
}})
if 'id' not in data['?']:
data['?']['id'] = uuid.uuid4().hex
return object_store.load(data, owner, context)
def instantiate(data, owner, object_store, context, scope_type,
default_type=None):
if data is None:
data = {}
if not isinstance(data, yaqlutils.MappingType):
raise ValueError('Incorrect object initialization format')
default_type = resolve_type(default_type, scope_type)
if len(data) == 1:
key = next(iter(data.keys()))
ns_resolver = scope_type.namespace_resolver
if ns_resolver.is_typename(key, False) or isinstance(
key, (dsl_types.MuranoTypeReference, dsl_types.MuranoType)):
type_obj = resolve_type(key, scope_type)
props = yaqlutils.filter_parameters_dict(data[key] or {})
props = evaluate(props, context, freeze=False)
return type_obj.new(
owner, object_store, object_store.executor)(
context, **props)
data = evaluate(data, context, freeze=False)
if '?' not in data:
if not default_type:
raise ValueError('Type information is missing')
data.update({'?': {
'type': default_type.name,
'classVersion': str(default_type.version)
}})
if 'id' not in data['?']:
data['?']['id'] = uuid.uuid4().hex
return object_store.load(data, owner, context)
def new_from_dict(type_name,
context,
parameters,
owner=None,
object_name=None,
extra=None):
return new(context, type_name, owner, object_name, extra,
**utils.filter_parameters_dict(parameters))
def parse_object_definition(spec, scope_type, context):
if not isinstance(spec, yaqlutils.MappingType):
return None
if context:
spec = evaluate(spec, context, freeze=False)
else:
spec = spec.copy()
system_data = None
type_obj = None
props = {}
ns_resolver = scope_type.namespace_resolver if scope_type else None
for key in spec:
if (ns_resolver and ns_resolver.is_typename(key, False) or isinstance(
key, (dsl_types.MuranoTypeReference, dsl_types.MuranoType))):
type_obj = resolve_type(key, scope_type)
props = spec.pop(key) or {}
system_data = spec
break
if system_data is None:
props = spec
if '?' in spec:
system_data = spec.pop('?')
obj_type = system_data.get('type')
if isinstance(obj_type, dsl_types.MuranoTypeReference):
type_obj = obj_type.type
elif isinstance(obj_type, dsl_types.MuranoType):
type_obj = obj_type
elif obj_type:
type_str, version_str, package_str = parse_type_string(
obj_type, system_data.get('classVersion'),
system_data.get('package'))
version_spec = parse_version_spec(version_str)
package_loader = get_package_loader()
if package_str:
package = package_loader.load_package(
package_str, version_spec)
else:
package = package_loader.load_class_package(
type_str, version_spec)
type_obj = package.find_class(type_str, False)
else:
system_data = {}
return {
'type': type_obj,
'properties': yaqlutils.filter_parameters_dict(props),
'id': system_data.get('id'),
'name': system_data.get('name'),
'metadata': system_data.get('metadata'),
'destroyed': system_data.get('destroyed', False),
'dependencies': system_data.get('dependencies', {}),
'extra': {
key: value
for key, value in system_data.items() if key.startswith('_')
}
}
def _invoke_method(self, method, this, context, args, kwargs,
skip_stub=False):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
kwargs = utils.filter_parameters_dict(kwargs)
runtime_version = method.murano_class.package.runtime_version
yaql_engine = yaql_integration.choose_yaql_engine(runtime_version)
if context is None or not skip_stub:
actions_only = context is None and not method.name.startswith('.')
method_context = self.create_method_context(
self.create_object_context(this, context), method)
method_context[constants.CTX_SKIP_FRAME] = True
method_context[constants.CTX_ACTIONS_ONLY] = actions_only
return method.yaql_function_definition(
yaql_engine, method_context, this.real_this)(*args, **kwargs)
if (context[constants.CTX_ACTIONS_ONLY] and method.usage !=
murano_method.MethodUsages.Action):
raise Exception('{0} is not an action'.format(method.name))
context = self.create_method_context(
self.create_object_context(this, context), method)
if isinstance(this, dsl_types.MuranoObject):
this = this.real_this
if method.arguments_scheme is not None:
args, kwargs = self._canonize_parameters(
method.arguments_scheme, args, kwargs)
with self._acquire_method_lock(method, this):
for i, arg in enumerate(args, 2):
context[str(i)] = arg
for key, value in six.iteritems(kwargs):
context[key] = value
def call():
if isinstance(method.body, specs.FunctionDefinition):
native_this = this.cast(
method.murano_class).extension
return method.body(
yaql_engine, context, native_this)(*args, **kwargs)
else:
return (None if method.body is None
else method.body.execute(context))
if (not isinstance(method.body, specs.FunctionDefinition) or
not method.body.meta.get(constants.META_NO_TRACE)):
with self._log_method(context, args, kwargs) as log:
result = call()
log(result)
return result
else:
return call()
def parse_object_definition(spec, scope_type, context):
if not isinstance(spec, yaqlutils.MappingType):
return None
if context:
spec = evaluate(spec, context, freeze=False)
else:
spec = spec.copy()
system_data = None
type_obj = None
props = {}
ns_resolver = scope_type.namespace_resolver if scope_type else None
for key in spec:
if (ns_resolver and ns_resolver.is_typename(key, False) or
isinstance(key, (dsl_types.MuranoTypeReference,
dsl_types.MuranoType))):
type_obj = resolve_type(key, scope_type)
props = spec.pop(key) or {}
system_data = spec
break
if system_data is None:
props = spec
if '?' in spec:
system_data = spec.pop('?')
obj_type = system_data.get('type')
if isinstance(obj_type, dsl_types.MuranoTypeReference):
type_obj = obj_type.type
elif isinstance(obj_type, dsl_types.MuranoType):
type_obj = obj_type
elif obj_type:
version_spec = parse_version_spec(
system_data.get('classVersion'))
package_loader = get_package_loader()
if 'package' in system_data:
package = package_loader.load_package(
system_data['package'], version_spec)
else:
package = package_loader.load_class_package(
obj_type, version_spec)
type_obj = package.find_class(obj_type, False)
else:
system_data = {}
return {
'type': type_obj,
'properties': yaqlutils.filter_parameters_dict(props),
'id': system_data.get('id'),
'name': system_data.get('name'),
'extra': {
key: value for key, value in six.iteritems(system_data)
if key.startswith('_')
}
}
def call_func(context, op_dot, base, name, args, kwargs,
receiver=utils.NO_VALUE):
if isinstance(receiver, (dsl_types.MuranoObject,
dsl_types.MuranoTypeReference)):
kwargs = utils.filter_parameters_dict(kwargs)
args += tuple(
expressions.MappingRuleExpression(expressions.KeywordConstant(key),
value)
for key, value in six.iteritems(kwargs))
function = expressions.Function(name, *args)
return op_dot(context, receiver, function)
else:
return base(context, name, args, kwargs, receiver)
def call_func(context,
op_dot,
base,
name,
args,
kwargs,
receiver=utils.NO_VALUE):
if isinstance(receiver,
(dsl_types.MuranoObject, dsl_types.MuranoTypeReference)):
kwargs = utils.filter_parameters_dict(kwargs)
args += tuple(
expressions.MappingRuleExpression(expressions.KeywordConstant(
key), value) for key, value in kwargs.items())
function = expressions.Function(name, *args)
return op_dot(context, receiver, function)
else:
return base(context, name, args, kwargs, receiver)
def call_func(context, engine, name, args, kwargs, receiver=utils.NO_VALUE):
""":yaql:call
Evaluates function name with specified args and kwargs and returns the
result.
:signature: call(name, args, kwargs)
:arg name: name of callable
:argType name: string
:arg args: sequence of items to be used for calling
:argType args: sequence
:arg kwargs: dictionary with kwargs to be used for calling
:argType kwargs: mapping
:returnType: any (callable return type)
.. code::
yaql> call(let, [1, 2], {a => 3, b => 4}) -> $1 + $a + $2 + $b
10
"""
return context(name, engine,
receiver)(*args, **utils.filter_parameters_dict(kwargs))
def _canonize_parameters(arguments_scheme, args, kwargs,
method_name, receiver):
arg_names = list(arguments_scheme.keys())
parameter_values = {}
varargs_arg = None
vararg_values = []
kwargs_arg = None
kwarg_values = {}
for name, definition in six.iteritems(arguments_scheme):
if definition.usage == dsl_types.MethodArgumentUsages.VarArgs:
varargs_arg = name
parameter_values[name] = vararg_values
elif definition.usage == dsl_types.MethodArgumentUsages.KwArgs:
kwargs_arg = name
parameter_values[name] = kwarg_values
for i, arg in enumerate(args):
name = None if i >= len(arg_names) else arg_names[i]
if name is None or name in (varargs_arg, kwargs_arg):
if varargs_arg:
vararg_values.append(arg)
else:
raise yaql_exceptions.NoMatchingMethodException(
method_name, receiver)
else:
parameter_values[name] = arg
for name, value in six.iteritems(utils.filter_parameters_dict(kwargs)):
if name in arguments_scheme and name not in (
varargs_arg, kwargs_arg):
parameter_values[name] = value
elif kwargs_arg:
kwarg_values[name] = value
else:
raise yaql_exceptions.NoMatchingMethodException(
method_name, receiver)
return tuple(), parameter_values
def _canonize_parameters(arguments_scheme, args, kwargs,
method_name, receiver):
arg_names = list(arguments_scheme.keys())
parameter_values = {}
varargs_arg = None
vararg_values = []
kwargs_arg = None
kwarg_values = {}
for name, definition in arguments_scheme.items():
if definition.usage == dsl_types.MethodArgumentUsages.VarArgs:
varargs_arg = name
parameter_values[name] = vararg_values
elif definition.usage == dsl_types.MethodArgumentUsages.KwArgs:
kwargs_arg = name
parameter_values[name] = kwarg_values
for i, arg in enumerate(args):
name = None if i >= len(arg_names) else arg_names[i]
if name is None or name in (varargs_arg, kwargs_arg):
if varargs_arg:
vararg_values.append(arg)
else:
raise yaql_exceptions.NoMatchingMethodException(
method_name, receiver)
else:
parameter_values[name] = arg
for name, value in utils.filter_parameters_dict(kwargs).items():
if name in arguments_scheme and name not in (
varargs_arg, kwargs_arg):
parameter_values[name] = value
elif kwargs_arg:
kwarg_values[name] = value
else:
raise yaql_exceptions.NoMatchingMethodException(
method_name, receiver)
return tuple(), parameter_values
def new_from_dict(type_name, context, parameters, owner=None, object_name=None, extra=None):
return new(context, type_name, owner, object_name, extra, **utils.filter_parameters_dict(parameters))
def invoke_method(self, method, this, context, args, kwargs,
skip_stub=False):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
kwargs = utils.filter_parameters_dict(kwargs)
runtime_version = method.declaring_type.package.runtime_version
yaql_engine = yaql_integration.choose_yaql_engine(runtime_version)
if context is None or not skip_stub:
actions_only = context is None and not method.name.startswith('.')
method_context = self.create_method_context(
self.create_object_context(this, context), method)
method_context[constants.CTX_SKIP_FRAME] = True
method_context[constants.CTX_ACTIONS_ONLY] = actions_only
stub = method.static_stub if isinstance(
this, dsl_types.MuranoType) else method.instance_stub
if stub is None:
raise ValueError(
'Method {0} cannot be called on receiver {1}'.format(
method, this))
real_this = this.real_this if isinstance(
this, dsl_types.MuranoObject) else this.get_reference()
return stub(yaql_engine, method_context, real_this)(
*args, **kwargs)
if context[constants.CTX_ACTIONS_ONLY] and not method.is_action:
raise dsl_exceptions.MethodNotExposed(
'{0} is not an action'.format(method.name))
if method.is_static:
obj_context = self.create_object_context(
method.declaring_type, context)
else:
obj_context = self.create_object_context(this, context)
context = self.create_method_context(obj_context, method)
if isinstance(this, dsl_types.MuranoObject):
this = this.real_this
if method.arguments_scheme is not None:
args, kwargs = self._canonize_parameters(
method.arguments_scheme, args, kwargs, method.name, this)
this_lock = this
arg_values_for_lock = {}
method_meta = [m for m in method.get_meta(context)
if m.type.name == ('io.murano.metadata.'
'engine.Synchronize')]
if method_meta:
method_meta = method_meta[0]
if method_meta:
if not method_meta.get_property('onThis', context):
this_lock = None
for arg_name in method_meta.get_property('onArgs', context):
arg_val = kwargs.get(arg_name)
if arg_val is not None:
arg_values_for_lock[arg_name] = arg_val
arg_values_for_lock = utils.filter_parameters_dict(arg_values_for_lock)
with self._acquire_method_lock(method, this_lock, arg_values_for_lock):
for i, arg in enumerate(args, 2):
context[str(i)] = arg
for key, value in six.iteritems(kwargs):
context[key] = value
def call():
if isinstance(method.body, specs.FunctionDefinition):
if isinstance(this, dsl_types.MuranoType):
native_this = this.get_reference()
else:
native_this = dsl.MuranoObjectInterface(this.cast(
method.declaring_type))
return method.body(
yaql_engine, context, native_this)(*args, **kwargs)
else:
context[constants.CTX_NAMES_SCOPE] = \
method.declaring_type
return (None if method.body is None
else method.body.execute(context))
if (not isinstance(method.body, specs.FunctionDefinition) or
not method.body.meta.get(constants.META_NO_TRACE)):
with self._log_method(context, args, kwargs) as log:
result = call()
log(result)
return result
else:
return call()
def call_func(context, engine, name, args, kwargs, receiver=utils.NO_VALUE):
return context(name, engine, receiver)(
*args, **utils.filter_parameters_dict(kwargs))
def _invoke_method(self,
method,
this,
context,
args,
kwargs,
skip_stub=False):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
kwargs = utils.filter_parameters_dict(kwargs)
runtime_version = method.declaring_type.package.runtime_version
yaql_engine = yaql_integration.choose_yaql_engine(runtime_version)
if context is None or not skip_stub:
actions_only = context is None and not method.name.startswith('.')
method_context = self.create_method_context(
self.create_object_context(this, context), method)
method_context[constants.CTX_SKIP_FRAME] = True
method_context[constants.CTX_ACTIONS_ONLY] = actions_only
stub = method.static_stub if isinstance(
this, dsl_types.MuranoType) else method.instance_stub
if stub is None:
raise ValueError(
'Method {0} cannot be called on receiver {1}'.format(
method, this))
return stub(yaql_engine, method_context, this.real_this)(*args,
**kwargs)
if (context[constants.CTX_ACTIONS_ONLY]
and method.usage != dsl_types.MethodUsages.Action):
raise Exception('{0} is not an action'.format(method.name))
if method.is_static:
obj_context = self.create_object_context(method.declaring_type,
context)
else:
obj_context = self.create_object_context(this, context)
context = self.create_method_context(obj_context, method)
if isinstance(this, dsl_types.MuranoObject):
this = this.real_this
if method.arguments_scheme is not None:
args, kwargs = self._canonize_parameters(method.arguments_scheme,
args, kwargs)
with self._acquire_method_lock(method, this):
for i, arg in enumerate(args, 2):
context[str(i)] = arg
for key, value in six.iteritems(kwargs):
context[key] = value
def call():
if isinstance(method.body, specs.FunctionDefinition):
if isinstance(this, dsl_types.MuranoType):
native_this = this.get_reference()
else:
native_this = dsl.MuranoObjectInterface(
this.cast(method.declaring_type), self)
return method.body(yaql_engine, context,
native_this)(*args, **kwargs)
else:
context[constants.CTX_NAMES_SCOPE] = \
method.declaring_type
return (None if method.body is None else
method.body.execute(context))
if (not isinstance(method.body, specs.FunctionDefinition)
or not method.body.meta.get(constants.META_NO_TRACE)):
with self._log_method(context, args, kwargs) as log:
result = call()
log(result)
return result
else:
return call()
def invoke_method(self, method, this, context, args, kwargs,
skip_stub=False, invoke_action=True):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
kwargs = utils.filter_parameters_dict(kwargs)
runtime_version = method.declaring_type.package.runtime_version
yaql_engine = yaql_integration.choose_yaql_engine(runtime_version)
if context is None or not skip_stub:
actions_only = (context is None and not method.name.startswith('.')
and invoke_action)
method_context = self.create_method_context(
self.create_object_context(this, context), method)
method_context[constants.CTX_SKIP_FRAME] = True
method_context[constants.CTX_ACTIONS_ONLY] = actions_only
stub = method.static_stub if isinstance(
this, dsl_types.MuranoType) else method.instance_stub
if stub is None:
raise ValueError(
'Method {0} cannot be called on receiver {1}'.format(
method, this))
real_this = this.real_this if isinstance(
this, dsl_types.MuranoObject) else this.get_reference()
return stub(yaql_engine, method_context, real_this)(
*args, **kwargs)
if context[constants.CTX_ACTIONS_ONLY] and not method.is_action:
raise dsl_exceptions.MethodNotExposed(
'{0} is not an action'.format(method.name))
if method.is_static:
obj_context = self.create_object_context(
method.declaring_type, context)
else:
obj_context = self.create_object_context(this, context)
context = self.create_method_context(obj_context, method)
if isinstance(this, dsl_types.MuranoObject):
if this.destroyed:
raise dsl_exceptions.ObjectDestroyedError(this)
this = this.real_this
if method.arguments_scheme is not None:
args, kwargs = self._canonize_parameters(
method.arguments_scheme, args, kwargs, method.name, this)
this_lock = this
arg_values_for_lock = {}
method_meta = [m for m in method.get_meta(context)
if m.type.name == ('io.murano.metadata.'
'engine.Synchronize')]
if method_meta:
method_meta = method_meta[0]
if method_meta:
if not method_meta.get_property('onThis', context):
this_lock = None
for arg_name in method_meta.get_property('onArgs', context):
arg_val = kwargs.get(arg_name)
if arg_val is not None:
arg_values_for_lock[arg_name] = arg_val
arg_values_for_lock = utils.filter_parameters_dict(arg_values_for_lock)
with self._acquire_method_lock(method, this_lock, arg_values_for_lock):
for i, arg in enumerate(args, 2):
context[str(i)] = arg
for key, value in kwargs.items():
context[key] = value
def call():
if isinstance(method.body, specs.FunctionDefinition):
if isinstance(this, dsl_types.MuranoType):
native_this = this.get_reference()
else:
native_this = dsl.MuranoObjectInterface(this.cast(
method.declaring_type))
return method.body(
yaql_engine, context, native_this)(*args, **kwargs)
else:
context[constants.CTX_NAMES_SCOPE] = \
method.declaring_type
return (None if method.body is None
else method.body.execute(context))
if (not isinstance(method.body, specs.FunctionDefinition) or
not method.body.meta.get(constants.META_NO_TRACE)):
with self._log_method(context, args, kwargs) as log:
result = call()
log(result)
return result
else:
return call()
