path: root/azure/aria/aria-extension-cloudify/src/aria/extensions/aria_extension_tosca/simple_v1_0/modeling/functions.py

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.

from StringIO import StringIO # Note: cStringIO does not support Unicode
import re

from aria.utils.collections import FrozenList
from aria.utils.formatting import (as_raw, safe_repr)
from aria.utils.type import full_type_name
from aria.parser import implements_specification
from aria.parser.exceptions import InvalidValueError
from aria.parser.validation import Issue
from aria.modeling.exceptions import CannotEvaluateFunctionException
from aria.modeling.models import (Node, NodeTemplate, Relationship, RelationshipTemplate)
from aria.modeling.functions import (Function, Evaluation)


#
# Intrinsic
#

@implements_specification('4.3.1', 'tosca-simple-1.0')
class Concat(Function):
    """
    The ``concat`` function is used to concatenate two or more string values within a TOSCA
    service template.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        if not isinstance(argument, list):
            raise InvalidValueError(
                'function "concat" argument must be a list of string expressions: {0}'
                .format(safe_repr(argument)),
                locator=self.locator)

        string_expressions = []
        for index, an_argument in enumerate(argument):
            string_expressions.append(parse_string_expression(context, presentation, 'concat',
                                                              index, None, an_argument))
        self.string_expressions = FrozenList(string_expressions)

    @property
    def as_raw(self):
        string_expressions = []
        for string_expression in self.string_expressions:
            if hasattr(string_expression, 'as_raw'):
                string_expression = as_raw(string_expression)
            string_expressions.append(string_expression)
        return {'concat': string_expressions}

    def __evaluate__(self, container_holder):
        final = True
        value = StringIO()
        for e in self.string_expressions:
            e, final = evaluate(e, final, container_holder)
            if e is not None:
                value.write(unicode(e))
        value = value.getvalue() or u''
        return Evaluation(value, final)


@implements_specification('4.3.2', 'tosca-simple-1.0')
class Token(Function):
    """
    The ``token`` function is used within a TOSCA service template on a string to parse out
    (tokenize) substrings separated by one or more token characters within a larger string.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        if (not isinstance(argument, list)) or (len(argument) != 3):
            raise InvalidValueError('function "token" argument must be a list of 3 parameters: {0}'
                                    .format(safe_repr(argument)),
                                    locator=self.locator)

        self.string_with_tokens = parse_string_expression(context, presentation, 'token', 0,
                                                          'the string to tokenize', argument[0])
        self.string_of_token_chars = parse_string_expression(context, presentation, 'token', 1,
                                                             'the token separator characters',
                                                             argument[1])
        self.substring_index = parse_int(context, presentation, 'token', 2,
                                         'the 0-based index of the token to return', argument[2])

    @property
    def as_raw(self):
        string_with_tokens = self.string_with_tokens
        if hasattr(string_with_tokens, 'as_raw'):
            string_with_tokens = as_raw(string_with_tokens)
        string_of_token_chars = self.string_of_token_chars
        if hasattr(string_of_token_chars, 'as_raw'):
            string_of_token_chars = as_raw(string_of_token_chars)
        return {'token': [string_with_tokens, string_of_token_chars, self.substring_index]}

    def __evaluate__(self, container_holder):
        final = True
        string_with_tokens, final = evaluate(self.string_with_tokens, final, container_holder)
        string_of_token_chars, final = evaluate(self.string_of_token_chars, final, container_holder)

        if string_of_token_chars:
            regex = '[' + ''.join(re.escape(c) for c in string_of_token_chars) + ']'
            split = re.split(regex, string_with_tokens)
            if self.substring_index < len(split):
                return Evaluation(split[self.substring_index], final)

        raise CannotEvaluateFunctionException()


#
# Property
#

