def create_operation_template_model(context, service_template, operation):
model = OperationTemplate(name=operation._name)
if operation.description:
model.description = operation.description.value
implementation = operation.implementation
if implementation is not None:
primary = implementation.primary
extract_implementation_primary(context, service_template, operation,
model, primary)
relationship_edge = operation._get_extensions(context).get(
'relationship_edge')
if relationship_edge is not None:
if relationship_edge == 'source':
model.relationship_edge = False
elif relationship_edge == 'target':
model.relationship_edge = True
dependencies = implementation.dependencies
configuration = OrderedDict()
if dependencies:
for dependency in dependencies:
key, value = split_prefix(dependency)
if key is not None:
# Special ARIA prefix: signifies configuration parameters
# Parse as YAML
try:
value = yaml.load(value)
except yaml.parser.MarkedYAMLError as e:
context.validation.report(
'YAML parser {0} in operation configuration: {1}'.
format(e.problem, value),
locator=implementation._locator,
level=Issue.FIELD)
continue
# Coerce to intrinsic functions, if there are any
value = coerce_parameter_value(context, implementation,
None, value).value
# Support dot-notation nesting
set_nested(configuration, key.split('.'), value)
else:
if model.dependencies is None:
model.dependencies = []
model.dependencies.append(dependency)
# Convert configuration to Configuration models
for key, value in configuration.iteritems():
model.configurations[key] = Configuration.wrap(
key, value, description='Operation configuration.')
create_parameter_models_from_assignments(model.inputs,
operation.inputs,
model_cls=Input)
return model
def get_template_interfaces(context, presentation, type_name):
"""
Returns the assigned interface_template values while making sure they are defined in the type.
This includes the interfaces themselves, their operations, and inputs for interfaces and
operations.
Interface and operation inputs' default values, if available, will be used if we did not assign
them.
Makes sure that required inputs indeed end up with a value.
This code is especially complex due to the many levels of nesting involved.
"""
template_interfaces = OrderedDict()
the_type = presentation._get_type(
context) # NodeType, RelationshipType, GroupType
# InterfaceDefinition (or InterfaceAssignment in the case of RelationshipTemplate):
interface_definitions = the_type._get_interfaces(
context) if the_type is not None else None
# Copy over interfaces from the type (will initialize inputs with default values)
if interface_definitions is not None:
for interface_name, interface_definition in interface_definitions.iteritems(
):
# Note that in the case of a RelationshipTemplate, we will already have the values as
# InterfaceAssignment. It will not be converted, just cloned.
template_interfaces[interface_name] = \
convert_interface_definition_from_type_to_template(context, interface_definition,
presentation)
# Fill in our interfaces
our_interface_assignments = presentation.interfaces
if our_interface_assignments:
# InterfaceAssignment:
for interface_name, our_interface_assignment in our_interface_assignments.iteritems(
):
if interface_name in template_interfaces:
interface_assignment = template_interfaces[
interface_name] # InterfaceAssignment
# InterfaceDefinition (or InterfaceAssignment in the case of RelationshipTemplate):
interface_definition = interface_definitions[interface_name]
merge_interface(context, presentation, interface_assignment,
our_interface_assignment, interface_definition,
interface_name)
else:
context.validation.report(
'interface definition "%s" not declared at %s "%s" in "%s"'
% (interface_name, type_name, presentation.type,
presentation._fullname),
locator=our_interface_assignment._locator,
level=Issue.BETWEEN_TYPES)
# Check that there are no required inputs that we haven't assigned
for interface_name, interface_template in template_interfaces.iteritems():
if interface_name in interface_definitions:
# InterfaceDefinition (or InterfaceAssignment in the case of RelationshipTemplate):
interface_definition = interface_definitions[interface_name]
our_interface_assignment = our_interface_assignments.get(interface_name) \
if our_interface_assignments is not None else None
validate_required_inputs(context, presentation, interface_template,
interface_definition,
our_interface_assignment, interface_name)
return template_interfaces