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