--- /dev/null
+# 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.
+
+"""
+ARIA modeling service template module
+"""
+
+# pylint: disable=too-many-lines, no-self-argument, no-member, abstract-method
+
+from __future__ import absolute_import # so we can import standard 'types'
+
+from sqlalchemy import (
+ Column,
+ Text,
+ Integer,
+ Boolean,
+ DateTime,
+ PickleType
+)
+from sqlalchemy.ext.declarative import declared_attr
+
+from ..utils import (collections, formatting)
+from .mixins import TemplateModelMixin
+from . import (
+ relationship,
+ types as modeling_types
+)
+
+
+class ServiceTemplateBase(TemplateModelMixin):
+ """
+ Template for creating :class:`Service` instances.
+
+ Usually created by various DSL parsers, such as ARIA's TOSCA extension. However, it can also be
+ created programmatically.
+ """
+
+ __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')
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def substitution_template(cls):
+ """
+ Exposes an entire service as a single node.
+
+ :type: :class:`SubstitutionTemplate`
+ """
+ return relationship.one_to_one(
+ cls, 'substitution_template', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def node_types(cls):
+ """
+ Base for the node type hierarchy,
+
+ :type: :class:`Type`
+ """
+ return relationship.one_to_one(
+ cls, 'type', fk='node_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def group_types(cls):
+ """
+ Base for the group type hierarchy,
+
+ :type: :class:`Type`
+ """
+ return relationship.one_to_one(
+ cls, 'type', fk='group_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def policy_types(cls):
+ """
+ Base for the policy type hierarchy,
+
+ :type: :class:`Type`
+ """
+ return relationship.one_to_one(
+ cls, 'type', fk='policy_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def relationship_types(cls):
+ """
+ Base for the relationship type hierarchy,
+
+ :type: :class:`Type`
+ """
+ return relationship.one_to_one(
+ cls, 'type', fk='relationship_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def capability_types(cls):
+ """
+ Base for the capability type hierarchy,
+
+ :type: :class:`Type`
+ """
+ return relationship.one_to_one(
+ cls, 'type', fk='capability_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def interface_types(cls):
+ """
+ Base for the interface type hierarchy,
+
+ :type: :class:`Type`
+ """
+ return relationship.one_to_one(
+ cls, 'type', fk='interface_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def artifact_types(cls):
+ """
+ Base for the artifact type hierarchy,
+
+ :type: :class:`Type`
+ """
+ return relationship.one_to_one(
+ cls, 'type', fk='artifact_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def services(cls):
+ """
+ Instantiated services.
+
+ :type: [:class:`Service`]
+ """
+ return relationship.one_to_many(cls, 'service', dict_key='name')
+
+ @declared_attr
+ def node_templates(cls):
+ """
+ Templates for creating nodes.
+
+ :type: {:obj:`basestring`, :class:`NodeTemplate`}
+ """
+ return relationship.one_to_many(cls, 'node_template', dict_key='name')
+
+ @declared_attr
+ def group_templates(cls):
+ """
+ Templates for creating groups.
+
+ :type: {:obj:`basestring`, :class:`GroupTemplate`}
+ """
+ return relationship.one_to_many(cls, 'group_template', dict_key='name')
+
+ @declared_attr
+ def policy_templates(cls):
+ """
+ Templates for creating policies.
+
+ :type: {:obj:`basestring`, :class:`PolicyTemplate`}
+ """
+ return relationship.one_to_many(cls, 'policy_template', dict_key='name')
+
+ @declared_attr
+ def workflow_templates(cls):
+ """
+ Templates for creating workflows.
+
+ :type: {:obj:`basestring`, :class:`OperationTemplate`}
+ """
+ return relationship.one_to_many(cls, 'operation_template', dict_key='name')
+
+ @declared_attr
+ def outputs(cls):
+ """
+ Declarations for output parameters are filled in after service installation.
+
+ :type: {:obj:`basestring`: :class:`Output`}
+ """
+ return relationship.one_to_many(cls, 'output', dict_key='name')
+
+ @declared_attr
+ def inputs(cls):
+ """
+ Declarations for externally provided parameters.
+
+ :type: {:obj:`basestring`: :class:`Input`}
+ """
+ return relationship.one_to_many(cls, 'input', dict_key='name')
+
+ @declared_attr
+ def plugin_specifications(cls):
+ """
+ Required plugins for instantiated services.
+
+ :type: {:obj:`basestring`: :class:`PluginSpecification`}
+ """
+ return relationship.one_to_many(cls, 'plugin_specification', dict_key='name')
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def meta_data(cls):
+ """
+ Associated metadata.
+
+ :type: {:obj:`basestring`: :class:`Metadata`}
+ """
+ # Warning! We cannot use the attr name "metadata" because it's used by SQLAlchemy!
+ return relationship.many_to_many(cls, 'metadata', dict_key='name')
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def substitution_template_fk(cls):
+ """For ServiceTemplate one-to-one to SubstitutionTemplate"""
+ return relationship.foreign_key('substitution_template', nullable=True)
+
+ @declared_attr
+ def node_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def group_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def policy_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def relationship_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def capability_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def interface_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def artifact_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ main_file_name = Column(Text, doc="""
+ Filename of CSAR or YAML file from which this service template was parsed.
+
+ :type: :obj:`basestring`
+ """)
+
+ created_at = Column(DateTime, nullable=False, index=True, doc="""
+ Creation timestamp.
+
+ :type: :class:`~datetime.datetime`
+ """)
+
+ updated_at = Column(DateTime, doc="""
+ Update timestamp.
+
+ :type: :class:`~datetime.datetime`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('description', self.description),
+ ('metadata', formatting.as_raw_dict(self.meta_data)),
+ ('node_templates', formatting.as_raw_list(self.node_templates)),
+ ('group_templates', formatting.as_raw_list(self.group_templates)),
+ ('policy_templates', formatting.as_raw_list(self.policy_templates)),
+ ('substitution_template', formatting.as_raw(self.substitution_template)),
+ ('inputs', formatting.as_raw_dict(self.inputs)),
+ ('outputs', formatting.as_raw_dict(self.outputs)),
+ ('workflow_templates', formatting.as_raw_list(self.workflow_templates))))
+
+ @property
+ def types_as_raw(self):
+ return collections.OrderedDict((
+ ('node_types', formatting.as_raw(self.node_types)),
+ ('group_types', formatting.as_raw(self.group_types)),
+ ('policy_types', formatting.as_raw(self.policy_types)),
+ ('relationship_types', formatting.as_raw(self.relationship_types)),
+ ('capability_types', formatting.as_raw(self.capability_types)),
+ ('interface_types', formatting.as_raw(self.interface_types)),
+ ('artifact_types', formatting.as_raw(self.artifact_types))))
+
+
+class NodeTemplateBase(TemplateModelMixin):
+ """
+ Template for creating zero or more :class:`Node` instances, which are typed vertices in the
+ service topology.
+ """
+
+ __tablename__ = 'node_template'
+
+ __private_fields__ = ('type_fk',
+ 'service_template_fk')
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def nodes(cls):
+ """
+ Instantiated nodes.
+
+ :type: [:class:`Node`]
+ """
+ return relationship.one_to_many(cls, 'node')
+
+ @declared_attr
+ def interface_templates(cls):
+ """
+ Associated interface templates.
+
+ :type: {:obj:`basestring`: :class:`InterfaceTemplate`}
+ """
+ return relationship.one_to_many(cls, 'interface_template', dict_key='name')
+
+ @declared_attr
+ def artifact_templates(cls):
+ """
+ Associated artifacts.
+
+ :type: {:obj:`basestring`: :class:`ArtifactTemplate`}
+ """
+ return relationship.one_to_many(cls, 'artifact_template', dict_key='name')
+
+ @declared_attr
+ def capability_templates(cls):
+ """
+ Associated exposed capability templates.
+
+ :type: {:obj:`basestring`: :class:`CapabilityTemplate`}
+ """
+ return relationship.one_to_many(cls, 'capability_template', dict_key='name')
+
+ @declared_attr
+ def requirement_templates(cls):
+ """
+ Associated potential relationships with other nodes.
+
+ :type: [:class:`RequirementTemplate`]
+ """
+ return relationship.one_to_many(cls, 'requirement_template', other_fk='node_template_fk')
+
+ @declared_attr
+ def properties(cls):
+ """
+ Declarations for associated immutable parameters.
+
+ :type: {:obj:`basestring`: :class:`Property`}
+ """
+ return relationship.one_to_many(cls, 'property', dict_key='name')
+
+ @declared_attr
+ def attributes(cls):
+ """
+ Declarations for associated mutable parameters.
+
+ :type: {:obj:`basestring`: :class:`Attribute`}
+ """
+ return relationship.one_to_many(cls, 'attribute', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def type(cls):
+ """
+ Node type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def service_template(cls):
+ """
+ Containing service template.
+
+ :type: :class:`ServiceTemplate`
+ """
+ return relationship.many_to_one(cls, 'service_template')
+
+ # endregion
+
+ # region association proxies
+
+ @declared_attr
+ def service_template_name(cls):
+ return relationship.association_proxy('service_template', 'name')
+
+ @declared_attr
+ def type_name(cls):
+ return relationship.association_proxy('type', 'name')
+
+ # endregion
+
+ # region foreign_keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For NodeTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to NodeTemplate"""
+ return relationship.foreign_key('service_template')
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ directives = Column(PickleType, doc="""
+ Directives that apply to this node template.
+
+ :type: [:obj:`basestring`]
+ """)
+
+ default_instances = Column(Integer, default=1, doc="""
+ Default number nodes that will appear in the service.
+
+ :type: :obj:`int`
+ """)
+
+ min_instances = Column(Integer, default=0, doc="""
+ Minimum number nodes that will appear in the service.
+
+ :type: :obj:`int`
+ """)
+
+ max_instances = Column(Integer, default=None, doc="""
+ Maximum number nodes that will appear in the service.
+
+ :type: :obj:`int`
+ """)
+
+ target_node_template_constraints = Column(PickleType, doc="""
+ Constraints for filtering relationship targets.
+
+ :type: [:class:`NodeTemplateConstraint`]
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('description', self.description),
+ ('type_name', self.type.name),
+ ('properties', formatting.as_raw_dict(self.properties)),
+ ('attributes', formatting.as_raw_dict(self.properties)),
+ ('interface_templates', formatting.as_raw_list(self.interface_templates)),
+ ('artifact_templates', formatting.as_raw_list(self.artifact_templates)),
+ ('capability_templates', formatting.as_raw_list(self.capability_templates)),
+ ('requirement_templates', formatting.as_raw_list(self.requirement_templates))))
+
+ def is_target_node_template_valid(self, target_node_template):
+ """
+ Checks if ``target_node_template`` matches all our ``target_node_template_constraints``.
+ """
+
+ if self.target_node_template_constraints:
+ for node_template_constraint in self.target_node_template_constraints:
+ if not node_template_constraint.matches(self, target_node_template):
+ return False
+ return True
+
+ @property
+ def _next_index(self):
+ """
+ Next available node index.
+
+ :returns: node index
+ :rtype: int
+ """
+
+ max_index = 0
+ if self.nodes:
+ max_index = max(int(n.name.rsplit('_', 1)[-1]) for n in self.nodes)
+ return max_index + 1
+
+ @property
+ def _next_name(self):
+ """
+ Next available node name.
+
+ :returns: node name
+ :rtype: basestring
+ """
+
+ return '{name}_{index}'.format(name=self.name, index=self._next_index)
+
+ @property
+ def scaling(self):
+ 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 self.capability_templates.itervalues():
+ if capability_template.type.role == 'scaling':
+ extract_properties(capability_template.properties)
+
+ # From service scaling policies
+ for policy_template in self.service_template.policy_templates.itervalues():
+ if policy_template.type.role == 'scaling':
+ if policy_template.is_for_node_template(self.name):
+ extract_properties(policy_template.properties)
+
+ # Defaults
+ scaling.setdefault('min_instances', 0)
+ scaling.setdefault('max_instances', 1)
+ scaling.setdefault('default_instances', 1)
+
+ return scaling
+
+
+class GroupTemplateBase(TemplateModelMixin):
+ """
+ Template for creating a :class:`Group` instance, which is a typed logical container for zero or
+ more :class:`Node` instances.
+ """
+
+ __tablename__ = 'group_template'
+
+ __private_fields__ = ('type_fk',
+ 'service_template_fk')
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def groups(cls):
+ """
+ Instantiated groups.
+
+ :type: [:class:`Group`]
+ """
+ return relationship.one_to_many(cls, 'group')
+
+ @declared_attr
+ def interface_templates(cls):
+ """
+ Associated interface templates.
+
+ :type: {:obj:`basestring`: :class:`InterfaceTemplate`}
+ """
+ return relationship.one_to_many(cls, 'interface_template', dict_key='name')
+
+ @declared_attr
+ def properties(cls):
+ """
+ Declarations for associated immutable parameters.
+
+ :type: {:obj:`basestring`: :class:`Property`}
+ """
+ return relationship.one_to_many(cls, 'property', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def service_template(cls):
+ """
+ Containing service template.
+
+ :type: :class:`ServiceTemplate`
+ """
+ return relationship.many_to_one(cls, 'service_template')
+
+ @declared_attr
+ def type(cls):
+ """
+ Group type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def node_templates(cls):
+ """
+ Nodes instantiated by these templates will be members of the group.
+
+ :type: [:class:`NodeTemplate`]
+ """
+ return relationship.many_to_many(cls, 'node_template')
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For GroupTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to GroupTemplate"""
+ return relationship.foreign_key('service_template')
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('description', self.description),
+ ('type_name', self.type.name),
+ ('properties', formatting.as_raw_dict(self.properties)),
+ ('interface_templates', formatting.as_raw_list(self.interface_templates))))
+
+ def contains_node_template(self, name):
+ for node_template in self.node_templates:
+ if node_template.name == name:
+ return True
+ return False
+
+
+class PolicyTemplateBase(TemplateModelMixin):
+ """
+ Template for creating a :class:`Policy` instance, which is a typed set of orchestration hints
+ applied to zero or more :class:`Node` or :class:`Group` instances.
+ """
+
+ __tablename__ = 'policy_template'
+
+ __private_fields__ = ('type_fk',
+ 'service_template_fk')
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def policies(cls):
+ """
+ Instantiated policies.
+
+ :type: [:class:`Policy`]
+ """
+ return relationship.one_to_many(cls, 'policy')
+
+ @declared_attr
+ def properties(cls):
+ """
+ Declarations for associated immutable parameters.
+
+ :type: {:obj:`basestring`: :class:`Property`}
+ """
+ return relationship.one_to_many(cls, 'property', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def service_template(cls):
+ """
+ Containing service template.
+
+ :type: :class:`ServiceTemplate`
+ """
+ return relationship.many_to_one(cls, 'service_template')
+
+ @declared_attr
+ def type(cls):
+ """
+ Policy type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def node_templates(cls):
+ """
+ Policy will be enacted on all nodes instantiated by these templates.
+
+ :type: {:obj:`basestring`: :class:`NodeTemplate`}
+ """
+ return relationship.many_to_many(cls, 'node_template')
+
+ @declared_attr
+ def group_templates(cls):
+ """
+ Policy will be enacted on all nodes in all groups instantiated by these templates.
+
+ :type: {:obj:`basestring`: :class:`GroupTemplate`}
+ """
+ return relationship.many_to_many(cls, 'group_template')
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For PolicyTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to PolicyTemplate"""
+ return relationship.foreign_key('service_template')
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('description', self.description),
+ ('type_name', self.type.name),
+ ('properties', formatting.as_raw_dict(self.properties))))
+
+ def is_for_node_template(self, name):
+ for node_template in self.node_templates:
+ if node_template.name == name:
+ return True
+ for group_template in self.group_templates:
+ if group_template.contains_node_template(name):
+ return True
+ return False
+
+ def is_for_group_template(self, name):
+ for group_template in self.group_templates:
+ if group_template.name == name:
+ return True
+ return False
+
+
+class SubstitutionTemplateBase(TemplateModelMixin):
+ """
+ Template for creating a :class:`Substitution` instance, which exposes an entire instantiated
+ service as a single node.
+ """
+
+ __tablename__ = 'substitution_template'
+
+ __private_fields__ = ('node_type_fk',)
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def substitutions(cls):
+ """
+ Instantiated substitutions.
+
+ :type: [:class:`Substitution`]
+ """
+ return relationship.one_to_many(cls, 'substitution')
+
+ @declared_attr
+ def mappings(cls):
+ """
+ Map requirement and capabilities to exposed node.
+
+ :type: {:obj:`basestring`: :class:`SubstitutionTemplateMapping`}
+ """
+ return relationship.one_to_many(cls, 'substitution_template_mapping', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def node_type(cls):
+ """
+ Exposed node type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def node_type_fk(cls):
+ """For SubstitutionTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ # endregion
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('node_type_name', self.node_type.name),
+ ('mappings', formatting.as_raw_dict(self.mappings))))
+
+
+class SubstitutionTemplateMappingBase(TemplateModelMixin):
+ """
+ Used by :class:`SubstitutionTemplate` to map a capability template or a requirement template to
+ the exposed node.
+
+ The :attr:`name` field should match the capability or requirement name on the exposed node's
+ type.
+
+ Only one of :attr:`capability_template` and :attr:`requirement_template` can be set.
+ """
+
+ __tablename__ = 'substitution_template_mapping'
+
+ __private_fields__ = ('substitution_template_fk',
+ 'capability_template_fk',
+ 'requirement_template_fk')
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def capability_template(cls):
+ """
+ Capability template to expose (can be ``None``).
+
+ :type: :class:`CapabilityTemplate`
+ """
+ return relationship.one_to_one(
+ cls, 'capability_template', back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def requirement_template(cls):
+ """
+ Requirement template to expose (can be ``None``).
+
+ :type: :class:`RequirementTemplate`
+ """
+ return relationship.one_to_one(
+ cls, 'requirement_template', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def substitution_template(cls):
+ """
+ Containing substitution template.
+
+ :type: :class:`SubstitutionTemplate`
+ """
+ return relationship.many_to_one(cls, 'substitution_template', back_populates='mappings')
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def substitution_template_fk(cls):
+ """For SubstitutionTemplate one-to-many to SubstitutionTemplateMapping"""
+ return relationship.foreign_key('substitution_template')
+
+ @declared_attr
+ def capability_template_fk(cls):
+ """For SubstitutionTemplate one-to-one to CapabilityTemplate"""
+ return relationship.foreign_key('capability_template', nullable=True)
+
+ @declared_attr
+ def requirement_template_fk(cls):
+ """For SubstitutionTemplate one-to-one to RequirementTemplate"""
+ return relationship.foreign_key('requirement_template', nullable=True)
+
+ # endregion
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),))
+
+
+class RequirementTemplateBase(TemplateModelMixin):
+ """
+ Template for creating :class:`Relationship` instances, which are optionally-typed edges in the
+ service topology, connecting a :class:`Node` to a :class:`Capability` of another node.
+
+ Note that there is no equivalent "Requirement" instance model. Instead, during instantiation a
+ requirement template is matched with a capability and a :class:`Relationship` is instantiated.
+
+ A requirement template *must* target a :class:`CapabilityType` or a capability name. It can
+ optionally target a specific :class:`NodeType` or :class:`NodeTemplate`.
+
+ Requirement templates may optionally contain a :class:`RelationshipTemplate`. If they do not,
+ a :class:`Relationship` will be instantiated with default values.
+ """
+
+ __tablename__ = 'requirement_template'
+
+ __private_fields__ = ('target_capability_type_fk',
+ 'target_node_template_fk',
+ 'target_node_type_fk',
+ 'relationship_template_fk',
+ 'node_template_fk')
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def target_capability_type(cls):
+ """
+ Target capability type.
+
+ :type: :class:`CapabilityType`
+ """
+ return relationship.one_to_one(cls,
+ 'type',
+ fk='target_capability_type_fk',
+ back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def target_node_template(cls):
+ """
+ Target node template (can be ``None``).
+
+ :type: :class:`NodeTemplate`
+ """
+ return relationship.one_to_one(cls,
+ 'node_template',
+ fk='target_node_template_fk',
+ back_populates=relationship.NO_BACK_POP)
+
+ @declared_attr
+ def relationship_template(cls):
+ """
+ Associated relationship template (can be ``None``).
+
+ :type: :class:`RelationshipTemplate`
+ """
+ return relationship.one_to_one(cls, 'relationship_template')
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def relationships(cls):
+ """
+ Instantiated relationships.
+
+ :type: [:class:`Relationship`]
+ """
+ return relationship.one_to_many(cls, 'relationship')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def node_template(cls):
+ """
+ Containing node template.
+
+ :type: :class:`NodeTemplate`
+ """
+ return relationship.many_to_one(cls, 'node_template', fk='node_template_fk')
+
+ @declared_attr
+ def target_node_type(cls):
+ """
+ Target node type (can be ``None``).
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(
+ cls, 'type', fk='target_node_type_fk', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def target_node_type_fk(cls):
+ """For RequirementTemplate many-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def target_node_template_fk(cls):
+ """For RequirementTemplate one-to-one to NodeTemplate"""
+ return relationship.foreign_key('node_template', nullable=True)
+
+ @declared_attr
+ def target_capability_type_fk(cls):
+ """For RequirementTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to RequirementTemplate"""
+ return relationship.foreign_key('node_template')
+
+ @declared_attr
+ def relationship_template_fk(cls):
+ """For RequirementTemplate one-to-one to RelationshipTemplate"""
+ return relationship.foreign_key('relationship_template', nullable=True)
+
+ # endregion
+
+ target_capability_name = Column(Text, doc="""
+ Target capability name in node template or node type (can be ``None``).
+
+ :type: :obj:`basestring`
+ """)
+
+ target_node_template_constraints = Column(PickleType, doc="""
+ Constraints for filtering relationship targets.
+
+ :type: [:class:`NodeTemplateConstraint`]
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('target_node_type_name', self.target_node_type.name
+ if self.target_node_type is not None else None),
+ ('target_node_template_name', self.target_node_template.name
+ if self.target_node_template is not None else None),
+ ('target_capability_type_name', self.target_capability_type.name
+ if self.target_capability_type is not None else None),
+ ('target_capability_name', self.target_capability_name),
+ ('relationship_template', formatting.as_raw(self.relationship_template))))
+
+
+class RelationshipTemplateBase(TemplateModelMixin):
+ """
+ Optional addition to a :class:`RequirementTemplate`.
+
+ Note that a relationship template here is not exactly equivalent to a relationship template
+ entity in TOSCA. For example, a TOSCA requirement specifying a relationship type rather than a
+ relationship template would still be represented here as a relationship template.
+ """
+
+ __tablename__ = 'relationship_template'
+
+ __private_fields__ = ('type_fk',)
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def relationships(cls):
+ """
+ Instantiated relationships.
+
+ :type: [:class:`Relationship`]
+ """
+ return relationship.one_to_many(cls, 'relationship')
+
+ @declared_attr
+ def interface_templates(cls):
+ """
+ Associated interface templates.
+
+ :type: {:obj:`basestring`: :class:`InterfaceTemplate`}
+ """
+ return relationship.one_to_many(cls, 'interface_template', dict_key='name')
+
+ @declared_attr
+ def properties(cls):
+ """
+ Declarations for associated immutable parameters.
+
+ :type: {:obj:`basestring`: :class:`Property`}
+ """
+ return relationship.one_to_many(cls, 'property', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def type(cls):
+ """
+ Relationship type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For RelationshipTemplate many-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('type_name', self.type.name if self.type is not None else None),
+ ('name', self.name),
+ ('description', self.description),
+ ('properties', formatting.as_raw_dict(self.properties)),
+ ('interface_templates', formatting.as_raw_list(self.interface_templates))))
+
+
+class CapabilityTemplateBase(TemplateModelMixin):
+ """
+ Template for creating :class:`Capability` instances, typed attachments which serve two purposes:
+ to provide extra properties and attributes to :class:`Node` instances, and to expose targets for
+ :class:`Relationship` instances from other nodes.
+ """
+
+ __tablename__ = 'capability_template'
+
+ __private_fields__ = ('type_fk',
+ 'node_template_fk')
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def capabilities(cls):
+ """
+ Instantiated capabilities.
+
+ :type: [:class:`Capability`]
+ """
+ return relationship.one_to_many(cls, 'capability')
+
+ @declared_attr
+ def properties(cls):
+ """
+ Declarations for associated immutable parameters.
+
+ :type: {:obj:`basestring`: :class:`Property`}
+ """
+ return relationship.one_to_many(cls, 'property', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def node_template(cls):
+ """
+ Containing node template.
+
+ :type: :class:`NodeTemplate`
+ """
+ return relationship.many_to_one(cls, 'node_template')
+
+ @declared_attr
+ def type(cls):
+ """
+ Capability type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def valid_source_node_types(cls):
+ """
+ Reject requirements that are not from these node types.
+
+ :type: [:class:`Type`]
+ """
+ return relationship.many_to_many(cls, 'type', prefix='valid_sources')
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For CapabilityTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to CapabilityTemplate"""
+ return relationship.foreign_key('node_template')
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ min_occurrences = Column(Integer, default=None, doc="""
+ Minimum number of requirement matches required.
+
+ :type: :obj:`int`
+ """)
+
+ max_occurrences = Column(Integer, default=None, doc="""
+ Maximum number of requirement matches allowed.
+
+ :type: :obj:`int`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('description', self.description),
+ ('type_name', self.type.name),
+ ('min_occurrences', self.min_occurrences),
+ ('max_occurrences', self.max_occurrences),
+ ('valid_source_node_types', [v.name for v in self.valid_source_node_types]),
+ ('properties', formatting.as_raw_dict(self.properties))))
+
+
+class InterfaceTemplateBase(TemplateModelMixin):
+ """
+ Template for creating :class:`Interface` instances, which are typed bundles of
+ :class:`Operation` instances.
+
+ Can be associated with a :class:`NodeTemplate`, a :class:`GroupTemplate`, or a
+ :class:`RelationshipTemplate`.
+ """
+
+ __tablename__ = 'interface_template'
+
+ __private_fields__ = ('type_fk',
+ 'node_template_fk',
+ 'group_template_fk',
+ 'relationship_template_fk')
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def inputs(cls):
+ """
+ Declarations for externally provided parameters that can be used by all operations of the
+ interface.
+
+ :type: {:obj:`basestring`: :class:`Input`}
+ """
+ return relationship.one_to_many(cls, 'input', dict_key='name')
+
+ @declared_attr
+ def interfaces(cls):
+ """
+ Instantiated interfaces.
+
+ :type: [:class:`Interface`]
+ """
+ return relationship.one_to_many(cls, 'interface')
+
+ @declared_attr
+ def operation_templates(cls):
+ """
+ Associated operation templates.
+
+ :type: {:obj:`basestring`: :class:`OperationTemplate`}
+ """
+ return relationship.one_to_many(cls, 'operation_template', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def node_template(cls):
+ """
+ Containing node template (can be ``None``).
+
+ :type: :class:`NodeTemplate`
+ """
+ return relationship.many_to_one(cls, 'node_template')
+
+ @declared_attr
+ def group_template(cls):
+ """
+ Containing group template (can be ``None``).
+
+ :type: :class:`GroupTemplate`
+ """
+ return relationship.many_to_one(cls, 'group_template')
+
+ @declared_attr
+ def relationship_template(cls):
+ """
+ Containing relationship template (can be ``None``).
+
+ :type: :class:`RelationshipTemplate`
+ """
+ return relationship.many_to_one(cls, 'relationship_template')
+
+ @declared_attr
+ def type(cls):
+ """
+ Interface type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For InterfaceTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to InterfaceTemplate"""
+ return relationship.foreign_key('node_template', nullable=True)
+
+ @declared_attr
+ def group_template_fk(cls):
+ """For GroupTemplate one-to-many to InterfaceTemplate"""
+ return relationship.foreign_key('group_template', nullable=True)
+
+ @declared_attr
+ def relationship_template_fk(cls):
+ """For RelationshipTemplate one-to-many to InterfaceTemplate"""
+ return relationship.foreign_key('relationship_template', nullable=True)
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('description', self.description),
+ ('type_name', self.type.name),
+ ('inputs', formatting.as_raw_dict(self.inputs)), # pylint: disable=no-member
+ # TODO fix self.properties reference
+ ('operation_templates', formatting.as_raw_list(self.operation_templates))))
+
+
+class OperationTemplateBase(TemplateModelMixin):
+ """
+ Template for creating :class:`Operation` instances, which are entry points to Python functions
+ called as part of a workflow execution.
+ """
+
+ __tablename__ = 'operation_template'
+
+ __private_fields__ = ('service_template_fk',
+ 'interface_template_fk',
+ 'plugin_fk')
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def plugin_specification(cls):
+ """
+ Associated plugin specification.
+
+ :type: :class:`PluginSpecification`
+ """
+ return relationship.one_to_one(
+ cls, 'plugin_specification', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def operations(cls):
+ """
+ Instantiated operations.
+
+ :type: [:class:`Operation`]
+ """
+ return relationship.one_to_many(cls, 'operation')
+
+ @declared_attr
+ def inputs(cls):
+ """
+ Declarations for parameters provided to the :attr:`implementation`.
+
+ :type: {:obj:`basestring`: :class:`Input`}
+ """
+ return relationship.one_to_many(cls, 'input', dict_key='name')
+
+ @declared_attr
+ def configurations(cls):
+ """
+ Configuration parameters for the operation instance Python :attr:`function`.
+
+ :type: {:obj:`basestring`: :class:`Configuration`}
+ """
+ return relationship.one_to_many(cls, 'configuration', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def service_template(cls):
+ """
+ Containing service template (can be ``None``). For workflow operation templates.
+
+ :type: :class:`ServiceTemplate`
+ """
+ return relationship.many_to_one(cls, 'service_template',
+ back_populates='workflow_templates')
+
+ @declared_attr
+ def interface_template(cls):
+ """
+ Containing interface template (can be ``None``).
+
+ :type: :class:`InterfaceTemplate`
+ """
+ return relationship.many_to_one(cls, 'interface_template')
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to OperationTemplate"""
+ return relationship.foreign_key('service_template', nullable=True)
+
+ @declared_attr
+ def interface_template_fk(cls):
+ """For InterfaceTemplate one-to-many to OperationTemplate"""
+ return relationship.foreign_key('interface_template', nullable=True)
+
+ @declared_attr
+ def plugin_specification_fk(cls):
+ """For OperationTemplate one-to-one to PluginSpecification"""
+ return relationship.foreign_key('plugin_specification', nullable=True)
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ relationship_edge = Column(Boolean, doc="""
+ When ``True`` specifies that the operation is on the relationship's target edge; ``False`` is
+ the source edge (only used by operations on relationships)
+
+ :type: :obj:`bool`
+ """)
+
+ implementation = Column(Text, doc="""
+ Implementation (usually the name of an artifact).
+
+ :type: :obj:`basestring`
+ """)
+
+ dependencies = Column(modeling_types.StrictList(item_cls=basestring), doc="""
+ Dependencies (usually names of artifacts).
+
+ :type: [:obj:`basestring`]
+ """)
+
+ function = Column(Text, doc="""
+ Full path to Python function.
+
+ :type: :obj:`basestring`
+ """)
+
+ executor = Column(Text, doc="""
+ Name of executor.
+
+ :type: :obj:`basestring`
+ """)
+
+ max_attempts = Column(Integer, doc="""
+ Maximum number of attempts allowed in case of task failure.
+
+ :type: :obj:`int`
+ """)
+
+ retry_interval = Column(Integer, doc="""
+ Interval between task retry attemps (in seconds).
+
+ :type: :obj:`float`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('description', self.description),
+ ('implementation', self.implementation),
+ ('dependencies', self.dependencies),
+ ('inputs', formatting.as_raw_dict(self.inputs))))
+
+
+class ArtifactTemplateBase(TemplateModelMixin):
+ """
+ Template for creating an :class:`Artifact` instance, which is a typed file, either provided in a
+ CSAR or downloaded from a repository.
+ """
+
+ __tablename__ = 'artifact_template'
+
+ __private_fields__ = ('type_fk',
+ 'node_template_fk')
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def artifacts(cls):
+ """
+ Instantiated artifacts.
+
+ :type: [:class:`Artifact`]
+ """
+ return relationship.one_to_many(cls, 'artifact')
+
+ @declared_attr
+ def properties(cls):
+ """
+ Declarations for associated immutable parameters.
+
+ :type: {:obj:`basestring`: :class:`Property`}
+ """
+ return relationship.one_to_many(cls, 'property', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def node_template(cls):
+ """
+ Containing node template.
+
+ :type: :class:`NodeTemplate`
+ """
+ return relationship.many_to_one(cls, 'node_template')
+
+ @declared_attr
+ def type(cls):
+ """
+ Artifact type.
+
+ :type: :class:`Type`
+ """
+ return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For ArtifactTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to ArtifactTemplate"""
+ return relationship.foreign_key('node_template')
+
+ # endregion
+
+ description = Column(Text, doc="""
+ Human-readable description.
+
+ :type: :obj:`basestring`
+ """)
+
+ source_path = Column(Text, doc="""
+ Source path (in CSAR or repository).
+
+ :type: :obj:`basestring`
+ """)
+
+ target_path = Column(Text, doc="""
+ Path at which to install at destination.
+
+ :type: :obj:`basestring`
+ """)
+
+ repository_url = Column(Text, doc="""
+ Repository URL.
+
+ :type: :obj:`basestring`
+ """)
+
+ repository_credential = Column(modeling_types.StrictDict(basestring, basestring), doc="""
+ Credentials for accessing the repository.
+
+ :type: {:obj:`basestring`, :obj:`basestring`}
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('description', self.description),
+ ('type_name', self.type.name),
+ ('source_path', self.source_path),
+ ('target_path', self.target_path),
+ ('repository_url', self.repository_url),
+ ('repository_credential', formatting.as_agnostic(self.repository_credential)),
+ ('properties', formatting.as_raw_dict(self.properties))))
+
+
+class PluginSpecificationBase(TemplateModelMixin):
+ """
+ Requirement for a :class:`Plugin`.
+
+ The actual plugin to be selected depends on those currently installed in ARIA.
+ """
+
+ __tablename__ = 'plugin_specification'
+
+ __private_fields__ = ('service_template_fk',
+ 'plugin_fk')
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def service_template(cls):
+ """
+ Containing service template.
+
+ :type: :class:`ServiceTemplate`
+ """
+ return relationship.many_to_one(cls, 'service_template')
+
+ @declared_attr
+ def plugin(cls): # pylint: disable=method-hidden
+ """
+ Matched plugin.
+
+ :type: :class:`Plugin`
+ """
+ return relationship.many_to_one(cls, 'plugin', back_populates=relationship.NO_BACK_POP)
+
+ # endregion
+
+ # region foreign keys
+
+ @declared_attr
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to PluginSpecification"""
+ return relationship.foreign_key('service_template', nullable=True)
+
+ @declared_attr
+ def plugin_fk(cls):
+ """For PluginSpecification many-to-one to Plugin"""
+ return relationship.foreign_key('plugin', nullable=True)
+
+ # endregion
+
+ version = Column(Text, doc="""
+ Minimum plugin version.
+
+ :type: :obj:`basestring`
+ """)
+
+ enabled = Column(Boolean, nullable=False, default=True, doc="""
+ Whether the plugin is enabled.
+
+ :type: :obj:`bool`
+ """)
+
+ @property
+ def as_raw(self):
+ return collections.OrderedDict((
+ ('name', self.name),
+ ('version', self.version),
+ ('enabled', self.enabled)))
Code Review / multicloud / azure.git / blobdiff