1 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Introduction

<relationship_template_defn_1>

5.2.6.2.1.2 Examples

This section provides a set of examples for the single elements of a service template.

Simple inputs example without any validation clauses:

inputs:

fooName:

type: string

description: Simple string parameter without a validation clause.

default: bar

Example of inputs with a validation clause:

inputs:

SiteName:

type: string

description: String parameter with validation clause.

default: My Site

validation: { $min_length: [ $value, 9 ] }

5.2.6.2.2 node_templates

The node_templates section lists the Node Templates that describe the (software) components that are used to compose cloud applications.

5.2.6.2.2.1 grammar

The grammar of the node_templates section is a follows:

node_templates:

<node_template_defn_1>

...

<node_template_defn_n>

5.2.6.2.2.2 Example

Example of node_templates section:

node_templates:

my_webapp_node_template:

type: WebApplication

my_database_node_template:

type: Database

5.2.6.2.3 relationship_templates

The relationship_templates section lists the Relationship Templates that describe the relations between components that are used to compose cloud applications.

Note that in TOSCA, the explicit definition of relationship templates as it was required in TOSCA v1.0 is optional, since relationships between nodes get implicitly defined by referencing other node templates in the requirements sections of node templates.

5.2.6.2.3.1 Grammar

The grammar of the relationship_templates section is as follows:

relationship_templates:

...

<relationship_template_defn_n>

5.2.6.2.3.2 Example

Example of relationship_templates section:

relationship_templates:

my_connectsto_relationship:

type: tosca.relationships.ConnectsTo

interfaces:

Configure:

inputs:

speed: { $$get_attribute: [ SELF, SOURCE, connect_speed ] }

5.2.6.2.4 outputs

The outputs section provides a means to define the output parameters that are available from a TOSCA service template. It allows for exposing attributes of node templates or relationship templates within the containing service_template to users of a service.

5.2.6.2.4.1 Grammar

The grammar of the outputs section is as follows:

outputs:

5.2.6.2.4.2 Example

Example of the outputs section:

outputs:

server_address:

description: The first private IP address for the provisioned server.

value: { $get_attribute: [ node5, networks, private, addresses, 0 ] }

5.2.6.2.5 groups

The groups section allows for grouping one or more node templates within a TOSCA Service Template and for assigning special attributes like policies to the group.

5.2.6.2.5.1 Grammar

The grammar of the groups section is as follows:

groups:

<group_defn_1>

...

<group_defn_n>

5.2.6.2.5.2 Example

The following example shows the definition of three Compute nodes in the node_templates section of a service_template as well as the grouping of two of the Compute nodes in a group server_group_1.

node_templates:

server1:

type: tosca.nodes.Compute

# more details ...

server2:

type: tosca.nodes.Compute

# more details ...

server3:

type: tosca.nodes.Compute

# more details ...

groups:

# server2 and server3 are part of the same group

server_group_1:

type: tosca.groups.Root

members: [ server2, server3 ]

5.2.6.2.6 policies

The policies section allows for declaring policies that can be applied to entities in the service template.

5.2.6.2.6.1 Grammar

The grammar of the policies section is as follows:

policies:

- <policy_defn_1>

- ...

- <policy_defn_n>

5.2.6.2.6.2 Example

The following example shows the definition of a placement policy.

policies:

- my_placement_policy:

type: mycompany.mytypes.policy.placement

5.2.6.2.7 substitution_mapping

5.2.6.2.7.1 requirement_mapping

The grammar of a requirement_mapping is as follows:

<requirement_name>: [ <node_template_name>, <node_template_requirement_name> ]

The multi-line grammar is as follows :

<requirement_name>:

mapping: [ <node_template_name>, <node_template_capability_name> ]

properties:

<property_name>: <property_value>

· requirement_name: represents the name of the requirement as it appears in the Node Type definition for the Node Type (name) that is declared as the value for on the substitution_mappings’ “node_type” key.

· node_template_name: represents a valid name of a Node Template definition (within the same service_template declaration as the substitution_mapping is declared).

· node_template_requirement_name: represents a valid name of a requirement definition within the <node_template_name> declared in this mapping.

5.2.6.2.7.2 Example

The following example shows the definition of a placement policy.

service_template:

inputs:

cpus:

type: integer

validation: { $less_than: [ $value, 2 ] } # OR use “defaults” key

substitution_mappings:

node_type: MyService

properties: # Do not care if running or matching (e.g., Compute node)

# get from outside? Get from contsraint?

num_cpus: cpus # Implied “PUSH”

# get from some node in the topology…

num_cpus: [ <node>, <cap>, <property> ]

# 1) Running

architecture:

# a) Explicit

value: { $get_property: [some_service, architecture] }

# b) implicit

value: [ some_service, <req | cap name>, <property name> architecture ]

default: “amd”

# c) INPUT mapping?

???

# 2) Catalog (Matching)

architecture:

contraints: equals: “x86”

capabilities:

bar: [ some_service, bar ]

requirements:

foo: [ some_service, foo ]

node_templates:

some_service:

type: MyService

properties:

rate: 100

capabilities:

bar:

...

requirements:

- foo:

...

5.3 Nodes and Relationships

5.3.1 Node Type

A Node Type is a reusable entity that defines the type of one or more Node Templates. As such, a Node Type defines the structure of observable properties and attributes, the capabilities and requirements of the node as well as its supported interfaces and the artifacts it uses.

5.3.1.1 Keynames

The Node Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Node Type has the following recognized keynames:

Keyname	Mandatory	Type	Description
properties	no	map of property definitions	An optional map of property definitions for the Node Type.
attributes	no	map of attribute definitions	An optional map of attribute definitions for the Node Type.
capabilities	no	map of capability definitions	An optional map of capability definitions for the Node Type.
requirements	no	list of requirement definitions	An optional list of requirement definitions for the Node Type.
interfaces	no	map of interface definitions	An optional map of interface definitions supported by the Node Type.
artifacts	no	map of artifact definitions	An optional map of artifact definitions for the Node Type.

5.3.1.2 Grammar

Node Types have following grammar:

<node_type_name>:

derived_from: <parent_node_type_name>

version: <version_number>

metadata:

description: <node_type_description>

properties:

attributes:

capabilities:

<capability_definitions>

requirements:

- <requirement_definitions>

interfaces:

<interface_definitions>

artifacts:

<artifact_definitions>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· node_type_name: represents the mandatory symbolic name of the Node Type being declared.

· parent_node_type_name: represents the name (string) of the Node Type this Node Type definition derives from (i.e. its parent type).

· version_number: represents the optional TOSCA version number for the Node Type.

· node_type_description: represents the optional description string for the corresponding node_type_name.

· property_definitions: represents the optional map of property definitions for the Node Type.

· attribute_definitions: represents the optional map of attribute definitions for the Node Type.

· capability_definitions: represents the optional map of capability definitions for the Node Type.

· requirement_definitions: represents the optional list of requirement definitions for the Node Type.

· interface_definitions: represents the optional map of one or more interface definitions supported by the Node Type.

· artifact_definitions: represents the optional map of artifact definitions for the Node Type

5.3.1.3 Derivation rules

During Node Type derivation the keyname definitions follow these rules:

· properties: existing property definitions may be refined; new property definitions may be added.

· attributes: existing attribute definitions may be refined; new attribute definitions may be added.

· capabilities: existing capability definitions may be refined; new capability definitions may be added.

· requirements: existing requirement definitions may be refined; new requirement definitions may be added.

· interfaces: existing interface definitions may be refined; new interface definitions may be added.

· artifacts: existing artifact definitions (identified by their symbolic name) may be redefined; new artifact definitions may be added.

– note that an artifact is created for a specific purpose and corresponds to a specific file (with e.g. a path name and checksum); if it cannot meet its purpose in a derived type then a new artifact should be defined and used.

– thus, if an artifact defined in a parent node type does not correspond anymore with the needs in the child node type, its definition may be completely redefined; thus, an existing artifact definition is not refined, but completely overwritten.

5.3.1.4 Additional Requirements

· Requirements are intentionally expressed as a list of TOSCA Requirement definitions which SHOULD be resolved (processed) in sequence by TOSCA Orchestrators.

5.3.1.5 Example

my_company.my_types.my_app_node_type:

derived_from: tosca.nodes.SoftwareComponent

description: My company’s custom applicaton

properties:

my_app_password:

type: string

description: application password

validation:

$and:

- { $min_length: [ $value, 6 ] }

- { $max_length: [ $value, 10 ] }

attributes:

my_app_port:

type: integer

description: application port number

requirements:

- some_database:

capability: EndPoint.Database

node: Database

relationship: ConnectsTo

5.3.2 Node Template

A Node Template specifies the occurrence of a manageable component as part of an application’s topology model which is defined in a TOSCA Service Template. A Node Template is an instance of a specified Node Type and can provide customized properties, relationships, or interfaces that complement and change the defaults provided by its Node Type.

5.3.2.1 Keynames

The following is the list of recognized keynames for a TOSCA Node Template definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory name of the Node Type the Node Template is based upon.
description	no	string	An optional description for the Node Template.
metadata	no	map of string	Defines a section used to declare additional metadata information.
directives	no	list of string	An optional list of directive values to provide processing instructions to orchestrators and tooling.
properties	no	map of property assignments	An optional map of property value assignments for the Node Template.
attributes	no	map of attribute assignments	An optional map of attribute value assignments for the Node Template.
requirements	no	list of requirement assignments	An optional list of requirement assignments for the Node Template.
capabilities	no	map of capability assignments	An optional map of capability assignments for the Node Template.
interfaces	no	map of interface assignments	An optional map of interface assignments for the Node Template.
artifacts	no	map of artifact definitions	An optional map of artifact definitions for the Node Template.
node_filter	no	node filter	The optional filter definition that TOSCA orchestrators will use to select the correct target node.
copy	no	string	The optional (symbolic) name of another node template to copy into (all keynames and values) and use as a basis for this node template.

5.3.2.2 Grammar

<node_template_name>:

type: <node_type_name>

description: <node_template_description>

directives: [<directives>]

metadata:

properties:

attributes:

requirements:

- <requirement_assignments>

capabilities:

<capability_assignments>

interfaces:

<interface_assignments>

artifacts:

<artifact_definitions>

node_filter:

<node_filter_definition>

copy: <source_node_template_name>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· node_template_name: represents the mandatory symbolic name of the Node Template being declared.

· node_type_name: represents the name of the Node Type the Node Template is based upon.

· node_template_description: represents the optional description string for Node Template.

· directives: represents the optional list of processing instruction keywords (as strings) for use by tooling and orchestrators.

· property_assignments: represents the optional map of property assignments for the Node Template that provide values for properties defined in its declared Node Type.

· attribute_assignments: represents the optional map of attribute assignments for the Node Template that provide values for attributes defined in its declared Node Type.

· requirement_assignments: represents the optional list of requirement assignments for the Node Template for requirement definitions provided in its declared Node Type.

· capability_assignments: represents the optional map of capability assignments for the Node Template for capability definitions provided in its declared Node Type.

· interface_assignments: represents the optional map of interface assignments for the Node Template interface definitions provided in its declared Node Type.

· artifact_definitions: represents the optional map of artifact definitions for the Node Template that augment those provided by its declared Node Type.

· node_filter_definition: represents the optional node filter TOSCA orchestrators will use for selecting a matching node template.

· source_node_template_name: represents the optional (symbolic) name of another node template to copy into (all keynames and values) and use as a basis for this node template.

5.3.2.3 Additional requirements

· The source node template provided as a value on the copy keyname MUST NOT itself use the copy keyname (i.e., it must itself be a complete node template description and not copied from another node template).

5.3.2.4 Example

node_templates:

mysql:

type: tosca.nodes.DBMS.MySQL

properties:

root_password: { $get_input: my_mysql_rootpw }

port: { $get_input: my_mysql_port }

requirements:

- host: db_server

interfaces:

Standard:

operations:

configure: scripts/my_own_configure.sh

5.3.3 Relationship Type

A Relationship Type is a reusable entity that defines the type of one or more relationships between Node Types or Node Templates.

5.3.3.1 Keynames

The Relationship Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Relationship Type has the following recognized keynames:

Keyname	Mandatory	Definition/Type	Description
properties	no	map of property definitions	An optional map of property definitions for the Relationship Type.
attributes	no	map of attribute definitions	An optional map of attribute definitions for the Relationship Type.
interfaces	no	map of interface definitions	An optional map of interface definitions supported by the Relationship Type.
valid_capability_types	no	list of string	An optional list of one or more names of Capability Types that are valid targets for this relationship. If undefined, all Capability Types are valid.
valid_target_node_types	no	list of string	An optional list of one or more names of Node Types that are valid targets for this relationship. If undefined, all Node Types are valid targets.
valid_source_node_types	no	list of string	An optional list of one or more names of Node Types that are valid sources for this relationship. If undefined, all Node Types are valid sources.

5.3.3.2 Grammar

Relationship Types have following grammar:

<relationship_type_name>:

derived_from: <parent_relationship_type_name>

version: <version_number>

metadata:

description: <relationship_description>

properties:

attributes:

interfaces:

<interface_definitions>

valid_capability_types: [ <capability_type_names> ]

valid_target_node_types: [ <target_node_type_names> ]

valid_source_node_types: [ <source_node_type_names> ]

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· relationship_type_name: represents the mandatory symbolic name of the Relationship Type being declared as a string.

· parent_relationship_type_name: represents the name (string) of the Relationship Type this Relationship Type definition derives from (i.e., its “parent” type).

· relationship_description: represents the optional description string for the corresponding relationship_type_name.

· version_number: represents the optional TOSCA version number for the Relationship Type.

· property_definitions: represents the optional map of property definitions for the Relationship Type.

· attribute_definitions: represents the optional map of attribute definitions for the Relationship Type.

· interface_definitions: represents the optional map of interface definitions supported by the Relationship Type.

· capability_type_names: represents the optional list of valid target Capability Types for the relationship; if undefined, the valid target types are not restricted at all (i.e., all Capability Types are valid).

· target_node_type_names: represents the optional list of valid target Node Types for the relationship; if undefined, the valid types are not restricted at all (i.e., all Node Types are valid).

· source_node_type_names: represents the optional list of valid source Node Types for the relationship; if undefined, the valid types are not restricted at all (i.e., all Node Types are valid).

5.3.3.3 Derivation rules

During Relationship Type derivation the keyname definitions follow these rules:

· properties: existing property definitions may be refined; new property definitions may be added.

· attributes: existing attribute definitions may be refined; new attribute definitions may be added.

· interfaces: existing interface definitions may be refined; new interface definitions may be added.

· valid_capability_types: if valid_capability_types is defined in the parent type, each element in this list must either be in the parent type list or derived from an element in the parent type list; if valid_target_types is not defined in the parent type then no restrictions are applied.

· valid_target_node_types: same derivation rules as for valid_capability_types

· valid_source_node_types: same derivation rules as for valid_capability_types

5.3.3.4 Examples

mycompanytypes.myrelationships.AppDependency:

derived_from: tosca.relationships.DependsOn

valid_capability_types: [ mycompanytypes.mycapabilities.SomeAppCapability ]

5.3.4 Relationship Template

A Relationship Template specifies the occurrence of a manageable relationship between node templates as part of an application’s topology model that is defined in a TOSCA Service Template. A Relationship template is an instance of a specified Relationship Type and can provide customized properties, or operations that complement and change the defaults provided by its Relationship Type and its implementations.

Relations between Node Templates can be defined either using Relationship Templates or Requirements and Capability definitions within Node Types. Use of Relationship Templates decouples relationship definitions from Node Type definitions, allowing Node Type definitions to be more “generic” for use in a wider set of service templates which have varying relation definition requirements. The Relationship Templates are local within a service template and so have a limited scope. Requirements and Capabilities defined in Node Types have a wider scope, exposed within any service template which contains a Node Template of the Node Type.

Note that using the relationship templates is underspecified currently and can be used only as a further template for relationships in requirements definition. This topic needs further work.

5.3.4.1 Keynames

The following is the list of recognized keynames for a TOSCA Relationship Template definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory name of the Relationship Type the Relationship Template is based upon.
description	no	string	An optional description for the Relationship Template.
metadata	no	map of string	Defines a section used to declare additional metadata information.
properties	no	map of property assignments	An optional map of property assignments for the Relationship Template.
attributes	no	map of attribute assignments	An optional map of attribute assignments for the Relationship Template.
interfaces	no	map of interface assignments	An optional map of interface assignments for the relationship template.
copy	no	string	The optional (symbolic) name of another relationship template to copy into (all keynames and values) and use as a basis for this relationship template.

5.3.4.2 Grammar

<relationship_template_name>:

type: <relationship_type_name>

description: <relationship_type_description>

metadata:

properties:

attributes:

<source_relationship_template_name>

interfaces:

<interface_assignments>

copy:

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· relationship_template_name: represents the mandatory symbolic name of the Relationship Template being declared.

· relationship_type_name: represents the name of the Relationship Type the Relationship Template is based upon.

· relationship_template_description: represents the optional description string for the Relationship Template.

· property_assignments: represents the optional map of property assignments for the Relationship Template that provide values for properties defined in its declared Relationship Type.

· attribute_assignments: represents the optional map of attribute assignments for the Relationship Template that provide values for attributes defined in its declared Relationship Type.

· interface_assignments: represents the optional map of interface assignments for the Relationship Template for interface definitions provided by its declared Relationship Type.

· source_relationship_template_name: represents the optional (symbolic) name of another relationship template to copy into (all keynames and values) and use as a basis for this relationship template.

5.3.4.3 Additional requirements

· The source relationship template provided as a value on the copy keyname MUST NOT itself use the copy keyname (i.e., it must itself be a complete relationship template description and not copied from another relationship template).

5.3.4.4 Example

relationship_templates:

storage_attachment:

type: AttachesTo

properties:

location: /my_mount_point

5.3.5 Capabilities and Requirements

5.3.5.1 Capability Type

A Capability Type is a reusable entity that describes a kind of capability that a Node Type can declare to expose. Requirements (implicit or explicit) that are declared as part of one node can be matched to (i.e., fulfilled by) the Capabilities declared by another node.

5.3.5.1.1 Keynames

The Capability Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Capability Type has the following recognized keynames:

Keyname	Mandatory	Type	Description
properties	no	map of property definitions	An optional map of property definitions for the Capability Type.
attributes	no	map of attribute definitions	An optional map of attribute definitions for the Capability Type.
valid_source_node_types	no	list of string	An optional list of one or more valid names of Node Types that are supported as valid sources of any relationship established to the declared Capability Type. If undefined, all Node Types are valid sources.
valid_relationship_types	no	list of string	An optional list of one or more valid names of Relationship Types that are supported as valid types of any relationship established to the declared Capability Type. If undefined, all Relationship Types are valid.

5.3.5.1.2 Grammar

Capability Types have following grammar:

<capability_type_name>:

derived_from: <parent_capability_type_name>

version: <version_number>

description: <capability_description>

properties:

attributes:

valid_source_node_types: [ <node_type_names> ]

valid_relationship_types: [ <relationship_type_names> ]

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· capability_type_name: represents the mandatory name of the Capability Type being declared as a string.

· parent_capability_type_name: represents the name of the Capability Type this Capability Type definition derives from (i.e., its “parent” type).

· version_number: represents the optional TOSCA version number for the Capability Type.

· capability_description: represents the optional description string for the Capability Type.

· property_definitions: represents the optional map of property definitions for the Capability Type.

· attribute_definitions: represents the optional map of attribute definitions for the Capability Type.

· node_type_names: represents the optional list of one or more names of Node Types that the Capability Type supports as valid sources for a successful relationship to be established to a capability of this Capability Type; if undefined, the valid source types are not restricted at all (i.e. all Node Types are valid).

· relationship_type_names: represents the optional list of one or more names of Relationship Types that the Capability Type supports as valid types for a successful relationship to be established to a capability of this Capability Type; if undefined, the valid types are not restricted at all (i.e. all Relationship Types are valid).

5.3.5.1.3 Derivation rules

During Capability Type derivation the keyname definitions follow these rules:

· properties: existing property definitions may be refined; new property definitions may be added.

· attributes: existing attribute definitions may be refined; new attribute definitions may be added.

· valid_source_node_types: if valid_source_types is defined in the parent type, each element in this list must either be in the parent type list or derived from an element in the parent type list; if valid_source_types is not defined in the parent type then no restrictions are applied.

· valid_relationship_types: same derivations rules as for valid_source_node_types.

5.3.5.1.4 Example

mycompany.mytypes.myapplication.MyFeature:

derived_from: tosca.capabilities.Root

description: a custom feature of my company’s application

properties:

my_feature_setting:

type: string

my_feature_value:

type: integer

5.3.5.2 Capability definition

A Capability definition defines a typed set of data that a node can expose and is used to describe a relevant feature of the component described by the node. A Capability is defined part of a Node Type definition and may be refined during Node Type derivation.

5.3.5.2.1 Keynames

The following is the list of recognized keynames for a TOSCA capability definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory name of the Capability Type this capability definition is based upon.
description	no	string	The optional description of the Capability definition.
properties	no	map of property refinements	An optional map of property refinements for the Capability definition. The referred properties must have been defined in the Capability Type definition referred by the type keyword. New properties may not be added.
attributes	no	map of attribute refinements	An optional map of attribute refinements for the Capability definition. The referred attributes must have been defined in the Capability Type definition referred by the type keyword. New attributes may not be added.
valid_source_node_types	no	list of string	An optional list of one or more valid names of Node Types that are supported as valid sources of any relationship established to the declared Capability Type. If undefined, all node types are valid sources. If valid_source_node_types is defined in the Capability Type, each element in this list must either be or derived from an element in the list defined in the type.
valid_relationship_types	no	list of string	An optional list of one or more valid names of Relationship Types that are supported as valid types of any relationship established to the declared Capability Type. If undefined, all Relationship Types are valid. If valid_relationship_types is defined in the Capability Type, each element in this list must either be or derived from an element in the list defined in the type.

