From 7c200d66f1d84e4265f586f079196b5faa6d0c4a Mon Sep 17 00:00:00 2001 From: Stan Lagun Date: Fri, 26 Feb 2016 00:13:58 +0300 Subject: [PATCH] Use more generic "type" name instead of "murano_class" 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 --- meta/io.murano/Classes/StackTrace.yaml | 4 +- murano/dsl/attribute_store.py | 2 +- murano/dsl/context_manager.py | 4 +- murano/dsl/dsl.py | 2 +- murano/dsl/dsl_types.py | 20 +-- murano/dsl/executor.py | 24 ++-- murano/dsl/helpers.py | 6 +- murano/dsl/lhs_expression.py | 6 +- murano/dsl/murano_method.py | 24 ++-- murano/dsl/murano_object.py | 10 +- murano/dsl/murano_package.py | 6 +- murano/dsl/murano_property.py | 14 +- .../dsl/{murano_class.py => murano_type.py} | 120 +++++++++--------- murano/dsl/principal_objects/stack_trace.py | 20 +-- murano/dsl/reflection.py | 14 +- murano/dsl/type_scheme.py | 6 +- murano/dsl/typespec.py | 2 +- murano/dsl/yaql_functions.py | 16 +-- murano/dsl/yaql_integration.py | 10 +- murano/engine/mock_context_manager.py | 24 ++-- murano/engine/system/resource_manager.py | 2 +- murano/tests/unit/dsl/test_exceptions.py | 2 +- murano/tests/unit/engine/system/test_agent.py | 4 +- .../unit/engine/test_mock_context_manager.py | 8 +- 24 files changed, 175 insertions(+), 175 deletions(-) rename murano/dsl/{murano_class.py => murano_type.py} (88%) diff --git a/meta/io.murano/Classes/StackTrace.yaml b/meta/io.murano/Classes/StackTrace.yaml index 5fff6645..ad375f9b 100644 --- a/meta/io.murano/Classes/StackTrace.yaml +++ b/meta/io.murano/Classes/StackTrace.yaml @@ -20,5 +20,5 @@ Properties: Contract: - instruction: $.string() location: $ - method: $ - class: $ + methodName: $ + typeName: $ diff --git a/murano/dsl/attribute_store.py b/murano/dsl/attribute_store.py index 0db5c0c9..4a0c0876 100644 --- a/murano/dsl/attribute_store.py +++ b/murano/dsl/attribute_store.py @@ -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 diff --git a/murano/dsl/context_manager.py b/murano/dsl/context_manager.py index c3f41f90..36c6626a 100644 --- a/murano/dsl/context_manager.py +++ b/murano/dsl/context_manager.py @@ -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 diff --git a/murano/dsl/dsl.py b/murano/dsl/dsl.py index d6895c1d..b36e69c6 100644 --- a/murano/dsl/dsl.py +++ b/murano/dsl/dsl.py @@ -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): diff --git a/murano/dsl/dsl_types.py b/murano/dsl/dsl_types.py index 08b8e8d5..5e350da1 100644 --- a/murano/dsl/dsl_types.py +++ b/murano/dsl/dsl_types.py @@ -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): diff --git a/murano/dsl/executor.py b/murano/dsl/executor.py index 007564d6..d4fe1acb 100644 --- a/murano/dsl/executor.py +++ b/murano/dsl/executor.py @@ -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( diff --git a/murano/dsl/helpers.py b/murano/dsl/helpers.py index 84a78197..dfe1afbd 100644 --- a/murano/dsl/helpers.py +++ b/murano/dsl/helpers.py @@ -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 diff --git a/murano/dsl/lhs_expression.py b/murano/dsl/lhs_expression.py index dd2cdf99..6ccf47a8 100644 --- a/murano/dsl/lhs_expression.py +++ b/murano/dsl/lhs_expression.py @@ -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) diff --git a/murano/dsl/murano_method.py b/murano/dsl/murano_method.py index cab8e288..51d2779e 100644 --- a/murano/dsl/murano_method.py +++ b/murano/dsl/murano_method.py @@ -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, diff --git a/murano/dsl/murano_object.py b/murano/dsl/murano_object.py index 6c71491e..2ce727c8 100644 --- a/murano/dsl/murano_object.py +++ b/murano/dsl/murano_object.py @@ -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))) diff --git a/murano/dsl/murano_package.py b/murano/dsl/murano_package.py index ddf95543..4dca8bc7 100644 --- a/murano/dsl/murano_package.py +++ b/murano/dsl/murano_package.py @@ -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 diff --git a/murano/dsl/murano_property.py b/murano/dsl/murano_property.py index f118a85a..5c954114 100644 --- a/murano/dsl/murano_property.py +++ b/murano/dsl/murano_property.py @@ -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) diff --git a/murano/dsl/murano_class.py b/murano/dsl/murano_type.py similarity index 88% rename from murano/dsl/murano_class.py rename to murano/dsl/murano_type.py index 1e6a7428..f0c31518 100644 --- a/murano/dsl/murano_class.py +++ b/murano/dsl/murano_type.py @@ -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 diff --git a/murano/dsl/principal_objects/stack_trace.py b/murano/dsl/principal_objects/stack_trace.py index 7e99e5d0..16f10349 100644 --- a/murano/dsl/principal_objects/stack_trace.py +++ b/murano/dsl/principal_objects/stack_trace.py @@ -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 in method {0}\n{2} {1}'.format( - method, instruction, prefix) + method_name, instruction, prefix) def create_stack_trace(context, include_native_frames=True): diff --git a/murano/dsl/reflection.py b/murano/dsl/reflection.py index 2b1bb035..8ebe9e7c 100644 --- a/murano/dsl/reflection.py +++ b/murano/dsl/reflection.py @@ -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) diff --git a/murano/dsl/type_scheme.py b/murano/dsl/type_scheme.py index ac24198f..3d915ce5 100644 --- a/murano/dsl/type_scheme.py +++ b/murano/dsl/type_scheme.py @@ -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 diff --git a/murano/dsl/typespec.py b/murano/dsl/typespec.py index aa45e3d0..e858c657 100644 --- a/murano/dsl/typespec.py +++ b/murano/dsl/typespec.py @@ -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) diff --git a/murano/dsl/yaql_functions.py b/murano/dsl/yaql_functions.py index 8bde292f..933a94ef 100644 --- a/murano/dsl/yaql_functions.py +++ b/murano/dsl/yaql_functions.py @@ -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): diff --git a/murano/dsl/yaql_integration.py b/murano/dsl/yaql_integration.py index 4c2c2ccd..213a9ecd 100644 --- a/murano/dsl/yaql_integration.py +++ b/murano/dsl/yaql_integration.py @@ -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 diff --git a/murano/engine/mock_context_manager.py b/murano/engine/mock_context_manager.py index 7cb245b4..9144728e 100644 --- a/murano/engine/mock_context_manager.py +++ b/murano/engine/mock_context_manager.py @@ -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() diff --git a/murano/engine/system/resource_manager.py b/murano/engine/system/resource_manager.py index 16bbab3f..be5a396b 100644 --- a/murano/engine/system/resource_manager.py +++ b/murano/engine/system/resource_manager.py @@ -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 diff --git a/murano/tests/unit/dsl/test_exceptions.py b/murano/tests/unit/dsl/test_exceptions.py index bdc98a4b..f6d7f147 100644 --- a/murano/tests/unit/dsl/test_exceptions.py +++ b/murano/tests/unit/dsl/test_exceptions.py @@ -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)) diff --git a/murano/tests/unit/engine/system/test_agent.py b/murano/tests/unit/engine/system/test_agent.py index 37380dbe..0cfca6b9 100644 --- a/murano/tests/unit/engine/system/test_agent.py +++ b/murano/tests/unit/engine/system/test_agent.py @@ -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) diff --git a/murano/tests/unit/engine/test_mock_context_manager.py b/murano/tests/unit/engine/test_mock_context_manager.py index 753abf00..3dc375aa 100644 --- a/murano/tests/unit/engine/test_mock_context_manager.py +++ b/murano/tests/unit/engine/test_mock_context_manager.py @@ -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