Phase 1: added all remaing instance elements
Project: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/commit/e0b83e4b Tree: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/tree/e0b83e4b Diff: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/diff/e0b83e4b Branch: refs/heads/ARIA-44-Merge-parser-and-storage-models Commit: e0b83e4bf3c7b642de507a0d110f530f88795e4d Parents: 09f1f73 Author: mxmrlv <mxm...@gmail.com> Authored: Thu Jan 19 15:13:52 2017 +0200 Committer: mxmrlv <mxm...@gmail.com> Committed: Thu Jan 19 15:13:52 2017 +0200 ---------------------------------------------------------------------- aria/modeling/instance_elements.py | 394 +++++++++++++++++++++++++++++++- 1 file changed, 393 insertions(+), 1 deletion(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/e0b83e4b/aria/modeling/instance_elements.py ---------------------------------------------------------------------- diff --git a/aria/modeling/instance_elements.py b/aria/modeling/instance_elements.py index 82d2f7e..a4a3108 100644 --- a/aria/modeling/instance_elements.py +++ b/aria/modeling/instance_elements.py @@ -11,6 +11,8 @@ from ..utils import collections, formatting, console from ..parser import validation +# region Tier 0 elements + class ServiceInstance(elements.Element, structure.ModelMixin): description = Column(Text) @@ -324,6 +326,231 @@ class Artifact(elements.Element, structure.ModelMixin): utils.dump_parameters(context, self.properties) +class Policy(elements.Element, structure.ModelMixin): + """ + An instance of a :class:`PolicyTemplate`. + + Properties: + + * :code:`name`: Name + * :code:`type_name`: Must be represented in the :class:`ModelingContext` + * :code:`properties`: Dict of :class:`Parameter` + * :code:`target_node_ids`: Must be represented in the :class:`ServiceInstance` + * :code:`target_group_ids`: Must be represented in the :class:`ServiceInstance` + """ + + type_name = Column(Text) + properties = Column(type.StrictDict(basestring, elements.Parameter)) + target_node_ids = Column(type.StrictList(basestring)) + target_group_ids = Column(type.StrictList(basestring)) + + @property + def as_raw(self): + return collections.OrderedDict(( + ('name', self.name), + ('type_name', self.type_name), + ('properties', formatting.as_raw_dict(self.properties)), + ('target_node_ids', self.target_node_ids), + ('target_group_ids', self.target_group_ids))) + + def validate(self, context): + if context.modeling.policy_types.get_descendant(self.type_name) is None: + context.validation.report('policy "%s" has an unknown type: %s' + % (self.name, + utils.safe_repr(self.type_name)), + level=validation.Issue.BETWEEN_TYPES) + + utils.validate_dict_values(context, self.properties) + + def coerce_values(self, context, container, report_issues): + utils.coerce_dict_values(context, container, self.properties, report_issues) + + def dump(self, context): + console.puts('Policy: %s' % context.style.node(self.name)) + with context.style.indent: + console.puts('Type: %s' % context.style.type(self.type_name)) + utils.dump_parameters(context, self.properties) + if self.target_node_ids: + console.puts('Target nodes:') + with context.style.indent: + for node_id in self.target_node_ids: + console.puts(context.style.node(node_id)) + if self.target_group_ids: + console.puts('Target groups:') + with context.style.indent: + for group_id in self.target_group_ids: + console.puts(context.style.node(group_id)) + + +class GroupPolicy(elements.Element, structure.ModelMixin): + """ + Policies applied to groups. + + Properties: + + * :code:`name`: Name + * :code:`description`: Description + * :code:`type_name`: Must be represented in the :class:`ModelingContext` + * :code:`properties`: Dict of :class:`Parameter` + * :code:`triggers`: Dict of :class:`GroupPolicyTrigger` + """ + + description = Column(Text) + type_name = Column(Text) + properties = Column(type.StrictDict(basestring, elements.Parameter)) + triggers = Column(type.StrictDict(basestring, GroupPolicyTrigger)) + + @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)), + ('triggers', formatting.as_raw_list(self.triggers)))) + + def validate(self, context): + if context.modeling.policy_types.get_descendant(self.type_name) is None: + context.validation.report( + 'group policy "%s" has an unknown type: %s' + % (self.name, + formatting.safe_repr(self.type_name)), + level=validation.Issue.BETWEEN_TYPES) + + utils.validate_dict_values(context, self.properties) + utils.validate_dict_values(context, self.triggers) + + def coerce_values(self, context, container, report_issues): + utils.coerce_dict_values(context, container, self.properties, report_issues) + utils.coerce_dict_values(context, container, self.triggers, report_issues) + + def dump(self, context): + console.puts(context.style.node(self.name)) + if self.description: + console.puts(context.style.meta(self.description)) + with context.style.indent: + console.puts('Group policy type: %s' % context.style.type(self.type_name)) + utils.dump_parameters(context, self.properties) + utils.dump_dict_values(context, self.triggers, 'Triggers') + + +class GroupPolicyTrigger(elements.Element, structure.ModelMixin): + """ + Triggers for :class:`GroupPolicy`. + + Properties: + + * :code:`name`: Name + * :code:`description`: Description + * :code:`implementation`: Implementation string (interpreted by the orchestrator) + * :code:`properties`: Dict of :class:`Parameter` + """ + + description = Column(Text) + # Check: what's that? + implementation = Column() + properties = Column(type.StrictDict(basestring, elements.Parameter)) + + @property + def as_raw(self): + return collections.OrderedDict(( + ('name', self.name), + ('description', self.description), + ('implementation', self.implementation), + ('properties', formatting.as_raw_dict(self.properties)))) + + def validate(self, context): + utils.validate_dict_values(context, self.properties) + + def coerce_values(self, context, container, report_issues): + utils.coerce_dict_values(context, container, self.properties, report_issues) + + def dump(self, context): + console.puts(context.style.node(self.name)) + if self.description: + console.puts(context.style.meta(self.description)) + with context.style.indent: + console.puts('Implementation: %s' % context.style.literal(self.implementation)) + utils.dump_parameters(context, self.properties) + + +class Mapping(elements.Element, structure.ModelMixin): + """ + An instance of a :class:`MappingTemplate`. + + Properties: + + * :code:`mapped_name`: Exposed capability or requirement name + * :code:`node_id`: Must be represented in the :class:`ServiceInstance` + * :code:`name`: Name of capability or requirement at the node + """ + + mapped_name = Column(Text) + node_id = Column(Text) + + @property + def as_raw(self): + return collections.OrderedDict(( + ('mapped_name', self.mapped_name), + ('node_id', self.node_id), + ('name', self.name))) + + def dump(self, context): + console.puts('%s -> %s.%s' + % (context.style.node(self.mapped_name), + context.style.node(self.node_id), + context.style.node(self.name))) + + +class Substitution(elements.Element, structure.ModelMixin): + """ + An instance of a :class:`SubstitutionTemplate`. + + Properties: + + * :code:`node_type_name`: Must be represented in the :class:`ModelingContext` + * :code:`capabilities`: Dict of :class:`Mapping` + * :code:`requirements`: Dict of :class:`Mapping` + """ + + node_type_name = Column(Text) + capabilities = Column(type.StrictDict(basestring, Mapping)) + requirements = Column(type.StrictDict(basestring, Mapping)) + + @property + def as_raw(self): + return collections.OrderedDict(( + ('node_type_name', self.node_type_name), + ('capabilities', formatting.as_raw_list(self.capabilities)), + ('requirements', formatting.as_raw_list(self.requirements)))) + + def validate(self, context): + if context.modeling.node_types.get_descendant(self.node_type_name) is None: + context.validation.report('substitution "%s" has an unknown type: %s' + % (self.name, # pylint: disable=no-member + # TODO fix self.name reference + formatting.safe_repr(self.node_type_name)), + level=validation.Issue.BETWEEN_TYPES) + + utils.validate_dict_values(context, self.capabilities) + utils.validate_dict_values(context, self.requirements) + + def coerce_values(self, context, container, report_issues): + utils.coerce_dict_values(context, container, self.capabilities, report_issues) + utils.coerce_dict_values(context, container, self.requirements, report_issues) + + def dump(self, context): + console.puts('Substitution:') + with context.style.indent: + console.puts('Node type: %s' % context.style.type(self.node_type_name)) + utils.dump_dict_values(context, self.capabilities, 'Capability mappings') + utils.dump_dict_values(context, self.requirements, 'Requirement mappings') + + +# endregion + + +# region Tier 1 elements class Node(elements.Element, structure.ModelMixin): """ @@ -482,4 +709,169 @@ class Node(elements.Element, structure.ModelMixin): utils.dump_interfaces(context, self.interfaces) utils.dump_dict_values(context, self.artifacts, 'Artifacts') utils.dump_dict_values(context, self.capabilities, 'Capabilities') - utils.dump_list_values(context, self.relationships, 'Relationships') \ No newline at end of file + utils.dump_list_values(context, self.relationships, 'Relationships') + + +class Relationship(elements.Element, structure.ModelMixin): + """ + Connects :class:`Node` to another node. + + An instance of a :class:`RelationshipTemplate`. + + Properties: + + * :code:`name`: Name (usually the name of the requirement at the source node template) + * :code:`source_requirement_index`: Must be represented in the source node template + * :code:`target_node_id`: Must be represented in the :class:`ServiceInstance` + * :code:`target_capability_name`: Matches the capability at the target node + * :code:`type_name`: Must be represented in the :class:`ModelingContext` + * :code:`template_name`: Must be represented in the :class:`ServiceModel` + * :code:`properties`: Dict of :class:`Parameter` + * :code:`source_interfaces`: Dict of :class:`Interface` + * :code:`target_interfaces`: Dict of :class:`Interface` + """ + + def __init__(self, name=None, + source_requirement_index=None, + type_name=None, + template_name=None): + if name is not None and not isinstance(name, basestring): + raise ValueError('name must be a string or None') + if (source_requirement_index is not None and + (not isinstance(source_requirement_index, int) or ( + source_requirement_index < 0))): + raise ValueError('source_requirement_index must be int > 0') + if type_name is not None and not isinstance(type_name, basestring): + raise ValueError('type_name must be a string or None') + if template_name is not None and not isinstance(template_name, basestring): + raise ValueError('template_name must be a string or None') + + source_requirement_index = Column(Integer) + target_node_id = Column(Text) + target_capability_name = Column(Text) + type_name = Column(Text) + template_name = Column(Text) + properties = Column(type.StrictDict(basestring, elements.Parameter)) + source_interfaces = Column(type.StrictDict(basestring, Interface)) + target_interfaces = Column(type.StrictDict(basestring, Interface)) + + @property + def as_raw(self): + return collections.OrderedDict(( + ('name', self.name), + ('source_requirement_index', self.source_requirement_index), + ('target_node_id', self.target_node_id), + ('target_capability_name', self.target_capability_name), + ('type_name', self.type_name), + ('template_name', self.template_name), + ('properties', formatting.as_raw_dict(self.properties)), + ('source_interfaces', formatting.as_raw_list(self.source_interfaces)), + ('target_interfaces', formatting.as_raw_list(self.target_interfaces)))) + + def validate(self, context): + if self.type_name: + if context.modeling.relationship_types.get_descendant(self.type_name) is None: + context.validation.report('relationship "%s" has an unknown type: %s' + % (self.name, + formatting.safe_repr(self.type_name)), + level=validation.Issue.BETWEEN_TYPES) + utils.validate_dict_values(context, self.properties) + utils.validate_dict_values(context, self.source_interfaces) + utils.validate_dict_values(context, self.target_interfaces) + + def coerce_values(self, context, container, report_issues): + utils.coerce_dict_values(context, container, self.properties, report_issues) + utils.coerce_dict_values(context, container, self.source_interfaces, report_issues) + utils.coerce_dict_values(context, container, self.target_interfaces, report_issues) + + def dump(self, context): + if self.name: + if self.source_requirement_index is not None: + console.puts('%s (%d) ->' % ( + context.style.node(self.name), self.source_requirement_index)) + else: + console.puts('%s ->' % context.style.node(self.name)) + else: + console.puts('->') + with context.style.indent: + console.puts('Node: %s' % context.style.node(self.target_node_id)) + if self.target_capability_name is not None: + console.puts('Capability: %s' % context.style.node(self.target_capability_name)) + if self.type_name is not None: + console.puts('Relationship type: %s' % context.style.type(self.type_name)) + if self.template_name is not None: + console.puts('Relationship template: %s' % context.style.node(self.template_name)) + utils.dump_parameters(context, self.properties) + utils.dump_interfaces(context, self.source_interfaces, 'Source interfaces') + utils.dump_interfaces(context, self.target_interfaces, 'Target interfaces') + + +class Group(elements.Element, structure.ModelMixin): + """ + An instance of a :class:`GroupTemplate`. + + Properties: + + * :code:`id`: Unique ID (prefixed with the template name) + * :code:`type_name`: Must be represented in the :class:`ModelingContext` + * :code:`template_name`: Must be represented in the :class:`ServiceModel` + * :code:`properties`: Dict of :class:`Parameter` + * :code:`interfaces`: Dict of :class:`Interface` + * :code:`policies`: Dict of :class:`GroupPolicy` + * :code:`member_node_ids`: Must be represented in the :class:`ServiceInstance` + * :code:`member_group_ids`: Must be represented in the :class:`ServiceInstance` + """ + + type_name = Column(Text) + template_name = Column(Text) + properties = Column(type.StrictDict(basestring, elements.Parameter)) + interfaces = Column(type.StrictDict(basestring, Interface)) + policies = Column(type.StrictDict(basestring, GroupPolicy)) + member_node_ids = Column(type.StrictList(basestring)) + member_group_ids = Column(type.StrictList(basestring)) + + @property + def as_raw(self): + return collections.OrderedDict(( + ('id', self.id), + ('type_name', self.type_name), + ('template_name', self.template_name), + ('properties', formatting.as_raw_dict(self.properties)), + ('interfaces', formatting.as_raw_list(self.interfaces)), + ('policies', formatting.as_raw_list(self.policies)), + ('member_node_ids', self.member_node_ids), + ('member_group_ids', self.member_group_ids))) + + def validate(self, context): + if context.modeling.group_types.get_descendant(self.type_name) is None: + context.validation.report('group "%s" has an unknown type: %s' + % (self.name, # pylint: disable=no-member + # TODO fix self.name reference + formatting.safe_repr(self.type_name)), + level=validation.Issue.BETWEEN_TYPES) + + utils.validate_dict_values(context, self.properties) + utils.validate_dict_values(context, self.interfaces) + utils.validate_dict_values(context, self.policies) + + def coerce_values(self, context, container, report_issues): + utils.coerce_dict_values(context, container, self.properties, report_issues) + utils.coerce_dict_values(context, container, self.interfaces, report_issues) + utils.coerce_dict_values(context, container, self.policies, report_issues) + + def dump(self, context): + console.puts('Group: %s' % context.style.node(self.id)) + with context.style.indent: + console.puts('Type: %s' % context.style.type(self.type_name)) + console.puts('Template: %s' % context.style.type(self.template_name)) + utils.dump_parameters(context, self.properties) + utils.dump_interfaces(context, self.interfaces) + utils.dump_dict_values(context, self.policies, 'Policies') + if self.member_node_ids: + console.puts('Member nodes:') + with context.style.indent: + for node_id in self.member_node_ids: + console.puts(context.style.node(node_id)) + +# endregion +
