deb-murano/murano/dsl/yaql_integration.py

#    Copyright (c) 2015 Mirantis, Inc.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

import inspect

import six
import yaql
from yaql.language import contexts
from yaql.language import conventions
from yaql.language import factory
from yaql.language import specs
from yaql.language import utils
from yaql.language import yaqltypes
from yaql import legacy

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_functions


ENGINE_10_OPTIONS = {
    'yaql.limitIterators': constants.ITERATORS_LIMIT,
    'yaql.memoryQuota': constants.EXPRESSION_MEMORY_QUOTA,
    'yaql.convertSetsToLists': True,
    'yaql.convertTuplesToLists': True,
    'yaql.iterableDicts': True
}

ENGINE_12_OPTIONS = {
    'yaql.limitIterators': constants.ITERATORS_LIMIT,
    'yaql.memoryQuota': constants.EXPRESSION_MEMORY_QUOTA,
    'yaql.convertSetsToLists': True,
    'yaql.convertTuplesToLists': True
}


def _add_operators(engine_factory):
    engine_factory.insert_operator(
        '>', True, 'is', factory.OperatorType.BINARY_LEFT_ASSOCIATIVE, False)
    engine_factory.insert_operator(
        None, True, ':', factory.OperatorType.BINARY_LEFT_ASSOCIATIVE, True)
    engine_factory.insert_operator(
        ':', True, ':', factory.OperatorType.PREFIX_UNARY, False)
    engine_factory.operators.insert(0, ())


def _create_engine(runtime_version):
    engine_factory = factory.YaqlFactory()
    _add_operators(engine_factory=engine_factory)
    options = (ENGINE_10_OPTIONS
               if runtime_version <= constants.RUNTIME_VERSION_1_1
               else ENGINE_12_OPTIONS)
    return engine_factory.create(options=options)


@specs.name('#finalize')
def _finalize(obj, context):
    return helpers.evaluate(obj, context)

CONVENTION = conventions.CamelCaseConvention()
ENGINE_10 = _create_engine(constants.RUNTIME_VERSION_1_0)
ENGINE_12 = _create_engine(constants.RUNTIME_VERSION_1_2)
ROOT_CONTEXT_10 = legacy.create_context(
    convention=CONVENTION, finalizer=_finalize)
ROOT_CONTEXT_12 = yaql.create_context(
    convention=CONVENTION, finalizer=_finalize)


class ContractedValue(yaqltypes.GenericType):
    def __init__(self, value_spec):
        self._value_spec = value_spec
        self._last_result = False

        super(ContractedValue, self).__init__(
            True, None,
            lambda value, sender, context, *args, **kwargs:
                self._value_spec.validate(
                    value, sender.real_this,
                    context[constants.CTX_ARGUMENT_OWNER], context))

    def convert(self, value, *args, **kwargs):
        if value is None:
            return self.converter(value, *args, **kwargs)
        return super(ContractedValue, self).convert(value, *args, **kwargs)


def create_empty_context():
    context = contexts.Context(convention=CONVENTION)
    context.register_function(_finalize)
    return context


@helpers.memoize
def create_context(runtime_version):
    if runtime_version <= constants.RUNTIME_VERSION_1_1:
        context = ROOT_CONTEXT_10.create_child_context()
    else:
        context = ROOT_CONTEXT_12.create_child_context()
    context[constants.CTX_YAQL_ENGINE] = choose_yaql_engine(runtime_version)
    return yaql_functions.register(context, runtime_version)


def choose_yaql_engine(runtime_version):
    return (ENGINE_10 if runtime_version <= constants.RUNTIME_VERSION_1_1
            else ENGINE_12)


def parse(expression, runtime_version):
    return choose_yaql_engine(runtime_version)(expression)


def call_func(__context, __name, *args, **kwargs):
    engine = __context[constants.CTX_YAQL_ENGINE]
    return __context(__name, engine)(
        *args,
        **{CONVENTION.convert_parameter_name(key): value
           for key, value in six.iteritems(kwargs)})


def _infer_parameter_type(name, class_name):
    if name == 'context':
        return yaqltypes.Context()
    if name == 'this':
        return dsl.ThisParameterType()
    if name == 'interfaces':
        return dsl.InterfacesParameterType()
    if name == 'yaql_engine':
        return yaqltypes.Engine()

    if name.startswith('__'):
        return _infer_parameter_type(name[2:], class_name)
    if class_name and name.startswith('_{0}__'.format(class_name)):
        return _infer_parameter_type(name[3 + len(class_name):], class_name)


