-# OpenECOMP JTOSCA
+# ONAP JTOSCA
---
# Introduction
-OpenECOMP JTOSCA is delivered as helper JAR that can be used by clients that work with TOSCA CSAR files.
+ONAP JTOSCA is delivered as helper JAR that can be used by clients that work with TOSCA CSAR files.
It parses the CSAR and returns the model object which represents the CSAR contents.
Prior to that, it performs validations on the CSAR to check its TOSCA compliance.
-# Compiling OpenECOMP JTOSCA
+# Compiling ONAP JTOSCA
-OpenECOMP JTOSCA can be compiled easily using maven command: `mvn clean install`
+ONAP JTOSCA can be compiled easily using maven command: `mvn clean install`
The result is JAR file under "target" folder
# Getting Help
*** to be completed on release ***
-SDC@lists.openecomp.org
+SDC@lists.onap.org
SDC Javadoc and Maven site
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
- <groupId>org.openecomp.sdc.jtosca</groupId>
+ <groupId>org.onap.sdc.jtosca</groupId>
<artifactId>jtosca</artifactId>
- <version>1.2.2-SNAPSHOT</version>
+ <version>1.3.0</version>
<name>sdc-jtosca</name>
<properties>
<!--<sonar.projectBaseDir>${project.basedir}</sonar.projectBaseDir>-->
<sonar.jacoco.reportPath>${project.basedir}/target/jacoco.exec</sonar.jacoco.reportPath>
<nexus.proxy>https://nexus.onap.org</nexus.proxy>
- <sitePath>/content/sites/site/org/openecomp/sdc/jtosca/${project.version}</sitePath>
+ <sitePath>/content/sites/site/org/onap/sdc/jtosca/${project.version}</sitePath>
<snapshots.path>snapshots</snapshots.path>
<releases.path>releases</releases.path>
<staging.profile.id>176c31dfe190a</staging.profile.id>
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.elements.CapabilityTypeDef;
-import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
+import org.onap.sdc.toscaparser.api.elements.CapabilityTypeDef;
+import org.onap.sdc.toscaparser.api.elements.PropertyDef;
public class CapabilityAssignment {
-package org.openecomp.sdc.toscaparser.api;
-
-import org.openecomp.sdc.toscaparser.api.CapabilityAssignment;
+package org.onap.sdc.toscaparser.api;
import java.util.ArrayList;
import java.util.HashMap;
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
-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;
-import org.openecomp.sdc.toscaparser.api.functions.Function;
-import org.openecomp.sdc.toscaparser.api.utils.TOSCAVersionProperty;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.*;
+import org.onap.sdc.toscaparser.api.elements.constraints.Constraint;
+import org.onap.sdc.toscaparser.api.elements.constraints.Schema;
+import org.onap.sdc.toscaparser.api.functions.Function;
+import org.onap.sdc.toscaparser.api.utils.TOSCAVersionProperty;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ValidateUtils;
public class DataEntity {
// A complex data value entity
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
+
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.*;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-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;
protected LinkedHashMap<String,Object> customDef;
protected StatefulEntityType typeDefinition;
private ArrayList<Property> _properties;
- private ArrayList<InterfacesDef> _interfaces;
+ private ArrayList<InterfacesDef> _interfaces;
private ArrayList<RequirementAssignment> _requirements;
private ArrayList<CapabilityAssignment> _capabilities;
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ValidateUtils;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.elements.Metadata;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
-
public class Group extends EntityTemplate {
private static final String TYPE = "type";
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.UrlUtils;
-import org.openecomp.sdc.toscaparser.api.elements.TypeValidation;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.UrlUtils;
+import org.onap.sdc.toscaparser.api.elements.TypeValidation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;
if((_path == null || _path.isEmpty()) && tpl == null) {
//msg = _('Input tosca template is not provided.')
//log.warning(msg)
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE184", "ValidationError: Input tosca template is not provided"));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE184", "ValidationError: Input tosca template is not provided"));
}
this.path = _path;
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
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.CopyUtils;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.elements.*;
+import org.onap.sdc.toscaparser.api.utils.CopyUtils;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class NodeTemplate extends EntityTemplate {
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ValidateUtils;
public class Policy extends EntityTemplate {
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.elements.constraints.Constraint;
-import org.openecomp.sdc.toscaparser.api.elements.constraints.Schema;
-import org.openecomp.sdc.toscaparser.api.functions.Function;
+import org.onap.sdc.toscaparser.api.elements.constraints.Constraint;
+import org.onap.sdc.toscaparser.api.elements.constraints.Schema;
+import org.onap.sdc.toscaparser.api.functions.Function;
public class Property {
// TOSCA built-in Property type
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.elements.EntityType;
-import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
-import org.openecomp.sdc.toscaparser.api.elements.StatefulEntityType;
+import org.onap.sdc.toscaparser.api.elements.PropertyDef;
+import org.onap.sdc.toscaparser.api.elements.StatefulEntityType;
+import org.onap.sdc.toscaparser.api.elements.EntityType;
public class RelationshipTemplate extends EntityTemplate {
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.UrlUtils;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.UrlUtils;
-
public class Repository {
private static final String DESCRIPTION = "description";
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import java.util.Map;
-package org.openecomp.sdc.toscaparser.api;
-
-import org.openecomp.sdc.toscaparser.api.RequirementAssignment;
+package org.onap.sdc.toscaparser.api;
import java.util.ArrayList;
import java.util.List;
-package org.openecomp.sdc.toscaparser.api;
-
-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;
+package org.onap.sdc.toscaparser.api;
+
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.NodeType;
+import org.onap.sdc.toscaparser.api.elements.PropertyDef;
+import org.onap.sdc.toscaparser.api.parameters.Input;
+import org.onap.sdc.toscaparser.api.parameters.Output;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
import java.util.HashSet;
-package org.openecomp.sdc.toscaparser.api;
-
-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.functions.Function;
-import org.openecomp.sdc.toscaparser.api.functions.GetAttribute;
-import org.openecomp.sdc.toscaparser.api.functions.GetInput;
-import org.openecomp.sdc.toscaparser.api.parameters.Input;
-import org.openecomp.sdc.toscaparser.api.parameters.Output;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+package org.onap.sdc.toscaparser.api;
+
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.InterfacesDef;
+import org.onap.sdc.toscaparser.api.elements.NodeType;
+import org.onap.sdc.toscaparser.api.elements.RelationshipType;
+import org.onap.sdc.toscaparser.api.functions.Function;
+import org.onap.sdc.toscaparser.api.functions.GetAttribute;
+import org.onap.sdc.toscaparser.api.functions.GetInput;
+import org.onap.sdc.toscaparser.api.parameters.Input;
+import org.onap.sdc.toscaparser.api.parameters.Output;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
import java.util.HashSet;
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
+import org.onap.sdc.toscaparser.api.elements.RelationshipType;
//import java.util.Iterator;
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.ValidationIssueCollector;
+import org.onap.sdc.toscaparser.api.parameters.Output;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.io.File;
import java.io.FileInputStream;
import java.util.function.Predicate;
import java.nio.file.Paths;
-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;
-import org.openecomp.sdc.toscaparser.api.extensions.ExtTools;
-import org.openecomp.sdc.toscaparser.api.parameters.Input;
-import org.openecomp.sdc.toscaparser.api.parameters.Output;
-import org.openecomp.sdc.toscaparser.api.prereq.CSAR;
-import org.openecomp.sdc.toscaparser.api.utils.JToscaErrorCodes;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaException;
+import org.onap.sdc.toscaparser.api.elements.EntityType;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+import org.onap.sdc.toscaparser.api.extensions.ExtTools;
+import org.onap.sdc.toscaparser.api.parameters.Input;
+import org.onap.sdc.toscaparser.api.prereq.CSAR;
+import org.onap.sdc.toscaparser.api.utils.JToscaErrorCodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ValidateUtils;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
-
public class Triggers extends EntityTemplate {
private static final String DESCRIPTION = "description";
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class UnsupportedType {
-package org.openecomp.sdc.toscaparser.api.common;
+package org.onap.sdc.toscaparser.api.common;
public class JToscaException extends Exception {
-package org.openecomp.sdc.toscaparser.api.common;
+package org.onap.sdc.toscaparser.api.common;
public class JToscaValidationIssue {
-package org.openecomp.sdc.toscaparser.api.common;
+package org.onap.sdc.toscaparser.api.common;
import java.util.IllegalFormatException;
-package org.openecomp.sdc.toscaparser.api.common;
+package org.onap.sdc.toscaparser.api.common;
import java.util.*;
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.util.LinkedHashMap;
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.util.LinkedHashMap;
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
-
public class CapabilityTypeDef extends StatefulEntityType {
// TOSCA built-in capabilities type
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-import org.openecomp.sdc.toscaparser.api.extensions.ExtTools;
-import org.openecomp.sdc.toscaparser.api.utils.CopyUtils;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.CopyUtils;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.extensions.ExtTools;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;
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
+import org.onap.sdc.toscaparser.api.utils.yamlparser
log = logging.getLogger('tosca')
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
public class GroupType extends StatefulEntityType {
private static final String DERIVED_FROM = "derived_from";
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.EntityTemplate;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.EntityTemplate;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.util.AbstractMap;
import java.util.HashMap;
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
import java.util.LinkedHashMap;
// Filter the node types
ArrayList<String> nodeTypes = new ArrayList<>();
for(String nt: customDef.keySet()) {
- if(nt.startsWith(NODE_PREFIX) || nt.startsWith("org.openecomp") && !nt.equals("tosca.nodes.Root")) {
+ if(nt.startsWith(NODE_PREFIX) || nt.startsWith("org.onap") && !nt.equals("tosca.nodes.Root")) {
nodeTypes.add(nt);
}
}
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.TOSCAVersionProperty;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.TOSCAVersionProperty;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class PolicyType extends StatefulEntityType {
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.DataEntity;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ValidateUtils;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.DataEntity;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
-
public class PortSpec {
// Parent class for tosca.datatypes.network.PortSpec type
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class PropertyDef {
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
public class RelationshipType extends StatefulEntityType {
private static final String DERIVED_FROM = "derived_from";
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-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.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ValidateUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
public class ScalarUnitFrequency extends ScalarUnit {
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
public class ScalarUnitSize extends ScalarUnit {
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
public class ScalarUnitTime extends ScalarUnit {
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.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.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.UnsupportedType;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class StatefulEntityType extends EntityType {
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.extensions.ExtTools;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.extensions.ExtTools;
public class TypeValidation {
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-import org.openecomp.sdc.toscaparser.api.elements.ScalarUnit;
-import org.openecomp.sdc.toscaparser.api.functions.Function;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.ScalarUnit;
+import org.onap.sdc.toscaparser.api.functions.Function;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public abstract class Constraint {
if(!(constraint instanceof LinkedHashMap) ||
((LinkedHashMap<String,Object>)constraint).size() != 1) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE101",
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE101",
"InvalidSchemaError: Invalid constraint schema " + constraint.toString()));
}
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
public class Equal extends Constraint {
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.functions.Function;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.functions.Function;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class GreaterOrEqual extends Constraint {
// Constraint class for "greater_or_equal"
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class GreaterThan extends Constraint {
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
import java.util.ArrayList;
public class InRange extends Constraint {
super(name,type,c);
if(!(constraintValue instanceof ArrayList) || ((ArrayList<Object>)constraintValue).size() != 2) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE106", "InvalidSchemaError: The property \"in_range\" expects a list"));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE106", "InvalidSchemaError: The property \"in_range\" expects a list"));
}
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Length extends Constraint {
// Constraint class for "length"
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE109", "InvalidSchemaError: The property \"length\" expects an integer"));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE109", "InvalidSchemaError: The property \"length\" expects an integer"));
}
}
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class LessOrEqual extends Constraint {
// Constraint class for "less_or_equal"
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE110", "InvalidSchemaError: The property \"less_or_equal\" expects comparable values"));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE110", "InvalidSchemaError: The property \"less_or_equal\" expects comparable values"));
}
}
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.Date;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
public class LessThan extends Constraint {
@Override
super(name,type,c);
if(!validTypes.contains(constraintValue.getClass().getSimpleName())) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE111", "InvalidSchemaError: The property \"less_than\" expects comparable values"));
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE111", "InvalidSchemaError: The property \"less_than\" expects comparable values"));
}
}
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class MaxLength extends Constraint {
// Constraint class for "min_length"
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class MinLength extends Constraint {
// Constraint class for "min_length"
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.regex.Matcher;
import java.util.regex.PatternSyntaxException;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Pattern extends Constraint {
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
public class Schema {
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
+package org.onap.sdc.toscaparser.api.elements.constraints;
import java.util.ArrayList;
-package org.openecomp.sdc.toscaparser.api.extensions;
+package org.onap.sdc.toscaparser.api.extensions;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.reflections.Reflections;
import org.reflections.scanners.ResourcesScanner;
import org.slf4j.Logger;
-package org.openecomp.sdc.toscaparser.api.functions;
+package org.onap.sdc.toscaparser.api.functions;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.TopologyTemplate;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
-import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
public class Concat extends Function {
// Validate the function and provide an instance of the function
// get_attribute: [ server, port ] ]
- public Concat(TopologyTemplate ttpl,Object context,String name,ArrayList<Object> args) {
+ public Concat(TopologyTemplate ttpl, Object context, String name, ArrayList<Object> args) {
super(ttpl,context,name,args);
}
@Override
void validate() {
if(args.size() < 1) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE145",
+ ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE145",
"ValueError: Invalid arguments for function \"concat\". " +
"Expected at least one argument"));
}
-package org.openecomp.sdc.toscaparser.api.functions;
+package org.onap.sdc.toscaparser.api.functions;
import java.util.*;
-import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.ToscaTemplate;
+import org.onap.sdc.toscaparser.api.TopologyTemplate;
public abstract class Function {
-package org.openecomp.sdc.toscaparser.api.functions;
+package org.onap.sdc.toscaparser.api.functions;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.*;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.*;
-import org.openecomp.sdc.toscaparser.api.elements.AttributeDef;
-import org.openecomp.sdc.toscaparser.api.elements.CapabilityTypeDef;
-import org.openecomp.sdc.toscaparser.api.elements.DataType;
-import org.openecomp.sdc.toscaparser.api.elements.EntityType;
-import org.openecomp.sdc.toscaparser.api.elements.NodeType;
-import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
-import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
-import org.openecomp.sdc.toscaparser.api.elements.StatefulEntityType;
-import org.openecomp.sdc.toscaparser.api.elements.constraints.Schema;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.*;
+import org.onap.sdc.toscaparser.api.elements.AttributeDef;
+import org.onap.sdc.toscaparser.api.elements.CapabilityTypeDef;
+import org.onap.sdc.toscaparser.api.elements.DataType;
+import org.onap.sdc.toscaparser.api.elements.EntityType;
+import org.onap.sdc.toscaparser.api.elements.NodeType;
+import org.onap.sdc.toscaparser.api.elements.PropertyDef;
+import org.onap.sdc.toscaparser.api.elements.RelationshipType;
+import org.onap.sdc.toscaparser.api.elements.StatefulEntityType;
+import org.onap.sdc.toscaparser.api.elements.constraints.Schema;
public class GetAttribute extends Function {
// Get an attribute value of an entity defined in the service template
-package org.openecomp.sdc.toscaparser.api.functions;
+package org.onap.sdc.toscaparser.api.functions;
-import org.openecomp.sdc.toscaparser.api.DataEntity;
-import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
-import org.openecomp.sdc.toscaparser.api.parameters.Input;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.DataEntity;
+import org.onap.sdc.toscaparser.api.TopologyTemplate;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.parameters.Input;
import java.util.ArrayList;
import java.util.LinkedHashMap;
public class GetInput extends Function {
- public GetInput(TopologyTemplate toscaTpl,Object context,String name,ArrayList<Object> _args) {
+ public GetInput(TopologyTemplate toscaTpl, Object context, String name, ArrayList<Object> _args) {
super(toscaTpl,context,name,_args);
}
-package org.openecomp.sdc.toscaparser.api.functions;
+package org.onap.sdc.toscaparser.api.functions;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.EntityTemplate;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.RelationshipTemplate;
+import org.onap.sdc.toscaparser.api.TopologyTemplate;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.InterfacesDef;
+import org.onap.sdc.toscaparser.api.elements.RelationshipType;
+import org.onap.sdc.toscaparser.api.elements.StatefulEntityType;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.util.ArrayList;
-import org.openecomp.sdc.toscaparser.api.*;
-import org.openecomp.sdc.toscaparser.api.elements.InterfacesDef;
-import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
-import org.openecomp.sdc.toscaparser.api.elements.StatefulEntityType;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class GetOperationOutput extends Function {
- public GetOperationOutput(TopologyTemplate ttpl,Object context,String name,ArrayList<Object> args) {
+ public GetOperationOutput(TopologyTemplate ttpl, Object context, String name, ArrayList<Object> args) {
super(ttpl,context,name,args);
}
_findOperationName(interfaceName,(String)args.get(2));
}
else {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE159",
+ 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\""));
-package org.openecomp.sdc.toscaparser.api.functions;
+package org.onap.sdc.toscaparser.api.functions;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.*;
+import org.onap.sdc.toscaparser.api.elements.CapabilityTypeDef;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.*;
-import org.openecomp.sdc.toscaparser.api.elements.CapabilityTypeDef;
-import org.openecomp.sdc.toscaparser.api.elements.EntityType;
-import org.openecomp.sdc.toscaparser.api.elements.NodeType;
-import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
-import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
-import org.openecomp.sdc.toscaparser.api.elements.StatefulEntityType;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.*;
+import org.onap.sdc.toscaparser.api.elements.EntityType;
+import org.onap.sdc.toscaparser.api.elements.NodeType;
+import org.onap.sdc.toscaparser.api.elements.PropertyDef;
+import org.onap.sdc.toscaparser.api.elements.RelationshipType;
+import org.onap.sdc.toscaparser.api.elements.StatefulEntityType;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class GetProperty extends Function {
// Get a property value of an entity defined in the same service template
// * { get_property: [ SELF, database_endpoint, port, 1 ] }
- public GetProperty(TopologyTemplate ttpl,Object context,String name,ArrayList<Object> args) {
+ public GetProperty(TopologyTemplate ttpl, Object context, String name, ArrayList<Object> args) {
super(ttpl,context,name,args);
}
}
Object prop = foundProp.getValue();
if(prop instanceof Function) {
- Function.getFunction(toscaTpl,context, prop, toscaTpl.getResolveGetInput());
+ getFunction(toscaTpl,context, prop, toscaTpl.getResolveGetInput());
}
}
else if(args.size() >= 3) {
if(propertyValue instanceof Function) {
return ((Function)propertyValue).result();
}
- return Function.getFunction(toscaTpl,context,propertyValue, toscaTpl.getResolveGetInput());
+ return getFunction(toscaTpl,context,propertyValue, toscaTpl.getResolveGetInput());
}
public String getNodeTemplateName() {
-package org.openecomp.sdc.toscaparser.api.functions;
+package org.onap.sdc.toscaparser.api.functions;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.TopologyTemplate;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.ArrayList;
-import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Token extends Function {
// Validate the function and provide an instance of the function
// [ get_attribute: [ my_server, data_endpoint, ip_address ], ':', 1 ]
- public Token(TopologyTemplate ttpl,Object context,String name,ArrayList<Object> args) {
+ public Token(TopologyTemplate ttpl, Object context, String name, ArrayList<Object> args) {
super(ttpl,context,name,args);
}
-package org.openecomp.sdc.toscaparser.api.parameters;
+package org.onap.sdc.toscaparser.api.parameters;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.DataEntity;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
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.elements.EntityType;
-import org.openecomp.sdc.toscaparser.api.elements.constraints.Constraint;
-import org.openecomp.sdc.toscaparser.api.elements.constraints.Schema;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.elements.EntityType;
+import org.onap.sdc.toscaparser.api.elements.constraints.Constraint;
+import org.onap.sdc.toscaparser.api.elements.constraints.Schema;
public class Input {
-package org.openecomp.sdc.toscaparser.api.parameters;
+package org.onap.sdc.toscaparser.api.parameters;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.LinkedHashMap;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class Output {
-package org.openecomp.sdc.toscaparser.api.prereq;
+package org.onap.sdc.toscaparser.api.prereq;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.ImportsLoader;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.utils.UrlUtils;
import java.io.BufferedOutputStream;
import java.io.File;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
-import org.openecomp.sdc.toscaparser.api.ImportsLoader;
-import org.openecomp.sdc.toscaparser.api.common.JToscaException;
-import org.openecomp.sdc.toscaparser.api.utils.JToscaErrorCodes;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import org.openecomp.sdc.toscaparser.api.utils.UrlUtils;
+import org.onap.sdc.toscaparser.api.common.JToscaException;
+import org.onap.sdc.toscaparser.api.utils.JToscaErrorCodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;
if(isFile) {
File f = new File(path);
if (!f.isFile()) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE220", 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 {
-package org.openecomp.sdc.toscaparser.api.utils;
+package org.onap.sdc.toscaparser.api.utils;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-package org.openecomp.sdc.toscaparser.api.utils;
+package org.onap.sdc.toscaparser.api.utils;
import java.util.ArrayList;
import java.util.LinkedHashMap;
-package org.openecomp.sdc.toscaparser.api.utils;
+package org.onap.sdc.toscaparser.api.utils;
public enum JToscaErrorCodes {
-package org.openecomp.sdc.toscaparser.api.utils;
+package org.onap.sdc.toscaparser.api.utils;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-package org.openecomp.sdc.toscaparser.api.utils;
+package org.onap.sdc.toscaparser.api.utils;
-import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
+import org.onap.sdc.toscaparser.api.common.ValidationIssueCollector;
public class ThreadLocalsHolder {
-package org.openecomp.sdc.toscaparser.api.utils;
+package org.onap.sdc.toscaparser.api.utils;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.io.IOException;
import java.net.HttpURLConnection;
-package org.openecomp.sdc.toscaparser.api.utils;
+package org.onap.sdc.toscaparser.api.utils;
-import org.openecomp.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import java.util.ArrayList;
import java.util.Date;
+++ /dev/null
-package org.openecomp.sdc.toscaparser.api.elements.constraints;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
-
-
-public class Schema {
-
- private static final String TYPE = "type";
- private static final String REQUIRED = "required";
- private static final String DESCRIPTION = "description";
- private static final String DEFAULT = "default";
- private static final String CONSTRAINTS = "constraints";
- private static final String STATUS = "status";
- private static final String ENTRYSCHEMA = "entry_schema";
- private static final String KEYS[] = {
- TYPE, REQUIRED, DESCRIPTION,DEFAULT, CONSTRAINTS, ENTRYSCHEMA, STATUS};
-
- public static final String INTEGER = "integer";
- public static final String STRING = "string";
- public static final String BOOLEAN = "boolean";
- public static final String FLOAT = "float";
- public static final String RANGE = "range";
- public static final String NUMBER = "number";
- public static final String TIMESTAMP = "timestamp";
- public static final String LIST = "list";
- public static final String MAP = "map";
- public static final String SCALAR_UNIT_SIZE = "scalar-unit.size";
- public static final String SCALAR_UNIT_FREQUENCY = "scalar-unit.frequency";
- public static final String SCALAR_UNIT_TIME = "scalar-unit.time";
- public static final String VERSION = "version";
- public static final String PORTDEF = "PortDef";
- public static final String PORTSPEC = "PortSpec"; //??? PortSpec.SHORTNAME
-<<<<<<< HEAD
- public static final String JSON = "json";
-=======
- public static final String JSON = "json";
->>>>>>> master
-
- public static final String PROPERTY_TYPES[] = {
- INTEGER, STRING, BOOLEAN, FLOAT, RANGE,NUMBER, TIMESTAMP, LIST, MAP,
- SCALAR_UNIT_SIZE, SCALAR_UNIT_FREQUENCY, SCALAR_UNIT_TIME,
- VERSION, PORTDEF, PORTSPEC, JSON};
-
- @SuppressWarnings("unused")
- private static final String SCALAR_UNIT_SIZE_DEFAULT = "B";
-
- private static Map<String,Long> SCALAR_UNIT_SIZE_DICT = new HashMap<>();
- static {
- SCALAR_UNIT_SIZE_DICT.put("B", 1L);
- SCALAR_UNIT_SIZE_DICT.put("KB", 1000L);
- SCALAR_UNIT_SIZE_DICT.put("KIB", 1024L);
- SCALAR_UNIT_SIZE_DICT.put("MB", 1000000L);
- SCALAR_UNIT_SIZE_DICT.put("MIB", 1048576L);
- SCALAR_UNIT_SIZE_DICT.put("GB", 1000000000L);
- SCALAR_UNIT_SIZE_DICT.put("GIB", 1073741824L);
- SCALAR_UNIT_SIZE_DICT.put("TB", 1000000000000L);
- SCALAR_UNIT_SIZE_DICT.put("TIB", 1099511627776L);
- }
-
- private String name;
- private LinkedHashMap<String,Object> schema;
- private int _len;
- private ArrayList<Constraint> constraintsList;
-
-
- public Schema(String _name,LinkedHashMap<String,Object> _schemaDict) {
- name = _name;
-
- if(!(_schemaDict instanceof LinkedHashMap)) {
- //msg = (_('Schema definition of "%(pname)s" must be a dict.')
- // % dict(pname=name))
- ExceptionCollector.appendException(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))
- ExceptionCollector.appendException(String.format(
- "InvalidSchemaError: Schema definition of \"%s\" must have a \"type\" attribute",name));
- }
-
- schema = _schemaDict;
- _len = 0; //??? None
- constraintsList = new ArrayList<>();
- }
-
- public String getType() {
- return (String)schema.get(TYPE);
- }
-
- public boolean isRequired() {
- return (boolean)schema.getOrDefault(REQUIRED, true);
- }
-
- public String getDescription() {
- return (String)schema.getOrDefault(DESCRIPTION,"");
- }
-
- public Object getDefault() {
- return schema.get(DEFAULT);
- }
-
- public String getStatus() {
- return (String)schema.getOrDefault(STATUS,"");
- }
-
- @SuppressWarnings("unchecked")
- public ArrayList<Constraint> getConstraints() {
- if(constraintsList.size() == 0) {
- Object cob = schema.get(CONSTRAINTS);
- if(cob instanceof ArrayList) {
- ArrayList<Object> constraintSchemata = (ArrayList<Object>)cob;
- for(Object ob: constraintSchemata) {
- if(ob instanceof LinkedHashMap) {
- for(String cClass: ((LinkedHashMap<String,Object>)ob).keySet()) {
- Constraint c = Constraint.factory(cClass,name,getType(),ob);
- if(c != null) {
- constraintsList.add(c);
- }
- else {
- // error
- ExceptionCollector.appendException(String.format(
- "UnknownFieldError: Constraint type \"%s\" for property \"%s\" is not supported",
- cClass,name));
- }
- break;
- }
- }
- }
- }
- }
- return constraintsList;
- }
-
- @SuppressWarnings("unchecked")
- public LinkedHashMap<String,Object> getEntrySchema() {
- return (LinkedHashMap<String,Object>)schema.get(ENTRYSCHEMA);
- }
-
- // Python intrinsic methods...
-
- // substitute for __getitem__ (aka self[key])
- public Object getItem(String key) {
- return schema.get(key);
- }
-
- /*
- def __iter__(self):
- for k in self.KEYS:
- try:
- self.schema[k]
- except KeyError:
- pass
- else:
- yield k
- */
-
- // substitute for __len__ (aka self.len())
- public int getLen() {
- int len = 0;
- for(String k: KEYS) {
- if(schema.get(k) != null) {
- len++;
- }
- _len = len;
- }
- return _len;
- }
- // getter
- public LinkedHashMap<String,Object> getSchema() {
- return schema;
- }
-
-}
-
-/*python
-
-class Schema(collections.Mapping):
-
-KEYS = (
- TYPE, REQUIRED, DESCRIPTION,
- DEFAULT, CONSTRAINTS, ENTRYSCHEMA, STATUS
-) = (
- 'type', 'required', 'description',
- 'default', 'constraints', 'entry_schema', 'status'
-)
-
-PROPERTY_TYPES = (
- INTEGER, STRING, BOOLEAN, FLOAT, RANGE,
- NUMBER, TIMESTAMP, LIST, MAP,
- SCALAR_UNIT_SIZE, SCALAR_UNIT_FREQUENCY, SCALAR_UNIT_TIME,
- VERSION, PORTDEF, PORTSPEC
-) = (
- 'integer', 'string', 'boolean', 'float', 'range',
- 'number', 'timestamp', 'list', 'map',
- 'scalar-unit.size', 'scalar-unit.frequency', 'scalar-unit.time',
- 'version', 'PortDef', PortSpec.SHORTNAME
-)
-
-SCALAR_UNIT_SIZE_DEFAULT = 'B'
-SCALAR_UNIT_SIZE_DICT = {'B': 1, 'KB': 1000, 'KIB': 1024, 'MB': 1000000,
- 'MIB': 1048576, 'GB': 1000000000,
- 'GIB': 1073741824, 'TB': 1000000000000,
- 'TIB': 1099511627776}
-
-def __init__(self, name, schema_dict):
- self.name = name
- 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))
-
- 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))
-
- self.schema = schema_dict
- self._len = None
- self.constraints_list = []
-
-@property
-def type(self):
- return self.schema[self.TYPE]
-
-@property
-def required(self):
- return self.schema.get(self.REQUIRED, True)
-
-@property
-def description(self):
- return self.schema.get(self.DESCRIPTION, '')
-
-@property
-def default(self):
- return self.schema.get(self.DEFAULT)
-
-@property
-def status(self):
- return self.schema.get(self.STATUS, '')
-
-@property
-def constraints(self):
- if not self.constraints_list:
- constraint_schemata = self.schema.get(self.CONSTRAINTS)
- if constraint_schemata:
- self.constraints_list = [Constraint(self.name,
- self.type,
- cschema)
- for cschema in constraint_schemata]
- return self.constraints_list
-
-@property
-def entry_schema(self):
- return self.schema.get(self.ENTRYSCHEMA)
-
-def __getitem__(self, key):
- return self.schema[key]
-
-def __iter__(self):
- for k in self.KEYS:
- try:
- self.schema[k]
- except KeyError:
- pass
- else:
- yield k
-
-def __len__(self):
- if self._len is None:
- self._len = len(list(iter(self)))
- return self._len
-*/
\ No newline at end of file
+++ /dev/null
-package org.openecomp.sdc.toscaparser.api.prereq;
-
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.RandomAccessFile;
-import java.net.URL;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.nio.file.StandardCopyOption;
-import java.util.*;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-import java.util.zip.ZipInputStream;
-
-import org.openecomp.sdc.toscaparser.api.ImportsLoader;
-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;
-import org.slf4j.LoggerFactory;
-import org.yaml.snakeyaml.Yaml;
-
-<<<<<<< HEAD:jtosca/src/main/java/org/openecomp/sdc/toscaparser/prereq/CSAR.java
-import org.openecomp.sdc.toscaparser.ImportsLoader;
-import org.openecomp.sdc.toscaparser.common.ExceptionCollector;
-import org.openecomp.sdc.toscaparser.utils.UrlUtils;
-
-=======
->>>>>>> 243072-jtosca-package-fix:jtosca/src/main/java/org/openecomp/sdc/toscaparser/api/prereq/CSAR.java
-public class CSAR {
-
- private static Logger log = LoggerFactory.getLogger(CSAR.class.getName());
- private static final ArrayList<String> META_PROPERTIES_FILES = new ArrayList<>(Arrays.asList("TOSCA-Metadata/TOSCA.meta", "csar.meta"));
-
- private String path;
- private boolean isFile;
- private boolean isValidated;
- private boolean errorCaught;
- private String csar;
- private String tempDir;
-// private Metadata metaData;
- private File tempFile;
- private LinkedHashMap<String, LinkedHashMap<String, Object>> metaProperties;
-
- public CSAR(String csarPath, boolean aFile) {
- path = csarPath;
- isFile = aFile;
- isValidated = false;
- errorCaught = false;
- csar = null;
- tempDir = null;
- tempFile = null;
- metaProperties = new LinkedHashMap<>();
- }
-
- @SuppressWarnings("unchecked")
- public boolean validate() {
- isValidated = true;
-
- //validate that the file or URL exists
-
- if(isFile) {
- File f = new File(path);
- if (!f.isFile()) {
- ExceptionCollector.appendException(String.format("\"%s\" is not a file", path));
- return false;
- }
- else {
- this.csar = path;
- }
- }
- else {
- if(!UrlUtils.validateUrl(path)) {
- ExceptionCollector.appendException(String.format("ImportError: \"%s\" does not exist",path));
- return false;
- }
- // get it to a local file
- try {
- File tempFile = File.createTempFile("csartmp",".csar");
- Path ptf = Paths.get(tempFile.getPath());
- URL webfile = new URL(path);
- InputStream in = webfile.openStream();
- Files.copy(in,ptf,StandardCopyOption.REPLACE_EXISTING);
- }
- catch(Exception e) {
- ExceptionCollector.appendException("ImportError: failed to load CSAR from " + path);
- return false;
- }
-
- log.debug("CSAR - validate - currently only files are supported");
- return false;
- }
-
- _parseAndValidateMetaProperties();
-
- if(errorCaught) {
- return false;
- }
-
- // validate that external references in the main template actually exist and are accessible
- _validateExternalReferences();
-
- return !errorCaught;
-
- }
-
- private void _parseAndValidateMetaProperties() {
-
- ZipFile zf = null;
-
- try {
-
- // validate that it is a valid zip file
- RandomAccessFile raf = new RandomAccessFile(csar, "r");
- long n = raf.readInt();
- raf.close();
- // check if Zip's magic number
- if (n != 0x504B0304) {
- throw new IOException(String.format("\"%s\" is not a valid zip file", csar));
- }
-
- // validate that it contains the metadata file in the correct location
- zf = new ZipFile(csar);
- ZipEntry ze = zf.getEntry("TOSCA-Metadata/TOSCA.meta");
- if (ze == null) {
- throw new IOException(String.format(
- "\"%s\" is not a valid CSAR as it does not contain the " +
- "required file \"TOSCA.meta\" in the folder \"TOSCA-Metadata\"", csar));
- }
-
- //Going over expected metadata files and parsing them
- for (String metaFile: META_PROPERTIES_FILES) {
-
- byte ba[] = new byte[4096];
- ze = zf.getEntry(metaFile);
- if (ze != null) {
- InputStream inputStream = zf.getInputStream(ze);
- n = inputStream.read(ba, 0, 4096);
-
- String md = new String(ba);
- md = md.substring(0, (int) n);
- Yaml yaml = new Yaml();
- Object mdo = yaml.load(md);
- if (!(mdo instanceof LinkedHashMap)) {
- throw new IOException(String.format(
- "The file \"%s\" in the" +
- " CSAR \"%s\" does not contain valid YAML content", ze.getName(), csar));
- }
-
- String[] split = ze.getName().split("/");
- String fileName = split[split.length - 1];
-
- if (!metaProperties.containsKey(fileName)) {
- metaProperties.put(fileName, (LinkedHashMap<String, Object>) mdo);
- }
- }
- }
-
- // verify it has "Entry-Definition"
- String edf = _getMetadata("Entry-Definitions");
- if (edf == null) {
- throw new IOException(String.format(
- "The CSAR \"%s\" is missing the required metadata " +
- "\"Entry-Definitions\" in \"TOSCA-Metadata/TOSCA.meta\"", csar));
- }
-
- //validate that "Entry-Definitions' metadata value points to an existing file in the CSAR
- boolean foundEDF = false;
- Enumeration<? extends ZipEntry> entries = zf.entries();
- while (entries.hasMoreElements()) {
- ze = entries.nextElement();
- if (ze.getName().equals(edf)) {
- foundEDF = true;
- break;
- }
- }
- if (!foundEDF) {
- throw new IOException(String.format(
- "The \"Entry-Definitions\" file defined in the CSAR \"%s\" does not exist", csar));
- }
- } catch (Exception e) {
- ExceptionCollector.appendException("ValidationError: " + e.getMessage());
- errorCaught = true;
- }
-
- try {
- if (zf != null) {
- zf.close();
- }
- } catch (IOException e) {
- }
- }
-
- public void cleanup() {
- try {
- if(tempFile != null) {
- tempFile.delete();
- }
- }
- catch(Exception e) {
- }
- }
-
- private String _getMetadata(String key) {
- if(!isValidated) {
- validate();
- }
- Object value = _getMetaProperty("TOSCA.meta").get(key);
- return value != null ? value.toString() : null;
- }
-
- public String getAuthor() {
- return _getMetadata("Created-By");
- }
-
- public String getVersion() {
- return _getMetadata("CSAR-Version");
- }
-
- public LinkedHashMap<String, LinkedHashMap<String, Object>> getMetaProperties() {
- return metaProperties;
- }
-
- private LinkedHashMap<String, Object> _getMetaProperty(String propertiesFile) {
- return metaProperties.get(propertiesFile);
- }
-
- public String getMainTemplate() {
- String entryDef = _getMetadata("Entry-Definitions");
- ZipFile zf;
- boolean ok = false;
- try {
- zf = new ZipFile(path);
- ok = (zf.getEntry(entryDef) != null);
- zf.close();
- }
- catch(IOException e) {
- if(!ok) {
- log.error("CSAR - getMainTemplate - failed to open {}", path);
- }
- }
- if(ok) {
- return entryDef;
- }
- else {
- return null;
- }
- }
-
- @SuppressWarnings("unchecked")
- public LinkedHashMap<String,Object> getMainTemplateYaml() {
- String mainTemplate = tempDir + File.separator + getMainTemplate();
- if(mainTemplate != null) {
- try {
- InputStream input = new FileInputStream(new File(mainTemplate));
- Yaml yaml = new Yaml();
- Object data = yaml.load(input);
- if(!(data instanceof LinkedHashMap)) {
- throw new IOException();
- }
- return (LinkedHashMap<String,Object>)data;
- }
- catch(Exception e) {
- ExceptionCollector.appendException(String.format(
- "The file \"%s\" in the CSAR \"%s\" does not " +
- "contain valid TOSCA YAML content",
- mainTemplate,csar));
- }
- }
- return null;
- }
-
- public String getDescription() {
- String desc = _getMetadata("Description");
- if(desc != null) {
- return desc;
- }
-
- Map<String, Object> metaData = metaProperties.get("TOSCA.meta");
- metaData.put("Description", getMainTemplateYaml().get("description"));
- return _getMetadata("Description");
- }
-
- public String getTempDir() {
- return tempDir;
- }
-
- public void decompress() throws IOException {
- if(!isValidated) {
- validate();
- }
- tempDir = Files.createTempDirectory("JTP").toString();
- unzip(path,tempDir);
-
- }
-
- private void _validateExternalReferences() {
- // Extracts files referenced in the main template
- // These references are currently supported:
- // * imports
- // * interface implementations
- // * artifacts
- try {
- decompress();
- String mainTplFile = getMainTemplate();
- if(mainTplFile == null) {
- return;
- }
-
- LinkedHashMap<String,Object> mainTpl = getMainTemplateYaml();
- if(mainTpl.get("imports") != null) {
- // this loads the imports
- ImportsLoader il = new ImportsLoader((ArrayList<Object>)mainTpl.get("imports"),
- tempDir + File.separator + mainTplFile,
- (Object)null,
- (LinkedHashMap<String,Object>)null);
- }
-
- if(mainTpl.get("topology_template") != null) {
- LinkedHashMap<String,Object> topologyTemplate =
- (LinkedHashMap<String,Object>)mainTpl.get("topology_template");
-
- if(topologyTemplate.get("node_templates") != null) {
- LinkedHashMap<String,Object> nodeTemplates =
- (LinkedHashMap<String,Object>)topologyTemplate.get("node_templates");
- for(String nodeTemplateKey: nodeTemplates.keySet()) {
- LinkedHashMap<String,Object> nodeTemplate =
- (LinkedHashMap<String,Object>)nodeTemplates.get(nodeTemplateKey);
- if(nodeTemplate.get("artifacts") != null) {
- LinkedHashMap<String,Object> artifacts =
- (LinkedHashMap<String,Object>)nodeTemplate.get("artifacts");
- for(String artifactKey: artifacts.keySet()) {
- Object artifact = artifacts.get(artifactKey);
- if(artifact instanceof String) {
- _validateExternalReference(mainTplFile,(String)artifact,true);
- }
- else if(artifact instanceof LinkedHashMap) {
- String file = (String)((LinkedHashMap<String,Object>)artifact).get("file");
- if(file != null) {
- _validateExternalReference(mainTplFile,file,true);
- }
- }
- else {
- ExceptionCollector.appendException(String.format(
- "ValueError: Unexpected artifact definition for \"%s\"",
- artifactKey));
- errorCaught = true;
- }
- }
- }
- if(nodeTemplate.get("interfaces") != null) {
- LinkedHashMap<String,Object> interfaces =
- (LinkedHashMap<String,Object>)nodeTemplate.get("interfaces");
- for(String interfaceKey: interfaces.keySet()) {
- LinkedHashMap<String,Object> _interface =
- (LinkedHashMap<String,Object>)interfaces.get(interfaceKey);
- for(String operationKey: _interface.keySet()) {
- Object operation = _interface.get(operationKey);
- if(operation instanceof String) {
- _validateExternalReference(mainTplFile,(String)operation,false);
- }
- else if(operation instanceof LinkedHashMap) {
- String imp = (String)((LinkedHashMap<String,Object>)operation).get("implementation");
- if(imp != null) {
- _validateExternalReference(mainTplFile,imp,true);
- }
- }
- }
- }
- }
- }
- }
- }
- }
- catch(IOException e) {
- errorCaught = true;
- }
- finally {
- // delete tempDir (only here?!?)
- File fdir = new File(tempDir);
- deleteDir(fdir);
- tempDir = null;
- }
- }
-
- public static void deleteDir(File fdir) {
- try {
- if (fdir.isDirectory()) {
- for (File c : fdir.listFiles())
- deleteDir(c);
- }
- fdir.delete();
- }
- catch(Exception e) {
- }
- }
-
- private void _validateExternalReference(String tplFile,String resourceFile,boolean raiseExc) {
- // Verify that the external resource exists
-
- // If resource_file is a URL verify that the URL is valid.
- // If resource_file is a relative path verify that the path is valid
- // considering base folder (self.temp_dir) and tpl_file.
- // Note that in a CSAR resource_file cannot be an absolute path.
- if(UrlUtils.validateUrl(resourceFile)) {
- String msg = String.format("URLException: The resource at \"%s\" cannot be accessed",resourceFile);
- try {
- if(UrlUtils.isUrlAccessible(resourceFile)) {
- return;
- }
- else {
- ExceptionCollector.appendException(msg);
- errorCaught = true;
- }
- }
- catch (Exception e) {
- ExceptionCollector.appendException(msg);
- }
- }
-
- String dirPath = Paths.get(tplFile).getParent().toString();
- String filePath = tempDir + File.separator + dirPath + File.separator + resourceFile;
- File f = new File(filePath);
- if(f.isFile()) {
- return;
- }
-
- if(raiseExc) {
- ExceptionCollector.appendException(String.format(
- "ValueError: The resource \"%s\" does not exist",resourceFile));
- }
- errorCaught = true;
- }
-
- private void unzip(String zipFilePath, String destDirectory) throws IOException {
- File destDir = new File(destDirectory);
- if (!destDir.exists()) {
- destDir.mkdir();
- }
- ZipInputStream zipIn = new ZipInputStream(new FileInputStream(zipFilePath));
- ZipEntry entry = zipIn.getNextEntry();
- // iterates over entries in the zip file
- while (entry != null) {
- // create all directories needed for nested items
- String[] parts = entry.getName().split("/");
- String s = destDirectory + File.separator ;
- for(int i=0; i< parts.length-1; i++) {
- s += parts[i];
- File idir = new File(s);
- if(!idir.exists()) {
- idir.mkdir();
- }
- s += File.separator;
- }
- String filePath = destDirectory + File.separator + entry.getName();
- if (!entry.isDirectory()) {
- // if the entry is a file, extracts it
- extractFile(zipIn, filePath);
- } else {
- // if the entry is a directory, make the directory
- File dir = new File(filePath);
- dir.mkdir();
- }
- zipIn.closeEntry();
- entry = zipIn.getNextEntry();
- }
- zipIn.close();
- }
-
- /**
- * Extracts a zip entry (file entry)
- * @param zipIn
- * @param filePath
- * @throws IOException
- */
- private static final int BUFFER_SIZE = 4096;
-
- private void extractFile(ZipInputStream zipIn, String filePath) throws IOException {
- //BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
- FileOutputStream fos = new FileOutputStream(filePath);
- BufferedOutputStream bos = new BufferedOutputStream(fos);
- byte[] bytesIn = new byte[BUFFER_SIZE];
- int read = 0;
- while ((read = zipIn.read(bytesIn)) != -1) {
- bos.write(bytesIn, 0, read);
- }
- bos.close();
- }
-
-}
-
-/*python
-
-from toscaparser.common.exception import ExceptionCollector
-from toscaparser.common.exception import URLException
-from toscaparser.common.exception import ValidationError
-from toscaparser.imports import ImportsLoader
-from toscaparser.utils.gettextutils import _
-from toscaparser.utils.urlutils import UrlUtils
-
-try: # Python 2.x
- from BytesIO import BytesIO
-except ImportError: # Python 3.x
- from io import BytesIO
-
-
-class CSAR(object):
-
- def __init__(self, csar_file, a_file=True):
- self.path = csar_file
- self.a_file = a_file
- self.is_validated = False
- self.error_caught = False
- self.csar = None
- self.temp_dir = None
-
- def validate(self):
- """Validate the provided CSAR file."""
-
- self.is_validated = True
-
- # validate that the file or URL exists
- missing_err_msg = (_('"%s" does not exist.') % self.path)
- if self.a_file:
- if not os.path.isfile(self.path):
- ExceptionCollector.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(
- ValidationError(message=missing_err_msg))
- return False
- else:
- response = requests.get(self.path)
- self.csar = BytesIO(response.content)
-
- # 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(
- ValidationError(message=err_msg))
- return False
-
- # validate that it contains the metadata file in the correct location
- self.zfile = zipfile.ZipFile(self.csar, 'r')
- filelist = self.zfile.namelist()
- if 'TOSCA-Metadata/TOSCA.meta' not in filelist:
- 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(
- ValidationError(message=err_msg))
- return False
-
- # validate that 'Entry-Definitions' property exists in TOSCA.meta
- data = self.zfile.read('TOSCA-Metadata/TOSCA.meta')
- invalid_yaml_err_msg = (_('The file "TOSCA-Metadata/TOSCA.meta" in '
- 'the CSAR "%s" does not contain valid YAML '
- 'content.') % self.path)
- try:
- meta = yaml.load(data)
- if type(meta) is dict:
- self.metadata = meta
- else:
- ExceptionCollector.appendException(
- ValidationError(message=invalid_yaml_err_msg))
- return False
- except yaml.YAMLError:
- ExceptionCollector.appendException(
- ValidationError(message=invalid_yaml_err_msg))
- return False
-
- if 'Entry-Definitions' not in self.metadata:
- err_msg = (_('The CSAR "%s" is missing the required metadata '
- '"Entry-Definitions" in '
- '"TOSCA-Metadata/TOSCA.meta".')
- % self.path)
- ExceptionCollector.appendException(
- ValidationError(message=err_msg))
- return False
-
- # validate that 'Entry-Definitions' metadata value points to an
- # existing file in the CSAR
- entry = self.metadata.get('Entry-Definitions')
- 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(
- ValidationError(message=err_msg))
- return False
-
- # validate that external references in the main template actually
- # exist and are accessible
- self._validate_external_references()
- return not self.error_caught
-
- def get_metadata(self):
- """Return the metadata dictionary."""
-
- # validate the csar if not already validated
- if not self.is_validated:
- self.validate()
-
- # return a copy to avoid changes overwrite the original
- return dict(self.metadata) if self.metadata else None
-
- def _get_metadata(self, key):
- if not self.is_validated:
- self.validate()
- return self.metadata.get(key)
-
- def get_author(self):
- return self._get_metadata('Created-By')
-
- def get_version(self):
- return self._get_metadata('CSAR-Version')
-
- def get_main_template(self):
- entry_def = self._get_metadata('Entry-Definitions')
- if entry_def in self.zfile.namelist():
- return entry_def
-
- def get_main_template_yaml(self):
- main_template = self.get_main_template()
- if main_template:
- data = self.zfile.read(main_template)
- invalid_tosca_yaml_err_msg = (
- _('The file "%(template)s" in the CSAR "%(csar)s" does not '
- 'contain valid TOSCA YAML content.') %
- {'template': main_template, 'csar': self.path})
- try:
- tosca_yaml = yaml.load(data)
- if type(tosca_yaml) is not dict:
- ExceptionCollector.appendException(
- ValidationError(message=invalid_tosca_yaml_err_msg))
- return tosca_yaml
- except Exception:
- ExceptionCollector.appendException(
- ValidationError(message=invalid_tosca_yaml_err_msg))
-
- def get_description(self):
- desc = self._get_metadata('Description')
- if desc is not None:
- return desc
-
- self.metadata['Description'] = \
- self.get_main_template_yaml().get('description')
- return self.metadata['Description']
-
- def decompress(self):
- if not self.is_validated:
- self.validate()
- self.temp_dir = tempfile.NamedTemporaryFile().name
- with zipfile.ZipFile(self.csar, "r") as zf:
- zf.extractall(self.temp_dir)
-
- def _validate_external_references(self):
- """Extracts files referenced in the main template
-
- These references are currently supported:
- * imports
- * interface implementations
- * artifacts
- """
- try:
- self.decompress()
- main_tpl_file = self.get_main_template()
- if not main_tpl_file:
- return
- main_tpl = self.get_main_template_yaml()
-
- if 'imports' in main_tpl:
- ImportsLoader(main_tpl['imports'],
- os.path.join(self.temp_dir, main_tpl_file))
-
- if 'topology_template' in main_tpl:
- topology_template = main_tpl['topology_template']
-
- if 'node_templates' in topology_template:
- node_templates = topology_template['node_templates']
-
- for node_template_key in node_templates:
- node_template = node_templates[node_template_key]
- if 'artifacts' in node_template:
- artifacts = node_template['artifacts']
- for artifact_key in artifacts:
- artifact = artifacts[artifact_key]
- if isinstance(artifact, six.string_types):
- self._validate_external_reference(
- main_tpl_file,
- artifact)
- elif isinstance(artifact, dict):
- if 'file' in artifact:
- self._validate_external_reference(
- main_tpl_file,
- artifact['file'])
- else:
- ExceptionCollector.appendException(
- ValueError(_('Unexpected artifact '
- 'definition for "%s".')
- % artifact_key))
- self.error_caught = True
- if 'interfaces' in node_template:
- interfaces = node_template['interfaces']
- for interface_key in interfaces:
- interface = interfaces[interface_key]
- for opertation_key in interface:
- operation = interface[opertation_key]
- if isinstance(operation, six.string_types):
- self._validate_external_reference(
- main_tpl_file,
- operation,
- False)
- elif isinstance(operation, dict):
- if 'implementation' in operation:
- self._validate_external_reference(
- main_tpl_file,
- operation['implementation'])
- finally:
- if self.temp_dir:
- shutil.rmtree(self.temp_dir)
-
- def _validate_external_reference(self, tpl_file, resource_file,
- raise_exc=True):
- """Verify that the external resource exists
-
- If resource_file is a URL verify that the URL is valid.
- If resource_file is a relative path verify that the path is valid
- considering base folder (self.temp_dir) and tpl_file.
- Note that in a CSAR resource_file cannot be an absolute path.
- """
- if UrlUtils.validate_url(resource_file):
- msg = (_('The resource at "%s" cannot be accessed.') %
- resource_file)
- try:
- if UrlUtils.url_accessible(resource_file):
- return
- else:
- ExceptionCollector.appendException(
- URLException(what=msg))
- self.error_caught = True
- except Exception:
- ExceptionCollector.appendException(
- URLException(what=msg))
- self.error_caught = True
-
- if os.path.isfile(os.path.join(self.temp_dir,
- os.path.dirname(tpl_file),
- resource_file)):
- return
-
- if raise_exc:
- ExceptionCollector.appendException(
- ValueError(_('The resource "%s" does not exist.')
- % resource_file))
- self.error_caught = True
-*/
-
-
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.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
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");
+ File jtoscaFiles = new File(args[0]+ "\\jtosca\\src\\main\\java\\org\\onap\\sdc\\toscaparser\\api");
try {
printFiles(jtoscaFiles);
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import org.junit.Test;
-import org.openecomp.sdc.toscaparser.api.common.JToscaException;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaException;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import java.io.File;
import java.util.ArrayList;
-package org.openecomp.sdc.toscaparser.api;
+package org.onap.sdc.toscaparser.api;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.util.LinkedHashMap;
import org.junit.Test;
-import org.openecomp.sdc.toscaparser.api.common.JToscaException;
-import org.openecomp.sdc.toscaparser.api.utils.JToscaErrorCodes;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
+import org.onap.sdc.toscaparser.api.common.JToscaException;
+import org.onap.sdc.toscaparser.api.utils.JToscaErrorCodes;
+import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class JToscaMetadataParse {
-package org.openecomp.sdc.toscaparser.api.elements;
+package org.onap.sdc.toscaparser.api.elements;
import org.junit.After;
-import org.junit.Before;
import org.junit.Test;
import java.util.HashMap;
# because they are used in Jenkins, whose plug-in doesn't support
major=1
-minor=2
-patch=2
+minor=3
+patch=0
base_version=${major}.${minor}.${patch}
Code Review / sdc / sdc-tosca.git / commitdiff