openstack/deb-murano
Code Issues Proposed changes

Use more generic "type" name instead of "murano_class"

Browse Source 
Because the're going to be many different types of classes
(like meta-classes) it is reasonable to distinguish murano_class
from a "type", that can refer to any type of class (type)

Change-Id: I05993eb7a37627aaeacbc6c828250791e145d706
This commit is contained in:
Stan Lagun
2016-02-26 00:13:58 +03:00
parent b4d8e93c00
commit 7c200d66f1
24 changed files with 175 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
meta/io.murano/Classes/StackTrace.yaml
View File

@@ -20,5 +20,5 @@ Properties:
Contract:
- instruction: $.string()
location: $
method: $
class: $
methodName: $
typeName: $

2
murano/dsl/attribute_store.py
View File

@@ -24,7 +24,7 @@ class AttributeStore(object):
@staticmethod
def _get_attribute_key(tagged_object, owner_type, name):
if isinstance(owner_type, dsl_types.MuranoTypeReference):
owner_type = owner_type.murano_class
owner_type = owner_type.type
if isinstance(tagged_object, dsl_types.MuranoObjectInterface):
tagged_object = tagged_object.object
return tagged_object.object_id, owner_type.name, name

4
murano/dsl/context_manager.py
View File

@@ -30,8 +30,8 @@ class ContextManager(object):
def create_package_context(self, package):
return package.context
def create_class_context(self, murano_class):
return murano_class.context
def create_type_context(self, murano_type):
return murano_type.context
def create_object_context(self, obj):
return None

2
murano/dsl/dsl.py
View File

@@ -204,7 +204,7 @@ class MuranoObjectInterface(dsl_types.MuranoObjectInterface):
if isinstance(type, six.string_types):
type = helpers.get_class(type)
elif isinstance(type, dsl_types.MuranoTypeReference):
type = type.murano_class
type = type.type
p = self.owner
while p is not None:
if type.is_compatible(p):

20
murano/dsl/dsl_types.py
View File

@@ -13,7 +13,11 @@
# under the License.
class MuranoClass(object):
class MuranoType(object):
pass
class MuranoClass(MuranoType):
pass
@@ -38,23 +42,23 @@ class MuranoProperty(object):
class MuranoTypeReference(object):
def __init__(self, murano_class):
self.__murano_class = murano_class
def __init__(self, murano_type):
self.__murano_type = murano_type
@property
def murano_class(self):
return self.__murano_class
def type(self):
return self.__murano_type
def __repr__(self):
return '*' + repr(self.murano_class)
return '*' + repr(self.type)
def __eq__(self, other):
if not isinstance(other, MuranoTypeReference):
return False
return self.murano_class == other.murano_class
return self.type == other.type
def __hash__(self):
return hash(self.murano_class)
return hash(self.type)
class YaqlExpression(object):

24
murano/dsl/executor.py
View File