5.3.5.2.2 Grammar

Capability definitions have one of the following grammars:

5.3.5.2.2.1 Short notation

The following single-line grammar may be used when only the capability type needs to be declared, without further refinement of the definitions in the capability type:

<capability_definition_name>: <capability_type>

5.3.5.2.2.2 Extended notation

The following multi-line grammar may be used when additional information on the capability definition is needed:

<capability_definition_name>:

type: <capability_type>

description: <capability_description>

properties:

<property_refinements>

attributes:

<attribute_refinements>

valid_source_node_types: [ <node_type_names> ]

valid_relationship_types: [ <relationship_type_names> ]

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· capability_definition_name: represents the symbolic name of the capability as a string.

· capability_type: represents the mandatory name of a capability type the capability definition is based upon.

· capability_description: represents the optional description of the capability definition.

· property_refinements: represents the optional map of property definitions refinements for properties already defined in the capability type; new properties may not be added.

· attribute_refinements: represents the optional map of attribute definitions refinements for attributes already defined in the capability type; new attributes may not be added.

· node_type_names: represents the optional list of one or more names of node types that the capability definition supports as valid sources for a successful relationship to be established to said capability

· if valid_source_node_types is defined in the capability type, each element in this list MUST either be in that list or derived from an element in that list; if valid_source_types is not defined in the capability type then no restrictions are applied.

· relationship_type_names: represents the optional list of one or more names of relationship types that the capability definition supports as valid type for a successful relationship to be established to said capability

· if valid_relationship_types is defined in the capability type, each element in this list MUST either be in that list or derived from an element in that list; if valid_source_types is not defined in the capability type then no restrictions are applied.

5.3.5.2.3 Refinement rules

A capability definition within a node type uses the following definition refinement rules when the containing node type is derived:

· type: must be derived from (or the same as) the type in the capability definition in the parent node type definition.

· description: a new definition is unrestricted and will overwrite the one inherited from the capability definition in the parent node type definition.

· properties: not applicable to the definitions in the parent node type but to the definitions in the capability type referred by the type keyname (see grammar above for the rules).

· attributes: not applicable to the definitions in the parent node type but to the definitions in the capability type referred by the type keyname (see grammar above for the rules).

· valid_source_node_types: not applicable to the definitions in the parent node type but to the definitions in the capability type referred by the type keyname (see grammar above for the rules).

· valid_relationship_types: not applicable to the definitions in the parent node type but to the definitions in the capability type referred by the type keyname (see grammar above for the rules).

5.3.5.2.4 Examples

The following examples show capability definitions in both simple and full forms:

5.3.5.2.4.1 Simple notation example

# Simple notation, no properties need to be refined

some_capability: mytypes.mycapabilities.MyCapabilityTypeName

5.3.5.2.4.2 Full notation example

# Full notation, refining properties

some_capability:

type: mytypes.mycapabilities.MyCapabilityTypeName

properties:

limit:

default: 100

5.3.5.2.5 Additional requirements

· Capability symbolic names SHALL be unique; it is an error if a capability name is found to occur more than once.

5.3.5.2.6 Note

· The occurrences keyname is deprecated in TOSCA 2.0. By default, the number of “occurrences” is UNBOUNDED, i.e. any number of relationships can be created with a certain capability as a target. To constrain the creation of a relationship to a target capability, the new “allocation” keyname is used within a requirement assignment.

5.3.5.3 Capability assignment

A capability assignment allows node template authors to assign values to properties and attributes for a capability definition that is part of the node templates’ respective type definition, and also to set the capability occurrences.

5.3.5.3.1 Keynames

The following is the list of recognized keynames for a TOSCA capability assignment:

Keyname	Mandatory	Type	Description
properties	no	map of property assignments	An optional map of property assignments for the Capability definition.
attributes	no	map of attribute assignments	An optional map of attribute assignments for the Capability definition.
directives	no default: [internal, external]	list of string valid string values: “internal”, “external”	Describes if the fulfillment of this capability assignment should use relationships with source nodes created within this template (“internal”) or should use source nodes created outside this template as available to the TOSCA environment ("external”) or if it should use a combination of the above. If so, the order of the strings in the list defines which scope should be attempted first. If no scope is defined, the default value is [internal, external]. If no directives are defined, the default value is left to the particular implementation.

5.3.5.3.2 Grammar

Capability assignments have one of the following grammars:

<capability_definition_name>:

properties:

attributes:

<requirement_definition_name>:

directives: <directives_list>

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· capability_definition_name: represents the symbolic name of the capability as a string.

· property_assignments: represents the optional map of property assignments that provide values for properties defined in the Capability definition.

· attribute_assignments: represents the optional map of attribute assignments that provide values for attributes defined in the Capability definition.

· directives_list: represents the optional list of strings that defines directives for this capability:

· valid values for the strings:

· “internal” – relationships to this capability can be created from source nodes created within this template.

· “external” – relationships to this capability can be created from source nodes created outside this template as available to the TOSCA environment.

· the order of the strings in the list defines which scope should be attempted first when fulfilling the assignment.

· If no directives are defined, the default value is left to the particular implementation.

5.3.5.3.3 Example

The following example shows a capability assignment:

5.3.5.3.3.1 Notation example

node_templates:

some_node_template:

capabilities:

some_capability:

properties:

limit: 100

5.3.5.3.4 Note

5.3.5.4 Requirement Type

Requirement types are not defined in TOSCA. TOSCA seeks to simplify the modeling by not declaring specific Requirement Types with nodes declaring their features sets using TOSCA Capability Types. So, it suffices that capabilities are advertised a-priory by Capability Types, while requirement definitions can be directly created during Node Type design.

5.3.5.5 Requirement definition

The Requirement definition describes a requirement (dependency) of a TOSCA node which needs to be fulfilled by a matching Capability definition declared by another TOSCA node. A Requirement is defined as part of a Node Type definition and may be refined during Node Type derivation.

5.3.5.5.1 Keynames

The following is the list of recognized keynames for a TOSCA requirement definition:

Keyname	Mandatory	Type	Description
description	no	string	The optional description of the Requirement definition.
capability	yes	string	The mandatory keyname used to provide either the: · symbolic name of a Capability definition within a target Node Type that can fulfill the requirement. · name of a Capability Type that the TOSCA orchestrator will use to select a type-compatible target node to fulfill the requirement at runtime.
node	conditional	string	The optional keyname used to provide the name of a valid Node Type that contains the capability definition that can be used to fulfill the requirement. If a symbolic name of a Capability definition has been used for the capability keyname, then the node keyname is mandatory.
relationship	conditional	string	The optional keyname used to provide the name of a valid Relationship Type to construct a relationship when fulfilling the requirement. The relationship definition is mandatory either in the requirement definition of in the requirement assignment.
node_filter	no	node filter	The optional filter definition that TOSCA orchestrators will use to select a type-compatible target node that can fulfill the associated abstract requirement at runtime.
count_range	no	range of integer	The optional minimum required and maximum allowed number of relationships created by the requirement. If this key is not specified, the implied default of [0, UNBOUNDED] will be used. Note: the keyword UNBOUNDED is also supported to represent any positive integer.

5.3.5.5.1.1 Additional keynames for multi-line relationship grammar

The Requirement definition contains the Relationship Type information needed by TOSCA Orchestrators to construct relationships to other TOSCA nodes with matching capabilities; however, it is sometimes recognized that additional parameters may need to be passed to the relationship (perhaps for configuration). In these cases, additional grammar is provided so that the requirement definition may declare interface refinements (e.g. changing the implementation definition or declaring additional parameter definitions to be used as inputs/outputs).

Keyname	Mandatory	Type	Description
type	yes	string	The optional keyname used to provide the name of the Relationship Type as part of the relationship keyname definition.
interfaces	no	map of interface refinements	The optional keyname used to reference declared interface definitions on the corresponding Relationship Type for refinement.

5.3.5.5.2 Grammar

Requirement definitions have one of the following grammars:

5.3.5.5.2.1 Simple grammar (Capability Type only)

<requirement_definition_name>: <capability_type_name>

5.3.5.5.2.2 Extended grammar (with Node and Relationship Types)

description: <requirement_description>

capability: <capability_symbolic_name> | <capability_type_name>

node: <node_type_name>

relationship: <relationship_type_name>

node_filter: <node_filter_definition>

count_range: [ <min_count>, <max_count> ]

5.3.5.5.2.3 Extended grammar for declaring Parameter Definitions on the relationship’s Interfaces

The following additional multi-line grammar is provided for the relationship keyname in order to declare new parameter definitions for inputs/outputs of known Interface definitions of the declared Relationship Type.

<requirement_definition_name>:

# Other keynames omitted for brevity

relationship:

type: <relationship_type_name>

interfaces: <interface_refinements>

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· requirement_definition_name: represents the mandatory symbolic name of the requirement definition as a string.

· requirement_description: represents the optional description of the requirement definition.

· capability_symbolic_name: represents the mandatory symbolic name of the Capability definition within the target Node Type.

· capability_type_name: represents the mandatory name of a Capability Type that can be used to fulfill the requirement.

· node_type_name: represents the name of a Node Type that contains either the Capability Type or the Capability definition the requirement can be fulfilled by; the node_type_name is mandatory if the capability_symbolic_name was used, and is optional if the capability_type_name was used.

· relationship_type_name: represents the optional name of a Relationship Type to be used to construct a relationship between this requirement definition (i.e. in the source node) to a matching capability definition (in a target node).

· node_filter_definition: represents the optional node filter TOSCA orchestrators will use to fulfill the requirement when selecting a target node, or to verify that the specified node template fulfills the requirement (if a node template was specified during requirement assignment).

· min_count, max_count: represents the optional range between a minimum required and maximum allowed count of the requirement

· this range constrains how many relationships from this requirement towards target capabilities (in target nodes) are created, and that number MUST be within the range specified here.

· by default (i.e. if count_range is undefined here), a requirement shall form exactly one relationship ( [1, 1] i.e. allowed at least one, and at most one).

· interface_refinements: represents refinements for one or more already declared interface definitions in the Relationship Type (as declared on the type keyname)

· allowing for the declaration of new parameter definitions for these interfaces or for specific operation or notification definitions of these interfaces or for the change of the description or implementation definitions.

5.3.5.5.3 Refinement rules

A requirement definition within a node type uses the following definition refinement rules when the containing node type is derived:

· description: a new definition is unrestricted and will overwrite the one inherited from the requirement definition in the parent node type definition.

· capability: the type of the capability must be derived from (or the same as) the capability type in the requirement definition in the parent node type definition.

· if the capability was specified using the symbolic name of a capability definition in the target node type, then the capability keyname definition MUST remain unchanged in any subsequent refinements or during assignment.

· node: must be derived from (or the same as) the node type in the requirement definition in the parent node type definition; if node is not defined in the parent type then no restrictions are applied;

· the node type specified by the node keyname must also contain a capability definition that fulfills the requirement set via the capability keyname above.

· relationship: must be derived from (or the same as) the relationship type in the requirement definition in the parent node type definition; if relationship is not defined in the parent type then no restrictions are applied.

· node_filter: a new definition is unrestricted and will be considered in addition (i.e. logical and) to the node_filter definition in the parent node type definition; further refinements may add further node filters.

· count_range: the new range MUST be within the range defined in the requirement definition in the parent node type definition.

5.3.5.5.4 Additional requirements

· Requirement symbolic names SHALL be unique; it is an error if a requirement name is found to occur more than once.

· If the count_range keyname is not present, then a default declaration as follows will be assumed:

count_range: [0, UNBOUNDED]

5.3.5.5.5 Notes

· The requirement symbolic name is used for identification of the requirement definition only and not relied upon for establishing any relationships in the topology.

5.3.5.5.6 Requirement definition is a tuple with a filter

A requirement definition allows type designers to govern which types are allowed (valid) for fulfillment using three levels of specificity with only the Capability definition or Capability Type being mandatory.

4. Node Type (mandatory/optional)

5. Relationship Type (optional)

6. Capability definition or Capability Type (mandatory)

The first level allows selection, as shown in both the simple or complex grammar, simply providing the node’s type using the node keyname. The second level allows specification of the relationship type to use when connecting the requirement to the capability using the relationship keyname. Finally, the specific Capability definition or Capability Type on the target node is provided using the capability keyname. Note that if a Capability definition is used, the Node Type definition is mandatory (as it refers to a Capability definition in that Node Type).

In addition to the node, relationship and capability types, a filter, with the keyname node_filter, may be provided to constrain the allowed set of potential target nodes based upon their properties and their capabilities’ properties. This allows TOSCA orchestrators to help find the “best fit” when selecting among multiple potential target nodes for the expressed requirements. Also, if a Node Template was specified during requirement assignment it allows TOSCA orchestrators to verify that the specified node template fulfills the requirement.

5.3.5.6 Requirement assignment

A Requirement assignment allows Node Template authors to provide assignments for the corresponding Requirement definition (i.e. having the same symbolic name) in the Node Type definition.

A Requirement assignment provides either names of Node Templates or selection criteria for TOSCA orchestrators to find matching TOSCA nodes that are used to fulfill the requirement’s declared Capability Type and/or Node Type. A Requirement assignment also provides either names of Relationship Templates (to use) or the name of Relationship Types (to create relationships) for relating the source node (containing the Requirement) to the target node (containing the Capability).

Note that several Requirement assignments in the Node Template definition can have the same symbolic name, each referring to different counts of the Requirement definition. To how many counts a particular assignment allows is set via the count_range keyname. Nevertheless, the sum of the count values for all of the Requirement assignments with the same symbolic name MUST be within the range of count_range specified by the corresponding Requirement definition.

5.3.5.6.1 Keynames

The following is the list of recognized keynames for a TOSCA requirement assignment:

Keyname	Mandatory	Type	Description
capability	no	string	The optional keyname used to provide either the: · symbolic name of a Capability definition within a target node that can fulfill the requirement. · name of a Capability Type that the TOSCA orchestrator will use to select a type-compatible target node to fulfill the requirement at runtime.
node	no	string	The optional keyname used to identify the target node of a relationship; specifically, it is used to provide either the: · name of a Node Template that can fulfill the target node requirement. · name of a Node Type that the TOSCA orchestrator will use to select a type-compatible target node to fulfill the requirement at runtime.
relationship	conditional	string	The conditional keyname used to provide either the: · name of a Relationship Template to use to relate this node to the target node when fulfilling the requirement. · name of a Relationship Type that the TOSCA orchestrator will use to create a relationship to relate this node to the target node when fulfilling the requirement. · Details of a Relationship Type and its property and interface assignments that the TOSCA orchestrator will use to create a relationship to relate this node to the target node when fulfilling the requirement. The relationship definition is mandatory either in the requirement definition of in the requirement assignment.
allocation	no	allocation block	The optional keyname that allows the inclusion of an allocation block. The allocation block contains a map of property assignments that semantically represent “allocations” from the property with the same name in the target capability. · The allocation acts as a “capacity filter” for the target capability in the target node. When the requirement is resolved, a capability in a node is a valid target for the requirement relationship if for each property of the target capability, the sum of all existing allocations plus the current allocation is less_or_equal to the property value.
node_filter	no	node filter	The optional filter definition that TOSCA orchestrators will use to select a type-compatible target node that can fulfill the requirement at runtime.
count	no	non-negative integer	An optional keyname that sets the cardinality of the requirement assignment, that is how many relationships to be established from this requirement assignment specification. If not defined, the assumed count for an assignment is 1. Note that there can be multiple requirement assignments for a requirement with a specific symbolic name. · The sum of all count values of assignments for a requirement with a specific symbolic name must be within the count_range defined in the requirement definition. · Moreover, the sum of all count values of non-optional assignments for a requirement with a specific symbolic name must also be within the count_range defined in the requirement definition.
directives	no	list of string valid string values: “internal”, “external”	Describes if the fulfillment of this requirement assignment should use relationships with target nodes created within this template (“internal”) or should use target nodes created outside this template as available to the TOSCA environment ("external”) or if it should use a combination of the above. If so, the order of the strings in the list defines which directive should be attempted first. If no directives are defined, the default value is left to the particular implementation.
optional	no default: false	boolean	Describes if the fulfillment of this requirement assignment is optional (true) or not (false). If not specified, the requirement assignment must be fulfilled, i.e. the default value is false. Note also, that non-optional requirements have precedence, thus during a service deployment, the optional requirements for all nodes should be resolved only after the non-optional requirements for all nodes have been resolved.

The following is the list of recognized keynames for a TOSCA requirement assignment’s relationship keyname which is used when property assignments or interface assignments (for e.g. changing the implementation keyname or declare additional parameter definitions to be used as inputs/outputs) need to be provided:

Keyname	Mandatory	Type	Description
type	no	string	The optional keyname used to provide the name of the Relationship Type for the Requirement assignment’s relationship.
properties	no	map of property assignments	An optional keyname providing property assignments for the relationship.
interfaces	no	map of interface assignments	The optional keyname providing Interface assignments for the corresponding Interface definitions in the Relationship Type.

5.3.5.6.2 Grammar

Requirement assignments have one of the following grammars:

5.3.5.6.2.1 Short notation:

The following single-line grammar may be used if only a concrete Node Template for the target node needs to be declared in the requirement:

<requirement_name>: <node_template_name>

5.3.5.6.2.2 Extended notation:

The following grammar should be used if the requirement assignment needs to provide more information than just the Node Template name:

<requirement_name>:

capability: <capability_symbolic_name> | <capability_type_name>

node: <node_template_name> | <node_type_name>

relationship: <relationship_template_name> | <relationship_type_name>

node_filter: <node_filter_definition>

directives: <directives_list>

optional: <is_optional>

5.3.5.6.2.3 Extended grammar with Property Assignments and Interface Assignments for the relationship

The following additional multi-line grammar is provided for the relationship keyname in order to provide new Property assignments and Interface assignments for the created relationship of the declared Relationship.

<requirement_name>:

# Other keynames omitted for brevity

relationship:

type: <relationship_template_name> | <relationship_type_name>

properties: <property_assignments>

interfaces: <interface_assignments>

5.3.5.6.2.4 Extended grammar with capacity allocation

The following additional multi-line grammar is provided for capacity allocation in the target capability. The property assignments under the allocation keyname represent “allocations” from the property with the same name in the target capability.

· The sum of all the allocations for all requirements assignments for a property in a target capability cannot exceed the value of that property.

· This means that during the deployment time of a certain service template – as a certain requirement assignment is resolved – a capability in a node is a valid target if

· for each property of the target capability

· the sum of all existing allocations plus the current allocation is less_or_equal to the property value

· Of course, allocations can be defined only for integer, float, or scalar property types.

<requirement_name>:

# Other keynames omitted for brevity

allocation:

properties: <allocation_property_assignments>

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· requirement_name: represents the symbolic name of a requirement assignment as a string.

· capability_symbolic_name: represents the optional name of the Capability definition within the target Node Type or Node Template;

· if the capability in the Requirement definition was specified using the symbolic name of a capability definition in a target node type, then the capability keyname definition

· MUST remain unchanged in any subsequent refinements or during assignment.

· if the capability in the Requirement definition was specified using the name of a Capability Type, then the Capability definition referred here by the capability_symbolic_name must be of a type that is the same as or derived from the said Capability Type in the Requirement definition.

· capability_type_name: represents the optional name of a Capability Type definition within the target Node Type or Node Template this requirement needs to form a relationship with;

· may not be used if the capability in the Requirement definition was specified using the symbolic name of a capability definition in a target node type.

· otherwise the capability_type_name must be of a type that is the same as or derived from the type defined by the capability keyname in the Requirement definition.

· node_template_name: represents the optional name of a Node Template that contains the capability this requirement will be fulfilled by;

· in addition, the Node Type of the Node Template must be of a type that is the same as or derived from the type defined by the node keyname (if the node keyname is defined) in the Requirement definition,

· in addition, the Node Template must fulfill the node filter requirements of the node_filter (if a node_filter is defined) in the Requirement definition.

· node_type_name: represents the optional name of a Node Type that contains the capability this Requirement will be fulfilled by;

· in addition, the node_type_name must be of a type that is the same as or derived from the type defined by the node keyname (if the node keyname is defined) in the Requirement definition.

· relationship_template_name: represents the optional name of a Relationship Template to be used when relating the Requirement to the Capability in the target node.

· in addition, the Relationship Type of the Relationship Template must be of a type that is the same as or derived from the type defined by the relationship keyname (if the relationship keyname is defined) in the Requirement definition.

· relationship_type_name: represents the optional name of a Relationship Type that is compatible with the Capability Type in the target node; the TOSCA orchestrator will create a relationship of the Relationship Type when relating the Requirement to the Capability in the target node.

· in addition, the relationship_type_name must be of a type that is the same as or derived from the type defined by the relationship keyname (if the relationship keyname is defined) in the Requirement definition.

· property_assignments: within the relationship declaration, it represents the optional map of property assignments for the declared relationship.

· interface_assignments: represents the optional map of interface assignments for the declared relationship used to provide parameter assignments on inputs and outputs of interfaces, operations and notifications or changing the implementation definition.

· allocation_property_assignments: within the allocation declaration, it represents the optional map of property assignments that semantically represent “allocations” from the property with the same name in the target capability. Syntactically their form is the same as for a normal property assignments.

· The allocation acts as a “capacity filter” for the target capability in the target node. When the requirement is resolved, a capability in a node is a valid target for the requirement relationship if for each property of the target capability, the sum of all existing allocations plus the current allocation is less_or_equal to the property value.

· Intuitively, the sum of “allocations” from all the incoming relationships for a certain capability property cannot exceed the value of the property.

· If the “allocation” refers (via its name) to a property that does not exist in a capability, then that capability cannot be a valid target.

· Of course, allocations can be defined only for integer, float, or scalar property types.

· node_filter_definition: represents the optional node filter TOSCA orchestrators will use to fulfill the requirement for selecting a target node; if a node template was specified during requirement assignment, the TOSCA orchestrator verifies that the specified node template fulfills the node filter.

· this node_filter does not replace the node_filter definition in the Requirement definition, it is applied in addition to that.

· count_value: represents the optional cardinality of this requirement assignment, that is how many relationships are to be established from this requirement assignment specification.

· If count is not defined, the assumed count_value for an assignment is 1.

· Note that there can be multiple requirement assignments for a requirement with a specific symbolic name.

· The sum of all count values of assignments for a requirement with a specific symbolic name must be within the count_range defined in the requirement definition.

· Moreover, the sum of all count values of non-optional assignments for a requirement with a specific symbolic name must also be within the count_range defined in the requirement definition.

· directives: represents the optional list of strings that defines directives for this requirement assignment:

· valid values for the strings:

· “internal” – relationship created by this requirement assignment use target nodes created within this template.

· “external” – relationship created by this requirement assignment use target nodes created outside this template as available to the TOSCA environment.

· the order of the strings in the list defines which directive should be attempted first when fulfilling the assignment.

· If no directives are defined, the default value is left to the particular implementation.

· is_optional: represents the optional boolean value specifying if this requirement assignment is optional or not.

· If is_optional is false, the assignment MUST be fulfilled.

· If is_optional is true, the assignment SHOULD be fulfilled, but if not possible the service deployment is still considered valid.

· The default value for is_optional is false.

5.3.5.6.3 Notes

· If no explicit requirement assignment for a requirement with symbolic name is defined, a default requirement assignment with keynames: capability, node, relationship, node_filter having the same values as in the requirement definition in the corresponding node type is assumed.

· Additionally, the count_value is assumed to be equal to the min_count value of the requirement definition in the corresponding node type.

· For all explicit requirement assignments with the same symbolic name:

· the sum of the count_value must be within the count_range specified in the corresponding requirement definition.

· the sum of the count_value for all non-optional requirements assignments must be within the count_range specified in the corresponding requirement definition.

· Non-optional requirements have precedence, thus during a service deployment, the optional requirements for all nodes should be resolved only after the non-optional requirements for all nodes have been resolved.

5.3.5.6.4 Examples

Examples of uses for the extended requirement assignment grammar include:

· The need to allow runtime selection of the target node a Node Type rather than a Node Template. This may include use of the node_filter keyname to provide node and capability filtering information to find the “best match” of a node at runtime.

· The need to further specify the Relationship Template or Relationship Type to use when relating the source node’s requirement to the target node’s capability.

· The need to further specify the capability (symbolic) name or Capability Type in the target node to form a relationship between.

· The need to specify the number of counts the requirement assigns (when greater than 1).

5.3.5.6.4.1 Example 1 – Hosting requirement on a Node Type

A web application node template named ‘my_application_node_template’ of type WebApplication declares a requirement named ‘host’ that needs to be fulfilled by any node that derives from the node type WebServer.

# Example of a requirement fulfilled by a specific web server node template

node_templates:

my_application_node_template:

type: tosca.nodes.WebApplication

...

requirements:

- host:

node: tosca.nodes.WebServer

In this case, the node template’s type is WebApplication which already declares the Relationship Type HostedOn to use to relate to the target node and the Capability Type of Container to be the specific target of the requirement in the target node.

5.3.5.6.4.2 Example 2 - Requirement with Node Template and a custom Relationship Type

This example is similar to the previous example; however, the requirement named ‘database’ describes a requirement for a connection to a database endpoint (Endpoint.Database) Capability Type in a node template (my_database). However, the connection requires a custom Relationship Type (my.types.CustomDbConnection’) declared on the keyname ‘relationship’.

# Example of a (database) requirement that is fulfilled by a node template named

# “my_database”, but also requires a custom database connection relationship

my_application_node_template:

requirements:

- database:

node: my_database

capability: Endpoint.Database

relationship: my.types.CustomDbConnection

5.3.5.6.4.3 Example 3 - Requirement for a Compute node with additional selection criteria (filter)

This example shows how to extend an abstract ‘host’ requirement for a Compute node with a filter definition that further constrains TOSCA orchestrators to include additional properties and capabilities on the target node when fulfilling the requirement.

node_templates:

mysql:

type: tosca.nodes.DBMS.MySQL

properties:

# omitted here for brevity

requirements:

- host:

node: tosca.nodes.Compute

node_filter:

capabilities:

- host:

properties:

- num_cpus: { in_range: [ 1, 4 ] }

- mem_size: { greater_or_equal: 512 MB }

- os:

properties:

- architecture: { equal: x86_64 }

- type: { equal: linux }

- distribution: { equal: ubuntu }

- mytypes.capabilities.compute.encryption:

properties:

- algorithm: { equal: aes }

- keylength: { valid_values: [ 128, 256 ] }

5.3.5.6.4.4 Example 4 - Requirement assignment for definition with count_range: [2,2]

This example shows how the assignments can look if the Requirement definition has the count_range different from the default [1,1]. In this case the redundant_database requirement has count_range: [2,2]. The Requirement definition is not presented here for brevity. In the Requirement assignment we use the short notation. Note that the count keyname for each assignment is not declared (i.e. the default value of 1 is used) and that the sum of the count values of both assignments is 2 which is in the range of [2,2] as specified in the Requirement definition.

# Example of a (redundant_database) requirement that is fulfilled by

# two node templates named “database1” and “database1

my_critical_application_node_template:

requirements:

- redundant_database: database1

- redundant_database: database2

5.3.5.6.4.5 Example 5 - Requirement assignment for definition with capacity allocation

This example shows how the assignment can look if the requirement is assuming a “capacity allocation” on the properties of the target capability (in this case a capability of type “tosca.capabilities.Compute”). When this requirement is resolved, a node is a valid target and a relationship is created only if both the capacity allocations for num_cpu and mem_size are fulfilled, that is the sum of the capacity allocations from all established relationships + current allocation is less or equal to the value of each respective property in the target capability.

So assuming that num_cpu property in the target capability of a candidate node has value 4 and the sum of capacity allocations of the other resolved requirements to that capability for num_cpu is 1 then then there is enough “remaining capacity” (4 – 1 = 3) to fulfill the current allocation (2), and a relationship to that node is established. Another node with num_cpu with value 2 could not be a valid target since 1 (existing) + 2 (current) = 3, and that is larger than the property value which is 2. Of course, similar calculations must be done for the mem_size allocation.

# Example of a (redundant_database) requirement that is fulfilled by

# two node templates named “database1” and “database1

my_critical_application_node_template:

requirements:

- host:

node: tosca.nodes.Compute

allocation:

properties:

num_cpu: 2

mem_size: 128 MB

5.3.5.7 Node Filter definition

5.3.5.7.1 Grammar

Node filters are defines using condition clauses as shown in the following grammar:

node_filter: <condition_clause>

In the above grammar, the condition_clause represents a Boolean expression that will be used to select (filter) TOSCA nodes that are valid candidates for fulfilling the requirement that defines the node filter. TOSCA orchestrators use node filters are follows:

· Orchestrators select an initial set of target node candidates based on the target capability type and/or the target node type specified in the requirement definition.

· A node in this initial set is a valid target node candidate if—when that node is used as the target node for the requirement—the node filter condition clause evaluates to True.

· Note that the context within which the node filter must be evaluated is the relationship that is established to the target node as a result of fulfilling the requirement. Specifically, this means that the SELF keyword in any TOSCA Path expressions refer to that relationship.

5.3.5.7.2 Example

The following example is a filter that will be used to select a Compute node based upon the values of its defined capabilities. Specifically, this filter will select Compute nodes that support a specific range of CPUs (i.e., num_cpus value between 1 and 4) and memory size (i.e., mem_size of 2 or greater) from its declared “host” capability.

my_node_template:

# other details omitted for brevity

requirements:

- host:

node_filter:

$and:

- $in_range:

- $get_property: [ SELF, CAPABILITY, num_cpus ]

- [ 1, 4 ]

- $greater_or_equal:

- $get_property: [ SELF, CAPABILITY, mem_size ]

- 512 MB

5.3.6 Interfaces

5.3.6.1 Interface Type

An Interface Type is a reusable entity that describes a set of operations that can be used to interact with or to manage a node or relationship in a TOSCA topology.

5.3.6.1.1 Keynames

The Interface Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Interface Type has the following recognized keynames:

Keyname	Mandatory	Type	Description
inputs	no	map of parameter definitions	The optional map of input parameter definitions available to all operations defined for this interface.
operations	no	map of operation definitions	The optional map of operations defined for this interface.
notifications	no	map of notification definitions	The optional map of notifications defined for this interface.

5.3.6.1.2 Grammar

Interface Types have following grammar:

<interface_type_name>:

derived_from: <parent_interface_type_name>

version: <version_number>

metadata:

description: <interface_description>

inputs:

<Error! Reference source not found.Error! Reference source not found.notification_definitions>

operations:

<operation_definitions>

notifications:

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· interface_type_name: represents the mandatory name of the interface as a string.

· parent_interface_type_name: represents the name of the Interface Type this Interface Type definition derives from (i.e. its “parent” type).

· version_number: represents the optional TOSCA version number for the Interface Type.

· interface_description: represents the optional description for the Interface Type.

· parameter_definitions: represents the optional map of parameter definitions which the TOSCA orchestrator will make available (i.e., or pass) to all implementation artifacts for operations declared on the interface during their execution.

· operation_definitions: represents the optional map of one or more operation definitions.

· notification_definitions: represents the optional map of one or more notification definitions.

5.3.6.1.3 Derivation rules

During Interface Type derivation the keyname definitions follow these rules:

· inputs: existing parameter definitions may be refined; new parameter definitions may be added.

· operations: existing operation definitions may be refined; new operation definitions may be added.

· notifications: existing notification definitions may be refined; new notification definitions may be added.

5.3.6.1.4 Example

The following example shows a custom interface used to define multiple configure operations.

mycompany.mytypes.myinterfaces.MyConfigure:

derived_from: tosca.interfaces.relationship.Root

description: My custom configure Interface Type

inputs:

mode:

type: string

operations:

pre_configure_service:

description: pre-configure operation for my service

post_configure_service:

description: post-configure operation for my service

5.3.6.1.5 Additional Requirements

· Interface Types MUST NOT include any implementations for defined operations or notifications; that is, the implementation keyname is invalid in this context.

5.3.6.2 Interface definition

An Interface definition defines an interface (containing operations and notifications definitions) that can be associated with (i.e. defined within) a Node or Relationship Type definition (including Interface definitions in Requirements definitions). An Interface definition may be refined in subsequent Node or Relationship Type derivations.

5.3.6.2.1 Keynames

The following is the list of recognized keynames for a TOSCA interface definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory name of the Interface Type this interface definition is based upon.
description	no	string	The optional description for this interface definition.
inputs	no	map of parameter definitions and refinements	The optional map of input parameter refinements and new input parameter definitions available to all operations defined for this interface (the input parameters to be refined have been defined in the Interface Type definition).
operations	no	map of operation refinements	The optional map of operations refinements for this interface. The referred operations must have been defined in the Interface Type definition.
notifications	no	map of notification refinements	The optional map of notifications refinements for this interface. The referred operations must have been defined in the Interface Type definition.

5.3.6.2.2 Grammar

Interface definitions in Node or Relationship Type definitions have the following grammar:

<interface_definition_name>:

type: <interface_type_name>

description: <interface_description>

inputs:

<parameter_definitions_and_refinements>

operations:

<operation_refinements>

notifications:

<Error! Reference source not found.Error! Reference source not found.notification_refinements>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· interface_definition_name: represents the mandatory symbolic name of the interface as a string.

· interface_type_name: represents the mandatory name of the Interface Type for the interface definition.

· interface_description: represents the optional description string for the interface.

· parameter_definitions_and_refinements: represents the optional map of input parameters which the TOSCA orchestrator will make available (i.e. pass) to all defined operations. This means these parameters and their values will be accessible to the implementation artifacts (e.g., scripts) associated to each operation during their execution

· the map represents a mix of parameter refinements (for parameters already defined in the Interface Type) and new parameter definitions.

· with the new parameter definitions, we can flexibly add new parameters when changing the implementation of operations and notifications during refinements or assignments.

· operation_refinements: represents the optional map of operation definition refinements for this interface; the referred operations must have been previously defined in the Interface Type.

· notification_refinements: represents the optional map of notification definition refinements for this interface; the referred notifications must have been previously defined in the Interface Type.

5.3.6.2.3 Refinement rules

An interface definition within a node or relationship type (including interface definitions in requirements definitions) uses the following definition refinement rules when the containing entity type is derived:

· type: must be derived from (or the same as) the type in the interface definition in the parent entity type definition.

· description: a new definition is unrestricted and will overwrite the one inherited from the interface definition in the parent entity type definition.

· inputs: not applicable to the definitions in the parent entity type but to the definitions in the interface type referred by the type keyname (see grammar above for the rules).

· operations: not applicable to the definitions in the parent entity type but to the definitions in the interface type referred by the type keyname (see grammar above for the rules).

· notifications: not applicable to the definitions in the parent entity type but to the definitions in the interface type referred by the type keyname (see grammar above for the rules).

5.3.6.3 Interface assignment

An Interface assignment is used to specify assignments for the inputs, operations and notifications defined in the Interface. Interface assignments may be used within a Node or Relationship Template definition (including when Interface assignments are referenced as part of a Requirement assignment in a Node Template).

5.3.6.3.1 Keynames

The following is the list of recognized keynames for a TOSCA interface definition:

Keyname	Mandatory	Type	Description
inputs	no	map of parameter value assignments	The optional map of input parameter assignments. Template authors MAY provide parameter assignments for interface inputs that are not defined in their corresponding Interface Type.
operations	no	map of operation assignments	The optional map of operations assignments specified for this interface.
notifications	no	map of notification assignments	The optional map of notifications assignments specified for this interface.

5.3.6.3.2 Grammar

Interface assignments have the following grammar:

<interface_definition_name>:

inputs:

<parameter_value_assignments>

operations:

<operation_assignments>

notifications:

<notification_assignments>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· interface_definition_name: represents the mandatory symbolic name of the interface as a string.

· parameter_value_assignments: represents the optional map of parameter value assignments for passing input parameter values to all interface operations

· template authors MAY provide new parameter assignments for interface inputs that are not defined in the Interface definition.

· operation_assignments: represents the optional map of operation assignments for operations defined in the Interface definition.

· notification_assignments: represents the optional map of notification assignments for notifications defined in the Interface definition.

5.3.6.4 Operation definition

An operation definition defines a function or procedure to which an operation implementation can be bound.

A new operation definition may be declared only inside interface type definitions (this is the only place where new operations can be defined). In interface type, node type, or relationship type definitions (including operation definitions as part of a requirement definition) we may further refine operations already defined in an interface type.

An operation definition or refinement inside an interface type definition may not contain an operation implementation definition and it may not contain an attribute mapping as part of its output definition (as both these keynames are node/relationship specific).

5.3.6.4.1 Keynames

The following is the list of recognized keynames for a TOSCA operation definition (including definition refinement)

Keyname	Mandatory	Type	Description
description	no	string	The optional description string for the associated operation.
implementation	no	operation implementation definition	The optional definition of the operation implementation. May not be used in an interface type definition (i.e. where an operation is initially defined), but only during refinements.
inputs	no	map of parameter definitions	The optional map of parameter definitions for operation input values.
outputs	no	map of parameter definitions	The optional map of parameter definitions for operation output values. Only as part of node and relationship type definitions, the output definitions may include mappings onto attributes of the node or relationship type that contains the definition.

5.3.6.4.2 Grammar

Operation definitions have the following grammar:

5.3.6.4.2.1 Short notation

The following single-line grammar may be used when the operation’s implementation definition is the only keyname that is needed, and when the operation implementation definition itself can be specified using a single line grammar:

<operation_name>: <operation_implementation_definition>

5.3.6.4.2.2 Extended notation

The following multi-line grammar may be used when additional information about the operation is needed:

<operation_name>:

description: <operation_description>

implementation: <operation_implementation_definition>

inputs:

outputs:

<parameter_value_assignments>

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· operation_name: represents the mandatory symbolic name of the operation as a string.

· operation_description: represents the optional description string for the operation.

· operation_implementation_definition: represents the optional specification of the operation’s implementation).

· parameter_definitions: represents the optional map of parameter definitions which the TOSCA orchestrator will make available as inputs to or receive as outputs from the corresponding implementation artifact during its execution.

5.3.6.4.3 Refinement rules

An operation definition within an interface, node, or relationship type (including interface definitions in requirements definitions) uses the following refinement rules when the containing entity type is derived:

· description: a new definition is unrestricted and will overwrite the one inherited from the operation definition in the parent entity type definition.

· implementation: a new definition is unrestricted and will overwrite the one inherited from the operation definition in the parent entity type definition.

· inputs: parameter definitions inherited from the parent entity type may be refined; new parameter definitions may be added.

· outputs: parameter definitions inherited from the parent entity type may be refined; new parameter definitions may be added.

5.3.6.4.4 Additional requirements

· The definition of implementation is not allowed in interface type definitions (as a node or node type context is missing at that point). Thus, it can be part only of an operation refinement and not of the original operation definition.

· The default refinement behavior for implementations SHALL be overwrite. That is, implementation definitions in a derived type overwrite any defined in its parent type.

· Defining a fixed value for an input parameter (as part of its definition) may only use a parameter_value_expression that is meaningful in the scope of the context. For example, within the context of an Interface Type definition functions such as get_propery or get_attribute cannot be used. Within the context of Node or Relationship Type definitions, these functions may only reference properties and attributes accessible starting from SELF (i.e. accessing a node by symbolic name is not meaningful).

· Defining attribute mapping as part of the output parameter definition is not allowed in interface type definitions (i.e. as part of operation definitions). It is allowed only in node and relationship type definitions (as part of operation refinements) and has to be meaningful in the scope of the context (e.g. SELF).

· Implementation artifact file names (e.g., script filenames) may include file directory path names that are relative to the TOSCA file file itself when packaged within a TOSCA Cloud Service Archive (CSAR) file.

5.3.6.4.5 Examples

5.3.6.4.5.1 Single-line example

interfaces:

Standard:

start: scripts/start_server.sh

5.3.6.4.5.2 Multi-line example with shorthand implementation definitions

interfaces:

Configure:

pre_configure_source:

implementation:

primary: scripts/pre_configure_source.sh

dependencies:

- scripts/setup.sh

- binaries/library.rpm

- scripts/register.py

5.3.6.4.5.3 Multi-line example with extended implementation definitions

interfaces:

Configure:

pre_configure_source:

implementation:

primary:

file: scripts/pre_configure_source.sh

type: tosca.artifacts.Implementation.Bash

repository: my_service_catalog

dependencies:

- file : scripts/setup.sh

type : tosca.artifacts.Implementation.Bash

repository : my_service_catalog

5.3.6.5 Operation assignment

An operation assignment may be used to assign values for input parameters, specify attribute mappings for output parameters, and define/redefine the implementation definition of an already defined operation in the interface definition. An operation assignment may be used inside interface assignments inside node template or relationship template definitions (this includes when operation assignments are part of a requirement assignment in a node template).

An operation assignment may add or change the implementation and description definition of the operation. Assigning a value to an input parameter that had a fixed value specified during operation definition or refinement is not allowed. Providing an attribute mapping for an output parameter that was mapped during an operation refinement is also not allowed.

Note also that in the operation assignment we can use inputs and outputs that have not been previously defined in the operation definition. This is equivalent to an ad-hoc definition of a parameter, where the type is inferred from the assigned value (for input parameters) or from the attribute to map to (for output parameters).

5.3.6.5.1 Keynames

The following is the list of recognized keynames for an operation assignment:

Keyname	Mandatory	Type	Description
implementation	no	operation implementation definition	The optional definition of the operation implementation. Overrides implementation provided at operation definition.
inputs	no	map of parameter value assignments	The optional map of parameter value assignments for assigning values to operation inputs.
outputs	no	map of parameter mapping assignments	The optional map of parameter mapping assignments that specify how operation outputs are mapped onto attributes of the node or relationship that contains the operation definition.

5.3.6.5.2 Grammar

Operation assignments have the following grammar:

5.3.6.5.2.1 Short notation

<operation_name>: <operation_implementation_definition>

5.3.6.5.2.2 Extended notation

The following multi-line grammar may be used in Node or Relationship Template definitions when additional information about the operation is needed:

<operation_name>:

implementation: <operation_implementation_definition>

inputs:

outputs:

<parameter_mapping_assignments>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· operation_name: represents the mandatory symbolic name of the operation as a string.

· operation_implementation_definition: represents the optional specification of the operation’s implementation

· the implementation declared here overrides the implementation provided at operation definition.

· parameter_value_assignments: represents the optional map of parameter value assignments for passing input parameter values to operations.

· assignments for operation inputs that are not defined in the operation definition may be provided

· parameter_mapping_assignments: represents the optional map of parameter mapping assignments that consists of named output values returned by operation implementations (i.e. artifacts) and associated attributes into which this output value must be stored

· assignments for operation outputs that are not defined in the operation definition may be provided.

5.3.6.5.3 Additional requirements

· The behavior for implementation of operations SHALL be override. That is, implementation definitions assigned in an operation assignment override any defined in the operation definition.

· Template authors MAY provide parameter assignments for operation inputs that are not defined in the operation definition.

· Template authors MAY provide attribute mappings for operation outputs that are not defined in the operation definition.

5.3.6.5.4 Examples

TBD

5.3.6.6 Notification definition

A notification definition defines an asynchronous notification or incoming message that can be associated with an interface. The notification is a way for an external event to be transmitted to the TOSCA orchestrator. Values can be sent with a notification as notification outputs and we can map them to node/relationship attributes similarly to the way operation outputs are mapped to attributes. The artifact that the orchestrator is registering with in order to receive the notification is specified using the implementation keyname in a similar way to operations. As opposed to an operation definition, a notification definition does not include an inputs keyname since notifications are not invoked from the orchestrator.

When the notification is received an event is generated within the orchestrator that can be associated to triggers in policies to call other internal operations and workflows. The notification name (using the <interface_name>.<notification_name> notation) itself identifies the event type that is generated and can be textually used when defining the associated triggers.

A notification definition may be used only inside interface type definitions (this is the only place where new notifications can be defined). Inside interface type, node type, or relationship type definitions (including notifications definitions as part of a requirement definition) we may further refine a notification already defined in the interface type.

A notification definition or refinement inside an interface type definition may not contain a notification implementation definition and it may not contain an attribute mapping as part of its output definition (as both these keynames are node/relationship specific).

5.3.6.6.1 Keynames

The following is the list of recognized keynames for a TOSCA notification definition:

Keyname	Mandatory	Type	Description
description	no	string	The optional description string for the associated notification.
implementation	no	notification implementation definition	The optional definition of the notification implementation.
outputs	no	map of parameter definitions	The optional map of parameter definitions that specify notification output values. Only as part of node and relationship type definitions, the output definitions may include their mappings onto attributes of the node type or relationship type that contains the definition.

5.3.6.6.2 Grammar

Notification definitions have the following grammar:

5.3.6.6.2.1 Short notation

The following single-line grammar may be used when the notification’s implementation definition is the only keyname that is needed and when the notification implementation definition itself can be specified using a single line grammar:

<notification_name>: <notification_implementation_definition>

5.3.6.6.2.2 Extended notation

The following multi-line grammar may be used when additional information about the notification is needed:

<notification_name>:

description: <notification_description>

implementation: <notification_implementation_definition>

outputs:

notification implementation definition

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· notification_name: represents the mandatory symbolic name of the notification as a string.

· notification_description: represents the optional description string for the notification.

· notification_implementation_definition: represents the optional specification of the notification implementation (i.e. the external artifact that may send notifications)

· parameter_definitions: represents the optional map of parameter definitions for parameters that the orchestrator will receive as outputs from the corresponding implementation artifact during its execution.

5.3.6.6.3 Refinement rules

A notification definition within an interface, node, or relationship type (including interface definitions in requirements definitions) uses the following refinement rules when the containing entity type is derived:

· description: a new definition is unrestricted and will overwrite the one inherited from the notification definition in the parent entity type definition.

· implementation: a new definition is unrestricted and will overwrite the one inherited from the notification definition in the parent entity type definition.

· outputs: parameter definitions inherited from the parent entity type may be refined; new parameter definitions may be added.

5.3.6.6.4 Additional requirements

· The definition of implementation is not allowed in interface type definitions (as a node or node type context is missing at that point). Thus, it can be part only of a notification refinement and not of the original notification definition.

· The default sub-classing (i.e. refinement) behavior for implementations of notifications SHALL be overwrite. That is, implementation artifacts definitions in a derived type overwrite any defined in its parent type.

· Defining a mapping in an output parameter definition may use an attribute target that is meaningful in the scope of the context. Within the context of Node or Relationship Type definitions these functions may only reference attributes starting from the same node (i.e. SELF).

5.3.6.6.5 Examples

TBD

5.3.6.7 Notification assignment

A notification assignment may be used to specify attribute mappings for output parameters and to define/redefine the implementation definition and description definition of an already defined notification in the interface definition. A notification assignment may be used inside interface assignments inside node or relationship template definitions (this includes when notification assignments are part of a requirement assignment in a node template).

Providing an attribute mapping for an output parameter that was mapped during a previous refinement is not allowed. Note also that in the notification assignment we can use outputs that have not been previously defined in the operation definition. This is equivalent to an ad-hoc definition of an output parameter, where the type is inferred from the attribute to map to.

5.3.6.7.1 Keynames

The following is the list of recognized keynames for a TOSCA notification assignment:

Keyname

Mandatory

Type

Description

implementation

The optional definition of the notification implementation. Overrides implementation provided at notification definition.

outputs

map of parameter

mapping assignments

The optional map of parameter mapping assignments that specify how notification outputs values are mapped onto attributes of the node or relationship type that contains the notification definition.

5.3.6.7.2 Grammar

Notification assignments have the following grammar:

5.3.6.7.2.1 Short notation

The following single-line grammar may be used when the notification’s implementation definition is the only keyname that is needed, and when the notification implementation definition itself can be specified using a single line grammar:

<notification_name>: <notification_implementation_definition>

5.3.6.7.2.2 Extended notation

The following multi-line grammar may be used in Node or Relationship Template definitions when additional information about the notification is needed:

<notification_name>:

implementation: <notification_implementation_definition>

outputs:

<parameter_mapping_assignments>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· notification_name: represents the mandatory symbolic name of the notification as a string.

· notification_implementation_definition: represents the optional specification of the notification implementation (i.e. the external artifact that is may send notifications)

· the implementation declared here overrides the implementation provided at notification definition.

· parameter_mapping_assignments: represents the optional map of parameter_mapping_assignments that consists of named output values returned by operation implementations (i.e. artifacts) and associated attributes into which this output value must be stored

· assignments for notification outputs that are not defined in the operation definition may be provided.

5.3.6.7.3 Additional requirements

· The behavior for implementation of notifications SHALL be override. That is, implementation definitions assigned in a notification assignment override any defined in the notification definition.

· Template authors MAY provide attribute mappings for notification outputs that are not defined in the corresponding notification definition.

5.3.6.7.4 Examples

TBD

5.3.6.8 Operation and notification implementation definition

An operation implementation definition specifies one or more artifacts (e.g. scripts) to be used as the implementation for an operation in an interface.

A notification implementation definition specifies one or more artifacts to be used by the orchestrator to subscribe and receive a particular notification (i.e. the artifact implements the notification).

The operation implementation definition and the notification implementation definition share the same keynames and grammar, with the exception of the timeout keyname that has no meaning in the context of a notification implementation definition and should not be used in such.

5.3.6.8.1 Keynames

The following is the list of recognized keynames for an operation implementation definition or a notification implementation definition:

Keyname	Mandatory	Type	Description
primary	no	artifact definition	The optional implementation artifact (i.e., the primary script file within a TOSCA CSAR file).
dependencies	no	list of artifact definition	The optional list of one or more dependent or secondary implementation artifacts which are referenced by the primary implementation artifact (e.g., a library the script installs or a secondary script).
timeout	no	integer	Timeout value in seconds. Has no meaning and should not be used within a notification implementation definition.

5.3.6.8.2 Grammar

Operation implementation definitions and notification implementation definitions have the following grammar:

5.3.6.8.2.1 Short notation for use with single artifact

The following single-line grammar may be used when only a primary implementation artifact name is needed:

implementation: <primary_artifact_name>

This notation can be used when the primary artifact name uniquely identifies the artifact, either because it refers to an artifact specified in the artifacts section of a type or template, or because it represents the name of a script in the CSAR file that contains the definition.

5.3.6.8.2.2 Short notation for use with multiple artifacts

The following multi-line short-hand grammar may be used when multiple artifacts are needed, but each of the artifacts can be uniquely identified by name as before:

implementation:

primary: <primary_artifact_name>

dependencies:

- <list_of_dependent_artifact_names>

timeout: 60

5.3.6.8.2.3 Extended notation for use with single artifact

The following multi-line grammar may be used in Node or Relationship Type or Template definitions when only a single artifact is used but additional information about the primary artifact is needed (e.g. to specify the repository from which to obtain the artifact, or to specify the artifact type when it cannot be derived from the artifact file extension):

implementation:

primary:

<primary_artifact_definition>

timeout: 100

5.3.6.8.2.4 Extended notation for use with multiple artifacts

The following multi-line grammar may be used in Node or Relationship Type or Template definitions when there are multiple artifacts that may be needed for the operation to be implemented and additional information about each of the artifacts is required:

implementation:

primary:

<primary_artifact_definition>

dependencies:

- <list_of_dependent_artifact definitions>

timeout: 120

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· primary_artifact_name: represents the optional name (string) of an implementation artifact definition (defined elsewhere), or the direct name of an implementation artifact’s relative filename (e.g., a service template-relative, path-inclusive filename or absolute file location using a URL).

· primary_artifact_definition: represents a full inline definition of an implementation artifact.

· list_of_dependent_artifact_names: represents the optional ordered list of one or more dependent or secondary implementation artifact names (as strings) which are referenced by the primary implementation artifact. TOSCA orchestrators will copy these files to the same location as the primary artifact on the target node so as to make them accessible to the primary implementation artifact when it is executed.

· list_of_dependent_artifact_definitions: represents the ordered list of one or more inline definitions of dependent or secondary implementation artifacts. TOSCA orchestrators will copy these artifacts to the same location as the primary artifact on the target node so as to make them accessible to the primary implementation artifact when it is executed.

5.3.7 Artifacts

5.3.7.1 Artifact Type

An Artifact Type is a reusable entity that defines the type of one or more files that are used to define implementation or deployment artifacts that are referenced by nodes or relationships.

5.3.7.1.1 Keynames

The Artifact Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Artifact Type has the following recognized keynames:

Keyname	Mandatory	Type	Description
mime_type	no	string	The optional mime type property for the Artifact Type.
file_ext	no	list of string	The optional file extension property for the Artifact Type.
properties	no	map of property definitions	An optional map of property definitions for the Artifact Type.

5.3.7.1.2 Grammar

Artifact Types have following grammar:

<artifact_type_name>:

derived_from: <parent_artifact_type_name>

version: <version_number>

metadata:

description: <artifact_description>

mime_type: <mime_type_string>

file_ext: [ <file_extensions> ]

properties:

file: http://10.10.86.141/images/Juniper_vSRX_15.1x49_D80_preconfigured.qcow2

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· artifact_type_name: represents the name of the Artifact Type being declared as a string.

· parent_artifact_type_name: represents the name of the Artifact Type this Artifact Type definition derives from (i.e., its “parent” type).

· version_number: represents the optional TOSCA version number for the Artifact Type.

· artifact_description: represents the optional description string for the Artifact Type.

· mime_type_string: represents the optional Multipurpose Internet Mail Extensions (MIME) standard string value that describes the file contents for this type of Artifact Type as a string.

· file_extensions: represents the optional list of one or more recognized file extensions for this type of artifact type as strings.

· property_definitions: represents the optional map of property definitions for the artifact type.

5.3.7.1.3 Derivation rules

During Artifact Type derivation the keyname definitions follow these rules:

· mime_type: a new definition is unrestricted and will overwrite the one inherited from the parent type.

· file_ext: a new definition is unrestricted and will overwrite the one inherited from the parent type.

· properties: existing property definitions may be refined; new property definitions may be added.

5.3.7.1.4 Examples

my_artifact_type:

description: Java Archive artifact type

derived_from: tosca.artifact.Root

mime_type: application/java-archive

file_ext: [ jar ]

properties:

id:

description: Identifier of the jar

type: string

required: true

creator:

description: Vendor of the java implementation on which the jar is based

type: string

required: false

5.3.7.1.5 Additional Requirements

· The ‘mime_type’ keyname is meant to have values that are Apache mime types such as those defined here: http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

5.3.7.1.6 Notes

Information about artifacts can be broadly classified in two categories that serve different purposes:

· Selection of artifact processor. This category includes informational elements such as artifact version, checksum, checksum algorithm etc. and s used by TOSCA Orchestrator to select the correct artifact processor for the artifact. These informational elements are captured in TOSCA as keywords for the artifact.

· Properties processed by artifact processor. Some properties are not processed by the Orchestrator but passed on to the artifact processor to assist with proper processing of the artifact. These informational elements are described through artifact properties.

5.3.7.2 Artifact definition

An artifact definition defines a named, typed file that can be associated with Node Type or Node Template and used by orchestration engine to facilitate deployment and implementation of interface operations.

5.3.7.2.1 Keynames

The following is the list of recognized keynames for a TOSCA artifact definition when using the extended notation:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory artifact type for the artifact definition.
file	yes	string	The mandatory URI string (relative or absolute) which can be used to locate the artifact’s file.
repository	no	string	The optional name of the repository definition which contains the location of the external repository that contains the artifact. The artifact is expected to be referenceable by its file URI within the repository.
description	no	string	The optional description for the artifact definition.
deploy_path	no	string	The file path the associated file will be deployed on within the target node’s container.
artifact_version	no	string	The version of this artifact. One use of this artifact_version is to declare the particular version of this artifact type, in addition to its mime_type (that is declared in the artifact type definition). Together with the mime_type it may be used to select a particular artifact processor for this artifact. For example, a python interpreter that can interpret python version 2.7.0.
checksum	no	string	The checksum used to validate the integrity of the artifact.
checksum_algorithm	no	string	Algorithm used to calculate the artifact checksum (e.g. MD5, SHA [Ref]). Shall be specified if checksum is specified for an artifact.
properties	no	map of property assignments	The optional map of property assignments associated with the artifact.

5.3.7.2.2 Grammar

Artifact definitions have one of the following grammars:

5.3.7.2.2.1 Short notation

The following single-line grammar may be used when the artifact’s type and mime type can be inferred from the file URI:

<artifact_name>: <artifact_file_URI>

5.3.7.2.2.2 Extended notation:

The following multi-line grammar may be used when the artifact’s definition’s type and mime type need to be explicitly declared:

<artifact_name>:

description: <artifact_description>

type: <artifact_type_name>

file: <artifact_file_URI>

repository: <artifact_repository_name>

deploy_path: <file_deployment_path>

version: <artifact _version>

checksum: <artifact_checksum>

checksum_algorithm: <artifact_checksum_algorithm>

properties: <property assignments>

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· artifact_name: represents the mandatory symbolic name of the artifact as a string.

· artifact_description: represents the optional description for the artifact.

· artifact_type_name: represents the mandatory artifact type the artifact definition is based upon.

· artifact_file_URI: represents the mandatory URI string (relative or absolute) which can be used to locate the artifact’s file.

· artifact_repository_name: represents the optional name of the repository definition to use to retrieve the associated artifact (file) from.

· file_deployement_path: represents the optional path the artifact_file_URI will be copied into within the target node’s container.

· artifact_version: represents the version of artifact

· artifact_checksum: represents the checksum of the Artifact

· artifact_checksum_algorithm:represents the algorithm for verifying the checksum. Shall be specified if checksum is specified

· properties: represents an optional map of property assignments associated with the artifact

5.3.7.2.3 Refinement rules

Artifact definitions represent specific external entities. If a certain artifact definition cannot be reused as is, then it may be completely redefined.

· If an artifact is redefined, the symbolic name from the definition in the parent node type is reused, but no keyname definitions are inherited from the definition in the parent node type, and the new definition completely overwrites the definition in the parent.

· If the artifact is not redefined the complete definition is inherited from the parent node type.

5.3.7.2.4 Examples

The following represents an artifact definition:

my_file_artifact: ../my_apps_files/operation_artifact.txt

The following example represents an artifact definition with property assignments:

artifacts:

sw_image:

description: Image for virtual machine

type: tosca.artifacts.Deployment.Image.VM

checksum: ba411cafee2f0f702572369da0b765e2

version: 3.2

checksum_algorithm: MD5

properties:

container_format: BARE

disk_format: QCOW2

min_disk: 1 GB

size: 649 MB

5.4 Properties, Attributes, and Parameters

This section presents handling data in TOSCA via properties, attributes, and parameters.

The type of the values they contain can be divided into built-in primitive types, special types that are extensions of the primitive types, and collection types, as well as user-defined refinements of these and complex data types that can themselves be defined in TOSCA profiles and the TOSCA file.

Values can also be evaluated from expressions based on TOSCA functions. [See XXX]

The following table summarizes the built-in types. All of these type names are reserved and cannot be used for custom data types. Note, however, that it is possible to derive a custom data type from a primitive type in order to add validation clauses.

Primitive Types: (section 4.4.1)

· string

· integer

· float

· boolean

· bytes

· nil

Special Types: (section 4.4.2)

· range

· timestamp

· scalar-unit.size

· scalar-unit.time

· scalar-unit.frequency

· scalar-unit.bitrate

Collection Types: (section 4.4.3)

· list

· map

Notes that were originally in the metadata section:

Important notes:

YAML map keys can be any value, not just strings. TOSCA metadata grammar allows that full YAML expressiveness and does not add additional restrictions beyond requiring correct YAM syntax.

YAML does not specify the bit width of integers and floats but suggests that 32 bits should be acceptable.

Users should be careful about the difference between parsing floats and integers. If they explicitly want a float, they should add ".0".

Users should be careful with version strings being parsed as floats. E.g., "3.2" is a float but "3.2.1" is a string,

5.4.1 Primitive Types

The TOSCA primitive types have been specified to allow for the broadest possible support for implementations.

Guiding principles:

1. Because TOSCA files are written in YAML they must support all the literal primitives in YAML. However, it is important to also allow for consistency of representation of external data, e.g. service template inputs and outputs, property and attribute values stored in a database, etc.

2. Adherence to 64-bit precision to ensure portability of numeric data.

3. TOSCA parsers shall not automatically convert between primitive types. Thus, care should be taken to use the correct YAML notation for that type. Details will be provided below.

5.4.1.1 string

An array of Unicode runes. (For storing an arbitrary array of bytes see the “bytes” type, below.)

Because we adhere to 64-bit precision, the minimum length of strings is 0 and the maximum length of strings is 4,294,967,295.

TOSCA does not specify a character encoding. For example, a string could be encoded as UTF-8 or UTF-16. The exact encoding used depends on the implementation.

Be aware that YAML parsers will attempt to parse unquoted character sequences as other types (booleans, integers, floats, etc.) before falling back to the !!string type. For example, the unquoted sequence “0.1” would be interpreted as a YAML !!float. Likewise, the unquoted sequence “nan” would become the !!float value of not-a-number. However, in TOSCA a string value must be specified in YAML as a !!string.

A TOSCA parser shall not attempt to convert other primitive types to strings if a string type is required. This requirement is necessary for ensuring portability, because there is no single, standard representation for the other types, e.g. scientific notations for decimals, the words “true” vs. “True” for booleans, etc. In YAML users should thus add quotation marks around literal strings that YAML would otherwise interpret as other types.

This following example would be invalid if there were no quotation marks around “0.1”:

node_types:

Node:

properties:

name:

type: string

service_template:

node_templates:

node:

type: Node

properties:

5.4.1.1.1 Notes:

1. There are various ways to specify literal !!string data in YAML for handling indentation, newlines, as well as convenient support for line folding for multiline strings. All may be used in TOSCA. A TOSCA parser shall not modify the YAML string in any way, e.g. no trimming of whitespace or newlines. [YAML 1.2 chapter 6]

2. The TOSCA functions “concat”, “join”, “token”, “length”, “min_length”, “max_length”, and “pattern” are all Unicode-aware. Specifically, the length of a string is a count of its runes, not the length of the byte array, which may differ according to the encoding. [See XXX]

3. The TOSCA functions that check for equality, “equal” and “valid_values”, should work regardless of the Unicode encoding. For example, comparing two strings that are “!”, one of which is in UTF-8 and is encoded as “0x21”, the other which is in UTF-16 and is encoded as “0x0021”, would result in equality. For simplicity, implementations may standardize on a single encoding, e.g., UTF-8, and convert all other encodings to it. [See XXX]

4. Relatedly, although in YAML 1.2 a !!string is already defined as a Unicode sequence [YAML 1.2 section 10.1.1.3], this sequence can be variously encoded according to the character set and encoding of the YAML stream [YAML 1.2 chapter 5]. The consequence is that a TOSCA string specified in literal YAML may inherit the encoding of the YAML document. Again, implementations may prefer to convert all strings to a single encoding.

5. TOSCA strings cannot be the null value but can be empty strings (a string with length zero). [See “nil”, below]

6. YAML is a streaming format, but TOSCA strings are explicitly not streams and thus do have a size limit. Thus, TOSCA implementations should check against the size limit.

[Tal’s comment: for functions we should specify their exact behavior for various primitive types. Some won’t work on all types, e.g. “length” should not work on integers.]

5.4.1.2 integer

A 64-bit signed integer.

For simplicity, TOSCA does not have integers of other bit widths, nor does it have an unsigned integer type. However, it is possible to enforce most of these variations using data type validation clauses [see XXX].

For example, this would be a custom data type for unsigned 16-bit integers:

data_types:

UInt16:

derived_from: integer

validation: { $in_range: [ $value, [ 0, 0xFFFF ] ] }

5.4.1.2.1 Notes

YAML allows for the standard decimal notation as well as hexadecimal and octal notations [YAML 1.2 example 2.19]. In the above example we indeed used the hexadecimal notation.

7. The JSON schema for YAML 1.2 [YAML 1.2 chapter 10.2] allows for compatibility with JSON, such that YAML would be a superset of JSON. However, note that the JSON format does not distinguish between integers and floats, and thus many JSON implementations use floats instead of integers.

8. TOSCA does not specify the endianness of integers and indeed makes no requirements for data representation.

5.4.1.3 float

A 64-bit (double-precision) floating-point number [IEEE 754], including the standard values for negative infinity, positive infinity, and not-a-number.

Be aware that YAML parsers will parse numbers with a decimal point as !!float even if they could be represented as !!int, and likewise numbers without a decimal point would always be parsed as !!int.

A TOSCA parser shall not attempt to convert a YAML !!int to a float. This requirement is necessary for avoiding rounding errors and ensuring portability. Users should thus add a “.0” suffix to literal integers that must be floats. Note that this even includes zero, i.e. users must specify “0” for a zero integer and “0.0” for a zero float.

This following example would be invalid if there were no “.0” suffix added to “10”:

node_types:

Node:

properties:

velocity:

type: float

service_template:

node_templates:

node:

type: Node

properties:

velocity: 10.0

5.4.1.3.1 Notes

1. In addition to decimal, YAML also allows for specifying floats using scientific notation as well as special unquoted words for negative infinity, positive infinity, and not-a-number [YAML 1.2 example 2.20].

2. TOSCA does not specify how to convert to other precisions nor to other formats, e.g. Bfloat16 and TensorFloat-32.

3. TOSCA does not specify the endianness of floats and indeed makes no requirements for data representation.

5.4.1.4 boolean

A single bit.

Note that in YAML literal booleans can be only either the unquoted all-lowercase words “true” or “false”.

A TOSCA parser shall not attempt to convert these values, nor variations such as “yes” or “True”, as quoted strings to booleans, nor shall it attempt to convert integer values (such as 1 and 0) to booleans. This requirement is necessary for ensuring portability as well as clarity.

5.4.1.5 bytes

An array of arbitrary bytes. Because we adhere to 64-bit precision, the minimum length of bytes is 0 and the maximum length of bytes is 4,294,967,295.

To specify literal bytes in YAML you must use a Base64-encoded !!string [RFC 2045 section 6.8]. There exist many free tools to help you convert arbitrary data to Base64.

Example:

node_types:

Node:

properties:

preamble:

type: bytes

service_template:

node_templates:

node:

type: Node

properties:

preamble: "\

R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\

OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\

+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\

AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="

5.4.1.5.1 Notes

1. There is no standard way to represent literal bytes in YAML 1.2. Though some YAML implementations may support the !!binary type working draft, to ensure portability TOSCA implementations shall not accept this YAML type.

2. The TOSCA functions “length”, “min_length”, and “max_length” work differently for the bytes type vs. the string type. For the latter the length is the count of Unicode runes, not the count of bytes.

3. TOSCA bytes values cannot be the null value but can be empty arrays (a bytes value with length zero). [See “nil”, below]

5.4.1.6 nil

The nil type always has the same singleton value. No other type can have this value.

This value is provided literally in YAML via the unquoted all-lowercase word “null”.

Example:

node_types:

Node:

properties:

nothing:

type: nil

required: true

service_template:

node_templates:

node:

type: Node

properties:

nothing: null

Note that a nil-typed value is distinct from an unassigned value. For consistency TOSCA requires you to assign nil values even though their value is obvious. Thus, the above example would be invalid if we did not specify the null value for the property at the node template.

Following is a valid example of not assigning a value:

node_types:

Node:

properties:

nothing:

type: nil

required: false

service_template:

node_templates:

node:

type: Node

5.4.2 Special Types

5.4.2.1 TOSCA version

A TOSCA version string.

TOSCA supports the concept of “reuse” of type definitions, as well as template definitions which could be versioned and change over time. It is important to provide a reliable, normative means to represent a version string which enables the comparison and management of types and templates over time.

5.4.2.1.1 Grammar

TOSCA version strings have the following grammar:

<major_version>.<minor_version>[.<fix_version>[.<qualifier>[-<build_version] ] ]

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· major_version: is a mandatory integer value greater than or equal to 0 (zero)

· minor_version: is a mandatory integer value greater than or equal to 0 (zero).

· fix_version: is an optional integer value greater than or equal to 0 (zero).

· qualifier: is an optional string that indicates a named, pre-release version of the associated code that has been derived from the version of the code identified by the combination major_version, minor_version and fix_version numbers.

· build_version: is an optional integer value greater than or equal to 0 (zero) that can be used to further qualify different build versions of the code that has the same qualifer_string.

5.4.2.1.2 Version Comparison

· When specifying a version string that contains just a major and a minor version number, the version string must be enclosed in quotes to prevent the YAML parser from treating the version as a floating point value.

· When comparing TOSCA versions, all component versions (i.e., major, minor and fix) are compared in sequence from left to right.

· TOSCA versions that include the optional qualifier are considered older than those without a qualifier.

· TOSCA versions with the same major, minor, and fix versions and have the same qualifier string, but with different build versions can be compared based upon the build version.

· Qualifier strings are considered domain-specific. Therefore, this specification makes no recommendation on how to compare TOSCA versions with the same major, minor and fix versions, but with different qualifiers strings and simply considers them different branches derived from the same code.

5.4.2.1.3 Examples

Examples of valid TOSCA version strings:

# basic version strings

‘6.1’

2.0.1

# version string with optional qualifier

3.1.0.beta

# version string with optional qualifier and build version

1.0.0.alpha-10

5.4.2.1.4 Notes

· [Maven-Version] The TOSCA version type is compatible with the Apache Maven versioning policy.

5.4.2.1.5 Additional Requirements

· A version value of zero (i.e., ‘0.0’, or ‘0.0.0’) SHALL indicate there no version provided.

· A version value of zero used with any qualifiers SHALL NOT be valid.

5.4.2.2 TOSCA range type

The range type can be used to define numeric ranges with a lower and upper boundary. For example, this allows for specifying a range of ports to be opened in a firewall.

5.4.2.2.1 Grammar

TOSCA range values have the following grammar:

[<lower_bound>, <upper_bound>]

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· lower_bound: is a mandatory integer value that denotes the lower boundary of the range.

· upper_bound: is a mandatory integer value that denotes the upper boundary of the range. This value MUST be greater than or equal to lower_bound.

5.4.2.2.2 Keywords

The following Keywords may be used in the TOSCA range type:

Keyword	Applicable Types	Description
UNBOUNDED	scalar	Used to represent an unbounded upper bounds (positive) value in a set for a scalar type.

5.4.2.2.3 Examples

Example of a node template property with a range value:

# numeric range between 1 and 100

a_range_property: [ 1, 100 ]

# a property that has allows any number 0 or greater

num_connections: [ 0, UNBOUNDED ]

5.4.2.3 TOSCA timestamp type

A local instant in time containing two elements: the local notation plus the time zone offset.

TOSCA timestamps are represented as strings following [RFC 3339], which in turn uses a simplified profile of [ISO 8601]. TOSCA adds an exception to RFC 3339: though RFC 3339 supports timestamps with unknown local offsets, represented as the "-0" timezone, TOSCA does not support this feature and will treat the unknown time zone as UTC. There are two reasons for this exception: the first is that many systems do not support this distinction and TOSCA aims for interoperability, and the second is that timestamps with unknown time zones cannot be converted to UTC, making it impossible to apply comparison functions. If this feature is required, it can be supported via a custom data type (see XXX).

5.4.2.3.1 Notes

· It is strongly recommended that all literal YAML timestamps be enclosed in quotation marks to ensure that they are parsed as strings. Otherwise, some YAML parsers might interpret them as the YAML !!timestamp type, which is rejected by TOSCA (see below).

· The TOSCA functions "equal", "greater_than", "greater_or_equal", "less_than", and "less_or_equal" all use the universal instant, i.e. as the local instant is converted to UTC by applying the timezone offset.

· Some YAML implementations may support the !!timestamp type working draft, but to ensure portability TOSCA implementations shall not accept this YAML type. Also note that the YAML !!timestamp supports a relaxed notation with whitespace, which does not conform to RFC 3339.

· RFC 3339 is based on the Gregorian calendar, including leap years and leap seconds, and is thus explicitly culturally biased. It cannot be used for non-Gregorian locales. Other calendar representations can be supported via custom data types (see XXX).

· Time zone information is expressed and stored numerically as an offset from UTC, thus daylight savings and other local changes are not included.

· TOSCA does not specify a canonical representation for timestamps. The only requirement is that representations adhere to RFC 3339.

5.4.2.4 TOSCA scalar-unit type

The scalar-unit type can be used to define scalar values along with a unit from the list of recognized units provided below.

5.4.2.4.1 Grammar

TOSCA scalar-unit typed values have the following grammar:

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· scalar: is a mandatory scalar value.

· unit: is a mandatory unit value. The unit value MUST be type-compatible with the scalar.

5.4.2.4.2 Additional requirements

· Whitespace: any number of spaces (including zero or none) SHALL be allowed between the scalar value and the unit value.

· It SHALL be considered an error if either the scalar or unit portion is missing on a property or attribute declaration derived from any scalar-unit type.

· When performing validation clause evaluation on values of the scalar-unit type, both the scalar value portion and unit value portion SHALL be compared together (i.e., both are treated as a single value). For example, if we have a property called storage_size (which is of type scalar-unit) a valid range constraint would appear as follows:

– storage_size: in_range [ 4 GB, 20 GB ]

where storage_size’s range will be evaluated using both the numeric and unit values (combined together), in this case ‘4 GB’ and ’20 GB’.

5.4.2.4.3 Concrete Types

The scalar-unit type grammar is abstract and has four recognized concrete types in TOSCA:

· scalar-unit.size – used to define properties that have scalar values measured in size units.

· scalar-unit.time – used to define properties that have scalar values measured in size units.

· scalar-unit.frequency – used to define properties that have scalar values measured in units per second.

· scalar-unit.bitrate – used to define properties that have scalar values measured in bits or bytes per second

These types and their allowed unit values are defined below.

5.4.2.4.4 scalar-unit.size

5.4.2.4.4.1 Recognized Units

Unit	Usage	Description
B	size	byte
kB	size	kilobyte (1000 bytes)
KiB	size	kibibytes (1024 bytes)
MB	size	megabyte (1000000 bytes)
MiB	size	mebibyte (1048576 bytes)
GB	size	gigabyte (1000000000 bytes)
GiB	size	gibibytes (1073741824 bytes)
TB	size	terabyte (1000000000000 bytes)
TiB	size	tebibyte (1099511627776 bytes)

5.4.2.4.4.2 Examples

# Storage size in Gigabytes

properties:

storage_size: 10 GB

5.4.2.4.4.3 Notes

· The unit values recognized by TOSCA for size-type units are based upon a subset of those defined by GNU at http://www.gnu.org/software/parted/manual/html_node/unit.html, which is a non-normative reference to this specification.

· TOSCA treats these unit values as case-insensitive (e.g., a value of ‘kB’, ‘KB’ or ‘kb’ is equivalent), but it is considered best practice to use the case of these units as prescribed by GNU.

· Some cloud providers may not support byte-level granularity for storage size allocations. In those cases, these values could be treated as desired sizes and actual allocations will be based upon individual provider capabilities.

5.4.2.4.5 scalar-unit.time

5.4.2.4.5.1 Recognized Units

Unit	Usage	Description
d	time	days
h	time	hours
m	time	minutes
s	time	seconds
ms	time	milliseconds
us	time	microseconds
ns	time	nanoseconds

5.4.2.4.5.2 Examples

# Response time in milliseconds

properties:

respone_time: 10 ms

5.4.2.4.5.3 Notes

· The unit values recognized by TOSCA for time-type units are based upon a subset of those defined by International System of Units whose recognized abbreviations are defined within the following reference:

– http://www.ewh.ieee.org/soc/ias/pub-dept/abbreviation.pdf

– This document is a non-normative reference to this specification and intended for publications or grammars enabled for Latin characters which are not accessible in typical programming languages

5.4.2.4.6 scalar-unit.frequency

5.4.2.4.6.1 Recognized Units

Unit	Usage	Description
Hz	frequency	Hertz, or Hz. equals one cycle per second.
kHz	frequency	Kilohertz, or kHz, equals to 1,000 Hertz
MHz	frequency	Megahertz, or MHz, equals to 1,000,000 Hertz or 1,000 kHz
GHz	frequency	Gigahertz, or GHz, equals to 1,000,000,000 Hertz, or 1,000,000 kHz, or 1,000 MHz.

5.4.2.4.6.2 Examples

# Processor raw clock rate

properties:

clock_rate: 2.4 GHz

5.4.2.4.6.3 Notes

· The value for Hertz (Hz) is the International Standard Unit (ISU) as described by the Bureau International des Poids et Mesures (BIPM) in the “SI Brochure: The International System of Units (SI) [8th edition, 2006; updated in 2014]”, http://www.bipm.org/en/publications/si-brochure/

5.4.2.4.7 scalar-unit.bitrate

5.4.2.4.7.1 Recognized Units

Unit	Usage	Description
bps	bitrate	bit per second
Kbps	bitrate	kilobit (1000 bits) per second
Kibps	bitrate	kibibits (1024 bits) per second
Mbps	bitrate	megabit (1000000 bits) per second
Mibps	bitrate	mebibit (1048576 bits) per second
Gbps	bitrate	gigabit (1000000000 bits) per second
Gibps	bitrate	gibibits (1073741824 bits) per second
Tbps	bitrate	terabit (1000000000000 bits) per second
Tibps	bitrate	tebibits (1099511627776 bits) per second

5.4.2.4.7.2 Examples

# Somewhere in a node template definition

requirements:

- link:

node_filter:

capabilities:

- myLinkable

properties:

bitrate:

- greater_or_equal: 10 Kbps # 10 * 1000 bits per second at least

5.4.3 Collection Types

5.4.3.1 TOSCA list type

The list type allows for specifying multiple values for a a parameter of property. For example, if an application allows for being configured to listen on multiple ports, a list of ports could be configured using the list data type.

Note that entries in a list must be of the same type. The type (for simple entries) or schema (for complex entries) is defined by the mandatory entry_schema attribute of the respective property definition, attribute definitions, or input or output parameter definitions. Schema definitions can be arbitrarily complex (they may themselves define a list).

5.4.3.1.1 Grammar

TOSCA lists are essentially normal YAML lists with the following grammars:

5.4.3.1.1.1 Square bracket notation

[ <list_entry_1>, <list_entry_2>, ... ]

5.4.3.1.1.2 Bulleted list notation

- <list_entry_1>

- ...

- <list_entry_n>

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· <list_entry_*>: represents one entry of the list.

5.4.3.1.2 Declaration Examples

5.4.3.1.2.1 List declaration using a simple type

The following example shows a list declaration with an entry schema based upon a simple integer type (which has an additional validation clause):

<some_entity>:

...

properties:

listen_ports:

type: list

entry_schema:

description: listen port entry (simple integer type)

type: integer

validation: { $max_length: [ $value, 128 ] }

5.4.3.1.2.2 List declaration using a complex type

The following example shows a list declaration with an entry schema based upon a complex type:

<some_entity>:

...

properties:

products:

type: list

entry_schema:

description: Product information entry (complex type) defined elsewhere

type: ProductInfo

5.4.3.1.3 Definition Examples

These examples show two notation options for defining lists:

· A single-line option which is useful for only short lists with simple entries.

· A multi-line option where each list entry is on a separate line; this option is typically useful or more readable if there is a large number of entries, or if the entries are complex.

5.4.3.1.3.1 Square bracket notation

listen_ports: [ 80, 8080 ]

5.4.3.1.3.2 Bulleted list notation

listen_ports:

- 80

- 8080

5.4.3.2 TOSCA map type

The map type allows for specifying multiple values for a parameter of property as a map. In contrast to the list type, where each entry can only be addressed by its index in the list, entries in a map are named elements that can be addressed by their keys.

Note that entries in a map for one property or parameter must be of the same type. The type (for simple entries) or schema (for complex entries) is defined by the entry_schema attribute of the respective property definition, attribute definition, or input or output parameter definition. In addition, the keys that identify entries in a map must be of the same type as well. The type of these keys is defined by the key_schema attribute of the respective property_definition, attribute_definition, or input or output parameter_definition. If the key_schema is not specified, keys are assumed to be of type string.

5.4.3.2.1 Grammar

TOSCA maps are normal YAML dictionaries with following grammar:

5.4.3.2.1.1 Single-line grammar

{ <entry_key_1>: <entry_value_1>, ..., <entry_key_n>: <entry_value_n> }

5.4.3.2.1.2 Multi-line grammar

<entry_key_1>: <entry_value_1>

...

<entry_key_n>: <entry_value_n>

In the above grammars, the pseudo values that appear in angle brackets have the following meaning:

· entry_key_*: is the mandatory key for an entry in the map

· entry_value_*: is the value of the respective entry in the map

5.4.3.2.2 Declaration Examples

5.4.3.2.2.1 Map declaration using a simple type

The following example shows a map with an entry schema definition based upon an existing string type (which has an additional validation clause):

<some_entity>:

...

properties:

emails:

type: map

entry_schema:

description: basic email address

type: string

validation: { $max_length: [ $value, 128 ] }

5.4.3.2.2.2 Map declaration using a complex type

The following example shows a map with an entry schema definition for contact information:

<some_entity>:

...

properties:

contacts:

type: map

entry_schema:

description: simple contact information

type: ContactInfo

5.4.3.2.3 Definition Examples

These examples show two notation options for defining maps:

· A single-line option which is useful for only short maps with simple entries.

· A multi-line option where each map entry is on a separate line; this option is typically useful or more readable if there is a large number of entries, or if the entries are complex.

5.4.3.2.3.1 Single-line notation

# notation option for shorter maps

user_name_to_id_map: { user1: 1001, user2: 1002 }

5.4.3.2.3.2 Multi-line notation

# notation for longer maps

user_name_to_id_map:

user1: 1001

user2: 1002

5.4.4 Data Type

A Data Type definition defines the schema for new datatypes in TOSCA.

5.4.4.1 Keynames

The Data Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Data Type has the following recognized keynames:

Keyname	Mandatory	Type	Description
validation	no	validation clause	The optional validation clause that must evaluate to True for values of this Data Type to be valid.
properties	no	map of property definitions	The optional map property definitions that comprise the schema for a complex Data Type in TOSCA.
key_schema	conditional (default: string)	schema definition	For data types that derive from the TOSCA map data type, the optional schema definition for the keys used to identify entries in properties of this data type. If not specified, the key_schema defaults to string. For data types that do not derive from the TOSCA map data type, the key_schema is not allowed.
entry_schema	conditional	schema definition	For data types that derive from the TOSCA map or list data types, the mandatory schema definition for the entries in properties of this data type. For data types that do not derive from the TOSCA list or map data type, the entry_schema is not allowed.

5.4.4.2 Grammar

Data Types have the following grammar:

<data_type_name>:

derived_from: <existing_type_name>

version: <version_number>

metadata:

description: <datatype_description>

validation: <validation_clause>

properties:

Validation clauses have the following grammar:

key_schema: <key_schema_definition>

entry_schema: <entry_schema_definition>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· data_type_name: represents the mandatory symbolic name of the data type as a string.

· version_number: represents the optional TOSCA version number for the data type.

· datatype_description: represents the optional description for the data type.

· existing_type_name: represents the optional name of a valid TOSCA primitive type or data type this new data type derives from.

· validation_clause: represents the optional validation clause that must evaluate to True for values of this data type to be valid.

· property_definitions: represents the optional map of one or more property definitions that provide the schema for the data type

– property_definitions may not be added to data types derived_from TOSCA primitive types.

· key_schema_definition: if the data type derives from the TOSCA map type (i.e existing_type_name is a map or derives from a map), it represents the optional schema definition for the keys used to identify entry properties of this type.

· entry_schema_definition: if the data type derives from the TOSCA map or list types (i.e. existing_type name is a map or list or derives from a map or list), it represents the mandatory schema definition for the entries in properties of this type.

5.4.4.3 Derivation rules

During Data Type derivation the keyname definitions follow these rules:

· validation: a new validation clause may be defined; this validation clause does not replace the validation clause defined in the parent type but is considered in addition to it.

· properties: existing property definitions may be refined; new property definitions may be added.

· key_schema: the key_schema definition may be refined according to schema refinement rules.

· entry_schema: the entry_schema definition may be refined according to schema refinement rules.

5.4.4.4 Additional Requirements

· A valid datatype definition MUST have either a valid derived_from declaration or at least one valid property definition.

· Any validation clauses SHALL be type-compatible with the type declared by the derived_from keyname.

· If a properties keyname is provided, it SHALL contain one or more valid property definitions.

· Property definitions may not be added to data types derived from TOSCA primitive types.

5.4.4.5 Examples

The following example represents a Data Type definition based upon an existing string type:

5.4.4.5.1 Defining a complex datatype

# define a new complex datatype

mytypes.phonenumber:

description: my phone number datatype

properties:

countrycode:

type: integer

areacode:

type: integer

number:

type: integer

5.4.4.5.2 Defining a datatype derived from an existing datatype

# define a new datatype that derives from existing type and extends it

mytypes.phonenumber.extended:

derived_from: mytypes.phonenumber

description: custom phone number type that extends the basic phonenumber type

properties:

phone_description:

type: string

validation: { $max_length: [ $value, 128 ] }

5.4.5 Schema definition

All entries in a map or list for one property or parameter must be of the same type. Similarly, all keys for map entries for one property or parameter must be of the same type as well. A TOSCA schema definition specifies the type (for simple entries) or schema (for complex entries) for keys and entries in TOSCA set types such as the TOSCA list or map.

If the schema definition specifies a map key, the type of the key schema must be derived originally from the string type (which basically ensures that the schema type is a string with additional validation clauses). As there is little need for complex keys this caters to more straight-forward and clear specifications. If the key schema is not defined it is assumed to be string by default.

Schema definitions appear in data type definitions when derived_from a map or list type or in parameter, property, or attribute definitions of a map or list type.

5.4.5.1 Keynames

The following is the list of recognized keynames for a TOSCA schema definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory data type for the key or entry. If this schema definition is for a map key, then the referred type must be derived originally from string.
description	no	string	The optional description for the schema.
validation	no	validation clauses\	The optional validation clause that must evaluate to True for the property.
key_schema	no (default: string)	schema definition	When the schema itself is of type map, the optional schema definition that is used to specify the type of the keys of that map’s entries (if key_schema is not defined it is assumed to be “string” by default). For other schema types, the key_schema must not be defined.
entry_schema	conditional	schema definition	When the schema itself is of type map or list, the schema definition is mandatory and is used to specify the type of the entries in that map or list. For other schema types, the entry_schema must not be defined.

5.4.5.2 Grammar

5.4.5.2.1 Short notation

The following single-line grammar may be used when only the schema type needs to be declared:

<schema_definition>: <schema_type>

5.4.5.2.2 Extended Notation

The following multi-line grammar may be used when additional information on the schema definition is needed:

<schema_definition>:

type: <schema_type>

description: <schema_description>

validation: <schema_validation_clause>

key_schema: <key_schema_definition>

entry_schema: <entry_schema_definition>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· schema_type: represents the mandatory type name for entries of the specified schema

– if this schema definition is for a map key, then the schema_type must be derived originally from string.

· schema_description: represents the optional description of the schema definition

· schema_validation_clause: represents the optional validation clause for entries of the specified schema.

· key_schema_definition: if the schema_type is map, it represents the optional schema definition for the keys of that map’s entries.

· entry_schema_definition: if the schema_type is map or list, it represents the mandatory schema definition for the entries in that map or list.

5.4.5.3 Refinement rules

A schema definition uses the following definition refinement rules when the containing entity type is derived:

· type: must be derived from (or the same as) the type in the schema definition in the parent entity type definition.

· description: a new definition is unrestricted and will overwrite the one inherited from the schema definition in the parent entity type definition.

· validation: a new definition is unrestricted; this validation clause does not replace the validation clause defined in the schema definition in the parent entity type but is considered in addition to it.

· key_schema: may be refined (recursively) according to schema refinement rules.

· entry_schema: may be refined (recursively) according to schema refinement rules.

5.4.6 Validation clause definition

A validation clause that must evaluate to True if the value for the entity it references is considered valid.

5.4.6.1 Grammar

validation: < validation_clause>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· validation_clause: represents a Boolean expression that must evaluate to True in order for values to be valid. Any Boolean expression can be used with any function with any degree of nesting.

5.4.6.2 The $value Function

The Boolean expression used as a validation clause must have a mechanism for referencing the value to which the expression applies. A special-purpose function is introduced for this purpose. This function is named $value and refers to the value used for the data type or the parameter definition that contains the validation clause.

5.4.6.3 Examples

The following shows an example of validation clauses used in data type definitions:

data_types:

# Full function syntax for the $value function

Count1:

derived_from: integer

validation: { $greater_or_equal: [ { $value: [] }, 0 ] }

# Simple function syntax for the $value function

Count2:

derived_from: integer

validation: { $greater_or_equal: [ $value, 0 ] }

# Full function syntax with arguments

FrequencyRange:

properties:

low:

type: scalar-unit.frequency

high:

type: scalar-unit.frequency

validation:

$greater_or_equal: [ { $value: [ high ] }, { $value: [ low ] } ]

The following shows an example of validation clauses used in property definitions:

node_types:

Scalable:

properties:

minimum_instances:

type: integer

validation: { $greater_or_equal: [ $value, 0 ] } # positive integer

maximum_instances:

type: integer

validation:

$greater_or_equal:

- $value

- $get_property: [ SELF, minimum_instances ]

default_instances:

type: integer

validation:

$and:

- $greater_or_equal:

- $value

- $get_property: [ SELF, minimum_instances ]

- $less_or_equal:

- $value

- $get_property: [ SELF, maximum_instances ]

required: false

5.4.7 Property definition

A property definition defines a named, typed value and related data that can be associated with an entity defined in this specification (e.g., Node Types, Relationship Types, Capability Types, etc.). Properties are used by template authors to provide input values to TOSCA entities which indicate their “desired state” when they are instantiated. The value of a property can be retrieved using the get_property function within TOSCA Service Templates.

5.4.7.1 Attribute and Property reflection

The actual state of the entity, at any point in its lifecycle once instantiated, is reflected by an attribute. TOSCA orchestrators automatically create an attribute for every declared property (with the same symbolic name) to allow introspection of both the desired state (property) and actual state (attribute). If an attribute is reflected from a property, its initial value is the value of the reflected property.

5.4.7.2 Keynames

The following is the list of recognized keynames for a TOSCA property definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory data type for the property.
description	no	string	The optional description for the property.
required	No (default: true)	boolean	An optional key that declares a property as required (true) or not (false). Defaults to true.
default	no	<must match property type>	An optional key that may provide a value to be used as a default if not provided by another means. The default keyname SHALL NOT be defined when property is not required (i.e. the value of the required keyname is false).
value	no	<see below>	An optional key that may provide a fixed value to be used. A property that has a fixed value provided (as part of a definition or refinement) cannot be subject to a further refinement or assignment. That is, a fixed value cannot be changed.
status	No (default: supported)	string	The optional status of the property relative to the specification or implementation. See table below for valid values. Defaults to supported.
validation	no	validation clause	The optional validation clause for the property.
key_schema	conditional (default: string)	schema definition	The schema definition for the keys used to identify entries in properties of type TOSCA map (or types that derive from map). If not specified, the key_schema defaults to string. For properties of type other than map, the key_schema is not allowed.
entry_schema	conditional	schema definition	The schema definition for the entries in properties of TOSCA collection types such as list, map, or types that derive from list or map) If the property type is a collection type, the entry schema is mandatory. For other types, the entry_schema is not allowed.
external-schema	no	string	The optional key that contains a schema definition that TOSCA Orchestrators MAY use for validation when the “type” key’s value indicates an External schema (e.g., “json”). See section “External schema” below for further explanation and usage.
metadata	no	map of string	Defines a section used to declare additional metadata information.