def get_function_definition(func, murano_method):
    body = func
    param_type_func = lambda name: _infer_parameter_type(name, None)
    is_method = False
    if inspect.ismethod(func):
        is_method = True
        body = func.im_func
        param_type_func = lambda name: _infer_parameter_type(
            name, func.im_class.__name__)
    fd = specs.get_function_definition(
        body, convention=CONVENTION,
        parameter_type_func=param_type_func)
    if is_method:
        fd.is_method = True
        fd.is_function = False
        fd.set_parameter(
            0,
            yaqltypes.PythonType(func.im_class),
            overwrite=True)
    name = getattr(func, '__murano_name', None)
    if name:
        fd.name = name
    fd.insert_parameter(specs.ParameterDefinition(
        '?1', yaqltypes.Context(), 0))

    def payload(__context, *args, **kwargs):
        with helpers.contextual(__context):
            return body(*args, **kwargs)

    fd.payload = payload
    fd.meta[constants.META_MURANO_METHOD] = murano_method
    return fd


def build_wrapper_function_definition(murano_method):
    if isinstance(murano_method.body, specs.FunctionDefinition):
        return _build_native_wrapper_function_definition(murano_method)
    else:
        return _build_mpl_wrapper_function_definition(murano_method)


def _build_native_wrapper_function_definition(murano_method):
    runtime_version = murano_method.murano_class.package.runtime_version
    engine = choose_yaql_engine(runtime_version)

    @specs.method
    @specs.name(murano_method.name)
    @specs.meta(constants.META_MURANO_METHOD, murano_method)
    def payload(__context, __sender, *args, **kwargs):
        executor = helpers.get_executor(__context)
        args = tuple(dsl.to_mutable(arg, engine) for arg in args)
        kwargs = dsl.to_mutable(kwargs, engine)
        return helpers.evaluate(murano_method.invoke(
            executor, __sender, args, kwargs, __context, True), __context)

    return specs.get_function_definition(payload)


def _build_mpl_wrapper_function_definition(murano_method):
    def payload(__context, __sender, *args, **kwargs):
        executor = helpers.get_executor(__context)
        return murano_method.invoke(
            executor, __sender, args, kwargs, __context, True)

    fd = specs.FunctionDefinition(
        murano_method.name, payload, is_function=False, is_method=True)

    for i, (name, arg_spec) in enumerate(
            six.iteritems(murano_method.arguments_scheme), 2):
        p = specs.ParameterDefinition(
            name, ContractedValue(arg_spec),
            position=i, default=dsl.NO_VALUE)
        fd.parameters[name] = p

    fd.set_parameter(specs.ParameterDefinition(
        '__context', yaqltypes.Context(), 0))

    nullable = murano_method.usage == 'Static'
    sender_type = yaqltypes.PythonType(dsl_types.MuranoObject, nullable)
    fd.set_parameter(specs.ParameterDefinition('__sender', sender_type, 1))

    fd.meta[constants.META_MURANO_METHOD] = murano_method
    return fd


def get_class_factory_definition(cls, murano_class):
    runtime_version = murano_class.package.runtime_version
    engine = choose_yaql_engine(runtime_version)

    def payload(__context, __sender, *args, **kwargs):
        assert __sender is None
        args = tuple(dsl.to_mutable(arg, engine) for arg in args)
        kwargs = dsl.to_mutable(kwargs, engine)
        with helpers.contextual(__context):
            return helpers.evaluate(cls(*args, **kwargs), __context)

    if hasattr(cls.__init__, 'im_func'):
        fd = specs.get_function_definition(
            cls.__init__.im_func,
            parameter_type_func=lambda name: _infer_parameter_type(
                name, cls.__init__.im_class.__name__),
            convention=CONVENTION)
    else:
        fd = specs.get_function_definition(lambda self: None)
        fd.meta[constants.META_NO_TRACE] = True
    fd.insert_parameter(specs.ParameterDefinition(
        '?1', yaqltypes.Context(), position=0))
    fd.is_method = True
    fd.is_function = False
    fd.name = '__init__'
    fd.payload = payload
    return fd


def filter_parameters(__fd, *args, **kwargs):
    if '*' not in __fd.parameters:
        position_args = 0
        for p in six.itervalues(__fd.parameters):
            if p.position is not None:
                position_args += 1
        args = args[:position_args]
    kwargs = kwargs.copy()
    for name in kwargs.keys():
        if not utils.is_keyword(name):
            del kwargs[name]
    if '**' not in __fd.parameters:
        names = {p.alias or p.name for p in six.itervalues(__fd.parameters)}
        for name in kwargs.keys():
            if name not in names:
                del kwargs[name]
    return args, kwargs