project.common.1.0.0.source-code.topology-1_0_0_wd03.yml.vm Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
SeaClouds common module
The newest version!
## Will look in the context for:
## - template_name
## - template_version
## - template_author
## - application_description
## - topology
## --------------------------------------------
## -- Serialize an AbstractPropertyValue
#macro(serializeAbtractPropertyValue $v)
#if($utils.isScalarPropertyValue($v))
## TODO: manage integer, boolean ... by looking into property definition
$utils.renderScalar($v.value)
#elseif($utils.isFunctionPropertyValue($v))
#if($v.function=="get_input")
{ ${v.function}: ${v.parameters.get(0)} }
#else
{ ${v.function}: [ $utils.getCsvToString($v.parameters) ] }
#end## if
#end
#end## macro serializeAbtractPropertyValue
## --------------------------------------------
## -- Serialize an AbstractPropertyValue map
#macro(serializeAbtractPropertyValues $map $tab)
#foreach($mapEntry in $map.entrySet())
#if($utils.isAbstractPropertyValueNotNull($mapEntry.value))
$tab${mapEntry.key}: #serializeAbtractPropertyValue(${mapEntry.value})
#end## if
#end## of mapEntry iteration
#end## macro serializeAbtractPropertyValues
## BEGINING OF DOCUMENT
tosca_definitions_version: tosca_simple_yaml_1_0_0_wd03
description: ${template_description}
template_name: ${template_name}
template_version: ${template_version}
template_author: ${template_author}
#if($utils.collectionIsNotEmpty($topology.dependencies))

imports:
#foreach($dependency in ${topology.dependencies})
  - ${dependency.name}:${dependency.version}
#end
#end## if

topology_template:
#if($application_description)
  description: ${utils.renderDescription(${application_description}, "    ")}
#end## if application_description defined
#if($utils.mapIsNotEmptyAndContainsNotnullValues($topology.inputs))
  inputs:
#foreach($inputEntry in $topology.inputs.entrySet())
    ${inputEntry.key}:
      type: ${inputEntry.value.type}
      required: $inputEntry.value.required
#if($inputEntry.value.default)
      default: $utils.renderScalar($inputEntry.value.default)
#end## if default defined
#if($utils.collectionIsNotEmpty($inputEntry.value.constraints))
      constraints:
#foreach($constraint in $inputEntry.value.constraints)
        - ${utils.renderConstraint($constraint)}
#end## constraint iteration
#end## if constraints not empty
#if($inputEntry.value.description)
      description: ${utils.renderDescription($inputEntry.value.description, "        ")}
#end## if description defined
#end## foreach($inputEntry in $topology.inputs.entrySet())
#end## if($utils.mapIsNotEmptyAndContainsNotnullValues($topology.inputs))
#if($utils.mapIsNotEmptyAndContainsNotnullValues($topology.inputArtifacts))
  input_artifacts:
#foreach($inputArtifactEntry in $topology.inputArtifacts.entrySet())
    ${inputArtifactEntry.key}:
      type: ${inputArtifactEntry.value.artifactType}
#if($inputArtifactEntry.value.description)
      description: ${utils.renderDescription($inputArtifactEntry.value.description, "        ")}
#end##if($inputArtifactEntry.value.description)
#end##foreach($inputArtifactEntry in $topology.inputArtifacts.entrySet())
#end##if($utils.mapIsNotEmptyAndContainsNotnullValues($topology.inputArtifacts))
  node_templates:
#foreach($nodeTemplateEntry in ${topology.nodeTemplates.entrySet()})
    ${nodeTemplateEntry.key}:
      type: ${nodeTemplateEntry.value.type}
#if($utils.mapIsNotEmptyAndContainsNotnullValues($nodeTemplateEntry.value.properties))
      properties:
#serializeAbtractPropertyValues($nodeTemplateEntry.value.properties "        ")
#end## if
#if($utils.mapIsNotEmptyAndContainsNotnullValues($nodeTemplateEntry.value.relationships))
      requirements:
