Merge "BUG 2509 : Removing all journal entries from a Followers in-memory journal...

[controller.git] / opendaylight / md-sal / sal-rest-connector / src / main / java / org / opendaylight / controller / sal / rest / impl / XmlToCompositeNodeReader.java

diff --git a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/rest/impl/XmlToCompositeNodeReader.java b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/rest/impl/XmlToCompositeNodeReader.java
index 7d0690cdc27e0a6754a354f187b88317e558720f..d71a12ff744c2b06b804a7d4a53487ec66739451 100644 (file)
--- a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/rest/impl/XmlToCompositeNodeReader.java
+++ b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/rest/impl/XmlToCompositeNodeReader.java
@@ -28,16 +28,20 @@ import org.opendaylight.controller.sal.restconf.impl.NodeWrapper;
 import org.opendaylight.controller.sal.restconf.impl.SimpleNodeWrapper;
 import org.opendaylight.yangtools.yang.data.api.Node;
 
+@Deprecated
 public class XmlToCompositeNodeReader {
 
     private final static XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
+    static {
+        xmlInputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", false);
+    }
     private XMLEventReader eventReader;
 
-    public CompositeNodeWrapper read(InputStream entityStream) throws XMLStreamException, UnsupportedFormatException,
-            IOException {
-        // Get an XML stream which can be marked, and reset, so we can check and
-        // see if there is
-        // any content being provided.
+    public Node<?> read(InputStream entityStream) throws XMLStreamException,
+                                                                      UnsupportedFormatException,
+                                                                      IOException {
+        //Get an XML stream which can be marked, and reset, so we can check and see if there is
+        //any content being provided.
         entityStream = getMarkableStream(entityStream);
 
         if (isInputStreamEmpty(entityStream)) {
@@ -45,7 +49,6 @@ public class XmlToCompositeNodeReader {
         }
 
         eventReader = xmlInputFactory.createXMLEventReader(entityStream);
-
         if (eventReader.hasNext()) {
             XMLEvent element = eventReader.peek();
             if (element.isStartDocument()) {
@@ -53,12 +56,8 @@ public class XmlToCompositeNodeReader {
             }
         }
 
-        if (eventReader.hasNext() && !isCompositeNodeEvent(eventReader.peek())) {
-            throw new UnsupportedFormatException("Root element of XML has to be composite element.");
-        }
-
         final Stack<NodeWrapper<?>> processingQueue = new Stack<>();
-        CompositeNodeWrapper root = null;
+        NodeWrapper<?> root = null;
         NodeWrapper<?> element = null;
         while (eventReader.hasNext()) {
             final XMLEvent event = eventReader.nextEvent();
@@ -71,17 +70,15 @@ public class XmlToCompositeNodeReader {
                 }
                 NodeWrapper<?> newNode = null;
                 if (isCompositeNodeEvent(event)) {
+                    newNode = resolveCompositeNodeFromStartElement(startElement);
                     if (root == null) {
-                        root = resolveCompositeNodeFromStartElement(startElement);
-                        newNode = root;
-                    } else {
-                        newNode = resolveCompositeNodeFromStartElement(startElement);
+                        root = newNode;
                     }
                 } else if (isSimpleNodeEvent(event)) {
+                    newNode = resolveSimpleNodeFromStartElement(startElement);
                     if (root == null) {
-                        throw new UnsupportedFormatException("Root element of XML has to be composite element.");
+                        root = newNode;
                     }
-                    newNode = resolveSimpleNodeFromStartElement(startElement);
                 }
 
                 if (newNode != null) {
@@ -99,13 +96,12 @@ public class XmlToCompositeNodeReader {
             throw new UnsupportedFormatException("XML should contain only one root element");
         }
 
-        return root;
+        return (Node<?>) root;
     }
 
     /**
-     * If the input stream is not markable, then it wraps the input stream with
-     * a buffered stream, which is mark able. That way we can check if the
-     * stream is empty safely.
+     * If the input stream is not markable, then it wraps the input stream with a buffered stream, which is mark able.
+     * That way we can check if the stream is empty safely.
      *
      * @param entityStream
      * @return
@@ -117,7 +113,7 @@ public class XmlToCompositeNodeReader {
         return entityStream;
     }
 
-    private boolean isInputStreamEmpty(InputStream entityStream) throws IOException {
+    private boolean isInputStreamEmpty(final InputStream entityStream) throws IOException {
         boolean isEmpty = false;
         entityStream.mark(1);
         if (entityStream.read() == -1) {
@@ -187,7 +183,7 @@ public class XmlToCompositeNodeReader {
                 resolveValueOfElement(data, startElement));
     }
 
-    private String getValueOf(StartElement startElement) throws XMLStreamException {
+    private String getValueOf(final StartElement startElement) throws XMLStreamException {
         String data = null;
         if (eventReader.hasNext()) {
             final XMLEvent innerEvent = eventReader.peek();
@@ -208,7 +204,7 @@ public class XmlToCompositeNodeReader {
         return data == null ? null : data.trim();
     }
 
-    private String getAdditionalData(XMLEvent event) throws XMLStreamException {
+    private String getAdditionalData(final XMLEvent event) throws XMLStreamException {
         String data = "";
         if (eventReader.hasNext()) {
             final XMLEvent innerEvent = eventReader.peek();
@@ -223,16 +219,16 @@ public class XmlToCompositeNodeReader {
         return data;
     }
 
-    private String getLocalNameFor(StartElement startElement) {
+    private String getLocalNameFor(final StartElement startElement) {
         return startElement.getName().getLocalPart();
     }
 
-    private URI getNamespaceFor(StartElement startElement) {
+    private URI getNamespaceFor(final StartElement startElement) {
         String namespaceURI = startElement.getName().getNamespaceURI();
         return namespaceURI.isEmpty() ? null : URI.create(namespaceURI);
     }
 
-    private Object resolveValueOfElement(String value, StartElement startElement) {
+    private Object resolveValueOfElement(final String value, final StartElement startElement) {
         // it could be instance-identifier Built-In Type
         if (value.startsWith("/")) {
             IdentityValuesDTO iiValue = RestUtil.asInstanceIdentifier(value, new RestUtil.PrefixMapingFromXml(