diff options
Diffstat (limited to 'azure/aria/aria-extension-cloudify/src/aria/aria/modeling/service_common.py')
| -rw-r--r-- | azure/aria/aria-extension-cloudify/src/aria/aria/modeling/service_common.py | 601 |
1 files changed, 601 insertions, 0 deletions
diff --git a/azure/aria/aria-extension-cloudify/src/aria/aria/modeling/service_common.py b/azure/aria/aria-extension-cloudify/src/aria/aria/modeling/service_common.py new file mode 100644 index 0000000..d1f6b00 --- /dev/null +++ b/azure/aria/aria-extension-cloudify/src/aria/aria/modeling/service_common.py @@ -0,0 +1,601 @@ +# 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 +) +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 + :vartype value: basestring + """ + + __tablename__ = 'metadata' + + value = Column(Text) + + @property + def as_raw(self): + return collections.OrderedDict(( + ('name', self.name), + ('value', self.value))) |