http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/56841a4d/aria/modeling/utils.py
----------------------------------------------------------------------
diff --git a/aria/modeling/utils.py b/aria/modeling/utils.py
index 274eb88..5218b81 100644
--- a/aria/modeling/utils.py
+++ b/aria/modeling/utils.py
@@ -22,8 +22,6 @@ from json import JSONEncoder
 from StringIO import StringIO
 
 from . import exceptions
-from ..parser.consumption import ConsumptionContext
-from ..utils.console import puts
 from ..utils.type import validate_value_type
 from ..utils.collections import OrderedDict
 from ..utils.formatting import string_list_as_string
@@ -84,7 +82,7 @@ def validate_required_inputs_are_supplied(declared_inputs, 
supplied_inputs):
             .format(string_list_as_string(missing_required_inputs)))
 
 
-def merge_parameter_values(provided_values, declared_parameters, model_cls):
+def merge_parameter_values(provided_values, declared_parameters, 
model_cls=None):
     """
     Merges parameter values according to those declared by a type.
 
@@ -109,6 +107,7 @@ def merge_parameter_values(provided_values, 
declared_parameters, model_cls):
     provided_values = provided_values or {}
     provided_values_of_wrong_type = OrderedDict()
     model_parameters = OrderedDict()
+    model_cls = model_cls or get_class_from_relationship(declared_parameters)
 
     for declared_parameter_name, declared_parameter in 
declared_parameters.iteritems():
         if declared_parameter_name in provided_values:
@@ -125,14 +124,14 @@ def merge_parameter_values(provided_values, 
declared_parameters, model_cls):
                 # TODO This error shouldn't be raised (or caught), but right 
now we lack support
                 # for custom data_types, which will raise this error. Skipping 
their validation.
                 pass
-            model_parameters[declared_parameter_name] = model_cls( # pylint: 
disable=unexpected-keyword-arg
+            model_parameters[declared_parameter_name] = model_cls(             
                     # pylint: disable=unexpected-keyword-arg
                 name=declared_parameter_name,
                 type_name=type_name,
                 description=declared_parameter.description,
                 value=value)
         else:
             # Copy default value from declaration
-            model_parameters[declared_parameter_name] = 
declared_parameter.instantiate(None)
+            model_parameters[declared_parameter_name] = 
model_cls(**declared_parameter.as_raw)
 
     if provided_values_of_wrong_type:
         error_message = StringIO()
@@ -144,76 +143,6 @@ def merge_parameter_values(provided_values, 
declared_parameters, model_cls):
     return model_parameters
 
 
-def coerce_dict_values(the_dict, report_issues=False):
-    if not the_dict:
-        return
-    coerce_list_values(the_dict.itervalues(), report_issues)
-
-
-def coerce_list_values(the_list, report_issues=False):
-    if not the_list:
-        return
-    for value in the_list:
-        value.coerce_values(report_issues)
-
-
-def validate_dict_values(the_dict):
-    if not the_dict:
-        return
-    validate_list_values(the_dict.itervalues())
-
-
-def validate_list_values(the_list):
-    if not the_list:
-        return
-    for value in the_list:
-        value.validate()
-
-
-def instantiate_dict(container, the_dict, from_dict):
-    if not from_dict:
-        return
-    for name, value in from_dict.iteritems():
-        value = value.instantiate(container)
-        if value is not None:
-            the_dict[name] = value
-
-
-def instantiate_list(container, the_list, from_list):
-    if not from_list:
-        return
-    for value in from_list:
-        value = value.instantiate(container)
-        if value is not None:
-            the_list.append(value)
-
-
-def dump_list_values(the_list, name):
-    if not the_list:
-        return
-    puts('%s:' % name)
-    context = ConsumptionContext.get_thread_local()
-    with context.style.indent:
-        for value in the_list:
-            value.dump()
-
-
-def dump_dict_values(the_dict, name):
-    if not the_dict:
-        return
-    dump_list_values(the_dict.itervalues(), name)
-
-
-def dump_interfaces(interfaces, name='Interfaces'):
-    if not interfaces:
-        return
-    puts('%s:' % name)
-    context = ConsumptionContext.get_thread_local()
-    with context.style.indent:
-        for interface in interfaces.itervalues():
-            interface.dump()
-
-
 def parameters_as_values(the_dict):
     return dict((k, v.value) for k, v in the_dict.iteritems())
 
@@ -244,3 +173,9 @@ def fix_doc(cls):
     cls.__doc__ = cls.__bases__[-1].__doc__
 
     return cls
+
+
+def get_class_from_relationship(property):
+    class_ = property._sa_adapter.owner_state.class_
+    prop_name = property._sa_adapter.attr.key
+    return getattr(class_, prop_name).property.mapper.class_

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/56841a4d/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/56841a4d/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/56841a4d/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/56841a4d/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/56841a4d/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..d355e6d
--- /dev/null
+++ b/aria/orchestrator/topology/template_handler.py
@@ -0,0 +1,597 @@
+# 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()
+
+        modeling_utils.validate_no_undeclared_inputs(
+            declared_inputs=self._model.inputs, supplied_inputs=inputs or {})
+        modeling_utils.validate_required_inputs_are_supplied(
+            declared_inputs=self._model.inputs, supplied_inputs=inputs or {})
+
+        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/56841a4d/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..6164a10
--- /dev/null
+++ b/aria/orchestrator/topology/topology.py
@@ -0,0 +1,217 @@
+# 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.validation import issue
+from ...modeling import models
+from ...utils import console
+from . import (
+    template_handler,
+    instance_handler,
+    common
+)
+
+
+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 console.TopologyStylizer()
+
+        # 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 = console.TopologyStylizer()
+        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 console.TopologyStylizer()
+        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/56841a4d/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/56841a4d/aria/orchestrator/workflow_runner.py
----------------------------------------------------------------------
diff --git a/aria/orchestrator/workflow_runner.py 
b/aria/orchestrator/workflow_runner.py
index 0eac61c..4dbf29b 100644
--- a/aria/orchestrator/workflow_runner.py
+++ b/aria/orchestrator/workflow_runner.py
@@ -141,9 +141,8 @@ class WorkflowRunner(object):
                                                      supplied_inputs=inputs or 
{})
         
modeling_utils.validate_required_inputs_are_supplied(declared_inputs=workflow_inputs,
                                                              
supplied_inputs=inputs or {})
-        execution.inputs = modeling_utils.merge_parameter_values(inputs,
-                                                                 
workflow_inputs,
-                                                                 
model_cls=models.Input)
+        execution.inputs = modeling_utils.merge_parameter_values(
+            inputs, workflow_inputs, model_cls=models.Input)
         # TODO: these two following calls should execute atomically
         self._validate_no_active_executions(execution)
         self._model_storage.execution.put(execution)

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/56841a4d/aria/orchestrator/workflows/api/task.py
----------------------------------------------------------------------
diff --git a/aria/orchestrator/workflows/api/task.py 
b/aria/orchestrator/workflows/api/task.py
index ec96d27..6ce4a00 100644
--- a/aria/orchestrator/workflows/api/task.py
+++ b/aria/orchestrator/workflows/api/task.py
@@ -137,14 +137,13 @@ class OperationTask(BaseTask):
         operation = 
self.actor.interfaces[self.interface_name].operations[self.operation_name]
         self.plugin = operation.plugin
         self.function = operation.function
-        self.arguments = modeling_utils.merge_parameter_values(arguments,
-                                                               
operation.arguments,
-                                                               
model_cls=models.Argument)
+        self.arguments = modeling_utils.merge_parameter_values(arguments, 
operation.arguments)
 
         actor = self.actor
         if hasattr(actor, '_wrapped'):
             # Unwrap instrumented model
             actor = actor._wrapped
+
         if isinstance(actor, models.Node):
             self._context_cls = context.operation.NodeOperationContext
         elif isinstance(actor, models.Relationship):

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/56841a4d/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',


Reply via email to