@@ -75,7 +75,7 @@ class MuranoDslExecutor(object):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
kwargs = utils.filter_parameters_dict(kwargs)
runtime_version = method.murano_class.package.runtime_version
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('.')
@@ -92,7 +92,7 @@ class MuranoDslExecutor(object):
if method.is_static:
obj_context = self.create_object_context(
method.murano_class, context)
method.declaring_type, context)
else:
obj_context = self.create_object_context(this, context)
context = self.create_method_context(obj_context, method)
@@ -112,11 +112,11 @@ class MuranoDslExecutor(object):
def call():
if isinstance(method.body, specs.FunctionDefinition):
if isinstance(this, dsl_types.MuranoClass):
if isinstance(this, dsl_types.MuranoType):
native_this = this.get_reference()
else:
native_this = dsl.MuranoObjectInterface(this.cast(
method.murano_class), self)
method.declaring_type), self)
return method.body(
yaql_engine, context, native_this)(*args, **kwargs)
else:
@@ -136,7 +136,7 @@ class MuranoDslExecutor(object):
def _acquire_method_lock(self, method, this):
method_id = id(method)
if method.is_static:
this_id = id(method.murano_class)
this_id = id(method.declaring_type)
else:
this_id = this.object_id
thread_id = helpers.get_current_thread_id()
@@ -168,7 +168,7 @@ class MuranoDslExecutor(object):
(u'{0} => {1}'.format(name, value)
for name, value in six.iteritems(kwargs)))
params_str = u', '.join(param_gen)
method_name = '{0}::{1}'.format(method.murano_class.name, method.name)
method_name = '::'.join((method.declaring_type.name, method.name))
thread_id = helpers.get_current_thread_id()
caller_str = ''
caller_ctx = helpers.get_caller_context(context)
@@ -278,14 +278,14 @@ class MuranoDslExecutor(object):
self.context_manager.create_package_context(package))
return context
def create_class_context(self, murano_class):
def create_type_context(self, murano_type):
package_context = self.create_package_context(
murano_class.package)
murano_type.package)
context = helpers.link_contexts(
package_context,
self.context_manager.create_class_context(
murano_class)).create_child_context()
context[constants.CTX_TYPE] = murano_class
self.context_manager.create_type_context(
murano_type)).create_child_context()
context[constants.CTX_TYPE] = murano_type
return context
def create_object_context(self, obj, caller_context=None):
@@ -294,7 +294,7 @@ class MuranoDslExecutor(object):
obj = None
else:
obj_type = obj.type
class_context = self.create_class_context(obj_type)
class_context = self.create_type_context(obj_type)
if obj is not None:
context = helpers.link_contexts(
class_context, self.context_manager.create_object_context(

6
murano/dsl/helpers.py
View File

@@ -303,14 +303,14 @@ def traverse(seed, producer=None, track_visited=True):
def cast(obj, murano_class, pov_or_version_spec=None):
if isinstance(obj, dsl_types.MuranoObjectInterface):
obj = obj.object
if isinstance(pov_or_version_spec, dsl_types.MuranoClass):
if isinstance(pov_or_version_spec, dsl_types.MuranoType):
pov_or_version_spec = pov_or_version_spec.package
elif isinstance(pov_or_version_spec, six.string_types):
pov_or_version_spec = parse_version_spec(pov_or_version_spec)
if isinstance(murano_class, dsl_types.MuranoTypeReference):
murano_class = murano_class.murano_class
if isinstance(murano_class, dsl_types.MuranoClass):
murano_class = murano_class.type
if isinstance(murano_class, dsl_types.MuranoType):
if pov_or_version_spec is None:
pov_or_version_spec = parse_version_spec(murano_class.version)
murano_class = murano_class.name

6
murano/dsl/lhs_expression.py
View File

@@ -72,9 +72,9 @@ class LhsExpression(object):
src.set_property(key, value, root_context)
elif isinstance(src, (
dsl_types.MuranoTypeReference,
dsl_types.MuranoClass)):
if not isinstance(src, dsl_types.MuranoClass):
mc = src.murano_class
dsl_types.MuranoType)):
if isinstance(src, dsl_types.MuranoTypeReference):
mc = src.type
else:
mc = src
mc.set_property(key, value, root_context)

24
murano/dsl/murano_method.py
View File