5.4.7.3 Status values

The following property status values are supported:

Value	Description
supported	Indicates the property is supported. This is the default value for all property definitions.
unsupported	Indicates the property is not supported.
experimental	Indicates the property is experimental and has no official standing.
deprecated	Indicates the property has been deprecated by a new specification version.

5.4.7.4 Grammar

Property definitions have the following grammar:

<property_name>:

type: <property_type>

description: <property_description>

required: <property_required>

default: <default_value>

value: <property_value> | { <property_value_expression> }

status: <status_value>

validation: <validation_clause>

key_schema: <key_schema_definition>

entry_schema: <entry_schema_definition>

metadata:

<metadata_map>

The following single-line grammar is supported when only a fixed value or fixed value expression needs to be provided to a property:

<property_name>: <property_value> | { <property_value_expression> }

This single-line grammar is equivalent to the following:

<property_name>:

value: <property_value> | { <property_value_expression> }

Note that the short form can be used only during a refinement (i.e. the property has been previously defined).

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· property_name: represents the mandatory symbolic name of the property as a string.

· property_description: represents the optional description of the property.

· property_type: represents the mandatory data type of the property.

· property_required: represents an optional boolean value (true or false) indicating whether or not the property is required. If this keyname is not present on a property definition, then the property SHALL be considered required (i.e., true) by default.