#foreach($relationship in ${nodeTemplateEntry.value.relationships.values()})
        - ${relationship.requirementName}:
            node: ${relationship.target}
            capability: $topology.nodeTemplates[$relationship.target].capabilities[$relationship.targetedCapabilityName].type
            relationship: ${relationship.type}
#if($utils.mapIsNotEmptyAndContainsNotnullValues($relationship.properties))
            properties:
#serializeAbtractPropertyValues($relationship.properties "              ")
#end## if
#end## of relationship iteration
#end## if
#if($utils.hasCapabilitiesContainingNotNullProperties($nodeTemplateEntry.value))
      capabilities:
#foreach($capabilityEntry in ${nodeTemplateEntry.value.capabilities.entrySet()})
#if($utils.mapIsNotEmptyAndContainsNotnullValues($capabilityEntry.value.properties))
        ${capabilityEntry.key}:
          properties:
#serializeAbtractPropertyValues($capabilityEntry.value.properties "            ")
#end## if capability properties not empty
#end## of capabilityEntry iteration
#end## if hasCapabilitiesContainingNotNullProperties
#if($utils.mapIsNotEmptyAndContainsNotnullValues($nodeTemplateEntry.value.artifacts))
      artifacts:
#foreach($artifactEntry in ${nodeTemplateEntry.value.artifacts.entrySet()})
        ${artifactEntry.key}:
#if($artifactEntry.value.artifactRef)
          implementation: ${artifactEntry.value.artifactRef}
#end## if($artifactEntry.value.artifactRef)
          type: ${artifactEntry.value.artifactType}
#if($artifactEntry.value.artifactName)
          description: ${artifactEntry.value.artifactName}
#end## if($artifactEntry.value.artifactName)
#end## of artifactEntry iteration
#end## if artifacts map not empty
#end## of nodeTemplateEntry iteration
#if($utils.mapIsNotEmptyAndContainsNotnullValues($topology.groups))
  groups:
#foreach($groupEntry in ${topology.groups.entrySet()})
    ${groupEntry.key}:
      members: [ $utils.getCsvToString($groupEntry.value.members) ]
#if($utils.collectionIsNotEmpty($groupEntry.value.policies))
      policies:
#foreach($policy in ${groupEntry.value.policies})
        - name: ${policy.name}
          type: ${policy.type}
#end## of policy iteration
#end## if $groupEntry.value.policies not empty
#end## of groupEntry iteration
#end## if $topology.groups not empty
#if($utils.mapIsNotEmptyAndContainsNotnullValues($topology.outputProperties) || $utils.mapIsNotEmptyAndContainsNotnullValues($topology.outputAttributes)  || $utils.mapIsNotEmptyAndContainsNotnullValues($topology.outputCapabilityProperties))
  outputs:
#foreach($outputPropertyEntry in ${topology.outputProperties.entrySet()})
#foreach($outputProperty in ${outputPropertyEntry.value})
    ${outputPropertyEntry.key}_${outputProperty}:
      value: { get_property: [ ${outputPropertyEntry.key}, ${outputProperty} ] }
#end## of outputProperty iteration
#end## of outputPropertyEntry iteration
#foreach($outputAttributeEntry in ${topology.outputAttributes.entrySet()})
#foreach($outputAttribute in ${outputAttributeEntry.value})
    ${outputAttributeEntry.key}_${outputAttribute}:
      value: { get_attribute: [ ${outputAttributeEntry.key}, ${outputAttribute} ] }
#end## of outputProperty iteration
#end## of outputAttributeEntry iteration
#foreach($outputCapaPropEntry in ${topology.outputCapabilityProperties.entrySet()})
#foreach($outputCapaPropSubEntry in ${outputCapaPropEntry.value.entrySet()})
#foreach($outputCapaProp in ${outputCapaPropSubEntry.value})
    ${outputCapaPropEntry.key}_${outputCapaPropSubEntry.key}_${outputCapaProp}:
      value: { get_property: [ ${outputCapaPropEntry.key}, ${outputCapaPropSubEntry.key}, ${outputCapaProp} ] }
#end## of outputCapaProp iteration
#end## of outputCapaPropSubEntry iteration
#end## of outputCapaPropEntry iteration
#end## if maps are not empty