| # 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 common module |
| """ |
| |
| # pylint: disable=no-self-argument, no-member, abstract-method |
| |
| from sqlalchemy import ( |
| Column, |
| Text, |
| Boolean, |
| PickleType |
| ) |
| from sqlalchemy.ext.declarative import declared_attr |
| |
| from ..utils import ( |
| collections, |
| formatting |
| ) |
| from .mixins import InstanceModelMixin, TemplateModelMixin, ParameterMixin |
| from . import relationship |
| |
| |
| class OutputBase(ParameterMixin): |
| """ |
| Output parameter or declaration for an output parameter. |
| """ |
| |
| __tablename__ = 'output' |
| |
| # region many_to_one relationships |
| |
| @declared_attr |
| def service_template(cls): |
| """ |
| Containing service template (can be ``None``). |
| |
| :type: :class:`ServiceTemplate` |
| """ |
| return relationship.many_to_one(cls, 'service_template') |
| |
| @declared_attr |
| def service(cls): |
| """ |
| Containing service (can be ``None``). |
| |
| :type: :class:`ServiceTemplate` |
| """ |
| return relationship.many_to_one(cls, 'service') |
| |
| # endregion |
| |
| # region foreign keys |
| |
| @declared_attr |
| def service_template_fk(cls): |
| return relationship.foreign_key('service_template', nullable=True) |
| |
| @declared_attr |
| def service_fk(cls): |
| return relationship.foreign_key('service', nullable=True) |
| |
| # endregion |
| |
| |
| class InputBase(ParameterMixin): |
| """ |
| Input parameter or declaration for an input parameter. |
| """ |
| |
| __tablename__ = 'input' |
| |
| required = Column(Boolean, doc=""" |
| Is the input mandatory. |
| |
| :type: :obj:`bool` |
| """) |
| |
| @classmethod |
| def wrap(cls, name, value, description=None, required=True): # pylint: disable=arguments-differ |
| input = super(InputBase, cls).wrap(name, value, description) |
| input.required = required |
| return input |
| |
| # region many_to_one relationships |
| |
| @declared_attr |
| def service_template(cls): |
| """ |
| Containing service template (can be ``None``). |
| |
| :type: :class:`ServiceTemplate` |
| """ |
| return relationship.many_to_one(cls, 'service_template') |
| |
| @declared_attr |
| def service(cls): |
| """ |
| Containing service (can be ``None``). |
| |
| :type: :class:`Service` |
| """ |
| return relationship.many_to_one(cls, 'service') |
| |
| @declared_attr |
| def interface(cls): |
| """ |
| Containing interface (can be ``None``). |
| |
| :type: :class:`Interface` |
| """ |
| return relationship.many_to_one(cls, 'interface') |
| |
| @declared_attr |
| def operation(cls): |
| """ |
| Containing operation (can be ``None``). |
| |
| :type: :class:`Operation` |
| """ |
| return relationship.many_to_one(cls, 'operation') |
| |
| @declared_attr |
| def interface_template(cls): |
| """ |
| Containing interface template (can be ``None``). |
| |
| :type: :class:`InterfaceTemplate` |
| """ |
| return relationship.many_to_one(cls, 'interface_template') |
| |
| @declared_attr |
| def operation_template(cls): |
| """ |
| Containing operation template (can be ``None``). |
| |
| :type: :class:`OperationTemplate` |
| """ |
| return relationship.many_to_one(cls, 'operation_template') |
| |
| @declared_attr |
| def execution(cls): |
| """ |
| Containing execution (can be ``None``). |
| |
| :type: :class:`Execution` |
| """ |
| return relationship.many_to_one(cls, 'execution') |
| |
| # endregion |
| |
| # region foreign keys |
| |
| @declared_attr |
| def service_template_fk(cls): |
| return relationship.foreign_key('service_template', nullable=True) |
| |
| @declared_attr |
| def service_fk(cls): |
| return relationship.foreign_key('service', nullable=True) |
| |
| @declared_attr |
| def interface_fk(cls): |
| return relationship.foreign_key('interface', nullable=True) |
| |
| @declared_attr |
| def operation_fk(cls): |
| return relationship.foreign_key('operation', nullable=True) |
| |
| @declared_attr |
| def interface_template_fk(cls): |
| return relationship.foreign_key('interface_template', nullable=True) |
| |
| @declared_attr |
| def operation_template_fk(cls): |
| return relationship.foreign_key('operation_template', nullable=True) |
| |
| @declared_attr |
| def execution_fk(cls): |
| return relationship.foreign_key('execution', nullable=True) |
| |
| @declared_attr |
| def task_fk(cls): |
| return relationship.foreign_key('task', nullable=True) |
| |
| # endregion |
| |
| |
| class ConfigurationBase(ParameterMixin): |
| """ |
| Configuration parameter. |
| """ |
| |
| __tablename__ = 'configuration' |
| |
| # region many_to_one relationships |
| |
| @declared_attr |
| def operation_template(cls): |
| """ |
| Containing operation template (can be ``None``). |
| |
| :type: :class:`OperationTemplate` |
| """ |
| return relationship.many_to_one(cls, 'operation_template') |
| |
| @declared_attr |
| def operation(cls): |
| """ |
| Containing operation (can be ``None``). |
| |
| :type: :class:`Operation` |
| """ |
| return relationship.many_to_one(cls, 'operation') |
| |
| # endregion |
| |
| # region foreign keys |
| |
| @declared_attr |
| def operation_template_fk(cls): |
| return relationship.foreign_key('operation_template', nullable=True) |
| |
| @declared_attr |
| def operation_fk(cls): |
| return relationship.foreign_key('operation', nullable=True) |
| |
| # endregion |
| |
| |
| class PropertyBase(ParameterMixin): |
| """ |
| Property parameter or declaration for a property parameter. |
| """ |
| |
| __tablename__ = 'property' |
| |
| # 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 policy_template(cls): |
| """ |
| Containing policy template (can be ``None``). |
| |
| :type: :class:`PolicyTemplate` |
| """ |
| return relationship.many_to_one(cls, 'policy_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 capability_template(cls): |
| """ |
| Containing capability template (can be ``None``). |
| |
| :type: :class:`CapabilityTemplate` |
| """ |
| return relationship.many_to_one(cls, 'capability_template') |
| |
| @declared_attr |
| def artifact_template(cls): |
| """ |
| Containing artifact template (can be ``None``). |
| |
| :type: :class:`ArtifactTemplate` |
| """ |
| return relationship.many_to_one(cls, 'artifact_template') |
| |
| @declared_attr |
| def node(cls): |
| """ |
| Containing node (can be ``None``). |
| |
| :type: :class:`Node` |
| """ |
| return relationship.many_to_one(cls, 'node') |
| |
| @declared_attr |
| def group(cls): |
| """ |
| Containing group (can be ``None``). |
| |
| :type: :class:`Group` |
| """ |
| return relationship.many_to_one(cls, 'group') |
| |
| @declared_attr |
| def policy(cls): |
| """ |
| Containing policy (can be ``None``). |
| |
| :type: :class:`Policy` |
| """ |
| return relationship.many_to_one(cls, 'policy') |
| |
| @declared_attr |
| def relationship(cls): |
| """ |
| Containing relationship (can be ``None``). |
| |
| :type: :class:`Relationship` |
| """ |
| return relationship.many_to_one(cls, 'relationship') |
| |
| @declared_attr |
| def capability(cls): |
| """ |
| Containing capability (can be ``None``). |
| |
| :type: :class:`Capability` |
| """ |
| return relationship.many_to_one(cls, 'capability') |
| |
| @declared_attr |
| def artifact(cls): |
| """ |
| Containing artifact (can be ``None``). |
| |
| :type: :class:`Artifact` |
| """ |
| return relationship.many_to_one(cls, 'artifact') |
| |
| # endregion |
| |
| # region foreign keys |
| |
| @declared_attr |
| def node_template_fk(cls): |
| return relationship.foreign_key('node_template', nullable=True) |
| |
| @declared_attr |
| def group_template_fk(cls): |
| return relationship.foreign_key('group_template', nullable=True) |
| |
| @declared_attr |
| def policy_template_fk(cls): |
| return relationship.foreign_key('policy_template', nullable=True) |
| |
| @declared_attr |
| def relationship_template_fk(cls): |
| return relationship.foreign_key('relationship_template', nullable=True) |
| |
| @declared_attr |
| def capability_template_fk(cls): |
| return relationship.foreign_key('capability_template', nullable=True) |
| |
| @declared_attr |
| def artifact_template_fk(cls): |
| return relationship.foreign_key('artifact_template', nullable=True) |
| |
| @declared_attr |
| def node_fk(cls): |
| return relationship.foreign_key('node', nullable=True) |
| |
| @declared_attr |
| def group_fk(cls): |
| return relationship.foreign_key('group', nullable=True) |
| |
| @declared_attr |
| def policy_fk(cls): |
| return relationship.foreign_key('policy', nullable=True) |
| |
| @declared_attr |
| def relationship_fk(cls): |
| return relationship.foreign_key('relationship', nullable=True) |
| |
| @declared_attr |
| def capability_fk(cls): |
| return relationship.foreign_key('capability', nullable=True) |
| |
| @declared_attr |
| def artifact_fk(cls): |
| return relationship.foreign_key('artifact', nullable=True) |
| |
| # endregion |
| |
| |
| class AttributeBase(ParameterMixin): |
| """ |
| Attribute parameter or declaration for an attribute parameter. |
| """ |
| |
| __tablename__ = 'attribute' |
| |
| # 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 node(cls): |
| """ |
| Containing node (can be ``None``). |
| |
| :type: :class:`Node` |
| """ |
| return relationship.many_to_one(cls, 'node') |
| |
| # endregion |
| |
| # region foreign keys |
| |
| @declared_attr |
| def node_template_fk(cls): |
| """For Attribute many-to-one to NodeTemplate""" |
| return relationship.foreign_key('node_template', nullable=True) |
| |
| @declared_attr |
| def node_fk(cls): |
| """For Attribute many-to-one to Node""" |
| return relationship.foreign_key('node', nullable=True) |
| |
| # endregion |
| |
| |
| class TypeBase(InstanceModelMixin): |
| """ |
| Type and its children. Can serve as the root for a type hierarchy. |
| """ |
| |
| __tablename__ = 'type' |
| |
| __private_fields__ = ('parent_type_fk',) |
| |
| variant = Column(Text, nullable=False) |
| |
| description = Column(Text, doc=""" |
| Human-readable description. |
| |
| :type: :obj:`basestring` |
| """) |
| |
| _role = Column(Text, name='role') |
| |
| # region one_to_one relationships |
| |
| @declared_attr |
| def parent(cls): |
| """ |
| Parent type (will be ``None`` for the root of a type hierarchy). |
| |
| :type: :class:`Type` |
| """ |
| return relationship.one_to_one_self(cls, 'parent_type_fk') |
| |
| # endregion |
| |
| # region one_to_many relationships |
| |
| @declared_attr |
| def children(cls): |
| """ |
| Children. |
| |
| :type: [:class:`Type`] |
| """ |
| return relationship.one_to_many(cls, other_fk='parent_type_fk', self=True) |
| |
| # endregion |
| |
| # region foreign keys |
| |
| @declared_attr |
| def parent_type_fk(cls): |
| """For Type one-to-many to Type""" |
| return relationship.foreign_key('type', nullable=True) |
| |
| # endregion |
| |
| @property |
| def role(self): |
| def get_role(the_type): |
| if the_type is None: |
| return None |
| elif the_type._role is None: |
| return get_role(the_type.parent) |
| return the_type._role |
| |
| return get_role(self) |
| |
| @role.setter |
| def role(self, value): |
| self._role = value |
| |
| def is_descendant(self, base_name, name): |
| base = self.get_descendant(base_name) |
| if base is not None: |
| if base.get_descendant(name) is not None: |
| return True |
| return False |
| |
| def get_descendant(self, name): |
| if self.name == name: |
| return self |
| for child in self.children: |
| found = child.get_descendant(name) |
| if found is not None: |
| return found |
| return None |
| |
| def iter_descendants(self): |
| for child in self.children: |
| yield child |
| for descendant in child.iter_descendants(): |
| yield descendant |
| |
| @property |
| def as_raw(self): |
| return collections.OrderedDict(( |
| ('name', self.name), |
| ('description', self.description), |
| ('role', self.role))) |
| |
| @property |
| def as_raw_all(self): |
| types = [] |
| self._append_raw_children(types) |
| return types |
| |
| def _append_raw_children(self, types): |
| for child in self.children: |
| raw_child = formatting.as_raw(child) |
| raw_child['parent'] = self.name |
| types.append(raw_child) |
| child._append_raw_children(types) |
| |
| @property |
| def hierarchy(self): |
| """ |
| Type hierarchy as a list beginning with this type and ending in the root. |
| |
| :type: [:class:`Type`] |
| """ |
| return [self] + (self.parent.hierarchy if self.parent else []) |
| |
| |
| class MetadataBase(TemplateModelMixin): |
| """ |
| Custom values associated with the service. |
| |
| This model is used by both service template and service instance elements. |
| |
| :ivar name: name |
| :vartype name: basestring |
| :ivar value: value |
| """ |
| |
| __tablename__ = 'metadata' |
| |
| value = Column(PickleType) |
| |
| @property |
| def as_raw(self): |
| return collections.OrderedDict(( |
| ('name', self.name), |
| ('value', self.value))) |