<groupId>org.openecomp.sdc.jtosca</groupId>
<artifactId>jtosca</artifactId>
- <version>1.1.10-SNAPSHOT</version>
+ <version>1.1.11-SNAPSHOT</version>
<name>sdc-jtosca</name>
<properties>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
+
+ <dependency>
+ <groupId>com.opencsv</groupId>
+ <artifactId>opencsv</artifactId>
+ <version>3.10</version>
+ </dependency>
+
+ <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-io -->
+<dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-io</artifactId>
+ <version>1.3.2</version>
+</dependency>
+
</dependencies>
<reporting>
-package org.openecomp.sdc.toscaparser.api;
+package org.openecomp.sdc.toscaparser.api;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.openecomp.sdc.toscaparser.api.elements.*;
import org.openecomp.sdc.toscaparser.api.elements.constraints.Constraint;
import org.openecomp.sdc.toscaparser.api.elements.constraints.Schema;
else {
if(!(value instanceof LinkedHashMap)) {
//ERROR under investigation
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE001", String.format(
"TypeMismatchError: \"%s\" is not a map. The type is \"%s\"",
- value.toString(),dataType.getType()));
+ value.toString(),dataType.getType())));
if (value instanceof List && ((List) value).size() > 0) {
value = ((List) value).get(0);
for(String valueKey: valueDict.keySet()) {
//1710 devlop JSON validation
if(!("json").equals(dataType.getType()) && !allowedProps.contains(valueKey)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: Data value of type \"%s\" contains unknown field \"%s\"",
- dataType.getType(),valueKey));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE100", String.format(
+ "UnknownFieldError: Data value of type \"%s\" contains unknown field \"%s\"",
+ dataType.getType(),valueKey)));
}
}
}
}
if(missingProp.size() > 0) {
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE003",String.format(
"MissingRequiredFieldError: Data value of type \"%s\" is missing required field(s) \"%s\"",
- dataType.getType(),missingProp.toString()));
+ dataType.getType(),missingProp.toString())));
}
// check every field
}
else if (type == null) {
//NOT ANALYZED
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE002", String.format(
"MissingType: Type is missing for value \"%s\"",
- value.toString()));
+ value.toString())));
return value;
}
else if(type.equals(Schema.STRING)) {
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import MissingRequiredFieldError
from toscaparser.common.exception import TypeMismatchError
from toscaparser.common.exception import UnknownFieldError
# If the datatype has 'properties' definition
else:
if not isinstance(self.value, dict):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
TypeMismatchError(what=self.value,
type=self.datatype.type))
allowed_props = []
# check allowed field
for value_key in list(self.value.keys()):
if value_key not in allowed_props:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what=(_('Data value of type "%s"')
% self.datatype.type),
field=value_key))
if req_key not in list(self.value.keys()):
missingprop.append(req_key)
if missingprop:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what=(_('Data value of type "%s"')
% self.datatype.type), required=missingprop))
import java.util.LinkedHashMap;
import java.util.List;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
import org.openecomp.sdc.toscaparser.api.elements.*;
import org.openecomp.sdc.toscaparser.api.elements.constraints.Constraint;
import org.openecomp.sdc.toscaparser.api.elements.constraints.Schema;
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.openecomp.sdc.toscaparser.api.elements.*;
+import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import java.util.List;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.elements.*;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
public abstract class EntityTemplate {
// Base class for TOSCA templates
if(type == null) {
//msg = (_('Policy definition of "%(pname)s" must have'
// ' a "type" ''attribute.') % dict(pname=name))
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValidationError: Policy definition of \"%s\" must have a \"type\" attribute",name));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE140", String.format(
+ "ValidationError: Policy definition of \"%s\" must have a \"type\" attribute",name)));
}
typeDefinition = new PolicyType(type, customDef);
}
// '"default_instances" value is not between '
// '"min_instances" and "max_instances".' %
// self.name)
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE141", String.format(
"ValidationError: \"properties\" of template \"%s\": \"default_instances\" value is not between \"min_instances\" and \"max_instances\"",
- name));
+ name)));
}
}
}
}
// Required properties found without value or a default value
if(!reqPropsNoValueOrDefault.isEmpty()) {
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE003", String.format(
"MissingRequiredFieldError: properties of template \"%s\" are missing field(s): %s",
- name,reqPropsNoValueOrDefault.toString()));
+ name,reqPropsNoValueOrDefault.toString())));
}
}
else {
// Required properties in schema, but not in template
if(!requiredProps.isEmpty()) {
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE004", String.format(
"MissingRequiredFieldError2: properties of template \"%s\" are missing field(s): %s",
- name,requiredProps.toString()));
+ name,requiredProps.toString())));
}
}
}
@SuppressWarnings("unchecked")
private void _validateField(LinkedHashMap<String,Object> template) {
if(!(template instanceof LinkedHashMap)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "MissingRequiredFieldError: Template \"%s\" is missing required field \"%s\"",name,TYPE));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE142", String.format(
+ "MissingRequiredFieldError: Template \"%s\" is missing required field \"%s\"",name,TYPE)));
return;//???
}
boolean bBad = false;
bBad = (template.get(TYPE) == null);
}
if(bBad) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "MissingRequiredFieldError: Template \"%s\" is missing required field \"%s\"",name,TYPE));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE143", String.format(
+ "MissingRequiredFieldError: Template \"%s\" is missing required field \"%s\"",name,TYPE)));
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: Section \"%s\" of template \"%s\" contains unknown field \"%s\"",section,name,sname));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE144", String.format(
+ "UnknownFieldError: Section \"%s\" of template \"%s\" contains unknown field \"%s\"",section,name,sname)));
}
}
if not type:
msg = (_('Policy definition of "%(pname)s" must have'
' a "type" ''attribute.') % dict(pname=name))
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(msg))
self.type_definition = PolicyType(type, custom_def)
'"default_instances" value is not between '
'"min_instances" and "max_instances".' %
self.name)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=err_msg))
def _common_validate_properties(self, entitytype, properties):
req_props_no_value_or_default.append(r)
# Required properties found without value or a default value
if req_props_no_value_or_default:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what='"properties" of template "%s"' % self.name,
required=req_props_no_value_or_default))
else:
# Required properties in schema, but not in template
if required_props:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what='"properties" of template "%s"' % self.name,
required=required_props))
def _validate_field(self, template):
if not isinstance(template, dict):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what='Template "%s"' % self.name, required=self.TYPE))
try:
else:
template[self.TYPE]
except KeyError:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what='Template "%s"' % self.name, required=self.TYPE))
def _common_validate_field(self, schema, allowedlist, section):
for name in schema:
if name not in allowedlist:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(
what=('"%(section)s" of template "%(nodename)s"'
% {'section': section, 'nodename': self.name}),
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.elements.Metadata;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE183", String.format(
"UnknownFieldError: Groups \"%s\" contains unknown field \"%s\"",
- name,key));
+ name,key)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import UnknownFieldError
from toscaparser.entity_template import EntityTemplate
from toscaparser.utils import validateutils
def _validate_keys(self):
for key in self.entity_tpl.keys():
if key not in SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Groups "%s"' % self.name,
field=key))
*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import org.openecomp.sdc.toscaparser.api.elements.TypeValidation;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.openecomp.sdc.toscaparser.api.utils.UrlUtils;
if((_path == null || _path.isEmpty()) && tpl == null) {
//msg = _('Input tosca template is not provided.')
//log.warning(msg)
- ThreadLocalsHolder.getCollector().appendException("ValidationError: Input tosca template is not provided");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE184", "ValidationError: Input tosca template is not provided"));
}
this.path = _path;
if(importslist == null) {
//msg = _('"imports" keyname is defined without including templates.')
//log.error(msg)
- ThreadLocalsHolder.getCollector().appendException(
- "ValidationError: \"imports\" keyname is defined without including templates");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE185",
+ "ValidationError: \"imports\" keyname is defined without including templates"));
return;
}
if(importNames.contains(importName)) {
//msg = (_('Duplicate import name "%s" was found.') % import_name)
//log.error(msg)
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValidationError: Duplicate import name \"%s\" was found",importName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE186", String.format(
+ "ValidationError: Duplicate import name \"%s\" was found",importName)));
}
importNames.add(importName); //???
private void _validateImportKeys(String importName, LinkedHashMap<String,Object> importUri) {
if(importUri.get(FILE) == null) {
//log.warning(_('Missing keyname "file" in import "%(name)s".') % {'name': import_name})
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "MissingRequiredFieldError: Import of template \"%s\" is missing field %s",importName,FILE));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE187", String.format(
+ "MissingRequiredFieldError: Import of template \"%s\" is missing field %s",importName,FILE)));
}
for(String key: importUri.keySet()) {
boolean bFound = false;
//log.warning(_('Unknown keyname "%(key)s" error in '
// 'imported definition "%(def)s".')
// % {'key': key, 'def': import_name})
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: Import of template \"%s\" has unknown fiels %s",importName,key));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE188", String.format(
+ "UnknownFieldError: Import of template \"%s\" has unknown fiels %s",importName,key)));
}
}
}
repository = (String)((LinkedHashMap<String,Object>)importUriDef).get(REPOSITORY);
if(repository != null) {
if(!repositories.keySet().contains(repository)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE189", String.format(
"InvalidPropertyValueError: Repository \"%s\" not found in \"%s\"",
- repository,repositories.keySet().toString()));
+ repository,repositories.keySet().toString())));
}
}
}
// 'definition "%(import_name)s".')
// % {'import_name': import_name})
//log.error(msg)
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValidationError: A template file name is not provided with import definition \"%s\"",importName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE190", String.format(
+ "ValidationError: A template file name is not provided with import definition \"%s\"",importName)));
al[0] = al[1] = null;
return al;
}
return al;
}
catch(IOException e) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: \"%s\" loading YAML import from \"%s\"",e.getClass().getSimpleName(),fileName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE191", String.format(
+ "ImportError: \"%s\" loading YAML import from \"%s\"",e.getClass().getSimpleName(),fileName)));
al[0] = al[1] = null;
return al;
}
String msg = String.format(
"ImportError: Absolute file name \"%s\" cannot be used in the URL-based input template \"%s\"",
fileName,path);
- ThreadLocalsHolder.getCollector().appendException(msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE192", msg));
al[0] = al[1] = null;
return al;
}
//log.error(msg)
String msg = String.format(
"ValueError: \"%s\" is not a valid file",importTemplate);
- ThreadLocalsHolder.getCollector().appendException(msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE193", msg));
log.debug("ImportsLoader - _loadImportTemplate - {}", msg);
}
}
else {
String msg = String.format(
"Relative file name \"%s\" cannot be used in a pre-parsed input template",fileName);
- ThreadLocalsHolder.getCollector().appendException("ImportError: " + msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE194", "ImportError: " + msg));
al[0] = al[1] = null;
return al;
}
if(importTemplate == null || importTemplate.isEmpty()) {
//log.error(_('Import "%(name)s" is not valid.') %
// {'name': import_uri_def})
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: Import \"%s\" is not valid",importUriDef));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE195", String.format(
+ "ImportError: Import \"%s\" is not valid",importUriDef)));
al[0] = al[1] = null;
return al;
}
// for now, this must be a file
if(!aFile) {
log.error("ImportsLoader - _loadImportTemplate - Error!! Expected a file. importUriDef = {}, importTemplate = {}", importUriDef, importTemplate);
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: Import \"%s\" is not a file",importName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE196", String.format(
+ "ImportError: Import \"%s\" is not a file",importName)));
al[0] = al[1] = null;
return al;
}
return al;
}
catch(FileNotFoundException e) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: Failed to load YAML from \"%s\"",importName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE197", String.format(
+ "ImportError: Failed to load YAML from \"%s\"",importName)));
al[0] = al[1] = null;
return al;
}
catch(Exception e) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: Exception from SnakeYAML file = \"%s\"",importName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE198", String.format(
+ "ImportError: Exception from SnakeYAML file = \"%s\"",importName)));
al[0] = al[1] = null;
return al;
}
if(shortImportNotation) {
//log.error(_('Import "%(name)s" is not valid.') % import_uri_def)
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: Import \"%s\" is not valid",importName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE199", String.format(
+ "ImportError: Import \"%s\" is not valid",importName)));
al[0] = al[1] = null;
return al;
}
String msg = String.format(
"referenced repository \"%s\" in import definition \"%s\" not found",
repository,importName);
- ThreadLocalsHolder.getCollector().appendException("ImportError: " + msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE200", "ImportError: " + msg));
al[0] = al[1] = null;
return al;
}
return al;
}
catch(IOException e) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: Exception loading YAML import from \"%s\"",fullUrl));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE201", String.format(
+ "ImportError: Exception loading YAML import from \"%s\"",fullUrl)));
al[0] = al[1] = null;
return al;
}
String msg = String.format(
"repository URL \"%s\" in import definition \"%s\" is not valid",
repoUrl,importName);
- ThreadLocalsHolder.getCollector().appendException("ImportError: " + msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE202", "ImportError: " + msg));
}
// if we got here something is wrong with the flow...
log.error("ImportsLoader - _loadImportTemplate - got to dead end (importName {})", importName);
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ImportError: _loadImportTemplate got to dead end (importName %s)\n",importName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE203", String.format(
+ "ImportError: _loadImportTemplate got to dead end (importName %s)\n",importName)));
al[0] = al[1] = null;
return al;
}
import logging
import os
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidPropertyValueError
from toscaparser.common.exception import MissingRequiredFieldError
from toscaparser.common.exception import UnknownFieldError
if not path and not tpl:
msg = _('Input tosca template is not provided.')
log.warning(msg)
- ExceptionCollector.appendException(ValidationError(message=msg))
+ ValidationIssueCollector.appendException(ValidationError(message=msg))
self.path = path
self.repositories = {}
if tpl and tpl.get('repositories'):
msg = _('"imports" keyname is defined without including '
'templates.')
log.error(msg)
- ExceptionCollector.appendException(ValidationError(message=msg))
+ ValidationIssueCollector.appendException(ValidationError(message=msg))
return
for import_def in self.importslist:
msg = (_('Duplicate import name "%s" was found.') %
import_name)
log.error(msg)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=msg))
imports_names.add(import_name)
if self.FILE not in import_uri_def.keys():
log.warning(_('Missing keyname "file" in import "%(name)s".')
% {'name': import_name})
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what='Import of template "%s"' % import_name,
required=self.FILE))
log.warning(_('Unknown keyname "%(key)s" error in '
'imported definition "%(def)s".')
% {'key': key, 'def': import_name})
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(
what='Import of template "%s"' % import_name,
field=key))
repos = self.repositories.keys()
if repository is not None:
if repository not in repos:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidPropertyValueError(
what=_('Repository is not found in "%s"') % repos))
else:
'definition "%(import_name)s".')
% {'import_name': import_name})
log.error(msg)
- ExceptionCollector.appendException(ValidationError(message=msg))
+ ValidationIssueCollector.appendException(ValidationError(message=msg))
return
if toscaparser.utils.urlutils.UrlUtils.validate_url(file_name):
'"%(template)s".')
% {'name': file_name, 'template': self.path})
log.error(msg)
- ExceptionCollector.appendException(ImportError(msg))
+ ValidationIssueCollector.appendException(ImportError(msg))
return
import_template = toscaparser.utils.urlutils.UrlUtils.\
join_url(self.path, file_name)
% {'import_template':
import_template})
log.error(msg)
- ExceptionCollector.appendException
+ ValidationIssueCollector.appendException
(ValueError(msg))
else: # template is pre-parsed
if os.path.isabs(file_name) and os.path.isfile(file_name):
'in a pre-parsed input template.')
% {'name': file_name})
log.error(msg)
- ExceptionCollector.appendException(ImportError(msg))
+ ValidationIssueCollector.appendException(ImportError(msg))
return
if not import_template:
log.error(_('Import "%(name)s" is not valid.') %
{'name': import_uri_def})
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ImportError(_('Import "%s" is not valid.') %
import_uri_def))
return
if short_import_notation:
log.error(_('Import "%(name)s" is not valid.') % import_uri_def)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ImportError(_('Import "%s" is not valid.') % import_uri_def))
return
'definition "%(tpl)s" not found.')
% {'n_uri': repository, 'tpl': import_name})
log.error(msg)
- ExceptionCollector.appendException(ImportError(msg))
+ ValidationIssueCollector.appendException(ImportError(msg))
return
if toscaparser.utils.urlutils.UrlUtils.validate_url(full_url):
'definition "%(tpl)s".')
% {'n_uri': repo_url, 'tpl': import_name})
log.error(msg)
- ExceptionCollector.appendException(ImportError(msg))
+ ValidationIssueCollector.appendException(ImportError(msg))
*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
}
}
if(bFound || customDef.get(node) != null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE205", String.format(
"NotImplementedError: Lookup by TOSCA types is not supported. Requirement for \"%s\" can not be full-filled",
- getName()));
+ getName())));
return null;
}
if(templates.get(node) == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "KeyError: Node template \"%s\" was not found",node));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE206", String.format(
+ "KeyError: Node template \"%s\" was not found",node)));
return null;
}
NodeTemplate relatedTpl = new NodeTemplate(node,templates,customDef,null,null);
if(relationship == null) {
ArrayList<Object> parentReqs = ((NodeType)typeDefinition).getAllRequirements();
if(parentReqs == null) {
- ThreadLocalsHolder.getCollector().appendException("ValidationError: parent_req is null");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE207", "ValidationError: parent_req is null"));
}
else {
// for(String key: req.keySet()) {
}
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE208", String.format(
"MissingRequiredFieldError: \"relationship\" used in template \"%s\" is missing required field \"type\"",
- relatedTpl.getName()));
+ relatedTpl.getName())));
}
}
for(RelationshipType rtype: ((NodeType)typeDefinition).getRelationship().keySet()) {
ArrayList<Object> requires = (ArrayList<Object>)((NodeType)typeDefinition).getValue(REQUIREMENTS, entityTpl, false);
if(requires != null) {
if(!(requires instanceof ArrayList)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "TypeMismatchError: \"requirements\" of template \"%s\" are not of type \"list\"",name));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE209", String.format(
+ "TypeMismatchError: \"requirements\" of template \"%s\" are not of type \"list\"",name)));
}
else {
for(Object ro: requires) {
if(occurrences.size() != 2 ||
!(0 <= (int)occurrences.get(0) && (int)occurrences.get(0) <= (int)occurrences.get(1)) ||
(int)occurrences.get(1) == 0) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidPropertyValueError: property has invalid value %s",occurrences.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE210", String.format(
+ "InvalidPropertyValueError: property has invalid value %s",occurrences.toString())));
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: \"requirements\" of template \"%s\" contains unknown field \"%s\"",name,key));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE211", String.format(
+ "UnknownFieldError: \"requirements\" of template \"%s\" contains unknown field \"%s\"",name,key)));
}
}
}
_commonValidateField(value,_collectCustomIfaceOperations(iname),"interfaces");
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: \"interfaces\" of template \"%s\" contains unknown field %s",name,iname));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE212", String.format(
+ "UnknownFieldError: \"interfaces\" of template \"%s\" contains unknown field %s",name,iname)));
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: Node template \"%s\" has unknown field \"%s\"",name,ntname));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE213", String.format(
+ "UnknownFieldError: Node template \"%s\" has unknown field \"%s\"",name,ntname)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidPropertyValueError
from toscaparser.common.exception import MissingRequiredFieldError
from toscaparser.common.exception import TypeMismatchError
'Requirement for "%s" can not be full-filled.') % self.name
if (node in list(self.type_definition.TOSCA_DEF.keys())
or node in self.custom_def):
- ExceptionCollector.appendException(NotImplementedError(msg))
+ ValidationIssueCollector.appendException(NotImplementedError(msg))
return
if node not in self.templates:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('Node template "%s" was not found.') % node))
return
if not relationship:
parent_reqs = self.type_definition.get_all_requirements()
if parent_reqs is None:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message='parent_req is ' +
str(parent_reqs)))
else:
elif not relationship.startswith(rel_prfx):
relationship = rel_prfx + relationship
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what=_('"relationship" used in template '
'"%s"') % related_tpl.name,
self.entity_tpl)
if requires:
if not isinstance(requires, list):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
TypeMismatchError(
what='"requirements" of template "%s"' % self.name,
type='list'))
DataEntity.validate_datatype('integer', value)
if len(occurrences) != 2 or not (0 <= occurrences[0] <= occurrences[1]) \
or occurrences[1] == 0:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidPropertyValueError(what=(occurrences)))
def _validate_requirements_keys(self, requirement):
for key in requirement.keys():
if key not in self.REQUIREMENTS_SECTION:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(
what='"requirements" of template "%s"' % self.name,
field=key))
self._collect_custom_iface_operations(name),
'interfaces')
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(
what='"interfaces" of template "%s"' %
self.name, field=name))
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(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Node template "%s"' % self.name,
field=name))*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE219", String.format(
"UnknownFieldError: Policy \"%s\" contains unknown field \"%s\"",
- name,key));
+ name,key)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import UnknownFieldError
from toscaparser.entity_template import EntityTemplate
from toscaparser.triggers import Triggers
def _validate_keys(self):
for key in self.entity_tpl.keys():
if key not in SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Policy "%s"' % self.name,
field=key))
*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.openecomp.sdc.toscaparser.api.utils.UrlUtils;
if(reposit instanceof LinkedHashMap) {
url = (String)((LinkedHashMap<String,Object>)reposit).get("url");
if(url == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE229", String.format(
"MissingRequiredFieldError: Repository \"%s\" is missing required field \"url\"",
- name));
+ name)));
}
}
loadAndValidate(name,reposit);
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE230", String.format(
"UnknownFieldError: repositories \"%s\" contains unknown field \"%s\"",
- keyname,key));
+ keyname,key)));
}
}
if(repositUrl != null) {
boolean urlVal = UrlUtils.validateUrl(repositUrl);
if(!urlVal) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "URLException: repsositories \"%s\" Invalid Url",keyname));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE231", String.format(
+ "URLException: repsositories \"%s\" Invalid Url",keyname)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import MissingRequiredFieldError
from toscaparser.common.exception import UnknownFieldError
from toscaparser.common.exception import URLException
self.reposit = values
if isinstance(self.reposit, dict):
if 'url' not in self.reposit.keys():
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(what=_('Repository "%s"')
% self.name, required='url'))
self.url = self.reposit['url']
if isinstance(reposit_def, dict):
for key in reposit_def.keys():
if key not in SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what=_('repositories "%s"')
% self.keyname, field=key))
url_val = toscaparser.utils.urlutils.UrlUtils.\
validate_url(reposit_url)
if url_val is not True:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
URLException(what=_('repsositories "%s" Invalid Url')
% self.keyname))
*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api;
-import java.util.*;
-
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.openecomp.sdc.toscaparser.api.elements.NodeType;
import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
import org.openecomp.sdc.toscaparser.api.parameters.Input;
import org.openecomp.sdc.toscaparser.api.parameters.Output;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+
public class SubstitutionMappings {
// SubstitutionMappings class declaration
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE232", String.format(
"UnknownFieldError: SubstitutionMappings contain unknown field \"%s\"",
- key));
+ key)));
}
}
}
// validate the node_type of substitution mappings
String nodeType = (String)subMappingDef.get(NODE_TYPE);
if(nodeType == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE233", String.format(
"MissingRequiredFieldError: SubstitutionMappings used in topology_template is missing required field \"%s\"",
- NODE_TYPE));
+ NODE_TYPE)));
}
Object nodeTypeDef = customDefs.get(nodeType);
if(nodeTypeDef == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidNodeTypeError: \"%s\" is invalid",nodeType));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE234", String.format(
+ "InvalidNodeTypeError: \"%s\" is invalid",nodeType)));
}
}
for(String property: requiredProperties) {
// Check property which is 'required' and has no 'default' value
if(!allInputs.contains(property)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE235", String.format(
"MissingRequiredInputError: SubstitutionMappings with node_type \"%s\" is missing required input \"%s\"",
- getNodeType(),property));
+ getNodeType(),property)));
}
}
// If the optional properties of node type need to be customized by
diffset.removeAll(allInputs);
for(String parameter: diffset) {
if(allProperties.contains(parameter)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE236", String.format(
"MissingRequiredInputError: SubstitutionMappings with node_type \"%s\" is missing required input \"%s\"",
- getNodeType(),parameter));
+ getNodeType(),parameter)));
}
}
// Additional inputs are not in the properties of node type must
diffset = allInputs;
diffset.removeAll(allProperties);
if(diffset.contains(inp.getName()) && inp.getDefault() == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE237", String.format(
"MissingRequiredInputError: SubstitutionMappings with node_type \"%s\" is missing rquired input \"%s\"",
- getNodeType(),inp.getName()));
+ getNodeType(),inp.getName())));
}
}
}
for(CapabilityAssignment cap: nodeCapabilities) {
if(tplsCapabilities != null && tplsCapabilities.get(cap.getName()) == null) {
; //pass
- // ExceptionCollector.appendException(
+ // ValidationIssueCollector.appendException(
// UnknownFieldError(what='SubstitutionMappings',
// field=cap))
}
String cap = ro.getName();
if(tplsRequirements != null && tplsRequirements.get(cap) == null) {
; //pass
- // ExceptionCollector.appendException(
+ // ValidationIssueCollector.appendException(
// UnknownFieldError(what='SubstitutionMappings',
// field=cap))
}
for(Output output: outputs) {
Object ado = getNodeDefinition().getAttributesDef();
if(ado != null && ((LinkedHashMap<String,Object>)ado).get(output.getName()) == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE238", String.format(
"UnknownOutputError: Unknown output \"%s\" in SubstitutionMappings with node_type \"%s\"",
- output.getName(),getNodeType()));
+ output.getName(),getNodeType())));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidNodeTypeError
from toscaparser.common.exception import MissingDefaultValueError
from toscaparser.common.exception import MissingRequiredFieldError
"""validate the keys of substitution mappings."""
for key in self.sub_mapping_def.keys():
if key not in self.SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what=_('SubstitutionMappings'),
field=key))
"""validate the node_type of substitution mappings."""
node_type = self.sub_mapping_def.get(self.NODE_TYPE)
if not node_type:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(
what=_('SubstitutionMappings used in topology_template'),
required=self.NODE_TYPE))
node_type_def = self.custom_defs.get(node_type)
if not node_type_def:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidNodeTypeError(what=node_type))
def _validate_inputs(self):
for property in required_properties:
# Check property which is 'required' and has no 'default' value
if property not in all_inputs:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredInputError(
what=_('SubstitutionMappings with node_type ')
+ self.node_type,
all_properties = set(self.node_definition.get_properties_def())
for parameter in customized_parameters - all_inputs:
if parameter in all_properties:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredInputError(
what=_('SubstitutionMappings with node_type ')
+ self.node_type,
for input in self.inputs:
if input.name in all_inputs - all_properties \
and input.default is None:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingDefaultValueError(
what=_('SubstitutionMappings with node_type ')
+ self.node_type,
if (tpls_capabilities and
cap not in list(tpls_capabilities.keys())):
pass
- # ExceptionCollector.appendException(
+ # ValidationIssueCollector.appendException(
# UnknownFieldError(what='SubstitutionMappings',
# field=cap))
if (tpls_requirements and
req not in list(tpls_requirements.keys())):
pass
- # ExceptionCollector.appendException(
+ # ValidationIssueCollector.appendException(
# UnknownFieldError(what='SubstitutionMappings',
# field=req))
# has properties, the specification will be amended?
for output in self.outputs:
if output.name not in self.node_definition.get_attributes_def():
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownOutputError(
where=_('SubstitutionMappings with node_type ')
+ self.node_type,
package org.openecomp.sdc.toscaparser.api;
-import java.util.*;
-
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.openecomp.sdc.toscaparser.api.elements.InterfacesDef;
import org.openecomp.sdc.toscaparser.api.elements.NodeType;
import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
import org.openecomp.sdc.toscaparser.api.parameters.Output;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
public class TopologyTemplate {
private static final String DESCRIPTION = "description";
DataEntity.validateDatatype("list", memberNames,null,null,null);
if(memberNames.size() < 1 ||
(new HashSet<String>(memberNames)).size() != memberNames.size()) {
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE005",String.format(
"InvalidGroupTargetException: Member nodes \"%s\" should be >= 1 and not repeated",
- memberNames.toString()));
+ memberNames.toString())));
}
else {
memberNodes = _getGroupMembers(memberNames);
}
for(String member: members) {
if(!nodeNames.contains(member)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidGroupTargetException: Target member \"%s\" is not found in \"nodeTemplates\"",member));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE239", String.format(
+ "InvalidGroupTargetException: Target member \"%s\" is not found in \"nodeTemplates\"",member)));
}
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: TopologyTemplate contains unknown field \"%s\"",name));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE240", String.format(
+ "UnknownFieldError: TopologyTemplate contains unknown field \"%s\"",name)));
}
}
}
DataEntity.validate_datatype('list', member_names)
if len(member_names) < 1 or \
len(member_names) != len(set(member_names)):
- exception.ExceptionCollector.appendException(
+ exception.ValidationIssueCollector.appendException(
exception.InvalidGroupTargetException(
message=_('Member nodes "%s" should be >= 1 '
'and not repeated') % member_names))
node_names.append(node.name)
for member in members:
if member not in node_names:
- exception.ExceptionCollector.appendException(
+ exception.ValidationIssueCollector.appendException(
exception.InvalidGroupTargetException(
message=_('Target member "%s" is not found in '
'node_templates') % member))
def _validate_field(self):
for name in self.tpl:
if name not in SECTIONS:
- exception.ExceptionCollector.appendException(
+ exception.ValidationIssueCollector.appendException(
exception.UnknownFieldError(what='Template', field=name))
def _process_intrinsic_functions(self):
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaError;
+
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
import org.openecomp.sdc.toscaparser.api.elements.InterfacesDef;
import org.openecomp.sdc.toscaparser.api.elements.NodeType;
import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
DataEntity.validateDatatype("list", memberNames,null,null,null);
if(memberNames.size() < 1 ||
(new HashSet<String>(memberNames)).size() != memberNames.size()) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendError(new JToscaError("JE241", String.format(
"InvalidGroupTargetException: Member nodes \"%s\" should be >= 1 and not repeated",
- memberNames.toString()));
+ memberNames.toString())));
}
else {
memberNodes = _getGroupMembers(memberNames);
}
for(String member: members) {
if(!nodeNames.contains(member)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidGroupTargetException: Target member \"%s\" is not found in \"nodeTemplates\"",member));
+ ThreadLocalsHolder.getCollector().appendError(new JToscaError("JE242", String.format(
+ "InvalidGroupTargetException: Target member \"%s\" is not found in \"nodeTemplates\"",member)));
}
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: TopologyTemplate contains unknown field \"%s\"",name));
+ ThreadLocalsHolder.getCollector().appendError(new JToscaError("JE243", String.format(
+ "UnknownFieldError: TopologyTemplate contains unknown field \"%s\"",name)));
}
}
}
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
import org.openecomp.sdc.toscaparser.api.common.JToscaException;
import org.openecomp.sdc.toscaparser.api.elements.EntityType;
import org.openecomp.sdc.toscaparser.api.elements.Metadata;
boolean aFile,
LinkedHashMap<String, Object> yamlDictTpl, boolean _resolveGetInput) throws JToscaException {
- ThreadLocalsHolder.setCollector(new ExceptionCollector(_path));
+ ThreadLocalsHolder.setCollector(new ValidationIssueCollector());
VALID_TEMPLATE_VERSIONS = new ArrayList<>();
VALID_TEMPLATE_VERSIONS.add("tosca_simple_yaml_1_0");
tpl = yamlDictTpl;
}
else {
- ThreadLocalsHolder.getCollector().appendException(
- "ValueError: No path or yaml_dict_tpl was provided. There is nothing to parse");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE244",
+ "ValueError: No path or yaml_dict_tpl was provided. There is nothing to parse"));
log.debug("ToscaTemplate ValueError: No path or yaml_dict_tpl was provided. There is nothing to parse");
}
private void _validateField() {
String sVersion = _tplVersion();
if(sVersion == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "MissingRequiredField: Template is missing required field \"%s\"",DEFINITION_VERSION));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE245", String.format(
+ "MissingRequiredField: Template is missing required field \"%s\"",DEFINITION_VERSION)));
}
else {
_validateVersion(sVersion);
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE246", String.format(
"UnknownFieldError: Template contains unknown field \"%s\"",
- sKey));
+ sKey)));
}
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE247", String.format(
"InvalidTemplateVersion: \"%s\" is invalid. Valid versions are %s",
- sVersion,VALID_TEMPLATE_VERSIONS.toString()));
+ sVersion,VALID_TEMPLATE_VERSIONS.toString())));
}
else if(!sVersion.equals("tosca_simple_yaml_1_0")) {
EntityType.updateDefinitions(sVersion);
}
}
else {
- ThreadLocalsHolder.getCollector().appendException("ValueError: " + _path + " is not a valid file");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE248", "ValueError: " + _path + " is not a valid file"));
return null;
}
return null;
}
private void verifyTemplate() throws JToscaException {
- ThreadLocalsHolder.getCollector().setWantTrace(false);
-
- //Warnings
- int warningsCount = ThreadLocalsHolder.getCollector().warningsCaught();
- if (warningsCount > 0) {
- List<String> warningsStrings = ThreadLocalsHolder.getCollector().getWarningsReport();
- log.warn("####################################################################################################");
- log.warn("CSAR Warnings found! CSAR name - {}", inputPath);
- log.warn("ToscaTemplate - verifyTemplate - {} Parsing Warning{} occurred...", warningsCount, (warningsCount > 1 ? "s" : ""));
- for (String s : warningsStrings) {
- log.warn("{}. CSAR name - {}", s, inputPath);
- }
- log.warn("####################################################################################################");
- }
-
//Criticals
- int criticalsCount = ThreadLocalsHolder.getCollector().criticalsCaught();
- if (criticalsCount > 0) {
- List<String> criticalStrings = ThreadLocalsHolder.getCollector().getCriticalsReport();
- log.error("####################################################################################################");
- log.error("ToscaTemplate - verifyTemplate - {} Parsing Critical{} occurred...", criticalsCount, (criticalsCount > 1 ? "s" : ""));
- for (String s : criticalStrings) {
- log.error("{}. CSAR name - {}", s, inputPath);
+ int validationIssuesCaught = ThreadLocalsHolder.getCollector().validationIssuesCaught();
+ if (validationIssuesCaught > 0) {
+ List<String> validationIssueStrings = ThreadLocalsHolder.getCollector().getValidationIssueReport();
+ log.trace("####################################################################################################");
+ log.trace("ToscaTemplate - verifyTemplate - {} Parsing Critical{} occurred...", validationIssuesCaught, (validationIssuesCaught > 1 ? "s" : ""));
+ for (String s : validationIssueStrings) {
+ log.trace("{}. CSAR name - {}", s, inputPath);
}
- throw new JToscaException(String.format("CSAR Validation Failed. CSAR name - {}. Please check logs for details.", inputPath), JToscaErrorCodes.CSAR_TOSCA_VALIDATION_ERROR.getValue());
+ log.trace("####################################################################################################");
}
+
}
public String getPath() {
import os
from copy import deepcopy
-from toscaparser.common.exception import ExceptionCollector.collector
+from toscaparser.common.exception import ValidationIssueCollector.collector
from toscaparser.common.exception import InvalidTemplateVersion
from toscaparser.common.exception import MissingRequiredFieldError
from toscaparser.common.exception import UnknownFieldError
def __init__(self, path=None, parsed_params=None, a_file=True,
yaml_dict_tpl=None):
- ExceptionCollector.collector.start()
+ ValidationIssueCollector.collector.start()
self.a_file = a_file
self.input_path = None
self.path = None
if yaml_dict_tpl:
self.tpl = yaml_dict_tpl
else:
- ExceptionCollector.collector.appendException(
+ ValidationIssueCollector.collector.appendException(
ValueError(_('No path or yaml_dict_tpl was provided. '
'There is nothing to parse.')))
self._handle_nested_tosca_templates_with_topology()
self.graph = ToscaGraph(self.nodetemplates)
- ExceptionCollector.collector.stop()
+ ValidationIssueCollector.collector.stop()
self.verify_template()
def _topology_template(self):
def _validate_field(self):
version = self._tpl_version()
if not version:
- ExceptionCollector.collector.appendException(
+ ValidationIssueCollector.collector.appendException(
MissingRequiredFieldError(what='Template',
required=DEFINITION_VERSION))
else:
for name in self.tpl:
if (name not in SECTIONS and
name not in self.ADDITIONAL_SECTIONS.get(version, ())):
- ExceptionCollector.collector.appendException(
+ ValidationIssueCollector.collector.appendException(
UnknownFieldError(what='Template', field=name))
def _validate_version(self, version):
if version not in self.VALID_TEMPLATE_VERSIONS:
- ExceptionCollector.collector.appendException(
+ ValidationIssueCollector.collector.appendException(
InvalidTemplateVersion(
what=version,
valid_versions=', '. join(self.VALID_TEMPLATE_VERSIONS)))
self.a_file = True # the file has been decompressed locally
return os.path.join(csar.temp_dir, csar.get_main_template())
else:
- ExceptionCollector.collector.appendException(
+ ValidationIssueCollector.collector.appendException(
ValueError(_('"%(path)s" is not a valid file.')
% {'path': path}))
def verify_template(self):
- if ExceptionCollector.collector.exceptionsCaught():
+ if ValidationIssueCollector.collector.exceptionsCaught():
if self.input_path:
raise ValidationError(
message=(_('\nThe input "%(path)s" failed validation with '
'the following error(s): \n\n\t')
% {'path': self.input_path}) +
- '\n\t'.join(ExceptionCollector.collector.getExceptionsReport()))
+ '\n\t'.join(ValidationIssueCollector.collector.getExceptionsReport()))
else:
raise ValidationError(
message=_('\nThe pre-parsed input failed validation with '
'the following error(s): \n\n\t') +
- '\n\t'.join(ExceptionCollector.collector.getExceptionsReport()))
+ '\n\t'.join(ValidationIssueCollector.collector.getExceptionsReport()))
else:
if self.input_path:
msg = (_('The input "%(path)s" successfully passed '
package org.openecomp.sdc.toscaparser.api;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE249", String.format(
"UnknownFieldError: Triggers \"%s\" contains unknown field \"%s\"",
- name,key));
+ name,key)));
}
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE250", String.format(
"UnknownFieldError: Triggers \"%s\" contains unknown field \"%s\"",
- name,key));
+ name,key)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import UnknownFieldError
from toscaparser.entity_template import EntityTemplate
def _validate_keys(self):
for key in self.trigger_tpl.keys():
if key not in SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Triggers "%s"' % self.name,
field=key))
def _validate_condition(self):
for key in self.get_condition():
if key not in CONDITION_KEYNAMES:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Triggers "%s"' % self.name,
field=key))
*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class UnsupportedType {
public static boolean validateType(String entityType) {
for(String ust: unsupportedTypes) {
if(ust.equals(entityType)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnsupportedTypeError: Entity type \"%s\" is not supported",entityType));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE251", String.format(
+ "UnsupportedTypeError: Entity type \"%s\" is not supported",entityType)));
return true;
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import UnsupportedTypeError
from toscaparser.utils.gettextutils import _
@staticmethod
def validate_type(entitytype):
if entitytype in UnsupportedType.un_supported_types:
- ExceptionCollector.appendException(UnsupportedTypeError(
+ ValidationIssueCollector.appendException(UnsupportedTypeError(
what=_('%s')
% entitytype))
return True
+++ /dev/null
-package org.openecomp.sdc.toscaparser.api.common;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-// Perfectly good enough...
-
-public class ExceptionCollector {
-
- private static Logger log = LoggerFactory.getLogger(ExceptionCollector.class.getName());
-
- private Map<String, String> notAnalyzedExceptions = new HashMap<>();
- private Map<String, String> criticalExceptions = new HashMap<>();
- private Map<String, String> warningExceptions = new HashMap<>();
-
- private boolean bWantTrace = true;
- private String filePath;
-
- public enum ReportType {WARNING, CRITICAL, NOT_ANALYZED}
-
- public ExceptionCollector(String filePath) {
- this.filePath = filePath;
- }
-
- public void appendException(String exception) {
-
- addException(exception, ReportType.NOT_ANALYZED);
- }
-
- public void appendCriticalException(String exception) {
-
- addException(exception, ReportType.CRITICAL);
- }
-
- public void appendWarning(String exception) {
-
- addException(exception, ReportType.WARNING);
- }
-
- private void addException(String exception, ReportType type) {
-
- Map<String, String> exceptions = getExceptionCollection(type);
-
- if (!exceptions.containsKey(exception)) {
- // get stack trace
- StackTraceElement[] ste = Thread.currentThread().getStackTrace();
- StringBuilder sb = new StringBuilder();
- // skip the last 2 (getStackTrace and this)
- for (int i = 2; i < ste.length; i++) {
- sb.append(String.format(" %s(%s:%d)%s", ste[i].getClassName(), ste[i].getFileName(),
- ste[i].getLineNumber(), i == ste.length - 1 ? " " : "\n"));
- }
- exceptions.put(exception, sb.toString());
- }
- }
-
- public List<String> getCriticalsReport() {
-
- return getReport(ReportType.CRITICAL);
- }
-
- public List<String> getNotAnalyzedExceptionsReport() {
-
- return getReport(ReportType.NOT_ANALYZED);
- }
-
- public List<String> getWarningsReport() {
-
- return getReport(ReportType.WARNING);
- }
-
- private List<String> getReport(ReportType type) {
- Map<String, String> collectedExceptions = getExceptionCollection(type);
-
- List<String> report = new ArrayList<>();
- if (collectedExceptions.size() > 0) {
- for (Map.Entry<String, String> exception : collectedExceptions.entrySet()) {
- report.add(exception.getKey());
- if (bWantTrace) {
- report.add(exception.getValue());
- }
- }
- }
-
- return report;
- }
-
- private Map<String, String> getExceptionCollection(ReportType type) {
- switch (type) {
- case WARNING:
- return warningExceptions;
- case CRITICAL:
- return criticalExceptions;
- case NOT_ANALYZED:
- return notAnalyzedExceptions;
- default:
- return notAnalyzedExceptions;
- }
- }
-
- public int errorsNotAnalyzedCaught() {
- return notAnalyzedExceptions.size();
- }
-
- public int criticalsCaught() {
- return criticalExceptions.size();
- }
-
- public int warningsCaught() {
- return warningExceptions.size();
- }
-
- public void setWantTrace(boolean b) {
- bWantTrace = b;
- }
-
-}
this.code = code;
}
- //JT1001 - Meta file missing
- //JT1002 - Invalid yaml content
- //JT1003 - Entry-Definition not defined in meta file
- //JT1004 - Entry-Definition file missing
- //JT1005 - General Error
- //JT1006 - General Error/Path not valid
+ //JE1001 - Meta file missing
+ //JE1002 - Invalid yaml content
+ //JE1003 - Entry-Definition not defined in meta file
+ //JE1004 - Entry-Definition file missing
+ //JE1005 - General Error
+ //JE1006 - General Error/Path not valid
}
--- /dev/null
+package org.openecomp.sdc.toscaparser.api.common;
+
+public class JToscaValidationIssue {
+
+ private String code;
+ private String message;
+
+
+ public JToscaValidationIssue(String code, String message) {
+ super();
+ this.code = code;
+ this.message = message;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+
+ public void setMessage(String message) {
+ this.message = message;
+ }
+
+ public String getCode() {
+ return code;
+ }
+
+ public void setCode(String code) {
+ this.code = code;
+ }
+
+ @Override
+ public String toString() {
+ return "JToscaError [code=" + code + ", message=" + message + "]";
+ }
+}
--- /dev/null
+package org.openecomp.sdc.toscaparser.api.common;
+
+import java.util.*;
+
+// Perfectly good enough...
+
+public class ValidationIssueCollector {
+
+ private Map<String,JToscaValidationIssue> validationIssues = new HashMap<String,JToscaValidationIssue>();
+ public void appendValidationIssue(JToscaValidationIssue issue) {
+
+ validationIssues.put(issue.getMessage(),issue);
+
+ }
+
+ public List<String> getValidationIssueReport() {
+ List<String> report = new ArrayList<>();
+ if (!validationIssues.isEmpty()) {
+ for (JToscaValidationIssue exception : validationIssues.values()) {
+ report.add("["+exception.getCode()+"]: "+ exception.getMessage());
+ }
+ }
+
+ return report;
+ }
+ public Map<String,JToscaValidationIssue> getValidationIssues() {
+ return validationIssues;
+ }
+
+
+ public int validationIssuesCaught() {
+ return validationIssues.size();
+ }
+
+}
// doesn't do anything except emit an exception anyway
//if not hasattr(self, 'defs'):
// defs = None
- // ExceptionCollector.appendException(
+ // ValidationIssueCollector.appendException(
// ValidationError(message="defs is " + str(defs)))
//else:
// defs = self.defs
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import ValidationError
from toscaparser.extensions.exttools import ExtTools
import org.openecomp.sdc.toscaparser.api.utils.yamlparser
value = None
if not hasattr(self, 'defs'):
defs = None
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message="defs is " + str(defs)))
else:
defs = self.defs
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class GroupType extends StatefulEntityType {
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE120", String.format(
"UnknownFieldError: Group Type \"%s\" contains unknown field \"%s\"",
- groupType,name));
+ groupType,name)));
}
}
}
private void _validateMetadata(LinkedHashMap<String,Object> metadata) {
String mtt = (String) metadata.get("type");
if(mtt != null && !mtt.equals("map") && !mtt.equals("tosca:map")) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE121", String.format(
"InvalidTypeError: \"%s\" defined in group for metadata is invalid",
- mtt));
+ mtt)));
}
for(String entrySchema: metadata.keySet()) {
Object estob = metadata.get(entrySchema);
if(estob instanceof LinkedHashMap) {
String est = (String)((LinkedHashMap<String,Object>)estob).get("type");
if(!est.equals("string")) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE122", String.format(
"InvalidTypeError: \"%s\" defined in group for metadata \"%s\" is invalid",
- est,entrySchema));
+ est,entrySchema)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidTypeError
from toscaparser.common.exception import UnknownFieldError
from toscaparser.elements.statefulentitytype import StatefulEntityType
if self.defs:
for name in self.defs.keys():
if name not in self.SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Group Type %s'
% self.grouptype, field=name))
def _validate_metadata(self, meta_data):
if not meta_data.get('type') in ['map', 'tosca:map']:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTypeError(what='"%s" defined in group for '
'metadata' % (meta_data.get('type'))))
for entry_schema, entry_schema_type in meta_data.items():
if isinstance(entry_schema_type, dict) and not \
entry_schema_type.get('type') == 'string':
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTypeError(what='"%s" defined in group for '
'metadata "%s"'
% (entry_schema_type.get('type'),
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
import org.openecomp.sdc.toscaparser.api.EntityTemplate;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class InterfacesDef extends StatefulEntityType {
inputs = (LinkedHashMap<String,Object>)me.getValue();
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE123", String.format(
"UnknownFieldError: \"interfaces\" of template \"%s\" contain unknown field \"%s\"",
- nodeTemplate.getName(),me.getKey()));
+ nodeTemplate.getName(),me.getKey())));
}
}
}
# License for the specific language governing permissions and limitations
# under the License.
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import UnknownFieldError
from toscaparser.elements.statefulentitytype import StatefulEntityType
else:
what = ('"interfaces" of template "%s"' %
self.node_template.name)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what=what, field=i))
else:
self.implementation = value
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
-import org.openecomp.sdc.toscaparser.api.elements.InterfacesDef;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class NodeType extends StatefulEntityType {
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: Nodetype \"%s\" has unknown field \"%s\"",ntype,key));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE124", String.format(
+ "UnknownFieldError: Nodetype \"%s\" has unknown field \"%s\"",ntype,key)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import UnknownFieldError
from toscaparser.elements.capabilitytype import CapabilityTypeDef
import org.openecomp.sdc.toscaparser.api.elements.interfaces as ifaces
if self.defs:
for key in self.defs.keys():
if key not in self.SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Nodetype"%s"' % self.ntype,
field=key))
*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.TOSCAVersionProperty;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE125", String.format(
"UnknownFieldError: Policy \"%s\" contains unknown field \"%s\"",
- type,key));
+ type,key)));
}
}
}
LinkedHashMap<String,Object> _customDef) {
for(String nodetype: _targetsList) {
if(_customDef.get(nodetype) == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE126", String.format(
"InvalidTypeError: \"%s\" defined in targets for policy \"%s\"",
- nodetype,type));
+ nodetype,type)));
}
}
private void _validateMetadata(LinkedHashMap<String,Object> _metaData) {
String mtype = (String)_metaData.get("type");
if(mtype != null && !mtype.equals("map") && !mtype.equals("tosca:map")) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE127", String.format(
"InvalidTypeError: \"%s\" defined in policy for metadata",
- mtype));
+ mtype)));
}
for(String entrySchema: metaData.keySet()) {
Object estob = metaData.get(entrySchema);
String est = (String)
((LinkedHashMap<String,Object>)estob).get("type");
if(!est.equals("string")) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE128", String.format(
"InvalidTypeError: \"%s\" defined in policy for metadata \"%s\"",
- est,entrySchema));
+ est,entrySchema)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidTypeError
from toscaparser.common.exception import UnknownFieldError
from toscaparser.elements.statefulentitytype import StatefulEntityType
def _validate_keys(self):
for key in self.defs.keys():
if key not in self.SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Policy "%s"' % self.type,
field=key))
def _validate_targets(self, targets_list, custom_def):
for nodetype in targets_list:
if nodetype not in custom_def:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTypeError(what='"%s" defined in targets for '
'policy "%s"' % (nodetype, self.type)))
def _validate_metadata(self, meta_data):
if not meta_data.get('type') in ['map', 'tosca:map']:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTypeError(what='"%s" defined in policy for '
'metadata' % (meta_data.get('type'))))
for entry_schema, entry_schema_type in meta_data.items():
if isinstance(entry_schema_type, dict) and not \
entry_schema_type.get('type') == 'string':
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTypeError(what='"%s" defined in policy for '
'metadata "%s"'
% (entry_schema_type.get('type'),
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
import org.openecomp.sdc.toscaparser.api.DataEntity;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
// verify one of the specified values is set
if(source == null && sourceRange == null &&
target == null && targetRange == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE129", String.format(
"InvalidTypeAdditionalRequirementsError: Additional requirements for type \"%s\" not met",
- TYPE_URI));
+ TYPE_URI)));
}
// Validate source value is in specified range
if(source != null && sourceRange != null) {
}
}
catch(Exception e) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE130", String.format(
"ValueError: \"%s\" do not meet requirements for type \"%s\"",
- _properties.toString(),SHORTNAME));
+ _properties.toString(),SHORTNAME)));
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidTypeAdditionalRequirementsError
from toscaparser.utils.gettextutils import _
import org.openecomp.sdc.toscaparser.api.utils.validateutils as validateutils
# verify one of the specified values is set
if source is None and source_range is None and \
target is None and target_range is None:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTypeAdditionalRequirementsError(
type=PortSpec.TYPE_URI))
# Validate source value is in specified range
msg = _('"%(value)s" do not meet requirements '
'for type "%(type)s".') \
% {'value': properties, 'type': PortSpec.SHORTNAME}
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(msg))
*/
\ No newline at end of file
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class PropertyDef {
if(schema.get("type") == null) {
//msg = (_('Schema definition of "%(pname)s" must have a "type" '
// 'attribute.') % dict(pname=self.name))
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidSchemaError: Schema definition of \"%s\" must have a \"type\" attribute",name));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE131", String.format(
+ "InvalidSchemaError: Schema definition of \"%s\" must have a \"type\" attribute",name)));
}
_loadRequiredAttrFromSchema();
_loadStatusAttrFromSchema();
// attr,
// value,
// valid_values)
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE132", String.format(
"Schema definition of \"%s\" has \"required\" attribute with an invalid value",
- name));
+ name)));
}
}
}
// attr,
// value,
// valid_values)
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE006", String.format(
"Schema definition of \"%s\" has \"status\" attribute with an invalid value",
- name));
+ name)));
}
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidSchemaError
from toscaparser.common.exception import TOSCAException
from toscaparser.utils.gettextutils import _
except KeyError:
msg = (_('Schema definition of "%(pname)s" must have a "type" '
'attribute.') % dict(pname=self.name))
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidSchemaError(message=msg))
if self.schema:
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
-import org.openecomp.sdc.toscaparser.api.elements.EntityType;
-import org.openecomp.sdc.toscaparser.api.elements.StatefulEntityType;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class RelationshipType extends StatefulEntityType {
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownFieldError: Relationshiptype \"%s\" has unknown field \"%s\"",type,key));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE133", String.format(
+ "UnknownFieldError: Relationshiptype \"%s\" has unknown field \"%s\"",type,key)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import UnknownFieldError
from toscaparser.elements.statefulentitytype import StatefulEntityType
def _validate_keys(self):
for key in self.defs.keys():
if key not in self.SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Relationshiptype "%s"' % self.type,
field=key))
*/
\ No newline at end of file
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
import org.slf4j.Logger;
return key;
}
}
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE007", String.format(
"'The unit \"%s\" is not valid. Valid units are \n%s",
- inputUnit,SCALAR_UNIT_DICT.keySet().toString()));
+ inputUnit,SCALAR_UNIT_DICT.keySet().toString())));
return inputUnit;
}
}
value = matcher.group(1) + " " + scalarUnit;
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a valid scalar-unit",value.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE134", String.format(
+ "ValueError: \"%s\" is not a valid scalar-unit",value.toString())));
}
return value;
}
if(type.equals(SCALAR_UNIT_FREQUENCY)) {
return (new ScalarUnitFrequency(value)).getNumFromScalarUnit(unit);
}
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "TypeError: \"%s\" is not a valid scalar-unit type",type));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE135", String.format(
+ "TypeError: \"%s\" is not a valid scalar-unit type",type)));
return 0.0;
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.utils.gettextutils import _
from toscaparser.utils import validateutils
'"%(valid_units)s".') %
{'unit': input_unit,
'valid_units': sorted(self.SCALAR_UNIT_DICT.keys())})
- ExceptionCollector.appendException(ValueError(msg))
+ ValidationIssueCollector.appendException(ValueError(msg))
def validate_scalar_unit(self):
regex = re.compile('([0-9.]+)\s*(\w+)')
return self.value
except Exception:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a valid scalar-unit.')
% self.value))
return (ScalarUnit_Class(value).
get_num_from_scalar_unit(unit))
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
TypeError(_('"%s" is not a valid scalar-unit type.') % type))
*/
\ No newline at end of file
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
import org.openecomp.sdc.toscaparser.api.UnsupportedType;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
-import org.openecomp.sdc.toscaparser.api.elements.AttributeDef;
-import org.openecomp.sdc.toscaparser.api.elements.EntityType;
-import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
}
else{
defs = null;
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidTypeError: \"%s\" is not a valid type",entityType));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE136", String.format(
+ "InvalidTypeError: \"%s\" is not a valid type",entityType)));
}
}
type = entityType;
Object to = me.getValue();
if(to == null || !(to instanceof LinkedHashMap)) {
String s = to == null ? "null" : to.getClass().getSimpleName();
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "Unexpected type error: property \"%s\" has type \"%s\" (expected dict)",pdname,s));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE137", String.format(
+ "Unexpected type error: property \"%s\" has type \"%s\" (expected dict)",pdname,s)));
continue;
}
LinkedHashMap<String,Object> pdschema = (LinkedHashMap<String,Object>)to;
self.defs = custom_def[entitytype]
else:
self.defs = None
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTypeError(what=entitytype))
self.type = entitytype
package org.openecomp.sdc.toscaparser.api.elements;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.extensions.ExtTools;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE138", String.format(
"UnknownFieldError: Template \"%s\" contains unknown field \"%s\"",
- importDef.toString(),name));
+ importDef.toString(),name)));
}
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE139", String.format(
"InvalidTemplateVersion: version \"%s\" in \"%s\" is not supported\n" +
"Allowed versions: [%s]",
- sVersion,importDef.toString(),allowed));
+ sVersion,importDef.toString(),allowed)));
}
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidTemplateVersion
from toscaparser.common.exception import UnknownFieldError
from toscaparser.extensions.exttools import ExtTools
for name in custom_type:
if name not in self.ALLOWED_TYPE_SECTIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
# UnknownFieldError(what='Template ' + (self.import_def),
UnknownFieldError(what= (self.import_def),
field=name))
def _validate_type_version(self, version):
if version not in self.VALID_TEMPLATE_VERSIONS:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTemplateVersion(
# what=version + ' in ' + self.import_def,
what=self.import_def,
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.openecomp.sdc.toscaparser.api.elements.ScalarUnit;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
if(!(constraint instanceof LinkedHashMap) ||
((LinkedHashMap<String,Object>)constraint).size() != 1) {
- ThreadLocalsHolder.getCollector().appendException(
- "InvalidSchemaError: Invalid constraint schema " + constraint.toString());
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE101",
+ "InvalidSchemaError: Invalid constraint schema " + constraint.toString()));
}
if(constraintClass.equals(EQUAL)) {
return new Pattern(propname,proptype,constraint);
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidSchemaError: Invalid property \"%s\"",constraintClass));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE102", String.format(
+ "InvalidSchemaError: Invalid property \"%s\"",constraintClass)));
return null;
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE103", String.format(
"InvalidSchemaError: Property \"%s\" is not valid for data type \"%s\"",
- constraintKey,propertyType));
+ constraintKey,propertyType)));
}
}
value = ScalarUnit.getScalarunitValue(propertyType,value,null);
}
if(!_isValid(value)) {
- ThreadLocalsHolder.getCollector().appendWarning("ValidationError: " + _errMsg(value));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE008", "ValidationError: " + _errMsg(value)));
}
}
if(not isinstance(constraint, collections.Mapping) or
len(constraint) != 1):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidSchemaError(message=_('Invalid constraint schema.')))
for type in constraint.keys():
ConstraintClass = get_constraint_class(type)
if not ConstraintClass:
msg = _('Invalid property "%s".') % type
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidSchemaError(message=msg))
return ConstraintClass(property_name, property_type, constraint)
'"%(dtype)s".') % dict(
ctype=self.constraint_key,
dtype=property_type)
- ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+ ValidationIssueCollector.appendException(InvalidSchemaError(message=msg))
def _get_scalarunit_constraint_value(self):
if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
value = scalarunit.get_scalarunit_value(self.property_type, value)
if not self._is_valid(value):
err_msg = self._err_msg(value)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=err_msg))
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.functions.Function;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"greater_or_equal\" expects comparable values");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE104", "InvalidSchemaError: The property \"greater_or_equal\" expects comparable values"));
}
}
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class GreaterThan extends Constraint {
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"greater_than\" expects comparable values");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE105", "InvalidSchemaError: The property \"greater_than\" expects comparable values"));
}
}
super(GreaterThan, self).__init__(property_name, property_type,
constraint)
if not isinstance(constraint[self.GREATER_THAN], self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "greater_than" '
'expects comparable values.')))
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
super(name,type,c);
if(!(constraintValue instanceof ArrayList) || ((ArrayList<Object>)constraintValue).size() != 2) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"in_range\" expects a list");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE106", "InvalidSchemaError: The property \"in_range\" expects a list"));
}
String msg = "The property \"in_range\" expects comparable values";
for(Object vo: alcv) {
if(!validTypes.contains(vo.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: " + msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE107", "InvalidSchemaError: " + msg));
}
// The only string we allow for range is the special value 'UNBOUNDED'
if((vo instanceof String) && !((String)vo).equals(UNBOUNDED)) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: " + msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE108", "InvalidSchemaError: " + msg));
}
}
min = alcv.get(0);
super(InRange, self).__init__(property_name, property_type, constraint)
if(not isinstance(self.constraint_value, collections.Sequence) or
(len(constraint[self.IN_RANGE]) != 2)):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidSchemaError(message=_('The property "in_range" '
'expects a list.')))
msg = _('The property "in_range" expects comparable values.')
for value in self.constraint_value:
if not isinstance(value, self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidSchemaError(message=msg))
# The only string we allow for range is the special value
# 'UNBOUNDED'
if(isinstance(value, str) and value != self.UNBOUNDED):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidSchemaError(message=msg))
self.min = self.constraint_value[0]
package org.openecomp.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Length extends Constraint {
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"length\" expects an integer");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE109", "InvalidSchemaError: The property \"length\" expects an integer"));
}
}
def __init__(self, property_name, property_type, constraint):
super(Length, self).__init__(property_name, property_type, constraint)
if not isinstance(self.constraint_value, self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "length" expects '
'an integer.')))
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class LessOrEqual extends Constraint {
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"less_or_equal\" expects comparable values");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE110", "InvalidSchemaError: The property \"less_or_equal\" expects comparable values"));
}
}
super(LessOrEqual, self).__init__(property_name, property_type,
constraint)
if not isinstance(self.constraint_value, self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "less_or_equal" '
'expects comparable values.')))
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class LessThan extends Constraint {
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"less_than\" expects comparable values");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE111", "InvalidSchemaError: The property \"less_than\" expects comparable values"));
}
}
super(LessThan, self).__init__(property_name, property_type,
constraint)
if not isinstance(self.constraint_value, self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "less_than" '
'expects comparable values.')))
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class MaxLength extends Constraint {
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"max_length\" expects an integer");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE112", "InvalidSchemaError: The property \"max_length\" expects an integer"));
}
}
super(MaxLength, self).__init__(property_name, property_type,
constraint)
if not isinstance(self.constraint_value, self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "max_length" '
'expects an integer.')))
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class MinLength extends Constraint {
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"min_length\" expects an integer");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE113", "InvalidSchemaError: The property \"min_length\" expects an integer"));
}
}
super(MinLength, self).__init__(property_name, property_type,
constraint)
if not isinstance(self.constraint_value, self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "min_length" '
'expects an integer.')))
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.regex.Matcher;
import java.util.regex.PatternSyntaxException;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Pattern extends Constraint {
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendException("InvalidSchemaError: The property \"pattern\" expects a string");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE114", "InvalidSchemaError: The property \"pattern\" expects a string"));
}
}
protected boolean _isValid(Object value) {
try {
if(!(value instanceof String)) {
- ThreadLocalsHolder.getCollector().appendException(String.format("ValueError: Input value \"%s\" to \"pattern\" property \"%s\" must be a string",
- value.toString(),propertyName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE115", String.format("ValueError: Input value \"%s\" to \"pattern\" property \"%s\" must be a string",
+ value.toString(),propertyName)));
return false;
}
String strp = constraintValue.toString();
return false;
}
catch(PatternSyntaxException pse) {
- ThreadLocalsHolder.getCollector().appendException(String.format("ValueError: Invalid regex \"%s\" in \"pattern\" property \"%s\"",
- constraintValue.toString(),propertyName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE116", String.format("ValueError: Invalid regex \"%s\" in \"pattern\" property \"%s\"",
+ constraintValue.toString(),propertyName)));
return false;
}
}
def __init__(self, property_name, property_type, constraint):
super(Pattern, self).__init__(property_name, property_type, constraint)
if not isinstance(self.constraint_value, self.valid_types):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "pattern" '
'expects a string.')))
self.match = re.compile(self.constraint_value).match
package org.openecomp.sdc.toscaparser.api.elements.constraints;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
if(!(_schemaDict instanceof LinkedHashMap)) {
//msg = (_('Schema definition of "%(pname)s" must be a dict.')
// % dict(pname=name))
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidSchemaError: Schema definition of \"%s\" must be a dict",name));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE117", String.format(
+ "InvalidSchemaError: Schema definition of \"%s\" must be a dict",name)));
}
if(_schemaDict.get("type") == null) {
//msg = (_('Schema definition of "%(pname)s" must have a "type" '
// 'attribute.') % dict(pname=name))
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "InvalidSchemaError: Schema definition of \"%s\" must have a \"type\" attribute",name));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE118", String.format(
+ "InvalidSchemaError: Schema definition of \"%s\" must have a \"type\" attribute",name)));
}
schema = _schemaDict;
}
else {
// error
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE119", String.format(
"UnknownFieldError: Constraint type \"%s\" for property \"%s\" is not supported",
- cClass,name));
+ cClass,name)));
}
break;
}
if not isinstance(schema_dict, collections.Mapping):
msg = (_('Schema definition of "%(pname)s" must be a dict.')
% dict(pname=name))
- ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+ ValidationIssueCollector.appendException(InvalidSchemaError(message=msg))
try:
schema_dict['type']
except KeyError:
msg = (_('Schema definition of "%(pname)s" must have a "type" '
'attribute.') % dict(pname=name))
- ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+ ValidationIssueCollector.appendException(InvalidSchemaError(message=msg))
self.schema = schema_dict
self._len = None
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
public class Schema {
super(ValidValues, self).__init__(property_name, property_type,
constraint)
if not isinstance(self.constraint_value, collections.Sequence):
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
InvalidSchemaError(message=_('The property "valid_values" '
'expects a list.')))
package org.openecomp.sdc.toscaparser.api.functions;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Concat extends Function {
@Override
void validate() {
if(args.size() < 1) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE145",
"ValueError: Invalid arguments for function \"concat\". " +
- "Expected at least one argument");
+ "Expected at least one argument"));
}
}
def validate(self):
if len(self.args) < 1:
- ExceptionCollector.appendException(
+ ValidationIsshueCollector.appendException(
ValueError(_('Invalid arguments for function "{0}". Expected '
'at least one arguments.').format(CONCAT)))
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIsshueCollector
from toscaparser.common.exception import UnknownInputError
from toscaparser.dataentity import DataEntity
from toscaparser.elements.constraints import Schema
package org.openecomp.sdc.toscaparser.api.functions;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
@Override
void validate() {
if(args.size() < 2) {
- ThreadLocalsHolder.getCollector().appendException(
- "ValueError: Illegal arguments for function \"get_attribute\". Expected arguments: \"node-template-name\", \"req-or-cap\" (optional), \"property name.\"");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE146",
+ "ValueError: Illegal arguments for function \"get_attribute\". Expected arguments: \"node-template-name\", \"req-or-cap\" (optional), \"property name.\""));
return;
}
else if(args.size() == 2) {
for(Object elem: args.subList(index,args.size())) {
if(valueType.equals("list")) {
if(!(elem instanceof Integer)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE147", String.format(
"ValueError: Illegal arguments for function \"get_attribute\" \"%s\". Expected positive integer argument",
- elem.toString()));
+ elem.toString())));
}
Object ob = attr.getSchema().get("entry_schema");
valueType = (String)
}
}
if(bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: 'Illegal arguments for function \"get_attribute\". Unexpected attribute/index value \"%d\"",
- elem));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE148", String.format(
+ "ValueError: 'Illegal arguments for function \"get_attribute\". Unexpected attribute/index value \"%s\"",
+ elem)));
return;
}
else { // It is a complex type
valueType = (String)prop.getSchema().get("type");
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE149", String.format(
"KeyError: Illegal arguments for function \"get_attribute\". Attribute name \"%s\" not found in \"%\"",
- elem,valueType));
+ elem,valueType)));
}
}
}
if(nodeTpl != null &&
!_attributeExistsInType(nodeTpl.getTypeDefinition()) &&
!nodeTpl.getProperties().keySet().contains(getAttributeName())) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE150", String.format(
"KeyError: Attribute \"%s\" was not found in node template \"%s\"",
- getAttributeName(),nodeTpl.getName()));
+ getAttributeName(),nodeTpl.getName())));
}
return nodeTpl;
}
// Currently this is the only way to tell whether the function
// is used within the outputs section of the TOSCA template.
if(context instanceof ArrayList) {
- ThreadLocalsHolder.getCollector().appendException(
- "ValueError: \"get_attribute: [ HOST, ... ]\" is not allowed in \"outputs\" section of the TOSCA template");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE151",
+ "ValueError: \"get_attribute: [ HOST, ... ]\" is not allowed in \"outputs\" section of the TOSCA template"));
return null;
}
NodeTemplate nodeTpl = _findHostContainingAttribute(SELF);
if(nodeTpl == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE152", String.format(
"ValueError: \"get_attribute: [ HOST, ... ]\" was used in " +
"node template \"%s\" but \"%s\" was not found in " +
- "the relationship chain",((NodeTemplate)context).getName(),HOSTED_ON));
+ "the relationship chain",((NodeTemplate)context).getName(),HOSTED_ON)));
return null;
}
return nodeTpl;
}
if(nodeTemplateName.equals(TARGET)) {
if(!(((EntityTemplate)context).getTypeDefinition() instanceof RelationshipType)) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE153",
"KeyError: \"TARGET\" keyword can only be used in context " +
- " to \"Relationships\" target node");
+ " to \"Relationships\" target node"));
return null;
}
return ((RelationshipTemplate)context).getTarget();
}
if(nodeTemplateName.equals(SOURCE)) {
if(!(((EntityTemplate)context).getTypeDefinition() instanceof RelationshipType)) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE154",
"KeyError: \"SOURCE\" keyword can only be used in context " +
- " to \"Relationships\" source node");
+ " to \"Relationships\" source node"));
return null;
}
return ((RelationshipTemplate)context).getTarget();
return nt;
}
}
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "KeyError: Node template \"%s\" was not found",nodeTemplateName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE155", String.format(
+ "KeyError: Node template \"%s\" was not found",nodeTemplateName)));
return null;
}
attribute = attrs.get(attrName);
}
if(attribute == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE156", String.format(
"KeyError: Attribute \"%s\" was not found in capability \"%s\" of node template \"%s\" referenced from node template \"%s\"",
- attrName,capabilityName,nodeTemplate.getName(),((NodeTemplate)context).getName()));
+ attrName,capabilityName,nodeTemplate.getName(),((NodeTemplate)context).getName())));
}
return attribute;
}
String msg = String.format(
"Requirement/CapabilityAssignment \"%s\" referenced from node template \"%s\" was not found in node template \"%s\"",
capabilityName,((NodeTemplate)context).getName(),nodeTemplate.getName());
- ThreadLocalsHolder.getCollector().appendException("KeyError: " + msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE157", "KeyError: " + msg));
return null;
}
def validate(self):
if len(self.args) < 2:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Illegal arguments for function "{0}". Expected '
'arguments: "node-template-name", "req-or-cap"'
'(optional), "property name"'
for elem in self.args[index:]:
if value_type == "list":
if not isinstance(elem, int):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Illegal arguments for function'
' "{0}". "{1}" Expected positive'
' integer argument'
elif value_type == "map":
value_type = attr.schema['entry_schema']['type']
elif value_type in Schema.PROPERTY_TYPES:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Illegal arguments for function'
' "{0}". Unexpected attribute/'
'index value "{1}"'
prop = found[0]
value_type = prop.schema['type']
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('Illegal arguments for function'
' "{0}". Attribute name "{1}" not'
' found in "{2}"'
if node_tpl and \
not self._attribute_exists_in_type(node_tpl.type_definition) \
and self.attribute_name not in node_tpl.get_properties():
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('Attribute "%(att)s" was not found in node '
'template "%(ntpl)s".') %
{'att': self.attribute_name,
# Currently this is the only way to tell whether the function
# is used within the outputs section of the TOSCA template.
if isinstance(self.context, list):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_(
'"get_attribute: [ HOST, ... ]" is not allowed in '
'"outputs" section of the TOSCA template.')))
return
node_tpl = self._find_host_containing_attribute()
if not node_tpl:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_(
'"get_attribute: [ HOST, ... ]" was used in node '
'template "{0}" but "{1}" was not found in '
return node_tpl
if node_template_name == TARGET:
if not isinstance(self.context.type_definition, RelationshipType):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('"TARGET" keyword can only be used in context'
' to "Relationships" target node')))
return
return self.context.target
if node_template_name == SOURCE:
if not isinstance(self.context.type_definition, RelationshipType):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('"SOURCE" keyword can only be used in context'
' to "Relationships" source node')))
return
for node_template in self.tosca_tpl.nodetemplates:
if node_template.name == name:
return node_template
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_(
'Node template "{0}" was not found.'
).format(node_template_name)))
if attrs and attr_name in attrs.keys():
attribute = attrs[attr_name]
if not attribute:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('Attribute "%(attr)s" was not found in '
'capability "%(cap)s" of node template '
'"%(ntpl1)s" referenced from node template '
capability_name,
self.context.name,
node_template.name)
- ExceptionCollector.appendException(KeyError(msg))
+ ValidationIssueCollector.appendException(KeyError(msg))
@property
def node_template_name(self):
import org.openecomp.sdc.toscaparser.api.DataEntity;
import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.openecomp.sdc.toscaparser.api.parameters.Input;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
// args.toString()));
// }
if(args.size() > 2) {
- ThreadLocalsHolder.getCollector().appendWarning(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE009", String.format(
"ValueError: Expected max 2 arguments for function \"get_input\" but received \"%s\"",
- args.size()));
+ args.size())));
}
boolean bFound = false;
for(Input inp: toscaTpl.getInputs()) {
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "UnknownInputError: Unknown input \"%s\"",args.get(0)));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE158", String.format(
+ "UnknownInputError: Unknown input \"%s\"",args.get(0))));
}
}
def validate(self):
if len(self.args) != 1:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_(
'Expected one argument for function "get_input" but '
'received "%s".') % self.args))
inputs = [input.name for input in self.tosca_tpl.inputs]
if self.args[0] not in inputs:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownInputError(input_name=self.args[0]))
def result(self):
package org.openecomp.sdc.toscaparser.api.functions;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import org.openecomp.sdc.toscaparser.api.*;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.elements.InterfacesDef;
import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
import org.openecomp.sdc.toscaparser.api.elements.StatefulEntityType;
_findOperationName(interfaceName,(String)args.get(2));
}
else {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE159",
"ValueError: Illegal arguments for function \"get_operation_output\". " +
"Expected arguments: \"template_name\",\"interface_name\"," +
- "\"operation_name\",\"output_variable_name\"");
+ "\"operation_name\",\"output_variable_name\""));
}
}
return _interfaceName;
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE160", String.format(
"ValueError: invalid interface name \"%s\" in \"get_operation_output\"",
- _interfaceName));
+ _interfaceName)));
return null;
}
}
return operationName;
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE161", String.format(
"ValueError: Invalid operation of Configure interface \"%s\" in \"get_operation_output\"",
- operationName));
+ operationName)));
return null;
}
}
return operationName;
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE162", String.format(
"ValueError: Invalid operation of Configure interface \"%s\" in \"get_operation_output\"",
- operationName));
+ operationName)));
return null;
}
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE163", String.format(
"ValueError: Invalid interface name \"%s\" in \"get_operation_output\"",
- interfaceName));
+ interfaceName)));
return null;
}
}
private NodeTemplate _findNodeTemplate(String nodeTemplateName) {
if(nodeTemplateName.equals(TARGET)) {
if(!(((EntityTemplate)context).getTypeDefinition() instanceof RelationshipType)) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE164",
"KeyError: \"TARGET\" keyword can only be used in context " +
- " to \"Relationships\" target node");
+ " to \"Relationships\" target node"));
return null;
}
return ((RelationshipTemplate)context).getTarget();
}
if(nodeTemplateName.equals(SOURCE)) {
if(!(((EntityTemplate)context).getTypeDefinition() instanceof RelationshipType)) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE165",
"KeyError: \"SOURCE\" keyword can only be used in context " +
- " to \"Relationships\" source node");
+ " to \"Relationships\" source node"));
return null;
}
return ((RelationshipTemplate)context).getTarget();
return nt;
}
}
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "KeyError: Node template \"%s\" was not found",nodeTemplateName));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE166", String.format(
+ "KeyError: Node template \"%s\" was not found",nodeTemplateName)));
return null;
}
interface_name = self._find_interface_name(self.args[1])
self._find_operation_name(interface_name, self.args[2])
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Illegal arguments for function "{0}". Expected '
'arguments: "template_name","interface_name",'
'"operation_name","output_variable_name"'
if interface_name in toscaparser.elements.interfaces.SECTIONS:
return interface_name
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Enter a valid interface name'
).format(GET_OPERATION_OUTPUT)))
return
interfaces_relationship_configure_operations):
return operation_name
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Enter an operation of Configure interface'
).format(GET_OPERATION_OUTPUT)))
return
StatefulEntityType.interfaces_node_lifecycle_operations):
return operation_name
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Enter an operation of Standard interface'
).format(GET_OPERATION_OUTPUT)))
return
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Enter a valid operation name'
).format(GET_OPERATION_OUTPUT)))
return
def _find_node_template(self, node_template_name):
if node_template_name == TARGET:
if not isinstance(self.context.type_definition, RelationshipType):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('"TARGET" keyword can only be used in context'
' to "Relationships" target node')))
return
return self.context.target
if node_template_name == SOURCE:
if not isinstance(self.context.type_definition, RelationshipType):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('"SOURCE" keyword can only be used in context'
' to "Relationships" source node')))
return
for node_template in self.tosca_tpl.nodetemplates:
if node_template.name == name:
return node_template
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_(
'Node template "{0}" was not found.'
).format(node_template_name)))
package org.openecomp.sdc.toscaparser.api.functions;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.LinkedHashMap;
@Override
void validate() {
if(args.size() < 2) {
- ThreadLocalsHolder.getCollector().appendException(
- "ValueError: Illegal arguments for function \"get_property\". Expected arguments: \"node-template-name\", \"req-or-cap\" (optional), \"property name.\"");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE167",
+ "ValueError: Illegal arguments for function \"get_property\". Expected arguments: \"node-template-name\", \"req-or-cap\" (optional), \"property name.\""));
return;
}
if(args.size() == 2) {
property = ((Property)props.get(propertyName)).getValue();
}
if(property == null && throwErrors) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE168", String.format(
"KeyError: Property \"%s\" was not found in capability \"%s\" of node template \"%s\" referenced from node template \"%s\"",
- propertyName,capabilityName,nodeTemplate.getName(),((NodeTemplate)context).getName()));
+ propertyName,capabilityName,nodeTemplate.getName(),((NodeTemplate)context).getName())));
}
return property;
}
if(throwErrors) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE169", String.format(
"KeyError: Requirement/CapabilityAssignment \"%s\" referenced from node template \"%s\" was not found in node template \"%s\"",
- capabilityName,((NodeTemplate)context).getName(),nodeTemplate.getName()));
+ capabilityName,((NodeTemplate)context).getName(),nodeTemplate.getName())));
}
return null;
LinkedHashMap<String,Property> props = nodeTpl.getProperties();
Property found = props.get(propertyName);
if(found == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE170", String.format(
"KeyError: Property \"%s\" was not found in node template \"%s\"",
- propertyName,nodeTpl.getName()));
+ propertyName,nodeTpl.getName())));
}
return found;
}
if(nodeTemplateName.equals(HOST)) {
NodeTemplate node = _findHostContainingProperty(null);
if(node == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE171", String.format(
"KeyError: Property \"%s\" was not found in capability \"%s\" of node template \"%s\" referenced from node template \"%s\"",
- (String)args.get(2),(String)args.get(1),((NodeTemplate)context).getName()));
+ (String)args.get(2),(String)args.get(1),((NodeTemplate)context).getName())));
return null;
}
return node;
}
if(nodeTemplateName.equals(TARGET)) {
if(!(((RelationshipTemplate)context).getTypeDefinition() instanceof RelationshipType)) {
- ThreadLocalsHolder.getCollector().appendException(
- "KeyError: \"TARGET\" keyword can only be used in context to \"Relationships\" target node");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE172",
+ "KeyError: \"TARGET\" keyword can only be used in context to \"Relationships\" target node"));
return null;
}
return ((RelationshipTemplate)context).getTarget();
}
if(nodeTemplateName.equals(SOURCE)) {
if(!(((RelationshipTemplate)context).getTypeDefinition() instanceof RelationshipType)) {
- ThreadLocalsHolder.getCollector().appendException(
- "KeyError: \"SOURCE\" keyword can only be used in context to \"Relationships\" target node");
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE173",
+ "KeyError: \"SOURCE\" keyword can only be used in context to \"Relationships\" target node"));
return null;
}
return ((RelationshipTemplate)context).getSource();
return nodeTemplate;
}
}
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE174", String.format(
"KeyError: Node template \"%s\" was not found. Referenced from Node Template \"%s\"",
- nodeTemplateName,((NodeTemplate)context).getName()));
+ nodeTemplateName,((NodeTemplate)context).getName())));
return null;
}
return ((ArrayList)value).get(index);
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE175", String.format(
"KeyError: Property \"%s\" found in capability \"%s\" referenced from node template \"%s\" must have an element with index %d",
- args.get(2),args.get(1),((NodeTemplate)context).getName(),index));
+ args.get(2),args.get(1),((NodeTemplate)context).getName(),index)));
}
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE176", String.format(
"KeyError: Property \"%s\" found in capability \"%s\" referenced from node template \"%s\" must be a list",
- args.get(2),args.get(1),((NodeTemplate)context).getName()));
+ args.get(2),args.get(1),((NodeTemplate)context).getName())));
}
return null;
}
return ov;
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE177", String.format(
"KeyError: Property \"%s\" found in capability \"%s\" referenced from node template \"%s\" must have an attribute named \"%s\"",
- args.get(2),args.get(1),((NodeTemplate)context).getName(),attribute));
+ args.get(2),args.get(1),((NodeTemplate)context).getName(),attribute)));
}
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE178", String.format(
"KeyError: Property \"%s\" found in capability \"%s\" referenced from node template \"%s\" must be a dict",
- args.get(2),args.get(1),((NodeTemplate)context).getName()));
+ args.get(2),args.get(1),((NodeTemplate)context).getName())));
}
return null;
}
def validate(self):
if len(self.args) < 2:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_(
'Expected arguments: "node-template-name", "req-or-cap" '
'(optional), "property name".')))
if props and property_name in props.keys():
property = props[property_name].value
if not property:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('Property "%(prop)s" was not found in '
'capability "%(cap)s" of node template '
'"%(ntpl1)s" referenced from node template '
capability_name,
self.context.name,
node_template.name)
- ExceptionCollector.appendException(KeyError(msg))
+ ValidationIssueCollector.appendException(KeyError(msg))
def _find_property(self, property_name):
node_tpl = self._find_node_template(self.args[0])
props = node_tpl.get_properties()
found = [props[property_name]] if property_name in props else []
if len(found) == 0:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('Property "%(prop)s" was not found in node '
'template "%(ntpl)s".') %
{'prop': property_name,
return self._find_host_containing_property()
if node_template_name == TARGET:
if not isinstance(self.context.type_definition, RelationshipType):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('"TARGET" keyword can only be used in context'
' to "Relationships" target node')))
return
return self.context.target
if node_template_name == SOURCE:
if not isinstance(self.context.type_definition, RelationshipType):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_('"SOURCE" keyword can only be used in context'
' to "Relationships" source node')))
return
for node_template in self.tosca_tpl.nodetemplates:
if node_template.name == node_template_name:
return node_template
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_(
'Node template "{0}" was not found.'
).format(node_template_name)))
if index < len(value):
return value[index]
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_(
"Property '{0}' found in capability '{1}'"
" referenced from node template {2}"
self.context.name,
index)))
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_(
"Property '{0}' found in capability '{1}'"
" referenced from node template {2}"
if attibute in value:
return value[attibute]
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_(
"Property '{0}' found in capability '{1}'"
" referenced from node template {2}"
self.context.name,
attibute)))
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
KeyError(_(
"Property '{0}' found in capability '{1}'"
" referenced from node template {2}"
package org.openecomp.sdc.toscaparser.api.functions;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.NodeTemplate;
import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Token extends Function {
@Override
void validate() {
if(args.size() < 3) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE180",
"ValueError: Invalid arguments for function \"token\". " +
- "Expected at least three arguments");
+ "Expected at least three arguments"));
}
else {
if(!(args.get(1) instanceof String) ||
((String)args.get(1)).length() != 1) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE181",
"ValueError: Invalid arguments for function \"token\". " +
- "Expected single char value as second argument");
+ "Expected single char value as second argument"));
}
if(!(args.get(2) instanceof Integer)) {
- ThreadLocalsHolder.getCollector().appendException(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE182",
"ValueError: Invalid arguments for function \"token\"" +
- "Expected integer value as third argument");
+ "Expected integer value as third argument"));
}
}
}
def validate(self):
if len(self.args) < 3:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Invalid arguments for function "{0}". Expected '
'at least three arguments.').format(TOKEN)))
else:
if not isinstance(self.args[1], str) or len(self.args[1]) != 1:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Invalid arguments for function "{0}". '
'Expected single char value as second '
'argument.').format(TOKEN)))
if not isinstance(self.args[2], int):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Invalid arguments for function "{0}". '
'Expected integer value as third '
'argument.').format(TOKEN)))
package org.openecomp.sdc.toscaparser.api.parameters;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import org.openecomp.sdc.toscaparser.api.DataEntity;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.elements.EntityType;
import org.openecomp.sdc.toscaparser.api.elements.constraints.Constraint;
import org.openecomp.sdc.toscaparser.api.elements.constraints.Schema;
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE214", String.format(
"UnknownFieldError: Input \"%s\" contains unknown field \"%s\"",
- name,key));
+ name,key)));
}
}
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: Invalid type \"%s\"",inputType));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE215", String.format(
+ "ValueError: Invalid type \"%s\"",inputType)));
}
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import MissingRequiredFieldError
from toscaparser.common.exception import UnknownFieldError
from toscaparser.dataentity import DataEntity
def _validate_field(self):
for name in self.schema.schema:
if name not in self.INPUTFIELD:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Input "%s"' % self.name,
field=name))
def validate_type(self, input_type):
if input_type not in Schema.PROPERTY_TYPES:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Invalid type "%s".') % type))
# tODO(anyone) Need to test for any built-in datatype not just network
package org.openecomp.sdc.toscaparser.api.parameters;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Output {
private void _validateField() {
if(!(attrs instanceof LinkedHashMap)) {
//TODO wrong error message...
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE216", String.format(
"ValidationError: Output \"%s\" has wrong type. Expecting a dict",
- name));
+ name)));
}
if(getValue() == null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE217", String.format(
"MissingRequiredFieldError: Output \"%s\" is missing required \"%s\"",
- name,VALUE));
+ name,VALUE)));
}
for(String key: attrs.keySet()) {
boolean bFound = false;
}
}
if(!bFound) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE218", String.format(
"UnknownFieldError: Output \"%s\" contains unknown field \"%s\"",
- name,key));
+ name,key)));
}
}
}
def _validate_field(self):
if not isinstance(self.attrs, dict):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(what='Output "%s"' % self.name,
required=self.VALUE))
if self.value is None:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
MissingRequiredFieldError(what='Output "%s"' % self.name,
required=self.VALUE))
for name in self.attrs:
if name not in self.OUTPUTFIELD:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
UnknownFieldError(what='Output "%s"' % self.name,
field=name))
*/
package org.openecomp.sdc.toscaparser.api.prereq;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
if(isFile) {
File f = new File(path);
if (!f.isFile()) {
- ThreadLocalsHolder.getCollector().appendException(String.format("\"%s\" is not a file", path));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE220", String.format("\"%s\" is not a file", path)));
return false;
}
else {
}
else {
if(!UrlUtils.validateUrl(path)) {
- ThreadLocalsHolder.getCollector().appendException(String.format("ImportError: \"%s\" does not exist",path));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE221", String.format("ImportError: \"%s\" does not exist",path)));
return false;
}
// get it to a local file
Files.copy(in,ptf,StandardCopyOption.REPLACE_EXISTING);
}
catch(Exception e) {
- ThreadLocalsHolder.getCollector().appendException("ImportError: failed to load CSAR from " + path);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE222", "ImportError: failed to load CSAR from " + path));
return false;
}
//ThreadLocalsHolder.getCollector().appendCriticalException(e.getMessage());
throw e;
} catch (Exception e) {
- ThreadLocalsHolder.getCollector().appendException("ValidationError: " + e.getMessage());
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE223", "ValidationError: " + e.getMessage()));
errorCaught = true;
}
return (LinkedHashMap<String,Object>)data;
}
catch(Exception e) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE224", String.format(
"The file \"%s\" in the CSAR \"%s\" does not " +
"contain valid TOSCA YAML content",
- mainTemplate,csar));
+ mainTemplate,csar)));
}
}
return null;
}
}
else {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE225", String.format(
"ValueError: Unexpected artifact definition for \"%s\"",
- artifactKey));
+ artifactKey)));
errorCaught = true;
}
}
return;
}
else {
- ThreadLocalsHolder.getCollector().appendException(msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE226", msg));
errorCaught = true;
}
}
catch (Exception e) {
- ThreadLocalsHolder.getCollector().appendException(msg);
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE227", msg));
}
}
}
if(raiseExc) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: The resource \"%s\" does not exist",resourceFile));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE228", String.format(
+ "ValueError: The resource \"%s\" does not exist",resourceFile)));
}
errorCaught = true;
}
/*python
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import URLException
from toscaparser.common.exception import ValidationError
from toscaparser.imports import ImportsLoader
missing_err_msg = (_('"%s" does not exist.') % self.path)
if self.a_file:
if not os.path.isfile(self.path):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=missing_err_msg))
return False
else:
self.csar = self.path
else: # a URL
if not UrlUtils.validate_url(self.path):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=missing_err_msg))
return False
else:
# validate that it is a valid zip file
if not zipfile.is_zipfile(self.csar):
err_msg = (_('"%s" is not a valid zip file.') % self.path)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=err_msg))
return False
err_msg = (_('"%s" is not a valid CSAR as it does not contain the '
'required file "TOSCA.meta" in the folder '
'"TOSCA-Metadata".') % self.path)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=err_msg))
return False
if type(meta) is dict:
self.metadata = meta
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=invalid_yaml_err_msg))
return False
except yaml.YAMLError:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=invalid_yaml_err_msg))
return False
'"Entry-Definitions" in '
'"TOSCA-Metadata/TOSCA.meta".')
% self.path)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=err_msg))
return False
if entry and entry not in filelist:
err_msg = (_('The "Entry-Definitions" file defined in the '
'CSAR "%s" does not exist.') % self.path)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=err_msg))
return False
try:
tosca_yaml = yaml.load(data)
if type(tosca_yaml) is not dict:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=invalid_tosca_yaml_err_msg))
return tosca_yaml
except Exception:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValidationError(message=invalid_tosca_yaml_err_msg))
def get_description(self):
main_tpl_file,
artifact['file'])
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('Unexpected artifact '
'definition for "%s".')
% artifact_key))
if UrlUtils.url_accessible(resource_file):
return
else:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
URLException(what=msg))
self.error_caught = True
except Exception:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
URLException(what=msg))
self.error_caught = True
return
if raise_exc:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('The resource "%s" does not exist.')
% resource_file))
self.error_caught = True
import java.util.zip.ZipInputStream;
import org.openecomp.sdc.toscaparser.api.ImportsLoader;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
import org.openecomp.sdc.toscaparser.api.elements.Metadata;
import org.openecomp.sdc.toscaparser.api.utils.UrlUtils;
import org.slf4j.Logger;
public enum JToscaErrorCodes {
- MISSING_META_FILE("JT1001"),
- INVALID_META_YAML_CONTENT("JT1002"),
- ENTRY_DEFINITION_NOT_DEFINED("JT1003"),
- MISSING_ENTRY_DEFINITION_FILE ("JT1004"),
- GENERAL_ERROR("JT1005"),
- PATH_NOT_VALID("JT1006"),
- CSAR_TOSCA_VALIDATION_ERROR("JT1007"),
- INVALID_CSAR_FORMAT("JT1008");
+ MISSING_META_FILE("JE1001"),
+ INVALID_META_YAML_CONTENT("JE1002"),
+ ENTRY_DEFINITION_NOT_DEFINED("JE1003"),
+ MISSING_ENTRY_DEFINITION_FILE ("JE1004"),
+ GENERAL_ERROR("JE1005"),
+ PATH_NOT_VALID("JE1006"),
+ CSAR_TOSCA_VALIDATION_ERROR("JE1007"),
+ INVALID_CSAR_FORMAT("JE1008");
private String value;
package org.openecomp.sdc.toscaparser.api.utils;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
-
public class TOSCAVersionProperty {// test with functions/test_concat.yaml
private String version;
Pattern pattern = Pattern.compile(versionRe);
Matcher matcher = pattern.matcher(version);
if(!matcher.find()) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE252", String.format(
"InvalidTOSCAVersionPropertyException: " +
"Value of TOSCA version property \"%s\" is invalid",
- version));
+ version)));
return;
}
minorVersion = matcher.group("gMinorVersion");
if((fixVersion == null && value != null) ||
(minorVersion.equals("0") && majorVersion.equals("0") &&
fixVersion.equals("0") && value != null)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE253", String.format(
"InvalidTOSCAVersionPropertyException: " +
"Value of TOSCA version property \"%s\" is invalid",
- version));
+ version)));
}
return value;
}
// Eg: version = 18.0.0-1 is invalid.
if(qualifier == null && value != null) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE254", String.format(
"InvalidTOSCAVersionPropertyException: " +
"Value of TOSCA version property \"%s\" is invalid",
- version));
+ version)));
}
return value;
}
self.version = str(version)
match = self.VERSION_RE.match(self.version)
if not match:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTOSCAVersionPropertyException(what=(self.version)))
return
ver = match.groupdict()
if (self.fix_version is None and value) or \
(self.minor_version == self.major_version ==
self.fix_version == '0' and value):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTOSCAVersionPropertyException(what=(self.version)))
return value
Eg: version = 18.0.0-1 is invalid.
"""
if not self.qualifier and value:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
InvalidTOSCAVersionPropertyException(what=(self.version)))
return value
package org.openecomp.sdc.toscaparser.api.utils;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
+import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
public class ThreadLocalsHolder {
- private static final ThreadLocal<ExceptionCollector> exceptionCollectorThreadLocal = new ThreadLocal<>();
+ private static final ThreadLocal<ValidationIssueCollector> exceptionCollectorThreadLocal = new ThreadLocal<>();
private ThreadLocalsHolder(){}
- public static ExceptionCollector getCollector() {
+ public static ValidationIssueCollector getCollector() {
return exceptionCollectorThreadLocal.get();
}
- public static void setCollector(ExceptionCollector exceptionCollector) {
+ public static void setCollector(ValidationIssueCollector validationIssueCollector) {
cleanup();
- exceptionCollectorThreadLocal.set(exceptionCollector);
+ exceptionCollectorThreadLocal.set(validationIssueCollector);
}
public static void cleanup(){
package org.openecomp.sdc.toscaparser.api.utils;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
-
public class UrlUtils {
public static boolean validateUrl(String sUrl) {
// relative_path: heat-translator
// - joined: http://www.githib.com/openstack/heat-translator
if(!validateUrl(sUrl)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: The URL \"%s\" is malformed",sUrl));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE255", String.format(
+ "ValueError: The URL \"%s\" is malformed",sUrl)));
}
try {
URL base = new URL(sUrl);
return (new URL(base,relativePath)).toString();
}
catch(MalformedURLException e) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: Joining URL \"%s\" and relative path \"%s\" caused an exception",sUrl,relativePath));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE256", String.format(
+ "ValueError: Joining URL \"%s\" and relative path \"%s\" caused an exception",sUrl,relativePath)));
return sUrl;
}
}
from six.moves.urllib.parse import urljoin
from six.moves.urllib.parse import urlparse
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.utils.gettextutils import _
try:
- joined: http://www.githib.com/openstack/heat-translator
"""
if not UrlUtils.validate_url(url):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a valid URL.') % url))
return urljoin(url, relative_path)
package org.openecomp.sdc.toscaparser.api.utils;
+import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
-
public class ValidateUtils {
private static final String RANGE_UNBOUNDED = "UNBOUNDED";
public static Object validateNumeric(Object value) {
if(value != null) {
if (!(value instanceof Number)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a numeric", value.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE257", String.format(
+ "ValueError: \"%s\" is not a numeric",value.toString())));
}
}
return value;
if (value instanceof Boolean) {
return (Boolean) value ? 1 : 0;
}
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not an integer", value.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE258", String.format(
+ "ValueError: \"%s\" is not an integer",value.toString())));
}
}
return value;
public static Object validateFloat(Object value) {
if(value != null) {
if (!(value instanceof Float || value instanceof Double)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a float", value.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE259", String.format(
+ "ValueError: \"%s\" is not a float",value.toString())));
}
}
return value;
public static Object validateString(Object value) {
if(value != null) {
if (!(value instanceof String)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \'%s\' is not a string", value.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE260", String.format(
+ "ValueError: \'%s\' is not a string",value.toString())));
}
}
return value;
public static Object validateList(Object value) {
if(value != null) {
if (!(value instanceof ArrayList)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a list", value.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE261", String.format(
+ "ValueError: \"%s\" is not a list",value.toString())));
}
}
return value;
validateList(range);
// validate range list has a min and max
if(range instanceof ArrayList && ((ArrayList<Object>)range).size() != 2) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a valid range",range.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE262", String.format(
+ "ValueError: \"%s\" is not a valid range",range.toString())));
// too dangerous to continue...
return range;
}
if(!(r0 instanceof Integer) && !(r0 instanceof Float) ||
!(r1 instanceof Integer) && !(r1 instanceof Float)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a valid range",range.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE263", String.format(
+ "ValueError: \"%s\" is not a valid range",range.toString())));
// too dangerous to continue...
return range;
}
if(!minTest && !maxTest) {
// Note: min == max is allowed
if(min > max) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError:\"%s\" is not a valid range",range.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE264", String.format(
+ "ValueError:\"%s\" is not a valid range",range.toString())));
}
}
return range;
public static Object validateValueInRange(Object value,Object range,String propName) {
// verify all 3 are numeric and convert to Floats
if(!(value instanceof Integer || value instanceof Float)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: validateInRange: \"%s\" is not a number",range.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE265", String.format(
+ "ValueError: validateInRange: \"%s\" is not a number",range.toString())));
return value;
}
Float fval = value instanceof Integer ? ((Integer)value).floatValue() : (Float)value;
// better safe than sorry...
// validate that range list has a min and max
if(range instanceof ArrayList && ((ArrayList<Object>)range).size() != 2) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a valid range",range.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE266", String.format(
+ "ValueError: \"%s\" is not a valid range",range.toString())));
// too dangerous to continue...
return value;
}
if(!(r0 instanceof Integer) && !(r0 instanceof Float) ||
!(r1 instanceof Integer) && !(r1 instanceof Float)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a valid range",range.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE267", String.format(
+ "ValueError: \"%s\" is not a valid range",range.toString())));
// too dangerous to continue...
return value;
}
if(!minTest && !maxTest) {
// Note: min == max is allowed
if(min > max) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError:\"%s\" is not a valid range",range.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE268", String.format(
+ "ValueError:\"%s\" is not a valid range",range.toString())));
}
}
// finally...
}
}
if(bError) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE269", String.format(
"RangeValueError: Property \"%s\", \"%s\" not in range [\"%s\" - \"%s\"",
- propName,value.toString(),r0.toString(),r1.toString()));
+ propName,value.toString(),r0.toString(),r1.toString())));
}
return value;
}
public static Object validateMap(Object ob) {
if(ob != null) {
if (!(ob instanceof LinkedHashMap)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError\"%s\" is not a map.", ob.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE270", String.format(
+ "ValueError\"%s\" is not a map.",ob.toString())));
}
}
return ob;
return normalized.equals("true");
}
}
- ThreadLocalsHolder.getCollector().appendException(String.format(
- "ValueError: \"%s\" is not a boolean", value.toString()));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE271", String.format(
+ "ValueError: \"%s\" is not a boolean",value.toString())));
}
return value;
}
except Exception as e:
original_err_msg = str(e)
log.error(original_err_msg)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%(val)s" is not a valid timestamp. "%(msg)s"') %
{'val': value, 'msg': original_err_msg}))
*/
// timestamps are loaded as Date objects by the YAML parser
if(value != null) {
if (!(value instanceof Date)) {
- ThreadLocalsHolder.getCollector().appendException(String.format(
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE272", String.format(
"ValueError: \"%s\" is not a valid timestamp",
- value.toString()));
+ value.toString())));
}
}
/*python
from toscaparser.elements import constraints
-from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationIssueCollector
from toscaparser.common.exception import InvalidTOSCAVersionPropertyException
from toscaparser.common.exception import RangeValueError
from toscaparser.utils.gettextutils import _
def validate_numeric(value):
if not isinstance(value, numbers.Number):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a numeric.') % value))
return value
try:
value = int(value)
except Exception:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not an integer.') % value))
return value
def validate_float(value):
if not isinstance(value, float):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a float.') % value))
return value
def validate_string(value):
if not isinstance(value, six.string_types):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a string.') % value))
return value
def validate_list(value):
if not isinstance(value, list):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a list.') % value))
return value
validate_list(range)
# validate range list has a min and max
if len(range) != 2:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a valid range.') % range))
# validate min and max are numerics or the keyword UNBOUNDED
min_test = max_test = False
if not min_test and not max_test:
# Note: min == max is allowed
if min > max:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a valid range.') % range))
return range
# Note: value is valid if equal to min
if range[0] != RANGE_UNBOUNDED:
if value < range[0]:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
RangeValueError(pname=prop_name,
pvalue=value,
vmin=range[0],
# Note: value is valid if equal to max
if range[1] != RANGE_UNBOUNDED:
if value > range[1]:
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
RangeValueError(pname=prop_name,
pvalue=value,
vmin=range[0],
def validate_map(value):
if not isinstance(value, collections.Mapping):
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a map.') % value))
return value
if normalised in ['true', 'false']:
return normalised == 'true'
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%s" is not a boolean.') % value))
except Exception as e:
original_err_msg = str(e)
log.error(original_err_msg)
- ExceptionCollector.appendException(
+ ValidationIssueCollector.appendException(
ValueError(_('"%(val)s" is not a valid timestamp. "%(msg)s"') %
{'val': value, 'msg': original_err_msg}))
return
--- /dev/null
+package org.openecomp.sdc.toscaparser.api;
+
+import com.opencsv.CSVWriter;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Scanner;
+//Generate excel file, include all validation issues errors in jtosca
+//the error java code, the line number and file name for each error.
+public class GetValidationIssues {
+
+ public static CSVWriter fileWriter = null;
+ public static List<String[]> data = new ArrayList<>();
+
+ public static void main(String[] args) {
+ System.out.println("GetAllValidationIssues - path to project files Directory is " + Arrays.toString(args));
+ File jtoscaFiles = new File(args[0]+ "\\jtosca\\src\\main\\java\\org\\openecomp\\sdc\\toscaparser\\api");
+
+ try {
+ printFiles(jtoscaFiles);
+ fileWriter = new CSVWriter(new FileWriter(args[1]+"\\JToscaValidationIssues_"+System.currentTimeMillis()+".csv"), '\t');
+ fileWriter.writeNext(new String[] {"Error Message", "Class Name", "Line No."}, false);
+ fileWriter.writeAll(data, false);
+ } catch (IOException e) {
+ e.printStackTrace();
+ } finally {
+ try {
+ fileWriter.flush();
+ fileWriter.close();
+ } catch (IOException e) {
+ System.out.println("Error while flushing/closing fileWriter !!!");
+ e.printStackTrace();
+ }
+ }
+ }
+
+ private static void printFiles(File dir) {
+ if (dir != null && dir.exists()) {
+ for (File file : dir.listFiles()) {
+ if (file.isDirectory())
+ printFiles(file);
+ else {
+ Scanner scanner = null;
+ try {
+ scanner = new Scanner(file);
+
+ int lineNum = 0;
+ while (scanner.hasNextLine()) {
+ String line = scanner.nextLine();
+ lineNum++;
+ if (line.startsWith("/*python"))
+ break;
+
+ if (!line.trim().startsWith("//") && !line.trim().startsWith("#") && line.contains("ThreadLocalsHolder.getCollector().appendValidationIssue")) {
+ String errMsg = line.trim();
+ if (!errMsg.contains(";")) {
+ String nextLine = null;
+ while (scanner.hasNextLine() && (nextLine == null || !nextLine.contains(";"))) {
+ nextLine = scanner.nextLine();
+ errMsg += nextLine.trim();
+ }
+ }
+
+ data.add(new String[]{errMsg, file.getName(), String.valueOf(lineNum)});
+ }
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+ }
+}
+
Code Review / sdc / sdc-tosca.git / commitdiff