Repository: incubator-ariatosca Updated Branches: refs/heads/ARIA-105-integrate-modeling 09f826a12 -> 7d20a8488
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/aria/modeling/service_template.py ---------------------------------------------------------------------- diff --git a/aria/modeling/service_template.py b/aria/modeling/service_template.py index fb77bb8..5d667e3 100644 --- a/aria/modeling/service_template.py +++ b/aria/modeling/service_template.py @@ -35,7 +35,7 @@ from ..parser.reading import deepcopy_with_locators from ..utils import collections, formatting, console from .mixins import TemplateModelMixin from . import ( - relationships, + relationship, utils, types as modeling_types ) @@ -99,74 +99,83 @@ class ServiceTemplateBase(TemplateModelMixin): # pylint: disable=too-many-public __tablename__ = 'service_template' + __private_fields__ = ['substitution_template_fk', + 'node_type_fk', + 'group_type_fk', + 'policy_type_fk', + 'relationship_type_fk', + 'capability_type_fk', + 'interface_type_fk', + 'artifact_type_fk'] + description = Column(Text) main_file_name = Column(Text) @declared_attr def meta_data(cls): # Warning! We cannot use the attr name "metadata" because it's used by SQLAlchemy! - return relationships.many_to_many(cls, 'metadata', dict_key='name') + return relationship.many_to_many(cls, 'metadata', dict_key='name') @declared_attr def node_templates(cls): - return relationships.one_to_many(cls, 'node_template', dict_key='name') + return relationship.one_to_many(cls, 'node_template', dict_key='name') @declared_attr def group_templates(cls): - return relationships.one_to_many(cls, 'group_template', dict_key='name') + return relationship.one_to_many(cls, 'group_template', dict_key='name') @declared_attr def policy_templates(cls): - return relationships.one_to_many(cls, 'policy_template', dict_key='name') + return relationship.one_to_many(cls, 'policy_template', dict_key='name') @declared_attr def substitution_template(cls): - return relationships.one_to_one(cls, 'substitution_template') + return relationship.one_to_one(cls, 'substitution_template') @declared_attr def inputs(cls): - return relationships.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name') @declared_attr def outputs(cls): - return relationships.many_to_many(cls, 'parameter', prefix='outputs', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='outputs', dict_key='name') @declared_attr def workflow_templates(cls): - return relationships.one_to_many(cls, 'operation_template', dict_key='name') + return relationship.one_to_many(cls, 'operation_template', dict_key='name') @declared_attr def plugin_specifications(cls): - return relationships.one_to_many(cls, 'plugin_specification', dict_key='name') + return relationship.one_to_many(cls, 'plugin_specification', dict_key='name') @declared_attr def node_types(cls): - return relationships.one_to_one(cls, 'type', fk='node_type_fk', other_property=False) + return relationship.one_to_one(cls, 'type', fk='node_type_fk', other_property=False) @declared_attr def group_types(cls): - return relationships.one_to_one(cls, 'type', fk='group_type_fk', other_property=False) + return relationship.one_to_one(cls, 'type', fk='group_type_fk', other_property=False) @declared_attr def policy_types(cls): - return relationships.one_to_one(cls, 'type', fk='policy_type_fk', other_property=False) + return relationship.one_to_one(cls, 'type', fk='policy_type_fk', other_property=False) @declared_attr def relationship_types(cls): - return relationships.one_to_one(cls, 'type', fk='relationship_type_fk', - other_property=False) + return relationship.one_to_one(cls, 'type', fk='relationship_type_fk', + other_property=False) @declared_attr def capability_types(cls): - return relationships.one_to_one(cls, 'type', fk='capability_type_fk', other_property=False) + return relationship.one_to_one(cls, 'type', fk='capability_type_fk', other_property=False) @declared_attr def interface_types(cls): - return relationships.one_to_one(cls, 'type', fk='interface_type_fk', other_property=False) + return relationship.one_to_one(cls, 'type', fk='interface_type_fk', other_property=False) @declared_attr def artifact_types(cls): - return relationships.one_to_one(cls, 'type', fk='artifact_type_fk', other_property=False) + return relationship.one_to_one(cls, 'type', fk='artifact_type_fk', other_property=False) # region orchestration @@ -180,42 +189,42 @@ class ServiceTemplateBase(TemplateModelMixin): # pylint: disable=too-many-public @declared_attr def substitution_template_fk(cls): """For ServiceTemplate one-to-one to SubstitutionTemplate""" - return relationships.fk('substitution_template', nullable=True) + return relationship.foreign_key('substitution_template', nullable=True) @declared_attr def node_type_fk(cls): """For ServiceTemplate one-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def group_type_fk(cls): """For ServiceTemplate one-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def policy_type_fk(cls): """For ServiceTemplate one-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def relationship_type_fk(cls): """For ServiceTemplate one-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def capability_type_fk(cls): """For ServiceTemplate one-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def interface_type_fk(cls): """For ServiceTemplate one-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def artifact_type_fk(cls): """For ServiceTemplate one-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) # endregion @@ -356,15 +365,6 @@ class ServiceTemplateBase(TemplateModelMixin): # pylint: disable=too-many-public console.puts('Interface types:') self.interface_types.dump() - __private_fields__ = ['substitution_template_fk', - 'node_type_fk', - 'group_type_fk', - 'policy_type_fk', - 'relationship_type_fk', - 'capability_type_fk', - 'interface_type_fk', - 'artifact_type_fk'] - class NodeTemplateBase(TemplateModelMixin): """ @@ -412,9 +412,13 @@ class NodeTemplateBase(TemplateModelMixin): __tablename__ = 'node_template' + __private_fields__ = ['type_fk', + 'service_template_fk', + 'service_template_name'] + @declared_attr def type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') description = Column(Text) default_instances = Column(Integer, default=1) @@ -423,42 +427,42 @@ class NodeTemplateBase(TemplateModelMixin): @declared_attr def properties(cls): - return relationships.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') @declared_attr def interface_templates(cls): - return relationships.one_to_many(cls, 'interface_template', dict_key='name') + return relationship.one_to_many(cls, 'interface_template', dict_key='name') @declared_attr def artifact_templates(cls): - return relationships.one_to_many(cls, 'artifact_template', dict_key='name') + return relationship.one_to_many(cls, 'artifact_template', dict_key='name') @declared_attr def capability_templates(cls): - return relationships.one_to_many(cls, 'capability_template', dict_key='name') + return relationship.one_to_many(cls, 'capability_template', dict_key='name') @declared_attr def requirement_templates(cls): - return relationships.one_to_many(cls, 'requirement_template', child_fk='node_template_fk', - child_property='node_template') + return relationship.one_to_many(cls, 'requirement_template', child_fk='node_template_fk', + child_property='node_template') target_node_template_constraints = Column(modeling_types.StrictList(FunctionType)) @declared_attr def plugin_specifications(cls): - return relationships.many_to_many(cls, 'plugin_specification', dict_key='name') + return relationship.many_to_many(cls, 'plugin_specification', dict_key='name') # region foreign_keys @declared_attr def type_fk(cls): """For NodeTemplate many-to-one to Type""" - return relationships.fk('type') + return relationship.foreign_key('type') @declared_attr def service_template_fk(cls): """For ServiceTemplate one-to-many to NodeTemplate""" - return relationships.fk('service_template') + return relationship.foreign_key('service_template') # endregion @@ -541,10 +545,6 @@ class NodeTemplateBase(TemplateModelMixin): utils.dump_dict_values(self.capability_templates, 'Capability templates') utils.dump_list_values(self.requirement_templates, 'Requirement templates') - __private_fields__ = ['type_fk', - 'service_template_fk', - 'service_template_name'] - class GroupTemplateBase(TemplateModelMixin): """ @@ -575,35 +575,38 @@ class GroupTemplateBase(TemplateModelMixin): __tablename__ = 'group_template' + __private_fields__ = ['type_fk', + 'service_template_fk'] + @declared_attr def type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') description = Column(Text) @declared_attr def node_templates(cls): - return relationships.many_to_many(cls, 'node_template') + return relationship.many_to_many(cls, 'node_template') @declared_attr def properties(cls): - return relationships.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') @declared_attr def interface_templates(cls): - return relationships.one_to_many(cls, 'interface_template', dict_key='name') + return relationship.one_to_many(cls, 'interface_template', dict_key='name') # region foreign keys @declared_attr def type_fk(cls): """For GroupTemplate many-to-one to Type""" - return relationships.fk('type') + return relationship.foreign_key('type') @declared_attr def service_template_fk(cls): """For ServiceTemplate one-to-many to GroupTemplate""" - return relationships.fk('service_template') + return relationship.foreign_key('service_template') # endregion @@ -650,9 +653,6 @@ class GroupTemplateBase(TemplateModelMixin): console.puts('Member node templates: {0}'.format(', '.join( (str(context.style.node(v.name)) for v in self.node_templates)))) - __private_fields__ = ['type_fk', - 'service_template_fk'] - class PolicyTemplateBase(TemplateModelMixin): """ @@ -680,35 +680,38 @@ class PolicyTemplateBase(TemplateModelMixin): __tablename__ = 'policy_template' + __private_fields__ = ['type_fk', + 'service_template_fk'] + @declared_attr def type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') description = Column(Text) @declared_attr def node_templates(cls): - return relationships.many_to_many(cls, 'node_template') + return relationship.many_to_many(cls, 'node_template') @declared_attr def group_templates(cls): - return relationships.many_to_many(cls, 'group_template') + return relationship.many_to_many(cls, 'group_template') @declared_attr def properties(cls): - return relationships.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') # region foreign keys @declared_attr def type_fk(cls): """For PolicyTemplate many-to-one to Type""" - return relationships.fk('type') + return relationship.foreign_key('type') @declared_attr def service_template_fk(cls): """For ServiceTemplate one-to-many to PolicyTemplate""" - return relationships.fk('service_template') + return relationship.foreign_key('service_template') # endregion @@ -756,9 +759,6 @@ class PolicyTemplateBase(TemplateModelMixin): console.puts('Target group templates: {0}'.format(', '.join( (str(context.style.node(v.name)) for v in self.group_templates)))) - __private_fields__ = ['type_fk', - 'service_template_fk'] - class SubstitutionTemplateBase(TemplateModelMixin): """ @@ -777,20 +777,22 @@ class SubstitutionTemplateBase(TemplateModelMixin): __tablename__ = 'substitution_template' + __private_fields__ = ['node_type_fk'] + @declared_attr def node_type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') @declared_attr def mappings(cls): - return relationships.one_to_many(cls, 'substitution_template_mapping', dict_key='name') + return relationship.one_to_many(cls, 'substitution_template_mapping', dict_key='name') # region foreign keys @declared_attr def node_type_fk(cls): """For SubstitutionTemplate many-to-one to Type""" - return relationships.fk('type') + return relationship.foreign_key('type') # endregion @@ -820,8 +822,6 @@ class SubstitutionTemplateBase(TemplateModelMixin): console.puts('Node type: {0}'.format(context.style.type(self.node_type.name))) utils.dump_dict_values(self.mappings, 'Mappings') - __private_fields__ = ['node_type_fk'] - class SubstitutionTemplateMappingBase(TemplateModelMixin): """ @@ -844,39 +844,44 @@ class SubstitutionTemplateMappingBase(TemplateModelMixin): __tablename__ = 'substitution_template_mapping' + __private_fields__ = ['substitution_template_fk', + 'node_template_fk', + 'capability_template_fk', + 'requirement_template_fk'] + @declared_attr def node_template(cls): - return relationships.one_to_one(cls, 'node_template') + return relationship.one_to_one(cls, 'node_template') @declared_attr def capability_template(cls): - return relationships.one_to_one(cls, 'capability_template') + return relationship.one_to_one(cls, 'capability_template') @declared_attr def requirement_template(cls): - return relationships.one_to_one(cls, 'requirement_template') + return relationship.one_to_one(cls, 'requirement_template') # region foreign keys @declared_attr def substitution_template_fk(cls): """For SubstitutionTemplate one-to-many to SubstitutionTemplateMapping""" - return relationships.fk('substitution_template') + return relationship.foreign_key('substitution_template') @declared_attr def node_template_fk(cls): """For SubstitutionTemplate one-to-one to NodeTemplate""" - return relationships.fk('node_template') + return relationship.foreign_key('node_template') @declared_attr def capability_template_fk(cls): """For SubstitutionTemplate one-to-one to CapabilityTemplate""" - return relationships.fk('capability_template', nullable=True) + return relationship.foreign_key('capability_template', nullable=True) @declared_attr def requirement_template_fk(cls): """For SubstitutionTemplate one-to-one to RequirementTemplate""" - return relationships.fk('requirement_template', nullable=True) + return relationship.foreign_key('requirement_template', nullable=True) # endregion @@ -885,6 +890,9 @@ class SubstitutionTemplateMappingBase(TemplateModelMixin): return collections.OrderedDict(( ('name', self.name))) + def coerce_values(self, container, report_issues): + pass + def instantiate(self, container): from . import models context = ConsumptionContext.get_thread_local() @@ -926,11 +934,6 @@ class SubstitutionTemplateMappingBase(TemplateModelMixin): if self.capability_template else self.requirement_template.name))) - __private_fields__ = ['substitution_template_fk', - 'node_template_fk', - 'capability_template_fk', - 'requirement_template_fk'] - class RequirementTemplateBase(TemplateModelMixin): """ @@ -965,54 +968,60 @@ class RequirementTemplateBase(TemplateModelMixin): __tablename__ = 'requirement_template' + __private_fields__ = ['target_node_type_fk', + 'target_node_template_fk', + 'target_capability_type_fk' + 'node_template_fk', + 'relationship_template_fk'] + @declared_attr def target_node_type(cls): - return relationships.many_to_one(cls, 'type', fk='target_node_type_fk', - parent_property=False) + return relationship.many_to_one(cls, 'type', fk='target_node_type_fk', + parent_property=False) @declared_attr def target_node_template(cls): - return relationships.one_to_one(cls, 'node_template', fk='target_node_template_fk', - other_property=False) + return relationship.one_to_one(cls, 'node_template', fk='target_node_template_fk', + other_property=False) @declared_attr def target_capability_type(cls): - return relationships.one_to_one(cls, 'type', fk='target_capability_type_fk', - other_property=False) + return relationship.one_to_one(cls, 'type', fk='target_capability_type_fk', + other_property=False) target_capability_name = Column(Text) target_node_template_constraints = Column(modeling_types.StrictList(FunctionType)) @declared_attr def relationship_template(cls): - return relationships.one_to_one(cls, 'relationship_template') + return relationship.one_to_one(cls, 'relationship_template') # region foreign keys @declared_attr def target_node_type_fk(cls): """For RequirementTemplate many-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def target_node_template_fk(cls): """For RequirementTemplate one-to-one to NodeTemplate""" - return relationships.fk('node_template', nullable=True) + return relationship.foreign_key('node_template', nullable=True) @declared_attr def target_capability_type_fk(cls): """For RequirementTemplate one-to-one to NodeTemplate""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) @declared_attr def node_template_fk(cls): """For NodeTemplate one-to-many to RequirementTemplate""" - return relationships.fk('node_template') + return relationship.foreign_key('node_template') @declared_attr def relationship_template_fk(cls): """For RequirementTemplate one-to-one to RelationshipTemplate""" - return relationships.fk('relationship_template', nullable=True) + return relationship.foreign_key('relationship_template', nullable=True) # endregion @@ -1115,12 +1124,6 @@ class RequirementTemplateBase(TemplateModelMixin): with context.style.indent: self.relationship_template.dump() - __private_fields__ = ['target_node_type_fk', - 'target_node_template_fk', - 'target_capability_type_fk' - 'node_template_fk', - 'relationship_template_fk'] - class RelationshipTemplateBase(TemplateModelMixin): """ @@ -1150,26 +1153,28 @@ class RelationshipTemplateBase(TemplateModelMixin): __tablename__ = 'relationship_template' + __private_fields__ = ['type_fk'] + @declared_attr def type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') description = Column(Text) @declared_attr def properties(cls): - return relationships.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') @declared_attr def interface_templates(cls): - return relationships.one_to_many(cls, 'interface_template', dict_key='name') + return relationship.one_to_many(cls, 'interface_template', dict_key='name') # region foreign keys @declared_attr def type_fk(cls): """For RelationshipTemplate many-to-one to Type""" - return relationships.fk('type', nullable=True) + return relationship.foreign_key('type', nullable=True) # endregion @@ -1184,12 +1189,11 @@ class RelationshipTemplateBase(TemplateModelMixin): def instantiate(self, container): from . import models - relationship_model = models.Relationship(type=self.type, + relationship_model = models.Relationship(name=self.name, + type=self.type, relationship_template=self) - utils.instantiate_dict(container, - relationship_model.properties, self.properties) - utils.instantiate_dict(container, - relationship_model.interfaces, self.interface_templates) + utils.instantiate_dict(container, relationship_model.properties, self.properties) + utils.instantiate_dict(container, relationship_model.interfaces, self.interface_templates) return relationship_model def validate(self): @@ -1214,8 +1218,6 @@ class RelationshipTemplateBase(TemplateModelMixin): utils.dump_dict_values(self.properties, 'Properties') utils.dump_interfaces(self.interface_templates, 'Interface templates') - __private_fields__ = ['type_fk'] - class CapabilityTemplateBase(TemplateModelMixin): """ @@ -1247,9 +1249,12 @@ class CapabilityTemplateBase(TemplateModelMixin): __tablename__ = 'capability_template' + __private_fields__ = ['type_fk', + 'node_template_fk'] + @declared_attr def type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') description = Column(Text) min_occurrences = Column(Integer, default=None) # optional @@ -1257,23 +1262,23 @@ class CapabilityTemplateBase(TemplateModelMixin): @declared_attr def valid_source_node_types(cls): - return relationships.many_to_many(cls, 'type', prefix='valid_sources') + return relationship.many_to_many(cls, 'type', prefix='valid_sources') @declared_attr def properties(cls): - return relationships.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') # region foreign keys @declared_attr def type_fk(cls): """For CapabilityTemplate many-to-one to Type""" - return relationships.fk('type') + return relationship.foreign_key('type') @declared_attr def node_template_fk(cls): """For NodeTemplate one-to-many to CapabilityTemplate""" - return relationships.fk('node_template') + return relationship.foreign_key('node_template') # endregion @@ -1347,9 +1352,6 @@ class CapabilityTemplateBase(TemplateModelMixin): for v in self.valid_source_node_types)))) utils.dump_dict_values(self.properties, 'Properties') - __private_fields__ = ['type_fk', - 'node_template_fk'] - class InterfaceTemplateBase(TemplateModelMixin): """ @@ -1378,41 +1380,46 @@ class InterfaceTemplateBase(TemplateModelMixin): __tablename__ = 'interface_template' + __private_fields__ = ['type_fk', + 'node_template_fk', + 'group_template_fk', + 'relationship_template_fk'] + @declared_attr def type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') description = Column(Text) @declared_attr def inputs(cls): - return relationships.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name') @declared_attr def operation_templates(cls): - return relationships.one_to_many(cls, 'operation_template', dict_key='name') + return relationship.one_to_many(cls, 'operation_template', dict_key='name') # region foreign keys @declared_attr def type_fk(cls): """For InterfaceTemplate many-to-one to Type""" - return relationships.fk('type') + return relationship.foreign_key('type') @declared_attr def node_template_fk(cls): """For NodeTemplate one-to-many to InterfaceTemplate""" - return relationships.fk('node_template', nullable=True) + return relationship.foreign_key('node_template', nullable=True) @declared_attr def group_template_fk(cls): """For GroupTemplate one-to-many to InterfaceTemplate""" - return relationships.fk('group_template', nullable=True) + return relationship.foreign_key('group_template', nullable=True) @declared_attr def relationship_template_fk(cls): """For RelationshipTemplate one-to-many to InterfaceTemplate""" - return relationships.fk('relationship_template', nullable=True) + return relationship.foreign_key('relationship_template', nullable=True) # endregion @@ -1454,11 +1461,6 @@ class InterfaceTemplateBase(TemplateModelMixin): utils.dump_dict_values(self.inputs, 'Inputs') utils.dump_dict_values(self.operation_templates, 'Operation templates') - __private_fields__ = ['type_fk', - 'node_template_fk', - 'group_template_fk', - 'relationship_template_fk'] - class OperationTemplateBase(TemplateModelMixin): """ @@ -1495,18 +1497,22 @@ class OperationTemplateBase(TemplateModelMixin): __tablename__ = 'operation_template' + __private_fields__ = ['service_template_fk', + 'interface_template_fk', + 'plugin_fk'] + description = Column(Text) @declared_attr def plugin_specification(cls): - return relationships.one_to_one(cls, 'plugin_specification') + return relationship.one_to_one(cls, 'plugin_specification') implementation = Column(Text) dependencies = Column(modeling_types.StrictList(item_cls=basestring)) @declared_attr def inputs(cls): - return relationships.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name') executor = Column(Text) max_retries = Column(Integer) @@ -1517,17 +1523,17 @@ class OperationTemplateBase(TemplateModelMixin): @declared_attr def service_template_fk(cls): """For ServiceTemplate one-to-many to OperationTemplate""" - return relationships.fk('service_template', nullable=True) + return relationship.foreign_key('service_template', nullable=True) @declared_attr def interface_template_fk(cls): """For InterfaceTemplate one-to-many to OperationTemplate""" - return relationships.fk('interface_template', nullable=True) + return relationship.foreign_key('interface_template', nullable=True) @declared_attr def plugin_specification_fk(cls): """For OperationTemplate one-to-one to PluginSpecification""" - return relationships.fk('plugin_specification', nullable=True) + return relationship.foreign_key('plugin_specification', nullable=True) # endregion @@ -1584,10 +1590,6 @@ class OperationTemplateBase(TemplateModelMixin): context.style.literal(self.retry_interval))) utils.dump_dict_values(self.inputs, 'Inputs') - __private_fields__ = ['service_template_fk', - 'interface_template_fk', - 'plugin_fk'] - class ArtifactTemplateBase(TemplateModelMixin): """ @@ -1618,9 +1620,12 @@ class ArtifactTemplateBase(TemplateModelMixin): __tablename__ = 'artifact_template' + __private_fields__ = ['type_fk', + 'node_template_fk'] + @declared_attr def type(cls): - return relationships.many_to_one(cls, 'type') + return relationship.many_to_one(cls, 'type') description = Column(Text) source_path = Column(Text) @@ -1630,19 +1635,19 @@ class ArtifactTemplateBase(TemplateModelMixin): @declared_attr def properties(cls): - return relationships.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') + return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') # region foreign keys @declared_attr def type_fk(cls): """For ArtifactTemplate many-to-one to Type""" - return relationships.fk('type') + return relationship.foreign_key('type') @declared_attr def node_template_fk(cls): """For NodeTemplate one-to-many to ArtifactTemplate""" - return relationships.fk('node_template') + return relationship.foreign_key('node_template') # endregion @@ -1694,6 +1699,3 @@ class ArtifactTemplateBase(TemplateModelMixin): console.puts('Repository credential: {0}'.format( context.style.literal(self.repository_credential))) utils.dump_dict_values(self.properties, 'Properties') - - __private_fields__ = ['type_fk', - 'node_template_fk'] http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/aria/modeling/utils.py ---------------------------------------------------------------------- diff --git a/aria/modeling/utils.py b/aria/modeling/utils.py index 762754f..0b4015c 100644 --- a/aria/modeling/utils.py +++ b/aria/modeling/utils.py @@ -29,7 +29,7 @@ def coerce_value(container, value, report_issues=False): return [coerce_value(container, v, report_issues) for v in value] elif isinstance(value, dict): return OrderedDict((k, coerce_value(container, v, report_issues)) - for k, v in value.items()) + for k, v in value.iteritems()) elif hasattr(value, '_evaluate'): context = ConsumptionContext.get_thread_local() try: @@ -43,30 +43,30 @@ def coerce_value(container, value, report_issues=False): return value -def validate_dict_values(the_dict): +def coerce_dict_values(container, the_dict, report_issues=False): if not the_dict: return - validate_list_values(the_dict.itervalues()) + coerce_list_values(container, the_dict.itervalues(), report_issues) -def validate_list_values(the_list): +def coerce_list_values(container, the_list, report_issues=False): if not the_list: return for value in the_list: - value.validate() + value.coerce_values(container, report_issues) -def coerce_dict_values(container, the_dict, report_issues=False): +def validate_dict_values(the_dict): if not the_dict: return - coerce_list_values(container, the_dict.itervalues(), report_issues) + validate_list_values(the_dict.itervalues()) -def coerce_list_values(container, the_list, report_issues=False): +def validate_list_values(the_list): if not the_list: return for value in the_list: - value.coerce_values(container, report_issues) + value.validate() def instantiate_dict(container, the_dict, from_dict): http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/aria/orchestrator/workflows/api/task.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/workflows/api/task.py b/aria/orchestrator/workflows/api/task.py index 2600aaa..98016ca 100644 --- a/aria/orchestrator/workflows/api/task.py +++ b/aria/orchestrator/workflows/api/task.py @@ -99,15 +99,14 @@ class OperationTask(BaseTask): if not isinstance(v, models.Parameter): inputs[k] = models.Parameter.wrap(k, v) - # TODO: These extra inputs should likely be stored as a separate entry in the task model, - # because they are different from the operation inputs. The two kinds of inputs should also - # not be merged. + # TODO: Suggestion: these extra inputs should likely be stored as a separate entry in the + # task model, because they are different from the operation inputs. The two kinds of inputs + # should also not be merged. if interface_name or operation_name: - operation = OperationTask._get_operation(actor.interfaces, interface_name, - operation_name) + operation = self._get_operation(interface_name, operation_name) if operation is None: - raise exceptions.TaskException( + raise exceptions.TaskCreationException( 'Could not find operation "{0}" on interface "{1}" for {2} "{3}"' .format(operation_name, interface_name, actor_type, actor.name)) @@ -115,7 +114,7 @@ class OperationTask(BaseTask): if operation.plugin_specification: self.plugin = OperationTask._find_plugin(operation.plugin_specification) if self.plugin is None: - raise exceptions.TaskException( + raise exceptions.TaskCreationException( 'Could not find plugin of operation "{0}" on interface "{1}" for {2} "{3}"' .format(operation_name, interface_name, actor_type, actor.name)) @@ -195,9 +194,8 @@ class OperationTask(BaseTask): inputs=inputs, runs_on=runs_on) - @staticmethod - def _get_operation(interfaces, interface_name, operation_name): - interface = interfaces.get(interface_name) + def _get_operation(self, interface_name, operation_name): + interface = self.actor.interfaces.get(interface_name) if interface is not None: return interface.operations.get(operation_name) return None @@ -249,5 +247,3 @@ class StubTask(BaseTask): """ Enables creating empty tasks. """ - - pass http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/aria/orchestrator/workflows/builtin/utils.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/workflows/builtin/utils.py b/aria/orchestrator/workflows/builtin/utils.py index 84d8293..6fc1ffe 100644 --- a/aria/orchestrator/workflows/builtin/utils.py +++ b/aria/orchestrator/workflows/builtin/utils.py @@ -26,7 +26,7 @@ def create_node_task(interface_name, operation_name, node): return OperationTask.for_node(node=node, interface_name=interface_name, operation_name=operation_name) - except exceptions.TaskException: + except exceptions.TaskCreationException: return None @@ -44,7 +44,7 @@ def create_relationship_tasks(interface_name, operation_name, runs_on, node): interface_name=interface_name, operation_name=operation_name, runs_on=runs_on)) - except exceptions.TaskException: + except exceptions.TaskCreationException: pass return sequence http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/aria/orchestrator/workflows/exceptions.py ---------------------------------------------------------------------- diff --git a/aria/orchestrator/workflows/exceptions.py b/aria/orchestrator/workflows/exceptions.py index e2f5b59..f624fec 100644 --- a/aria/orchestrator/workflows/exceptions.py +++ b/aria/orchestrator/workflows/exceptions.py @@ -68,4 +68,9 @@ class TaskException(exceptions.AriaError): """ Raised by the task """ - pass + + +class TaskCreationException(TaskException): + """ + Raised by the task + """ http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/docs/requirements.txt ---------------------------------------------------------------------- diff --git a/docs/requirements.txt b/docs/requirements.txt index 669522a..72b28f1 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -11,4 +11,4 @@ # limitations under the License. Sphinx==1.5.3 -sphinx_rtd_theme==0.2.2 +sphinx_rtd_theme==0.2.4 http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/extensions/aria_extension_tosca/simple_v1_0/modeling/__init__.py ---------------------------------------------------------------------- diff --git a/extensions/aria_extension_tosca/simple_v1_0/modeling/__init__.py b/extensions/aria_extension_tosca/simple_v1_0/modeling/__init__.py index ec5ba3b..4477732 100644 --- a/extensions/aria_extension_tosca/simple_v1_0/modeling/__init__.py +++ b/extensions/aria_extension_tosca/simple_v1_0/modeling/__init__.py @@ -250,7 +250,9 @@ def create_requirement_template_model(context, service_template, requirement): capability, capability_variant = requirement._get_capability(context) if capability is not None: if capability_variant == 'capability_type': - model['target_capability_type_name'] = capability._name + capability_type = \ + service_template.capability_types.get_descendant(capability._name) + model['target_capability_type'] = capability_type else: model['target_capability_name'] = capability._name @@ -265,6 +267,7 @@ def create_requirement_template_model(context, service_template, requirement): if relationship is not None: model.relationship_template = \ create_relationship_template_model(context, service_template, relationship) + model.relationship_template.name = requirement._name return model @@ -280,8 +283,7 @@ def create_relationship_template_model(context, service_template, relationship): relationship_type = relationship_template._get_type(context) relationship_type = service_template.relationship_types.get_descendant( relationship_type._name) - model = RelationshipTemplate(type=relationship_type, - name=relationship_template._name) + model = RelationshipTemplate(type=relationship_type) if relationship_template.description: model.description = relationship_template.description.value http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/tests/modeling/test_models.py ---------------------------------------------------------------------- diff --git a/tests/modeling/test_models.py b/tests/modeling/test_models.py index 755a394..5266d79 100644 --- a/tests/modeling/test_models.py +++ b/tests/modeling/test_models.py @@ -177,11 +177,11 @@ class TestServiceTemplate(object): @pytest.mark.parametrize( 'is_valid, description, created_at, updated_at, main_file_name', [ - (True, 'description', now, now, '/path'), (False, {}, now, now, '/path'), (False, 'description', 'error', now, '/path'), (False, 'description', now, 'error', '/path'), (False, 'description', now, now, {}), + (True, 'description', now, now, '/path'), ] ) http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/7d20a848/tests/orchestrator/workflows/executor/test_executor.py ---------------------------------------------------------------------- diff --git a/tests/orchestrator/workflows/executor/test_executor.py b/tests/orchestrator/workflows/executor/test_executor.py index e2602b7..0a2280d 100644 --- a/tests/orchestrator/workflows/executor/test_executor.py +++ b/tests/orchestrator/workflows/executor/test_executor.py @@ -43,7 +43,6 @@ def test_execute(executor): expected_value = 'value' successful_task = MockTask(mock_successful_task) failing_task = MockTask(mock_failing_task) - #task_with_inputs = MockTask(mock_task_with_input, inputs=dict(input='value')) task_with_inputs = MockTask(mock_task_with_input, inputs={'input': models.Parameter.wrap( 'input', 'value')})