@@ -41,10 +41,10 @@ class MethodUsages(object):
class MuranoMethod(dsl_types.MuranoMethod):
def __init__(self, murano_class, name, payload, original_name=None):
def __init__(self, declaring_type, name, payload, original_name=None):
self._name = name
original_name = original_name or name
self._murano_class = weakref.ref(murano_class)
self._declaring_type = weakref.ref(declaring_type)
if callable(payload):
if isinstance(payload, specs.FunctionDefinition):
@@ -55,9 +55,9 @@ class MuranoMethod(dsl_types.MuranoMethod):
self._arguments_scheme = None
if any((
helpers.inspect_is_static(
murano_class.extension_class, original_name),
declaring_type.extension_class, original_name),
helpers.inspect_is_classmethod(
murano_class.extension_class, original_name))):
declaring_type.extension_class, original_name))):
self._usage = MethodUsages.Static
else:
self._usage = (self._body.meta.get('usage') or
@@ -92,8 +92,8 @@ class MuranoMethod(dsl_types.MuranoMethod):
return self._name
@property
def murano_class(self):
return self._murano_class()
def declaring_type(self):
return self._declaring_type()
@property
def arguments_scheme(self):
@@ -121,21 +121,21 @@ class MuranoMethod(dsl_types.MuranoMethod):
def __repr__(self):
return 'MuranoMethod({0}::{1})'.format(
self.murano_class.name, self.name)
self.declaring_type.name, self.name)
def invoke(self, executor, this, args, kwargs, context=None,
skip_stub=False):
if isinstance(this, dsl.MuranoObjectInterface):
this = this.object
if this and not self.murano_class.is_compatible(this):
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.murano_class)
this = this.cast(self.declaring_type)
else:
this = self.murano_class
this = self.declaring_type
return executor.invoke_method(
self, this, context, args, kwargs, skip_stub)
@@ -143,7 +143,7 @@ class MuranoMethod(dsl_types.MuranoMethod):
class MuranoMethodArgument(dsl_types.MuranoMethodArgument, typespec.Spec):
def __init__(self, murano_method, method_name, arg_name, declaration):
super(MuranoMethodArgument, self).__init__(
declaration, murano_method.murano_class)
declaration, murano_method.declaring_type)
self._method_name = method_name
self._arg_name = arg_name
self._murano_method = weakref.ref(murano_method)
@@ -153,7 +153,7 @@ class MuranoMethodArgument(dsl_types.MuranoMethodArgument, typespec.Spec):
return super(MuranoMethodArgument, self).validate(*args, **kwargs)
except exceptions.ContractViolationException as e:
msg = u'[{0}::{1}({2}{3})] {4}'.format(
self.murano_method.murano_class.name,
self.murano_method.declaring_type.name,
self.murano_method.name, self.name,
e.path, six.text_type(e))
six.reraise(exceptions.ContractViolationException,

10
murano/dsl/murano_object.py
View File

@@ -184,16 +184,16 @@ class MuranoObject(dsl_types.MuranoObject):
if name in start_type.properties:
spec = start_type.properties[name]
if spec.usage == typespec.PropertyUsages.Static:
return spec.murano_class.get_property(name, context)
return spec.declaring_type.get_property(name, context)
else:
return self.cast(start_type)._get_property_value(name)
else:
try:
spec = start_type.find_single_property(name)
if spec.usage == typespec.PropertyUsages.Static:
return spec.murano_class.get_property(name, context)
return spec.declaring_type.get_property(name, context)
else:
return self.cast(spec.murano_class).__properties[name]
return self.cast(spec.declaring_type).__properties[name]
except exceptions.NoPropertyFound:
if derived:
return self.cast(caller_class)._get_property_value(name)
@@ -229,13 +229,13 @@ class MuranoObject(dsl_types.MuranoObject):
raise exceptions.NoWriteAccessError(name)
if spec.usage == typespec.PropertyUsages.Static:
classes_for_static_properties.append(spec.murano_class)
classes_for_static_properties.append(spec.declaring_type)
else:
default = self.__config.get(name, spec.default)
default = self.__defaults.get(name, default)
default = helpers.evaluate(default, context)
obj = self.cast(spec.murano_class)
obj = self.cast(spec.declaring_type)
values_to_assign.append((obj, spec.validate(
value, self.real_this,
self.real_this, context, default=default)))

6
murano/dsl/murano_package.py
View File

@@ -22,8 +22,8 @@ from murano.dsl import constants
from murano.dsl import dsl_types
from murano.dsl import exceptions
from murano.dsl import helpers
from murano.dsl import murano_class
from murano.dsl import murano_object
from murano.dsl import murano_type
from murano.dsl import principal_objects
from murano.dsl import yaql_integration
@@ -88,7 +88,7 @@ class MuranoPackage(dsl_types.MuranoPackage):
def _register_mpl_class(self, data, name=None):
type_obj = self._classes.get(name)
if not type_obj:
type_obj = murano_class.MuranoClass.create(data, self, name)
type_obj = murano_type.create(data, self, name)
self._classes[name] = type_obj
return type_obj
@@ -131,7 +131,7 @@ class MuranoPackage(dsl_types.MuranoPackage):
self._register_native_class(cls, name)
else:
self._native_load_queue[name] = cls
elif isinstance(cls, murano_class.MuranoClass):
elif isinstance(cls, dsl_types.MuranoType):
self._classes[cls.name] = cls
else:
self._load_queue[name] = cls

14
murano/dsl/murano_property.py
View File

@@ -23,23 +23,23 @@ from murano.dsl import typespec
class MuranoProperty(dsl_types.MuranoProperty, typespec.Spec):
def __init__(self, murano_class, property_name, declaration):
super(MuranoProperty, self).__init__(declaration, murano_class)
def __init__(self, declaring_type, property_name, declaration):
super(MuranoProperty, self).__init__(declaration, declaring_type)
self._property_name = property_name
self._murano_class = weakref.ref(murano_class)
self._declaring_type = weakref.ref(declaring_type)
def validate(self, *args, **kwargs):
try:
return super(MuranoProperty, self).validate(*args, **kwargs)
except exceptions.ContractViolationException as e:
msg = u'[{0}.{1}{2}] {3}'.format(
self.murano_class.name, self.name, e.path, six.text_type(e))
self.declaring_type.name, self.name, e.path, six.text_type(e))
six.reraise(exceptions.ContractViolationException,
msg, sys.exc_info()[2])
@property
def murano_class(self):
return self._murano_class()
def declaring_type(self):
return self._declaring_type()
@property
def name(self):
@@ -47,4 +47,4 @@ class MuranoProperty(dsl_types.MuranoProperty, typespec.Spec):
def __repr__(self):
return 'MuranoProperty({type}::{name})'.format(
type=self.murano_class.name, name=self.name)
type=self.declaring_type.name, name=self.name)

