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):