def __init__(self,
node_type,
interfacetype,
node_template=None,
name=None,
value=None):
self.ntype = node_type
self.node_template = node_template
self.type = interfacetype
self.name = name
self.value = value
self.implementation = None
self.inputs = None
self.defs = {}
if interfacetype == LIFECYCLE_SHORTNAME:
interfacetype = LIFECYCLE
if interfacetype == CONFIGURE_SHORTNAME:
interfacetype = CONFIGURE
if node_type:
self.defs = self.TOSCA_DEF[interfacetype]
if value:
if isinstance(self.value, dict):
for i, j in self.value.items():
if i == IMPLEMENTATION:
self.implementation = j
elif i == INPUTS:
self.inputs = j
else:
what = ('"interfaces" of template "%s"' %
self.node_template.name)
ExceptionCollector.appendException(
UnknownFieldError(what=what, field=i))
else:
self.implementation = value
def _validate_fields(self):
if self.defs:
for name in self.defs.keys():
if name not in self.SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what='Group Type %s'
% self.grouptype, field=name))
def _validate_interfaces(self):
ifaces = self.type_definition.get_value(self.INTERFACES,
self.entity_tpl)
if ifaces:
for name, value in ifaces.items():
if name == 'defaults':
self._common_validate_field(
value, ['implementation', 'inputs', 'outputs'],
'interfaces')
elif name in (LIFECYCLE, LIFECYCLE_SHORTNAME):
self._common_validate_field(
value, INTERFACE_DEF_RESERVED_WORDS +
InterfacesDef.interfaces_node_lifecycle_operations,
'interfaces')
elif name in (CONFIGURE, CONFIGURE_SHORTNAME):
self._common_validate_field(
value, INTERFACE_DEF_RESERVED_WORDS + InterfacesDef.
interfaces_relationship_configure_operations,
'interfaces')
elif (name in self.type_definition.interfaces
or name in self.type_definition.TOSCA_DEF):
self._common_validate_field(
value, INTERFACE_DEF_RESERVED_WORDS +
self._collect_custom_iface_operations(name),
'interfaces')
else:
ExceptionCollector.appendException(
UnknownFieldError(
what='"interfaces" of template "%s"' % self.name,
field=name))
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_keys(self):
if self.defs:
for key in self.defs.keys():
if key not in self.SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what='Nodetype"%s"' % self.ntype,
field=key))
def _validate_keys(self):
for key in self.entity_tpl.keys():
if key not in SECTIONS:
log.info("Unknown field Policy {}: {}".format(self.name, key))
ExceptionCollector.appendException(
UnknownFieldError(what='Policy "%s"' % self.name,
field=key))
def _validate_requirements_keys(self, requirement):
for key in requirement.keys():
if key not in self.REQUIREMENTS_SECTION:
ExceptionCollector.appendException(
UnknownFieldError(what='"requirements" of template "%s"' %
self.name,
field=key))
def _validate_interfaces(self):
ifaces = self.type_definition.get_value(self.INTERFACES,
self.entity_tpl)
if ifaces:
for name, value in ifaces.items():
if name in (LIFECYCLE, LIFECYCLE_SHORTNAME):
self._common_validate_field(
value,
InterfacesDef.interfaces_node_lifecycle_operations,
'interfaces')
elif name in (CONFIGURE, CONFIGURE_SHORTNAME):
self._common_validate_field(
value, InterfacesDef.
interfaces_relationship_configure_operations,
'interfaces')
else:
interfaces = self.type_definition.interfaces
if interfaces is None:
interfaces = dict()
if name in interfaces.keys():
self._common_validate_field(
value, self._collect_custom_iface_operations(name),
'interfaces')
else:
ExceptionCollector.appendException(
UnknownFieldError(
what='"interfaces" of template "%s"' %
self.name,
field=name))
def _validate_field(self):
for name in self.schema.schema:
if name not in self.INPUTFIELD:
log.error("Unknown input field {}: {}".format(self.name, name))
ExceptionCollector.appendException(
UnknownFieldError(what='Input "%s"' % self.name,
field=name))
def _validate_keys(self):
"""validate the keys of substitution mappings."""
for key in self.sub_mapping_def.keys():
if key not in self.SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what=_('SubstitutionMappings'),
field=key))
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 _validate_keys(self):
if len(self.activity_tpl) != 1:
ExceptionCollector.appendException(
ValidationError(message="Invalid Activity"))
for key in self.activity_tpl.keys():
if key not in SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what='Activity', field=key))
def __init__(self,
node_type,
interfacename,
node_template=None,
name=None,
value=None):
self.ntype = node_type
self.node_template = node_template
self.type = interfacename
self.interfacename = interfacename
self.name = name
self.value = value
self.implementation = None
self.inputs = None
self.defs = {}
if interfacename == LIFECYCLE_SHORTNAME:
self.interfacetype = LIFECYCLE
elif interfacename == CONFIGURE_SHORTNAME:
self.interfacetype = CONFIGURE
elif hasattr(self.ntype, 'interfaces') \
and self.ntype.interfaces \
and interfacename in self.ntype.interfaces:
self.interfacetype = self.ntype.interfaces[interfacename]['type']
if not self.interfacetype:
ExceptionCollector.appendException(
TypeError(
"Interface type for interface \"{0}\" not found".format(
self.interfacename)))
if node_type:
if self.node_template and self.node_template.custom_def \
and self.interfacetype in self.node_template.custom_def:
self.defs = self.node_template.custom_def[self.interfacetype]
elif self.interfacetype in self.TOSCA_DEF:
self.defs = self.TOSCA_DEF[self.interfacetype]
if not self.defs:
ExceptionCollector.appendException(
TypeError("Interface type definition for interface \"{0}\" "
"not found".format(self.interfacetype)))
if value:
if isinstance(self.value, dict):
for i, j in self.value.items():
if i == IMPLEMENTATION:
self.implementation = j
elif i == INPUTS:
self.inputs = j
elif i == SERIALIZER:
self.serializer = j
else:
what = ('"interfaces" of template "%s"' %
self.node_template.name)
ExceptionCollector.appendException(
UnknownFieldError(what=what, field=i))
else:
self.implementation = value
def _validate_type_keys(self, custom_type):
version = custom_type[self.DEFINITION_VERSION] \
if self.DEFINITION_VERSION in custom_type \
else None
if version:
self._validate_type_version(version)
self.version = version
for name in custom_type:
if name not in self.ALLOWED_TYPE_SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what='Template ' + (self.import_def),
field=name))
def _validate_field(self):
if not isinstance(self.attrs, dict):
ExceptionCollector.appendException(
MissingRequiredFieldError(what='Output "%s"' % self.name,
required=self.VALUE))
if self.value is None:
ExceptionCollector.appendException(
MissingRequiredFieldError(what='Output "%s"' % self.name,
required=self.VALUE))
for name in self.attrs:
if name not in self.OUTPUTFIELD:
ExceptionCollector.appendException(
UnknownFieldError(what='Output "%s"' % self.name,
field=name))
def _validate_field(self):
version = self._tpl_version()
if not version:
ExceptionCollector.appendException(
MissingRequiredFieldError(what='Template',
required=DEFINITION_VERSION))
else:
self._validate_version(version)
self.version = version
for name in self.tpl:
if name not in SECTIONS and name not in SPECIAL_SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what='Template', field=name))
def _validate_keys(self):
if self.defs:
for key in self.defs:
if key not in self.SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what='Nodetype"%s"' % self.ntype,
field=key))
if key == self.REQUIREMENTS:
if not isinstance(self.defs[self.REQUIREMENTS], list):
ExceptionCollector.appendException(
InvalidTypeDefinition(
type='Nodetype %s' % self.ntype,
what='"requirements" field value must be a list'
))
def _validate_inputs(self):
"""validate the inputs of substitution mappings."""
# The inputs in service template which defines substutition mappings
# must be in properties of node template which is mapped or provide
# defualt value. Currently the input.name is not restrict to be the
# same as properte's name in specification, but they should be equal
# for current implementation.
property_names = list(self.sub_mapped_node_template.get_properties().
keys() if self.sub_mapped_node_template else [])
for input in self.inputs:
if input.name not in property_names and input.default is None:
ExceptionCollector.appendException(
UnknownFieldError(what='SubstitutionMappings',
field=input.name))
def _collect_custom_iface_operations(self, name):
allowed_operations = []
nodetype_iface_def = self.type_definition.interfaces[name]
allowed_operations.extend(nodetype_iface_def.keys())
# Handle cases where type is not defined in the derived node interface
if 'type' not in nodetype_iface_def:
node_type = self.type_definition.parent_type
while node_type.ntype != 'tosca.nodes.Root':
try:
nodetype_iface_def = node_type.interfaces[name]
if 'type' in nodetype_iface_def:
break
else:
allowed_operations.extend(nodetype_iface_def.keys())
node_type = node_type.parent_type
except Exception:
node_type = node_type.parent_type
else:
ExceptionCollector.appendException(
UnknownFieldError(what='"interfaces" of template "%s"' %
self.name,
field=name))
iface_type = nodetype_iface_def['type']
if iface_type in self.type_definition.custom_def:
iface_type_def = self.type_definition.custom_def[iface_type]
else:
iface_type_def = self.type_definition.TOSCA_DEF[iface_type]
allowed_operations.extend(iface_type_def.keys())
# Pickup operations from the parent types also
while 'derived_from' in iface_type_def:
iface_type = iface_type_def['derived_from']
if iface_type == 'tosca.interfaces.Root':
break
if iface_type in self.type_definition.custom_def:
iface_type_def = self.type_definition.custom_def[iface_type]
else:
iface_type_def = self.type_definition.TOSCA_DEF[iface_type]
allowed_operations.extend(iface_type_def.keys())
allowed_operations = [
op for op in allowed_operations
if op not in INTERFACE_DEF_RESERVED_WORDS
]
return list(set(allowed_operations))
def _common_validate_field(self, schema, allowedlist, section):
if schema is None:
ExceptionCollector.appendException(
ValidationError(message=(
'Missing value for "%s". Must contain one of: "%s"' %
(section, ", ".join(allowedlist)))))
else:
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 _validate_import_keys(self, import_name, import_uri_def):
if self.FILE not in import_uri_def.keys():
log.warning(_('Missing keyname "file" in import "%(name)s".')
% {'name': import_name})
ExceptionCollector.appendException(
MissingRequiredFieldError(
what='Import of template "%s"' % import_name,
required=self.FILE))
for key in import_uri_def.keys():
if key not in self.IMPORTS_SECTION:
log.warning(_('Unknown keyname "%(key)s" error in '
'imported definition "%(def)s".')
% {'key': key, 'def': import_name})
ExceptionCollector.appendException(
UnknownFieldError(
what='Import of template "%s"' % import_name,
field=key))
def validate_implementation(self):
if isinstance(self.implementation, dict):
for key, value in self.implementation.items():
if key == PRIMARY:
self.validate_inline_artifact(value)
elif key == DEPENDENCIES:
if not isinstance(value, list):
ExceptionCollector.appendException(
ValidationError(message=self._msg))
else:
for artifact in value:
self.validate_inline_artifact(artifact)
elif key not in IMPLEMENTATION_DEF_RESERVED_WORDS:
ExceptionCollector.appendException(
UnknownFieldError(what="implementation in " +
self._msg,
field=key))
def load_and_validate(self, val, reposit_def):
self.keyname = val
if isinstance(reposit_def, dict):
for key in reposit_def.keys():
if key not in SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what=_('repositories "%s"') %
self.keyname,
field=key))
if URL in reposit_def.keys():
reposit_url = reposit_def.get(URL)
url_val = toscaparser.utils.urlutils.UrlUtils.\
validate_url(reposit_url)
if url_val is not True:
ExceptionCollector.appendException(
URLException(what=_('repsositories "%s" Invalid Url') %
self.keyname))
def _validate_type_keys(self, custom_type):
version = custom_type[self.DEFINITION_VERSION] \
if self.DEFINITION_VERSION in custom_type \
else None
if version:
self._validate_type_version(version)
self.version = version
for name in custom_type:
if name in self.ALLOWED_TYPE_SECTIONS:
pass
elif version and version in self.exttools.get_sections() and \
name in self.exttools.get_sections()[version]:
pass
else:
ExceptionCollector.appendException(
UnknownFieldError(what='Template ' + str(self.import_def),
field=name))
def process_req(req):
log.debug("Node requirements: {}".format(req))
if tpls_requirements:
keys = []
if isinstance(tpls_requirements, list):
for tp in tpls_requirements:
keys.extend(list(tp.keys()))
else:
keys = list(tpls_requirements.keys())
log.debug("Tpl keys: {}".format(keys))
for req_key in req.keys():
if req_key in keys:
pass
else:
log.info("Unknown field Subs: {}".format(req))
ExceptionCollector.appendException(
UnknownFieldError(what='SubstitutionMappings',
field=req))
def _validate_requirements(self):
"""validate the requirements of substitution mappings."""
# The requirements must be in node template which is mapped.
tpls_requirements = self.sub_mapping_def.get(self.REQUIREMENTS)
node_requirements = self.sub_mapped_node_template.requirements \
if self.sub_mapped_node_template else None
log.debug("tpls req: {}, node req: {}".format(tpls_requirements,
node_requirements))
def process_req(req):
log.debug("Node requirements: {}".format(req))
if tpls_requirements:
keys = []
if isinstance(tpls_requirements, list):
for tp in tpls_requirements:
keys.extend(list(tp.keys()))
else:
keys = list(tpls_requirements.keys())
log.debug("Tpl keys: {}".format(keys))
for req_key in req.keys():
if req_key in keys:
pass
else:
log.info("Unknown field Subs: {}".format(req))
ExceptionCollector.appendException(
UnknownFieldError(what='SubstitutionMappings',
field=req))
if isinstance(node_requirements, dict) or not node_requirements:
for req in node_requirements if node_requirements else {}:
process_req({req: node_requirements[req]})
elif isinstance(node_requirements, list):
for req in node_requirements:
process_req(req)
else:
ExceptionCollector.appendException(
UnknownFieldError(what='SubstitutionMappings',
field='Requirements is not list or dict'))
def _validate_fields(self, nodetemplate):
for name in nodetemplate.keys():
if name not in self.SECTIONS and name not in self.SPECIAL_SECTIONS:
ExceptionCollector.appendException(
UnknownFieldError(what='Node template "%s"' % self.name,
field=name))
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
def _validate_condition(self):
for key in self.get_condition():
if key not in CONDITION_KEYNAMES:
ExceptionCollector.appendException(
UnknownFieldError(what='Triggers "%s"' % self.name,
field=key))
def _validate_field(self):
for name in self.schema.schema:
if name not in self.INPUTFIELD:
ExceptionCollector.appendException(
UnknownFieldError(what='Input "%s"' % self.name,
field=name))