@implements_specification('4.4.1', 'tosca-simple-1.0')
class GetInput(Function):
    """
    The ``get_input`` function is used to retrieve the values of properties declared within the
    inputs section of a TOSCA Service Template.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        self.input_property_name = parse_string_expression(context, presentation, 'get_input',
                                                           None, 'the input property name',
                                                           argument)

        if isinstance(self.input_property_name, basestring):
            the_input = context.presentation.get_from_dict('service_template', 'topology_template',
                                                           'inputs', self.input_property_name)
            if the_input is None:
                raise InvalidValueError(
                    'function "get_input" argument is not a valid input name: {0}'
                    .format(safe_repr(argument)),
                    locator=self.locator)

    @property
    def as_raw(self):
        return {'get_input': as_raw(self.input_property_name)}

    def __evaluate__(self, container_holder):
        service = container_holder.service
        if service is None:
            raise CannotEvaluateFunctionException()

        value = service.inputs.get(self.input_property_name)
        if value is not None:
            value = value.value
            return Evaluation(value, False) # We never return final evaluations!

        raise InvalidValueError(
            'function "get_input" argument is not a valid input name: {0}'
            .format(safe_repr(self.input_property_name)),
            locator=self.locator)


@implements_specification('4.4.2', 'tosca-simple-1.0')
class GetProperty(Function):
    """
    The ``get_property`` function is used to retrieve property values between modelable entities
    defined in the same service template.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        if (not isinstance(argument, list)) or (len(argument) < 2):
            raise InvalidValueError(
                'function "get_property" argument must be a list of at least 2 string expressions: '
                '{0}'.format(safe_repr(argument)),
                locator=self.locator)

        self.modelable_entity_name = parse_modelable_entity_name(context, presentation,
                                                                 'get_property', 0, argument[0])
        # The first of these will be tried as a req-or-cap name:
        self.nested_property_name_or_index = argument[1:]

    @property
    def as_raw(self):
        return {'get_property': [self.modelable_entity_name] + self.nested_property_name_or_index}

    def __evaluate__(self, container_holder):
        modelable_entities = get_modelable_entities(container_holder, 'get_property', self.locator,
                                                    self.modelable_entity_name)
        req_or_cap_name = self.nested_property_name_or_index[0]

        for modelable_entity in modelable_entities:
            properties = None

            # First argument refers to a requirement template?
            if hasattr(modelable_entity, 'requirement_templates') \
                and modelable_entity.requirement_templates \
                and (req_or_cap_name in [v.name for v in modelable_entity.requirement_templates]):
                for requirement in modelable_entity.requirement_templates:
                    if requirement.name == req_or_cap_name:
                        # TODO
                        raise CannotEvaluateFunctionException()
            # First argument refers to a capability?
            elif hasattr(modelable_entity, 'capabilities') \
                and modelable_entity.capabilities \
                and (req_or_cap_name in modelable_entity.capabilities):
                properties = modelable_entity.capabilities[req_or_cap_name].properties
                nested_property_name_or_index = self.nested_property_name_or_index[1:]
            # First argument refers to a capability template?
            elif hasattr(modelable_entity, 'capability_templates') \
                and modelable_entity.capability_templates \
                and (req_or_cap_name in modelable_entity.capability_templates):
                properties = modelable_entity.capability_templates[req_or_cap_name].properties
                nested_property_name_or_index = self.nested_property_name_or_index[1:]
            else:
                properties = modelable_entity.properties
                nested_property_name_or_index = self.nested_property_name_or_index

            evaluation = get_modelable_entity_parameter(modelable_entity, properties,
                                                        nested_property_name_or_index)
            if evaluation is not None:
                return evaluation

        raise InvalidValueError(
            'function "get_property" could not find "{0}" in modelable entity "{1}"'
            .format('.'.join(self.nested_property_name_or_index), self.modelable_entity_name),
            locator=self.locator)


#
# Attribute
#

