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(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