· default_value: contains a type-compatible value that is used as a default value if a value is not provided by another means (via the fixed_value definition or via property assignment);

– the default_value shall not be defined for properties that are not required (i.e. property_required is “false”) as they will stay undefined.

· <property_value> | { <property_value_expression> }: contains a type-compatible value or value expression that may be defined during property definition or refinement to set and fix the value definition of the property

– note that a value definition cannot be changed; once defined, the property cannot be further refined or assigned. Thus, value definitions should be avoided in data_type definitions.

· status_value: a string that contains a keyword that indicates the status of the property relative to the specification or implementation.

· validation_clause: represents the optional Boolean expression that must evaluate to true for a value of this property to be valid.

· key_schema_definition: if the property_type is map, represents the optional schema definition for the keys used to identify entries in that map.

· entry_schema_definition: if the property_type is map or list, represents the mandatory schema definition for the entries in that map or list.

· metadata_map: represents the optional map of string.

5.4.7.5 Refinement rules

A property definition within data, capability, node, relationship, group, policy, and artifact types (including capability definitions in node types) matching the name of a property in the derived entity type uses the following refinement rules to combine the two property definitions together:

· type: must be derived from (or the same as) the type in the property definition in the parent entity type definition.

· description: a new definition is unrestricted and will overwrite the one inherited from the property definition in the parent entity type definition.