120
murano/dsl/murano_class.py → murano/dsl/murano_type.py
View File

@@ -31,61 +31,11 @@ from murano.dsl import namespace_resolver
from murano.dsl import yaql_integration
class MuranoClass(dsl_types.MuranoClass):
def __init__(self, ns_resolver, name, package, parents=None):
self._package = weakref.ref(package)
self._methods = {}
class MuranoType(dsl_types.MuranoType):
def __init__(self, ns_resolver, name, package):
self._namespace_resolver = ns_resolver
self._name = name
self._properties = {}
self._config = {}
self._extension_class = None
if self._name == constants.CORE_LIBRARY_OBJECT:
self._parents = []
else:
self._parents = parents or [
package.find_class(constants.CORE_LIBRARY_OBJECT)]
self._context = None
self._parent_mappings = self._build_parent_remappings()
self._property_values = {}
@classmethod
def create(cls, data, package, name=None):
namespaces = data.get('Namespaces') or {}
ns_resolver = namespace_resolver.NamespaceResolver(namespaces)
if not name:
name = ns_resolver.resolve_name(str(data['Name']))
parent_class_names = data.get('Extends')
parent_classes = []
if parent_class_names:
if not utils.is_sequence(parent_class_names):
parent_class_names = [parent_class_names]
for parent_name in parent_class_names:
full_name = ns_resolver.resolve_name(str(parent_name))
parent_classes.append(package.find_class(full_name))
type_obj = cls(ns_resolver, name, package, parent_classes)
properties = data.get('Properties') or {}
for property_name, property_spec in six.iteritems(properties):
spec = murano_property.MuranoProperty(
type_obj, property_name, property_spec)
type_obj.add_property(property_name, spec)
methods = data.get('Methods') or data.get('Workflow') or {}
method_mappings = {
'initialize': '.init',
'destroy': '.destroy'
}
for method_name, payload in six.iteritems(methods):
type_obj.add_method(
method_mappings.get(method_name, method_name), payload)
return type_obj
self._package = weakref.ref(package)
@property
def name(self):
@@ -99,6 +49,23 @@ class MuranoClass(dsl_types.MuranoClass):
def namespace_resolver(self):
return self._namespace_resolver
class MuranoClass(dsl_types.MuranoClass, MuranoType):
def __init__(self, ns_resolver, name, package, parents=None):
super(MuranoClass, self).__init__(ns_resolver, name, package)
self._methods = {}
self._properties = {}
self._config = {}
self._extension_class = None
if self._name == constants.CORE_LIBRARY_OBJECT:
self._parents = []
else:
self._parents = parents or [
package.find_class(constants.CORE_LIBRARY_OBJECT)]
self._context = None
self._parent_mappings = self._build_parent_remappings()
self._property_values = {}
@property
def declared_parents(self):
return self._parents
@@ -257,10 +224,9 @@ class MuranoClass(dsl_types.MuranoClass):
def is_compatible(self, obj):
if isinstance(obj, (murano_object.MuranoObject,
dsl.MuranoObjectInterface)):
dsl.MuranoObjectInterface,
dsl_types.MuranoTypeReference)):
obj = obj.type
elif isinstance(obj, dsl_types.MuranoTypeReference):
obj = obj.murano_class
if obj is self:
return True
return any(cls is self for cls in obj.ancestors())
@@ -386,14 +352,52 @@ class MuranoClass(dsl_types.MuranoClass):
def get_property(self, name, context):
prop = self.find_static_property(name)
cls = prop.murano_class
cls = prop.declaring_type
value = cls._property_values.get(name, prop.default)
return prop.validate(value, cls, None, context)
def set_property(self, name, value, context):
prop = self.find_static_property(name)
cls = prop.murano_class
cls = prop.declaring_type
cls._property_values[name] = prop.validate(value, cls, None, context)
def get_reference(self):
return dsl_types.MuranoTypeReference(self)
def create(data, package, name=None):
namespaces = data.get('Namespaces') or {}
ns_resolver = namespace_resolver.NamespaceResolver(namespaces)
if not name:
name = ns_resolver.resolve_name(str(data['Name']))
parent_class_names = data.get('Extends')
parent_classes = []
if parent_class_names:
if not utils.is_sequence(parent_class_names):
parent_class_names = [parent_class_names]
for parent_name in parent_class_names:
full_name = ns_resolver.resolve_name(str(parent_name))
parent_classes.append(package.find_class(full_name))
type_obj = MuranoClass(ns_resolver, name, package, parent_classes)
properties = data.get('Properties') or {}
for property_name, property_spec in six.iteritems(properties):
spec = murano_property.MuranoProperty(
type_obj, property_name, property_spec)
type_obj.add_property(property_name, spec)
methods = data.get('Methods') or data.get('Workflow') or {}
method_mappings = {
'initialize': '.init',
'destroy': '.destroy'
}
for method_name, payload in six.iteritems(methods):
type_obj.add_method(
method_mappings.get(method_name, method_name), payload)
return type_obj

