You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@ariatosca.apache.org by em...@apache.org on 2017/03/17 19:38:38 UTC
[10/18] incubator-ariatosca git commit: ARIA-105 Integrate parser and
orchestrator models
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/extensions/aria_extension_tosca/simple_v1_0/functions.py
----------------------------------------------------------------------
diff --git a/extensions/aria_extension_tosca/simple_v1_0/functions.py b/extensions/aria_extension_tosca/simple_v1_0/functions.py
index e385817..405aa8f 100644
--- a/extensions/aria_extension_tosca/simple_v1_0/functions.py
+++ b/extensions/aria_extension_tosca/simple_v1_0/functions.py
@@ -19,8 +19,9 @@ from aria.utils.collections import FrozenList
from aria.utils.formatting import as_raw, safe_repr
from aria.parser import dsl_specification
from aria.parser.exceptions import InvalidValueError
-from aria.parser.modeling import (Function, CannotEvaluateFunctionException)
from aria.parser.validation import Issue
+from aria.modeling.exceptions import CannotEvaluateFunctionException
+from aria.modeling.functions import Function
#
# Intrinsic
@@ -139,8 +140,8 @@ class GetInput(Function):
raise CannotEvaluateFunctionException()
the_input = context.modeling.instance.inputs.get(
self.input_property_name,
- context.modeling.model.inputs.get(self.input_property_name))
- return the_input.value if the_input is not None else None
+ context.modeling.template.inputs.get(self.input_property_name))
+ return as_raw(the_input.value) if the_input is not None else None
@dsl_specification('4.4.2', 'tosca-simple-1.0')
class GetProperty(Function):
@@ -209,7 +210,7 @@ class GetProperty(Function):
found = False
break
if found:
- return value
+ return as_raw(value)
raise InvalidValueError(
'function "get_property" could not find "%s" in modelable entity "%s"' \
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/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 f340954..ec5ba3b 100644
--- a/extensions/aria_extension_tosca/simple_v1_0/modeling/__init__.py
+++ b/extensions/aria_extension_tosca/simple_v1_0/modeling/__init__.py
@@ -13,203 +13,239 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+"""
+Creates ARIA service template models based on the TOSCA presentation.
+
+Relies on many helper methods in the presentation classes.
+"""
+
import re
+from types import FunctionType
+from datetime import datetime
-from aria.parser.modeling import (Type, RelationshipType, PolicyType, ServiceModel, NodeTemplate,
+from aria.modeling.models import (Type, ServiceTemplate, NodeTemplate,
RequirementTemplate, RelationshipTemplate, CapabilityTemplate,
GroupTemplate, PolicyTemplate, SubstitutionTemplate,
- MappingTemplate, InterfaceTemplate, OperationTemplate,
- ArtifactTemplate, Metadata, Parameter)
+ SubstitutionTemplateMapping, InterfaceTemplate, OperationTemplate,
+ ArtifactTemplate, Metadata, Parameter, PluginSpecification)
from ..data_types import coerce_value
-from platform import node
-def create_service_model(context): # pylint: disable=too-many-locals,too-many-branches
- model = ServiceModel()
+
+def create_service_template_model(context): # pylint: disable=too-many-locals,too-many-branches
+ model = ServiceTemplate(created_at=datetime.now(),
+ main_file_name=str(context.presentation.location))
model.description = context.presentation.get('service_template', 'description', 'value')
+ # Metadata
metadata = context.presentation.get('service_template', 'metadata')
if metadata is not None:
- substitution_template = Metadata()
- substitution_template.values['template_name'] = metadata.template_name
- substitution_template.values['template_author'] = metadata.template_author
- substitution_template.values['template_version'] = metadata.template_version
- custom = metadata.custom
- if custom:
- for name, v in custom.iteritems():
- substitution_template.values[name] = v
- model.metadata = substitution_template
+ create_metadata_models(context, model, metadata)
+ # Types
+ model.node_types = Type(variant='node')
create_types(context,
- context.modeling.node_types,
+ model.node_types,
context.presentation.get('service_template', 'node_types'))
+ model.group_types = Type(variant='group')
create_types(context,
- context.modeling.group_types,
+ model.group_types,
context.presentation.get('service_template', 'group_types'))
+ model.policy_types = Type(variant='policy')
create_types(context,
- context.modeling.capability_types,
- context.presentation.get('service_template', 'capability_types'))
- create_types(context,
- context.modeling.relationship_types,
- context.presentation.get('service_template', 'relationship_types'),
- create_relationship_type)
+ model.policy_types,
+ context.presentation.get('service_template', 'policy_types'))
+ model.relationship_types = Type(variant='relationship')
create_types(context,
- context.modeling.policy_types,
- context.presentation.get('service_template', 'policy_types'),
- create_policy_type)
+ model.relationship_types,
+ context.presentation.get('service_template', 'relationship_types'))
+ model.capability_types = Type(variant='capability')
create_types(context,
- context.modeling.artifact_types,
- context.presentation.get('service_template', 'artifact_types'))
+ model.capability_types,
+ context.presentation.get('service_template', 'capability_types'))
+ model.interface_types = Type(variant='interface')
create_types(context,
- context.modeling.interface_types,
+ model.interface_types,
context.presentation.get('service_template', 'interface_types'))
+ model.artifact_types = Type(variant='artifact')
+ create_types(context,
+ model.artifact_types,
+ context.presentation.get('service_template', 'artifact_types'))
+ # Topology template
topology_template = context.presentation.get('service_template', 'topology_template')
if topology_template is not None:
- create_properties_from_values(model.inputs, topology_template._get_input_values(context))
- create_properties_from_values(model.outputs, topology_template._get_output_values(context))
+ create_parameter_models_from_values(model.inputs,
+ topology_template._get_input_values(context))
+ create_parameter_models_from_values(model.outputs,
+ topology_template._get_output_values(context))
+ # Plugin specifications
+ policies = context.presentation.get('service_template', 'topology_template', 'policies')
+ if policies:
+ for policy in policies.itervalues():
+ if model.policy_types.get_descendant(policy.type).role == 'plugin':
+ plugin_specification = create_plugin_specification_model(context, policy)
+ model.plugin_specifications[plugin_specification.name] = plugin_specification
+
+ # Node templates
node_templates = context.presentation.get('service_template', 'topology_template',
'node_templates')
if node_templates:
- for node_template_name, node_template in node_templates.iteritems():
- model.node_templates[node_template_name] = create_node_template(context, node_template)
+ for node_template in node_templates.itervalues():
+ node_template_model = create_node_template_model(context, model, node_template)
+ model.node_templates[node_template_model.name] = node_template_model
+ for node_template in node_templates.itervalues():
+ fix_node_template_model(context, model, node_template)
+ # Group templates
groups = context.presentation.get('service_template', 'topology_template', 'groups')
if groups:
- for group_name, group in groups.iteritems():
- model.group_templates[group_name] = create_group_template(context, group)
+ for group in groups.itervalues():
+ group_template_model = create_group_template_model(context, model, group)
+ model.group_templates[group_template_model.name] = group_template_model
+ # Policy templates
policies = context.presentation.get('service_template', 'topology_template', 'policies')
if policies:
- for policy_name, policy in policies.iteritems():
- model.policy_templates[policy_name] = create_policy_template(context, policy)
+ for policy in policies.itervalues():
+ policy_template_model = create_policy_template_model(context, model, policy)
+ model.policy_templates[policy_template_model.name] = policy_template_model
+ # Substitution template
substitution_mappings = context.presentation.get('service_template', 'topology_template',
'substitution_mappings')
- if substitution_mappings is not None:
- substitution_template = SubstitutionTemplate(substitution_mappings.node_type)
- capabilities = substitution_mappings.capabilities
- if capabilities:
- for mapped_capability_name, capability in capabilities.iteritems():
- substitution_template.capability_templates[mapped_capability_name] = \
- MappingTemplate(mapped_capability_name, capability.node_template,
- capability.capability)
- requirements = substitution_mappings.requirements
- if requirements:
- for mapped_requirement_name, requirement in requirements.iteritems():
- substitution_template.requirement_templates[mapped_requirement_name] = \
- MappingTemplate(mapped_requirement_name, requirement.node_template,
- requirement.requirement)
- model.substitution_template = substitution_template
+ if substitution_mappings:
+ model.substitution_template = create_substitution_template_model(context, model,
+ substitution_mappings)
return model
-def create_node_template(context, node_template):
+
+def create_metadata_models(context, service_template, metadata):
+ service_template.meta_data['template_name'] = Metadata(name='template_name',
+ value=metadata.template_name)
+ service_template.meta_data['template_author'] = Metadata(name='template_author',
+ value=metadata.template_author)
+ service_template.meta_data['template_version'] = Metadata(name='template_version',
+ value=metadata.template_version)
+ custom = metadata.custom
+ if custom:
+ for name, value in custom.iteritems():
+ service_template.meta_data[name] = Metadata(name=name,
+ value=value)
+
+
+def create_node_template_model(context, service_template, node_template):
node_type = node_template._get_type(context)
- model = NodeTemplate(name=node_template._name, type_name=node_type._name)
+ node_type = service_template.node_types.get_descendant(node_type._name)
+ model = NodeTemplate(name=node_template._name,
+ type=node_type)
+
+ model.default_instances = 1
+ model.min_instances = 0
if node_template.description:
model.description = node_template.description.value
- create_properties_from_values(model.properties, node_template._get_property_values(context))
- create_interface_templates(context, model.interface_templates,
- node_template._get_interfaces(context))
+ create_parameter_models_from_values(model.properties,
+ node_template._get_property_values(context))
+ create_interface_template_models(context, service_template, model.interface_templates,
+ node_template._get_interfaces(context))
artifacts = node_template._get_artifacts(context)
if artifacts:
for artifact_name, artifact in artifacts.iteritems():
- model.artifact_templates[artifact_name] = create_artifact_template(context, artifact)
-
- requirements = node_template._get_requirements(context)
- if requirements:
- for _, requirement in requirements:
- model.requirement_templates.append(create_requirement_template(context, requirement))
+ model.artifact_templates[artifact_name] = \
+ create_artifact_template_model(context, service_template, artifact)
capabilities = node_template._get_capabilities(context)
if capabilities:
for capability_name, capability in capabilities.iteritems():
- model.capability_templates[capability_name] = create_capability_template(context,
- capability)
+ model.capability_templates[capability_name] = \
+ create_capability_template_model(context, service_template, capability)
- create_node_filter_constraint_lambdas(context, node_template.node_filter,
- model.target_node_template_constraints)
+ if model.target_node_template_constraints:
+ model.target_node_template_constraints = []
+ create_node_filter_constraint_lambdas(context, node_template.node_filter,
+ model.target_node_template_constraints)
return model
-def create_interface_template(context, interface):
- interface_type = interface._get_type(context)
- model = InterfaceTemplate(name=interface._name, type_name=interface_type._name)
- if interface_type.description:
- model.description = interface_type.description.value
-
- inputs = interface.inputs
- if inputs:
- for input_name, the_input in inputs.iteritems():
- model.inputs[input_name] = Parameter(the_input.value.type, the_input.value.value,
- the_input.value.description)
-
- operations = interface.operations
- if operations:
- for operation_name, operation in operations.iteritems():
- model.operation_templates[operation_name] = create_operation_template(context,
- operation)
+def fix_node_template_model(context, service_template, node_template):
+ # Requirements have to be created after all node templates have been created, because
+ # requirements might reference another node template
+ model = service_template.node_templates[node_template._name]
+ requirements = node_template._get_requirements(context)
+ if requirements:
+ for _, requirement in requirements:
+ model.requirement_templates.append(create_requirement_template_model(context,
+ service_template,
+ requirement))
- return model if model.operation_templates else None
-def create_operation_template(context, operation): # pylint: disable=unused-argument
- model = OperationTemplate(name=operation._name)
+def create_group_template_model(context, service_template, group):
+ group_type = group._get_type(context)
+ group_type = service_template.group_types.get_descendant(group_type._name)
+ model = GroupTemplate(name=group._name,
+ type=group_type)
- if operation.description:
- model.description = operation.description.value
+ if group.description:
+ model.description = group.description.value
- implementation = operation.implementation
- if implementation is not None:
- model.implementation = implementation.primary
- dependencies = implementation.dependencies
- if dependencies is not None:
- model.dependencies = dependencies
+ create_parameter_models_from_values(model.properties, group._get_property_values(context))
+ create_interface_template_models(context, service_template, model.interface_templates,
+ group._get_interfaces(context))
- inputs = operation.inputs
- if inputs:
- for input_name, the_input in inputs.iteritems():
- model.inputs[input_name] = Parameter(the_input.value.type, the_input.value.value,
- the_input.value.description)
+ members = group.members
+ if members:
+ for member in members:
+ node_template = service_template.node_templates[member]
+ assert node_template
+ model.node_templates.append(node_template)
return model
-def create_artifact_template(context, artifact):
- model = ArtifactTemplate(name=artifact._name, type_name=artifact.type,
- source_path=artifact.file)
- if artifact.description:
- model.description = artifact.description.value
+def create_policy_template_model(context, service_template, policy):
+ policy_type = policy._get_type(context)
+ policy_type = service_template.policy_types.get_descendant(policy_type._name)
+ model = PolicyTemplate(name=policy._name,
+ type=policy_type)
- model.target_path = artifact.deploy_path
+ if policy.description:
+ model.description = policy.description.value
- repository = artifact._get_repository(context)
- if repository is not None:
- model.repository_url = repository.url
- credential = repository._get_credential(context)
- if credential:
- for k, v in credential.iteritems():
- model.repository_credential[k] = v
+ create_parameter_models_from_values(model.properties, policy._get_property_values(context))
- create_properties_from_values(model.properties, artifact._get_property_values(context))
+ node_templates, groups = policy._get_targets(context)
+ if node_templates:
+ for target in node_templates:
+ node_template = service_template.node_templates[target._name]
+ assert node_template
+ model.node_templates.append(node_template)
+ if groups:
+ for target in groups:
+ group_template = service_template.group_templates[target._name]
+ assert group_template
+ model.group_templates.append(group_template)
return model
-def create_requirement_template(context, requirement):
+
+def create_requirement_template_model(context, service_template, requirement):
model = {'name': requirement._name}
node, node_variant = requirement._get_node(context)
if node is not None:
if node_variant == 'node_type':
- model['target_node_type_name'] = node._name
+ node_type = service_template.node_types.get_descendant(node._name)
+ model['target_node_type'] = node_type
else:
- model['target_node_template_name'] = node._name
+ node_template = service_template.node_templates[node._name]
+ model['target_node_template'] = node_template
capability, capability_variant = requirement._get_capability(context)
if capability is not None:
@@ -220,41 +256,47 @@ def create_requirement_template(context, requirement):
model = RequirementTemplate(**model)
- create_node_filter_constraint_lambdas(context, requirement.node_filter,
- model.target_node_template_constraints)
+ if model.target_node_template_constraints:
+ model.target_node_template_constraints = []
+ create_node_filter_constraint_lambdas(context, requirement.node_filter,
+ model.target_node_template_constraints)
relationship = requirement.relationship
if relationship is not None:
- model.relationship_template = create_relationship_template(context, relationship)
+ model.relationship_template = \
+ create_relationship_template_model(context, service_template, relationship)
return model
-def create_relationship_type(context, relationship_type): # pylint: disable=unused-argument
- return RelationshipType(relationship_type._name)
-
-def create_policy_type(context, policy_type): # pylint: disable=unused-argument
- return PolicyType(policy_type._name)
-def create_relationship_template(context, relationship):
+def create_relationship_template_model(context, service_template, relationship):
relationship_type, relationship_type_variant = relationship._get_type(context)
if relationship_type_variant == 'relationship_type':
- model = RelationshipTemplate(type_name=relationship_type._name)
+ relationship_type = service_template.relationship_types.get_descendant(
+ relationship_type._name)
+ model = RelationshipTemplate(type=relationship_type)
else:
relationship_template = relationship_type
relationship_type = relationship_template._get_type(context)
- model = RelationshipTemplate(type_name=relationship_type._name,
- template_name=relationship_template._name)
+ relationship_type = service_template.relationship_types.get_descendant(
+ relationship_type._name)
+ model = RelationshipTemplate(type=relationship_type,
+ name=relationship_template._name)
if relationship_template.description:
model.description = relationship_template.description.value
- create_properties_from_assignments(model.properties, relationship.properties)
- create_interface_templates(context, model.source_interface_templates, relationship.interfaces)
+ create_parameter_models_from_assignments(model.properties, relationship.properties)
+ create_interface_template_models(context, service_template, model.interface_templates,
+ relationship.interfaces)
return model
-def create_capability_template(context, capability):
+
+def create_capability_template_model(context, service_template, capability):
capability_type = capability._get_type(context)
- model = CapabilityTemplate(name=capability._name, type_name=capability_type._name)
+ capability_type = service_template.capability_types.get_descendant(capability_type._name)
+ model = CapabilityTemplate(name=capability._name,
+ type=capability_type)
capability_definition = capability._get_definition(context)
if capability_definition.description:
@@ -267,51 +309,154 @@ def create_capability_template(context, capability):
valid_source_types = capability_definition.valid_source_types
if valid_source_types:
- model.valid_source_node_type_names = valid_source_types
+ for valid_source_type in valid_source_types:
+ # TODO: handle shortcut type names
+ node_type = service_template.node_types.get_descendant(valid_source_type)
+ model.valid_source_node_types.append(node_type)
- create_properties_from_assignments(model.properties, capability.properties)
+ create_parameter_models_from_assignments(model.properties, capability.properties)
return model
-def create_group_template(context, group):
- group_type = group._get_type(context)
- model = GroupTemplate(name=group._name, type_name=group_type._name)
- if group.description:
- model.description = group.description.value
+def create_interface_template_model(context, service_template, interface):
+ interface_type = interface._get_type(context)
+ interface_type = service_template.interface_types.get_descendant(interface_type._name)
+ model = InterfaceTemplate(name=interface._name,
+ type=interface_type)
- create_properties_from_values(model.properties, group._get_property_values(context))
- create_interface_templates(context, model.interface_templates, group._get_interfaces(context))
+ if interface_type.description:
+ model.description = interface_type.description
- members = group.members
- if members:
- for member in members:
- model.member_node_template_names.append(member)
+ inputs = interface.inputs
+ if inputs:
+ for input_name, the_input in inputs.iteritems():
+ model.inputs[input_name] = Parameter(name=input_name,
+ type_name=the_input.value.type,
+ value=the_input.value.value,
+ description=the_input.value.description)
+
+ operations = interface.operations
+ if operations:
+ for operation_name, operation in operations.iteritems():
+ model.operation_templates[operation_name] = \
+ create_operation_template_model(context, service_template, operation)
+
+ return model if model.operation_templates else None
+
+
+def create_operation_template_model(context, service_template, operation): # pylint: disable=unused-argument
+ model = OperationTemplate(name=operation._name)
+
+ if operation.description:
+ model.description = operation.description.value
+
+ implementation = operation.implementation
+ if (implementation is not None) and operation.implementation.primary:
+ model.plugin_specification, model.implementation = \
+ parse_implementation_string(context, service_template, operation.implementation.primary)
+
+ dependencies = implementation.dependencies
+ if dependencies is not None:
+ model.dependencies = dependencies
+
+ inputs = operation.inputs
+ if inputs:
+ for input_name, the_input in inputs.iteritems():
+ model.inputs[input_name] = Parameter(name=input_name,
+ type_name=the_input.value.type,
+ value=the_input.value.value,
+ description=the_input.value.description)
return model
-def create_policy_template(context, policy):
- policy_type = policy._get_type(context)
- model = PolicyTemplate(name=policy._name, type_name=policy_type._name)
- if policy.description:
- model.description = policy.description.value
+def create_artifact_template_model(context, service_template, artifact):
+ artifact_type = artifact._get_type(context)
+ artifact_type = service_template.artifact_types.get_descendant(artifact_type._name)
+ model = ArtifactTemplate(name=artifact._name,
+ type=artifact_type,
+ source_path=artifact.file)
+
+ if artifact.description:
+ model.description = artifact.description.value
- create_properties_from_values(model.properties, policy._get_property_values(context))
+ model.target_path = artifact.deploy_path
- node_templates, groups = policy._get_targets(context)
- for node_template in node_templates:
- model.target_node_template_names.append(node_template._name)
- for group in groups:
- model.target_group_template_names.append(group._name)
+ repository = artifact._get_repository(context)
+ if repository is not None:
+ model.repository_url = repository.url
+ credential = repository._get_credential(context)
+ if credential:
+ model.repository_credential = {}
+ for k, v in credential.iteritems():
+ model.repository_credential[k] = v
+
+ create_parameter_models_from_values(model.properties, artifact._get_property_values(context))
+
+ return model
+
+
+def create_substitution_template_model(context, service_template, substitution_mappings):
+ node_type = service_template.node_types.get_descendant(substitution_mappings.node_type)
+ model = SubstitutionTemplate(node_type=node_type)
+
+ capabilities = substitution_mappings.capabilities
+ if capabilities:
+ for mapped_capability_name, capability in capabilities.iteritems():
+ name = 'capability.' + mapped_capability_name
+ node_template_model = service_template.node_templates[capability.node_template]
+ capability_template_model = \
+ node_template_model.capability_templates[capability.capability]
+ model.mappings[name] = \
+ SubstitutionTemplateMapping(name=name,
+ node_template=node_template_model,
+ capability_template=capability_template_model)
+
+ requirements = substitution_mappings.requirements
+ if requirements:
+ for mapped_requirement_name, requirement in requirements.iteritems():
+ name = 'requirement.' + mapped_requirement_name
+ node_template_model = service_template.node_templates[requirement.node_template]
+ requirement_template_model = None
+ for a_model in node_template_model.requirement_templates:
+ if a_model.name == requirement.requirement:
+ requirement_template_model = a_model
+ break
+ model.mappings[name] = \
+ SubstitutionTemplateMapping(name=name,
+ node_template=node_template_model,
+ requirement_template=requirement_template_model)
return model
+
+def create_plugin_specification_model(context, policy):
+ properties = policy.properties
+
+ def get(name):
+ prop = properties.get(name)
+ return prop.value if prop is not None else None
+
+ model = PluginSpecification(name=policy._name,
+ archive_name=get('archive_name') or '',
+ distribution=get('distribution'),
+ distribution_release=get('distribution_release'),
+ distribution_version=get('distribution_version'),
+ package_name=get('package_name') or '',
+ package_source=get('package_source'),
+ package_version=get('package_version'),
+ supported_platform=get('supported_platform'),
+ supported_py_versions=get('supported_py_versions'))
+
+ return model
+
+
#
# Utils
#
-def create_types(context, root, types, normalize=None):
+def create_types(context, root, types):
if types is None:
return
@@ -325,39 +470,49 @@ def create_types(context, root, types, normalize=None):
for name, the_type in types.iteritems():
if root.get_descendant(name) is None:
parent_type = the_type._get_parent(context)
- if normalize:
- model = normalize(context, the_type)
- else:
- model = Type(the_type._name)
+ model = Type(name=the_type._name,
+ role=the_type._get_extension('role'))
if the_type.description:
model.description = the_type.description.value
- model.role = the_type._get_extension('role')
if parent_type is None:
+ model.parent = root
+ model.variant = root.variant
root.children.append(model)
else:
container = root.get_descendant(parent_type._name)
if container is not None:
+ model.parent = container
+ model.variant = container.variant
container.children.append(model)
-def create_properties_from_values(properties, source_properties):
+
+def create_parameter_models_from_values(properties, source_properties):
if source_properties:
for property_name, prop in source_properties.iteritems():
- properties[property_name] = Parameter(prop.type, prop.value, prop.description)
+ properties[property_name] = Parameter(name=property_name,
+ type_name=prop.type,
+ value=prop.value,
+ description=prop.description)
-def create_properties_from_assignments(properties, source_properties):
+
+def create_parameter_models_from_assignments(properties, source_properties):
if source_properties:
for property_name, prop in source_properties.iteritems():
- properties[property_name] = Parameter(prop.value.type, prop.value.value,
- prop.value.description)
+ properties[property_name] = Parameter(name=property_name,
+ type_name=prop.value.type,
+ value=prop.value.value,
+ description=prop.value.description)
+
-def create_interface_templates(context, interfaces, source_interfaces):
+def create_interface_template_models(context, service_template, interfaces, source_interfaces):
if source_interfaces:
for interface_name, interface in source_interfaces.iteritems():
- interface = create_interface_template(context, interface)
+ interface = create_interface_template_model(context, service_template, interface)
if interface is not None:
interfaces[interface_name] = interface
-def create_node_filter_constraint_lambdas(context, node_filter, node_type_constraints):
+
+def create_node_filter_constraint_lambdas(context, node_filter, target_node_template_constraints):
if node_filter is None:
return
@@ -367,7 +522,7 @@ def create_node_filter_constraint_lambdas(context, node_filter, node_type_constr
func = create_constraint_clause_lambda(context, node_filter, constraint_clause,
property_name, None)
if func is not None:
- node_type_constraints.append(func)
+ target_node_template_constraints.append(func)
capabilities = node_filter.capabilities
if capabilities is not None:
@@ -378,7 +533,8 @@ def create_node_filter_constraint_lambdas(context, node_filter, node_type_constr
func = create_constraint_clause_lambda(context, node_filter, constraint_clause,
property_name, capability_name)
if func is not None:
- node_type_constraints.append(func)
+ target_node_template_constraints.append(func)
+
def create_constraint_clause_lambda(context, node_filter, constraint_clause, property_name, # pylint: disable=too-many-return-statements
capability_name):
@@ -497,3 +653,23 @@ def create_constraint_clause_lambda(context, node_filter, constraint_clause, pro
return pattern
return None
+
+
+def parse_implementation_string(context, service_template, implementation):
+ if not implementation:
+ return None, ''
+
+ index = implementation.find('>')
+ if index == -1:
+ return None, implementation
+ plugin_name = implementation[:index].strip()
+
+ if plugin_name == 'execution':
+ plugin_specification = None
+ else:
+ plugin_specification = service_template.plugin_specifications.get(plugin_name)
+ if plugin_specification is None:
+ raise ValueError('unknown plugin: "{0}"'.format(plugin_name))
+
+ implementation = implementation[index+1:].strip()
+ return plugin_specification, implementation
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/extensions/aria_extension_tosca/simple_v1_0/presenter.py
----------------------------------------------------------------------
diff --git a/extensions/aria_extension_tosca/simple_v1_0/presenter.py b/extensions/aria_extension_tosca/simple_v1_0/presenter.py
index 0809014..eee5769 100644
--- a/extensions/aria_extension_tosca/simple_v1_0/presenter.py
+++ b/extensions/aria_extension_tosca/simple_v1_0/presenter.py
@@ -19,7 +19,7 @@ from aria.parser.presentation import Presenter
from .functions import (Concat, Token, GetInput, GetProperty, GetAttribute, GetOperationOutput,
GetNodesOfType, GetArtifact)
-from .modeling import create_service_model
+from .modeling import create_service_template_model
from .templates import ServiceTemplate
class ToscaSimplePresenter1_0(Presenter): # pylint: disable=invalid-name
@@ -75,5 +75,5 @@ class ToscaSimplePresenter1_0(Presenter): # pylint: disable=invalid-name
return FrozenList(import_locations) if import_locations else EMPTY_READ_ONLY_LIST
@cachedmethod
- def _get_service_model(self, context): # pylint: disable=no-self-use
- return create_service_model(context)
+ def _get_model(self, context): # pylint: disable=no-self-use
+ return create_service_template_model(context)
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/end2end/test_orchestrator.py
----------------------------------------------------------------------
diff --git a/tests/end2end/test_orchestrator.py b/tests/end2end/test_orchestrator.py
index f930577..7b8dc97 100644
--- a/tests/end2end/test_orchestrator.py
+++ b/tests/end2end/test_orchestrator.py
@@ -17,9 +17,9 @@ import sys
from aria.orchestrator.runner import Runner
from aria.orchestrator.workflows.builtin import BUILTIN_WORKFLOWS
-from aria.parser.modeling.storage import initialize_storage
from aria.utils.imports import import_fullname
from aria.utils.collections import OrderedDict
+from aria.cli.dry import convert_to_dry
from tests.parser.service_templates import consume_node_cellar
@@ -38,23 +38,25 @@ def test_custom():
def _workflow(workflow_name):
context, _ = consume_node_cellar()
+ convert_to_dry(context.modeling.instance)
+
# TODO: this logic will eventually stabilize and be part of the ARIA API,
# likely somewhere in aria.orchestrator.workflows
if workflow_name in BUILTIN_WORKFLOWS:
workflow_fn = import_fullname('aria.orchestrator.workflows.builtin.' + workflow_name)
inputs = {}
else:
- policy = context.modeling.instance.policies[workflow_name]
- sys.path.append(policy.properties['implementation'].value)
-
- workflow_fn = import_fullname(policy.properties['function'].value)
+ workflow = context.modeling.instance.policies[workflow_name]
+ sys.path.append(workflow.properties['implementation'].value)
+ workflow_fn = import_fullname(workflow.properties['function'].value)
inputs = OrderedDict([
- (k, v.value) for k, v in policy.properties.iteritems()
+ (k, v.value) for k, v in workflow.properties.iteritems()
if k not in WORKFLOW_POLICY_INTERNAL_PROPERTIES
])
def _initialize_storage(model_storage):
- initialize_storage(context, model_storage, 1)
+ context.modeling.store(model_storage)
- runner = Runner(workflow_name, workflow_fn, inputs, _initialize_storage, 1)
+ runner = Runner(workflow_name, workflow_fn, inputs, _initialize_storage,
+ lambda: context.modeling.instance.id)
runner.run()
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/end2end/test_tosca_simple_v1_0.py
----------------------------------------------------------------------
diff --git a/tests/end2end/test_tosca_simple_v1_0.py b/tests/end2end/test_tosca_simple_v1_0.py
index f2a41ce..4658fc3 100644
--- a/tests/end2end/test_tosca_simple_v1_0.py
+++ b/tests/end2end/test_tosca_simple_v1_0.py
@@ -71,7 +71,7 @@ def test_use_case_network_4():
def test_use_case_webserver_dbms_1():
- consume_use_case('webserver-dbms-1', 'model')
+ consume_use_case('webserver-dbms-1', 'template')
def test_use_case_webserver_dbms_2():
@@ -83,7 +83,7 @@ def test_use_case_multi_tier_1():
def test_use_case_container_1():
- consume_use_case('container-1', 'model')
+ consume_use_case('container-1', 'template')
# NodeCellar
@@ -101,7 +101,7 @@ def test_node_cellar_presentation():
def test_node_cellar_model():
- consume_node_cellar('model')
+ consume_node_cellar('template')
def test_node_cellar_types():
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/mock/context.py
----------------------------------------------------------------------
diff --git a/tests/mock/context.py b/tests/mock/context.py
index cf1a32d..3de3133 100644
--- a/tests/mock/context.py
+++ b/tests/mock/context.py
@@ -38,13 +38,13 @@ def simple(tmpdir, inmemory=False, context_kwargs=None):
api_kwargs=dict(directory=os.path.join(tmpdir, 'resources'))
)
- service_instance_id = create_simple_topology_two_nodes(model_storage)
+ service_id = create_simple_topology_two_nodes(model_storage)
final_kwargs = dict(
name='simple_context',
model_storage=model_storage,
resource_storage=resource_storage,
- service_instance_id=service_instance_id,
+ service_id=service_id,
workflow_name=models.WORKFLOW_NAME,
task_max_attempts=models.TASK_MAX_ATTEMPTS,
task_retry_interval=models.TASK_RETRY_INTERVAL
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/mock/models.py
----------------------------------------------------------------------
diff --git a/tests/mock/models.py b/tests/mock/models.py
index 301fc01..bf43a75 100644
--- a/tests/mock/models.py
+++ b/tests/mock/models.py
@@ -15,132 +15,185 @@
from datetime import datetime
-from aria.storage.modeling import model
+from aria.modeling import models
from . import operations
-DEPLOYMENT_NAME = 'test_deployment_id'
-BLUEPRINT_NAME = 'test_blueprint_id'
-WORKFLOW_NAME = 'test_workflow_id'
-EXECUTION_NAME = 'test_execution_id'
+SERVICE_NAME = 'test_service_name'
+SERVICE_TEMPLATE_NAME = 'test_service_template_name'
+WORKFLOW_NAME = 'test_workflow_name'
+EXECUTION_NAME = 'test_execution_name'
TASK_RETRY_INTERVAL = 1
TASK_MAX_ATTEMPTS = 1
+DEPENDENCY_NODE_TEMPLATE_NAME = 'dependency_node_template'
DEPENDENCY_NODE_NAME = 'dependency_node'
-DEPENDENCY_NODE_INSTANCE_NAME = 'dependency_node_instance'
+DEPENDENT_NODE_TEMPLATE_NAME = 'dependent_node_template'
DEPENDENT_NODE_NAME = 'dependent_node'
-DEPENDENT_NODE_INSTANCE_NAME = 'dependent_node_instance'
-RELATIONSHIP_NAME = 'relationship'
-RELATIONSHIP_INSTANCE_NAME = 'relationship_instance'
-def get_dependency_node(deployment):
- return model.NodeTemplate(
- name=DEPENDENCY_NODE_NAME,
- type_name='test_node_type',
- type_hierarchy=[],
- default_instances=1,
- min_instances=1,
- max_instances=1,
- service_template=deployment.service_template,
+def create_service_template():
+ now = datetime.now()
+ return models.ServiceTemplate(
+ name=SERVICE_TEMPLATE_NAME,
+ description=None,
+ created_at=now,
+ updated_at=now,
+ main_file_name='main_file_name',
+ node_types=models.Type(variant='node', name='test_node_type'),
+ group_types=models.Type(variant='group', name='test_group_type'),
+ policy_types=models.Type(variant='policy', name='test_policy_type'),
+ relationship_types=models.Type(variant='relationship', name='test_relationship_type'),
+ capability_types=models.Type(variant='capability', name='test_capability_type'),
+ artifact_types=models.Type(variant='artifact', name='test_artifact_type'),
+ interface_types=models.Type(variant='interface', name='test_interface_type')
)
-def get_dependency_node_instance(dependency_node, deployment):
- return model.Node(
- name=DEPENDENCY_NODE_INSTANCE_NAME,
- service_instance=deployment,
- runtime_properties={'ip': '1.1.1.1'},
- node_template=dependency_node,
- state='',
- scaling_groups=[]
+def create_service(service_template):
+ now = datetime.utcnow()
+ return models.Service(
+ name=SERVICE_NAME,
+ service_template=service_template,
+ description='',
+ created_at=now,
+ updated_at=now,
+ permalink='',
+ scaling_groups={},
)
-def get_relationship(target):
- requirement_template = model.RequirementTemplate(target_node_template_name=target.name)
- capability_template = model.CapabilityTemplate()
-
- return requirement_template, capability_template
+def create_dependency_node_template(service_template):
+ node_type = service_template.node_types.get_descendant('test_node_type')
+ capability_type = service_template.capability_types.get_descendant('test_capability_type')
+ capability_template = models.CapabilityTemplate(
+ name='capability',
+ type=capability_type
+ )
-def get_relationship_instance(source_instance, target_instance):
- return model.Relationship(
- target_node=target_instance,
- source_node=source_instance,
+ node_template = models.NodeTemplate(
+ name=DEPENDENCY_NODE_TEMPLATE_NAME,
+ type=node_type,
+ capability_templates=_dictify(capability_template),
+ default_instances=1,
+ min_instances=1,
+ max_instances=1,
+ service_template=service_template
)
+ service_template.node_templates[node_template.name] = node_template
+ return node_template
-def get_dependent_node(deployment, requirement_template, capability_template):
- operation_templates = [model.OperationTemplate(implementation=op,
- service_template=deployment.service_template)
- for op in operations.NODE_OPERATIONS]
- interface_template = model.InterfaceTemplate(operation_templates=operation_templates)
+def create_dependent_node_template(service_template, dependency_node_template):
+ the_type = service_template.node_types.get_descendant('test_node_type')
- return model.NodeTemplate(
- name=DEPENDENT_NODE_NAME,
- type_name='test_node_type',
- type_hierarchy=[],
+ operation_templates = dict((op, models.OperationTemplate(
+ name=op,
+ implementation='test'))
+ for _, op in operations.NODE_OPERATIONS)
+ interface_template = models.InterfaceTemplate(
+ type=service_template.interface_types.get_descendant('test_interface_type'),
+ operation_templates=operation_templates)
+
+ requirement_template = models.RequirementTemplate(
+ name='requirement',
+ target_node_template=dependency_node_template
+ )
+
+ node_template = models.NodeTemplate(
+ name=DEPENDENT_NODE_TEMPLATE_NAME,
+ type=the_type,
default_instances=1,
min_instances=1,
max_instances=1,
- service_template=deployment.service_template,
- interface_templates=[interface_template],
+ interface_templates=_dictify(interface_template),
requirement_templates=[requirement_template],
- capability_templates=[capability_template],
+ service_template=service_template
+ )
+ service_template.node_templates[node_template.name] = node_template
+ return node_template
+
+
+def create_dependency_node(dependency_node_template, service):
+ node = models.Node(
+ name=DEPENDENCY_NODE_NAME,
+ type=dependency_node_template.type,
+ runtime_properties={'ip': '1.1.1.1'},
+ version=None,
+ node_template=dependency_node_template,
+ state='',
+ scaling_groups=[],
+ service=service
)
+ service.nodes[node.name] = node
+ return node
-def get_dependent_node_instance(dependent_node, deployment):
- return model.Node(
- name=DEPENDENT_NODE_INSTANCE_NAME,
- service_instance=deployment,
+def create_dependent_node(dependent_node_template, service):
+ node = models.Node(
+ name=DEPENDENT_NODE_NAME,
+ type=dependent_node_template.type,
runtime_properties={},
- node_template=dependent_node,
+ version=None,
+ node_template=dependent_node_template,
state='',
scaling_groups=[],
+ service=service
)
+ service.nodes[node.name] = node
+ return node
-def get_blueprint():
- now = datetime.now()
- return model.ServiceTemplate(
- plan={},
- name=BLUEPRINT_NAME,
- description=None,
- created_at=now,
- updated_at=now,
- main_file_name='main_file_name'
+def create_relationship(source, target):
+ return models.Relationship(
+ source_node=source,
+ target_node=target
)
-def get_execution(deployment):
- return model.Execution(
- service_instance=deployment,
- status=model.Execution.STARTED,
- workflow_name=WORKFLOW_NAME,
- started_at=datetime.utcnow(),
- parameters=None
+def create_interface_template(service_template, interface_name, operation_name,
+ operation_kwargs=None, interface_kwargs=None):
+ the_type = service_template.interface_types.get_descendant('test_interface_type')
+ operation_template = models.OperationTemplate(
+ name=operation_name,
+ **(operation_kwargs or {})
+ )
+ return models.InterfaceTemplate(
+ type=the_type,
+ operation_templates=_dictify(operation_template),
+ name=interface_name,
+ **(interface_kwargs or {})
)
-def get_deployment(blueprint):
- now = datetime.utcnow()
- return model.ServiceInstance(
- name=DEPLOYMENT_NAME,
- service_template=blueprint,
- description='',
- created_at=now,
- updated_at=now,
- workflows={},
- permalink='',
- policy_triggers={},
- policy_types={},
- scaling_groups={},
+def create_interface(service, interface_name, operation_name, operation_kwargs=None,
+ interface_kwargs=None):
+ the_type = service.service_template.interface_types.get_descendant('test_interface_type')
+ operation = models.Operation(
+ name=operation_name,
+ **(operation_kwargs or {})
+ )
+ return models.Interface(
+ type=the_type,
+ operations=_dictify(operation),
+ name=interface_name,
+ **(interface_kwargs or {})
+ )
+
+
+def create_execution(service):
+ return models.Execution(
+ service=service,
+ status=models.Execution.STARTED,
+ workflow_name=WORKFLOW_NAME,
+ started_at=datetime.utcnow(),
+ parameters=None
)
-def get_plugin(package_name='package', package_version='0.1'):
- return model.Plugin(
+def create_plugin(package_name='package', package_version='0.1'):
+ return models.Plugin(
+ name='test_plugin',
archive_name='archive_name',
distribution='distribution',
distribution_release='dist_release',
@@ -155,26 +208,20 @@ def get_plugin(package_name='package', package_version='0.1'):
)
-def get_interface_template(operation_name, operation_kwargs=None, interface_kwargs=None):
- operation_template = model.OperationTemplate(
- name=operation_name,
- **(operation_kwargs or {})
-
- )
- return model.InterfaceTemplate(
- operation_templates=[operation_template],
- name=operation_name.rsplit('.', 1)[0],
- **(interface_kwargs or {})
+def create_plugin_specification(package_name='package', package_version='0.1'):
+ return models.PluginSpecification(
+ name='test_plugin',
+ archive_name='archive_name',
+ distribution='distribution',
+ distribution_release='dist_release',
+ distribution_version='dist_version',
+ package_name=package_name,
+ package_source='source',
+ package_version=package_version,
+ supported_platform='any',
+ supported_py_versions=['python27']
)
-def get_interface(operation_name,
- operation_kwargs=None,
- interface_kwargs=None,
- edge=None):
- operation = model.Operation(name=operation_name, **(operation_kwargs or {}))
- interface_name = operation_name.rsplit('.', 1)[0]
- return model.Interface(operations=[operation],
- name=interface_name,
- edge=edge,
- **(interface_kwargs or {}))
+def _dictify(item):
+ return dict(((item.name, item),))
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/mock/operations.py
----------------------------------------------------------------------
diff --git a/tests/mock/operations.py b/tests/mock/operations.py
index 5495f6a..c752a8e 100644
--- a/tests/mock/operations.py
+++ b/tests/mock/operations.py
@@ -14,46 +14,46 @@
# limitations under the License.
NODE_OPERATIONS_INSTALL = [
- 'tosca.interfaces.node.lifecycle.Standard.create',
- 'tosca.interfaces.node.lifecycle.Standard.configure',
- 'tosca.interfaces.node.lifecycle.Standard.start',
+ ('Standard', 'create'),
+ ('Standard', 'configure'),
+ ('Standard', 'start')
]
NODE_OPERATIONS_UNINSTALL = [
- 'tosca.interfaces.node.lifecycle.Standard.stop',
- 'tosca.interfaces.node.lifecycle.Standard.delete',
+ ('Standard', 'stop'),
+ ('Standard', 'delete')
]
NODE_OPERATIONS = NODE_OPERATIONS_INSTALL + NODE_OPERATIONS_UNINSTALL
RELATIONSHIP_OPERATIONS_INSTALL = [
- 'tosca.interfaces.relationship.Configure.pre_configure_source',
- 'tosca.interfaces.relationship.Configure.pre_configure_target',
- 'tosca.interfaces.relationship.Configure.add_source',
- 'tosca.interfaces.relationship.Configure.add_target',
+ ('Configure', 'pre_configure_source'),
+ ('Configure', 'pre_configure_target'),
+ ('Configure', 'add_source'),
+ ('Configure', 'add_target')
]
RELATIONSHIP_OPERATIONS_UNINSTALL = [
- 'tosca.interfaces.relationship.Configure.remove_target',
- 'tosca.interfaces.relationship.Configure.target_changed',
+ ('Configure', 'remove_target'),
+ ('Configure', 'target_changed')
]
RELATIONSHIP_OPERATIONS = RELATIONSHIP_OPERATIONS_INSTALL + RELATIONSHIP_OPERATIONS_UNINSTALL
OPERATIONS_INSTALL = [
- 'tosca.interfaces.node.lifecycle.Standard.create',
- 'tosca.interfaces.relationship.Configure.pre_configure_source',
- 'tosca.interfaces.relationship.Configure.pre_configure_target',
- 'tosca.interfaces.node.lifecycle.Standard.configure',
- 'tosca.interfaces.node.lifecycle.Standard.start',
- 'tosca.interfaces.relationship.Configure.add_source',
- 'tosca.interfaces.relationship.Configure.add_target',
- 'tosca.interfaces.relationship.Configure.target_changed',
+ ('Standard', 'create'),
+ ('Configure', 'pre_configure_source'),
+ ('Configure', 'pre_configure_target'),
+ ('Standard', 'configure'),
+ ('Standard', 'start'),
+ ('Configure', 'add_source'),
+ ('Configure', 'add_target'),
+ ('Configure', 'target_changed')
]
OPERATIONS_UNINSTALL = [
- 'tosca.interfaces.relationship.Configure.remove_target',
- 'tosca.interfaces.relationship.Configure.target_changed',
- 'tosca.interfaces.node.lifecycle.Standard.stop',
- 'tosca.interfaces.node.lifecycle.Standard.delete',
+ ('Configure', 'remove_target'),
+ ('Configure', 'target_changed'),
+ ('Standard', 'stop'),
+ ('Standard', 'delete')
]
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/mock/topology.py
----------------------------------------------------------------------
diff --git a/tests/mock/topology.py b/tests/mock/topology.py
index d3e8b7b..7ccc885 100644
--- a/tests/mock/topology.py
+++ b/tests/mock/topology.py
@@ -13,74 +13,60 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from aria.storage.modeling import model
+from aria.modeling import models as aria_models
from . import models
def create_simple_topology_single_node(model_storage, create_operation):
- service_template = models.get_blueprint()
- model_storage.service_template.put(service_template)
-
- service_instance = models.get_deployment(service_template)
- model_storage.service_instance.put(service_instance)
+ service_template = models.create_service_template()
+ service = models.create_service(service_template)
- node_template = models.get_dependency_node(service_instance)
- node_template.interface_templates = [models.get_interface_template(
- 'tosca.interfaces.node.lifecycle.Standard.create',
+ node_template = models.create_dependency_node_template(service_template)
+ interface_template = models.create_interface_template(
+ service_template,
+ 'Standard', 'create',
operation_kwargs=dict(
implementation=create_operation,
- inputs=[model.Parameter(name='key', str_value='create', type='str'),
- model.Parameter(name='value', str_value=str(True), type='bool')]
- )
- )]
- model_storage.node_template.put(node_template)
+ inputs={'key': aria_models.Parameter.wrap('key', 'create'),
+ 'value': aria_models.Parameter.wrap('value', True)})
+ )
+ node_template.interface_templates[interface_template.name] = interface_template # pylint: disable=unsubscriptable-object
- node = models.get_dependency_node_instance(node_template, service_instance)
- node.interfaces = [models.get_interface(
- 'tosca.interfaces.node.lifecycle.Standard.create',
+ node = models.create_dependency_node(node_template, service)
+ interface = models.create_interface(
+ service,
+ 'Standard', 'create',
operation_kwargs=dict(
implementation=create_operation,
- inputs=[model.Parameter(name='key', str_value='create', type='str'),
- model.Parameter(name='value', str_value=str(True), type='bool')])
- )]
- model_storage.node.put(node)
-
+ inputs={'key': aria_models.Parameter.wrap('key', 'create'),
+ 'value': aria_models.Parameter.wrap('value', True)})
+ )
+ node.interfaces[interface.name] = interface # pylint: disable=unsubscriptable-object
-def create_simple_topology_two_nodes(model_storage):
- blueprint = models.get_blueprint()
- model_storage.service_template.put(blueprint)
- deployment = models.get_deployment(blueprint)
- model_storage.service_instance.put(deployment)
+ model_storage.service_template.put(service_template)
+ model_storage.service.put(service)
- #################################################################################
- # Creating a simple deployment with node -> node as a graph
- dependency_node = models.get_dependency_node(deployment)
- model_storage.node_template.put(dependency_node)
- storage_dependency_node = model_storage.node_template.get(dependency_node.id)
+def create_simple_topology_two_nodes(model_storage):
+ service_template = models.create_service_template()
+ service = models.create_service(service_template)
- dependency_node_instance = models.get_dependency_node_instance(storage_dependency_node,
- deployment)
- model_storage.node.put(dependency_node_instance)
- storage_dependency_node_instance = model_storage.node.get(dependency_node_instance.id)
+ # Creating a simple service with node -> node as a graph
- req_template, cap_template = models.get_relationship(storage_dependency_node)
- model_storage.requirement_template.put(req_template)
- model_storage.capability_template.put(cap_template)
+ dependency_node_template = models.create_dependency_node_template(service_template)
+ dependent_node_template = models.create_dependent_node_template(service_template,
+ dependency_node_template)
- dependent_node = models.get_dependent_node(deployment, req_template, cap_template)
- model_storage.node_template.put(dependent_node)
- storage_dependent_node = model_storage.node_template.get(dependent_node.id)
+ dependency_node = models.create_dependency_node(dependency_node_template, service)
+ dependent_node = models.create_dependent_node(dependent_node_template, service)
- dependent_node_instance = models.get_dependent_node_instance(storage_dependent_node, deployment)
- model_storage.node.put(dependent_node_instance)
- storage_dependent_node_instance = model_storage.node.get(dependent_node_instance.id)
+ dependent_node.outbound_relationships.append(models.create_relationship( # pylint: disable=no-member
+ source=dependent_node,
+ target=dependency_node
+ ))
- relationship_instance = models.get_relationship_instance(
- target_instance=storage_dependency_node_instance,
- source_instance=storage_dependent_node_instance
- )
- model_storage.relationship.put(relationship_instance)
+ model_storage.service_template.put(service_template)
+ model_storage.service.put(service)
- return deployment.id
+ return service.id
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/modeling/__init__.py
----------------------------------------------------------------------
diff --git a/tests/modeling/__init__.py b/tests/modeling/__init__.py
new file mode 100644
index 0000000..072ef54
--- /dev/null
+++ b/tests/modeling/__init__.py
@@ -0,0 +1,34 @@
+# 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.
+
+from sqlalchemy import (
+ Column,
+ Text,
+ Integer,
+)
+
+from aria.modeling import (
+ models,
+ types as modeling_types,
+ mixins
+)
+
+
+class MockModel(models.aria_declarative_base, mixins.ModelMixin): #pylint: disable=abstract-method
+ __tablename__ = 'mock_model'
+ model_dict = Column(modeling_types.Dict)
+ model_list = Column(modeling_types.List)
+ value = Column(Integer)
+ name = Column(Text)
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/modeling/test_mixins.py
----------------------------------------------------------------------
diff --git a/tests/modeling/test_mixins.py b/tests/modeling/test_mixins.py
new file mode 100644
index 0000000..7795b57
--- /dev/null
+++ b/tests/modeling/test_mixins.py
@@ -0,0 +1,219 @@
+# 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.
+
+import pytest
+
+import sqlalchemy
+
+from aria.storage import (
+ ModelStorage,
+ sql_mapi
+)
+from aria import modeling
+from aria.modeling.exceptions import ValueFormatException
+
+from ..storage import (
+ release_sqlite_storage,
+ init_inmemory_model_storage
+)
+from . import MockModel
+from ..mock import (
+ models,
+ context as mock_context
+)
+
+
+@pytest.fixture
+def storage():
+ base_storage = ModelStorage(sql_mapi.SQLAlchemyModelAPI,
+ initiator=init_inmemory_model_storage)
+ base_storage.register(MockModel)
+ yield base_storage
+ release_sqlite_storage(base_storage)
+
+
+@pytest.fixture(scope='module', autouse=True)
+def module_cleanup():
+ modeling.models.aria_declarative_base.metadata.remove(MockModel.__table__) # pylint: disable=no-member
+
+
+@pytest.fixture
+def context(tmpdir):
+ ctx = mock_context.simple(str(tmpdir))
+ yield ctx
+ release_sqlite_storage(ctx.model)
+
+
+def test_inner_dict_update(storage):
+ inner_dict = {'inner_value': 1}
+
+ mock_model = MockModel(model_dict={'inner_dict': inner_dict, 'value': 0})
+ storage.mock_model.put(mock_model)
+
+ storage_mm = storage.mock_model.get(mock_model.id)
+ assert storage_mm == mock_model
+
+ storage_mm.model_dict['inner_dict']['inner_value'] = 2
+ storage_mm.model_dict['value'] = -1
+ storage.mock_model.update(storage_mm)
+ storage_mm = storage.mock_model.get(storage_mm.id)
+
+ assert storage_mm.model_dict['inner_dict']['inner_value'] == 2
+ assert storage_mm.model_dict['value'] == -1
+
+
+def test_inner_list_update(storage):
+ mock_model = MockModel(model_list=[0, [1]])
+ storage.mock_model.put(mock_model)
+
+ storage_mm = storage.mock_model.get(mock_model.id)
+ assert storage_mm == mock_model
+
+ storage_mm.model_list[1][0] = 'new_inner_value'
+ storage_mm.model_list[0] = 'new_value'
+ storage.mock_model.update(storage_mm)
+ storage_mm = storage.mock_model.get(storage_mm.id)
+
+ assert storage_mm.model_list[1][0] == 'new_inner_value'
+ assert storage_mm.model_list[0] == 'new_value'
+
+
+def test_model_to_dict(context):
+ service = context.service
+ service = service.to_dict()
+
+ expected_keys = [
+ 'description',
+ 'created_at',
+ 'permalink',
+ 'scaling_groups',
+ 'updated_at'
+ ]
+
+ for expected_key in expected_keys:
+ assert expected_key in service
+
+
+def test_relationship_model_ordering(context):
+ service = context.model.service.get_by_name(models.SERVICE_NAME)
+ source_node = context.model.node.get_by_name(models.DEPENDENT_NODE_NAME)
+ target_node = context.model.node.get_by_name(models.DEPENDENCY_NODE_NAME)
+
+ new_node_template = modeling.models.NodeTemplate(
+ name='new_node_template',
+ type=source_node.type,
+ default_instances=1,
+ min_instances=1,
+ max_instances=1,
+ service_template=service.service_template
+ )
+
+ new_node = modeling.models.Node(
+ name='new_node',
+ type=source_node.type,
+ runtime_properties={},
+ service=service,
+ version=None,
+ node_template=new_node_template,
+ state='',
+ scaling_groups=[]
+ )
+
+ source_node.outbound_relationships.append(modeling.models.Relationship(
+ source_node=source_node,
+ target_node=new_node,
+ ))
+
+ new_node.outbound_relationships.append(modeling.models.Relationship( # pylint: disable=no-member
+ source_node=new_node,
+ target_node=target_node,
+ ))
+
+ context.model.node_template.put(new_node_template)
+ context.model.node.put(new_node)
+ context.model.node.refresh(source_node)
+ context.model.node.refresh(target_node)
+
+ def flip_and_assert(node, direction):
+ """
+ Reversed the order of relationships and assert effects took place.
+ :param node: the node instance to operate on
+ :param direction: the type of relationships to flip (inbound/outbound)
+ :return:
+ """
+ assert direction in ('inbound', 'outbound')
+
+ relationships = getattr(node, direction + '_relationships')
+ assert len(relationships) == 2
+
+ reversed_relationship = list(reversed(relationships))
+ assert relationships != reversed_relationship
+
+ relationships[:] = reversed_relationship
+ context.model.node.update(node)
+ assert relationships == reversed_relationship
+
+ flip_and_assert(source_node, 'outbound')
+ flip_and_assert(target_node, 'inbound')
+
+
+class StrictClass(modeling.models.aria_declarative_base, modeling.mixins.ModelMixin):
+ __tablename__ = 'strict_class'
+
+ strict_dict = sqlalchemy.Column(modeling.types.StrictDict(basestring, basestring))
+ strict_list = sqlalchemy.Column(modeling.types.StrictList(basestring))
+
+
+def test_strict_dict():
+
+ strict_class = StrictClass()
+
+ def assert_strict(sc):
+ with pytest.raises(ValueFormatException):
+ sc.strict_dict = {'key': 1}
+
+ with pytest.raises(ValueFormatException):
+ sc.strict_dict = {1: 'value'}
+
+ with pytest.raises(ValueFormatException):
+ sc.strict_dict = {1: 1}
+
+ assert_strict(strict_class)
+ strict_class.strict_dict = {'key': 'value'}
+ assert strict_class.strict_dict == {'key': 'value'}
+
+ assert_strict(strict_class)
+ with pytest.raises(ValueFormatException):
+ strict_class.strict_dict['key'] = 1
+ with pytest.raises(ValueFormatException):
+ strict_class.strict_dict[1] = 'value'
+ with pytest.raises(ValueFormatException):
+ strict_class.strict_dict[1] = 1
+
+
+def test_strict_list():
+ strict_class = StrictClass()
+
+ def assert_strict(sc):
+ with pytest.raises(ValueFormatException):
+ sc.strict_list = [1]
+
+ assert_strict(strict_class)
+ strict_class.strict_list = ['item']
+ assert strict_class.strict_list == ['item']
+
+ assert_strict(strict_class)
+ with pytest.raises(ValueFormatException):
+ strict_class.strict_list[0] = 1
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/09f826a1/tests/modeling/test_model_storage.py
----------------------------------------------------------------------
diff --git a/tests/modeling/test_model_storage.py b/tests/modeling/test_model_storage.py
new file mode 100644
index 0000000..bb778d4
--- /dev/null
+++ b/tests/modeling/test_model_storage.py
@@ -0,0 +1,102 @@
+# 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.
+
+import pytest
+
+from aria.storage import (
+ ModelStorage,
+ exceptions,
+ sql_mapi
+)
+from aria import (application_model_storage, modeling)
+from ..storage import (release_sqlite_storage, init_inmemory_model_storage)
+
+from . import MockModel
+
+
+@pytest.fixture
+def storage():
+ base_storage = ModelStorage(sql_mapi.SQLAlchemyModelAPI,
+ initiator=init_inmemory_model_storage)
+ base_storage.register(MockModel)
+ yield base_storage
+ release_sqlite_storage(base_storage)
+
+
+@pytest.fixture(scope='module', autouse=True)
+def module_cleanup():
+ modeling.models.aria_declarative_base.metadata.remove(MockModel.__table__) #pylint: disable=no-member
+
+
+def test_storage_base(storage):
+ with pytest.raises(AttributeError):
+ storage.non_existent_attribute()
+
+
+def test_model_storage(storage):
+ mock_model = MockModel(value=0, name='model_name')
+ storage.mock_model.put(mock_model)
+
+ assert storage.mock_model.get_by_name('model_name') == mock_model
+
+ assert [mm_from_storage for mm_from_storage in storage.mock_model.iter()] == [mock_model]
+ assert [mm_from_storage for mm_from_storage in storage.mock_model] == [mock_model]
+
+ storage.mock_model.delete(mock_model)
+ with pytest.raises(exceptions.StorageError):
+ storage.mock_model.get(mock_model.id)
+
+
+def test_application_storage_factory():
+ storage = application_model_storage(sql_mapi.SQLAlchemyModelAPI,
+ initiator=init_inmemory_model_storage)
+
+ assert storage.service_template
+ assert storage.node_template
+ assert storage.group_template
+ assert storage.policy_template
+ assert storage.substitution_template
+ assert storage.substitution_template_mapping
+ assert storage.requirement_template
+ assert storage.relationship_template
+ assert storage.capability_template
+ assert storage.interface_template
+ assert storage.operation_template
+ assert storage.artifact_template
+
+ assert storage.service
+ assert storage.node
+ assert storage.group
+ assert storage.policy
+ assert storage.substitution
+ assert storage.substitution_mapping
+ assert storage.relationship
+ assert storage.capability
+ assert storage.interface
+ assert storage.operation
+ assert storage.artifact
+
+ assert storage.execution
+ assert storage.service_update
+ assert storage.service_update_step
+ assert storage.service_modification
+ assert storage.plugin
+ assert storage.task
+
+ assert storage.parameter
+ assert storage.type
+ assert storage.metadata
+
+ release_sqlite_storage(storage)