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