def property_set_value(context, property_, object_, value):
if object_ is None:
helpers.get_executor().set_static_property(
property_.declaring_type,
name=property_.name, value=value, context=context)
else:
object_.cast(property_.declaring_type).set_property(
name=property_.name, value=value, context=context)
def extension_payload(__context, __receiver, *args, **kwargs):
executor = helpers.get_executor(__context)
args = tuple(dsl.to_mutable(arg, engine) for arg in args)
kwargs = dsl.to_mutable(kwargs, engine)
return helpers.evaluate(murano_method.invoke(
executor, murano_method.declaring_type,
(__receiver,) + args, kwargs, __context, True), __context)
def op_dot(context, sender, expr, operator):
executor = helpers.get_executor(context)
type_context = executor.context_manager.create_class_context(sender.type)
obj_context = executor.context_manager.create_object_context(sender)
ctx2 = linked_context.link(linked_context.link(context, type_context),
obj_context)
return operator(ctx2, sender, expr)
def op_dot(context, receiver, expr, operator):
executor = helpers.get_executor()
type_context = executor.context_manager.create_type_context(receiver.type)
obj_context = executor.context_manager.create_object_context(receiver)
ctx2 = helpers.link_contexts(helpers.link_contexts(context, type_context),
obj_context)
return operator(ctx2, receiver, expr)
def __init__(self, murano_class, owner, object_id=None, name=None,
known_classes=None, this=None, metadata=None):
self._initialized = False
self._destroyed = False
if known_classes is None:
known_classes = {}
if this is None:
self._owner = owner
self._object_id = object_id or helpers.generate_id()
self._type = murano_class
self._properties = {}
self._parents = {}
self._this = this
self._name = name
self._extension = None
self._executor = helpers.weak_ref(helpers.get_executor())
self._config = murano_class.package.get_class_config(
murano_class.name)
self._metadata = metadata
if not isinstance(self._config, dict):
self._config = {}
known_classes[murano_class.name] = self
for parent_class in murano_class.parents:
name = parent_class.name
if name not in known_classes:
obj = MuranoObject(
parent_class, owner,
object_id=self._object_id,
known_classes=known_classes, this=self.real_this)
self._parents[name] = known_classes[name] = obj
else:
self._parents[name] = known_classes[name]
self._destruction_dependencies = []
def convert(self, value, sender, context, function_spec, engine,
*args, **kwargs):
this = helpers.get_this(context)
if isinstance(this, dsl_types.MuranoObject):
executor = helpers.get_executor(context)
return MuranoObjectInterface(this, executor)
return this
def create_stack_trace(context, include_native_frames=True):
stacktrace = yaql_integration.call_func(
context, 'new', 'io.murano.StackTrace',
includeNativeFrames=include_native_frames)
executor = helpers.get_executor(context)
return dsl.MuranoObjectInterface(
stacktrace, executor)
def convert(self, value, sender, context, function_spec, engine, *args,
**kwargs):
this = helpers.get_this(context)
if isinstance(this, dsl_types.MuranoObject):
executor = helpers.get_executor(context)
return MuranoObjectInterface(this, executor)
return this
def get_meta(self, context):
if self._meta_values is None:
executor = helpers.get_executor()
context = executor.create_type_context(
self, caller_context=context)
self._meta_values = dslmeta.merge_providers(
self, lambda cls: cls._meta, context)
return self._meta_values
def create_stack_trace(context, include_native_frames=True):
stacktrace = yaql_integration.call_func(
context,
'new',
'io.murano.StackTrace',
includeNativeFrames=include_native_frames)
executor = helpers.get_executor(context)
return dsl.MuranoObjectInterface(stacktrace, executor)
def op_dot(context, sender, expr, operator):
executor = helpers.get_executor(context)
type_context = executor.context_manager.create_class_context(sender.type)
obj_context = executor.context_manager.create_object_context(sender)
ctx2 = linked_context.link(
linked_context.link(context, type_context),
obj_context)
return operator(ctx2, sender, expr)
def new(__context, __type_name, __owner=None, __object_name=None, __extra=None, **parameters):
object_store = helpers.get_object_store(__context)
executor = helpers.get_executor(__context)
new_context = __context.create_child_context()
for key, value in six.iteritems(parameters):
if utils.is_keyword(key):
new_context[key] = value
return __type_name.murano_class.new(__owner, object_store, executor, name=__object_name)(new_context, **parameters)
def get_meta(self, context):
if self._meta is None:
executor = helpers.get_executor(context)
store = object_store.ObjectStore(executor)
self._meta = list(map(
lambda x: x(context, store),
self._meta_factories))
return self._meta
def op_dot(context, receiver, expr, operator):
executor = helpers.get_executor()
type_context = executor.context_manager.create_type_context(receiver.type)
obj_context = executor.context_manager.create_object_context(receiver)
ctx2 = helpers.link_contexts(
helpers.link_contexts(context, type_context),
obj_context)
return operator(ctx2, receiver, expr)
def get_meta(self, context):
if self._meta_values is None:
executor = helpers.get_executor()
context = executor.create_type_context(
self, caller_context=context)
self._meta_values = dslmeta.merge_providers(
self, lambda cls: cls._meta, context)
return self._meta_values
def dump(obj, serialization_type=serializer.DumpTypes.Serializable,
ignore_upcasts=True):
if serialization_type not in serializer.DumpTypes.All:
raise ValueError('Invalid Serialization Type')
executor = helpers.get_executor()
if ignore_upcasts:
obj = obj.real_this
return serializer.serialize(obj, executor, serialization_type)
def invoke(context, this, *args):
try:
executor = helpers.get_executor(context)
murano_class = helpers.get_type(context)
return executor.invoke_method(name, this, context, murano_class, *args)
except exceptions.NoMethodFound:
raise yaql.exceptions.YaqlExecutionException()
except exceptions.AmbiguousMethodName:
raise yaql.exceptions.YaqlExecutionException()
def __getattr__(self, item):
executor = self.__executor or helpers.get_executor()
def func(*args, **kwargs):
self._insert_instruction()
return self.__object.type.invoke(
item, executor, self.__object, args, kwargs,
helpers.get_context())
return func
def dump(obj,
serialization_type=dsl_types.DumpTypes.Serializable,
ignore_upcasts=True):
if serialization_type not in dsl_types.DumpTypes.All:
raise ValueError('Invalid Serialization Type')
executor = helpers.get_executor()
if ignore_upcasts:
obj = obj.real_this
return serializer.serialize(obj, executor, serialization_type)
def invoke(context, this, *args):
try:
executor = helpers.get_executor(context)
murano_class = helpers.get_type(context)
return executor.invoke_method(name, this, context, murano_class,
*args)
except exceptions.NoMethodFound:
raise yaql.exceptions.YaqlExecutionException()
except exceptions.AmbiguousMethodName:
raise yaql.exceptions.YaqlExecutionException()
def __getattr__(self, item):
executor = self.__executor or helpers.get_executor()
def func(*args, **kwargs):
self._insert_instruction()
return self.__object.type.invoke(item, executor, self.__object,
args, kwargs,
helpers.get_context())
return func
def new(__context, __type_name, __owner=None, __object_name=None, __extra=None,
**parameters):
object_store = helpers.get_object_store(__context)
executor = helpers.get_executor(__context)
new_context = __context.create_child_context()
for key, value in six.iteritems(parameters):
if utils.is_keyword(key):
new_context[key] = value
return __type_name.type.new(
__owner, object_store, executor, name=__object_name)(
new_context, **parameters)
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(
utils.FrozenDict(
itertools.chain(six.iteritems(src), ((key, value), ))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, context['#root_context'])
elif isinstance(
src,
(dsl_types.MuranoTypeReference, dsl_types.MuranoType)):
if isinstance(src, dsl_types.MuranoTypeReference):
mc = src.type
else:
mc = src
helpers.get_executor().set_static_property(
mc, key, value, context['#root_context'])
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
def validate(self, value, this, owner, context, default=None):
if default is None:
default = self.default
executor = helpers.get_executor(context)
if isinstance(this, dsl_types.MuranoClass):
return self._contract(
value, executor.create_object_context(this),
None, None, default)
else:
return self._contract(
value, executor.create_object_context(
this.cast(self._container_class())),
this, owner, default)
def transform(self, value, this, owner, context, default=None):
if default is None:
default = self.default
executor = helpers.get_executor(context)
if isinstance(this, dsl_types.MuranoType):
return self._contract.transform(
value, executor.create_object_context(this),
None, None, default, helpers.get_type(context))
else:
return self._contract.transform(
value, executor.create_object_context(
this.cast(self._container_type())),
this, owner, default, helpers.get_type(context))
def get_meta(self, context):
def meta_producer(cls):
method = cls.methods.get(self.name)
if method is None:
return None
return method._meta
if self._meta_values is None:
executor = helpers.get_executor(context)
context = executor.create_type_context(
self.declaring_type, caller_context=context)
self._meta_values = meta.merge_providers(
self.declaring_type, meta_producer, context)
return self._meta_values
def get_meta(self, context):
def meta_producer(cls):
method = cls.methods.get(self.name)
if method is None:
return None
return method._meta
if self._meta_values is None:
executor = helpers.get_executor()
context = executor.create_type_context(self.declaring_type,
caller_context=context)
self._meta_values = meta.merge_providers(self.declaring_type,
meta_producer, context)
return self._meta_values
def invoke(self, this, args, kwargs, context=None, skip_stub=False):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
if this and not self.declaring_type.is_compatible(this):
raise Exception("'this' must be of compatible type")
if not this and not self.is_static:
raise Exception("A class instance is required")
if isinstance(this, dsl_types.MuranoObject):
this = this.cast(self.declaring_type)
else:
this = self.declaring_type
executor = helpers.get_executor()
return executor.invoke_method(
self, this, context, args, kwargs, skip_stub)
def invoke(self, this, args, kwargs, context=None, skip_stub=False):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
if this and not self.declaring_type.is_compatible(this):
raise Exception("'this' must be of compatible type")
if not this and not self.is_static:
raise Exception("A class instance is required")
if isinstance(this, dsl_types.MuranoObject):
this = this.cast(self.declaring_type)
else:
this = self.declaring_type
executor = helpers.get_executor()
return executor.invoke_method(self, this, context, args, kwargs,
skip_stub)
def load(self, value, owner, context, defaults=None):
if value is None:
return None
if '?' not in value or 'type' not in value['?']:
raise ValueError()
system_key = value['?']
object_id = system_key['id']
obj_type = system_key['type']
class_obj = self._class_loader.get_class(obj_type)
if not class_obj:
raise ValueError()
if object_id in self._store:
obj = self._store[object_id]
else:
obj = class_obj.new(owner,
self,
context=context,
object_id=object_id,
defaults=defaults)
self._store[object_id] = obj
self._designer_attributes_store[object_id] = \
ObjectStore._get_designer_attributes(system_key)
argspec = inspect.getargspec(obj.initialize).args
if '_context' in argspec:
value['_context'] = context
if '_parent' in argspec:
value['_owner'] = owner
try:
if owner is None:
self._initializing = True
obj.initialize(**value)
if owner is None:
self._initializing = False
obj.initialize(**value)
finally:
if owner is None:
self._initializing = False
if not self.initializing:
executor = helpers.get_executor(context)
methods = obj.type.find_all_methods('initialize')
methods.reverse()
for method in methods:
method.invoke(executor, obj, {})
return obj
def set_property(self, name, value, context=None):
if self is not self.real_this:
return self.real_this.set_property(name, value, context)
start_type, derived = self.__type, False
caller_class = None if not context else helpers.get_type(context)
if caller_class is not None and caller_class.is_compatible(self):
start_type, derived = caller_class, True
declared_properties = start_type.find_properties(
lambda p: p.name == name)
if context is None:
context = helpers.get_executor().create_object_context(self)
if len(declared_properties) > 0:
values_to_assign = []
classes_for_static_properties = []
first = True
for spec in self._list_properties(name):
if (caller_class is not None and
not helpers.are_property_modifications_allowed(context)
and
(spec.usage not in dsl_types.PropertyUsages.Writable
or not derived)):
raise exceptions.NoWriteAccessError(name)
if spec.usage == dsl_types.PropertyUsages.Static:
classes_for_static_properties.append(spec.declaring_type)
else:
default = self.__config.get(name, spec.default)
obj = self.cast(spec.declaring_type)
res = spec.transform(value,
self.real_this,
self.real_this,
context,
default=default)
if first:
value = res
first = False
values_to_assign.append((obj, res))
for obj, value in values_to_assign:
obj.__properties[name] = value
for cls in classes_for_static_properties:
cls.set_property(name, value, context)
elif derived:
obj = self.cast(caller_class)
obj.__properties[name] = value
else:
raise exceptions.PropertyWriteError(name, start_type)
def load(self, value, parent, context, defaults=None):
#tmp_store = ObjectStore(self._class_loader, self)
if value is None:
return None
if '?' not in value or 'type' not in value['?']:
raise ValueError()
system_key = value['?']
object_id = system_key['id']
obj_type = system_key['type']
class_obj = self._class_loader.get_class(obj_type)
if not class_obj:
raise ValueError()
if object_id in self._store:
obj = self._store[object_id]
else:
obj = class_obj.new(parent, self, context=context,
object_id=object_id, defaults=defaults)
self._store[object_id] = obj
self._designer_attributes_store[object_id] = \
ObjectStore._get_designer_attributes(system_key)
argspec = inspect.getargspec(obj.initialize).args
if '_context' in argspec:
value['_context'] = context
if '_parent' in argspec:
value['_parent'] = parent
try:
if parent is None:
self._initializing = True
obj.initialize(**value)
if parent is None:
self._initializing = False
obj.initialize(**value)
finally:
if parent is None:
self._initializing = False
if not self.initializing:
executor = helpers.get_executor(context)
methods = obj.type.find_all_methods('initialize')
methods.reverse()
for method in methods:
method.invoke(executor, obj, {})
return obj
def inject_method_with_str(context, target, target_method, mock_object,
mock_name):
ctx_manager = helpers.get_executor().context_manager
current_class = helpers.get_type(context)
mock_func = current_class.find_single_method(mock_name)
original_class = target.type
original_function = original_class.find_single_method(target_method)
result_fd = original_function.instance_stub.clone()
def payload_adapter(__context, __sender, *args, **kwargs):
return mock_func.invoke(mock_object, args, kwargs, __context, True)
result_fd.payload = payload_adapter
existing_mocks = ctx_manager.class_mock_ctx.setdefault(
original_class.name, [])
existing_mocks.append(result_fd)
def inject_method_with_str(context, target, target_method,
mock_object, mock_name):
ctx_manager = helpers.get_executor().context_manager
current_class = helpers.get_type(context)
mock_func = current_class.find_single_method(mock_name)
original_class = target.type
original_function = original_class.find_single_method(target_method)
result_fd = original_function.instance_stub.clone()
def payload_adapter(__context, __sender, *args, **kwargs):
return mock_func.invoke(
mock_object, args, kwargs, __context, True)
result_fd.payload = payload_adapter
existing_mocks = ctx_manager.class_mock_ctx.setdefault(
original_class.name, [])
existing_mocks.append(result_fd)
def inject_method_with_yaql_expr(context, target, target_method, expr):
ctx_manager = helpers.get_executor(context).context_manager
original_class = target.type
original_function = original_class.find_single_method(target_method)
result_fd = original_function.instance_stub.clone()
def payload_adapter(__super, __context, __sender, *args, **kwargs):
new_context = context.create_child_context()
new_context[constants.CTX_ORIGINAL_CONTEXT] = __context
mock_obj = context[constants.CTX_THIS]
new_context.register_function(lambda: __super(*args, **kwargs),
name='originalMethod')
return expr(new_context, mock_obj, *args, **kwargs)
result_fd.payload = payload_adapter
result_fd.insert_parameter('__super', yaqltypes.Super())
existing_mocks = ctx_manager.class_mock_ctx.setdefault(
original_class.name, [])
existing_mocks.append(result_fd)
def getter(src):
if isinstance(src, utils.MappingType):
return src.get(key, {})
elif isinstance(src, dsl_types.MuranoObject):
try:
return src.get_property(key, context['#root_context'])
except exceptions.UninitializedPropertyAccessError:
return {}
elif isinstance(
src,
(dsl_types.MuranoTypeReference, dsl_types.MuranoType)):
if isinstance(src, dsl_types.MuranoTypeReference):
mc = src.type
else:
mc = src
return helpers.get_executor().get_static_property(
mc, key, context['#root_context'])
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
def inject_method_with_yaql_expr(context, target, target_method, expr):
ctx_manager = helpers.get_executor().context_manager
original_class = target.type
original_function = original_class.find_single_method(target_method)
result_fd = original_function.instance_stub.clone()
def payload_adapter(__super, __context, __sender, *args, **kwargs):
new_context = context.create_child_context()
new_context[constants.CTX_ORIGINAL_CONTEXT] = __context
mock_obj = context[constants.CTX_THIS]
new_context.register_function(lambda: __super(*args, **kwargs),
name='originalMethod')
return expr(new_context, mock_obj, *args, **kwargs)
result_fd.payload = payload_adapter
result_fd.insert_parameter('__super', yaqltypes.Super())
existing_mocks = ctx_manager.class_mock_ctx.setdefault(
original_class.name, [])
existing_mocks.append(result_fd)
def set_property(self, name, value, context=None):
start_type, derived = self.__type, False
caller_class = None if not context else helpers.get_type(context)
if caller_class is not None and caller_class.is_compatible(self):
start_type, derived = caller_class, True
declared_properties = start_type.find_properties(
lambda p: p.name == name)
if context is None:
context = helpers.get_executor().create_object_context(self)
if len(declared_properties) > 0:
declared_properties = self.type.find_properties(
lambda p: p.name == name)
values_to_assign = []
classes_for_static_properties = []
for spec in declared_properties:
if (caller_class is not None and not
helpers.are_property_modifications_allowed(context) and
(spec.usage not in dsl_types.PropertyUsages.Writable or
not derived)):
raise exceptions.NoWriteAccessError(name)
if spec.usage == dsl_types.PropertyUsages.Static:
classes_for_static_properties.append(spec.declaring_type)
else:
default = self.__config.get(name, spec.default)
obj = self.cast(spec.declaring_type)
values_to_assign.append((obj, spec.transform(
value, self.real_this,
self.real_this, context, default=default)))
for obj, value in values_to_assign:
obj.__properties[name] = value
for cls in classes_for_static_properties:
cls.set_property(name, value, context)
elif derived:
obj = self.cast(caller_class)
obj.__properties[name] = value
else:
raise exceptions.PropertyWriteError(name, start_type)
def payload(__context, __sender, *args, **kwargs):
executor = helpers.get_executor(__context)
args = tuple(dsl.to_mutable(arg, engine) for arg in args)
kwargs = dsl.to_mutable(kwargs, engine)
return murano_method.invoke(executor, __sender, args, kwargs,
__context, True)
def get_meta(self, context):
if six.callable(self._meta):
executor = helpers.get_executor()
context = executor.create_package_context(self)
self._meta = self._meta().get_meta(context)
return self._meta
def op_dot_static(context, sender, expr, operator):
executor = helpers.get_executor(context)
type_context = executor.context_manager.create_class_context(sender.murano_class)
ctx2 = helpers.link_contexts(context, type_context)
return operator(ctx2, None, expr)
def load(self, model):
exc = helpers.get_executor()
return exc.load(model)
def get_meta(self, context):
executor = helpers.get_executor(context)
context = executor.create_type_context(
self.murano_method.declaring_type, caller_context=context)
return self._meta.get_meta(context)
def get_meta(self, context):
if six.callable(self._meta):
executor = helpers.get_executor(context)
context = executor.create_package_context(self)
self._meta = self._meta().get_meta(context)
return self._meta
def method_invoke(context, method, __object, *args, **kwargs):
executor = helpers.get_executor(context)
return method.invoke(executor, __object, args, kwargs, context)
def load(self, model):
exc = helpers.get_executor()
return exc.load(model)
def payload(__context, __receiver, *args, **kwargs):
executor = helpers.get_executor(__context)
return murano_method.invoke(
executor, murano_method.declaring_type,
(__receiver,) + args, kwargs, __context, True)
def property_get_value(context, property_, object_):
if object_ is None:
return helpers.get_executor().get_static_property(
property_.declaring_type, name=property_.name, context=context)
return object_.cast(property_.declaring_type).get_property(
name=property_.name, context=context)
def op_dot_static(context, receiver, expr, operator):
executor = helpers.get_executor(context)
type_context = executor.context_manager.create_type_context(
receiver.type)
ctx2 = helpers.link_contexts(context, type_context)
return operator(ctx2, receiver, expr)
def obj_attribution_static(context, cls, property_name):
return helpers.get_executor().get_static_property(cls.type, property_name,
context)
def attributes(self):
executor = helpers.get_executor()
return executor.attribute_store
def payload(__context, __sender, *args, **kwargs):
executor = helpers.get_executor(__context)
return murano_method.invoke(
executor, __sender, args, kwargs, __context, True)
def payload(__context, __sender, *args, **kwargs):
executor = helpers.get_executor(__context)
args = tuple(dsl.to_mutable(arg, engine) for arg in args)
kwargs = dsl.to_mutable(kwargs, engine)
return helpers.evaluate(murano_method.invoke(
executor, __sender, args, kwargs, __context, True), __context)
def payload_adapter(__context, __sender, *args, **kwargs):
executor = helpers.get_executor(__context)
return mock_func.invoke(
executor, mock_object, args, kwargs, __context, True)
def initialize(self, context, object_store, params):
if self.__initialized:
return
for property_name in self.__type.properties:
spec = self.__type.get_property(property_name)
if spec.usage == typespec.PropertyUsages.Config:
if property_name in self.__config:
property_value = self.__config[property_name]
else:
property_value = dsl.NO_VALUE
self.set_property(property_name, property_value)
init = self.type.methods.get('.init')
used_names = set()
names = set(self.__type.properties)
if init:
names.update(init.arguments_scheme.iterkeys())
last_errors = len(names)
init_args = {}
while True:
errors = 0
for property_name in names:
if init and property_name in init.arguments_scheme:
spec = init.arguments_scheme[property_name]
is_init_arg = True
else:
spec = self.__type.get_property(property_name)
is_init_arg = False
if property_name in used_names:
continue
if spec.usage == typespec.PropertyUsages.Config:
used_names.add(property_name)
continue
if spec.usage == typespec.PropertyUsages.Runtime:
if not spec.has_default:
used_names.add(property_name)
continue
property_value = dsl.NO_VALUE
else:
property_value = params.get(property_name, dsl.NO_VALUE)
try:
if is_init_arg:
init_args[property_name] = property_value
else:
self.set_property(property_name, property_value)
used_names.add(property_name)
except exceptions.UninitializedPropertyAccessError:
errors += 1
except exceptions.ContractViolationException:
if spec.usage != typespec.PropertyUsages.Runtime:
raise
if not errors:
break
if errors >= last_errors:
raise exceptions.CircularExpressionDependenciesError()
last_errors = errors
executor = helpers.get_executor(context)
if not object_store.initializing and self.__extension is None:
method = self.type.methods.get('__init__')
if method:
filtered_params = yaql_integration.filter_parameters(
method.body, **params)
self.__extension = method.invoke(
executor, self, filtered_params[0],
filtered_params[1], context)
for parent in self.__parents.values():
parent.initialize(context, object_store, params)
if not object_store.initializing and init:
context[constants.CTX_ARGUMENT_OWNER] = self.real_this
init.invoke(executor, self.real_this, (), init_args, context)
self.__initialized = True
def payload(__context, __sender, *args, **kwargs):
executor = helpers.get_executor(__context)
return murano_method.invoke(executor, __sender, args, kwargs,
__context, True)
def attributes(self):
executor = helpers.get_executor()
return executor.attribute_store
def method_invoke(context, method, __object, *args, **kwargs):
executor = helpers.get_executor(context)
return method.invoke(executor, __object, args, kwargs, context)
