class ResourceManager(object):
def __init__(self, context):
murano_class = helpers.get_type(helpers.get_caller_context(context))
self._package = murano_class.package
@staticmethod
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
@specs.inject('receiver', yaqltypes.Receiver())
def string(receiver, name, owner=None):
path = ResourceManager._get_package(owner, receiver).get_resource(name)
with open(path) as file:
return file.read()
@classmethod
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
@specs.inject('receiver', yaqltypes.Receiver())
def json(cls, receiver, name, owner=None):
return jsonlib.loads(cls.string(receiver, name, owner))
@classmethod
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
@specs.inject('receiver', yaqltypes.Receiver())
def yaml(cls, receiver, name, owner=None):
return yamllib.load(cls.string(receiver, name, owner),
Loader=yaml_loader)
@staticmethod
def _get_package(owner, receiver):
if owner is None:
if isinstance(receiver, dsl_types.MuranoObjectInterface):
return receiver.extension._package
murano_class = helpers.get_type(helpers.get_caller_context())
else:
murano_class = owner.type
return murano_class.package
def prepare_validate_context(root_context):
@specs.parameter('value', nullable=True)
@specs.method
def int_(value):
if value is None or isinstance(
value, int) and not isinstance(value, bool):
return value
raise exceptions.ContractViolationException()
@specs.parameter('value', nullable=True)
@specs.method
def string(value):
if value is None or isinstance(value, six.string_types):
return value
raise exceptions.ContractViolationException()
@specs.parameter('value', nullable=True)
@specs.method
def bool_(value):
if value is None or isinstance(value, bool):
return value
raise exceptions.ContractViolationException()
@specs.parameter('value', nullable=True)
@specs.method
def not_null(value):
if value is None:
raise exceptions.ContractViolationException()
return value
@specs.parameter('value', nullable=True)
@specs.parameter('predicate', yaqltypes.Lambda(with_context=True))
@specs.method
def check(value, predicate):
if predicate(root_context.create_child_context(), value):
return value
raise exceptions.ContractViolationException()
@specs.parameter('type', dsl.MuranoTypeParameter(
nullable=False, context=root_context))
@specs.parameter('value', nullable=True)
@specs.parameter('version_spec', yaqltypes.String(True))
@specs.method
def class_(value, type, version_spec=None):
if helpers.is_instance_of(
value, type.type.name,
version_spec or helpers.get_names_scope(root_context)):
return value
raise exceptions.ContractViolationException()
context = root_context.create_child_context()
context.register_function(int_)
context.register_function(string)
context.register_function(bool_)
context.register_function(check)
context.register_function(not_null)
context.register_function(class_)
return context
class SysObject(object):
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
def set_attr(self, this, context, name, value, owner=None):
if owner is None:
owner = helpers.get_type(helpers.get_caller_context(context))
attribute_store = helpers.get_attribute_store(context)
attribute_store.set(this.object, owner, name, value)
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
def get_attr(self, this, context, name, default=None, owner=None):
if owner is None:
owner = helpers.get_type(helpers.get_caller_context(context))
attribute_store = helpers.get_attribute_store(context)
result = attribute_store.get(this.object, owner, name)
return default if result is None else result
class ResourceManager(object):
def __init__(self, context):
murano_class = helpers.get_type(helpers.get_caller_context(context))
self._package = murano_class.package
@staticmethod
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
@specs.inject('receiver', yaqltypes.Receiver())
@specs.meta(constants.META_NO_TRACE, True)
def string(receiver, name, owner=None, binary=False):
path = ResourceManager._get_package(owner, receiver).get_resource(name)
mode = 'rb' if binary else 'rU'
with open(path, mode) as file:
return file.read()
@classmethod
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
@specs.inject('receiver', yaqltypes.Receiver())
@specs.meta(constants.META_NO_TRACE, True)
def json(cls, receiver, name, owner=None):
return jsonlib.loads(cls.string(receiver, name, owner))
@classmethod
@specs.parameter('owner', dsl.MuranoTypeParameter(nullable=True))
@specs.inject('receiver', yaqltypes.Receiver())
@specs.meta(constants.META_NO_TRACE, True)
def yaml(cls, receiver, name, owner=None):
# NOTE(kzaitsev, Sam Pilla) Bandit will raise an issue here,
# because it thinks that we're using an unsafe yaml.load.
# However we're passing a SafeLoader here
# (see definition of `yaml_loader` in this file; L27-30)
# so a `nosec` was added to ignore the false positive report.
return yamllib.load( # nosec
cls.string(receiver, name, owner), Loader=yaml_loader)
@staticmethod
def _get_package(owner, receiver):
if owner is None:
if isinstance(receiver, dsl_types.MuranoObjectInterface):
return receiver.extension._package
murano_class = helpers.get_type(helpers.get_caller_context())
else:
murano_class = owner.type
return murano_class.package
def _create_static_mpl_stub(murano_method):
def payload(__context, __receiver, *args, **kwargs):
return murano_method.invoke(__receiver, args, kwargs, __context, True)
fd = _create_basic_mpl_stub(murano_method, 1, payload, False)
receiver_type = dsl.MuranoTypeParameter(weakref.proxy(
murano_method.declaring_type),
resolve_strings=False)
fd.set_parameter(specs.ParameterDefinition('__receiver', receiver_type, 1))
return fd
def class_factory(context):
"""Factory for class() contract function that generates schema instead"""
@specs.parameter('schema', Schema)
@specs.parameter('name',
dsl.MuranoTypeParameter(nullable=False, context=context))
@specs.parameter('default_name',
dsl.MuranoTypeParameter(nullable=True, context=context))
@specs.parameter('version_spec', yaqltypes.String(True))
@specs.method
def class_(schema, name, default_name=None, version_spec=None):
types = 'muranoObject'
if '_notNull' not in schema.data:
types = [types] + ['null']
return Schema({'type': types, 'muranoType': name.type.name})
@specs.parameter('schema', Schema)
@specs.parameter('type_',
dsl.MuranoTypeParameter(nullable=False, context=context))
@specs.parameter('default_type',
dsl.MuranoTypeParameter(nullable=True, context=context))
@specs.parameter('version_spec', yaqltypes.String(True))
@specs.parameter('exclude_properties', yaqltypes.Sequence(nullable=True))
@specs.method
def template(schema,
type_,
exclude_properties=None,
default_type=None,
version_spec=None):
result = class_(schema, type_, default_type, version_spec)
result.data['owned'] = True
if exclude_properties:
result.data['excludedProperties'] = exclude_properties
return result
return class_, template
def _create_context(self, root_context):
@specs.parameter('name', yaqltypes.StringConstant())
def get_context_data(name):
def set_data(value):
if not name or name == '$' or name == '$this':
raise ValueError('Cannot assign to {0}'.format(name))
ctx = root_context
while constants.CTX_VARIABLE_SCOPE not in ctx:
ctx = ctx.parent
ctx[name] = value
return LhsExpression.Property(lambda: root_context[name], set_data)
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('key', yaqltypes.Keyword())
def attribution(this, key):
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, root_context)
elif isinstance(
src,
(dsl_types.MuranoTypeReference, dsl_types.MuranoType)):
if isinstance(src, dsl_types.MuranoTypeReference):
mc = src.type
else:
mc = src
mc.set_property(key, value, root_context)
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
def getter(src):
if isinstance(src, utils.MappingType):
return src.get(key, {})
elif isinstance(src, dsl_types.MuranoObject):
self._current_obj = src
self._current_obj_name = key
try:
return src.get_property(key, root_context)
except exceptions.UninitializedPropertyAccessError:
return {}
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
return LhsExpression.Property(lambda: getter(this.get()),
lambda value: setter(this, value))
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('index', yaqltypes.Lambda(with_context=True))
def indexation(this, index):
index = index(root_context)
def getter(src):
if utils.is_sequence(src):
return src[index]
else:
raise ValueError('indexation may only be applied to lists')
def setter(src_property, value):
src = src_property.get()
if utils.is_sequence(src):
src_property.set(src[:index] + (value, ) + src[index + 1:])
elif isinstance(src, utils.MappingType):
attribution(src_property, index).set(value)
if isinstance(index, int):
return LhsExpression.Property(
lambda: getter(this.get()),
lambda value: setter(this, value))
else:
return attribution(this, index)
def _wrap_type_reference(tr):
return LhsExpression.Property(lambda: tr, self._invalid_target)
@specs.parameter('prefix', yaqltypes.Keyword())
@specs.parameter('name', yaqltypes.Keyword())
@specs.name('#operator_:')
def ns_resolve(prefix, name):
return _wrap_type_reference(
yaql_functions.ns_resolve(context, prefix, name))
@specs.parameter('name', yaqltypes.Keyword())
@specs.name('#unary_operator_:')
def ns_resolve_unary(context, name):
return _wrap_type_reference(
yaql_functions.ns_resolve_unary(context, name))
@specs.parameter('object_', dsl_types.MuranoObject)
def type_(object_):
return _wrap_type_reference(yaql_functions.type_(object_))
@specs.name('type')
@specs.parameter('cls', dsl.MuranoTypeParameter())
def type_from_name(cls):
return _wrap_type_reference(cls)
context = yaql_integration.create_empty_context()
context.register_function(get_context_data, '#get_context_data')
context.register_function(attribution, '#operator_.')
context.register_function(indexation, '#indexer')
context.register_function(ns_resolve)
context.register_function(ns_resolve_unary)
context.register_function(type_)
context.register_function(type_from_name)
return context
from murano.dsl import constants
from murano.dsl import dsl
from murano.dsl import dsl_types
from murano.dsl import helpers
from murano.dsl import reflection
from murano.dsl import serializer
@specs.parameter('object_', dsl.MuranoObjectParameter())
def id_(object_):
return object_.id
@specs.parameter('object_', dsl.MuranoObjectParameter())
@specs.parameter('type__', dsl.MuranoTypeParameter())
@specs.parameter('version_spec', yaqltypes.String(True))
def cast(context, object_, type__, version_spec=None):
return helpers.cast(object_, type__.type.name, version_spec
or helpers.get_type(context))
@specs.parameter('__type_name', dsl.MuranoTypeParameter())
@specs.parameter('__extra', utils.MappingType)
@specs.parameter('__owner',
dsl.MuranoObjectParameter(nullable=True, decorate=False))
@specs.parameter('__object_name', yaqltypes.String(True))
def new(__context,
__type_name,
__owner=None,
__object_name=None,
class Template(contracts.ContractMethod):
name = 'template'
@specs.parameter('type_', dsl.MuranoTypeParameter(nullable=False,
lazy=True))
@specs.parameter('default_type',
dsl.MuranoTypeParameter(nullable=True, lazy=True))
@specs.parameter('version_spec', yaqltypes.String(True))
@specs.parameter('exclude_properties', yaqltypes.Sequence(nullable=True))
def __init__(self,
engine,
type_,
default_type=None,
version_spec=None,
exclude_properties=None):
self.type = type_(self.context).type
self.default_type = default_type(self.context) or self.type
self.version_spec = version_spec
self.exclude_properties = exclude_properties
self.engine = engine
def validate(self):
if self.value is None or helpers.is_instance_of(
self.value, self.type.name, self.version_spec
or helpers.get_names_scope(self.root_context)):
return self.value
if not isinstance(
self.value,
(dsl_types.MuranoObject, dsl_types.MuranoObjectInterface)):
raise exceptions.ContractViolationException(
'Value is not an object')
raise exceptions.ContractViolationException(
'Object of type {0} is not compatible with '
'requested type {1}'.format(self.value.type, self.type))
def check_type(self):
if isinstance(self.value, utils.MappingType):
return self.value
return self.validate()
def transform(self):
object_store = helpers.get_object_store()
if self.value is None:
return None
if isinstance(self.value, dsl_types.MuranoObject):
obj = self.value
elif isinstance(self.value, dsl_types.MuranoObjectInterface):
obj = self.value.object
elif isinstance(self.value, utils.MappingType):
passkey = utils.create_marker('<Contract Passkey>')
if self.exclude_properties:
parsed = helpers.parse_object_definition(
self.value, self.calling_type, self.context)
props = dsl.to_mutable(parsed['properties'], self.engine)
for p in self.exclude_properties:
helpers.patch_dict(props, p, passkey)
parsed['properties'] = props
value = helpers.assemble_object_definition(parsed)
else:
value = self.value
with helpers.thread_local_attribute(constants.TL_CONTRACT_PASSKEY,
passkey):
with helpers.thread_local_attribute(
constants.TL_OBJECTS_DRY_RUN, True):
obj = object_store.load(value,
self.owner,
context=self.context,
default_type=self.default_type,
scope_type=self.calling_type)
obj.__passkey__ = passkey
else:
raise exceptions.ContractViolationException(
'Value {0} cannot be represented as class {1}'.format(
helpers.format_scalar(self.value), self.type))
self.value = obj
return self.validate()
def finalize(self):
if self.value is None:
return None
object_store = helpers.get_object_store()
if object_store.initializing:
return {}
passkey = getattr(self.value, '__passkey__', None)
with helpers.thread_local_attribute(constants.TL_CONTRACT_PASSKEY,
passkey):
result = serializer.serialize(self.value.real_this,
object_store.executor,
dsl_types.DumpTypes.Mixed)
if self.exclude_properties:
for p in self.exclude_properties:
helpers.patch_dict(result, p, utils.NO_VALUE)
return result
def generate_schema(self):
result = Class.generate_class_schema(self.value, self.type)
result['owned'] = True
if self.exclude_properties:
result['excludedProperties'] = self.exclude_properties
return result
class Class(contracts.ContractMethod):
name = 'class'
@specs.parameter('name', dsl.MuranoTypeParameter(nullable=False,
lazy=True))
@specs.parameter('default_name',
dsl.MuranoTypeParameter(nullable=True, lazy=True))
@specs.parameter('version_spec', yaqltypes.String(True))
def __init__(self, name, default_name=None, version_spec=None):
self.type = name(self.context).type
self.default_type = default_name(self.context) or self.type
self.version_spec = version_spec
def validate(self):
if self.value is None or helpers.is_instance_of(
self.value, self.type.name, self.version_spec
or helpers.get_names_scope(self.root_context)):
return self.value
if not isinstance(
self.value,
(dsl_types.MuranoObject, dsl_types.MuranoObjectInterface)):
raise exceptions.ContractViolationException(
'Value is not an object')
raise exceptions.ContractViolationException(
'Object of type {0} is not compatible with '
'requested type {1}'.format(self.value.type, self.type))
def transform(self):
value = self.value
object_store = helpers.get_object_store()
if isinstance(self.value, contracts.ObjRef):
value = self.value.object_id
if value is None:
return None
if isinstance(value, dsl_types.MuranoObject):
obj = value
elif isinstance(value, dsl_types.MuranoObjectInterface):
obj = value.object
elif isinstance(value, utils.MappingType):
obj = object_store.load(value,
self.owner,
context=self.root_context,
default_type=self.default_type,
scope_type=self.calling_type)
elif isinstance(value, str):
obj = object_store.get(value)
if obj is None:
if not object_store.initializing:
raise exceptions.NoObjectFoundError(value)
else:
return contracts.ObjRef(value)
else:
raise exceptions.ContractViolationException(
'Value {0} cannot be represented as class {1}'.format(
helpers.format_scalar(value), self.type))
self.value = obj
return self.validate()
def generate_schema(self):
return self.generate_class_schema(self.value, self.type)
@staticmethod
def generate_class_schema(value, type_):
types = 'muranoObject'
if '_notNull' not in value:
types = [types] + ['null']
return {'type': types, 'muranoType': type_.name}
constext.register_function(with_original)
return constext
@specs.parameter('kwargs', yaqltypes.Lambda(with_context=True))
def with_original(context, **kwargs):
new_context = context.create_child_context()
original_context = context[constants.CTX_ORIGINAL_CONTEXT]
for k, v in six.iteritems(kwargs):
new_context['$' + k] = v(original_context)
return new_context
@specs.parameter('target',
yaqltypes.AnyOf(dsl.MuranoTypeParameter(),
dsl.MuranoObjectParameter()))
@specs.parameter('target_method', yaqltypes.String())
@specs.parameter('mock_object', dsl.MuranoObjectParameter())
@specs.parameter('mock_name', yaqltypes.String())
def inject_method_with_str(context, target, target_method, mock_object,
mock_name):
ctx_manager = helpers.get_executor(context).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 prepare_transform_context(root_context, this, owner, default,
calling_type):
@specs.parameter('value', nullable=True)
@specs.method
def int_(value):
if value is dsl.NO_VALUE:
value = default
if value is None:
return None
try:
return int(value)
except Exception:
raise exceptions.ContractViolationException(
'Value {0} violates int() contract'.format(
format_scalar(value)))
@specs.parameter('value', nullable=True)
@specs.method
def string(value):
if value is dsl.NO_VALUE:
value = default
if value is None:
return None
try:
return six.text_type(value)
except Exception:
raise exceptions.ContractViolationException(
'Value {0} violates string() contract'.format(
format_scalar(value)))
@specs.parameter('value', nullable=True)
@specs.method
def bool_(value):
if value is dsl.NO_VALUE:
value = default
if value is None:
return None
return True if value else False
@specs.parameter('value', nullable=True)
@specs.method
def not_null(value):
if isinstance(value, TypeScheme.ObjRef):
return value
if value is None:
raise exceptions.ContractViolationException(
'null value violates notNull() contract')
return value
@specs.parameter('value', nullable=True)
@specs.method
def error(value):
raise exceptions.ContractViolationException('error() contract')
@specs.parameter('value', nullable=True)
@specs.parameter('predicate', yaqltypes.Lambda(with_context=True))
@specs.parameter('msg', yaqltypes.String(nullable=True))
@specs.method
def check(value, predicate, msg=None):
if isinstance(value, TypeScheme.ObjRef) or predicate(
root_context.create_child_context(), value):
return value
else:
if not msg:
msg = "Value {0} doesn't match predicate".format(
format_scalar(value))
raise exceptions.ContractViolationException(msg)
@specs.parameter('obj', TypeScheme.ObjRef, nullable=True)
@specs.name('owned')
@specs.method
def owned_ref(obj):
if obj is None:
return None
if isinstance(obj, TypeScheme.ObjRef):
return obj
@specs.parameter('obj', dsl_types.MuranoObject)
@specs.method
def owned(obj):
p = obj.owner
while p is not None:
if p is this:
return obj
p = p.owner
raise exceptions.ContractViolationException(
'Object {0} violates owned() contract'.format(obj))
@specs.parameter('obj', TypeScheme.ObjRef, nullable=True)
@specs.name('not_owned')
@specs.method
def not_owned_ref(obj):
if isinstance(obj, TypeScheme.ObjRef):
return obj
if obj is None:
return None
@specs.parameter('obj', dsl_types.MuranoObject)
@specs.method
def not_owned(obj):
try:
owned(obj)
except exceptions.ContractViolationException:
return obj
else:
raise exceptions.ContractViolationException(
'Object {0} violates notOwned() contract'.format(obj))
@specs.parameter('name',
dsl.MuranoTypeParameter(nullable=False,
context=root_context))
@specs.parameter('default_name',
dsl.MuranoTypeParameter(nullable=True,
context=root_context))
@specs.parameter('value', nullable=True)
@specs.parameter('version_spec', yaqltypes.String(True))
@specs.method
def class_(value, name, default_name=None, version_spec=None):
object_store = helpers.get_object_store()
if not default_name:
default_name = name
murano_class = name.type
if isinstance(value, TypeScheme.ObjRef):
value = value.object_id
if value is None:
return None
if isinstance(value, dsl_types.MuranoObject):
obj = value
elif isinstance(value, dsl_types.MuranoObjectInterface):
obj = value.object
elif isinstance(value, utils.MappingType):
obj = object_store.load(value,
owner,
context=root_context,
default_type=default_name,
scope_type=calling_type)
elif isinstance(value, six.string_types):
obj = object_store.get(value)
if obj is None:
if not object_store.initializing:
raise exceptions.NoObjectFoundError(value)
else:
return TypeScheme.ObjRef(value)
else:
raise exceptions.ContractViolationException(
'Value {0} cannot be represented as class {1}'.format(
format_scalar(value), name))
if not helpers.is_instance_of(
obj, murano_class.name, version_spec
or helpers.get_type(root_context)):
raise exceptions.ContractViolationException(
'Object of type {0} is not compatible with '
'requested type {1}'.format(obj.type.name, murano_class))
return obj
@specs.parameter('type_',
dsl.MuranoTypeParameter(nullable=False,
context=root_context))
@specs.parameter('default_type',
dsl.MuranoTypeParameter(nullable=True,
context=root_context))
@specs.parameter('value', nullable=True)
@specs.parameter('version_spec', yaqltypes.String(True))
@specs.parameter('exclude_properties',
yaqltypes.Sequence(nullable=True))
@specs.method
def template(engine,
value,
type_,
exclude_properties=None,
default_type=None,
version_spec=None):
object_store = helpers.get_object_store()
passkey = None
if not default_type:
default_type = type_
murano_class = type_.type
if value is None:
return None
if isinstance(value, dsl_types.MuranoObject):
obj = value
elif isinstance(value, dsl_types.MuranoObjectInterface):
obj = value.object
elif isinstance(value, utils.MappingType):
passkey = utils.create_marker('<Contract Passkey>')
if exclude_properties:
parsed = helpers.parse_object_definition(
value, calling_type, context)
props = dsl.to_mutable(parsed['properties'], engine)
for p in exclude_properties:
helpers.patch_dict(props, p, passkey)
parsed['properties'] = props
value = helpers.assemble_object_definition(parsed)
with helpers.thread_local_attribute(
constants.TL_CONTRACT_PASSKEY, passkey):
with helpers.thread_local_attribute(
constants.TL_OBJECTS_DRY_RUN, True):
obj = object_store.load(value,
owner,
context=context,
default_type=default_type,
scope_type=calling_type)
else:
raise exceptions.ContractViolationException(
'Value {0} cannot be represented as class {1}'.format(
format_scalar(value), type_))
if not helpers.is_instance_of(
obj, murano_class.name, version_spec
or helpers.get_type(root_context)):
raise exceptions.ContractViolationException(
'Object of type {0} is not compatible with '
'requested type {1}'.format(obj.type.name, type_))
with helpers.thread_local_attribute(constants.TL_CONTRACT_PASSKEY,
passkey):
result = serializer.serialize(obj.real_this,
object_store.executor,
dsl_types.DumpTypes.Mixed)
if exclude_properties:
for p in exclude_properties:
helpers.patch_dict(result, p, utils.NO_VALUE)
return result
context = root_context.create_child_context()
context.register_function(int_)
context.register_function(string)
context.register_function(bool_)
context.register_function(check)
context.register_function(not_null)
context.register_function(error)
context.register_function(class_)
context.register_function(template)
context.register_function(owned_ref)
context.register_function(owned)
context.register_function(not_owned_ref)
context.register_function(not_owned)
return context
def prepare_transform_context(root_context, this, owner, default,
calling_type):
@specs.parameter('value', nullable=True)
@specs.method
def int_(value):
if value is dsl.NO_VALUE:
value = default
if value is None:
return None
try:
return int(value)
except Exception:
raise exceptions.ContractViolationException(
'Value {0} violates int() contract'.format(
format_scalar(value)))
@specs.parameter('value', nullable=True)
@specs.method
def string(value):
if value is dsl.NO_VALUE:
value = default
if value is None:
return None
try:
return six.text_type(value)
except Exception:
raise exceptions.ContractViolationException(
'Value {0} violates string() contract'.format(
format_scalar(value)))
@specs.parameter('value', nullable=True)
@specs.method
def bool_(value):
if value is dsl.NO_VALUE:
value = default
if value is None:
return None
return True if value else False
@specs.parameter('value', nullable=True)
@specs.method
def not_null(value):
if isinstance(value, TypeScheme.ObjRef):
return value
if value is None:
raise exceptions.ContractViolationException(
'null value violates notNull() contract')
return value
@specs.parameter('value', nullable=True)
@specs.method
def error(value):
raise exceptions.ContractViolationException('error() contract')
@specs.parameter('value', nullable=True)
@specs.parameter('predicate', yaqltypes.Lambda(with_context=True))
@specs.parameter('msg', yaqltypes.String(nullable=True))
@specs.method
def check(value, predicate, msg=None):
if isinstance(value, TypeScheme.ObjRef) or predicate(
root_context.create_child_context(), value):
return value
else:
if not msg:
msg = "Value {0} doesn't match predicate".format(
format_scalar(value))
raise exceptions.ContractViolationException(msg)
@specs.parameter('obj', TypeScheme.ObjRef, nullable=True)
@specs.name('owned')
@specs.method
def owned_ref(obj):
if obj is None:
return None
if isinstance(obj, TypeScheme.ObjRef):
return obj
@specs.parameter('obj', dsl_types.MuranoObject)
@specs.method
def owned(obj):
p = obj.owner
while p is not None:
if p is this:
return obj
p = p.owner
raise exceptions.ContractViolationException(
'Object {0} violates owned() contract'.format(obj))
@specs.parameter('obj', TypeScheme.ObjRef, nullable=True)
@specs.name('not_owned')
@specs.method
def not_owned_ref(obj):
if isinstance(obj, TypeScheme.ObjRef):
return obj
if obj is None:
return None
@specs.parameter('obj', dsl_types.MuranoObject)
@specs.method
def not_owned(obj):
try:
owned(obj)
except exceptions.ContractViolationException:
return obj
else:
raise exceptions.ContractViolationException(
'Object {0} violates notOwned() contract'.format(obj))
@specs.parameter('name', dsl.MuranoTypeParameter(
nullable=False, context=root_context))
@specs.parameter('default_name', dsl.MuranoTypeParameter(
nullable=True, context=root_context))
@specs.parameter('value', nullable=True)
@specs.parameter('version_spec', yaqltypes.String(True))
@specs.method
def class_(value, name, default_name=None, version_spec=None):
object_store = None if this is None else this.object_store
if not default_name:
default_name = name
murano_class = name.type
if value is None:
return None
if isinstance(value, dsl_types.MuranoObject):
obj = value
elif isinstance(value, dsl_types.MuranoObjectInterface):
obj = value.object
elif isinstance(value, utils.MappingType):
obj = helpers.instantiate(
value, owner, object_store, root_context,
calling_type, default_name)
elif isinstance(value, six.string_types) and object_store:
obj = object_store.get(value)
if obj is None:
if not object_store.initializing:
raise exceptions.NoObjectFoundError(value)
else:
return TypeScheme.ObjRef(value)
else:
raise exceptions.ContractViolationException(
'Value {0} cannot be represented as class {1}'.format(
format_scalar(value), name))
if not helpers.is_instance_of(
obj, murano_class.name,
version_spec or helpers.get_type(root_context)):
raise exceptions.ContractViolationException(
'Object of type {0} is not compatible with '
'requested type {1}'.format(obj.type.name, name))
return obj
context = root_context.create_child_context()
context.register_function(int_)
context.register_function(string)
context.register_function(bool_)
context.register_function(check)
context.register_function(not_null)
context.register_function(error)
context.register_function(class_)
context.register_function(owned_ref)
context.register_function(owned)
context.register_function(not_owned_ref)
context.register_function(not_owned)
return context
return constext
@specs.parameter('kwargs', yaqltypes.Lambda(with_context=True))
def with_original(context, **kwargs):
new_context = context.create_child_context()
original_context = context[constants.CTX_ORIGINAL_CONTEXT]
for k, v in kwargs.items():
new_context['$' + k] = v(original_context)
return new_context
@specs.parameter(
'target',
yaqltypes.AnyOf(dsl.MuranoTypeParameter(), dsl.MuranoObjectParameter()))
@specs.parameter('target_method', yaqltypes.String())
@specs.parameter('mock_object', dsl.MuranoObjectParameter())
@specs.parameter('mock_name', yaqltypes.String())
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):