@implements_specification('4.5.1', 'tosca-simple-1.0')
class GetAttribute(Function):
    """
    The ``get_attribute`` function is used to retrieve the values of named attributes declared
    by the referenced node or relationship template name.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        if (not isinstance(argument, list)) or (len(argument) < 2):
            raise InvalidValueError(
                'function "get_attribute" argument must be a list of at least 2 string expressions:'
                ' {0}'.format(safe_repr(argument)),
                locator=self.locator)

        self.modelable_entity_name = parse_modelable_entity_name(context, presentation,
                                                                 'get_attribute', 0, argument[0])
        # The first of these will be tried as a req-or-cap name:
        self.nested_attribute_name_or_index = argument[1:]

    @property
    def as_raw(self):
        return {'get_attribute': [self.modelable_entity_name] + self.nested_attribute_name_or_index}

    def __evaluate__(self, container_holder):
        modelable_entities = get_modelable_entities(container_holder, 'get_attribute', self.locator,
                                                    self.modelable_entity_name)
        for modelable_entity in modelable_entities:
            attributes = modelable_entity.attributes
            nested_attribute_name_or_index = self.nested_attribute_name_or_index
            evaluation = get_modelable_entity_parameter(modelable_entity, attributes,
                                                        nested_attribute_name_or_index)
            if evaluation is not None:
                evaluation.final = False # We never return final evaluations!
                return evaluation

        raise InvalidValueError(
            'function "get_attribute" could not find "{0}" in modelable entity "{1}"'
            .format('.'.join(self.nested_attribute_name_or_index), self.modelable_entity_name),
            locator=self.locator)


#
# Operation
#

@implements_specification('4.6.1', 'tosca-simple-1.0') # pylint: disable=abstract-method
class GetOperationOutput(Function):
    """
    The ``get_operation_output`` function is used to retrieve the values of variables exposed /
    exported from an interface operation.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        if (not isinstance(argument, list)) or (len(argument) != 4):
            raise InvalidValueError(
                'function "get_operation_output" argument must be a list of 4 parameters: {0}'
                .format(safe_repr(argument)),
                locator=self.locator)

        self.modelable_entity_name = parse_string_expression(context, presentation,
                                                             'get_operation_output', 0,
                                                             'modelable entity name', argument[0])
        self.interface_name = parse_string_expression(context, presentation, 'get_operation_output',
                                                      1, 'the interface name', argument[1])
        self.operation_name = parse_string_expression(context, presentation, 'get_operation_output',
                                                      2, 'the operation name', argument[2])
        self.output_variable_name = parse_string_expression(context, presentation,
                                                            'get_operation_output', 3,
                                                            'the output name', argument[3])

    @property
    def as_raw(self):
        interface_name = self.interface_name
        if hasattr(interface_name, 'as_raw'):
            interface_name = as_raw(interface_name)
        operation_name = self.operation_name
        if hasattr(operation_name, 'as_raw'):
            operation_name = as_raw(operation_name)
        output_variable_name = self.output_variable_name
        if hasattr(output_variable_name, 'as_raw'):
            output_variable_name = as_raw(output_variable_name)
        return {'get_operation_output': [self.modelable_entity_name, interface_name, operation_name,
                                         output_variable_name]}


#
# Navigation
#