20
murano/dsl/principal_objects/stack_trace.py
View File

@@ -49,8 +49,8 @@ class StackTrace(object):
native_frames.append({
'instruction': frame[4][0].strip(),
'location': location,
'method': method,
'class': None
'methodName': method,
'typeName': None
})
frames.extend(native_frames)
@@ -72,18 +72,18 @@ def compose_stack_frame(context):
'location': None if instruction is None
else instruction.source_file_position,
'method': None if method is None else method.name,
'class': None if method is None else method.murano_class.name
'methodName': None if method is None else method.name,
'typeName': None if method is None else method.declaring_type.name
}
def format_frame(frame, prefix=''):
instruction = frame['instruction']
method = frame['method']
murano_class = frame['class']
method_name = frame['methodName']
type_name = frame['typeName']
location = frame['location']
if murano_class:
method += ' of class ' + murano_class
if type_name:
method_name += ' of type ' + type_name
if location:
args = (
@@ -91,7 +91,7 @@ def format_frame(frame, prefix=''):
location.start_line,
':' + str(location.start_column)
if location.start_column >= 0 else '',
method,
method_name,
instruction,
prefix
)
@@ -99,7 +99,7 @@ def format_frame(frame, prefix=''):
u'{5} {4}').format(*args)
else:
return u'{2}File <unknown> in method {0}\n{2} {1}'.format(
method, instruction, prefix)
method_name, instruction, prefix)
def create_stack_trace(context, include_native_frames=True):

