Merge "Optimize the areas where its creating extra memory"

3 files changed, 140 insertions, 28 deletions

diff --git a/aai-schema-ingest/src/main/java/org/onap/aai/nodes/CaseFormatStore.java b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/CaseFormatStore.java
new file mode 100644
index 00000000..69a153da
--- /dev/null
+++ b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/CaseFormatStore.java
@@ -0,0 +1,105 @@
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.aai
+ * ================================================================================
+ * Copyright © 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+package org.onap.aai.nodes;
+
+import com.google.common.base.CaseFormat;
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * CaseFormatStore stores the converted strings from
+ * lower hyphen (example-object) to lower camel case (exampleObject)
+ * so it avoids the creation of the object for every single request
+ * and cause an issue with taking too much memory just for the conversion
+ */
+public class CaseFormatStore {
+
+    private final Map<String, String> lowerHyphenToLowerCamel = new HashMap<>();
+    private final Map<String, String> lowerHyphenToUpperCamel = new HashMap<>();
+    private final Map<String, String> lowerCamelToLowerHyphen = new HashMap<>();
+    private final Map<String, String> upperCamelToLowerHyphen = new HashMap<>();
+
+    CaseFormatStore(){}
+
+    /**
+     * Parses the document and creates a lower camel case string
+     * upper camel string, lower hyphen and lower camel case
+     *
+     * @param doc   Takes an xml document and adds it to the hash maps as appropriate
+     */
+    void parse(Document doc){
+
+        // Get the xml-root-element and add those nodes
+        // with the attribute name and it to the hashmaps
+        // For the attribute with name, it is going to be lower-hyphen
+        // If the attribute is javaAttribute then it will be lower camel case
+        NodeList list = doc.getElementsByTagName("xml-root-element");
+        addCaseFormatForNodesAndProperties(list, "name");
+
+        list = doc.getElementsByTagName("xml-element");
+        addCaseFormatForNodesAndProperties(list, "java-attribute");
+
+        list = doc.getElementsByTagName("xml-any-element");
+        addCaseFormatForNodesAndProperties(list, "java-attribute");
+    }
+
+    private void addCaseFormatForNodesAndProperties(NodeList list, String attributeName) {
+        for (int i = 0; i < list.getLength(); i++) {
+
+            String lowerCamel = null;
+            String lowerHyphen = null;
+
+            if ("java-attribute".equals(attributeName)) {
+                lowerCamel = list.item(i).getAttributes().getNamedItem(attributeName).getNodeValue();
+                lowerHyphen = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, lowerCamel);
+            } else {
+                lowerHyphen = list.item(i).getAttributes().getNamedItem(attributeName).getNodeValue();
+                lowerCamel = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, lowerHyphen);
+            }
+
+            String upperCamel = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, lowerHyphen);
+            lowerHyphenToLowerCamel.put(lowerHyphen, lowerCamel);
+            lowerHyphenToUpperCamel.put(lowerHyphen, upperCamel);
+            upperCamelToLowerHyphen.put(upperCamel, lowerHyphen);
+            lowerCamelToLowerHyphen.put(lowerCamel, lowerHyphen);
+        }
+    }
+
+    public Optional<String> fromLowerHyphenToLowerCamel(String value){
+        return Optional.ofNullable(lowerHyphenToLowerCamel.get(value));
+    }
+
+    public Optional<String> fromLowerHyphenToUpperCamel(String value){
+        return Optional.ofNullable(lowerHyphenToUpperCamel.get(value));
+    }
+
+    public Optional<String> fromUpperCamelToLowerHyphen(String value){
+        return Optional.ofNullable(upperCamelToLowerHyphen.get(value));
+    }
+
+    public Optional<String> fromLowerCamelToLowerHyphen(String value){
+        return Optional.ofNullable(lowerCamelToLowerHyphen.get(value));
+    }
+
+}
diff --git a/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java
index f9b23080..2428a6dd 100644
--- a/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java
+++ b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java
@@ -62,14 +62,14 @@ public class NodeIngestor {
 
     private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(NodeIngestor.class);
     private static final Pattern classNamePattern = Pattern.compile("\\.(v\\d+)\\.");
-    Map<SchemaVersion, List<String>> filesToIngest;
-    private Map<SchemaVersion, DynamicJAXBContext> versionContextMap = new TreeMap<>();
-    private Map<SchemaVersion, Set<String>> typesPerVersion = new TreeMap<>();
-    private Map<SchemaVersion, Document> schemaPerVersion = new TreeMap<>();
+    private Map<SchemaVersion, DynamicJAXBContext> versionContextMap = new HashMap<>();
+    private Map<SchemaVersion, Set<String>> typesPerVersion = new HashMap<>();
+    private Map<SchemaVersion, Document> schemaPerVersion = new HashMap<>();
     private String localSchema;
     private SchemaVersions schemaVersions;
     private Set<Translator> translators;
-    
+
+    private CaseFormatStore caseFormatStore;
     //TODO : See if you can get rid of InputStream resets
 
     /**
@@ -80,6 +80,7 @@ public class NodeIngestor {
      @Autowired
     public NodeIngestor(Set<Translator> translatorSet) {
         this.translators = translatorSet;
+        this.caseFormatStore = new CaseFormatStore();
     }
 
     @PostConstruct
@@ -126,7 +127,7 @@ public class NodeIngestor {
 
                 final DynamicJAXBContext ctx = ingest(inputStreams);
                 versionContextMap.put(version, ctx);
-                typesPerVersion.put(version, getAllNodeTypes(inputStreams));
+                setAllTypesAndProperties(version, inputStreams);
                 schemaPerVersion.put(version, createCombinedSchema(inputStreams, version, retrieveLocalSchema));
             }
         } catch (JAXBException | ParserConfigurationException | SAXException | IOException e) {
@@ -150,8 +151,7 @@ public class NodeIngestor {
         return DynamicJAXBContextFactory.createContextFromOXM(this.getClass().getClassLoader(), properties);
     }
 
-    private Set<String> getAllNodeTypes(List<InputStream> inputStreams) throws ParserConfigurationException, SAXException, IOException {
-        //Reset the InputStream to reset the offset to inital position
+    private void setAllTypesAndProperties(SchemaVersion version, List<InputStream> inputStreams) throws ParserConfigurationException, IOException, SAXException {
         Set<String> types = new HashSet<>();
         final DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
         docFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
@@ -162,15 +162,20 @@ public class NodeIngestor {
             inputStream.reset();
             final Document doc = docBuilder.parse(inputStream);
             final NodeList list = doc.getElementsByTagName("java-type");
-
-            for (int i = 0; i < list.getLength(); i++) {
-                String type = list.item(i).getAttributes().getNamedItem("name").getNodeValue();
-                types.add(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, type));
-            }
+            getAllNodeTypes(list, types);
+            caseFormatStore.parse(doc);
         }
 
-        LOGGER.debug("Types size" + types.size());
-        return types;
+        LOGGER.debug("Types size {}", types.size());
+        typesPerVersion.put(version, types);
+    }
+
+    private void getAllNodeTypes(NodeList list, Set<String> types){
+
+        for (int i = 0; i < list.getLength(); i++) {
+            String type = list.item(i).getAttributes().getNamedItem("name").getNodeValue();
+            types.add(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, type));
+        }
     }
 
     private Document createCombinedSchema(List<InputStream> inputStreams, SchemaVersion version, boolean localSchema) throws ParserConfigurationException, SAXException, IOException {
@@ -272,4 +277,8 @@ public class NodeIngestor {
             "</xml-bindings>";
         return new ByteArrayInputStream(source.getBytes(StandardCharsets.UTF_8));
     }
+
+    public CaseFormatStore getCaseFormatStore(){
+        return caseFormatStore;
+    }
 }
diff --git a/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java b/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java
index a1a40e69..8143b5e1 100644
--- a/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java
+++ b/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java
@@ -21,20 +21,23 @@ package org.onap.aai.setup;
 
 import org.onap.aai.validation.AAISchemaValidationException;
 
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 public class SchemaVersion implements Comparable<SchemaVersion> {
 
-    public static final Pattern VERSION_PATTERN = Pattern.compile("v[1-9][0-9]*");
+    public static final Pattern VERSION_PATTERN = Pattern.compile("v([1-9][0-9]*)");
 
-    private final String value;
+    private final Integer value;
 
     public SchemaVersion(String value){
-        if(!VERSION_PATTERN.matcher(value).matches()){
+        Matcher matcher = VERSION_PATTERN.matcher(value);
+
+        if(!matcher.find()){
             throw new AAISchemaValidationException("Invalid Schema Version " + value + ", value doesn't match the expected regex: " + VERSION_PATTERN);
+        } else {
+            this.value = Integer.parseInt(matcher.group(1));
         }
-
-        this.value = value;
     }
 
     @Override
@@ -44,6 +47,7 @@ public class SchemaVersion implements Comparable<SchemaVersion> {
 
     @Override
     public boolean equals(Object other){
+
         if(this == other){
             return true;
         }
@@ -62,7 +66,7 @@ public class SchemaVersion implements Comparable<SchemaVersion> {
 
     @Override
     public String toString(){
-        return value;
+        return String.valueOf("v" + value);
     }
 
     @Override
@@ -72,12 +76,6 @@ public class SchemaVersion implements Comparable<SchemaVersion> {
             return -1;
         }
 
-        // Requires to convert to integer to match the past behavior
-        // Otherwise the string comparison of versions aren't working as expected
-
-        Integer tVal = Integer.parseInt(this.value.replaceAll("v", ""));
-        Integer oVal = Integer.parseInt(o.value.replaceAll("v", ""));
-
-        return tVal.compareTo(oVal);
+        return this.value.compareTo(o.value);
     }
 }