def validate_datatype(
        type, value, entry_schema=None, custom_def=None, prop_name=None, self=None
    ):
        """Validate value with given type.

        If type is list or map, validate its entry by entry_schema(if defined)
        If type is a user-defined complex datatype, custom_def is required.
        """
        from toscaparser.functions import is_function

        if is_function(value):
            return value
        if type == Schema.ANY:
            return value
        if type == Schema.STRING:
            return validateutils.validate_string(value)
        elif type == Schema.INTEGER:
            return validateutils.validate_integer(value)
        elif type == Schema.FLOAT:
            return validateutils.validate_float(value)
        elif type == Schema.NUMBER:
            return validateutils.validate_numeric(value)
        elif type == Schema.BOOLEAN:
            return validateutils.validate_boolean(value)
        elif type == Schema.RANGE:
            return validateutils.validate_range(value)
        elif type == Schema.TIMESTAMP:
            validateutils.validate_timestamp(value)
            return value
        elif type == Schema.LIST:
            validateutils.validate_list(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.SCALAR_UNIT_SIZE:
            return ScalarUnit_Size(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_FREQUENCY:
            return ScalarUnit_Frequency(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_TIME:
            return ScalarUnit_Time(value).validate_scalar_unit()
        elif type == Schema.VERSION:
            return validateutils.TOSCAVersionProperty(value).get_version()
        elif type == Schema.MAP:
            validateutils.validate_map(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.PORTSPEC:
            ps = PortSpec(value)
            ps.validate()
            return ps
        elif type == Schema.PORTDEF:
            return validateutils.validate_portdef(value, prop_name)
        elif not self:
            return DataEntity(type, value, custom_def).validate()
        else:  # avoid infinite recursion
            return value
Exemple #2
0
 def __init__(self, name, policy, targets, targets_type, custom_def=None):
     super(Policy, self).__init__(name, policy, 'policy_type', custom_def)
     self.meta_data = None
     if self.METADATA in policy:
         self.meta_data = policy.get(self.METADATA)
         validateutils.validate_map(self.meta_data)
     self.targets_list = targets
     self.targets_type = targets_type
     self._validate_keys()
Exemple #3
0
 def __init__(self, name, group_templates, member_nodes, custom_defs=None):
     super(Group, self).__init__(name, group_templates, 'group_type',
                                 custom_defs)
     self.name = name
     self.tpl = group_templates
     self.meta_data = None
     if self.METADATA in self.tpl:
         self.meta_data = self.tpl.get(self.METADATA)
         validateutils.validate_map(self.meta_data)
     self.member_nodes = member_nodes
    def validate_datatype(type,
                          value,
                          entry_schema=None,
                          custom_def=None,
                          prop_name=None):
        '''Validate value with given type.

        If type is list or map, validate its entry by entry_schema(if defined)
        If type is a user-defined complex datatype, custom_def is required.
        '''
        from toscaparser.functions import is_function
        if is_function(value):
            return value
        if type == Schema.STRING:
            return validateutils.validate_string(value)
        elif type == Schema.INTEGER:
            return validateutils.validate_integer(value)
        elif type == Schema.FLOAT:
            return validateutils.validate_float(value)
        elif type == Schema.NUMBER:
            return validateutils.validate_numeric(value)
        elif type == Schema.BOOLEAN:
            return validateutils.validate_boolean(value)
        elif type == Schema.RANGE:
            return validateutils.validate_range(value)
        elif type == Schema.TIMESTAMP:
            validateutils.validate_timestamp(value)
            return value
        elif type == Schema.LIST:
            validateutils.validate_list(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.SCALAR_UNIT_SIZE:
            return ScalarUnit_Size(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_FREQUENCY:
            return ScalarUnit_Frequency(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_TIME:
            return ScalarUnit_Time(value).validate_scalar_unit()
        elif type == Schema.VERSION:
            return validateutils.TOSCAVersionProperty(value).get_version()
        elif type == Schema.MAP:
            validateutils.validate_map(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.PORTSPEC:
            # TODO(TBD) bug 1567063, validate source & target as PortDef type
            # as complex types not just as integers
            PortSpec.validate_additional_req(value, prop_name, custom_def)
        else:
            log.debug("Validate data {}: {}, def={}".format(
                type, value, custom_def))
            data = DataEntity(type, value, custom_def)
            return data.validate()
Exemple #5
0
 def __init__(self, name, policy, targets, targets_type, custom_def=None):
     super(Policy, self).__init__(name,
                                  policy,
                                  'policy_type',
                                  custom_def)
     self.meta_data = None
     if self.METADATA in policy:
         self.meta_data = policy.get(self.METADATA)
         validateutils.validate_map(self.meta_data)
     self.targets_list = targets
     self.targets_type = targets_type
     self._validate_keys()
Exemple #6
0
 def __init__(self, name, group_templates, member_nodes, custom_defs=None):
     super(Group, self).__init__(name,
                                 group_templates,
                                 'group_type',
                                 custom_defs)
     self.name = name
     self.tpl = group_templates
     self.meta_data = None
     if self.METADATA in self.tpl:
         self.meta_data = self.tpl.get(self.METADATA)
         validateutils.validate_map(self.meta_data)
     self.member_nodes = member_nodes
     self._validate_keys()
Exemple #7
0
 def __init__(self, name, artifact, custom_def=None, base=None):
     if isinstance(artifact, six.string_types):
         artifact = dict(file=artifact, type="tosca.artifacts.Root")
     elif "type" not in artifact:
         artifact = dict(artifact, type="tosca.artifacts.Root")
     super(Artifact, self).__init__(name, artifact, "artifact_type", custom_def)
     for key in SECTIONS[:-2]:  # skip "type" and "properties"
         setattr(self, key, artifact.get(key))
     self._source = base
     if self.metadata:
         validateutils.validate_map(self.metadata)
     # XXX validate file ext matches type definition
     self._validate_required_fields(artifact)
Exemple #8
0
    def validate_datatype(type, value, entry_schema=None, custom_def=None,
                          prop_name=None):
        '''Validate value with given type.

        If type is list or map, validate its entry by entry_schema(if defined)
        If type is a user-defined complex datatype, custom_def is required.
        '''
        from toscaparser.functions import is_function
        if is_function(value):
            return value
        if type == Schema.STRING:
            return validateutils.validate_string(value)
        elif type == Schema.INTEGER:
            return validateutils.validate_integer(value)
        elif type == Schema.FLOAT:
            return validateutils.validate_float(value)
        elif type == Schema.NUMBER:
            return validateutils.validate_numeric(value)
        elif type == Schema.BOOLEAN:
            return validateutils.validate_boolean(value)
        elif type == Schema.RANGE:
            return validateutils.validate_range(value)
        elif type == Schema.TIMESTAMP:
            validateutils.validate_timestamp(value)
            return value
        elif type == Schema.LIST:
            validateutils.validate_list(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.SCALAR_UNIT_SIZE:
            return ScalarUnit_Size(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_FREQUENCY:
            return ScalarUnit_Frequency(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_TIME:
            return ScalarUnit_Time(value).validate_scalar_unit()
        elif type == Schema.VERSION:
            return validateutils.TOSCAVersionProperty(value).get_version()
        elif type == Schema.MAP:
            validateutils.validate_map(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.PORTSPEC:
            # TODO(TBD) bug 1567063, validate source & target as PortDef type
            # as complex types not just as integers
            PortSpec.validate_additional_req(value, prop_name, custom_def)
        else:
            data = DataEntity(type, value, custom_def)
            return data.validate()
Exemple #9
0
 def __init__(self,
              name,
              policy,
              targets=None,
              targets_type=None,
              custom_def=None):
     super(Policy, self).__init__(name, policy, 'policy_type', custom_def)
     self.meta_data = None
     if self.METADATA in policy:
         self.meta_data = policy.get(self.METADATA)
         validateutils.validate_map(self.meta_data)
     self.targets_list = targets
     self.targets_type = targets_type
     self.triggers = self._triggers(policy.get(TRIGGERS))
     self.reservation = self._reservation(policy.get(RESERVATION))
Exemple #10
0
 def __init__(self, name, workflow, custom_def=None):
     self.name = name
     self._tpl = workflow
     self.meta_data = None
     if METADATA in workflow:
         self.meta_data = workflow.get(METADATA)
         validateutils.validate_map(self.meta_data)
     self._validate_keys()
     self.steps = self._steps(workflow.get(STEPS))
     self._validate_steps()
     self.inputs = workflow.get('inputs')
     self.preconditions = [
         Precondition(tpl) for tpl in workflow.get(PRECONDITIONS, [])
     ]
     self.outputs = workflow.get('outputs')
 def __init__(self, name, policy, targets=None, targets_type=None,
              custom_def=None):
     super(Policy, self).__init__(name,
                                  policy,
                                  'policy_type',
                                  custom_def)
     self.meta_data = None
     if self.METADATA in policy:
         self.meta_data = policy.get(self.METADATA)
         validateutils.validate_map(self.meta_data)
     self.targets_list = targets
     self.targets_type = targets_type
     self.triggers = self._triggers(policy.get(TRIGGERS))
     self.properties = None
     if 'properties' in policy:
         self.properties = policy['properties']
     self._validate_keys()
Exemple #12
0
    def validate_datatype(type, value, entry_schema=None, custom_def=None):
        '''Validate value with given type.

        If type is list or map, validate its entry by entry_schema(if defined)
        If type is a user-defined complex datatype, custom_def is required.
        '''
        if type == Schema.STRING:
            return validateutils.validate_string(value)
        elif type == Schema.INTEGER:
            return validateutils.validate_integer(value)
        elif type == Schema.FLOAT:
            return validateutils.validate_float(value)
        elif type == Schema.NUMBER:
            return validateutils.validate_number(value)
        elif type == Schema.BOOLEAN:
            return validateutils.validate_boolean(value)
        elif type == Schema.RANGE:
            return validateutils.validate_range(value)
        elif type == Schema.TIMESTAMP:
            validateutils.validate_timestamp(value)
            return value
        elif type == Schema.LIST:
            validateutils.validate_list(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.SCALAR_UNIT_SIZE:
            return ScalarUnit_Size(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_FREQUENCY:
            return ScalarUnit_Frequency(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_TIME:
            return ScalarUnit_Time(value).validate_scalar_unit()
        elif type == Schema.VERSION:
            return validateutils.TOSCAVersionProperty(value).get_version()
        elif type == Schema.MAP:
            validateutils.validate_map(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        else:
            data = DataEntity(type, value, custom_def)
            return data.validate()
Exemple #13
0
    def validate_datatype(type, value, entry_schema=None, custom_def=None):
        '''Validate value with given type.

        If type is list or map, validate its entry by entry_schema(if defined)
        If type is a user-defined complex datatype, custom_def is required.
        '''
        if type == Schema.STRING:
            return validateutils.validate_string(value)
        elif type == Schema.INTEGER:
            return validateutils.validate_integer(value)
        elif type == Schema.FLOAT:
            return validateutils.validate_float(value)
        elif type == Schema.NUMBER:
            return validateutils.validate_number(value)
        elif type == Schema.BOOLEAN:
            return validateutils.validate_boolean(value)
        elif type == Schema.TIMESTAMP:
            validateutils.validate_timestamp(value)
            return value
        elif type == Schema.LIST:
            validateutils.validate_list(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        elif type == Schema.SCALAR_UNIT_SIZE:
            return ScalarUnit_Size(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_FREQUENCY:
            return ScalarUnit_Frequency(value).validate_scalar_unit()
        elif type == Schema.SCALAR_UNIT_TIME:
            return ScalarUnit_Time(value).validate_scalar_unit()
        elif type == Schema.VERSION:
            return validateutils.TOSCAVersionProperty(value).get_version()
        elif type == Schema.MAP:
            validateutils.validate_map(value)
            if entry_schema:
                DataEntity.validate_entry(value, entry_schema, custom_def)
            return value
        else:
            data = DataEntity(type, value, custom_def)
            return data.validate()