14
murano/dsl/reflection.py
View File

@@ -21,7 +21,7 @@ from murano.dsl import dsl_types
from murano.dsl import helpers
@specs.yaql_property(dsl_types.MuranoClass)
@specs.yaql_property(dsl_types.MuranoType)
@specs.name('name')
def class_name(murano_class):
return murano_class.name
@@ -93,7 +93,7 @@ def property_usage(murano_property):
@specs.yaql_property(dsl_types.MuranoProperty)
@specs.name('declaring_type')
def property_owner(murano_property):
return murano_property.murano_class
return murano_property.declaring_type
@specs.name('get_value')
@@ -103,9 +103,9 @@ def property_owner(murano_property):
@specs.method
def property_get_value(context, property_, object_):
if object_ is None:
return property_.murano_class.get_property(
return property_.declaring_type.get_property(
name=property_.name, context=context)
return object_.cast(property_.murano_class).get_property(
return object_.cast(property_.declaring_type).get_property(
name=property_.name, context=context)
@@ -116,10 +116,10 @@ def property_get_value(context, property_, object_):
@specs.method
def property_set_value(context, property_, object_, value):
if object_ is None:
property_.murano_class.set_property(
property_.declaring_type.set_property(
name=property_.name, value=value, context=context)
else:
object_.cast(property_.murano_class).set_property(
object_.cast(property_.declaring_type).set_property(
name=property_.name, value=value, context=context)
@@ -139,7 +139,7 @@ def arguments(murano_method):
@specs.yaql_property(dsl_types.MuranoMethod)
@specs.name('declaring_type')
def method_owner(murano_method):
return murano_method.murano_class
return murano_method.declaring_type
@specs.parameter('method', dsl_types.MuranoMethod)

6
murano/dsl/type_scheme.py
View File

@@ -156,7 +156,7 @@ class TypeScheme(object):
object_store = this.object_store
if not default_name:
default_name = name
murano_class = name.murano_class
murano_class = name.type
if value is None:
return None
if isinstance(value, dsl_types.MuranoObject):
@@ -167,8 +167,8 @@ class TypeScheme(object):
if '?' not in value:
new_value = {'?': {
'id': uuid.uuid4().hex,
'type': default_name.murano_class.name,
'classVersion': str(default_name.murano_class.version)
'type': default_name.type.name,
'classVersion': str(default_name.type.version)
}}
new_value.update(value)
value = new_value

2
murano/dsl/typespec.py
View File

@@ -48,7 +48,7 @@ class Spec(object):
if default is None:
default = self.default
executor = helpers.get_executor(context)
if isinstance(this, dsl_types.MuranoClass):
if isinstance(this, dsl_types.MuranoType):
return self._contract(
value, executor.create_object_context(this),
None, None, default)

16
murano/dsl/yaql_functions.py
View File

@@ -35,7 +35,7 @@ def id_(object_):
@specs.parameter('version_spec', yaqltypes.String(True))
def cast(context, object_, type__, version_spec=None):
return helpers.cast(
object_, type__.murano_class.name,
object_, type__.type.name,
version_spec or helpers.get_type(context))
@@ -52,7 +52,7 @@ def new(__context, __type_name, __owner=None, __object_name=None, __extra=None,
for key, value in six.iteritems(parameters):
if utils.is_keyword(key):
new_context[key] = value
return __type_name.murano_class.new(
return __type_name.type.new(
__owner, object_store, executor, name=__object_name)(
new_context, **parameters)
@@ -131,7 +131,7 @@ def typeinfo(object_):
@specs.parameter('cls', dsl.MuranoTypeParameter())
@specs.name('typeinfo')
def typeinfo_for_class(cls):
return cls.murano_class
return cls.type
@specs.parameter('object_', dsl.MuranoObjectParameter(nullable=True))
@@ -150,7 +150,7 @@ def obj_attribution(context, obj, property_name):
@specs.parameter('property_name', yaqltypes.Keyword())
@specs.name('#operator_.')
def obj_attribution_static(context, cls, property_name):
return cls.murano_class.get_property(property_name, context)
return cls.type.get_property(property_name, context)
@specs.parameter('receiver', dsl.MuranoObjectParameter(decorate=False))
@@ -159,7 +159,7 @@ def obj_attribution_static(context, cls, property_name):
@specs.name('#operator_.')
def op_dot(context, receiver, expr, operator):
executor = helpers.get_executor(context)
type_context = executor.context_manager.create_class_context(receiver.type)
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),
@@ -173,8 +173,8 @@ def op_dot(context, receiver, expr, operator):
@specs.name('#operator_.')
def op_dot_static(context, receiver, expr, operator):
executor = helpers.get_executor(context)
type_context = executor.context_manager.create_class_context(
receiver.murano_class)
type_context = executor.context_manager.create_type_context(
receiver.type)
ctx2 = helpers.link_contexts(context, type_context)
return operator(ctx2, receiver, expr)
@@ -201,7 +201,7 @@ def ns_resolve_unary(context, name):
def is_instance_of(obj, type_):
if obj is None:
return False
return type_.murano_class.is_compatible(obj)
return type_.type.is_compatible(obj)
def register(context, runtime_version):

10
murano/dsl/yaql_integration.py
View File

@@ -149,7 +149,7 @@ def get_function_definition(func, murano_method, original_name):
param_type_func = lambda name: _infer_parameter_type(
name, cls.__name__)
body = func
cls = murano_method.murano_class.extension_class
cls = murano_method.declaring_type.extension_class
if helpers.inspect_is_method(cls, original_name):
body = func.im_func
if helpers.inspect_is_classmethod(cls, original_name):
@@ -162,7 +162,7 @@ def get_function_definition(func, murano_method, original_name):
if helpers.inspect_is_method(cls, original_name):
fd.set_parameter(
0,
dsl.MuranoObjectParameter(murano_method.murano_class),
dsl.MuranoObjectParameter(murano_method.declaring_type),
overwrite=True)
if helpers.inspect_is_classmethod(cls, original_name):
_remove_first_parameter(fd)
@@ -220,7 +220,7 @@ def build_wrapper_function_definition(murano_method):
def _build_native_wrapper_function_definition(murano_method):
runtime_version = murano_method.murano_class.package.runtime_version
runtime_version = murano_method.declaring_type.package.runtime_version
engine = choose_yaql_engine(runtime_version)
@specs.method
@@ -256,10 +256,10 @@ def _build_mpl_wrapper_function_definition(murano_method):
'__context', yaqltypes.Context(), 0))
receiver_type = dsl.MuranoObjectParameter(
weakref.proxy(murano_method.murano_class), decorate=False)
weakref.proxy(murano_method.declaring_type), decorate=False)
if murano_method.is_static:
receiver_type = yaqltypes.AnyOf(dsl.MuranoTypeParameter(
weakref.proxy(murano_method.murano_class)), receiver_type)
weakref.proxy(murano_method.declaring_type)), receiver_type)
fd.set_parameter(specs.ParameterDefinition('__receiver', receiver_type, 1))
fd.meta[constants.META_MURANO_METHOD] = murano_method