· required: if defined to “false” in the property definition parent entity type it may be redefined to “true”; note that if undefined it is automatically considered as being defined to “true”.

· default: a new definition is unrestricted and will overwrite the one inherited from the property definition in the parent entity type definition (note that the definition of a default value is only allowed if the required keyname is (re)defined as “true”).

· value: if undefined in the property definition in the parent entity type, it may be defined to any type-compatible value; once defined, the property cannot be further refined or assigned.

· status: a new definition is unrestricted and will overwrite the one inherited from the property definition in the parent entity type definition.

· validation: a new definition is unrestricted; this validation clause does not replace the validation clause defined in the property definition in the parent entity type but is considered in addition to it.

· key_schema: if defined in the property definition in the parent entity type it may be refined according to schema refinement rules.

· entry_schema: if defined in the property definition in the parent entity type it may be refined according to schema refinement rules.

· metadata: a new definition is unrestricted and will overwrite the one inherited from the property definition in the parent entity type definition.

5.4.7.6 Additional Requirements

· Implementations of TOSCA SHALL automatically reflect (i.e., make available) any property defined on an entity as an attribute of the entity with the same name as the property.

· A property SHALL be considered required by default (i.e., as if the required keyname on the definition is set to true) unless the definition’s required keyname is explicitly set to false.

· The value provided on a property definition’s default keyname SHALL be type compatible with the type declared on the definition’s type keyname.

· If a key_schema or entry_schema keyname is provided, its value (string) MUST represent a valid schema definition that matches the property type (i.e. the property type as defined by the type keyword must be the same as or derived originally from map (for key_schema) or map or list (for entry_schema).

· TOSCA Orchestrators MAY choose to validate the value of the ‘schema’ keyname in accordance with the corresponding schema specification for any recognized external types.

5.4.7.7 Examples

The following represents an example of a property definition with a validation clause:

properties:

num_cpus:

type: integer

description: Number of CPUs requested for a software node instance.

default: 1

required: true

validation; { $valid_values: [ $value, [ 1, 2, 4, 8 ] ] }

The following shows an example of a property refinement. Consider the definition of an Endpoint capability type:

tosca.capabilities.Endpoint:

derived_from: tosca.capabilities.Root

properties:

protocol:

type: string

required: true

default: tcp

port:

type: PortDef

required: false

secure:

type: boolean

required: false

default: false

# Other property definitions omitted for brevity

The Endpoint.Admin capability type refines the secure property of the Endpoint capability type from which it derives by forcing its value to always be true:

tosca.capabilities.Endpoint.Admin:

derived_from: tosca.capabilities.Endpoint

# Change Endpoint secure indicator to true from its default of false

properties:

secure: true

5.4.8 Property assignment

This section defines the grammar for assigning values to properties within TOSCA templates.

5.4.8.1 Keynames

The TOSCA property assignment has no keynames.

5.4.8.2 Grammar

Property assignments have the following grammar:

5.4.8.2.1 Short notation:

The following single-line grammar may be used when a simple value assignment is needed:

<property_name>: <property_value> | { <property_value_expression> }

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· property_name: represents the name of a property that will be used to select a property definition with the same name within on a TOSCA entity (e.g., Node Template, Relationship Template, etc.) which is declared in its declared type (e.g., a Node Type, Node Template, Capability Type, etc.).

· property_value, property_value_expression: represent the type-compatible value to assign to the property. Property values may be provided as the result of the evaluation of an expression or a function.

5.4.8.3 Additional Requirements

· Properties that have a (fixed) value defined during their definition or during a subsequent refinement may not be assigned (as their value is already set).

· If a required property has no value defined or assigned, its default value is assigned

· A non-required property that is not assigned it stays undefined, thus the default keyname is irrelevant for a non-required property.

5.4.9 Attribute definition

An attribute definition defines a named, typed value that can be associated with an entity defined in this specification (e.g., a Node, Relationship or Capability Type). Specifically, it is used to expose the “actual state” of some property of a TOSCA entity after it has been deployed and instantiated (as set by the TOSCA orchestrator). Attribute values can be retrieved via the get_attribute function from the instance model and used as values to other entities within TOSCA Service Templates.

5.4.9.1 Attribute and Property reflection

5.4.9.2 Keynames

The following is the list of recognized keynames for a TOSCA attribute definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory data type for the attribute.
description	no	string	The optional description for the attribute.
default	no	<any>	An optional key that may provide a value to be used as a default if not provided by another means. This value SHALL be type compatible with the type declared by the attribute definition’s type keyname.
status	no	string	The optional status of the attribute relative to the specification or implementation. See supported status values . Defaults to supported.
validation	no	validation clause	The optional validation clause for the attribute.
key_schema	conditional (default: string)	schema definition	The schema definition for the keys used to identify entries in attributes of type TOSCA map (or types that derive from map). If not specified, the key_schema defaults to string. For attributes of type other than map, the key_schema is not allowed.
entry_schema	conditional	schema definition	The schema definition for the entries in attributes of TOSCA collection types such as list, map, or types that derive from list or map) If the attribute type is a collection type, the entry schema is mandatory. For other types, the entry_schema is not allowed.
metadata	no	map of string	Defines a section used to declare additional metadata information.

5.4.9.3 Grammar

Attribute definitions have the following grammar:

attributes:

<attribute_name>:

type: <attribute_type>

description: <attribute_description>

default: <default_value>

status: <status_value>

validation: <attribute_validation_clause>

key_schema: <key_schema_definition>

entry_schema: <entry_schema_definition>

metadata:

<metadata_map>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· attribute_name: represents the mandatory symbolic name of the attribute as a string.

· attribute_type: represents the mandatory data type of the attribute.

· attribute_description: represents the optional description of the attribute.

· default_value: contains a type-compatible value that may be used as a default if not provided by another means.

· status_value: contains a value indicating the attribute’s status relative to the specification version (e.g., supported, deprecated, etc.); supported status values for this keyname are defined in the property definition section.

· attribute_validation_clause: represents the optional validation clause that must evaluate to True for values for the defined attribute to be valid.

· key_schema_definition: if the attribute_type is map, represents the optional schema definition for the keys used to identify entries in that map.

· entry_schema_definition: if the attribute_type is map or list, represents the mandatory schema definition for the entries in that map or list.

· metadata_map: represents the optional map of string.

5.4.9.4 Refinement rules

An attribute definition within data, capability, node, relationship, and group types (including capability definitions in node types) uses the following refinement rules when the containing entity type is derived:

· type: must be derived from (or the same as) the type in the attribute definition in the parent entity type definition.

· description: a new definition is unrestricted and will overwrite the one inherited from the attribute definition in the parent entity type definition.

· default: a new definition is unrestricted and will overwrite the one inherited from the attribute definition in the parent entity type definition.

· status: a new definition is unrestricted and will overwrite the one inherited from the attribute definition in the parent entity type definition.

· validation: a new definition is unrestricted; this validation clause does not replace the validation clause defined in the attribute definition in the parent entity type but is considered in addition to it.

· key_schema: if defined in the attribute definition in the parent entity type it may be refined according to schema refinement rules.

· entry_schema: if defined in the attribute definition in the parent entity type it may be refined according to schema refinement rules.

· metadata: a new definition is unrestricted and will overwrite the one inherited from the attribute definition in the parent entity type definition

5.4.9.5 Additional Requirements

· In addition to any explicitly defined attributes on a TOSCA entity (e.g., Node Type, Relationship Type, etc.), implementations of TOSCA MUST automatically reflect (i.e., make available) any property defined on an entity as an attribute of the entity with the same name as the property.

· Values for the default keyname MUST be derived or calculated from other attribute or operation output values (that reflect the actual state of the instance of the corresponding resource) and not hard-coded or derived from a property settings or inputs (i.e., desired state).

5.4.9.6 Notes

· Attribute definitions are very similar to Property definitions; however, properties of entities reflect an input that carries the template author’s requested or desired value (i.e., desired state) which the orchestrator (attempts to) use when instantiating the entity whereas attributes reflect the actual value (i.e., actual state) that provides the actual instantiated value.

– For example, a property can be used to request the IP address of a node using a property (setting); however, the actual IP address after the node is instantiated may by different and made available by an attribute.

5.4.9.7 Example

The following represents a mandatory attribute definition:

actual_cpus:

type: integer

description: Actual number of CPUs allocated to the node instance.

5.4.10 Attribute assignment

This section defines the grammar for assigning values to attributes within TOSCA templates.

5.4.10.1 Keynames

The TOSCA attribute assignment has no keynames.

5.4.10.2 Grammar

Attribute assignments have the following grammar:

5.4.10.2.1 Short notation:

The following single-line grammar may be used when a simple value assignment is needed:

<attribute_name>: <attribute_value> | { <attribute_value_expression> }

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· attribute_name: represents the name of an attribute that will be used to select an attribute definition with the same name within on a TOSCA entity (e.g., Node Template, Relationship Template, etc.) which is declared (or reflected from a Property definition) in its declared type (e.g., a Node Type, Node Template, Capability Type, etc.).

· attribute_value, attribute_value_expresssion: represent the type-compatible value to assign to the attribute. Attribute values may be provided as the result from the evaluation of an expression or a function.

5.4.10.3 Additional requirements

· Attributes that are the target of a parameter mapping assignment cannot also be assigned a value using an attribute assignment.

5.4.11 Parameter definition

A parameter definition defines a named, typed value and related data and may be used to exchange values between the TOSCA orchestrator and the external world. Such values may be

· inputs and outputs of interface operations and notifications

· inputs and outputs of workflows

· inputs and outputs of service templates

From the perspective of the TOSCA orchestrator such parameters are either “incoming” (i.e. transferring a value from the external world to the orchestrator) or “outgoing” (transferring a value from the orchestrator to the external world). Thus:

· outgoing parameters are:

– template outputs

– internal workflow outputs

– external workflow inputs

– operation inputs

· incoming parameters are:

– template inputs

– internal workflow inputs

– external workflow outputs

– operation outputs

– notification outputs

An “outgoing” parameter definition is essentially the same as a TOSCA property definition, however it may optionally inherit the data type of the value assigned to it rather than have an explicit data type defined.

An “incoming” parameter definition may define an attribute mapping of the parameter value to an attribute of a node. Optionally, it may inherit the data type of the attribute it is mapped to, rather than have an explicit data type defined for it.

5.4.11.1 Keynames

The TOSCA parameter definition has all the keynames of a TOSCA property definition with the following additional or changed keynames:

Keyname	Mandatory	Type	Description
type	no	string	The data type of the parameter. Note: This keyname is mandatory for a TOSCA Property definition but is not mandatory for a TOSCA Parameter definition.
value	no	<any>	The type-compatible value to assign to the parameter. Parameter values may be provided as the result from the evaluation of an expression or a function. May only be defined for outgoing parameters. Mutually exclusive with the “mapping” keyname.
mapping	no	attribute selection format	A mapping that specifies the node or relationship attribute into which the returned output value must be stored. May only be defined for incoming parameters. Mutually exclusive with the “value” keyname.

5.4.11.2 Grammar

Parameter definitions have the following grammar:

<parameter_name>:

type: <parameter_type>

description: <parameter_description>

value: <parameter_value> | { <parameter_value_expression> }

required: <parameter_required>

default: <parameter_default_value>

status: <status_value>

validation: <parameter_validation_clause>

key_schema: <key_schema_definition>

entry_schema: <entry_schema_definition>

mapping: <attribute_selection_form>

The following single-line grammar is supported when only a fixed value needs to be provided provided to an outgoing parameter:

<parameter_name>: <parameter_value> | { <parameter_value_expression> }

This single-line grammar is equivalent to the following:

<parameter_name>:

value: <parameter_value> | { <parameter_value_expression> }

The following single-line grammar is supported when only a parameter to attribute mapping needs to be provided to an incoming parameter:

<parameter_name>: <attribute_selection_form>

This single-line grammar is equivalent to the following:

<parameter_name>:

mapping: <attribute_selection_form>

Note that the context of the parameter definition unambiguously determines if the parameter is an incoming or an outgoing parameter.

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· parameter_name: represents the mandatory symbolic name of the parameter as a string.

· parameter_description: represents the optional description of the parameter.

· parameter_type: represents the optional data type of the parameter. Note, this keyname is mandatory for a TOSCA Property definition, but is not for a TOSCA Parameter definition.

· parameter_value, parameter_value_expresssion: represent the type-compatible value to assign to the parameter. Parameter values may be provided as the result from the evaluation of an expression or a function.

– once the value keyname is defined, the parameter cannot be further refined or assigned.

