summaryrefslogtreecommitdiffstats
path: root/tosca2heat/tosca-parser/toscaparser/elements
diff options
context:
space:
mode:
authorjulien zhang <zhang.jun3g@zte.com.cn>2016-04-22 08:43:26 +0000
committerGerrit Code Review <gerrit@172.30.200.206>2016-04-22 08:43:26 +0000
commit2fa4785aa218cf655f3405d832d2200d64fd033e (patch)
tree0061edccecca9a99aa9a50c6c0e2783c07370112 /tosca2heat/tosca-parser/toscaparser/elements
parent56c2a5d3ba6193c9a98870a264bc5e3aca19a086 (diff)
parentc8201c119ec686e79797721156767685fe848aca (diff)
Merge "Update tosca lib to version 0.5"
Diffstat (limited to 'tosca2heat/tosca-parser/toscaparser/elements')
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/TOSCA_definition_1_0.yaml926
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/__init__.py0
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/artifacttype.py45
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/attribute_definition.py20
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/capabilitytype.py75
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/constraints.py611
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/datatype.py56
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/entity_type.py145
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/grouptype.py86
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/interfaces.py76
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/nodetype.py226
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/policytype.py115
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/property_definition.py100
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/relationshiptype.py33
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/scalarunit.py129
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/statefulentitytype.py84
-rw-r--r--tosca2heat/tosca-parser/toscaparser/elements/tosca_type_validation.py58
17 files changed, 2785 insertions, 0 deletions
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/TOSCA_definition_1_0.yaml b/tosca2heat/tosca-parser/toscaparser/elements/TOSCA_definition_1_0.yaml
new file mode 100644
index 0000000..f8d781c
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/TOSCA_definition_1_0.yaml
@@ -0,0 +1,926 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+##########################################################################
+# The content of this file reflects TOSCA Simple Profile in YAML version
+# 1.0.0. It describes the definition for TOSCA types including Node Type,
+# Relationship Type, Capability Type and Interfaces.
+##########################################################################
+tosca_definitions_version: tosca_simple_yaml_1_0
+
+##########################################################################
+# Node Type.
+# A Node Type is a reusable entity that defines the type of one or more
+# Node Templates.
+##########################################################################
+tosca.nodes.Root:
+ description: >
+ The TOSCA root node all other TOSCA base node types derive from.
+ attributes:
+ tosca_id:
+ type: string
+ tosca_name:
+ type: string
+ state:
+ type: string
+ capabilities:
+ feature:
+ type: tosca.capabilities.Node
+ requirements:
+ - dependency:
+ capability: tosca.capabilities.Node
+ node: tosca.nodes.Root
+ relationship: tosca.relationships.DependsOn
+ occurrences: [ 0, UNBOUNDED ]
+ interfaces:
+ Standard:
+ type: tosca.interfaces.node.lifecycle.Standard
+
+tosca.nodes.Compute:
+ derived_from: tosca.nodes.Root
+ attributes:
+ private_address:
+ type: string
+ public_address:
+ type: string
+ networks:
+ type: map
+ entry_schema:
+ type: tosca.datatypes.network.NetworkInfo
+ ports:
+ type: map
+ entry_schema:
+ type: tosca.datatypes.network.PortInfo
+ capabilities:
+ host:
+ type: tosca.capabilities.Container
+ binding:
+ type: tosca.capabilities.network.Bindable
+ os:
+ type: tosca.capabilities.OperatingSystem
+ scalable:
+ type: tosca.capabilities.Scalable
+ requirements:
+ - local_storage:
+ capability: tosca.capabilities.Attachment
+ node: tosca.nodes.BlockStorage
+ relationship: tosca.relationships.AttachesTo
+ occurrences: [0, UNBOUNDED]
+
+tosca.nodes.SoftwareComponent:
+ derived_from: tosca.nodes.Root
+ properties:
+ # domain-specific software component version
+ component_version:
+ type: version
+ required: false
+ description: >
+ Software component version.
+ admin_credential:
+ type: tosca.datatypes.Credential
+ required: false
+ requirements:
+ - host:
+ capability: tosca.capabilities.Container
+ node: tosca.nodes.Compute
+ relationship: tosca.relationships.HostedOn
+
+tosca.nodes.DBMS:
+ derived_from: tosca.nodes.SoftwareComponent
+ properties:
+ port:
+ required: false
+ type: integer
+ description: >
+ The port the DBMS service will listen to for data and requests.
+ root_password:
+ required: false
+ type: string
+ description: >
+ The root password for the DBMS service.
+ capabilities:
+ host:
+ type: tosca.capabilities.Container
+ valid_source_types: [tosca.nodes.Database]
+
+tosca.nodes.Database:
+ derived_from: tosca.nodes.Root
+ properties:
+ user:
+ required: false
+ type: string
+ description: >
+ User account name for DB administration
+ port:
+ required: false
+ type: integer
+ description: >
+ The port the database service will use to listen for incoming data and
+ requests.
+ name:
+ required: false
+ type: string
+ description: >
+ The name of the database.
+ password:
+ required: false
+ type: string
+ description: >
+ The password for the DB user account
+ requirements:
+ - host:
+ capability: tosca.capabilities.Container
+ node: tosca.nodes.DBMS
+ relationship: tosca.relationships.HostedOn
+ capabilities:
+ database_endpoint:
+ type: tosca.capabilities.Endpoint.Database
+
+tosca.nodes.WebServer:
+ derived_from: tosca.nodes.SoftwareComponent
+ capabilities:
+ data_endpoint:
+ type: tosca.capabilities.Endpoint
+ admin_endpoint:
+ type: tosca.capabilities.Endpoint.Admin
+ host:
+ type: tosca.capabilities.Container
+ valid_source_types: [tosca.nodes.WebApplication]
+
+tosca.nodes.WebApplication:
+ derived_from: tosca.nodes.Root
+ properties:
+ context_root:
+ type: string
+ required: false
+ requirements:
+ - host:
+ capability: tosca.capabilities.Container
+ node: tosca.nodes.WebServer
+ relationship: tosca.relationships.HostedOn
+ capabilities:
+ app_endpoint:
+ type: tosca.capabilities.Endpoint
+
+tosca.nodes.BlockStorage:
+ derived_from: tosca.nodes.Root
+ properties:
+ size:
+ type: scalar-unit.size
+ constraints:
+ - greater_or_equal: 1 MB
+ volume_id:
+ type: string
+ required: false
+ snapshot_id:
+ type: string
+ required: false
+ attributes:
+ volume_id:
+ type: string
+ capabilities:
+ attachment:
+ type: tosca.capabilities.Attachment
+
+tosca.nodes.network.Network:
+ derived_from: tosca.nodes.Root
+ description: >
+ The TOSCA Network node represents a simple, logical network service.
+ properties:
+ ip_version:
+ type: integer
+ required: false
+ default: 4
+ constraints:
+ - valid_values: [ 4, 6 ]
+ description: >
+ The IP version of the requested network. Valid values are 4 for ipv4
+ or 6 for ipv6.
+ cidr:
+ type: string
+ required: false
+ description: >
+ The cidr block of the requested network.
+ start_ip:
+ type: string
+ required: false
+ description: >
+ The IP address to be used as the start of a pool of addresses within
+ the full IP range derived from the cidr block.
+ end_ip:
+ type: string
+ required: false
+ description: >
+ The IP address to be used as the end of a pool of addresses within
+ the full IP range derived from the cidr block.
+ gateway_ip:
+ type: string
+ required: false
+ description: >
+ The gateway IP address.
+ network_name:
+ type: string
+ required: false
+ description: >
+ An identifier that represents an existing Network instance in the
+ underlying cloud infrastructure or can be used as the name of the
+ newly created network. If network_name is provided and no other
+ properties are provided (with exception of network_id), then an
+ existing network instance will be used. If network_name is provided
+ alongside with more properties then a new network with this name will
+ be created.
+ network_id:
+ type: string
+ required: false
+ description: >
+ An identifier that represents an existing Network instance in the
+ underlying cloud infrastructure. This property is mutually exclusive
+ with all other properties except network_name. This can be used alone
+ or together with network_name to identify an existing network.
+ segmentation_id:
+ type: string
+ required: false
+ description: >
+ A segmentation identifier in the underlying cloud infrastructure.
+ E.g. VLAN ID, GRE tunnel ID, etc..
+ network_type:
+ type: string
+ required: false
+ description: >
+ It specifies the nature of the physical network in the underlying
+ cloud infrastructure. Examples are flat, vlan, gre or vxlan.
+ For flat and vlan types, physical_network should be provided too.
+ physical_network:
+ type: string
+ required: false
+ description: >
+ It identifies the physical network on top of which the network is
+ implemented, e.g. physnet1. This property is required if network_type
+ is flat or vlan.
+ dhcp_enabled:
+ type: boolean
+ required: false
+ default: true
+ description: >
+ Indicates should DHCP service be enabled on the network or not.
+ capabilities:
+ link:
+ type: tosca.capabilities.network.Linkable
+
+tosca.nodes.network.Port:
+ derived_from: tosca.nodes.Root
+ description: >
+ The TOSCA Port node represents a logical entity that associates between
+ Compute and Network normative types. The Port node type effectively
+ represents a single virtual NIC on the Compute node instance.
+ properties:
+ ip_address:
+ type: string
+ required: false
+ description: >
+ Allow the user to set a static IP.
+ order:
+ type: integer
+ required: false
+ default: 0
+ constraints:
+ - greater_or_equal: 0
+ description: >
+ The order of the NIC on the compute instance (e.g. eth2).
+ is_default:
+ type: boolean
+ required: false
+ default: false
+ description: >
+ If is_default=true this port will be used for the default gateway
+ route. Only one port that is associated to single compute node can
+ set as is_default=true.
+ ip_range_start:
+ type: string
+ required: false
+ description: >
+ Defines the starting IP of a range to be allocated for the compute
+ instances that are associated with this Port.
+ ip_range_end:
+ type: string
+ required: false
+ description: >
+ Defines the ending IP of a range to be allocated for the compute
+ instances that are associated with this Port.
+ attributes:
+ ip_address:
+ type: string
+ requirements:
+ - binding:
+ description: >
+ Binding requirement expresses the relationship between Port and
+ Compute nodes. Effectively it indicates that the Port will be
+ attached to specific Compute node instance
+ capability: tosca.capabilities.network.Bindable
+ relationship: tosca.relationships.network.BindsTo
+ node: tosca.nodes.Compute
+ - link:
+ description: >
+ Link requirement expresses the relationship between Port and Network
+ nodes. It indicates which network this port will connect to.
+ capability: tosca.capabilities.network.Linkable
+ relationship: tosca.relationships.network.LinksTo
+ node: tosca.nodes.network.Network
+
+tosca.nodes.ObjectStorage:
+ derived_from: tosca.nodes.Root
+ description: >
+ The TOSCA ObjectStorage node represents storage that provides the ability
+ to store data as objects (or BLOBs of data) without consideration for the
+ underlying filesystem or devices
+ properties:
+ name:
+ type: string
+ required: true
+ description: >
+ The logical name of the object store (or container).
+ size:
+ type: scalar-unit.size
+ required: false
+ constraints:
+ - greater_or_equal: 0 GB
+ description: >
+ The requested initial storage size.
+ maxsize:
+ type: scalar-unit.size
+ required: false
+ constraints:
+ - greater_or_equal: 0 GB
+ description: >
+ The requested maximum storage size.
+ capabilities:
+ storage_endpoint:
+ type: tosca.capabilities.Endpoint
+
+tosca.nodes.LoadBalancer:
+ derived_from: tosca.nodes.Root
+ properties:
+ algorithm:
+ type: string
+ required: false
+ status: experimental
+ capabilities:
+ client:
+ type: tosca.capabilities.Endpoint.Public
+ occurrences: [0, UNBOUNDED]
+ description: the Floating (IP) client’s on the public network can connect to
+ requirements:
+ - application:
+ capability: tosca.capabilities.Endpoint
+ relationship: tosca.relationships.RoutesTo
+ occurrences: [0, UNBOUNDED]
+ description: Connection to one or more load balanced applications
+
+tosca.nodes.Container.Application:
+ derived_from: tosca.nodes.Root
+ requirements:
+ - host:
+ capability: tosca.capabilities.Container
+ node: tosca.nodes.Container
+ relationship: tosca.relationships.HostedOn
+
+tosca.nodes.Container.Runtime:
+ derived_from: tosca.nodes.SoftwareComponent
+ capabilities:
+ host:
+ type: tosca.capabilities.Container
+ scalable:
+ type: tosca.capabilities.Scalable
+
+tosca.nodes.Container.Application.Docker:
+ derived_from: tosca.nodes.Container.Application
+ requirements:
+ - host:
+ capability: tosca.capabilities.Container.Docker
+
+##########################################################################
+# Relationship Type.
+# A Relationship Type is a reusable entity that defines the type of one
+# or more relationships between Node Types or Node Templates.
+##########################################################################
+tosca.relationships.Root:
+ description: >
+ The TOSCA root Relationship Type all other TOSCA base Relationship Types
+ derive from.
+ attributes:
+ tosca_id:
+ type: string
+ tosca_name:
+ type: string
+ interfaces:
+ Configure:
+ type: tosca.interfaces.relationship.Configure
+
+tosca.relationships.DependsOn:
+ derived_from: tosca.relationships.Root
+
+tosca.relationships.HostedOn:
+ derived_from: tosca.relationships.Root
+ valid_target_types: [ tosca.capabilities.Container ]
+
+tosca.relationships.ConnectsTo:
+ derived_from: tosca.relationships.Root
+ valid_target_types: [ tosca.capabilities.Endpoint ]
+ credential:
+ type: tosca.datatypes.Credential
+ required: false
+
+tosca.relationships.AttachesTo:
+ derived_from: tosca.relationships.Root
+ valid_target_types: [ tosca.capabilities.Attachment ]
+ properties:
+ location:
+ required: true
+ type: string
+ constraints:
+ - min_length: 1
+ device:
+ required: false
+ type: string
+
+tosca.relationships.RoutesTo:
+ derived_from: tosca.relationships.ConnectsTo
+ valid_target_types: [ tosca.capabilities.Endpoint ]
+
+tosca.relationships.network.LinksTo:
+ derived_from: tosca.relationships.DependsOn
+ valid_target_types: [ tosca.capabilities.network.Linkable ]
+
+tosca.relationships.network.BindsTo:
+ derived_from: tosca.relationships.DependsOn
+ valid_target_types: [ tosca.capabilities.network.Bindable ]
+
+##########################################################################
+# Capability Type.
+# A Capability Type is a reusable entity that describes a kind of
+# capability that a Node Type can declare to expose.
+##########################################################################
+tosca.capabilities.Root:
+ description: >
+ The TOSCA root Capability Type all other TOSCA base Capability Types
+ derive from.
+
+tosca.capabilities.Node:
+ derived_from: tosca.capabilities.Root
+
+tosca.capabilities.Container:
+ derived_from: tosca.capabilities.Root
+ properties:
+ num_cpus:
+ required: false
+ type: integer
+ constraints:
+ - greater_or_equal: 1
+ cpu_frequency:
+ required: false
+ type: scalar-unit.frequency
+ constraints:
+ - greater_or_equal: 0.1 GHz
+ disk_size:
+ required: false
+ type: scalar-unit.size
+ constraints:
+ - greater_or_equal: 0 MB
+ mem_size:
+ required: false
+ type: scalar-unit.size
+ constraints:
+ - greater_or_equal: 0 MB
+
+tosca.capabilities.Endpoint:
+ derived_from: tosca.capabilities.Root
+ properties:
+ protocol:
+ type: string
+ required: true
+ default: tcp
+ port:
+ type: tosca.datatypes.network.PortDef
+ required: false
+ secure:
+ type: boolean
+ required: false
+ default: false
+ url_path:
+ type: string
+ required: false
+ port_name:
+ type: string
+ required: false
+ network_name:
+ type: string
+ required: false
+ initiator:
+ type: string
+ required: false
+ default: source
+ constraints:
+ - valid_values: [source, target, peer]
+ ports:
+ type: map
+ required: false
+ constraints:
+ - min_length: 1
+ entry_schema:
+ type: tosca.datatypes.network.PortSpec
+ attributes:
+ ip_address:
+ type: string
+
+tosca.capabilities.Endpoint.Admin:
+ derived_from: tosca.capabilities.Endpoint
+ properties:
+ secure:
+ type: boolean
+ default: true
+ constraints:
+ - equal: true
+
+tosca.capabilities.Endpoint.Public:
+ derived_from: tosca.capabilities.Endpoint
+ properties:
+ # Change the default network_name to use the first public network found
+ network_name:
+ type: string
+ default: PUBLIC
+ constraints:
+ - equal: PUBLIC
+ floating:
+ description: >
+ Indicates that the public address should be allocated from a pool of
+ floating IPs that are associated with the network.
+ type: boolean
+ default: false
+ status: experimental
+ dns_name:
+ description: The optional name to register with DNS
+ type: string
+ required: false
+ status: experimental
+
+tosca.capabilities.Scalable:
+ derived_from: tosca.capabilities.Root
+ properties:
+ min_instances:
+ type: integer
+ required: true
+ default: 1
+ description: >
+ This property is used to indicate the minimum number of instances
+ that should be created for the associated TOSCA Node Template by
+ a TOSCA orchestrator.
+ max_instances:
+ type: integer
+ required: true
+ default: 1
+ description: >
+ This property is used to indicate the maximum number of instances
+ that should be created for the associated TOSCA Node Template by
+ a TOSCA orchestrator.
+ default_instances:
+ type: integer
+ required: false
+ description: >
+ An optional property that indicates the requested default number
+ of instances that should be the starting number of instances a
+ TOSCA orchestrator should attempt to allocate.
+ The value for this property MUST be in the range between the values
+ set for min_instances and max_instances properties.
+
+tosca.capabilities.Endpoint.Database:
+ derived_from: tosca.capabilities.Endpoint
+
+tosca.capabilities.Attachment:
+ derived_from: tosca.capabilities.Root
+
+tosca.capabilities.network.Linkable:
+ derived_from: tosca.capabilities.Root
+ description: >
+ A node type that includes the Linkable capability indicates that it can
+ be pointed by tosca.relationships.network.LinksTo relationship type, which
+ represents an association relationship between Port and Network node types.
+
+tosca.capabilities.network.Bindable:
+ derived_from: tosca.capabilities.Root
+ description: >
+ A node type that includes the Bindable capability indicates that it can
+ be pointed by tosca.relationships.network.BindsTo relationship type, which
+ represents a network association relationship between Port and Compute node
+ types.
+
+tosca.capabilities.OperatingSystem:
+ derived_from: tosca.capabilities.Root
+ properties:
+ architecture:
+ required: false
+ type: string
+ description: >
+ The host Operating System (OS) architecture.
+ type:
+ required: false
+ type: string
+ description: >
+ The host Operating System (OS) type.
+ distribution:
+ required: false
+ type: string
+ description: >
+ The host Operating System (OS) distribution. Examples of valid values
+ for an “type” of “Linux” would include:
+ debian, fedora, rhel and ubuntu.
+ version:
+ required: false
+ type: version
+ description: >
+ The host Operating System version.
+
+tosca.capabilities.Container.Docker:
+ derived_from: tosca.capabilities.Container
+ properties:
+ version:
+ type: list
+ required: false
+ entry_schema:
+ type: version
+ description: >
+ The Docker version capability.
+ publish_all:
+ type: boolean
+ default: false
+ required: false
+ description: >
+ Indicates that all ports (ranges) listed in the dockerfile
+ using the EXPOSE keyword be published.
+ publish_ports:
+ type: list
+ entry_schema:
+ type: PortSpec
+ required: false
+ description: >
+ List of ports mappings from source (Docker container)
+ to target (host) ports to publish.
+ expose_ports:
+ type: list
+ entry_schema:
+ type: PortSpec
+ required: false
+ description: >
+ List of ports mappings from source (Docker container) to expose
+ to other Docker containers (not accessible outside host).
+ volumes:
+ type: list
+ entry_schema:
+ type: string
+ required: false
+ description: >
+ The dockerfile VOLUME command which is used to enable access
+ from the Docker container to a directory on the host machine.
+ host_id:
+ type: string
+ required: false
+ description: >
+ The optional identifier of an existing host resource
+ that should be used to run this container on.
+ volume_id:
+ type: string
+ required: false
+ description: >
+ The optional identifier of an existing storage volume (resource)
+ that should be used to create the container's mount point(s) on.
+
+##########################################################################
+ # Interfaces Type.
+ # The Interfaces element describes a list of one or more interface
+ # definitions for a modelable entity (e.g., a Node or Relationship Type)
+ # as defined within the TOSCA Simple Profile specification.
+##########################################################################
+tosca.interfaces.node.lifecycle.Standard:
+ create:
+ description: Standard lifecycle create operation.
+ configure:
+ description: Standard lifecycle configure operation.
+ start:
+ description: Standard lifecycle start operation.
+ stop:
+ description: Standard lifecycle stop operation.
+ delete:
+ description: Standard lifecycle delete operation.
+
+tosca.interfaces.relationship.Configure:
+ pre_configure_source:
+ description: Operation to pre-configure the source endpoint.
+ pre_configure_target:
+ description: Operation to pre-configure the target endpoint.
+ post_configure_source:
+ description: Operation to post-configure the source endpoint.
+ post_configure_target:
+ description: Operation to post-configure the target endpoint.
+ add_target:
+ description: Operation to add a target node.
+ remove_target:
+ description: Operation to remove a target node.
+ add_source: >
+ description: Operation to notify the target node of a source node which
+ is now available via a relationship.
+ description:
+ target_changed: >
+ description: Operation to notify source some property or attribute of the
+ target changed
+
+##########################################################################
+ # Data Type.
+ # A Datatype is a complex data type declaration which contains other
+ # complex or simple data types.
+##########################################################################
+tosca.datatypes.Root:
+ description: >
+ The TOSCA root Data Type all other TOSCA base Data Types derive from
+
+tosca.datatypes.network.NetworkInfo:
+ derived_from: tosca.datatypes.Root
+ properties:
+ network_name:
+ type: string
+ network_id:
+ type: string
+ addresses:
+ type: list
+ entry_schema:
+ type: string
+
+tosca.datatypes.network.PortInfo:
+ derived_from: tosca.datatypes.Root
+ properties:
+ port_name:
+ type: string
+ port_id:
+ type: string
+ network_id:
+ type: string
+ mac_address:
+ type: string
+ addresses:
+ type: list
+ entry_schema:
+ type: string
+
+tosca.datatypes.network.PortDef:
+ derived_from: tosca.datatypes.Root
+ type: integer
+ constraints:
+ - in_range: [ 1, 65535 ]
+
+tosca.datatypes.network.PortSpec:
+ derived_from: tosca.datatypes.Root
+ properties:
+ protocol:
+ type: string
+ required: true
+ default: tcp
+ constraints:
+ - valid_values: [ udp, tcp, igmp ]
+ target:
+ type: PortDef
+ required: false
+ target_range:
+ type: range
+ required: false
+ constraints:
+ - in_range: [ 1, 65535 ]
+ source:
+ type: PortDef
+ required: false
+ source_range:
+ type: range
+ required: false
+ constraints:
+ - in_range: [ 1, 65535 ]
+
+tosca.datatypes.Credential:
+ derived_from: tosca.datatypes.Root
+ properties:
+ protocol:
+ type: string
+ token_type:
+ type: string
+ token:
+ type: string
+ keys:
+ type: map
+ entry_schema:
+ type: string
+ user:
+ type: string
+ required: false
+
+##########################################################################
+ # Artifact Type.
+ # An Artifact Type is a reusable entity that defines the type of one or more
+ # files which Node Types or Node Templates can have dependent relationships
+ # and used during operations such as during installation or deployment.
+##########################################################################
+tosca.artifacts.Root:
+ description: >
+ The TOSCA Artifact Type all other TOSCA Artifact Types derive from
+ properties:
+ version: version
+
+tosca.artifacts.File:
+ derived_from: tosca.artifacts.Root
+
+tosca.artifacts.Deployment:
+ derived_from: tosca.artifacts.Root
+ description: TOSCA base type for deployment artifacts
+
+tosca.artifacts.Deployment.Image:
+ derived_from: tosca.artifacts.Deployment
+
+tosca.artifacts.Deployment.Image.VM:
+ derived_from: tosca.artifacts.Deployment.Image
+
+tosca.artifacts.Implementation:
+ derived_from: tosca.artifacts.Root
+ description: TOSCA base type for implementation artifacts
+
+tosca.artifacts.Implementation.Bash:
+ derived_from: tosca.artifacts.Implementation
+ description: Script artifact for the Unix Bash shell
+ mime_type: application/x-sh
+ file_ext: [ sh ]
+
+tosca.artifacts.Implementation.Python:
+ derived_from: tosca.artifacts.Implementation
+ description: Artifact for the interpreted Python language
+ mime_type: application/x-python
+ file_ext: [ py ]
+
+tosca.artifacts.Deployment.Image.Container.Docker:
+ derived_from: tosca.artifacts.Deployment.Image
+ description: Docker container image
+
+tosca.artifacts.Deployment.Image.VM.ISO:
+ derived_from: tosca.artifacts.Deployment.Image
+ description: Virtual Machine (VM) image in ISO disk format
+ mime_type: application/octet-stream
+ file_ext: [ iso ]
+
+tosca.artifacts.Deployment.Image.VM.QCOW2:
+ derived_from: tosca.artifacts.Deployment.Image
+ description: Virtual Machine (VM) image in QCOW v2 standard disk format
+ mime_type: application/octet-stream
+ file_ext: [ qcow2 ]
+
+##########################################################################
+ # Policy Type.
+ # TOSCA Policy Types represent logical grouping of TOSCA nodes that have
+ # an implied relationship and need to be orchestrated or managed together
+ # to achieve some result.
+##########################################################################
+tosca.policies.Root:
+ description: The TOSCA Policy Type all other TOSCA Policy Types derive from.
+
+tosca.policies.Placement:
+ derived_from: tosca.policies.Root
+ description: The TOSCA Policy Type definition that is used to govern
+ placement of TOSCA nodes or groups of nodes.
+
+tosca.policies.Scaling:
+ derived_from: tosca.policies.Root
+ description: The TOSCA Policy Type definition that is used to govern
+ scaling of TOSCA nodes or groups of nodes.
+
+tosca.policies.Update:
+ derived_from: tosca.policies.Root
+ description: The TOSCA Policy Type definition that is used to govern
+ update of TOSCA nodes or groups of nodes.
+
+tosca.policies.Performance:
+ derived_from: tosca.policies.Root
+ description: The TOSCA Policy Type definition that is used to declare
+ performance requirements for TOSCA nodes or groups of nodes.
+
+##########################################################################
+ # Group Type.
+ # Group Type represents logical grouping of TOSCA nodes that have an
+ # implied membership relationship and may need to be orchestrated or
+ # managed together to achieve some result.
+##########################################################################
+tosca.groups.Root:
+ description: The TOSCA Group Type all other TOSCA Group Types derive from
+ interfaces:
+ Standard:
+ type: tosca.interfaces.node.lifecycle.Standard
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/__init__.py b/tosca2heat/tosca-parser/toscaparser/elements/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/__init__.py
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/artifacttype.py b/tosca2heat/tosca-parser/toscaparser/elements/artifacttype.py
new file mode 100644
index 0000000..3bfd7d0
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/artifacttype.py
@@ -0,0 +1,45 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class ArtifactTypeDef(StatefulEntityType):
+ '''TOSCA built-in artifacts type.'''
+
+ def __init__(self, atype, custom_def=None):
+ super(ArtifactTypeDef, self).__init__(atype, self.ARTIFACT_PREFIX,
+ custom_def)
+ self.type = atype
+ self.properties = None
+ if self.PROPERTIES in self.defs:
+ self.properties = self.defs[self.PROPERTIES]
+ self.parent_artifacts = self._get_parent_artifacts()
+
+ def _get_parent_artifacts(self):
+ artifacts = {}
+ parent_artif = self.parent_type
+ if parent_artif:
+ while parent_artif != 'tosca.artifacts.Root':
+ artifacts[parent_artif] = self.TOSCA_DEF[parent_artif]
+ parent_artif = artifacts[parent_artif]['derived_from']
+ return artifacts
+
+ @property
+ def parent_type(self):
+ '''Return an artifact this artifact is derived from.'''
+ return self.derived_from(self.defs)
+
+ def get_artifact(self, name):
+ '''Return the definition of an artifact field by name.'''
+ if name in self.defs:
+ return self.defs[name]
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/attribute_definition.py b/tosca2heat/tosca-parser/toscaparser/elements/attribute_definition.py
new file mode 100644
index 0000000..35ba27f
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/attribute_definition.py
@@ -0,0 +1,20 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+
+class AttributeDef(object):
+ '''TOSCA built-in Attribute type.'''
+
+ def __init__(self, name, value=None, schema=None):
+ self.name = name
+ self.value = value
+ self.schema = schema
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/capabilitytype.py b/tosca2heat/tosca-parser/toscaparser/elements/capabilitytype.py
new file mode 100644
index 0000000..0413443
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/capabilitytype.py
@@ -0,0 +1,75 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.elements.property_definition import PropertyDef
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class CapabilityTypeDef(StatefulEntityType):
+ '''TOSCA built-in capabilities type.'''
+
+ def __init__(self, name, ctype, ntype, custom_def=None):
+ self.name = name
+ super(CapabilityTypeDef, self).__init__(ctype, self.CAPABILITY_PREFIX,
+ custom_def)
+ self.nodetype = ntype
+ self.properties = None
+ if self.PROPERTIES in self.defs:
+ self.properties = self.defs[self.PROPERTIES]
+ self.parent_capabilities = self._get_parent_capabilities(custom_def)
+
+ def get_properties_def_objects(self):
+ '''Return a list of property definition objects.'''
+ properties = []
+ parent_properties = {}
+ if self.parent_capabilities:
+ for type, value in self.parent_capabilities.items():
+ parent_properties[type] = value.get('properties')
+ if self.properties:
+ for prop, schema in self.properties.items():
+ properties.append(PropertyDef(prop, None, schema))
+ if parent_properties:
+ for parent, props in parent_properties.items():
+ for prop, schema in props.items():
+ # add parent property if not overridden by children type
+ if not self.properties or \
+ prop not in self.properties.keys():
+ properties.append(PropertyDef(prop, None, schema))
+ return properties
+
+ def get_properties_def(self):
+ '''Return a dictionary of property definition name-object pairs.'''
+ return {prop.name: prop
+ for prop in self.get_properties_def_objects()}
+
+ def get_property_def_value(self, name):
+ '''Return the definition of a given property name.'''
+ props_def = self.get_properties_def()
+ if props_def and name in props_def:
+ return props_def[name].value
+
+ def _get_parent_capabilities(self, custom_def=None):
+ capabilities = {}
+ parent_cap = self.parent_type
+ if parent_cap:
+ while parent_cap != 'tosca.capabilities.Root':
+ if parent_cap in self.TOSCA_DEF.keys():
+ capabilities[parent_cap] = self.TOSCA_DEF[parent_cap]
+ elif custom_def and parent_cap in custom_def.keys():
+ capabilities[parent_cap] = custom_def[parent_cap]
+ parent_cap = capabilities[parent_cap]['derived_from']
+ return capabilities
+
+ @property
+ def parent_type(self):
+ '''Return a capability this capability is derived from.'''
+ return self.derived_from(self.defs)
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/constraints.py b/tosca2heat/tosca-parser/toscaparser/elements/constraints.py
new file mode 100644
index 0000000..9883da3
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/constraints.py
@@ -0,0 +1,611 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import collections
+import datetime
+import re
+
+import toscaparser
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidSchemaError
+from toscaparser.common.exception import ValidationError
+from toscaparser.elements import scalarunit
+from toscaparser.utils.gettextutils import _
+
+
+class Schema(collections.Mapping):
+
+ KEYS = (
+ TYPE, REQUIRED, DESCRIPTION,
+ DEFAULT, CONSTRAINTS, ENTRYSCHEMA
+ ) = (
+ 'type', 'required', 'description',
+ 'default', 'constraints', 'entry_schema'
+ )
+
+ PROPERTY_TYPES = (
+ INTEGER, STRING, BOOLEAN, FLOAT, RANGE,
+ NUMBER, TIMESTAMP, LIST, MAP,
+ SCALAR_UNIT_SIZE, SCALAR_UNIT_FREQUENCY, SCALAR_UNIT_TIME,
+ PORTDEF, VERSION
+ ) = (
+ 'integer', 'string', 'boolean', 'float', 'range',
+ 'number', 'timestamp', 'list', 'map',
+ 'scalar-unit.size', 'scalar-unit.frequency', 'scalar-unit.time',
+ 'PortDef', 'version'
+ )
+
+ SCALAR_UNIT_SIZE_DEFAULT = 'B'
+ SCALAR_UNIT_SIZE_DICT = {'B': 1, 'KB': 1000, 'KIB': 1024, 'MB': 1000000,
+ 'MIB': 1048576, 'GB': 1000000000,
+ 'GIB': 1073741824, 'TB': 1000000000000,
+ 'TIB': 1099511627776}
+
+ def __init__(self, name, schema_dict):
+ self.name = name
+ if not isinstance(schema_dict, collections.Mapping):
+ msg = (_('Schema definition of "%(pname)s" must be a dict.')
+ % dict(pname=name))
+ ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+
+ try:
+ schema_dict['type']
+ except KeyError:
+ msg = (_('Schema definition of "%(pname)s" must have a "type" '
+ 'attribute.') % dict(pname=name))
+ ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+
+ self.schema = schema_dict
+ self._len = None
+ self.constraints_list = []
+
+ @property
+ def type(self):
+ return self.schema[self.TYPE]
+
+ @property
+ def required(self):
+ return self.schema.get(self.REQUIRED, True)
+
+ @property
+ def description(self):
+ return self.schema.get(self.DESCRIPTION, '')
+
+ @property
+ def default(self):
+ return self.schema.get(self.DEFAULT)
+
+ @property
+ def constraints(self):
+ if not self.constraints_list:
+ constraint_schemata = self.schema.get(self.CONSTRAINTS)
+ if constraint_schemata:
+ self.constraints_list = [Constraint(self.name,
+ self.type,
+ cschema)
+ for cschema in constraint_schemata]
+ return self.constraints_list
+
+ @property
+ def entry_schema(self):
+ return self.schema.get(self.ENTRYSCHEMA)
+
+ def __getitem__(self, key):
+ return self.schema[key]
+
+ def __iter__(self):
+ for k in self.KEYS:
+ try:
+ self.schema[k]
+ except KeyError:
+ pass
+ else:
+ yield k
+
+ def __len__(self):
+ if self._len is None:
+ self._len = len(list(iter(self)))
+ return self._len
+
+
+class Constraint(object):
+ '''Parent class for constraints for a Property or Input.'''
+
+ CONSTRAINTS = (EQUAL, GREATER_THAN,
+ GREATER_OR_EQUAL, LESS_THAN, LESS_OR_EQUAL, IN_RANGE,
+ VALID_VALUES, LENGTH, MIN_LENGTH, MAX_LENGTH, PATTERN) = \
+ ('equal', 'greater_than', 'greater_or_equal', 'less_than',
+ 'less_or_equal', 'in_range', 'valid_values', 'length',
+ 'min_length', 'max_length', 'pattern')
+
+ UNBOUNDED = 'UNBOUNDED'
+
+ def __new__(cls, property_name, property_type, constraint):
+ if cls is not Constraint:
+ return super(Constraint, cls).__new__(cls)
+
+ if(not isinstance(constraint, collections.Mapping) or
+ len(constraint) != 1):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('Invalid constraint schema.')))
+
+ for type in constraint.keys():
+ ConstraintClass = get_constraint_class(type)
+ if not ConstraintClass:
+ msg = _('Invalid property "%s".') % type
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=msg))
+
+ return ConstraintClass(property_name, property_type, constraint)
+
+ def __init__(self, property_name, property_type, constraint):
+ self.property_name = property_name
+ self.property_type = property_type
+ self.constraint_value = constraint[self.constraint_key]
+ self.constraint_value_msg = self.constraint_value
+ if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
+ self.constraint_value = self._get_scalarunit_constraint_value()
+ # check if constraint is valid for property type
+ if property_type not in self.valid_prop_types:
+ msg = _('Property "%(ctype)s" is not valid for data type '
+ '"%(dtype)s".') % dict(
+ ctype=self.constraint_key,
+ dtype=property_type)
+ ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+
+ def _get_scalarunit_constraint_value(self):
+ if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
+ ScalarUnit_Class = (scalarunit.
+ get_scalarunit_class(self.property_type))
+ if isinstance(self.constraint_value, list):
+ return [ScalarUnit_Class(v).get_num_from_scalar_unit()
+ for v in self.constraint_value]
+ else:
+ return (ScalarUnit_Class(self.constraint_value).
+ get_num_from_scalar_unit())
+
+ def _err_msg(self, value):
+ return _('Property "%s" could not be validated.') % self.property_name
+
+ def validate(self, value):
+ self.value_msg = value
+ if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
+ value = scalarunit.get_scalarunit_value(self.property_type, value)
+ if not self._is_valid(value):
+ err_msg = self._err_msg(value)
+ ExceptionCollector.appendException(
+ ValidationError(message=err_msg))
+
+
+class Equal(Constraint):
+ """Constraint class for "equal"
+
+ Constrains a property or parameter to a value equal to ('=')
+ the value declared.
+ """
+
+ constraint_key = Constraint.EQUAL
+
+ valid_prop_types = Schema.PROPERTY_TYPES
+
+ def _is_valid(self, value):
+ if value == self.constraint_value:
+ return True
+
+ return False
+
+ def _err_msg(self, value):
+ return (_('The value "%(pvalue)s" of property "%(pname)s" is not '
+ 'equal to "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=self.value_msg,
+ cvalue=self.constraint_value_msg))
+
+
+class GreaterThan(Constraint):
+ """Constraint class for "greater_than"
+
+ Constrains a property or parameter to a value greater than ('>')
+ the value declared.
+ """
+
+ constraint_key = Constraint.GREATER_THAN
+
+ valid_types = (int, float, datetime.date,
+ datetime.time, datetime.datetime)
+
+ valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+ Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+ Schema.SCALAR_UNIT_TIME)
+
+ def __init__(self, property_name, property_type, constraint):
+ super(GreaterThan, self).__init__(property_name, property_type,
+ constraint)
+ if not isinstance(constraint[self.GREATER_THAN], self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "greater_than" '
+ 'expects comparable values.')))
+
+ def _is_valid(self, value):
+ if value > self.constraint_value:
+ return True
+
+ return False
+
+ def _err_msg(self, value):
+ return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+ 'greater than "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=self.value_msg,
+ cvalue=self.constraint_value_msg))
+
+
+class GreaterOrEqual(Constraint):
+ """Constraint class for "greater_or_equal"
+
+ Constrains a property or parameter to a value greater than or equal
+ to ('>=') the value declared.
+ """
+
+ constraint_key = Constraint.GREATER_OR_EQUAL
+
+ valid_types = (int, float, datetime.date,
+ datetime.time, datetime.datetime)
+
+ valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+ Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+ Schema.SCALAR_UNIT_TIME)
+
+ def __init__(self, property_name, property_type, constraint):
+ super(GreaterOrEqual, self).__init__(property_name, property_type,
+ constraint)
+ if not isinstance(self.constraint_value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property '
+ '"greater_or_equal" expects '
+ 'comparable values.')))
+
+ def _is_valid(self, value):
+ if toscaparser.functions.is_function(value) or \
+ value >= self.constraint_value:
+ return True
+ return False
+
+ def _err_msg(self, value):
+ return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+ 'greater than or equal to "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=self.value_msg,
+ cvalue=self.constraint_value_msg))
+
+
+class LessThan(Constraint):
+ """Constraint class for "less_than"
+
+ Constrains a property or parameter to a value less than ('<')
+ the value declared.
+ """
+
+ constraint_key = Constraint.LESS_THAN
+
+ valid_types = (int, float, datetime.date,
+ datetime.time, datetime.datetime)
+
+ valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+ Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+ Schema.SCALAR_UNIT_TIME)
+
+ def __init__(self, property_name, property_type, constraint):
+ super(LessThan, self).__init__(property_name, property_type,
+ constraint)
+ if not isinstance(self.constraint_value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "less_than" '
+ 'expects comparable values.')))
+
+ def _is_valid(self, value):
+ if value < self.constraint_value:
+ return True
+
+ return False
+
+ def _err_msg(self, value):
+ return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+ 'less than "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=self.value_msg,
+ cvalue=self.constraint_value_msg))
+
+
+class LessOrEqual(Constraint):
+ """Constraint class for "less_or_equal"
+
+ Constrains a property or parameter to a value less than or equal
+ to ('<=') the value declared.
+ """
+
+ constraint_key = Constraint.LESS_OR_EQUAL
+
+ valid_types = (int, float, datetime.date,
+ datetime.time, datetime.datetime)
+
+ valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+ Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+ Schema.SCALAR_UNIT_TIME)
+
+ def __init__(self, property_name, property_type, constraint):
+ super(LessOrEqual, self).__init__(property_name, property_type,
+ constraint)
+ if not isinstance(self.constraint_value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "less_or_equal" '
+ 'expects comparable values.')))
+
+ def _is_valid(self, value):
+ if value <= self.constraint_value:
+ return True
+
+ return False
+
+ def _err_msg(self, value):
+ return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+ 'less than or equal to "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=self.value_msg,
+ cvalue=self.constraint_value_msg))
+
+
+class InRange(Constraint):
+ """Constraint class for "in_range"
+
+ Constrains a property or parameter to a value in range of (inclusive)
+ the two values declared.
+ """
+
+ constraint_key = Constraint.IN_RANGE
+
+ valid_types = (int, float, datetime.date,
+ datetime.time, datetime.datetime, str)
+
+ valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+ Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+ Schema.SCALAR_UNIT_TIME, Schema.RANGE)
+
+ def __init__(self, property_name, property_type, constraint):
+ super(InRange, self).__init__(property_name, property_type, constraint)
+ if(not isinstance(self.constraint_value, collections.Sequence) or
+ (len(constraint[self.IN_RANGE]) != 2)):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "in_range" '
+ 'expects a list.')))
+
+ msg = _('The property "in_range" expects comparable values.')
+ for value in self.constraint_value:
+ if not isinstance(value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=msg))
+ # The only string we allow for range is the special value
+ # 'UNBOUNDED'
+ if(isinstance(value, str) and value != self.UNBOUNDED):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=msg))
+
+ self.min = self.constraint_value[0]
+ self.max = self.constraint_value[1]
+
+ def _is_valid(self, value):
+ if not isinstance(self.min, str):
+ if value < self.min:
+ return False
+ elif self.min != self.UNBOUNDED:
+ return False
+ if not isinstance(self.max, str):
+ if value > self.max:
+ return False
+ elif self.max != self.UNBOUNDED:
+ return False
+ return True
+
+ def _err_msg(self, value):
+ return (_('The value "%(pvalue)s" of property "%(pname)s" is out of '
+ 'range "(min:%(vmin)s, max:%(vmax)s)".') %
+ dict(pname=self.property_name,
+ pvalue=self.value_msg,
+ vmin=self.constraint_value_msg[0],
+ vmax=self.constraint_value_msg[1]))
+
+
+class ValidValues(Constraint):
+ """Constraint class for "valid_values"
+
+ Constrains a property or parameter to a value that is in the list of
+ declared values.
+ """
+ constraint_key = Constraint.VALID_VALUES
+
+ valid_prop_types = Schema.PROPERTY_TYPES
+
+ def __init__(self, property_name, property_type, constraint):
+ super(ValidValues, self).__init__(property_name, property_type,
+ constraint)
+ if not isinstance(self.constraint_value, collections.Sequence):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "valid_values" '
+ 'expects a list.')))
+
+ def _is_valid(self, value):
+ if isinstance(value, list):
+ return all(v in self.constraint_value for v in value)
+ return value in self.constraint_value
+
+ def _err_msg(self, value):
+ allowed = '[%s]' % ', '.join(str(a) for a in self.constraint_value)
+ return (_('The value "%(pvalue)s" of property "%(pname)s" is not '
+ 'valid. Expected a value from "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=value,
+ cvalue=allowed))
+
+
+class Length(Constraint):
+ """Constraint class for "length"
+
+ Constrains the property or parameter to a value of a given length.
+ """
+
+ constraint_key = Constraint.LENGTH
+
+ valid_types = (int, )
+
+ valid_prop_types = (Schema.STRING, )
+
+ def __init__(self, property_name, property_type, constraint):
+ super(Length, self).__init__(property_name, property_type, constraint)
+ if not isinstance(self.constraint_value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "length" expects '
+ 'an integer.')))
+
+ def _is_valid(self, value):
+ if isinstance(value, str) and len(value) == self.constraint_value:
+ return True
+
+ return False
+
+ def _err_msg(self, value):
+ return (_('Length of value "%(pvalue)s" of property "%(pname)s" '
+ 'must be equal to "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=value,
+ cvalue=self.constraint_value))
+
+
+class MinLength(Constraint):
+ """Constraint class for "min_length"
+
+ Constrains the property or parameter to a value to a minimum length.
+ """
+
+ constraint_key = Constraint.MIN_LENGTH
+
+ valid_types = (int, )
+
+ valid_prop_types = (Schema.STRING, Schema.MAP)
+
+ def __init__(self, property_name, property_type, constraint):
+ super(MinLength, self).__init__(property_name, property_type,
+ constraint)
+ if not isinstance(self.constraint_value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "min_length" '
+ 'expects an integer.')))
+
+ def _is_valid(self, value):
+ if ((isinstance(value, str) or isinstance(value, dict)) and
+ len(value) >= self.constraint_value):
+ return True
+
+ return False
+
+ def _err_msg(self, value):
+ return (_('Length of value "%(pvalue)s" of property "%(pname)s" '
+ 'must be at least "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=value,
+ cvalue=self.constraint_value))
+
+
+class MaxLength(Constraint):
+ """Constraint class for "max_length"
+
+ Constrains the property or parameter to a value to a maximum length.
+ """
+
+ constraint_key = Constraint.MAX_LENGTH
+
+ valid_types = (int, )
+
+ valid_prop_types = (Schema.STRING, Schema.MAP)
+
+ def __init__(self, property_name, property_type, constraint):
+ super(MaxLength, self).__init__(property_name, property_type,
+ constraint)
+ if not isinstance(self.constraint_value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "max_length" '
+ 'expects an integer.')))
+
+ def _is_valid(self, value):
+ if ((isinstance(value, str) or isinstance(value, dict)) and
+ len(value) <= self.constraint_value):
+ return True
+
+ return False
+
+ def _err_msg(self, value):
+ return (_('Length of value "%(pvalue)s" of property "%(pname)s" '
+ 'must be no greater than "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=value,
+ cvalue=self.constraint_value))
+
+
+class Pattern(Constraint):
+ """Constraint class for "pattern"
+
+ Constrains the property or parameter to a value that is allowed by
+ the provided regular expression.
+ """
+
+ constraint_key = Constraint.PATTERN
+
+ valid_types = (str, )
+
+ valid_prop_types = (Schema.STRING, )
+
+ def __init__(self, property_name, property_type, constraint):
+ super(Pattern, self).__init__(property_name, property_type, constraint)
+ if not isinstance(self.constraint_value, self.valid_types):
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=_('The property "pattern" '
+ 'expects a string.')))
+ self.match = re.compile(self.constraint_value).match
+
+ def _is_valid(self, value):
+ match = self.match(value)
+ return match is not None and match.end() == len(value)
+
+ def _err_msg(self, value):
+ return (_('The value "%(pvalue)s" of property "%(pname)s" does not '
+ 'match pattern "%(cvalue)s".') %
+ dict(pname=self.property_name,
+ pvalue=value,
+ cvalue=self.constraint_value))
+
+
+constraint_mapping = {
+ Constraint.EQUAL: Equal,
+ Constraint.GREATER_THAN: GreaterThan,
+ Constraint.GREATER_OR_EQUAL: GreaterOrEqual,
+ Constraint.LESS_THAN: LessThan,
+ Constraint.LESS_OR_EQUAL: LessOrEqual,
+ Constraint.IN_RANGE: InRange,
+ Constraint.VALID_VALUES: ValidValues,
+ Constraint.LENGTH: Length,
+ Constraint.MIN_LENGTH: MinLength,
+ Constraint.MAX_LENGTH: MaxLength,
+ Constraint.PATTERN: Pattern
+ }
+
+
+def get_constraint_class(type):
+ return constraint_mapping.get(type)
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/datatype.py b/tosca2heat/tosca-parser/toscaparser/elements/datatype.py
new file mode 100644
index 0000000..7e05a69
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/datatype.py
@@ -0,0 +1,56 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class DataType(StatefulEntityType):
+ '''TOSCA built-in and user defined complex data type.'''
+
+ def __init__(self, datatypename, custom_def=None):
+ super(DataType, self).__init__(datatypename, self.DATATYPE_PREFIX,
+ custom_def)
+ self.custom_def = custom_def
+
+ @property
+ def parent_type(self):
+ '''Return a datatype this datatype is derived from.'''
+ ptype = self.derived_from(self.defs)
+ if ptype:
+ return DataType(ptype, self.custom_def)
+ return None
+
+ @property
+ def value_type(self):
+ '''Return 'type' section in the datatype schema.'''
+ return self.entity_value(self.defs, 'type')
+
+ def get_all_properties_objects(self):
+ '''Return all properties objects defined in type and parent type.'''
+ props_def = self.get_properties_def_objects()
+ ptype = self.parent_type
+ while ptype:
+ props_def.extend(ptype.get_properties_def_objects())
+ ptype = ptype.parent_type
+ return props_def
+
+ def get_all_properties(self):
+ '''Return a dictionary of all property definition name-object pairs.'''
+ return {prop.name: prop
+ for prop in self.get_all_properties_objects()}
+
+ def get_all_property_value(self, name):
+ '''Return the value of a given property name.'''
+ props_def = self.get_all_properties()
+ if props_def and name in props_def.key():
+ return props_def[name].value
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/entity_type.py b/tosca2heat/tosca-parser/toscaparser/elements/entity_type.py
new file mode 100644
index 0000000..5d620a5
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/entity_type.py
@@ -0,0 +1,145 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import copy
+import logging
+import os
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationError
+from toscaparser.extensions.exttools import ExtTools
+import toscaparser.utils.yamlparser
+
+log = logging.getLogger('tosca')
+
+
+class EntityType(object):
+ '''Base class for TOSCA elements.'''
+
+ SECTIONS = (DERIVED_FROM, PROPERTIES, ATTRIBUTES, REQUIREMENTS,
+ INTERFACES, CAPABILITIES, TYPE, ARTIFACTS) = \
+ ('derived_from', 'properties', 'attributes', 'requirements',
+ 'interfaces', 'capabilities', 'type', 'artifacts')
+
+ '''TOSCA definition file.'''
+ TOSCA_DEF_FILE = os.path.join(
+ os.path.dirname(os.path.abspath(__file__)),
+ "TOSCA_definition_1_0.yaml")
+
+ loader = toscaparser.utils.yamlparser.load_yaml
+
+ TOSCA_DEF = loader(TOSCA_DEF_FILE)
+
+ RELATIONSHIP_TYPE = (DEPENDSON, HOSTEDON, CONNECTSTO, ATTACHESTO,
+ LINKSTO, BINDSTO) = \
+ ('tosca.relationships.DependsOn',
+ 'tosca.relationships.HostedOn',
+ 'tosca.relationships.ConnectsTo',
+ 'tosca.relationships.AttachesTo',
+ 'tosca.relationships.network.LinksTo',
+ 'tosca.relationships.network.BindsTo')
+
+ NODE_PREFIX = 'tosca.nodes.'
+ RELATIONSHIP_PREFIX = 'tosca.relationships.'
+ CAPABILITY_PREFIX = 'tosca.capabilities.'
+ INTERFACE_PREFIX = 'tosca.interfaces.'
+ ARTIFACT_PREFIX = 'tosca.artifacts.'
+ POLICY_PREFIX = 'tosca.policies.'
+ GROUP_PREFIX = 'tosca.groups.'
+ # currently the data types are defined only for network
+ # but may have changes in the future.
+ DATATYPE_PREFIX = 'tosca.datatypes.network.'
+ TOSCA = 'tosca'
+
+ def derived_from(self, defs):
+ '''Return a type this type is derived from.'''
+ return self.entity_value(defs, 'derived_from')
+
+ def is_derived_from(self, type_str):
+ '''Check if object inherits from the given type.
+
+ Returns true if this object is derived from 'type_str'.
+ False otherwise.
+ '''
+ if not self.type:
+ return False
+ elif self.type == type_str:
+ return True
+ elif self.parent_type:
+ return self.parent_type.is_derived_from(type_str)
+ else:
+ return False
+
+ def entity_value(self, defs, key):
+ if key in defs:
+ return defs[key]
+
+ def get_value(self, ndtype, defs=None, parent=None):
+ value = None
+ if defs is None:
+ if not hasattr(self, 'defs'):
+ return None
+ defs = self.defs
+ if ndtype in defs:
+ # copy the value to avoid that next operations add items in the
+ # item definitions
+ value = copy.copy(defs[ndtype])
+ if parent:
+ p = self
+ if p:
+ while p:
+ if ndtype in p.defs:
+ # get the parent value
+ parent_value = p.defs[ndtype]
+ if value:
+ if isinstance(value, dict):
+ for k, v in parent_value.items():
+ if k not in value.keys():
+ value[k] = v
+ if isinstance(value, list):
+ for p_value in parent_value:
+ if p_value not in value:
+ value.append(p_value)
+ else:
+ value = copy.copy(parent_value)
+ p = p.parent_type
+ return value
+
+ def get_definition(self, ndtype):
+ value = None
+ if not hasattr(self, 'defs'):
+ defs = None
+ ExceptionCollector.appendException(
+ ValidationError(message="defs is " + str(defs)))
+ else:
+ defs = self.defs
+ if defs is not None and ndtype in defs:
+ value = defs[ndtype]
+ p = self.parent_type
+ if p:
+ inherited = p.get_definition(ndtype)
+ if inherited:
+ inherited = dict(inherited)
+ if not value:
+ value = inherited
+ else:
+ inherited.update(value)
+ value.update(inherited)
+ return value
+
+
+def update_definitions(version):
+ exttools = ExtTools()
+ extension_defs_file = exttools.get_defs_file(version)
+
+ loader = toscaparser.utils.yamlparser.load_yaml
+
+ EntityType.TOSCA_DEF.update(loader(extension_defs_file))
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/grouptype.py b/tosca2heat/tosca-parser/toscaparser/elements/grouptype.py
new file mode 100644
index 0000000..ec5571c
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/grouptype.py
@@ -0,0 +1,86 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTypeError
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class GroupType(StatefulEntityType):
+ '''TOSCA built-in group type.'''
+
+ SECTIONS = (DERIVED_FROM, VERSION, METADATA, DESCRIPTION, PROPERTIES,
+ MEMBERS, INTERFACES) = \
+ ("derived_from", "version", "metadata", "description",
+ "properties", "members", "interfaces")
+
+ def __init__(self, grouptype, custom_def=None):
+ super(GroupType, self).__init__(grouptype, self.GROUP_PREFIX,
+ custom_def)
+ self.custom_def = custom_def
+ self.grouptype = grouptype
+ self._validate_fields()
+ self.group_description = None
+ if self.DESCRIPTION in self.defs:
+ self.group_description = self.defs[self.DESCRIPTION]
+
+ self.group_version = None
+ if self.VERSION in self.defs:
+ self.group_version = self.defs[self.VERSION]
+
+ self.group_properties = None
+ if self.PROPERTIES in self.defs:
+ self.group_properties = self.defs[self.PROPERTIES]
+
+ self.group_members = None
+ if self.MEMBERS in self.defs:
+ self.group_members = self.defs[self.MEMBERS]
+
+ if self.METADATA in self.defs:
+ self.meta_data = self.defs[self.METADATA]
+ self._validate_metadata(self.meta_data)
+
+ @property
+ def description(self):
+ return self.group_description
+
+ @property
+ def version(self):
+ return self.group_version
+
+ @property
+ def interfaces(self):
+ return self.get_value(self.INTERFACES)
+
+ def _validate_fields(self):
+ if self.defs:
+ for name in self.defs.keys():
+ if name not in self.SECTIONS:
+ ExceptionCollector.appendException(
+ UnknownFieldError(what='Group Type %s'
+ % self.grouptype, field=name))
+
+ def _validate_metadata(self, meta_data):
+ if not meta_data.get('type') in ['map', 'tosca:map']:
+ ExceptionCollector.appendException(
+ InvalidTypeError(what='"%s" defined in group for '
+ 'metadata' % (meta_data.get('type'))))
+ for entry_schema, entry_schema_type in meta_data.items():
+ if isinstance(entry_schema_type, dict) and not \
+ entry_schema_type.get('type') == 'string':
+ ExceptionCollector.appendException(
+ InvalidTypeError(what='"%s" defined in group for '
+ 'metadata "%s"'
+ % (entry_schema_type.get('type'),
+ entry_schema)))
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/interfaces.py b/tosca2heat/tosca-parser/toscaparser/elements/interfaces.py
new file mode 100644
index 0000000..88fb8ab
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/interfaces.py
@@ -0,0 +1,76 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+SECTIONS = (LIFECYCLE, CONFIGURE, LIFECYCLE_SHORTNAME,
+ CONFIGURE_SHORTNAME) = \
+ ('tosca.interfaces.node.lifecycle.Standard',
+ 'tosca.interfaces.relationship.Configure',
+ 'Standard', 'Configure')
+
+INTERFACEVALUE = (IMPLEMENTATION, INPUTS) = ('implementation', 'inputs')
+
+
+class InterfacesDef(StatefulEntityType):
+ '''TOSCA built-in interfaces type.'''
+
+ def __init__(self, node_type, interfacetype,
+ node_template=None, name=None, value=None):
+ self.ntype = node_type
+ self.node_template = node_template
+ self.type = interfacetype
+ self.name = name
+ self.value = value
+ self.implementation = None
+ self.inputs = None
+ self.defs = {}
+ if interfacetype == LIFECYCLE_SHORTNAME:
+ interfacetype = LIFECYCLE
+ if interfacetype == CONFIGURE_SHORTNAME:
+ interfacetype = CONFIGURE
+ if node_type:
+ self.defs = self.TOSCA_DEF[interfacetype]
+ if value:
+ if isinstance(self.value, dict):
+ for i, j in self.value.items():
+ if i == IMPLEMENTATION:
+ self.implementation = j
+ elif i == INPUTS:
+ self.inputs = j
+ else:
+ what = ('"interfaces" of template "%s"' %
+ self.node_template.name)
+ ExceptionCollector.appendException(
+ UnknownFieldError(what=what, field=i))
+ else:
+ self.implementation = value
+
+ @property
+ def lifecycle_ops(self):
+ if self.defs:
+ if self.type == LIFECYCLE:
+ return self._ops()
+
+ @property
+ def configure_ops(self):
+ if self.defs:
+ if self.type == CONFIGURE:
+ return self._ops()
+
+ def _ops(self):
+ ops = []
+ for name in list(self.defs.keys()):
+ ops.append(name)
+ return ops
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/nodetype.py b/tosca2heat/tosca-parser/toscaparser/elements/nodetype.py
new file mode 100644
index 0000000..8176def
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/nodetype.py
@@ -0,0 +1,226 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.common.exception import ValidationError
+from toscaparser.elements.capabilitytype import CapabilityTypeDef
+import toscaparser.elements.interfaces as ifaces
+from toscaparser.elements.interfaces import InterfacesDef
+from toscaparser.elements.relationshiptype import RelationshipType
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class NodeType(StatefulEntityType):
+ '''TOSCA built-in node type.'''
+ SECTIONS = (DERIVED_FROM, METADATA, PROPERTIES, VERSION, DESCRIPTION, ATTRIBUTES, REQUIREMENTS, CAPABILITIES, INTERFACES, ARTIFACTS) = \
+ ('derived_from', 'metadata', 'properties', 'version',
+ 'description', 'attributes', 'requirements', 'capabilities',
+ 'interfaces', 'artifacts')
+
+ def __init__(self, ntype, custom_def=None):
+ super(NodeType, self).__init__(ntype, self.NODE_PREFIX, custom_def)
+ self.ntype = ntype
+ self.custom_def = custom_def
+ self._validate_keys()
+
+ @property
+ def parent_type(self):
+ '''Return a node this node is derived from.'''
+ if not hasattr(self, 'defs'):
+ return None
+ pnode = self.derived_from(self.defs)
+ if pnode:
+ return NodeType(pnode, self.custom_def)
+
+ @property
+ def relationship(self):
+ '''Return a dictionary of relationships to other node types.
+
+ This method returns a dictionary of named relationships that nodes
+ of the current node type (self) can have to other nodes (of specific
+ types) in a TOSCA template.
+
+ '''
+ relationship = {}
+ requires = self.get_all_requirements()
+ if requires:
+ # NOTE(sdmonov): Check if requires is a dict.
+ # If it is a dict convert it to a list of dicts.
+ # This is needed because currently the code below supports only
+ # lists as requirements definition. The following check will
+ # make sure if a map (dict) was provided it will be converted to
+ # a list before proceeding to the parsing.
+ if isinstance(requires, dict):
+ requires = [{key: value} for key, value in requires.items()]
+
+ keyword = None
+ node_type = None
+ for require in requires:
+ for key, req in require.items():
+ if 'relationship' in req:
+ relation = req.get('relationship')
+ if 'type' in relation:
+ relation = relation.get('type')
+ node_type = req.get('node')
+ value = req
+ if node_type:
+ keyword = 'node'
+ else:
+ # If value is a dict and has a type key
+ # we need to lookup the node type using
+ # the capability type
+ value = req
+ if isinstance(value, dict):
+ captype = value['capability']
+ value = (self.
+ _get_node_type_by_cap(key, captype))
+ relation = self._get_relation(key, value)
+ keyword = key
+ node_type = value
+ rtype = RelationshipType(relation, keyword, self.custom_def)
+ relatednode = NodeType(node_type, self.custom_def)
+ relationship[rtype] = relatednode
+ return relationship
+
+ def _get_node_type_by_cap(self, key, cap):
+ '''Find the node type that has the provided capability
+
+ This method will lookup all node types if they have the
+ provided capability.
+ '''
+
+ # Filter the node types
+ node_types = [node_type for node_type in self.TOSCA_DEF.keys()
+ if node_type.startswith(self.NODE_PREFIX) and
+ node_type != 'tosca.nodes.Root']
+
+ for node_type in node_types:
+ node_def = self.TOSCA_DEF[node_type]
+ if isinstance(node_def, dict) and 'capabilities' in node_def:
+ node_caps = node_def['capabilities']
+ for value in node_caps.values():
+ if isinstance(value, dict) and \
+ 'type' in value and value['type'] == cap:
+ return node_type
+
+ def _get_relation(self, key, ndtype):
+ relation = None
+ ntype = NodeType(ndtype)
+ caps = ntype.get_capabilities()
+ if caps and key in caps.keys():
+ c = caps[key]
+ for r in self.RELATIONSHIP_TYPE:
+ rtypedef = ntype.TOSCA_DEF[r]
+ for properties in rtypedef.values():
+ if c.type in properties:
+ relation = r
+ break
+ if relation:
+ break
+ else:
+ for properties in rtypedef.values():
+ if c.parent_type in properties:
+ relation = r
+ break
+ return relation
+
+ def get_capabilities_objects(self):
+ '''Return a list of capability objects.'''
+ typecapabilities = []
+ caps = self.get_value(self.CAPABILITIES, None, True)
+ if caps is None:
+ caps = self.get_value(self.CAPABILITIES, None, True)
+ if caps:
+ # 'name' is symbolic name of the capability
+ # 'value' is a dict { 'type': <capability type name> }
+ for name, value in caps.items():
+ ctype = value.get('type')
+ cap = CapabilityTypeDef(name, ctype, self.type,
+ self.custom_def)
+ typecapabilities.append(cap)
+ return typecapabilities
+
+ def get_capabilities(self):
+ '''Return a dictionary of capability name-objects pairs.'''
+ return {cap.name: cap
+ for cap in self.get_capabilities_objects()}
+
+ @property
+ def requirements(self):
+ return self.get_value(self.REQUIREMENTS, None, True)
+
+ def get_all_requirements(self):
+ requires = self.requirements
+ parent_node = self.parent_type
+ if requires is None:
+ requires = self.get_value(self.REQUIREMENTS, None, True)
+ if parent_node is None:
+ ExceptionCollector.appendException(
+ ValidationError(message="parent_node is "
+ + str(parent_node)))
+ else:
+ parent_node = parent_node.parent_type
+ if parent_node:
+ while parent_node.type != 'tosca.nodes.Root':
+ req = parent_node.get_value(self.REQUIREMENTS, None, True)
+ for r in req:
+ if r not in requires:
+ requires.append(r)
+ parent_node = parent_node.parent_type
+ return requires
+
+ @property
+ def interfaces(self):
+ return self.get_value(self.INTERFACES)
+
+ @property
+ def lifecycle_inputs(self):
+ '''Return inputs to life cycle operations if found.'''
+ inputs = []
+ interfaces = self.interfaces
+ if interfaces:
+ for name, value in interfaces.items():
+ if name == ifaces.LIFECYCLE:
+ for x, y in value.items():
+ if x == 'inputs':
+ for i in y.iterkeys():
+ inputs.append(i)
+ return inputs
+
+ @property
+ def lifecycle_operations(self):
+ '''Return available life cycle operations if found.'''
+ ops = None
+ interfaces = self.interfaces
+ if interfaces:
+ i = InterfacesDef(self.type, ifaces.LIFECYCLE)
+ ops = i.lifecycle_ops
+ return ops
+
+ def get_capability(self, name):
+ caps = self.get_capabilities()
+ if caps and name in caps.keys():
+ return caps[name].value
+
+ def get_capability_type(self, name):
+ captype = self.get_capability(name)
+ if captype and name in captype.keys():
+ return captype[name].value
+
+ def _validate_keys(self):
+ if self.defs:
+ for key in self.defs.keys():
+ if key not in self.SECTIONS:
+ ExceptionCollector.appendException(
+ UnknownFieldError(what='Nodetype"%s"' % self.ntype,
+ field=key))
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/policytype.py b/tosca2heat/tosca-parser/toscaparser/elements/policytype.py
new file mode 100644
index 0000000..04cbab5
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/policytype.py
@@ -0,0 +1,115 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTypeError
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+from toscaparser.utils.validateutils import TOSCAVersionProperty
+
+
+class PolicyType(StatefulEntityType):
+
+ '''TOSCA built-in policies type.'''
+ SECTIONS = (DERIVED_FROM, METADATA, PROPERTIES, VERSION, DESCRIPTION, TARGETS) = \
+ ('derived_from', 'metadata', 'properties', 'version',
+ 'description', 'targets')
+
+ def __init__(self, ptype, custom_def=None):
+ super(PolicyType, self).__init__(ptype, self.POLICY_PREFIX,
+ custom_def)
+ self.type = ptype
+ self._validate_keys()
+
+ self.meta_data = None
+ if self.METADATA in self.defs:
+ self.meta_data = self.defs[self.METADATA]
+ self._validate_metadata(self.meta_data)
+
+ self.properties = None
+ if self.PROPERTIES in self.defs:
+ self.properties = self.defs[self.PROPERTIES]
+ self.parent_policies = self._get_parent_policies()
+
+ self.policy_version = None
+ if self.VERSION in self.defs:
+ self.policy_version = TOSCAVersionProperty(
+ self.defs[self.VERSION]).get_version()
+
+ self.policy_description = self.defs[self.DESCRIPTION] \
+ if self.DESCRIPTION in self.defs else None
+
+ self.targets_list = None
+ if self.TARGETS in self.defs:
+ self.targets_list = self.defs[self.TARGETS]
+ self._validate_targets(self.targets_list, custom_def)
+
+ def _get_parent_policies(self):
+ policies = {}
+ parent_policy = self.parent_type
+ if parent_policy:
+ while parent_policy != 'tosca.policies.Root':
+ policies[parent_policy] = self.TOSCA_DEF[parent_policy]
+ parent_policy = policies[parent_policy]['derived_from']
+ return policies
+
+ @property
+ def parent_type(self):
+ '''Return a policy this policy is derived from.'''
+ return self.derived_from(self.defs)
+
+ def get_policy(self, name):
+ '''Return the definition of a policy field by name.'''
+ if name in self.defs:
+ return self.defs[name]
+
+ @property
+ def targets(self):
+ '''Return targets.'''
+ return self.targets_list
+
+ @property
+ def description(self):
+ return self.policy_description
+
+ @property
+ def version(self):
+ return self.policy_version
+
+ def _validate_keys(self):
+ for key in self.defs.keys():
+ if key not in self.SECTIONS:
+ ExceptionCollector.appendException(
+ UnknownFieldError(what='Policy "%s"' % self.type,
+ field=key))
+
+ def _validate_targets(self, targets_list, custom_def):
+ for nodetype in targets_list:
+ if nodetype not in custom_def:
+ ExceptionCollector.appendException(
+ InvalidTypeError(what='"%s" defined in targets for '
+ 'policy "%s"' % (nodetype, self.type)))
+
+ def _validate_metadata(self, meta_data):
+ if not meta_data.get('type') in ['map', 'tosca:map']:
+ ExceptionCollector.appendException(
+ InvalidTypeError(what='"%s" defined in policy for '
+ 'metadata' % (meta_data.get('type'))))
+
+ for entry_schema, entry_schema_type in meta_data.items():
+ if isinstance(entry_schema_type, dict) and not \
+ entry_schema_type.get('type') == 'string':
+ ExceptionCollector.appendException(
+ InvalidTypeError(what='"%s" defined in policy for '
+ 'metadata "%s"'
+ % (entry_schema_type.get('type'),
+ entry_schema)))
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/property_definition.py b/tosca2heat/tosca-parser/toscaparser/elements/property_definition.py
new file mode 100644
index 0000000..a242ddf
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/property_definition.py
@@ -0,0 +1,100 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidSchemaError
+from toscaparser.common.exception import TOSCAException
+from toscaparser.utils.gettextutils import _
+
+
+class PropertyDef(object):
+ '''TOSCA built-in Property type.'''
+
+ VALID_PROPERTY_KEYNAMES = (PROPERTY_KEYNAME_DEFAULT,
+ PROPERTY_KEYNAME_REQUIRED,
+ PROPERTY_KEYNAME_STATUS) = \
+ ('default', 'required', 'status')
+
+ PROPERTY_REQUIRED_DEFAULT = True
+
+ VALID_REQUIRED_VALUES = ['true', 'false']
+ VALID_STATUS_VALUES = (PROPERTY_STATUS_SUPPORTED,
+ PROPERTY_STATUS_EXPERIMENTAL) = \
+ ('supported', 'experimental')
+
+ PROPERTY_STATUS_DEFAULT = PROPERTY_STATUS_SUPPORTED
+
+ def __init__(self, name, value=None, schema=None):
+ self.name = name
+ self.value = value
+ self.schema = schema
+ self._status = self.PROPERTY_STATUS_DEFAULT
+ self._required = self.PROPERTY_REQUIRED_DEFAULT
+
+ # Validate required 'type' property exists
+ try:
+ self.schema['type']
+ except KeyError:
+ msg = (_('Schema definition of "%(pname)s" must have a "type" '
+ 'attribute.') % dict(pname=self.name))
+ ExceptionCollector.appendException(
+ InvalidSchemaError(message=msg))
+
+ if self.schema:
+ self._load_required_attr_from_schema()
+ self._load_status_attr_from_schema()
+
+ @property
+ def default(self):
+ if self.schema:
+ for prop_key, prop_value in self.schema.items():
+ if prop_key == self.PROPERTY_KEYNAME_DEFAULT:
+ return prop_value
+ return None
+
+ @property
+ def required(self):
+ return self._required
+
+ def _load_required_attr_from_schema(self):
+ # IF 'required' keyname exists verify it's a boolean,
+ # if so override default
+ if self.PROPERTY_KEYNAME_REQUIRED in self.schema:
+ value = self.schema[self.PROPERTY_KEYNAME_REQUIRED]
+ if isinstance(value, bool):
+ self._required = value
+ else:
+ valid_values = ', '.join(self.VALID_REQUIRED_VALUES)
+ attr = self.PROPERTY_KEYNAME_REQUIRED
+ TOSCAException.generate_inv_schema_property_error(self,
+ attr,
+ value,
+ valid_values)
+
+ @property
+ def status(self):
+ return self._status
+
+ def _load_status_attr_from_schema(self):
+ # IF 'status' keyname exists verify it's a valid value,
+ # if so override default
+ if self.PROPERTY_KEYNAME_STATUS in self.schema:
+ value = self.schema[self.PROPERTY_KEYNAME_STATUS]
+ if value in self.VALID_STATUS_VALUES:
+ self._status = value
+ else:
+ valid_values = ', '.join(self.VALID_STATUS_VALUES)
+ attr = self.PROPERTY_KEYNAME_STATUS
+ TOSCAException.generate_inv_schema_property_error(self,
+ attr,
+ value,
+ valid_values)
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/relationshiptype.py b/tosca2heat/tosca-parser/toscaparser/elements/relationshiptype.py
new file mode 100644
index 0000000..9462d38
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/relationshiptype.py
@@ -0,0 +1,33 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class RelationshipType(StatefulEntityType):
+ '''TOSCA built-in relationship type.'''
+ def __init__(self, type, capability_name=None, custom_def=None):
+ super(RelationshipType, self).__init__(type, self.RELATIONSHIP_PREFIX,
+ custom_def)
+ self.capability_name = capability_name
+ self.custom_def = custom_def
+
+ @property
+ def parent_type(self):
+ '''Return a relationship this reletionship is derived from.'''
+ prel = self.derived_from(self.defs)
+ if prel:
+ return RelationshipType(prel)
+
+ @property
+ def valid_target_types(self):
+ return self.entity_value(self.defs, 'valid_target_types')
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/scalarunit.py b/tosca2heat/tosca-parser/toscaparser/elements/scalarunit.py
new file mode 100644
index 0000000..d7f72e6
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/scalarunit.py
@@ -0,0 +1,129 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import logging
+import re
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.utils.gettextutils import _
+from toscaparser.utils import validateutils
+
+log = logging.getLogger('tosca')
+
+
+class ScalarUnit(object):
+ '''Parent class for scalar-unit type.'''
+
+ SCALAR_UNIT_TYPES = (
+ SCALAR_UNIT_SIZE, SCALAR_UNIT_FREQUENCY, SCALAR_UNIT_TIME
+ ) = (
+ 'scalar-unit.size', 'scalar-unit.frequency', 'scalar-unit.time'
+ )
+
+ def __init__(self, value):
+ self.value = value
+
+ def _check_unit_in_scalar_standard_units(self, input_unit):
+ """Check whether the input unit is following specified standard
+
+ If unit is not following specified standard, convert it to standard
+ unit after displaying a warning message.
+ """
+ if input_unit in self.SCALAR_UNIT_DICT.keys():
+ return input_unit
+ else:
+ for key in self.SCALAR_UNIT_DICT.keys():
+ if key.upper() == input_unit.upper():
+ log.warning(_('The unit "%(unit)s" does not follow '
+ 'scalar unit standards; using "%(key)s" '
+ 'instead.') % {'unit': input_unit,
+ 'key': key})
+ return key
+ msg = (_('The unit "%(unit)s" is not valid. Valid units are '
+ '"%(valid_units)s".') %
+ {'unit': input_unit,
+ 'valid_units': sorted(self.SCALAR_UNIT_DICT.keys())})
+ ExceptionCollector.appendException(ValueError(msg))
+
+ def validate_scalar_unit(self):
+ regex = re.compile('([0-9.]+)\s*(\w+)')
+ try:
+ result = regex.match(str(self.value)).groups()
+ validateutils.str_to_num(result[0])
+ scalar_unit = self._check_unit_in_scalar_standard_units(result[1])
+ self.value = ' '.join([result[0], scalar_unit])
+ return self.value
+
+ except Exception:
+ ExceptionCollector.appendException(
+ ValueError(_('"%s" is not a valid scalar-unit.')
+ % self.value))
+
+ def get_num_from_scalar_unit(self, unit=None):
+ if unit:
+ unit = self._check_unit_in_scalar_standard_units(unit)
+ else:
+ unit = self.SCALAR_UNIT_DEFAULT
+ self.validate_scalar_unit()
+
+ regex = re.compile('([0-9.]+)\s*(\w+)')
+ result = regex.match(str(self.value)).groups()
+ converted = (float(validateutils.str_to_num(result[0]))
+ * self.SCALAR_UNIT_DICT[result[1]]
+ / self.SCALAR_UNIT_DICT[unit])
+ if converted - int(converted) < 0.0000000000001:
+ converted = int(converted)
+ return converted
+
+
+class ScalarUnit_Size(ScalarUnit):
+
+ SCALAR_UNIT_DEFAULT = 'B'
+ SCALAR_UNIT_DICT = {'B': 1, 'kB': 1000, 'KiB': 1024, 'MB': 1000000,
+ 'MiB': 1048576, 'GB': 1000000000,
+ 'GiB': 1073741824, 'TB': 1000000000000,
+ 'TiB': 1099511627776}
+
+
+class ScalarUnit_Time(ScalarUnit):
+
+ SCALAR_UNIT_DEFAULT = 'ms'
+ SCALAR_UNIT_DICT = {'d': 86400, 'h': 3600, 'm': 60, 's': 1,
+ 'ms': 0.001, 'us': 0.000001, 'ns': 0.000000001}
+
+
+class ScalarUnit_Frequency(ScalarUnit):
+
+ SCALAR_UNIT_DEFAULT = 'GHz'
+ SCALAR_UNIT_DICT = {'Hz': 1, 'kHz': 1000,
+ 'MHz': 1000000, 'GHz': 1000000000}
+
+
+scalarunit_mapping = {
+ ScalarUnit.SCALAR_UNIT_FREQUENCY: ScalarUnit_Frequency,
+ ScalarUnit.SCALAR_UNIT_SIZE: ScalarUnit_Size,
+ ScalarUnit.SCALAR_UNIT_TIME: ScalarUnit_Time,
+ }
+
+
+def get_scalarunit_class(type):
+ return scalarunit_mapping.get(type)
+
+
+def get_scalarunit_value(type, value, unit=None):
+ if type in ScalarUnit.SCALAR_UNIT_TYPES:
+ ScalarUnit_Class = get_scalarunit_class(type)
+ return (ScalarUnit_Class(value).
+ get_num_from_scalar_unit(unit))
+ else:
+ ExceptionCollector.appendException(
+ TypeError(_('"%s" is not a valid scalar-unit type.') % type))
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/statefulentitytype.py b/tosca2heat/tosca-parser/toscaparser/elements/statefulentitytype.py
new file mode 100644
index 0000000..47496f7
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/statefulentitytype.py
@@ -0,0 +1,84 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTypeError
+from toscaparser.elements.attribute_definition import AttributeDef
+from toscaparser.elements.entity_type import EntityType
+from toscaparser.elements.property_definition import PropertyDef
+
+
+class StatefulEntityType(EntityType):
+ '''Class representing TOSCA states.'''
+
+ interfaces_node_lifecycle_operations = ['create',
+ 'configure', 'start',
+ 'stop', 'delete']
+
+ interfaces_relationship_configure_operations = ['post_configure_source',
+ 'post_configure_target',
+ 'add_target',
+ 'remove_target']
+
+ def __init__(self, entitytype, prefix, custom_def=None):
+ entire_entitytype = entitytype
+ if not entitytype.startswith(self.TOSCA):
+ entire_entitytype = prefix + entitytype
+ if entire_entitytype in list(self.TOSCA_DEF.keys()):
+ self.defs = self.TOSCA_DEF[entire_entitytype]
+ entitytype = entire_entitytype
+ elif custom_def and entitytype in list(custom_def.keys()):
+ self.defs = custom_def[entitytype]
+ else:
+ self.defs = None
+ ExceptionCollector.appendException(
+ InvalidTypeError(what=entitytype))
+ self.type = entitytype
+
+ def get_properties_def_objects(self):
+ '''Return a list of property definition objects.'''
+ properties = []
+ props = self.get_definition(self.PROPERTIES)
+ if props:
+ for prop, schema in props.items():
+ properties.append(PropertyDef(prop, None, schema))
+ return properties
+
+ def get_properties_def(self):
+ '''Return a dictionary of property definition name-object pairs.'''
+ return {prop.name: prop
+ for prop in self.get_properties_def_objects()}
+
+ def get_property_def_value(self, name):
+ '''Return the property definition associated with a given name.'''
+ props_def = self.get_properties_def()
+ if props_def and name in props_def.keys():
+ return props_def[name].value
+
+ def get_attributes_def_objects(self):
+ '''Return a list of attribute definition objects.'''
+ attrs = self.get_value(self.ATTRIBUTES, parent=True)
+ if attrs:
+ return [AttributeDef(attr, None, schema)
+ for attr, schema in attrs.items()]
+ return []
+
+ def get_attributes_def(self):
+ '''Return a dictionary of attribute definition name-object pairs.'''
+ return {attr.name: attr
+ for attr in self.get_attributes_def_objects()}
+
+ def get_attribute_def_value(self, name):
+ '''Return the attribute definition associated with a given name.'''
+ attrs_def = self.get_attributes_def()
+ if attrs_def and name in attrs_def.keys():
+ return attrs_def[name].value
diff --git a/tosca2heat/tosca-parser/toscaparser/elements/tosca_type_validation.py b/tosca2heat/tosca-parser/toscaparser/elements/tosca_type_validation.py
new file mode 100644
index 0000000..16764bc
--- /dev/null
+++ b/tosca2heat/tosca-parser/toscaparser/elements/tosca_type_validation.py
@@ -0,0 +1,58 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTemplateVersion
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.extensions.exttools import ExtTools
+
+
+class TypeValidation(object):
+
+ ALLOWED_TYPE_SECTIONS = (DEFINITION_VERSION, DESCRIPTION, IMPORTS,
+ DSL_DEFINITIONS, NODE_TYPES, REPOSITORIES,
+ DATA_TYPES, ARTIFACT_TYPES, GROUP_TYPES,
+ RELATIONSHIP_TYPES, CAPABILITY_TYPES,
+ INTERFACE_TYPES, POLICY_TYPES) = \
+ ('tosca_definitions_version', 'description', 'imports',
+ 'dsl_definitions', 'node_types', 'repositories',
+ 'data_types', 'artifact_types', 'group_types',
+ 'relationship_types', 'capability_types',
+ 'interface_types', 'policy_types')
+ VALID_TEMPLATE_VERSIONS = ['tosca_simple_yaml_1_0']
+ exttools = ExtTools()
+ VALID_TEMPLATE_VERSIONS.extend(exttools.get_versions())
+
+ def __init__(self, custom_types, import_def):
+ self.import_def = import_def
+ self._validate_type_keys(custom_types)
+
+ def _validate_type_keys(self, custom_type):
+ version = custom_type[self.DEFINITION_VERSION] \
+ if self.DEFINITION_VERSION in custom_type \
+ else None
+ if version:
+ self._validate_type_version(version)
+ self.version = version
+
+ for name in custom_type:
+ if name not in self.ALLOWED_TYPE_SECTIONS:
+ ExceptionCollector.appendException(
+ UnknownFieldError(what='Template ' + (self.import_def),
+ field=name))
+
+ def _validate_type_version(self, version):
+ if version not in self.VALID_TEMPLATE_VERSIONS:
+ ExceptionCollector.appendException(
+ InvalidTemplateVersion(
+ what=version + ' in ' + self.import_def,
+ valid_versions=', '. join(self.VALID_TEMPLATE_VERSIONS)))