def validate(self): '''Validate if not a reference property.''' if not is_function(self.value): if self.type == Schema.STRING: self.value = str(self.value) self.value = DataEntity.validate_datatype(self.type, self.value, self.entry_schema, self.custom_def) self._validate_constraints()
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
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()
def validate(self): '''Validate if not a reference property.''' if is_function(self.value) is False: try: if self.type == Schema.STRING: self.value = str(self.value) self.value = DataEntity.validate_datatype( self.type, self.value, self.entry_schema, self.custom_def, self.name) self._validate_constraints() except Exception as e: log.error("Property error {}: {}".format(self.name, e)) if exception.ExceptionCollector.collecting is False: raise e
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()
def _validate_external_reference(self, tpl_file, resource_file, raise_exc=True): """Verify that the external resource exists If resource_file is a URL verify that the URL is valid. If resource_file is a relative path verify that the path is valid considering base folder (self.temp_dir) and tpl_file. Note that in a CSAR resource_file cannot be an absolute path. """ if is_function(resource_file): # Cannot validate it at this time return if UrlUtils.validate_url(resource_file): msg = (_('The resource at "%s" cannot be accessed.') % resource_file) try: if UrlUtils.url_accessible(resource_file): return else: ExceptionCollector.appendException(URLException(what=msg)) self.error_caught = True except Exception: ExceptionCollector.appendException(URLException(what=msg)) self.error_caught = True if os.path.isfile( os.path.join(self.temp_dir, os.path.dirname(tpl_file), resource_file)): return if raise_exc: ExceptionCollector.appendException( ValueError( _('The resource "%s" does not exist.') % resource_file)) self.error_caught = True
def validate(self): '''Validate the value by the definition of the datatype.''' # A datatype can not have both 'type' and 'properties' definitions. # If the datatype has 'type' definition log.debug("{}: Data type validate: {}, {}".format( self.datatype.type, self.datatype.value_type, self.value)) if self.datatype.value_type: self.value = DataEntity.validate_datatype(self.datatype.value_type, self.value, None, self.custom_def) schema = Schema(self.property_name, self.datatype.defs) for constraint in schema.constraints: constraint.validate(self.value) # If the datatype has 'properties' definition else: if not isinstance(self.value, dict): ExceptionCollector.appendException( TypeMismatchError(what=self.value, type=self.datatype.type)) allowed_props = [] required_props = [] default_props = {} if self.schema: allowed_props = self.schema.keys() for name, prop_def in self.schema.items(): if prop_def.required: required_props.append(name) if prop_def.default: default_props[name] = prop_def.default # check allowed field try: for value_key in list(self.value.keys()): if value_key not in allowed_props: log.info("Unknown field data {}: {}".format( self.datatype.type, value_key)) ExceptionCollector.appendException( UnknownFieldError( what=(_('Data value of type "%s"') % self.datatype.type), field=value_key)) except Exception as e: log.error("Value: {}: {}".format(self.value, e)) raise e # check default field for def_key, def_value in list(default_props.items()): if def_key not in list(self.value.keys()): self.value[def_key] = def_value # check missing field missingprop = [] for req_key in required_props: if req_key not in list(self.value.keys()): missingprop.append(req_key) if missingprop: log.info("Missing field data {}: {}".format( self.datatype.type, missingprop)) ExceptionCollector.appendException( MissingRequiredFieldError( what=(_('Data value of type "%s"') % self.datatype.type), required=missingprop)) # check every field for name, value in list(self.value.items()): schema_name = self._find_schema(name) if not schema_name: continue log.debug("Name: {}, Schema: {}".format(name, schema_name)) prop_schema = Schema(name, schema_name) # check if field value meets type defined DataEntity.validate_datatype(prop_schema.type, value, prop_schema.entry_schema, self.custom_def) # check if field value meets constraints defined if not a function from toscaparser.functions import is_function if prop_schema.constraints and is_function(value) is False: for constraint in prop_schema.constraints: if isinstance(value, list): for val in value: constraint.validate(val) else: constraint.validate(value) return self.value