From 008c299e68d78ee207d431ceeed70e98329888a5 Mon Sep 17 00:00:00 2001 From: Stan Lagun Date: Sat, 26 Mar 2016 01:28:20 +0300 Subject: [PATCH] Handling of ephemeral methods was fixed Ephemeral method is the one that created on the fly and doesn't belong to extension class. Such methods were returned as a replacement for ambiguous methods. Such ephemeral method would throw exception upon attempt to invoke it so that we get this exception on run-time rather that load-time. However yaql FunctionDefinition code wasn't ready for such functions Change-Id: Ica8585b9750277d29f571b90dc7b92e12e5fef30 Closes-Bug: #1562011 --- murano/dsl/murano_method.py | 11 ++++++----- murano/dsl/murano_type.py | 3 ++- murano/dsl/yaql_integration.py | 18 ++++++++++-------- 3 files changed, 18 insertions(+), 14 deletions(-) diff --git a/murano/dsl/murano_method.py b/murano/dsl/murano_method.py index 3e809df08..2c6a413ec 100644 --- a/murano/dsl/murano_method.py +++ b/murano/dsl/murano_method.py @@ -36,20 +36,22 @@ virtual_exceptions.register() class MuranoMethod(dsl_types.MuranoMethod, meta.MetaProvider): - def __init__(self, declaring_type, name, payload, original_name=None): + def __init__(self, declaring_type, name, payload, original_name=None, + ephemeral=False): self._name = name original_name = original_name or name self._declaring_type = weakref.ref(declaring_type) self._meta_values = None + self_ref = self if ephemeral else weakref.proxy(self) if callable(payload): if isinstance(payload, specs.FunctionDefinition): self._body = payload else: self._body = yaql_integration.get_function_definition( - payload, weakref.proxy(self), original_name) + payload, self_ref, original_name) self._arguments_scheme = None - if any(( + if declaring_type.extension_class and any(( helpers.inspect_is_static( declaring_type.extension_class, original_name), helpers.inspect_is_classmethod( @@ -96,8 +98,7 @@ class MuranoMethod(dsl_types.MuranoMethod, meta.MetaProvider): declaring_type) self._instance_stub, self._static_stub = \ - yaql_integration.build_stub_function_definitions( - weakref.proxy(self)) + yaql_integration.build_stub_function_definitions(self_ref) @property def name(self): diff --git a/murano/dsl/murano_type.py b/murano/dsl/murano_type.py index 7e01ca2fb..0be22c6d3 100644 --- a/murano/dsl/murano_type.py +++ b/murano/dsl/murano_type.py @@ -250,7 +250,8 @@ class MuranoClass(dsl_types.MuranoClass, MuranoType, dslmeta.MetaProvider): except exceptions.AmbiguousMethodName as e: def func(*args, **kwargs): raise e - yield murano_method.MuranoMethod(self, name, func) + yield murano_method.MuranoMethod( + self, name, func, ephemeral=True) def find_single_property(self, name): result = self.find_property(name) diff --git a/murano/dsl/yaql_integration.py b/murano/dsl/yaql_integration.py index d9038fb71..8c0ae7076 100644 --- a/murano/dsl/yaql_integration.py +++ b/murano/dsl/yaql_integration.py @@ -152,11 +152,12 @@ def _infer_parameter_type(name, class_name): 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.declaring_type.extension_class - if (helpers.inspect_is_method(cls, original_name) or + param_type_func = \ + lambda name: None if not cls else _infer_parameter_type( + name, cls.__name__) + body = func + if (cls is None or helpers.inspect_is_method(cls, original_name) or helpers.inspect_is_classmethod(cls, original_name)): body = helpers.function(func) fd = specs.get_function_definition( @@ -164,12 +165,12 @@ def get_function_definition(func, murano_method, original_name): parameter_type_func=param_type_func) fd.is_method = True fd.is_function = False - if helpers.inspect_is_method(cls, original_name): + if not cls or helpers.inspect_is_method(cls, original_name): fd.set_parameter( 0, dsl.MuranoObjectParameter(murano_method.declaring_type), overwrite=True) - if helpers.inspect_is_classmethod(cls, original_name): + if cls and helpers.inspect_is_classmethod(cls, original_name): _remove_first_parameter(fd) body = func name = getattr(func, '__murano_name', None) @@ -177,8 +178,9 @@ def get_function_definition(func, murano_method, original_name): fd.name = name fd.insert_parameter(specs.ParameterDefinition( '?1', yaqltypes.Context(), 0)) - is_static = (helpers.inspect_is_static(cls, original_name) or - helpers.inspect_is_classmethod(cls, original_name)) + is_static = cls and ( + helpers.inspect_is_static(cls, original_name) or + helpers.inspect_is_classmethod(cls, original_name)) if is_static: fd.insert_parameter(specs.ParameterDefinition( '?2', yaqltypes.PythonType(object), 1))