@implements_specification('4.7.1', 'tosca-simple-1.0')
class GetNodesOfType(Function):
    """
    The ``get_nodes_of_type`` function can be used to retrieve a list of all known instances of
    nodes of the declared Node Type.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        self.node_type_name = parse_string_expression(context, presentation, 'get_nodes_of_type',
                                                      None, 'the node type name', argument)

        if isinstance(self.node_type_name, basestring):
            node_types = context.presentation.get('service_template', 'node_types')
            if (node_types is None) or (self.node_type_name not in node_types):
                raise InvalidValueError(
                    'function "get_nodes_of_type" argument is not a valid node type name: {0}'
                    .format(safe_repr(argument)),
                    locator=self.locator)

    @property
    def as_raw(self):
        node_type_name = self.node_type_name
        if hasattr(node_type_name, 'as_raw'):
            node_type_name = as_raw(node_type_name)
        return {'get_nodes_of_type': node_type_name}

    def __evaluate__(self, container):
        pass


#
# Artifact
#

@implements_specification('4.8.1', 'tosca-simple-1.0') # pylint: disable=abstract-method
class GetArtifact(Function):
    """
    The ``get_artifact`` function is used to retrieve artifact location between modelable
    entities defined in the same service template.
    """

    def __init__(self, context, presentation, argument):
        self.locator = presentation._locator

        if (not isinstance(argument, list)) or (len(argument) < 2) or (len(argument) > 4):
            raise InvalidValueError(
                'function "get_artifact" argument must be a list of 2 to 4 parameters: {0}'
                .format(safe_repr(argument)),
                locator=self.locator)

        self.modelable_entity_name = parse_string_expression(context, presentation, 'get_artifact',
                                                             0, 'modelable entity name',
                                                             argument[0])
        self.artifact_name = parse_string_expression(context, presentation, 'get_artifact', 1,
                                                     'the artifact name', argument[1])
        self.location = parse_string_expression(context, presentation, 'get_artifact', 2,
                                                'the location or "LOCAL_FILE"', argument[2])
        self.remove = parse_bool(context, presentation, 'get_artifact', 3, 'the removal flag',
                                 argument[3])

    @property
    def as_raw(self):
        artifact_name = self.artifact_name
        if hasattr(artifact_name, 'as_raw'):
            artifact_name = as_raw(artifact_name)
        location = self.location
        if hasattr(location, 'as_raw'):
            location = as_raw(location)
        return {'get_artifacts': [self.modelable_entity_name, artifact_name, location, self.remove]}


#
# Utils
#

def get_function(context, presentation, value):
    functions = context.presentation.presenter.functions
    if isinstance(value, dict) and (len(value) == 1):
        key = value.keys()[0]
        if key in functions:
            try:
                return True, functions[key](context, presentation, value[key])
            except InvalidValueError as e:
                context.validation.report(issue=e.issue)
                return True, None
    return False, None


def parse_string_expression(context, presentation, name, index, explanation, value): # pylint: disable=unused-argument
    is_function, func = get_function(context, presentation, value)
    if is_function:
        return func
    else:
        value = str(value)
    return value


def parse_int(context, presentation, name, index, explanation, value): # pylint: disable=unused-argument
    if not isinstance(value, int):
        try:
            value = int(value)
        except ValueError:
            raise invalid_value(name, index, 'an integer', explanation, value,
                                presentation._locator)
    return value


def parse_bool(context, presentation, name, index, explanation, value): # pylint: disable=unused-argument
    if not isinstance(value, bool):
        raise invalid_value(name, index, 'a boolean', explanation, value, presentation._locator)
    return value


def parse_modelable_entity_name(context, presentation, name, index, value):
    value = parse_string_expression(context, presentation, name, index, 'the modelable entity name',
                                    value)
    if value == 'SELF':
        the_self, _ = parse_self(presentation)
        if the_self is None:
            raise invalid_modelable_entity_name(name, index, value, presentation._locator,
                                                'a node template or a relationship template')
    elif value == 'HOST':
        _, self_variant = parse_self(presentation)
        if self_variant != 'node_template':
            raise invalid_modelable_entity_name(name, index, value, presentation._locator,
                                                'a node template')
    elif (value == 'SOURCE') or (value == 'TARGET'):
        _, self_variant = parse_self(presentation)
        if self_variant != 'relationship_template':
            raise invalid_modelable_entity_name(name, index, value, presentation._locator,
                                                'a relationship template')
    elif isinstance(value, basestring):
        node_templates = \
            context.presentation.get('service_template', 'topology_template', 'node_templates') \
            or {}
        relationship_templates = \
            context.presentation.get('service_template', 'topology_template',
                                     'relationship_templates') \
            or {}
        if (value not in node_templates) and (value not in relationship_templates):
            raise InvalidValueError(
                'function "{0}" parameter {1:d} is not a valid modelable entity name: {2}'
                .format(name, index + 1, safe_repr(value)),
                locator=presentation._locator, level=Issue.BETWEEN_TYPES)
    return value


def parse_self(presentation):
    from ..types import (NodeType, RelationshipType)
    from ..templates import (
        NodeTemplate as NodeTemplatePresentation,
        RelationshipTemplate as RelationshipTemplatePresentation
    )

    if presentation is None:
        return None, None
    elif isinstance(presentation, NodeTemplatePresentation) or isinstance(presentation, NodeType):
        return presentation, 'node_template'
    elif isinstance(presentation, RelationshipTemplatePresentation) \
        or isinstance(presentation, RelationshipType):
        return presentation, 'relationship_template'
    else:
        return parse_self(presentation._container)


def evaluate(value, final, container_holder):
    """
    Calls ``__evaluate__`` and passes on ``final`` state.
    """

    if hasattr(value, '__evaluate__'):
        value = value.__evaluate__(container_holder)
        if not value.final:
            final = False
        return value.value, final
    else:
        return value, final


@implements_specification('4.1', 'tosca-simple-1.0')
def get_modelable_entities(container_holder, name, locator, modelable_entity_name):
    """
    The following keywords MAY be used in some TOSCA function in place of a TOSCA Node or
    Relationship Template name.
    """

    if modelable_entity_name == 'SELF':
        return get_self(container_holder, name, locator)
    elif modelable_entity_name == 'HOST':
        return get_hosts(container_holder, name, locator)
    elif modelable_entity_name == 'SOURCE':
        return get_source(container_holder, name, locator)
    elif modelable_entity_name == 'TARGET':
        return get_target(container_holder, name, locator)
    elif isinstance(modelable_entity_name, basestring):
        modelable_entities = []

        service = container_holder.service
        if service is not None:
            for node in service.nodes.itervalues():
                if node.node_template.name == modelable_entity_name:
                    modelable_entities.append(node)
        else:
            service_template = container_holder.service_template
            if service_template is not None:
                for node_template in service_template.node_templates.itervalues():
                    if node_template.name == modelable_entity_name:
                        modelable_entities.append(node_template)

        if not modelable_entities:
            raise CannotEvaluateFunctionException()

        return modelable_entities

    raise InvalidValueError('function "{0}" could not find modelable entity "{1}"'
                            .format(name, modelable_entity_name),
                            locator=locator)


def get_self(container_holder, name, locator):
    """
    A TOSCA orchestrator will interpret this keyword as the Node or Relationship Template instance
    that contains the function at the time the function is evaluated.
    """

    container = container_holder.container
    if (not isinstance(container, Node)) and \
        (not isinstance(container, NodeTemplate)) and \
        (not isinstance(container, Relationship)) and \
        (not isinstance(container, RelationshipTemplate)):
        raise InvalidValueError('function "{0}" refers to "SELF" but it is not contained in '
                                'a node or a relationship: {1}'.format(name,
                                                                       full_type_name(container)),
                                locator=locator)

    return [container]


def get_hosts(container_holder, name, locator):
    """
    A TOSCA orchestrator will interpret this keyword to refer to the all nodes that "host" the node
    using this reference (i.e., as identified by its HostedOn relationship).

    Specifically, TOSCA orchestrators that encounter this keyword when evaluating the get_attribute
    or ``get_property`` functions SHALL search each node along the "HostedOn" relationship chain
    starting at the immediate node that hosts the node where the function was evaluated (and then
    that node's host node, and so forth) until a match is found or the "HostedOn" relationship chain
    ends.
    """

    container = container_holder.container
    if (not isinstance(container, Node)) and (not isinstance(container, NodeTemplate)):
        raise InvalidValueError('function "{0}" refers to "HOST" but it is not contained in '
                                'a node: {1}'.format(name, full_type_name(container)),
                                locator=locator)

    if not isinstance(container, Node):
        # NodeTemplate does not have "host"; we'll wait until instantiation
        raise CannotEvaluateFunctionException()

    host = container.host
    if host is None:
        # We might have a host later
        raise CannotEvaluateFunctionException()

    return [host]


def get_source(container_holder, name, locator):
    """
    A TOSCA orchestrator will interpret this keyword as the Node Template instance that is at the
    source end of the relationship that contains the referencing function.
    """

    container = container_holder.container
    if (not isinstance(container, Relationship)) and \
        (not isinstance(container, RelationshipTemplate)):
        raise InvalidValueError('function "{0}" refers to "SOURCE" but it is not contained in '
                                'a relationship: {1}'.format(name, full_type_name(container)),
                                locator=locator)

    if not isinstance(container, RelationshipTemplate):
        # RelationshipTemplate does not have "source_node"; we'll wait until instantiation
        raise CannotEvaluateFunctionException()

    return [container.source_node]


def get_target(container_holder, name, locator):
    """
    A TOSCA orchestrator will interpret this keyword as the Node Template instance that is at the
    target end of the relationship that contains the referencing function.
    """

    container = container_holder.container
    if (not isinstance(container, Relationship)) and \
        (not isinstance(container, RelationshipTemplate)):
        raise InvalidValueError('function "{0}" refers to "TARGET" but it is not contained in '
                                'a relationship: {1}'.format(name, full_type_name(container)),
                                locator=locator)

    if not isinstance(container, RelationshipTemplate):
        # RelationshipTemplate does not have "target_node"; we'll wait until instantiation
        raise CannotEvaluateFunctionException()

    return [container.target_node]


def get_modelable_entity_parameter(modelable_entity, parameters, nested_parameter_name_or_index):
    if not parameters:
        return Evaluation(None, True)

    found = True
    final = True
    value = parameters

    for name_or_index in nested_parameter_name_or_index:
        if (isinstance(value, dict) and (name_or_index in value)) \
            or ((isinstance(value, list) and (name_or_index < len(value)))):
            value = value[name_or_index] # Parameter
            # We are not using Parameter.value, but rather Parameter._value, because we want to make
            # sure to get "final" (it is swallowed by Parameter.value)
            value, final = evaluate(value._value, final, value)
        else:
            found = False
            break

    return Evaluation(value, final) if found else None


def invalid_modelable_entity_name(name, index, value, locator, contexts):
    return InvalidValueError('function "{0}" parameter {1:d} can be "{2}" only in {3}'
                             .format(name, index + 1, value, contexts),
                             locator=locator, level=Issue.FIELD)


def invalid_value(name, index, the_type, explanation, value, locator):
    return InvalidValueError(
        'function "{0}" {1} is not {2}{3}: {4}'
        .format(name,
                'parameter {0:d}'.format(index + 1) if index is not None else 'argument',
                the_type,
                ', {0}'.format(explanation) if explanation is not None else '',
                safe_repr(value)),
        locator=locator, level=Issue.FIELD)