def _validate_nodefilter_filter(self, node_filter, cap_label=''):
valid = True
if cap_label:
name = 'capability "%s" on nodefilter on template "%s"' % (
cap_label, self.name)
else:
name = 'nodefilter on template "%s"' % self.name
if not isinstance(node_filter, dict):
ExceptionCollector.appendException(
TypeMismatchError(what=name, type='dict'))
return False
if 'properties' in node_filter:
propfilters = node_filter['properties']
if not isinstance(propfilters, list):
ExceptionCollector.appendException(
TypeMismatchError(what='"properties" of %s' % name,
type='list'))
return False
for filter in propfilters:
if not isinstance(filter, dict):
ExceptionCollector.appendException(
TypeMismatchError(what='filter in %s' % name,
type='dict'))
valid = False
continue
if len(filter) != 1:
msg = _(
'Invalid %s: only one condition allow per filter condition'
) % name
ExceptionCollector.appendException(
ValidationError(message=msg))
valid = False
continue
# XXX validate filter condition
return valid
def _validate_requirements(self):
type_requires = self.type_definition.get_all_requirements()
allowed_reqs = ["template"]
if type_requires:
for treq in type_requires:
for key, value in treq.items():
allowed_reqs.append(key)
if isinstance(value, dict):
for key in value:
allowed_reqs.append(key)
requires = self.type_definition.get_value(self.REQUIREMENTS,
self.entity_tpl)
if requires:
if not isinstance(requires, list):
ExceptionCollector.appendException(
TypeMismatchError(what='"requirements" of template "%s"' %
self.name,
type='list'))
else:
for req in requires:
for r1, value in req.items():
if isinstance(value, dict):
self._validate_requirements_keys(value)
self._validate_requirements_properties(value)
allowed_reqs.append(r1)
self._common_validate_field(req, allowed_reqs,
'requirements')
def __init__(self, name, values):
self.name = name
self.tpl = values
# TOSCA 1.0 backwards compatibility:
if isinstance(self.tpl, six.string_types):
tpl = dict(url=self.tpl)
else:
tpl = self.tpl
if isinstance(tpl, dict):
if URL not in tpl.keys():
ExceptionCollector.appendException(
MissingRequiredFieldError(what=_('repository "%s"') %
self.name,
required='url'))
for key, value in tpl.items():
if key not in SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what=_('repository "%s"') % name,
field=key))
setattr(self, key, value)
self.validate()
self.hostname = urlparse(self.url).hostname
else:
ExceptionCollector.appendException(
TypeMismatchError(what=_('repository "%s"') % self.name,
type="dict"))
def _validate_requirements(self):
type_requires = self.type_definition.get_all_requirements()
allowed_reqs = ["template"]
if type_requires:
for treq in type_requires:
for key, value in treq.items():
allowed_reqs.append(key)
if isinstance(value, dict):
for key in value:
allowed_reqs.append(key)
requires = self.requirements
if requires:
if not isinstance(requires, list):
ExceptionCollector.appendException(
TypeMismatchError(what='"requirements" of template "%s"' %
self.name,
type='list'))
else:
for req in requires:
if not isinstance(req, dict):
ExceptionCollector.appendException(
TypeMismatchError(
what='a "requirement" in template "%s"' %
self.name,
type='dict'))
continue
if len(req) != 1:
what = 'requirement "%s" in template "%s"' % (
req, self.name)
ExceptionCollector.appendException(
InvalidPropertyValueError(what=what))
continue
for r1, value in req.items():
if isinstance(value, dict):
self._validate_requirements_keys(value)
self._validate_requirements_properties(value)
node_filter = value.get('node_filter')
if node_filter:
self._validate_nodefilter(node_filter)
elif not isinstance(value, str):
msg = 'bad value "%s" for requirement "%s" in template "%s"' % (
value, r1, self.name)
ExceptionCollector.appendException(
ValidationError(message=msg))
def _validate_nodefilter(self, node_filter):
valid = True
if not self._validate_nodefilter_filter(node_filter):
return False
capfilters = node_filter.get('capabilities')
if capfilters:
if not isinstance(capfilters, list):
ExceptionCollector.appendException(
TypeMismatchError(
what='"capabilities" of nodefilter in template "%s"' %
self.name,
type='list'))
return False
for capfilter in capfilters:
if not isinstance(capfilter, dict):
ExceptionCollector.appendException(
TypeMismatchError(
what=
'capabilities list item on nodefilter in template "%s"'
% self.name,
type='dict'))
valid = False
continue
if len(capfilter) != 1:
msg = _(
'Invalid nodefilter on template "%s": only one capability name per list item'
) % self.name
ExceptionCollector.appendException(
ValidationError(message=msg))
valid = False
continue
name, filter = list(capfilter.items())[0]
if not self._validate_nodefilter_filter(filter, name):
valid = False
return valid
def _validate_properties(self):
properties = self.type_definition.get_value(self.PROPERTIES,
self.entity_tpl)
if isinstance(properties, list):
properties = {p["title"]: p.get('value') for p in properties}
if not properties:
properties = {}
if not isinstance(properties, dict):
ExceptionCollector.appendException(
TypeMismatchError(what='"properties" of template "%s"' %
self.name,
type='dict'))
return {}
self._common_validate_properties(self.type_definition, properties,
self.additionalProperties)
return properties
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
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
for value_key in list(self.value.keys()):
if value_key not in allowed_props:
ExceptionCollector.appendException(
UnknownFieldError(what=(_('Data value of type "%s"') %
self.datatype.type),
field=value_key))
# 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:
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
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 prop_schema.constraints:
for constraint in prop_schema.constraints:
if isinstance(value, list):
for val in value:
constraint.validate(val)
else:
constraint.validate(value)
return self.value