http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/orchestrator/execution_plugin/instantiation.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/execution_plugin/instantiation.py b/aria/orchestrator/execution_plugin/instantiation.py index f55aa50..49605b9 100644 --- a/aria/orchestrator/execution_plugin/instantiation.py +++ b/aria/orchestrator/execution_plugin/instantiation.py @@ -19,11 +19,7 @@ Instantiation of :class:`~aria.modeling.models.Operation` models. # TODO: this module will eventually be moved to a new "aria.instantiation" package -from ...utils.type import full_type_name -from ...utils.formatting import safe_repr from ...utils.collections import OrderedDict -from ...parser import validation -from ...parser.consumption import ConsumptionContext from ...modeling.functions import Function @@ -110,20 +106,24 @@ def _configure_remote(operation): # Make sure we have a user if fabric_env.get('user') is None: - context = ConsumptionContext.get_thread_local() - context.validation.report('must configure "ssh.user" for "{0}"' - .format(operation.implementation), - level=validation.Issue.BETWEEN_TYPES) + # TODO: fix + pass + # context = ConsumptionContext.get_thread_local() + # context.validation.report('must configure "ssh.user" for "{0}"' + # .format(operation.implementation), + # level=validation.Issue.BETWEEN_TYPES) # Make sure we have an authentication value if (fabric_env.get('password') is None) and \ (fabric_env.get('key') is None) and \ (fabric_env.get('key_filename') is None): - context = ConsumptionContext.get_thread_local() - context.validation.report('must configure "ssh.password", "ssh.key", or "ssh.key_filename" ' - 'for "{0}"' - .format(operation.implementation), - level=validation.Issue.BETWEEN_TYPES) + # TODO: fix + pass + # context = ConsumptionContext.get_thread_local() + # context.validation.report( + # 'must configure "ssh.password", "ssh.key", or "ssh.key_filename" for "{0}"'.format( + # operation.implementation), + # level=validation.Issue.BETWEEN_TYPES) operation.arguments['fabric_env'] = Argument.wrap('fabric_env', fabric_env, 'Fabric configuration.') @@ -152,10 +152,12 @@ def _get_process(operation): elif k == 'env': _validate_type(v, dict, 'process.env') else: - context = ConsumptionContext.get_thread_local() - context.validation.report('unsupported configuration parameter: "process.{0}"' - .format(k), - level=validation.Issue.BETWEEN_TYPES) + # TODO: fix + pass + # context = ConsumptionContext.get_thread_local() + # context.validation.report('unsupported configuration parameter: "process.{0}"' + # .format(k), + # level=validation.Issue.BETWEEN_TYPES) return value @@ -185,9 +187,11 @@ def _get_ssh(operation): elif k == 'address': _validate_type(v, basestring, 'ssh.address') else: - context = ConsumptionContext.get_thread_local() - context.validation.report('unsupported configuration parameter: "ssh.{0}"'.format(k), - level=validation.Issue.BETWEEN_TYPES) + # TODO: fix + pass + # context = ConsumptionContext.get_thread_local() + # context.validation.report('unsupported configuration parameter: "ssh.{0}"'.format(k), + # level=validation.Issue.BETWEEN_TYPES) return value @@ -195,10 +199,12 @@ def _validate_type(value, the_type, name): if isinstance(value, Function): return if not isinstance(value, the_type): - context = ConsumptionContext.get_thread_local() - context.validation.report('"{0}" configuration is not a {1}: {2}' - .format(name, full_type_name(the_type), safe_repr(value)), - level=validation.Issue.BETWEEN_TYPES) + # TODO: fix + pass + # context = ConsumptionContext.get_thread_local() + # context.validation.report('"{0}" configuration is not a {1}: {2}' + # .format(name, full_type_name(the_type), safe_repr(value)), + # level=validation.Issue.BETWEEN_TYPES) def _coerce_bool(value, name): @@ -212,10 +218,12 @@ def _coerce_bool(value, name): elif value == 'false': return False else: - context = ConsumptionContext.get_thread_local() - context.validation.report('"{0}" configuration is not "true" or "false": {1}' - .format(name, safe_repr(value)), - level=validation.Issue.BETWEEN_TYPES) + # TODO: fix + pass + # context = ConsumptionContext.get_thread_local() + # context.validation.report('"{0}" configuration is not "true" or "false": {1}' + # .format(name, safe_repr(value)), + # level=validation.Issue.BETWEEN_TYPES) def _dict_to_list_of_strings(the_dict, name):
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/orchestrator/topology/__init__.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/topology/__init__.py b/aria/orchestrator/topology/__init__.py new file mode 100644 index 0000000..099a950 --- /dev/null +++ b/aria/orchestrator/topology/__init__.py @@ -0,0 +1,16 @@ +# 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 .topology import Topology http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/orchestrator/topology/common.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/topology/common.py b/aria/orchestrator/topology/common.py new file mode 100644 index 0000000..45e9ab0 --- /dev/null +++ b/aria/orchestrator/topology/common.py @@ -0,0 +1,52 @@ +# 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. + + +class _Handler(object): + def __init__(self, topology, template): + self._topology = topology + self._model = template + + def _coerce(self, *templates, **kwargs): + for template in templates: + self._topology.coerce(template) + + def coerce(self): + pass + + def validate(self, **kwargs): + pass + + def _validate(self, *templates, **kwargs): + for template in templates: + self._topology.validate(template) + + def dump(self, out_stream): + pass + + +class _TemplateHandlerMixin(_Handler): + + def instantiate(self, instance_cls): + raise NotImplementedError + + +class _InstanceHandlerMixin(_Handler): + pass + + +class _OperatorHolderHandlerMixin(_Handler): + def configure_operations(self): + raise NotImplementedError http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/orchestrator/topology/instance_handler.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/topology/instance_handler.py b/aria/orchestrator/topology/instance_handler.py new file mode 100644 index 0000000..dbebf48 --- /dev/null +++ b/aria/orchestrator/topology/instance_handler.py @@ -0,0 +1,644 @@ +# 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 ... parser.modeling import context +from ... modeling import models +from ... utils import formatting +from .. import execution_plugin +from .. import decorators +from . import common + + +class Artifact(common._InstanceHandlerMixin): + + def coerce(self, **kwargs): + self._topology.coerce(self._model.properties, **kwargs) + + def validate(self, **kwargs): + self._topology.validate(self._model.properties) + + def dump(self, out_stream): + with out_stream.indent(): + out_stream.write(out_stream.node(self._model.name)) + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + out_stream.write('Artifact type: {0}'.format(out_stream.type( + self._model.type.name))) + out_stream.write('Source path: {0}'.format( + out_stream.literal(self._model.source_path))) + if self._model.target_path is not None: + out_stream.write('Target path: {0}'.format( + out_stream.literal(self._model.target_path))) + if self._model.repository_url is not None: + out_stream.write('Repository URL: {0}'.format( + out_stream.literal(self._model.repository_url))) + if self._model.repository_credential: + out_stream.write('Repository credential: {0}'.format( + out_stream.literal(self._model.repository_credential))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + + +class Capability(common._InstanceHandlerMixin): + def coerce(self, **kwargs): + self._topology.coerce(self._model.properties, **kwargs) + + def validate(self, **kwargs): + self._topology.validate(self._model.properties) + + def dump(self, out_stream): + out_stream.write(out_stream.node(self._model.name)) + with out_stream.indent(): + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + out_stream.write('Occurrences: {0:d} ({1:d}{2})'.format( + self._model.occurrences, + self._model.min_occurrences or 0, + ' to {0:d}'.format(self._model.max_occurrences) + if self._model.max_occurrences is not None + else ' or more')) + self._topology.dump(self._model.properties, out_stream, 'Properties') + + +class Group(common._OperatorHolderHandlerMixin): + + def coerce(self, **kwargs): + self._coerce(self._model.properties, self._model.interfaces, **kwargs) + + def validate(self, **kwargs): + self._validate(self._model.properties, + self._model.interfaces) + + def dump(self, out_stream): + out_stream.write('Group: {0}'.format(out_stream.node(self._model.name))) + with out_stream.indent(): + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + self._topology.dump(self._model.interfaces, out_stream, 'Interfaces') + if self._model.nodes: + out_stream.write('Member nodes:') + with out_stream.indent(): + for node in self._model.nodes: + out_stream.write(out_stream.node(node.name)) + + def configure_operations(self): + for interface in self._model.interfaces.values(): + self._topology.configure_operations(interface) + + +class Interface(common._OperatorHolderHandlerMixin): + def coerce(self, **kwargs): + self._coerce(self._model.inputs, self._model.operations, **kwargs) + + def validate(self, **kwargs): + self._validate(self._model.inputs, + self._model.operations) + + def dump(self, out_stream): + out_stream.write(out_stream.node(self._model.name)) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + out_stream.write('Interface type: {0}'.format(out_stream.type(self._model.type.name))) + self._topology.dump(self._model.inputs, out_stream, 'Inputs') + self._topology.dump(self._model.operations, out_stream, 'Operations') + + def configure_operations(self): + for operation in self._model.operations.values(): + self._topology.configure_operations(operation) + + +class Node(common._OperatorHolderHandlerMixin): + def coerce(self, **kwargs): + self._coerce(self._model.properties, + self._model.attributes, + self._model.interfaces, + self._model.artifacts, + self._model.capabilities, + self._model.outbound_relationships, + **kwargs) + + def validate(self, **kwargs): + if len(self._model.name) > context.ID_MAX_LENGTH: + self._topology.report( + '"{0}" has an ID longer than the limit of {1:d} characters: {2:d}'.format( + self._model.name, context.ID_MAX_LENGTH, len(self._model.name)), + level=self._topology.Issue.BETWEEN_INSTANCES) + + self._validate(self._model.properties, + self._model.attributes, + self._model.interfaces, + self._model.artifacts, + self._model.capabilities, + self._model.outbound_relationships) + + def dump(self, out_stream): + out_stream.write('Node: {0}'.format(out_stream.node(self._model.name))) + with out_stream.indent(): + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + out_stream.write('Template: {0}'.format( + out_stream.node(self._model.node_template.name))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + self._topology.dump(self._model.attributes, out_stream, 'Attributes') + self._topology.dump(self._model.interfaces, out_stream, 'Interfaces') + self._topology.dump(self._model.artifacts, out_stream, 'Artifacts') + self._topology.dump(self._model.capabilities, out_stream, 'Capabilities') + self._topology.dump(self._model.outbound_relationships, out_stream, 'Relationships') + + def configure_operations(self): + for interface in self._model.interfaces.values(): + self._topology.configure_operations(interface) + for relationship in self._model.outbound_relationships: + self._topology.configure_operations(relationship) + + def validate_capabilities(self): + satisfied = False + for capability in self._model.capabilities.itervalues(): + if not capability.has_enough_relationships: + self._topology.report( + 'capability "{0}" of node "{1}" requires at least {2:d} ' + 'relationships but has {3:d}'.format(capability.name, + self._model.name, + capability.min_occurrences, + capability.occurrences), + level=self._topology.Issue.BETWEEN_INSTANCES) + satisfied = False + return satisfied + + def satisfy_requirements(self): + satisfied = True + for requirement_template in self._model.node_template.requirement_templates: + + # Since we try and satisfy requirements, which are node template bound, and use that + # information in the creation of the relationship, Some requirements may have been + # satisfied by a previous run on that node template. + # The entire mechanism of satisfying requirements needs to be refactored. + if any(r.requirement_template == requirement_template + for r in self._model.outbound_relationships): + return satisfied + + # Find target template + target_node_template, target_node_capability = self._find_target(requirement_template) + if target_node_template is not None: + satisfied = self._satisfy_capability( + target_node_capability, target_node_template, requirement_template) + else: + self._topology.report('requirement "{0}" of node "{1}" has no target node template'. + format(requirement_template.name, self._model.name), + level=self._topology.Issue.BETWEEN_INSTANCES) + satisfied = False + return satisfied + + def _satisfy_capability(self, target_node_capability, target_node_template, + requirement_template): + # Find target nodes + target_nodes = target_node_template.nodes + if target_nodes: + target_node = None + target_capability = None + + if target_node_capability is not None: + # Relate to the first target node that has capacity + for node in target_nodes: + a_target_capability = node.capabilities.get(target_node_capability.name) + if a_target_capability.relate(): + target_node = node + target_capability = a_target_capability + break + else: + # Use first target node + target_node = target_nodes[0] + + if target_node is not None: + if requirement_template.relationship_template is not None: + relationship_model = self._topology.instantiate( + requirement_template.relationship_template) + else: + relationship_model = models.Relationship() + relationship_model.name = requirement_template.name + relationship_model.requirement_template = requirement_template + relationship_model.target_node = target_node + relationship_model.target_capability = target_capability + self._model.outbound_relationships.append(relationship_model) + return True + else: + self._topology.report( + 'requirement "{0}" of node "{1}" targets node ' + 'template "{2}" but its instantiated nodes do not ' + 'have enough capacity'.format( + requirement_template.name, self._model.name, target_node_template.name), + level=self._topology.Issue.BETWEEN_INSTANCES) + return False + else: + self._topology.report( + 'requirement "{0}" of node "{1}" targets node template ' + '"{2}" but it has no instantiated nodes'.format( + requirement_template.name, self._model.name, target_node_template.name), + level=self._topology.Issue.BETWEEN_INSTANCES) + return False + + def _find_target(self, requirement_template): + # We might already have a specific node template, so we'll just verify it + if requirement_template.target_node_template is not None: + if not self._model.node_template.is_target_node_template_valid( + requirement_template.target_node_template): + self._topology.report( + 'requirement "{0}" of node template "{1}" is for node ' + 'template "{2}" but it does not match constraints'.format( + requirement_template.name, + requirement_template.target_node_template.name, + self._model.node_template.name), + level=self._topology.Issue.BETWEEN_TYPES) + if (requirement_template.target_capability_type is not None or + requirement_template.target_capability_name is not None): + target_node_capability = self._get_capability(requirement_template) + if target_node_capability is None: + return None, None + else: + target_node_capability = None + + return requirement_template.target_node_template, target_node_capability + + # Find first node that matches the type + elif requirement_template.target_node_type is not None: + for target_node_template in \ + self._model.node_template.service_template.node_templates.itervalues(): + if requirement_template.target_node_type.get_descendant( + target_node_template.type.name) is None: + continue + + if not self._model.node_template.is_target_node_template_valid( + target_node_template): + continue + + target_node_capability = self._get_capability(requirement_template, + target_node_template) + + if target_node_capability is None: + continue + + return target_node_template, target_node_capability + + elif requirement_template.target_capability_type is not None: + for target_node_template in \ + self._model.node_template.service_template.node_templates.itervalues(): + target_node_capability = \ + self._get_capability(requirement_template, target_node_template) + if target_node_capability: + return target_node_template, target_node_capability + + return None, None + + def _get_capability(self, requirement_template, target_node_template=None): + target_node_template = target_node_template or requirement_template.target_node_template + + for capability_template in target_node_template.capability_templates.values(): + if self._satisfies_requirement( + capability_template, requirement_template, target_node_template): + return capability_template + + return None + + def _satisfies_requirement( + self, capability_template, requirement_template, target_node_template): + # Do we match the required capability type? + if (requirement_template.target_capability_type and + requirement_template.target_capability_type.get_descendant( + capability_template.type.name) is None): + return False + + # Are we in valid_source_node_types? + if capability_template.valid_source_node_types: + for valid_source_node_type in capability_template.valid_source_node_types: + if valid_source_node_type.get_descendant( + self._model.node_template.type.name) is None: + return False + + # Apply requirement constraints + if requirement_template.target_node_template_constraints: + for node_template_constraint in requirement_template.target_node_template_constraints: + if not node_template_constraint.matches( + self._model.node_template, target_node_template): + return False + + return True + + +class Operation(common._OperatorHolderHandlerMixin): + def coerce(self, **kwargs): + self._coerce(self._model.inputs, + self._model.configurations, + self._model.arguments, + **kwargs) + + def validate(self, **kwargs): + self._validate(self._model.inputs, + self._model.configurations, + self._model.arguments) + + def dump(self, out_stream): + out_stream.write(out_stream.node(self._model.name)) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + if self._model.implementation is not None: + out_stream.write('Implementation: {0}'.format( + out_stream.literal(self._model.implementation))) + if self._model.dependencies: + out_stream.write( + 'Dependencies: {0}'.format( + ', '.join((str(out_stream.literal(v)) for v in self._model.dependencies)))) + self._topology.dump(self._model.inputs, out_stream, 'Inputs') + if self._model.executor is not None: + out_stream.write('Executor: {0}'.format(out_stream.literal(self._model.executor))) + if self._model.max_attempts is not None: + out_stream.write('Max attempts: {0}'.format(out_stream.literal( + self._model.max_attempts))) + if self._model.retry_interval is not None: + out_stream.write('Retry interval: {0}'.format( + out_stream.literal(self._model.retry_interval))) + if self._model.plugin is not None: + out_stream.write('Plugin: {0}'.format( + out_stream.literal(self._model.plugin.name))) + self._topology.dump(self._model.configurations, out_stream, 'Configuration') + if self._model.function is not None: + out_stream.write('Function: {0}'.format(out_stream.literal(self._model.function))) + self._topology.dump(self._model.arguments, out_stream, 'Arguments') + + def configure_operations(self): + if self._model.implementation is None and self._model.function is None: + return + + if (self._model.interface is not None and + self._model.plugin is None and + self._model.function is None): + # ("interface" is None for workflow operations, which do not currently use "plugin") + # The default (None) plugin is the execution plugin + execution_plugin.instantiation.configure_operation(self._model) + else: + # In the future plugins may be able to add their own "configure_operation" hook that + # can validate the configuration and otherwise create specially derived arguments. For + # now, we just send all configuration parameters as arguments without validation. + for key, conf in self._model.configurations.items(): + self._model.arguments[key] = self._topology.instantiate(conf.as_argument()) + + if self._model.interface is not None: + # Send all interface inputs as extra arguments + # ("interface" is None for workflow operations) + # Note that they will override existing arguments of the same names + for key, input in self._model.interface.inputs.items(): + self._model.arguments[key] = self._topology.instantiate(input.as_argument()) + + # Send all inputs as extra arguments + # Note that they will override existing arguments of the same names + for key, input in self._model.inputs.items(): + self._model.arguments[key] = self._topology.instantiate(input.as_argument()) + + # Check for reserved arguments + used_reserved_names = set(decorators.OPERATION_DECORATOR_RESERVED_ARGUMENTS).intersection( + self._model.arguments.keys()) + if used_reserved_names: + self._topology.report( + 'using reserved arguments in operation "{0}": {1}'.format( + self._model.name, formatting.string_list_as_string(used_reserved_names)), + level=self._topology.Issue.EXTERNAL) + + +class Policy(common._InstanceHandlerMixin): + def coerce(self, **kwargs): + self._topology.coerce(self._model.properties, **kwargs) + + def validate(self, **kwargs): + self._topology.validate(self._model.properties) + + def dump(self, out_stream): + out_stream.write('Policy: {0}'.format(out_stream.node(self._model.name))) + with out_stream.indent(): + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + if self._model.nodes: + out_stream.write('Target nodes:') + with out_stream.indent(): + for node in self._model.nodes: + out_stream.write(out_stream.node(node.name)) + if self._model.groups: + out_stream.write('Target groups:') + with out_stream.indent(): + for group in self._model.groups: + out_stream.write(out_stream.node(group.name)) + + +class Relationship(common._OperatorHolderHandlerMixin): + def coerce(self, **kwargs): + self._coerce(self._model.properties, + self._model.interfaces, + **kwargs) + + def validate(self, **kwargs): + self._validate(self._model.properties, + self._model.interfaces) + + def dump(self, out_stream): + if self._model.name: + out_stream.write('{0} ->'.format(out_stream.node(self._model.name))) + else: + out_stream.write('->') + with out_stream.indent(): + out_stream.write('Node: {0}'.format(out_stream.node(self._model.target_node.name))) + if self._model.target_capability: + out_stream.write('Capability: {0}'.format(out_stream.node( + self._model.target_capability.name))) + if self._model.type is not None: + out_stream.write('Relationship type: {0}'.format( + out_stream.type(self._model.type.name))) + if (self._model.relationship_template is not None and + self._model.relationship_template.name): + out_stream.write('Relationship template: {0}'.format( + out_stream.node(self._model.relationship_template.name))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + self._topology.dump(self._model.interfaces, out_stream, 'Interfaces') + + def configure_operations(self): + for interface in self._model.interfaces.values(): + self._topology.configure_operations(interface) + + +class Service(common._OperatorHolderHandlerMixin): + def coerce(self, **kwargs): + self._coerce(self._model.meta_data, + self._model.nodes, + self._model.groups, + self._model.policies, + self._model.substitution, + self._model.inputs, + self._model.outputs, + self._model.workflows, + **kwargs) + + def validate(self, **kwargs): + self._validate(self._model.meta_data, + self._model.nodes, + self._model.groups, + self._model.policies, + self._model.substitution, + self._model.inputs, + self._model.outputs, + self._model.workflows) + + def dump(self, out_stream): + if self._model.description is not None: + out_stream.write(out_stream.meta(self._model.description)) + self._topology.dump(self._model.meta_data, out_stream, 'Metadata') + self._topology.dump(self._model.nodes, out_stream) + self._topology.dump(self._model.groups, out_stream) + self._topology.dump(self._model.policies, out_stream) + self._topology.dump(self._model.substitution, out_stream) + self._topology.dump(self._model.inputs, out_stream, 'Inputs') + self._topology.dump(self._model.outputs, out_stream, 'Outputs') + self._topology.dump(self._model.workflows, out_stream, 'Workflows') + + def configure_operations(self): + for node in self._model.nodes.itervalues(): + self._topology.configure_operations(node) + for group in self._model.groups.itervalues(): + self._topology.configure_operations(group) + for operation in self._model.workflows.itervalues(): + self._topology.configure_operations(operation) + + def validate_capabilities(self): + satisfied = True + for node in self._model.nodes.values(): + if not self._topology.validate_capabilities(node): + satisfied = False + return satisfied + + def satisfy_requirements(self): + return all(self._topology.satisfy_requirements(node) + for node in self._model.nodes.values()) + + +class Substitution(common._InstanceHandlerMixin): + def coerce(self, **kwargs): + self._topology.coerce(self._model.mappings, **kwargs) + + def validate(self, **kwargs): + self._topology.validate(self._model.mappings) + + def dump(self, out_stream): + out_stream.write('Substitution:') + with out_stream.indent(): + out_stream.write('Node type: {0}'.format(out_stream.type(self._model.node_type.name))) + self._topology.dump(self._model.mappings, out_stream, 'Mappings') + + +class SubstitutionMapping(common._InstanceHandlerMixin): + + def validate(self, **kwargs): + if (self._model.capability is None) and (self._model.requirement_template is None): + self._topology.report( + 'mapping "{0}" refers to neither capability nor a requirement' + ' in node: {1}'.format( + self._model.name, formatting.safe_repr(self._model.node.name)), + level=self._topology.Issue.BETWEEN_TYPES) + + def dump(self, out_stream): + if self._model.capability is not None: + out_stream.write('{0} -> {1}.{2}'.format( + out_stream.node(self._model.name), + out_stream.node(self._model.capability.node.name), + out_stream.node(self._model.capability.name))) + else: + out_stream.write('{0} -> {1}.{2}'.format( + out_stream.node(self._model.name), + out_stream.node(self._model.node.name), + out_stream.node(self._model.requirement_template.name))) + + +class Metadata(common._InstanceHandlerMixin): + + def dump(self, out_stream): + out_stream.write('{0}: {1}'.format( + out_stream.property(self._topology.name), + out_stream.literal(self._topology.value))) + + def coerce(self): + pass + + def instantiate(self, instance_cls, **kwargs): + return instance_cls(name=self._model.name, value=self._model.value) + + def validate(self): + pass + + +class _Parameter(common._InstanceHandlerMixin): + + def dump(self, out_stream): + if self._model.type_name is not None: + out_stream.write('{0}: {1} ({2})'.format( + out_stream.property(self._model.name), + out_stream.literal(formatting.as_raw(self._model.value)), + out_stream.type(self._model.type_name))) + else: + out_stream.write('{0}: {1}'.format( + out_stream.property(self._model.name), + out_stream.literal(formatting.as_raw(self._model.value)))) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + + def instantiate(self, instance_cls, **kwargs): + return instance_cls( + name=self._model.name, # pylint: disable=unexpected-keyword-arg + type_name=self._model.type_name, + _value=self._model._value, + description=self._model.description + ) + + def validate(self): + pass + + +class Attribute(_Parameter): + pass + + +class Input(_Parameter): + pass + + +class Output(_Parameter): + pass + + +class Argument(_Parameter): + pass + + +class Property(_Parameter): + pass + + +class Configuration(_Parameter): + pass + + +class Type(common._InstanceHandlerMixin): + def coerce(self): + pass + + def dump(self, out_stream): + if self._model.name: + out_stream.write(out_stream.type(self._model.name)) + with out_stream.indent(): + for child in self._model.children: + self._topology.dump(child, out_stream) http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/orchestrator/topology/template_handler.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/topology/template_handler.py b/aria/orchestrator/topology/template_handler.py new file mode 100644 index 0000000..78aadf0 --- /dev/null +++ b/aria/orchestrator/topology/template_handler.py @@ -0,0 +1,591 @@ +# 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 datetime import datetime + +from ...utils import formatting +from ...modeling import utils as modeling_utils +from . import utils, common + + +class ServiceTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + if self._model.description is not None: + out_stream.write(out_stream.meta(self._model.description)) + self._topology.dump(self._model.meta_data, out_stream, 'Metadata') + self._topology.dump(self._model.node_templates, out_stream) + self._topology.dump(self._model.group_templates, out_stream) + self._topology.dump(self._model.policy_templates, out_stream) + self._topology.dump(self._model.substitution_template, out_stream) + self._topology.dump(self._model.inputs, out_stream, 'Inputs') + self._topology.dump(self._model.outputs, out_stream, 'Outputs') + self._topology.dump(self._model.workflow_templates, out_stream, 'Workflow templates') + + def coerce(self, **kwargs): + self._coerce(self._model.meta_data, + self._model.node_templates, + self._model.group_templates, + self._model.policy_templates, + self._model.substitution_template, + self._model.inputs, + self._model.outputs, + self._model.workflow_templates, + **kwargs) + + def instantiate(self, instance_cls, inputs=None): # pylint: disable=arguments-differ + now = datetime.now() + service = instance_cls( + created_at=now, + updated_at=now, + description=utils.deepcopy_with_locators(self._model.description), + service_template=self._model, + inputs=modeling_utils.merge_parameter_values(inputs, self._model.inputs) + ) + + for plugin_specification in self._model.plugin_specifications.itervalues(): + if plugin_specification.enabled and self._topology._model_storage: + if utils.resolve_plugin_specification(plugin_specification, + self._topology.model_storage.plugin.list()): + plugin = plugin_specification.plugin + service.plugins[plugin.name] = plugin + else: + self._topology.report('specified plugin not found: {0}'.format( + plugin_specification.name), level=self._topology.Issue.EXTERNAL) + service.meta_data = self._topology.instantiate(self._model.meta_data) + + for node_template in self._model.node_templates.itervalues(): + for _ in range(self._scaling(node_template)['default_instances']): + node = self._topology.instantiate(node_template) + service.nodes[node.name] = node + + service.groups = self._topology.instantiate(self._model.group_templates) + service.policies = self._topology.instantiate(self._model.policy_templates) + service.workflows = self._topology.instantiate(self._model.workflow_templates) + service.substitution = self._topology.instantiate(self._model.substitution_template) + service.outputs = self._topology.instantiate(self._model.outputs) + + return service + + def _scaling(self, node_template): + scaling = {} + + def extract_property(properties, name): + if name in scaling: + return + prop = properties.get(name) + if (prop is not None) and (prop.type_name == 'integer') and (prop.value is not None): + scaling[name] = prop.value + + def extract_properties(properties): + extract_property(properties, 'min_instances') + extract_property(properties, 'max_instances') + extract_property(properties, 'default_instances') + + # From our scaling capabilities + for capability_template in node_template.capability_templates.itervalues(): + if capability_template.type.role == 'scaling': + extract_properties(capability_template.properties) + + # From service scaling policies + for policy_template in node_template.service_template.policy_templates.itervalues(): + if policy_template.type.role == 'scaling': + if policy_template.is_for_node_template(node_template.name): + extract_properties(policy_template.properties) + + # Defaults + scaling.setdefault('min_instances', 0) + scaling.setdefault('max_instances', 1) + scaling.setdefault('default_instances', 1) + + # Validate + # pylint: disable=too-many-boolean-expressions + if (scaling['min_instances'] < 0 or + scaling['max_instances'] < 0 or + scaling['default_instances'] < 0 or + scaling['max_instances'] < scaling['min_instances'] or + scaling['default_instances'] < scaling['min_instances'] or + scaling['default_instances'] > scaling['max_instances']): + self._topology.report( + 'invalid scaling parameters for node template "{0}": min={min_instances}, max=' + '{max_instances}, default={default_instances}'.format(self._model.name, **scaling), + level=self._topology.Issue.BETWEEN_TYPES) + + return scaling + + def validate(self): + self._topology.validate(self._model.meta_data) + self._topology.validate(self._model.node_templates) + self._topology.validate(self._model.group_templates) + self._topology.validate(self._model.policy_templates) + self._topology.validate(self._model.substitution_template) + self._topology.validate(self._model.inputs) + self._topology.validate(self._model.outputs) + self._topology.validate(self._model.workflow_templates) + self._topology.validate(self._model.node_types) + self._topology.validate(self._model.group_types) + self._topology.validate(self._model.policy_types) + self._topology.validate(self._model.relationship_types) + self._topology.validate(self._model.capability_types) + self._topology.validate(self._model.interface_types) + self._topology.validate(self._model.artifact_types) + + +class ArtifactTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + out_stream.write(out_stream.node(self._model.name)) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + out_stream.write('Artifact type: {0}'.format(out_stream.type(self._model.type.name))) + out_stream.write('Source path: {0}'.format(out_stream.literal(self._model.source_path))) + if self._model.target_path is not None: + out_stream.write('Target path: {0}'.format(out_stream.literal( + self._model.target_path))) + if self._model.repository_url is not None: + out_stream.write('Repository URL: {0}'.format( + out_stream.literal(self._model.repository_url))) + if self._model.repository_credential: + out_stream.write('Repository credential: {0}'.format( + out_stream.literal(self._model.repository_credential))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + + def coerce(self, **kwargs): + self._topology.coerce(self._model.properties, **kwargs) + + def instantiate(self, instance_cls): + return instance_cls( + name=self._model.name, + type=self._model.type, + description=utils.deepcopy_with_locators(self._model.description), + source_path=self._model.source_path, + target_path=self._model.target_path, + repository_url=self._model.repository_url, + repository_credential=self._model.repository_credential, + artifact_template=self._model) + + def validate(self): + self._topology.validate(self._model.properties) + + +class CapabilityTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + out_stream.write(out_stream.node(self._model.name)) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + out_stream.write( + 'Occurrences: {0:d}{1}'.format( + self._model.min_occurrences or 0, + ' to {0:d}'.format(self._model.max_occurrences) + if self._model.max_occurrences is not None + else ' or more')) + if self._model.valid_source_node_types: + out_stream.write('Valid source node types: {0}'.format( + ', '.join((str(out_stream.type(v.name)) + for v in self._model.valid_source_node_types)))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + + def coerce(self): + self._topology.coerce(self._model.properties) + + def instantiate(self, instance_cls): + return instance_cls(name=self._model.name, + type=self._model.type, + min_occurrences=self._model.min_occurrences, + max_occurrences=self._model.max_occurrences, + occurrences=0, + capability_template=self._model) + + def validate(self): + self._topology.validate(self._model.properties) + + +class RequirementTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + if self._model.name: + out_stream.write(out_stream.node(self._model.name)) + else: + out_stream.write('Requirement:') + with out_stream.indent(): + if self._model.target_node_type is not None: + out_stream.write('Target node type: {0}'.format( + out_stream.type(self._model.target_node_type.name))) + elif self._model.target_node_template is not None: + out_stream.write('Target node template: {0}'.format( + out_stream.node(self._model.target_node_template.name))) + if self._model.target_capability_type is not None: + out_stream.write('Target capability type: {0}'.format( + out_stream.type(self._model.target_capability_type.name))) + elif self._model.target_capability_name is not None: + out_stream.write('Target capability name: {0}'.format( + out_stream.node(self._model.target_capability_name))) + if self._model.target_node_template_constraints: + out_stream.write('Target node template constraints:') + with out_stream.indent(): + for constraint in self._model.target_node_template_constraints: + out_stream.write(out_stream.literal(constraint)) + if self._model.relationship_template: + out_stream.write('Relationship:') + with out_stream.indent(): + self._topology.dump(self._model.relationship_template, out_stream) + + def coerce(self, **kwargs): + self._topology.coerce(self._model.relationship_template, **kwargs) + + def instantiate(self, instance_cls): + return instance_cls(name=self._model.name, + type=self._model.type, + min_occurrences=self._model.min_occurrences, + max_occurrences=self._model.max_occurrences, + occurrences=0, + capability_template=self._model) + + def validate(self): + self._topology.validate(self._model.relationship_template) + + +class GroupTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + out_stream.write('Group template: {0}'.format(out_stream.node(self._model.name))) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + self._topology.dump(self._model.interface_templates, out_stream, 'Interface Templates') + if self._model.node_templates: + out_stream.write('Member node templates: {0}'.format(', '.join( + (str(out_stream.node(v.name)) for v in self._model.node_templates)))) + + def coerce(self, **kwargs): + self._coerce(self._model.properties, + self._model.interface_templates, + **kwargs) + + def instantiate(self, instance_cls): + group = instance_cls( + name=self._model.name, + type=self._model.type, + description=utils.deepcopy_with_locators(self._model.description), + group_template=self._model) + group.properties = self._topology.instantiate(self._model.properties) + group.interfaces = self._topology.instantiate(self._model.interface_templates) + if self._model.node_templates: + for node_template in self._model.node_templates: + group.nodes += node_template.nodes + return group + + def validate(self): + self._validate(self._model.properties, + self._model.interface_templates) + + +class InterfaceTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + out_stream.write(out_stream.node(self._model.name)) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + out_stream.write('Interface type: {0}'.format(out_stream.type(self._model.type.name))) + self._topology.dump(self._model.inputs, out_stream, 'Inputs') + self._topology.dump(self._model.operation_templates, out_stream, 'Operation templates') + + def coerce(self, **kwargs): + self._coerce(self._model.inputs, + self._model.operation_templates, + **kwargs) + + def instantiate(self, instance_cls): + interface = instance_cls( + name=self._model.name, + type=self._model.type, + description=utils.deepcopy_with_locators(self._model.description), + interface_template=self._model) + interface.inputs = self._topology.instantiate(self._model.inputs) + interface.operations = self._topology.instantiate(self._model.operation_templates) + return interface + + def validate(self): + self._validate(self._model.inputs, + self._model.operation_templates) + + +class NodeTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + out_stream.write('Node template: {0}'.format(out_stream.node(self._model.name))) + with out_stream.indent(): + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + self._topology.dump(self._model.attributes, out_stream, 'Attributes') + self._topology.dump( + self._model.interface_templates, out_stream, 'Interface Templates') + self._topology.dump( + self._model.artifact_templates, out_stream, 'Artifact Templates') + self._topology.dump( + self._model.capability_templates, out_stream, 'Capability Templates') + self._topology.dump( + self._model.requirement_templates, out_stream, 'Requirement Templates') + + def coerce(self, **kwargs): + self._coerce(self._model.properties, + self._model.attributes, + self._model.interface_templates, + self._model.artifact_templates, + self._model.capability_templates, + self._model.requirement_templates, + **kwargs) + + def instantiate(self, instance_cls): + node = instance_cls( + name=self._model._next_name, + type=self._model.type, + description=utils.deepcopy_with_locators(self._model.description), + node_template=self._model + ) + + node.properties = self._topology.instantiate(self._model.properties) + node.attributes = self._topology.instantiate(self._model.attributes) + node.interfaces = self._topology.instantiate(self._model.interface_templates) + node.artifacts = self._topology.instantiate(self._model.artifact_templates) + node.capabilities = self._topology.instantiate(self._model.capability_templates) + + # Default attributes + if 'tosca_name' in node.attributes and node.attributes['tosca_name'].type_name == 'string': + node.attributes['tosca_name'].value = self._model.name + if 'tosca_id' in node.attributes and node.attributes['tosca_id'].type_name == 'string': + node.attributes['tosca_id'].value = node.name + + return node + + def validate(self): + self._validate(self._model.properties, + self._model.attributes, + self._model.interface_templates, + self._model.artifact_templates, + self._model.capability_templates, + self._model.requirement_templates) + + +class PolicyTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + out_stream.write('Policy template: {0}'.format(out_stream.node(self._model.name))) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + out_stream.write('Type: {0}'.format(out_stream.type(self._model.type.name))) + self._topology.dump(self._model.properties, out_stream, 'Properties') + if self._model.node_templates: + out_stream.write('Target node templates: {0}'.format(', '.join( + (str(out_stream.node(v.name)) for v in self._model.node_templates)))) + if self._model.group_templates: + out_stream.write('Target group templates: {0}'.format(', '.join( + (str(out_stream.node(v.name)) for v in self._model.group_templates)))) + + def coerce(self, **kwargs): + self._topology.coerce(self._model.properties, **kwargs) + + def instantiate(self, instance_cls): + policy = instance_cls( + name=self._model.name, + type=self._model.type, + description=utils.deepcopy_with_locators(self._model.description), + policy_template=self._model) + + policy.properties = self._topology.instantiate(self._model.properties) + if self._model.node_templates: + for node_template in self._model.node_templates: + policy.nodes += node_template.nodes + if self._model.group_templates: + for group_template in self._model.group_templates: + policy.groups += group_template.groups + return policy + + def validate(self): + self._topology.validate(self._model.properties) + + +class SubstitutionTemplate(common._TemplateHandlerMixin): + + def dump(self, out_stream): + out_stream.write('Substitution template:') + with out_stream.indent(): + out_stream.write('Node type: {0}'.format(out_stream.type(self._model.node_type.name))) + self._topology.dump(self._model.mappings, out_stream, 'Mappings') + + def coerce(self, **kwargs): + self._topology.coerce(self._model.mappings, **kwargs) + + def instantiate(self, instance_cls): + return instance_cls(node_type=self._model.node_type, + substitution_template=self._model) + + def validate(self): + self._topology.validate(self._model.mappings) + + +class SubstitutionTemplateMapping(common._TemplateHandlerMixin): + + def dump(self, out_stream): + if self._topology.capability_template is not None: + node_template = self._topology.capability_template.node_template + else: + node_template = self._topology.requirement_template.node_template + out_stream.write('{0} -> {1}.{2}'.format( + out_stream.node(self._topology.name), + out_stream.node(node_template.name), + out_stream.node(self._topology.capability_template.name + if self._topology.capability_template + else self._topology.requirement_template.name))) + + def coerce(self): + pass + + def instantiate(self, instance_cls): + substitution_mapping = instance_cls( + name=self._model.name, + requirement_template=self._model.requirement_template) + + if self._model.capability_template is not None: + node_template = self._model.capability_template.node_template + else: + node_template = self._model.requirement_template.node_template + nodes = node_template.nodes + if len(nodes) == 0: + self._topology.report( + 'mapping "{0}" refers to node template "{1}" but there are no node instances'. + format(self._model.mapped_name, self._model.node_template.name), + level=self._topology.Issue.BETWEEN_INSTANCES) + return None + # The TOSCA spec does not provide a way to choose the node, + # so we will just pick the first one + substitution_mapping.node = nodes[0] + if self._model.capability_template: + for a_capability in substitution_mapping.node.capabilities.itervalues(): + if a_capability.capability_template.name == \ + self._model.capability_template.name: + substitution_mapping.capability = a_capability + + return substitution_mapping + + def validate(self): + if self._model.capability_template is None and self._model.requirement_template is None: + self._topology.report( + 'mapping "{0}" refers to neither capability nor a requirement ' + 'in node template: {1}'.format( + self._model.name, formatting.safe_repr(self._model.node_template.name)), + level=self._topology.Issue.BETWEEN_TYPES) + + +class RelationshipTemplate(common._TemplateHandlerMixin): + def dump(self, out_stream): + if self._model.type is not None: + out_stream.write('Relationship type: {0}'.format(out_stream.type( + self._model.type.name))) + else: + out_stream.write('Relationship template: {0}'.format( + out_stream.node(self._model.name))) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + self._topology.dump(self._model.properties, out_stream, 'Properties') + self._topology.dump(self._model.interface_templates, out_stream, 'Interface Templates') + + def coerce(self, **kwargs): + self._coerce(self._model.properties, self._model.interface_templates, **kwargs) + + def instantiate(self, instance_cls): + relationship = instance_cls( + name=self._model.name, + type=self._model.type, + relationship_template=self._model) + + relationship.properties = self._topology.instantiate(self._model.properties) + relationship.interfaces = self._topology.instantiate(self._model.interface_templates) + return relationship + + def validate(self): + self._validate(self._model.properties, self._model.interface_templates) + + +class OperationTemplate(common._TemplateHandlerMixin): + + def dump(self, out_stream): + out_stream.write(out_stream.node(self._model.name)) + if self._model.description: + out_stream.write(out_stream.meta(self._model.description)) + with out_stream.indent(): + if self._model.implementation is not None: + out_stream.write('Implementation: {0}'.format( + out_stream.literal(self._model.implementation))) + if self._model.dependencies: + out_stream.write('Dependencies: {0}'.format( + ', '.join((str(out_stream.literal(v)) for v in self._model.dependencies)))) + self._topology.dump(self._model.inputs, out_stream, 'Inputs') + if self._model.executor is not None: + out_stream.write('Executor: {0}'.format(out_stream.literal(self._model.executor))) + if self._model.max_attempts is not None: + out_stream.write('Max attempts: {0}'.format(out_stream.literal( + self._model.max_attempts))) + if self._model.retry_interval is not None: + out_stream.write('Retry interval: {0}'.format( + out_stream.literal(self._model.retry_interval))) + if self._model.plugin_specification is not None: + out_stream.write('Plugin specification: {0}'.format( + out_stream.literal(self._model.plugin_specification.name))) + self._topology.dump(self._model.configurations, out_stream, 'Configuration') + if self._model.function is not None: + out_stream.write('Function: {0}'.format(out_stream.literal(self._model.function))) + + def coerce(self, **kwargs): + self._coerce(self._model.inputs, + self._model.configurations, + **kwargs) + + def instantiate(self, instance_cls): + operation = instance_cls( + name=self._model.name, + description=utils.deepcopy_with_locators(self._model.description), + relationship_edge=self._model.relationship_edge, + implementation=self._model.implementation, + dependencies=self._model.dependencies, + executor=self._model.executor, + function=self._model.function, + max_attempts=self._model.max_attempts, + retry_interval=self._model.retry_interval, + operation_template=self._model) + + if (self._model.plugin_specification is not None and + self._model.plugin_specification.enabled): + operation.plugin = self._model.plugin_specification.plugin + + operation.inputs = self._topology.instantiate(self._model.inputs) + operation.configurations = self._topology.instantiate(self._model.configurations) + + return operation + + def validate(self): + self._validate(self._model.inputs, + self._model.configurations) + + +class PluginSpecification(common._TemplateHandlerMixin): + def instantiate(self, **kwargs): + pass + + def dump(self, out_stream): + pass http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/orchestrator/topology/topology.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/topology/topology.py b/aria/orchestrator/topology/topology.py new file mode 100644 index 0000000..4b47432 --- /dev/null +++ b/aria/orchestrator/topology/topology.py @@ -0,0 +1,266 @@ +# 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 +from contextlib import contextmanager + +from ...parser.validation import issue +from ...modeling import models +from ...utils import ( + console, + formatting +) +from . import ( + template_handler, + instance_handler, + common +) + + +class _Stylizer(object): + def __init__(self, indentation=2): + self._str = StringIO() + self._indentation = indentation + + def write(self, str_): + console.puts(str_, stream=self._str) + + @contextmanager + def indent(self, indent=None): + with console.indent(indent or self._indentation): + yield + + @staticmethod + def section(value): + return console.Colored.cyan(value, bold=True) + + @staticmethod + def type(value): + return console.Colored.blue(value, bold=True) + + @staticmethod + def node(value): + return console.Colored.red(value, bold=True) + + @staticmethod + def property(value): + return console.Colored.magenta(value, bold=True) + + @staticmethod + def literal(value): + return console.Colored.magenta(formatting.safe_repr(value)) + + @staticmethod + def meta(value): + return console.Colored.green(value) + + def __repr__(self): + return self._str.getvalue() + + def __str__(self): + return repr(self) + + +class Topology(issue.Reporter): + + _init_map = { + models.ServiceTemplate: models.Service, + models.ArtifactTemplate: models.Artifact, + models.CapabilityTemplate: models.Capability, + models.GroupTemplate: models.Group, + models.InterfaceTemplate: models.Interface, + models.NodeTemplate: models.Node, + models.PolicyTemplate: models.Policy, + models.SubstitutionTemplate: models.Substitution, + models.RelationshipTemplate: models.Relationship, + models.OperationTemplate: models.Operation, + models.RequirementTemplate: None, + models.SubstitutionTemplateMapping: models.SubstitutionMapping, + + # Common + models.Metadata: models.Metadata, + models.Attribute: models.Attribute, + models.Property: models.Property, + models.Input: models.Input, + models.Output: models.Output, + models.Configuration: models.Configuration, + models.Argument: models.Argument, + models.Type: models.Type + } + + def __init__(self, model_storage=None, *args, **kwargs): + # TODO: model storage is required only for the list of plugins, can we get it + # somewhere else? + super(Topology, self).__init__(*args, **kwargs) + self._model_storage = model_storage + self._handlers = dict(self._init_handlers(instance_handler), + **self._init_handlers(template_handler)) + + @staticmethod + def _init_handlers(module_): + handlers = {} + for attribute_name in dir(module_): + if attribute_name.startswith('_'): + continue + attribute = getattr(module_, attribute_name) + if isinstance(attribute, type) and issubclass(attribute, common._Handler): + handlers[getattr(models, attribute_name)] = attribute + return handlers + + def instantiate(self, model, **kwargs): + """ + all handlers used by instantiate should hold a tuple as value (handler, instnace_cls) + :param model: + :param kwargs: + :return: + """ + if isinstance(model, dict): + return dict((name, self.instantiate(value, **kwargs)) + for name, value in model.iteritems()) + elif isinstance(model, list): + return list(self.instantiate(value, **kwargs) for value in model) + elif model is not None: + _handler = self._handlers.get(model.__class__) + instance_cls = self._init_map.get(model.__class__) + return _handler(self, model).instantiate(instance_cls, **kwargs) + + def validate(self, model, **kwargs): + if isinstance(model, dict): + return self.validate(model.values()) + elif isinstance(model, list): + return all(self.validate(value) for value in model) + elif model is not None: + _handler = self._handlers.get(model.__class__) + return _handler(self, model).validate(**kwargs) + + def dump(self, model, out_stream=None, section_name=None, **kwargs): + out_stream = out_stream or _Stylizer() + + # if model is empty, no need to print out the section name + if model and section_name: + out_stream.write('{0}:'.format(section_name)) + + if isinstance(model, dict): + if str(out_stream): + with out_stream.indent(): + return self.dump(model.values(), out_stream=out_stream, **kwargs) + else: + return self.dump(model.values(), out_stream=out_stream, **kwargs) + + elif isinstance(model, list): + for value in model: + self.dump(value, out_stream=out_stream, **kwargs) + + elif model is not None: + _handler = self._handlers.get(model.__class__) + _handler(self, model).dump(out_stream=out_stream, **kwargs) + + return out_stream + + def dump_graph(self, service, **kwargs): + out_stream = _Stylizer() + for node in service.nodes.itervalues(): + if not node.inbound_relationships: + self._dump_graph_node(out_stream, node) + return out_stream + + def _dump_graph_node(self, out_stream, node, capability=None): + out_stream.write(out_stream.node(node.name)) + if capability is not None: + out_stream.write('{0} ({1})'.format(out_stream.property(capability.name), + out_stream.type(capability.type.name))) + if node.outbound_relationships: + with out_stream.indent(): + for relationship_model in node.outbound_relationships: + relationship_name = out_stream.property(relationship_model.name) + if relationship_model.type is not None: + out_stream.write('-> {0} ({1})'.format( + relationship_name, out_stream.type(relationship_model.type.name))) + else: + out_stream.write('-> {0}'.format(relationship_name)) + with out_stream.indent(3): + self._dump_graph_node(out_stream, + relationship_model.target_node, + relationship_model.target_capability) + + def coerce(self, model, **kwargs): + if isinstance(model, dict): + return self.validate(model.values()) + elif isinstance(model, list): + return all(self.validate(value) for value in model) + elif model is not None: + _handler = self._handlers.get(model.__class__) + return _handler(self, model).coerce(**kwargs) + + def dump_types(self, service_template, out_stream=None): + out_stream = out_stream or _Stylizer() + self.dump(service_template.node_types, out_stream, 'Node types') + self.dump(service_template.group_types, out_stream, 'Group types') + self.dump(service_template.capability_types, out_stream, 'Capability types') + self.dump(service_template.relationship_types, out_stream, 'Relationship types') + self.dump(service_template.policy_types, out_stream, 'Policy types') + self.dump(service_template.artifact_types, out_stream, 'Artifact types') + self.dump(service_template.interface_types, out_stream, 'Interface types') + + return str(out_stream) + + def satisfy_requirements(self, model, **kwargs): + if isinstance(model, dict): + return self.satisfy_requirements(model.values()) + elif isinstance(model, list): + return all(self.satisfy_requirements(value) for value in model) + elif model is not None: + _handler = self._handlers.get(model.__class__) + return _handler(self, model).satisfy_requirements(**kwargs) + + def validate_capabilities(self, model, **kwargs): + if isinstance(model, dict): + return self.validate_capabilities(model.values()) + elif isinstance(model, list): + return all(self.validate_capabilities(value) for value in model) + elif model is not None: + _handler = self._handlers.get(model.__class__) + return _handler(self, model).validate_capabilities(**kwargs) + + def _find_host(self, node): + if node.type.role == 'host': + return node + + has_role = lambda rel, role: \ + rel.target_capability is not None and rel.target_capability.type.role == role + + for relationship in node.outbound_relationships: + if has_role(relationship, 'host'): + host = self._find_host(relationship.target_node) + if host is not None: + return host + for relationship in node.inbound_relationships: + if has_role(relationship, 'feature'): + host = self._find_host(relationship.source_node) + if host is not None: + return host + return None + + def find_hosts(self, service): + for node in service.nodes.values(): + node.host = self._find_host(node) + + def configure_operations(self, model, **kwargs): + if isinstance(model, dict): + return self.configure_operations(model.values()) + elif isinstance(model, list): + return all(self.configure_operations(value) for value in model) + elif model is not None: + _handler = self._handlers.get(model.__class__) + return _handler(self, model).configure_operations(**kwargs) http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/orchestrator/topology/utils.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/topology/utils.py b/aria/orchestrator/topology/utils.py new file mode 100644 index 0000000..47396a5 --- /dev/null +++ b/aria/orchestrator/topology/utils.py @@ -0,0 +1,67 @@ +# 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 copy import deepcopy + +from ...utils.versions import VersionString + + +def deepcopy_with_locators(value): + """ + Like :func:`deepcopy`, but also copies over locators. + """ + + res = deepcopy(value) + copy_locators(res, value) + return res + + +def copy_locators(target, source): + """ + Copies over ``_locator`` for all elements, recursively. + + Assumes that target and source have exactly the same list/dict structure. + """ + + locator = getattr(source, '_locator', None) + if locator is not None: + try: + setattr(target, '_locator', locator) + except AttributeError: + pass + + if isinstance(target, list) and isinstance(source, list): + for i, _ in enumerate(target): + copy_locators(target[i], source[i]) + elif isinstance(target, dict) and isinstance(source, dict): + for k, v in target.items(): + copy_locators(v, source[k]) + + +def resolve_plugin_specification(plugin_specification, plugins): + matching_plugins = [] + if plugins: + for plugin in plugins: + if (plugin.name == plugin_specification.name and + (plugin_specification.version is None or + VersionString(plugin.package_version) >= plugin_specification.version) + ): + matching_plugins.append(plugin) + plugin_specification.plugin = None + if matching_plugins: + # Return highest version of plugin + plugin_specification.plugin = \ + max(matching_plugins, key=lambda plugin: VersionString(plugin.package_version).key) + return plugin_specification.plugin is not None http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/parser/consumption/__init__.py ---------------------------------------------------------------------- diff --git a/aria/parser/consumption/__init__.py b/aria/parser/consumption/__init__.py index bd4b29c..f9caf5f 100644 --- a/aria/parser/consumption/__init__.py +++ b/aria/parser/consumption/__init__.py @@ -20,7 +20,6 @@ Consumption package. :nosignatures: aria.parser.consumption.ConsumptionContext - aria.parser.consumption.Style Consumers --------- @@ -47,7 +46,6 @@ Consumers from .exceptions import ConsumerException from .context import ConsumptionContext -from .style import Style from .consumer import ( Consumer, ConsumerChain @@ -70,7 +68,6 @@ from .inputs import Inputs __all__ = ( 'ConsumerException', 'ConsumptionContext', - 'Style', 'Consumer', 'ConsumerChain', 'Read', http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/parser/consumption/consumer.py ---------------------------------------------------------------------- diff --git a/aria/parser/consumption/consumer.py b/aria/parser/consumption/consumer.py index 4f4c614..fb60d66 100644 --- a/aria/parser/consumption/consumer.py +++ b/aria/parser/consumption/consumer.py @@ -14,6 +14,7 @@ # limitations under the License. +from ...orchestrator import topology from ...exceptions import AriaException from ...utils.exceptions import print_exception from ..validation import Issue @@ -27,6 +28,7 @@ class Consumer(object): """ def __init__(self, context): + self.topology = topology.Topology() self.context = context def consume(self): @@ -73,6 +75,10 @@ class ConsumerChain(Consumer): handle_exception(consumer, e) else: raise e + + if consumer.topology.has_issues: + self.context.validation.extend_issues(consumer.topology.issues) + if self.context.validation.has_issues: break http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/90107846/aria/parser/consumption/context.py ---------------------------------------------------------------------- diff --git a/aria/parser/consumption/context.py b/aria/parser/consumption/context.py index 6fa61f4..5b2f31b 100644 --- a/aria/parser/consumption/context.py +++ b/aria/parser/consumption/context.py @@ -21,7 +21,6 @@ from ..loading import LoadingContext from ..reading import ReadingContext from ..presentation import PresentationContext from ..modeling import ModelingContext -from .style import Style _thread_locals = threading.local() @@ -58,7 +57,6 @@ class ConsumptionContext(object): def __init__(self, set_thread_local=True): self.args = [] self.out = sys.stdout - self.style = Style() self.validation = ValidationContext() self.loading = LoadingContext() self.reading = ReadingContext()