– the value keyname is relevant only for “outgoing” parameter definitions and SHOULD NOT be defined in “incoming” parameter definitions.

· parameter_required: represents an optional boolean value (true or false) indicating whether or not the parameter is required. If this keyname is not present on a parameter definition, then the parameter SHALL be considered required (i.e., true) by default.

· default_value: contains a type-compatible value that may be used as a default if not provided by other means.

– the default keyname SHALL NOT be defined for parameters that are not required (i.e. parameter_required is “false”) as they will stay undefined.

· status_value: a string that contains a keyword that indicates the status of the parameter relative to the specification or implementation.

· parameter_validation_clause: represents the optional validation clause on the parameter definition.

· key_schema_definition: if the parameter_type is map, represents the optional schema definition for the keys used to identify entries in that map. Note that if the key_schema is not defined, the key_schema defaults to string.

· entry_schema_definition: if the parameter_type is map or list, represents the mandatory schema definition for the entries in that map or list.

· attribute_selection_form: a list that corresponds to a valid attribute_selection_format; the parameter is mapped onto an attribute of the containing entity

– the mapping keyname is relevant only for “incoming” parameter definitions and SHOULD NOT be defined in “outgoing” parameter definitions.

5.4.11.3 Refinement rules

A parameter definition within interface types, interface definitions in node and relationship types, uses the following refinement rules when the containing entity type is derived:

· type: must be derived from (or the same as) the type in the parameter definition in the parent entity type definition.

· description: a new definition is unrestricted and will overwrite the one inherited from the parameter definition in the parent entity type definition.

· required: if defined to “false” in the parameter definition parent entity type it may be redefined to “true”; note that if undefined it is automatically considered as being defined to “true”.

· default: a new definition is unrestricted and will overwrite the one inherited from the parameter definition in the parent entity type definition (note that the definition of a default value is only allowed if the required keyname is (re)defined as “true”).

· value: if undefined in the parameter definition in the parent entity type, it may be defined to any type-compatible value; once defined, the parameter cannot be further refined or assigned

– the value keyname should be defined only for “outgoing” parameters.

· mapping: if undefined in the parameter definition in the parent entity type, it may be defined to any type-compatible attribute mapping; once defined, the parameter cannot be further refined or mapped

– the mapping keyname should be defined only for “incoming” parameters.

· status: a new definition is unrestricted and will overwrite the one inherited from the parameter definition in the parent entity type definition.

· validation: a new definition is unrestricted; this validation clause does not replace the validation clause defined in the parameter definition in the parent entity type but is considered in addition to it.

· key_schema: if defined in the parameter definition in the parent entity type it may be refined according to schema refinement rules.

· entry_schema: if defined in the parameter definition in the parent entity type it may be refined according to schema refinement rules.

· metadata: a new definition is unrestricted and will overwrite the one inherited from the parameter definition in the parent entity type definition.

5.4.11.4 Additional requirements

· A parameter SHALL be considered required by default (i.e., as if the required keyname on the definition is set to true) unless the definition’s required keyname is explicitly set to false.

· The value provided on a parameter definition’s default keyname SHALL be type compatible with the type declared on the definition’s type keyname.

5.4.11.5 Example

The following represents an example of an input parameter definition with a validation clause:

inputs:

cpus:

type: integer

description: Number of CPUs for the server.

validation: { $valid_values: [ $value, [ 1, 2, 4, 8 ] ] }

The following represents an example of an (untyped) output parameter definition:

outputs:

server_ip:

description: The private IP address of the provisioned server.

value: { $get_attribute: [ my_server, private_address ] }

5.4.12 Parameter value assignment

This section defines the grammar for assigning values to “outgoing” parameters in TOSCA templates.

5.4.12.1 Keynames

The TOSCA parameter value assignment has no keynames.

5.4.12.2 Grammar

Parameter value assignments have the following grammar:

<parameter_name>: <parameter_value> | { <parameter_value_expression> }

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· parameter_name: represents the symbolic name of the parameter to assign; note that in some cases, even parameters that do not have a corresponding definition in the entity type of the entity containing them may be assigned (see e.g. inputs and outputs in interfaces).

· parameter_value, parameter_value_expression: represent the type-compatible value to assign to the parameter. Parameter values may be provided as the result from the evaluation of an expression or a function.

5.4.12.3 Additional requirements

· Parameters that have a (fixed) value defined during their definition or during a subsequent refinement may not be assigned (as their value is already set).

· If a required parameter has no value defined or assigned, its default value is assigned.

· A non-required parameter that has no value assigned it stays undefined, thus the default keyname is irrelevant for a non-required parameter.

5.4.13 Parameter mapping assignment

A parameter to attribute mapping defines an “incoming” parameter value (e.g. an output value that is expected to be returned by an operation implementation) and a mapping that specifies the node or relationship attribute into which the returned “incoming” parameter value must be stored.

5.4.13.1 Keynames

The TOSCA parameter mapping assignment has no keynames.

5.4.13.2 Grammar

Parameter mapping assignments have the following grammar:

<parameter_name>: <attribute_selection_format>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· attribute_selection_format: represents a format that is used to select an attribute or a nested attribute on which to map the parameter value of the incoming parameter referred by parameter_name.

5.4.13.3 Attribute selection format

The attribute_selection_format is a list of the following format:

[<tosca_traversal_path>, <attribute_name>, <nested_attribute_name_or_index_1>, ..., <nested_attribute_name_or_index_n> ]

The various entities in this grammar are defined as follows:

Parameter	Mandatory	Description
<tosca_traversal_path>	yes	Using the <tosca_traversal_path> we can traverse the representation graph to reach the attribute we need to store the output value into. The specification of the <tosca_traversal_path> is explicated in section 6.4.2 get_property. Note that while the <tosca_traversal_path> is very powerful, its usage should normally be restricted to reach attributes in the local node ore relationship (i.e. SELF) or in a local capability definition.
<attribute_name>	yes	The name of the attribute into which the output value must be stored.
<nested_attribute_name_or_index_or_key_*>	no	Some TOSCA attributes are complex (i.e., composed as nested structures). These parameters are used to dereference into the names of these nested structures when needed. Some attributes represent list or map types. In these cases, an index or key may be provided to reference a specific entry in the list or map (identified by the previous parameter).

Note that it is possible for multiple operations to define outputs that map onto the same attribute value. For example, a create operation could include an output value that sets an attribute to an initial value, and the subsequence configure operation could then update that same attribute to a new value.

It is also possible that a node template assigns a value to an attribute that has an operation output mapped to it (including a value that is the result of calling an intrinsic function). Orchestrators could use the assigned value for the attribute as its initial value. After the operation runs that maps an output value onto that attribute, the orchestrator must then use the updated value, and the value specified in the node template will no longer be used.

5.4.13.4 Additional requirements

· Parameters that have a mapping defined during their definition or during a subsequent refinement may not be assigned (as their mapping is already set).

5.4.14 Function syntax

TOSCA supports the use of functions for providing dynamic service data values at runtime. The syntax of

a function has two representations:

· Any function can be represented by a YAML map with a single key, where the key is a string starting with a $ (dollar sign) character and where the remainder of the string represents the function name. If present, the value in the key-value pair represents the function arguments.

· A function without arguments can alternatively be represented by a YAML string value, where the string starts with a $ (dollar sign) character and where the remainder of the string represents the function name. This representation cannot be used in map keys.

· Function names may not contain the $ character as it will conflict with the escape mechanisms described below.

Therefore, any string starting with a $ (dollar sign) character will be interpreted as a function call. To allow for strings starting with $ character to be specified, the $ character at the start of the string needs to be escaped by using $$ (two dollar signs) characters instead. For example:

· $$name will represent the literal string $name

· $$$item will represent the literal string $$item, as only the first $ character is escaped.

As we could have function calls that return values to be used as keys in a map, hypothetically it is possible that we use the same function call as a YAML key more than once. Because YAML does not allow for duplicate map keys, in such cases we must allow for key variation. This is achieved by adding suffixes after the function name starting with a second $ character. For example, the following is a valid map where the function “keygen” is called three times and the returned values are used as keys in the hint map:

hint:

{ $keygen: [ UUID ] }: 34

{ $keygen$1: [ UUID ] }: 56

{ $keygen$2: [ UUID ] }: 78

TOSCA functions may be used wherever a value is expected, such as:

· a value for a TOSCA keyname

· a value for a parameter or property or attribute, including a value within a complex datatype

· a value for the arguments of another function

· other places such as in validation clauses, conditions, etc.

TOSCA parsers are expected to evaluate function values at runtime based on the provided function arguments.

The following snippet shows an example of a node template that uses a function to retrieve a security context at runtime:

properties:

context: { $get_security_context: { env: staging, role: admin } }

Nested functions are supported, that is, functions can be used in the arguments of another function. The result of the internal function will be passed as an argument to the outer function:

properties:

nested: {$outer_func: [{$inner_func: [iarg1, iarg2]}, oarg2]}

To allow for strings that are not function names to start with $, the dollar sign can be escaped by using $$ (two consecutive dollar characters). The following snippet shows escaped strings in a map that do not represent function calls:

properties:

prop1:

$$myid1: myval1

myid2: $$myval2

$$myid3: $$myval3

The arguments to the functions can be arbitrary TOSCA data, although TOSCA defines a number of built-in functions that define function-specific syntax for providing arguments. In addition, service designers can optionally define custom function signatures definitions for function arguments and function return values as specified in section 1.1.1.

5.4.14.1 Parsing rule

When parsing TOSCA files, TOSCA parsers MUST identify functions wherever values are specified using the following algorithm:

· Does the YAML string start with $?

o If yes, is the second character $?

§ If yes, discard the first $ and stop here (escape).

§ If no, is this a key in a YAML map?

· If yes, is this the only key in a YAML map?

o If yes, this is a function call.

o If no, emit a parsing syntax error ("malformed function").

· If no, this is a function call without arguments.

5.4.15 Function definitions

TOSCA includes grammar for defining function signatures and associated implementation artifacts in TOSCA profiles or in TOSCA service templates. This allows for validation of function return values and function arguments at design time, and the possibility to provide function implementation artifacts within CSARs. Note that the use of custom function definitions is entirely optional, service designers can use custom functions without defining associated function signatures and instead rely on support for those functions directly in the TOSCA orchestrator that will be used to process the TOSCA files. Of course, TOSCA processors may support custom functions that are not user-defined.

5.4.15.1 Keynames

The following is the list of recognized keynames for TOSCA function definition:

Keyname	Mandatory	Type	Description
signatures	yes	map of signature definitions	The map of signature definitions.
description	no	string	The description of the function.
metadata	no	map of metadata	Defines additional metadata information.

The following is the list of recognized keynames for TOSCA function signature definition:

Keyname	Mandatory	Type	Description
arguments	no	list of schema definitions	All defined arguments must be used in the function invocation (and in the order defined here). If no arguments are defined, the signature either accepts no argumats or any arguments of any form (depending on if the variadic keyname is false or true).
optional_arguments	no	list of schema definitions	Optional arguments may be used in the function invocation after the regular arguments. Still the order defined here must be respected.
variadic	no (default: false)	boolean	Specifies if the last defined argument (or optional_argument if defined) may be repeated any number of times in the function invocation
result	no	schema definition	Defines the type of the function result. If no result keyname is defined, then the function may return any result
implementation	no	implementation definition	Defines the implementation (e.g., artifact) for the function. The same definition as for operation/notification implementation is used.

5.4.15.2 Grammar

Function signatures can be defined in TOSCA profiles or TOSCA service templates using a YAML map under the functions keyname as follows. Note that this grammar allows the definition of functions that have arguments expressed within a YAML seq, however intrinsic functions may accept other argument definition syntaxes.

functions:

<function_def>

...

<function_def>

Each <function_def> defines the name of a function with an associated list of signature definitions as follows:

<function_name>:

signatures:

- <signature_def>

...

- <signature_def>

description: <string>

metadata: <map_of_metadata>

Only the signatures keyname is mandatory and must provide at least one signature definition. Note that the signatures are tested in the order of their definition. The first matching implementation is used.

Each <signature_def> is a map of following keywords definitions:

arguments:

- <schema_def>

...

- <schema_def>

optional_arguments:

- <schema_def>

...

- <schema_def>

variadic: <boolean>

result: <schema_def>

implementation: <implementation_def>

None of the keynames in the signature definition are mandatory.

The keynames have the following meaning:

The arguments keyname defines the type and the position of the function arguments. All defined arguments must be used in the function invocation (and in the order defined here).

The full flexibility of the schema definition for types can be used.

The optional_arguments keyname defines the type and the position of the function arguments. Optional arguments may be used in the function invocation after the regular arguments. Still the order defined here must be respected (that is, if m out of n of the optional arguments are used, they will correspond to the first m <schema_def>).

The full flexibility of the schema definition for types can be used.

The result keyname defines the type of the function result.

Again, the full flexibility of the schema definition for types can be used.
If no result keyname is defined, then the function may return any result.

The variadic keyname defines if the last defined argument may be repeated any number of times in the function invocation.

If variadic is true, the last defined argument may be repeated any number of times in the function invocation (on the last positions).

If optional_arguments is defined, then the last defined argument is the last defined optional_argument. Note that in this case we have a 0+ usage of the last argument.
If optional_arguments is not defined, then the last defined argument is the last defined regular argument. Note that in this case we have a 1+ usage of the last argument.

If variadic is false, the last argument definition has no special semantics.
If the arguments list is empty or not defined:

If variadic is false, the function is not accepting any arguments.
If variadic is true, the function is considered to accept any numbers of arguments of any type or form.

Default value of variadic is false.

The implementation keyname defines the implementation (e.g., artifact) for the function.

The same definition as for operation/notification implementation is used.
If no implementation is specified, then it's assumed that the TOSCA processor is preconfigured to handle the function call.
Note that several signatures of a function (or even of several functions) may refer to the same implementation in the implementation definition.

The functions section can be defined both outside and/or inside a service_template section:

Function definitions outside a service_template can be within a profile TOSCA file or imported TOSCA file

Namespacing works as for types. Overlapping definitions under the same <function_name> are not allowed.
Note that in that case the $ (dollar sign) character will be put in front of the namespace name. For example:

properties:

rnd_nr: { $namespace1:random_generator: [ seed ] }

Function definitions inside a service_template that are having the same <function_name> are considered a refinement of the homonymous definition outside the service_template, see refinement rules below.
For example, this would allow for two separated design moments in function design:

At profile design time (outside the service_template), when e.g. the arguments and the result is defined and thus the function can be correctly used in the node type definitions.
At service template design time (inside the service_template), when function implementation references within a current CSAR can be decided, and thus the implementation or the description may be added or changed.
Note also that we could have the whole definition in the service template or outside the service template, in the latter case defining a global implementation.

5.4.15.3 Refinement rules

Function definitions inside a service_template that are having the same <function_name> are considered a refinement of the homonymous definition outside the service_template.

signatures: as a general function refinement rule, for an already defined signature only the implementation may be changed.

New function signatures may be added to the signatures list, but only after the refinements of the existing signatures.
If an existing signature is not refined, an empty element must be used at the relevant location in the list.

· description: a new definition is unrestricted and will overwrite the one inherited from the function definition outside the service_template.

· metadata: a new definition is unrestricted and will overwrite the one inherited from the function definition outside the service_template.

5.4.15.4 Examples

5.4.15.4.1 Square root function with several signatures

The following example shows the definition of a square root function:

functions:

sqrt:

signatures:

- arguments:

- type: integer

validation: { $greater_or_equal: [ $value, 0 ] }

result:

type: float

implementation: scripts/sqrt.py

- arguments:

- type: float

validation: { $greater_or_equal: [ $value, 0.0 ] }

result:

type: float

implementation: scripts/sqrt.py

description: >

This is a square root function that defines two signatures:

the argument is either integer or float and the function

returns the suare root as a float.

The next sqrt is similar to above, but uses a simplified type notation (in this short form no validation clause can be expressed):

functions:

sqrt:

signatures:

- arguments: [ integer ]

result: float

implementation: scripts/sqrt.py

- arguments: [ float ]

result: float

implementation: scripts/sqrt.py

description: >

This is a square root function that defines two signatures:

the argument is either integer or float and the function

returns the suare root as a float.

5.4.15.4.2 Function with list of arguments

The following example shows a function that takes a list of arguments with different types:

functions:

my_func_with_different_argument_types:

signatures:

- arguments:

- type: MyType1

description: "this is the first argument ..."

- type: string

description: "this is the second argument ..."

- type: string

description: "this is the third argument ..."

- type: MyType2

description: "this is the argument that can be repeated ..."

variadic: true

result:

type: MyTypeRez

implementation: scripts/my.py

Same as the above, but in compact notation:

functions:

my_func_with_different_argument_types:

signatures:

- arguments: [MyType1, string, string, MyType2]

variadic: true

result: MyTypeRez

implementation: scripts/my.py

5.4.15.4.3 Function with no arguments

The arguments list can be empty or completely missing. In such a case, when using the function the arguments will be an empty list:

functions:

get_random_nr:

signatures:

- result: float

implementation: scripts/myrnd.py

5.4.15.4.4 Function with polymorphic arguments/result inside of lists

Function signatures with different types within the arguments and result lists:

functions:

union:

signatures:

- arguments:

- type: list

entry_schema: integer

variadic: true

result:

type: list

entry_schema: integer

implementation: scripts/libpi.py

- arguments:

- type: list

entry_schema: float

variadic: true

result:

type: list

entry_schema: float

implementation: scripts/libpi.py

5.4.15.4.5 Defining a list in a map argument

The following shows the use of a argument that is a map of lists of MyType:

functions:

complex_arg_function:

signatures:

- arguments:

- type: map

key_schema: string

entry_schema:

type: list

entry_schema: MyType

result: string

implementation: scripts/complex.py

5.4.15.4.6 User-defined function usage

The following shows more examples of function usage. Note that in the usage of the polymorphic union function, the TOSCA parser knows to identify the right signature via the types of the function arguments. Also note the usage of a user-defined function with no parameters; an empty list is used for the arguments.

properties:

integer_union: {$union: [[1, 7], [3, 4, 9], [15, 16]]}

float_union: {$union: [[3.5, 8.8], [1.3]]}

rnd: {$get_random_nr: []}

5.5 Substitution

5.5.1 Substitution mapping

A substitution mapping allows a given service template to be used as an implementation of abstract node templates of a specific node type. This allows the consumption of complex systems using a simplified vision.

5.5.1.1 Keynames

Keyname	Mandatory	Type	Description
node_type	yes	string	The mandatory name of the Node Type the service template is providing an implementation for.
substitution_filter	no	node filter	The optional filter that further constrains the abstract node templates for which this service template can provide an implementation.
properties	no	map of property mappings	The optional map of properties mapping allowing to map properties of the node_type to inputs of the service template.
attributes	no	map of attribute mappings	The optional map of attribute mappings allowing to map outputs from the service template to attributes of the node_type.
capabilities	no	map of capability mappings	The optional map of capabilities mapping.
requirements	no	map of requirement mappings	The optional map of requirements mapping.
interfaces	no	map of interfaces mappings	The optional map of interface mapping allows to map an interface and operations of the node type to implementations that could be either workflows or node template interfaces/operations.

5.5.1.2 Grammar

The grammar of the substitution_mapping section is as follows:

node_type: <node_type_name>

substitution_filter : <node_filter>

properties:

<property_mappings>

capabilities:

<capability_mappings>

requirements:

<requirement_mappings>

attributes:

<attribute_mappings>

interfaces:

<interface_mappings>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· node_type_name: represents the mandatory Node Type name that the Service Template is offering an implementation for.

· node_filter: represents the optional node filter that reduces the set of abstract node templates for which this service template is an implementation by only substituting for those node templates whose properties and capabilities satisfy the condition expression specified in the node filter.

· properties: represents the <optional> map of properties mappings.

· capability_mappings: represents the <optional> map of capability mappings.

· requirement_mappings: represents the <optional> map of requirement mappings.

· attributes: represents the <optional> map of attributes mappings.

· interfaces: represents the <optional> map of interfaces mappings.

5.5.1.3 Examples

5.5.1.4 Additional requirements

· The substitution mapping MUST provide mapping for every property, capability and requirement defined in the specified <node_type>

5.5.1.5 Notes

· The node_type specified in the substitution mapping SHOULD be abstract (does not provide implementation for normative operations).

5.5.2 Property mapping

A property mapping allows to map the property of a substituted node type to an input of the service template.

5.5.2.1 Keynames

The following is the list of recognized keynames for a TOSCA property mapping:

Keyname	Mandatory	Type	Description
mapping	no	list of strings	An array with 1 string element that references an input of the service.
value	no	matching the type of this property	This deprecated keyname allows to explicitly assigne a value to this property. This field is mutually exclusive with the mapping keyname.

5.5.2.2 Grammar

The single-line grammar of a property_mapping is as follows:

<property_name>: <property_value> # This use is deprecated

<property_name>: [ <input_name> ]

The multi-line grammar is as follows :

<property_name>:

mapping: [ < input_name > ]

<property_name>:

value: <property_value> # This use is deprecated

5.5.2.3 Notes

· Single line grammar for a property value assignment is not allowed for properties of type in order to avoid collision with the mapping single line grammar.

· The property_value mapping grammar has been deprecated. The original intent of the property-to-constant-value mapping was not to provide a mapping, but rather to present a matching mechanism to drive selection of the appropriate substituting template when more than one template was available as a substitution for the abstract node. In that case, a service template was only a valid candidate for substitution if the property value in the abstract node template matched the constant value specified in the property_value mapping for that property. With the introduction of substitution filter syntax to drive matching, there is no longer a need for the property-to-constant-value mapping functionality.