24
murano/engine/mock_context_manager.py
View File

@@ -20,7 +20,6 @@ from yaql.language import yaqltypes
from murano.common import engine
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 yaql_integration
@@ -52,11 +51,11 @@ class MockContextManager(engine.ContextManager):
new_context = self._create_new_ctx(self.obj_mock_ctx[obj_id])
return new_context
def create_class_context(self, murano_class):
original_context = super(MockContextManager,
self).create_class_context(murano_class)
def create_type_context(self, murano_type):
original_context = super(
MockContextManager, self).create_type_context(murano_type)
mock_context = self._create_new_ctx_for_class(murano_class.name)
mock_context = self._create_new_ctx_for_class(murano_type.name)
if mock_context:
result_context = helpers.link_contexts(
original_context, mock_context).create_child_context()
@@ -65,8 +64,8 @@ class MockContextManager(engine.ContextManager):
return result_context
def create_object_context(self, murano_obj):
original_context = super(MockContextManager,
self).create_object_context(murano_obj)
original_context = super(
MockContextManager, self).create_object_context(murano_obj)
mock_context = self._create_new_ctx_for_obj(murano_obj.type.name)
if mock_context:
@@ -109,11 +108,7 @@ def inject_method_with_str(context, target, target_method,
current_class = helpers.get_type(context)
mock_func = current_class.find_single_method(mock_name)
if isinstance(target, dsl_types.MuranoTypeReference):
original_class = target.murano_class
else:
original_class = target.type
original_class = target.type
original_function = original_class.find_single_method(target_method)
result_fd = original_function.yaql_function_definition.clone()
@@ -136,10 +131,7 @@ def inject_method_with_str(context, target, target_method,
@specs.parameter('expr', yaqltypes.Lambda(with_context=True))
def inject_method_with_yaql_expr(context, target, target_method, expr):
ctx_manager = helpers.get_executor(context).context_manager
if isinstance(target, dsl_types.MuranoTypeReference):
original_class = target.murano_class
else:
original_class = target.type
original_class = target.type
original_function = original_class.find_single_method(target_method)
result_fd = original_function.yaql_function_definition.clone()

2
murano/engine/system/resource_manager.py
View File

@@ -77,5 +77,5 @@ class ResourceManager(object):
return receiver.extension._package
murano_class = helpers.get_type(helpers.get_caller_context())
else:
murano_class = owner.murano_class
murano_class = owner.type
return murano_class.package

2
murano/tests/unit/dsl/test_exceptions.py
View File

@@ -90,7 +90,7 @@ class TestExceptions(test_case.DslTestCase):
matchers.MatchesRegex(
r'.*^ File \".*ExceptionHandling\.yaml\", '
r'line \d+:\d+ in method testStackTrace .*'
r'of class ExceptionHandling$.*'
r'of type ExceptionHandling$.*'
r'^ File \".*{0}\", line {1} '
r'in method exception_func$.*'.format(filename, line),
re.MULTILINE | re.DOTALL))

4
murano/tests/unit/engine/system/test_agent.py
View File

@@ -17,8 +17,8 @@ import os
import mock
import yaml as yamllib
from murano.dsl import murano_class
from murano.dsl import murano_object
from murano.dsl import murano_type
from murano.dsl import object_store
from murano.engine.system import agent
from murano.engine.system import resource_manager
@@ -33,7 +33,7 @@ class TestExecutionPlan(base.MuranoTestCase):
else:
self.yaml_loader = yamllib.SafeLoader
self.mock_murano_class = mock.Mock(spec=murano_class.MuranoClass)
self.mock_murano_class = mock.Mock(spec=murano_type.MuranoClass)
self.mock_murano_class.name = 'io.murano.system.Agent'
self.mock_murano_class.declared_parents = []
self.mock_object_store = mock.Mock(spec=object_store.ObjectStore)

8
murano/tests/unit/engine/test_mock_context_manager.py
View File

@@ -17,7 +17,7 @@ from yaql import specs
from murano.dsl import constants
from murano.dsl import executor
from murano.dsl import murano_class
from murano.dsl import murano_type
from murano.engine import execution_session
from murano.engine import mock_context_manager
from murano.engine.system import test_fixture
@@ -64,9 +64,9 @@ class MockRunner(runner.Runner):
class TestMockManager(base.MuranoTestCase):
def test_create_class_context(self):
def test_create_type_context(self):
mock_manager = mock_context_manager.MockContextManager()
mock_murano_class = mock.MagicMock(spec=murano_class.MuranoClass)
mock_murano_class = mock.MagicMock(spec=murano_type.MuranoClass)
mock_murano_class.name = FIXTURE_CLASS
original_function = mock.MagicMock(spec=specs.FunctionDefinition)
original_function.is_method = True
@@ -84,7 +84,7 @@ class TestMockManager(base.MuranoTestCase):
mock_manager.class_mock_ctx[FIXTURE_CLASS] = [mock_function]
result_context = mock_manager.create_class_context(mock_murano_class)
result_context = mock_manager.create_type_context(mock_murano_class)
all_functions = result_context.collect_functions(FIXTURE_FUNC)
# Mock function should go first, but result context should contain both