Update tosca lib to version 0.5

Use tosca-parser and heat-translator to analyze to the basic
nfv-tosca type definitions, and use simple tosca new feature
such as policy, group and trigger, which are now supported by
the latest version of tosca-parser and heat-translator.

JIRA:PARSER-18

Change-Id: I797bcacbb5b32005d0aeb0f3f32851ac96e30f01
Signed--off-by: shangxdy <shang.xiaodong@zte.com.cn>
Signed-off-by: shangxdy <shang.xiaodong@zte.com.cn>

1 files changed, 0 insertions, 287 deletions

diff --git a/tosca2heat/tosca-parser-0.3.0/toscaparser/entity_template.py b/tosca2heat/tosca-parser-0.3.0/toscaparser/entity_template.py
deleted file mode 100644
index 6f62ec5..0000000
--- a/tosca2heat/tosca-parser-0.3.0/toscaparser/entity_template.py
+++ /dev/null
@@ -1,287 +0,0 @@
-#    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.capabilities import Capability
-from toscaparser.common.exception import ExceptionCollector
-from toscaparser.common.exception import MissingRequiredFieldError
-from toscaparser.common.exception import UnknownFieldError
-from toscaparser.common.exception import ValidationError
-from toscaparser.elements.interfaces import InterfacesDef
-from toscaparser.elements.nodetype import NodeType
-from toscaparser.elements.relationshiptype import RelationshipType
-from toscaparser.properties import Property
-
-
-class EntityTemplate(object):
-    '''Base class for TOSCA templates.'''
-
-    SECTIONS = (DERIVED_FROM, PROPERTIES, REQUIREMENTS,
-                INTERFACES, CAPABILITIES, TYPE, DESCRIPTION, DIRECTIVES,
-                ATTRIBUTES, ARTIFACTS, NODE_FILTER, COPY) = \
-               ('derived_from', 'properties', 'requirements', 'interfaces',
-                'capabilities', 'type', 'description', 'directives',
-                'attributes', 'artifacts', 'node_filter', 'copy')
-    REQUIREMENTS_SECTION = (NODE, CAPABILITY, RELATIONSHIP, OCCURRENCES) = \
-                           ('node', 'capability', 'relationship',
-                            'occurrences')
-    # Special key names
-    SPECIAL_SECTIONS = (METADATA) = ('metadata')
-
-    def __init__(self, name, template, entity_name, custom_def=None):
-        self.name = name
-        self.entity_tpl = template
-        self.custom_def = custom_def
-        self._validate_field(self.entity_tpl)
-        if entity_name == 'node_type':
-            type = self.entity_tpl.get('type')
-            self.type_definition = NodeType(type, custom_def) \
-                if type is not None else None
-        if entity_name == 'relationship_type':
-            relationship = template.get('relationship')
-            type = None
-            if relationship and isinstance(relationship, dict):
-                type = relationship.get('type')
-            elif isinstance(relationship, str):
-                type = self.entity_tpl['relationship']
-            else:
-                type = self.entity_tpl['type']
-            self.type_definition = RelationshipType(type,
-                                                    None, custom_def)
-        self._properties = None
-        self._interfaces = None
-        self._requirements = None
-        self._capabilities = None
-
-    @property
-    def type(self):
-        if self.type_definition:
-            return self.type_definition.type
-
-    @property
-    def requirements(self):
-        if self._requirements is None:
-            self._requirements = self.type_definition.get_value(
-                self.REQUIREMENTS,
-                self.entity_tpl) or []
-        return self._requirements
-
-    def get_properties_objects(self):
-        '''Return properties objects for this template.'''
-        if self._properties is None:
-            self._properties = self._create_properties()
-        return self._properties
-
-    def get_properties(self):
-        '''Return a dictionary of property name-object pairs.'''
-        return {prop.name: prop
-                for prop in self.get_properties_objects()}
-
-    def get_property_value(self, name):
-        '''Return the value of a given property name.'''
-        props = self.get_properties()
-        if props and name in props.keys():
-            return props[name].value
-
-    @property
-    def interfaces(self):
-        if self._interfaces is None:
-            self._interfaces = self._create_interfaces()
-        return self._interfaces
-
-    def get_capabilities_objects(self):
-        '''Return capabilities objects for this template.'''
-        if not self._capabilities:
-            self._capabilities = self._create_capabilities()
-        return self._capabilities
-
-    def get_capabilities(self):
-        '''Return a dictionary of capability name-object pairs.'''
-        return {cap.name: cap
-                for cap in self.get_capabilities_objects()}
-
-    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 _create_capabilities(self):
-        capability = []
-        caps = self.type_definition.get_value(self.CAPABILITIES,
-                                              self.entity_tpl)
-        if caps:
-            for name, props in caps.items():
-                capabilities = self.type_definition.get_capabilities()
-                if name in capabilities.keys():
-                    c = capabilities[name]
-                    cap = Capability(name, props['properties'], c)
-                    capability.append(cap)
-        return capability
-
-    def _validate_properties(self, template, entitytype):
-        properties = entitytype.get_value(self.PROPERTIES, template)
-        self._common_validate_properties(entitytype, properties)
-
-    def _validate_capabilities(self):
-        type_capabilities = self.type_definition.get_capabilities()
-        allowed_caps = \
-            type_capabilities.keys() if type_capabilities else []
-        capabilities = self.type_definition.get_value(self.CAPABILITIES,
-                                                      self.entity_tpl)
-        if capabilities:
-            self._common_validate_field(capabilities, allowed_caps,
-                                        'capabilities')
-            self._validate_capabilities_properties(capabilities)
-
-    def _validate_capabilities_properties(self, capabilities):
-        for cap, props in capabilities.items():
-            capabilitydef = self.get_capability(cap).definition
-            self._common_validate_properties(capabilitydef,
-                                             props[self.PROPERTIES])
-
-            # validating capability properties values
-            for prop in self.get_capability(cap).get_properties_objects():
-                prop.validate()
-
-                # TODO(srinivas_tadepalli): temporary work around to validate
-                # default_instances until standardized in specification
-                if cap == "scalable" and prop.name == "default_instances":
-                    prop_dict = props[self.PROPERTIES]
-                    min_instances = prop_dict.get("min_instances")
-                    max_instances = prop_dict.get("max_instances")
-                    default_instances = prop_dict.get("default_instances")
-                    if not (min_instances <= default_instances
-                            <= max_instances):
-                        err_msg = ('"properties" of template "%s": '
-                                   '"default_instances" value is not between '
-                                   '"min_instances" and "max_instances".' %
-                                   self.name)
-                        ExceptionCollector.appendException(
-                            ValidationError(message=err_msg))
-
-    def _common_validate_properties(self, entitytype, properties):
-        allowed_props = []
-        required_props = []
-        for p in entitytype.get_properties_def_objects():
-            allowed_props.append(p.name)
-            if p.required:
-                required_props.append(p.name)
-        if properties:
-            self._common_validate_field(properties, allowed_props,
-                                        'properties')
-            # make sure it's not missing any property required by a tosca type
-            missingprop = []
-            for r in required_props:
-                if r not in properties.keys():
-                    missingprop.append(r)
-            if missingprop:
-                ExceptionCollector.appendException(
-                    MissingRequiredFieldError(
-                        what='"properties" of template "%s"' % self.name,
-                        required=missingprop))
-        else:
-            if required_props:
-                ExceptionCollector.appendException(
-                    MissingRequiredFieldError(
-                        what='"properties" of template "%s"' % self.name,
-                        required=missingprop))
-
-    def _validate_field(self, template):
-        if not isinstance(template, dict):
-            ExceptionCollector.appendException(
-                MissingRequiredFieldError(
-                    what='Template "%s"' % self.name, required=self.TYPE))
-        try:
-            relationship = template.get('relationship')
-            if relationship and not isinstance(relationship, str):
-                relationship[self.TYPE]
-            elif isinstance(relationship, str):
-                template['relationship']
-            else:
-                template[self.TYPE]
-        except KeyError:
-            ExceptionCollector.appendException(
-                MissingRequiredFieldError(
-                    what='Template "%s"' % self.name, required=self.TYPE))
-
-    def _common_validate_field(self, schema, allowedlist, section):
-        for name in schema:
-            if name not in allowedlist:
-                ExceptionCollector.appendException(
-                    UnknownFieldError(
-                        what=('"%(section)s" of template "%(nodename)s"'
-                              % {'section': section, 'nodename': self.name}),
-                        field=name))
-
-    def _create_properties(self):
-        props = []
-        properties = self.type_definition.get_value(self.PROPERTIES,
-                                                    self.entity_tpl) or {}
-        for name, value in properties.items():
-            props_def = self.type_definition.get_properties_def()
-            if props_def and name in props_def:
-                prop = Property(name, value,
-                                props_def[name].schema, self.custom_def)
-                props.append(prop)
-        for p in self.type_definition.get_properties_def_objects():
-            if p.default is not None and p.name not in properties.keys():
-                prop = Property(p.name, p.default, p.schema, self.custom_def)
-                props.append(prop)
-        return props
-
-    def _create_interfaces(self):
-        interfaces = []
-        type_interfaces = None
-        if isinstance(self.type_definition, RelationshipType):
-            if isinstance(self.entity_tpl, dict):
-                for rel_def, value in self.entity_tpl.items():
-                    if rel_def != 'type':
-                        rel_def = self.entity_tpl.get(rel_def)
-                        rel = None
-                        if isinstance(rel_def, dict):
-                            rel = rel_def.get('relationship')
-                        if rel:
-                            if self.INTERFACES in rel:
-                                type_interfaces = rel[self.INTERFACES]
-                                break
-        else:
-            type_interfaces = self.type_definition.get_value(self.INTERFACES,
-                                                             self.entity_tpl)
-        if type_interfaces:
-            for interface_type, value in type_interfaces.items():
-                for op, op_def in value.items():
-                    iface = InterfacesDef(self.type_definition,
-                                          interfacetype=interface_type,
-                                          node_template=self,
-                                          name=op,
-                                          value=op_def)
-                    interfaces.append(iface)
-        return interfaces
-
-    def get_capability(self, name):
-        """Provide named capability
-
-        :param name: name of capability
-        :return: capability object if found, None otherwise
-        """
-        caps = self.get_capabilities()
-        if caps and name in caps.keys():
-            return caps[name]