· The previous version of the specification allowed direct mappings from properties of the abstract node template to properties of node templates in the substituting service template. Support for these mappings has been deprecated since they would have resulted in unpredictable behavior, for the following reason. If the substituting template is a valid TOSCA template, then all the (required) properties of all its node templates must have valid property assignments already defined. If the substitution mappings of the substituting template include direct property-to-property mappings, the the substituting template ends up with two conflicting property assignments: one defined in the substituting template itself, and one defined by the substitution mappings. These conflicting assignments lead to unpredictable behavior.

5.5.2.4 Additional constraints

· When Input mapping it may be referenced by multiple nodes in the topologies with resulting attributes values that may differ later on in the various nodes. In any situation, the attribute reflecting the property of the substituted type will remain a constant value set to the one of the input at deployment time.

5.5.3 Attribute mapping

An attribute mapping allows to map the attribute of a substituted node type an output of the service template.

5.5.3.1 Keynames

The following is the list of recognized keynames for a TOSCA attribute mapping:

Keyname	Mandatory	Type	Description
mapping	no	list of strings	An array with 1 string element that references an output of the service.

5.5.3.2 Grammar

The single-line grammar of an attribute_mapping is as follows:

<attribute_name>: [ <output_name> ]

5.5.4 Capability mapping

A capability mapping allows to map the capability of one of the nodes of the service template to the capability of the node type the service template offers an implementation for.

5.5.4.1 Keynames

The following is the list of recognized keynames for a TOSCA capability mapping:

Keyname	Mandatory	Type	Description
mapping	no	list of strings (with 2 members)	A list of strings with 2 members, the first one being the name of a node template, the second the name of a capability of the specified node template.
properties	no	map of property assignments	This field is mutually exclusive with the mapping keyname and allows to provide a capability assignment for the template and specify it’s related properties.
attributes	no	map of attributes assignments	This field is mutually exclusive with the mapping keyname and allows to provide a capability assignment for the template and specify it’s related attributes.

5.5.4.2 Grammar

The single-line grammar of a capability_mapping is as follows:

<capability_name>: [ <node_template_name>, <node_template_capability_name> ]

The multi-line grammar is as follows :

<capability_name>:

mapping: [ <node_template_name>, <node_template_capability_name> ]

properties:

<property_name>: <property_value>

attributes:

<attribute_name>: <attribute_value>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· capability_name: represents the name of the capability as it appears in the Node Type definition for the Node Type (name) that is declared as the value for on the substitution_mappings’ “node_type” key.

· node_template_name: represents a valid name of a Node Template definition (within the same service_template declaration as the substitution_mapping is declared).

· node_template_capability_name: represents a valid name of a capability definition within the <node_template_name> declared in this mapping.

· property_name: represents the name of a property of the capability.

· property_value: represents the value to assign to a property of the capability.

· attribute_name: represents the name a an attribute of the capability.

· attribute_value: represents the value to assign to an attribute of the capability.

5.5.5 Requirement mapping

A requirement mapping allows to map the requirement of one of the nodes of the service template to the requirement of the node type the service template offers an implementation for.

5.5.5.1 Keynames

The following is the list of recognized keynames for a TOSCA requirement mapping:

Keyname	Mandatory	Type	Description
mapping	no	list of strings (2 members)	A list of strings with 2 elements, the first one being the name of a node template, the second the name of a requirement of the specified node template.
properties	no	List of property assignment	This field is mutually exclusive with the mapping keyname and allow to provide a requirement for the template and specify it’s related properties.
attributes	no	List of attributes assignment	This field is mutually exclusive with the mapping keyname and allow to provide a requirement for the template and specify it’s related attributes.

5.5.5.2 Grammar

The single-line grammar of a requirement_mapping is as follows:

<requirement_name>: [ <node_template_name>, <node_template_requirement_name> ]

The multi-line grammar is as follows :

<requirement_name>:

mapping: [ <node_template_name>, <node_template_requirement_name> ]

properties:

<property_name>: <property_value>

attributes:

<attribute_name>: <attribute_value>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· node_template_name: represents a valid name of a Node Template definition (within the same service_template declaration as the substitution_mapping is declared).

· node_template_requirement_name: represents a valid name of a requirement definition within the <node_template_name> declared in this mapping.

· property_name: represents the name of a property of the requirement.

· property_value: represents the value to assign to a property of the requirement.

· attribute_name: represents the name of an attribute of the requirement.

· attribute_value: represents the value to assign to an attribute of the requirement.

5.5.6 Interface mapping

An interface mapping allows to map a workflow of the service template to an operation of the node type the service template offers an implementation for.

5.5.6.1 Grammar

The grammar of an interface_mapping is as follows:

<interface_name>:

<operation_name>: <workflow_name>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· interface_name: represents the name of the interface as it appears in the Node Type definition for the Node Type (name) that is declared as the value for on the substitution_mappings’ “node_type” key. Or the name of a new management interface to add to the generated type.

· operation_name: represents the name of the operation as it appears in the interface type definition.

· workflow_name: represents the name of a workflow of the template to map to the specified operation.

5.5.6.2 Notes

· Declarative workflow generation will be applied by the TOSCA orchestrator after the service template have been substituted. Unless one of the normative operations of the standard interface is mapped through an interface mapping. In that case the declarative workflow generation will consider the substitution node as any other node calling the create, configure and start mapped workflows as if they where single operations.

· Operation implementation being TOSCA workflows the TOSCA orchestrator replace the usual operation_call activity by an inline activity using the specified workflow.

5.6 Groups and Policies

5.6.1 Group Type

A Group Type defines logical grouping types for nodes, typically for different management purposes. Conceptually, group definitions allow the creation of logical “membership” relationships to nodes in a service template that are not a part of the application’s explicit requirement dependencies in the service template (i.e. those required to actually get the application deployed and running). Instead, such logical membership allows for the introduction of things such as group management and uniform application of policies (i.e. requirements that are also not bound to the application itself) to the group’s members. .

5.6.1.1 Keynames

The Group Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Group Type has the following recognized keynames:

Keyname	Mandatory	Type	Description
properties	no	map of property definitions	An optional map of property definitions for the Group Type.
attributes	no	map of attribute definitions	An optional map of attribute definitions for the Group Type.
members	no	list of string	An optional list of one or more names of Node Types that are valid (allowed) as members of the Group Type.

5.6.1.2 Grammar

Group Types have the following grammar:

<group_type_name>:

derived_from: <parent_group_type_name>

version: <version_number>

metadata:

description: <group_description>

properties:

attributes:

members: [ <list_of_valid_member_types> ]

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· group_type_name: represents the mandatory symbolic name of the Group Type being declared as a string.

· parent_group_type_name: represents the name (string) of the Group Type this Group Type definition derives from (i.e. its “parent” type).

· version_number: represents the optional TOSCA version number for the Group Type.

· group_description: represents the optional description string for the corresponding group_type_name.

· attribute_definitions: represents the optional map of attribute definitions for the Group Type.

· property_definitions: represents the optional map of property definitions for the Group Type.

· list_of_valid_member_types: represents the optional list of TOSCA Node Types that are valid member types for being added to (i.e. members of) the Group Type; if the members keyname is not defined then there are no restrictions to the member types;

– note that the members of a group ultimately resolve to nodes, the types here just restrict which nodes can be defined as members in a group definition.

– A node type is matched if it is the specified type or is derived from the node type

5.6.1.3 Derivation rules

During Group Type derivation the keyname definitions follow these rules:

· properties: existing property definitions may be refined; new property definitions may be added.

· attributes: existing attribute definitions may be refined; new attribute definitions may be added.

· members: if the members keyname is defined in the parent type, each element in this list must either be in the parent type list or derived from an element in the parent type list; if the members keyname is not defined in the parent type then no restrictions are applied to the definition.

5.6.1.4 Example

The following represents a Group Type definition:

group_types:

mycompany.mytypes.groups.placement:

description: My company’s group type for placing nodes of type Compute

members: [ tosca.nodes.Compute ]

5.6.2 Group definition

Collections of Nodes may be defined using a Group. A group definition defines a logical grouping of node templates, typically for management purposes, but is separate from the application’s service template.

5.6.2.1 Keynames

The following is the list of recognized keynames for a TOSCA group definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory name of the group type the group definition is based upon.
description	no	string	The optional description for the group definition.
metadata	no	map of string	Defines a section used to declare additional metadata information.
properties	no	map of property assignments	An optional map of property value assignments for the group definition.
attributes	no	map of attribute assignments	An optional map of attribute value assignments for the group definition.
members	no	list of string	The optional list of one or more node template names that are members of this group definition.

5.6.2.2 Grammar

Group definitions have one the following grammars:

<group_name>:

type: <group_type_name>

description: <group_description>

metadata:

properties:

attributes:

members: [ <list_of_node_templates> ]

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· group_name: represents the mandatory symbolic name of the group as a string.

· group_type_name: represents the name of the Group Type the definition is based upon.

· group_description: contains an optional description of the group.

· property_assignments: represents the optional map of property assignments for the group definition that provide values for properties defined in its declared Group Type.

· attribute_assigments: represents the optional map of attribute assignments for the group definition that provide values for attributes defined in its declared Group Type.

· list_of_node_templates: contains the mandatory list of one or more node template names or group symbolic names (within the same service template) that are members of this logical group

– if the members keyname was defined (by specifying a list_of_valid_member_types) in the group type of this group then the nodes listed here must be compatible (i.e. be of that type or of type that is derived from) with the node types in the list_of_valid_member_types

5.6.2.3 Example

The following represents a group definition:

groups:

my_app_placement_group:

type: tosca.groups.Root

description: My application’s logical component grouping for placement

members: [ my_web_server, my_sql_database ]

5.6.3 Policy Type

A Policy Type defines a type of a policy that affects or governs an application or service’s topology at some stage of its lifecycle but is not explicitly part of the topology itself (i.e., it does not prevent the application or service from being deployed or run if it did not exist).

5.6.3.1 Keynames

The Policy Type is a TOSCA type entity and has the common keynames listed in Section 4.2.5.2 Common keynames in type definitions. In addition, the Policy Type has the following recognized keynames:

Keyname	Mandatory	Type	Description
properties	no	map of property definitions	An optional map of property definitions for the Policy Type.
targets	no	list of string	An optional list of valid Node Types or Group Types the Policy Type can be applied to.
triggers	no	map of trigger definitions	An optional map of policy triggers for the Policy Type.

5.6.3.2 Grammar

Policy Types have the following grammar:

<policy_type_name>:

derived_from: <parent_policy_type_name>

version: <version_number>

metadata:

description: <policy_description>

properties:

targets: [ <list_of_valid_target_types> ]

triggers:

<trigger_definitions>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· policy_type_name: represents the mandatory symbolic name of the Policy Type being declared as a string.

· parent_policy_type_name: represents the name (string) of the Policy Type this Policy Type definition derives from (i.e., its “parent” type).

· version_number: represents the optional TOSCA version number for the Policy Type.

· policy_description: represents the optional description string for the corresponding policy_type_name.

· property_definitions: represents the optional map of property definitions for the Policy Type.

· list_of_valid_target_types: represents the optional list of TOSCA types (i.e. Group or Node Types) that are valid targets for this Policy Type; if the targets keyname is not defined then there are no restrictions to the targets’ types.

· trigger_definitions: represents the optional map of trigger definitions for the policy.

5.6.3.3 Derivation rules

During Policy Type derivation the keyname definitions follow these rules:

· properties: existing property definitions may be refined; new property definitions may be added.

· targets: if the targets keyname is defined in the parent type, each element in this list must either be in the parent type list or derived from an element in the parent type list; if the targets keyname is not defined in the parent type then no restrictions are applied to this definition.

· triggers: existing trigger definitions may not be changed; new trigger definitions may be added.

5.6.3.4 Example

The following represents a Policy Type definition:

policy_types:

mycompany.mytypes.policies.placement.Container.Linux:

description: My company’s placement policy for linux

derived_from: tosca.policies.Root

5.6.4 Policy definition

A policy definition defines a policy that can be associated with a TOSCA service or top-level entity definition (e.g., group definition, node template, etc.).

5.6.4.1 Keynames

The following is the list of recognized keynames for a TOSCA policy definition:

Keyname	Mandatory	Type	Description
type	yes	string	The mandatory name of the policy type the policy definition is based upon.
description	no	string	The optional description for the policy definition.
metadata	no	map of string	Defines a section used to declare additional metadata information.
properties	no	map of property assignments	An optional map of property value assignments for the policy definition.
targets	no	list of string	An optional list of valid Node Templates or Groups the Policy can be applied to.
triggers	no	map of trigger definitions	An optional map of trigger definitions to invoke when the policy is applied by an orchestrator against the associated TOSCA entity. These triggers apply in addition to the triggers defined in the policy type.

5.6.4.2 Grammar

Policy definitions have one the following grammars:

<policy_name>:

type: <policy_type_name>

description: <policy_description>

metadata:

properties:

targets: [<list_of_policy_targets>]

triggers:

<trigger_definitions>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· policy_name: represents the mandatory symbolic name of the policy as a string.

· policy_type_name: represents the name of the policy the definition is based upon.

· policy_description: contains an optional description of the policy.

· property_assignments: represents the optional map of property assignments for the policy definition that provide values for properties defined in its declared Policy Type.

· list_of_policy_targets: represents the optional list of names of node templates or groups that the policy is to applied to.

– if the targets keyname was defined (by specifying a list_of_valid_target_types) in the policy type of this policy then the targets listed here must be compatible (i.e. be of that type or of type that is derived from) with the types (of nodes or groups) in the list_of_valid_target_types.

· trigger_definitions: represents the optional map of trigger definitions for the policy; these triggers apply in addition to the triggers defined in the policy type.

5.6.4.3 Example

The following represents a policy definition:

policies:

- my_compute_placement_policy:

type: tosca.policies.placement

description: Apply my placement policy to my application’s servers

targets: [ my_server_1, my_server_2 ]

# remainder of policy definition left off for brevity

5.6.5 Trigger definition

A trigger definition defines the event, condition and action that is used to “trigger” a policy with which it is associated.

5.6.5.1 Keynames

The following is the list of recognized keynames for a TOSCA trigger definition:

Keyname	Mandatory	Type	Description
description	no	string	The optional description string for the trigger.
event	yes	string	The mandatory name of the event that activates the trigger’s action.
condition	no	condition clause	The optional condition that must evaluate to true in order for the trigger’s action to be performed. Note: this is optional since sometimes the event occurrence itself is enough to trigger the action.
action	yes	list of activity definition	The list of sequential activities to be performed when the event is triggered, and the condition is met (i.e., evaluates to true).

5.6.5.2 Grammar

Trigger definitions have the following grammars:

<trigger_name>:

description: <trigger_description>

event: <event_name>

condition: <condition_clause>

action:

- <list_of_activity_definition>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· trigger_name: represents the mandatory symbolic name of the trigger as a string.

· trigger_description: represents the optional description string for the corresponding trigger_name.

· event_name: represents the mandatory name of an event associated with an interface notification on the identified resource (node). .

· condition_clause: an optional Boolean expression that can be evaluated within the context of the service with which the policy is associated and that must evaluate to true in order for the trigger’s action to be performed. Note that the arguments to the condition clause function can in turn be other TOSCA functions. If no condition clause is specified, the trigger event will always result in the trigger’s action being taken.

· list_of_activity_definition: represents the list of activities that are performed in response to the event if the (optional) condition is met.

5.6.6 Activity definitions

An activity defines an operation to be performed in a TOSCA workflow step or in an action body of a policy trigger. Activity definitions can be of the following types:

· Delegate workflow activity definition:

– Defines the name of the delegate workflow and optional input assignments. This activity requires the target to be provided by the orchestrator (no-op node or relationship).

· Set state activity definition:

– Sets the state of a node.

· Call operation activity definition:

– Calls an operation defined on a TOSCA interface of a node, relationship or group. The operation name uses the <interface_name>.<operation_name> notation. Optionally, assignments for the operation inputs can also be provided. If provided, they will override for this operation call the operation inputs assignment in the node template.

· Inline workflow activity definition:

– Inlines another workflow defined in the service (allowing reusability). The definition includes the name of a workflow to be inlined and optional workflow input assignments.

5.6.6.1 Delegate workflow activity definition

5.6.6.1.1 Keynames

The following is a list of recognized keynames for a delegate activity definition.

Keyname	Mandatory	Type	Description
delegate	yes	string or empty (see grammar below)	Defines the name of the delegate workflow and optional input assignments. This activity requires the target to be provided by the orchestrator (no-op node or relationship).
workflow	no	string	The name of the delegate workflow. Mandatory in the extended notation.
inputs	no	map of parameter assignments	The optional map of input parameter assignments for the delegate workflow.

5.6.6.1.2 Grammar

A delegate activity definition has the following grammar. The short notation can be used if no input assignments are provided.

5.6.6.1.2.1 Short notation

- delegate: <delegate_workflow_name>

5.6.6.1.2.2 Extended notation

- delegate:

workflow: <delegate_workflow_name>

inputs:

<parameter_assignments>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· delegate_workflow_name: represents the name of the workflow of the node provided by the TOSCA orchestrator.

· parameter_assignments: represents the optional map of parameter assignments for passing parameters as inputs to this workflow delegation.

5.6.6.2 Set state activity definition

Sets the state of the target node.

5.6.6.2.1 Keynames

The following is a list of recognized keynames for a set state activity definition.

Keyname	Mandatory	Type	Description
set_state	yes	string	Value of the node state.

5.6.6.2.2 Grammar

A set state activity definition has the following grammar.

- set_state: <new_node_state>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· new_node_state: represents the state that will be affected to the node once the activity is performed.

5.6.6.3 Call operation activity definition

This activity is used to call an operation on the target node. Operation input assignments can be optionally provided.

5.6.6.3.1 Keynames

The following is a list of recognized keynames for a call operation activity definition.

Keyname	Mandatory	Type	Description
call_operation	yes	string or empty (see grammar below)	Defines the opration call. The operation name uses the <interface_name>.<operation_name> notation. Optionally, assignments for the operation inputs can also be provided. If provided, they will override for this operation call the operation inputs assignment in the node template.
operation	no	string	The name of the operation to call, using the <interface_name>.<operation_name> notation. Mandatory in the extended notation.
inputs	no	map of parameter assignments	The optional map of input parameter assignments for the called operation. Any provided input assignments will override the operation input assignment in the target node template for this operation call.

5.6.6.3.2 Grammar

A call operation activity definition has the following grammar. The short notation can be used if no input assignments are provided.

5.6.6.3.2.1 Short notation

- call_operation: <operation_name>

5.6.6.3.2.2 Extended notation

- call_operation:

operation: <operation_name>

inputs:

<parameter_assignments>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· operation_name: represents the name of the operation that will be called during the workflow execution. The notation used is <interface_sub_name>.<operation_sub_name>, where interface_sub_name is the interface name and the operation_sub_name is the name of the operation within this interface.

· parameter_assignments: represents the optional map of parameter assignments for passing parameters as inputs to this workflow delegation.

5.6.6.4 Inline workflow activity definition

This activity is used to inline a workflow in the activities sequence. The definition includes the name of the inlined workflow and optional input assignments.

5.6.6.4.1 Keynames

The following is a list of recognized keynames for an inline workflow activity definition.

Keyname	Mandatory	Type	Description
inline	yes	string or empty (see grammar below)	The definition includes the name of a workflow to be inlined and optional workflow input assignments.
workflow	no	string	The name of the inlined workflow. Mandatory in the extended notation.
inputs	no	map of parameter assignments	The optional map of input parameter assignments for the inlined workflow.

5.6.6.4.2 Grammar

An inline workflow activity definition has the following grammar. The short notation can be used if no input assignments are provided.

5.6.6.4.2.1 Short notation

- inline: <inlined_workflow_name>

5.6.6.4.2.2 Extended notation

- inline:

workflow: <inlined_workflow_name>

inputs:

<parameter_assignments>

In the above grammar, the pseudo values that appear in angle brackets have the following meaning:

· inlined_workflow_name: represents the name of the workflow to inline.

· parameter_assignments: represents the optional map of parameter assignments for passing parameters as inputs to this workflow delegation.

5.6.6.5 Example

The following represents a list of activity definitions (using the short notation):

- delegate: deploy

- set_state: started

- call_operation: tosca.interfaces.node.lifecycle.Standard.start

- inline: my_workflow

5.7 Workflows

5.7.1 Imperative Workflow definition

A workflow definition defines an imperative workflow that is associated with a TOSCA service. A workflow definition can either include the steps that make up the workflow, or it can refer to an artifact that expresses the workflow using an external workflow language.

5.7.1.1 Keynames

The following is the list of recognized keynames for a TOSCA workflow definition:

Keyname	Mandatory	Type	Description
description	no	string	The optional description for the workflow definition.
metadata	no	map of string	Defines a section used to declare additional metadata information.
inputs	no	map of parameter definitions	The optional map of input parameter definitions.
precondition	no	condition clause	Condition clause that must evaluate to true before the workflow can be processed.
steps	no	map of step definitions	An optional map of valid imperative workflow step definitions.
implementation	no	operation implementation definition	The optional definition of an external workflow definition. This keyname is mutually exclusive with the steps keyname above.
outputs	no	map of attribute mappings	The optional map of attribute mappings that specify workflow output values and their mappings onto attributes of a node or relationship defined in the service.

5.7.1.2 Grammar

Imperative workflow definitions have the following grammar:

<workflow_name>:

description: <workflow_description>

metadata:

inputs: