X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=restconf%2Frestconf-nb-bierman02%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fnetconf%2Fsal%2Frest%2Fimpl%2FRestconfDocumentedExceptionMapper.java;h=1803a4b3ba20bedb649d3e1c6e5f6ac016db1309;hb=07315276858f9eeff0760b14ca87a25dc81041ed;hp=3828abd6a70a20bb1e4114553473bc8caee9f2ec;hpb=956285fc6f3ffeabd828f164700e7f997eda2faa;p=netconf.git

diff --git a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java
index 3828abd6a7..1803a4b3ba 100644
--- a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java
+++ b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java
@@ -5,18 +5,17 @@
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-
 package org.opendaylight.netconf.sal.rest.impl;
 
-import com.google.common.base.Preconditions;
-import com.google.common.base.Throwables;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.collect.Iterables;
 import com.google.gson.stream.JsonWriter;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
-import java.io.UnsupportedEncodingException;
-import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
@@ -24,6 +23,7 @@ import javax.ws.rs.core.Context;
 import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
 import javax.ws.rs.ext.ExceptionMapper;
 import javax.ws.rs.ext.Provider;
 import javax.xml.XMLConstants;
@@ -33,19 +33,21 @@ import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamWriter;
 import org.opendaylight.netconf.sal.rest.api.Draft02;
 import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
+import org.opendaylight.restconf.common.ErrorTags;
 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
-import org.opendaylight.restconf.common.context.NormalizedNodeContext;
 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
 import org.opendaylight.restconf.common.errors.RestconfError;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.ForwardingNormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
@@ -53,10 +55,8 @@ import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
 import org.opendaylight.yangtools.yang.data.codec.gson.JSONNormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.codec.gson.JsonWriterFactory;
 import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.SchemaAwareBuilders;
 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
@@ -91,7 +91,7 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
     private final ControllerContext controllerContext;
 
     public RestconfDocumentedExceptionMapper(final ControllerContext controllerContext) {
-        this.controllerContext = Preconditions.checkNotNull(controllerContext);
+        this.controllerContext = requireNonNull(controllerContext);
     }
 
     @Override
@@ -119,26 +119,22 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
             return Response.status(exception.getStatus()).type(MediaType.TEXT_PLAIN_TYPE).entity(" ").build();
         }
 
-        final int status = errors.iterator().next().getErrorTag().getStatusCode();
-
+        final Status status = ErrorTags.statusOf(errors.iterator().next().getErrorTag());
         final DataNodeContainer errorsSchemaNode =
                 (DataNodeContainer) controllerContext.getRestconfModuleErrorsSchemaNode();
-
         if (errorsSchemaNode == null) {
             return Response.status(status).type(MediaType.TEXT_PLAIN_TYPE).entity(exception.getMessage()).build();
         }
 
-        Preconditions.checkState(errorsSchemaNode instanceof ContainerSchemaNode,
-                "Found Errors SchemaNode isn't ContainerNode");
-        final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> errContBuild =
-                Builders.containerBuilder((ContainerSchemaNode) errorsSchemaNode);
+        checkState(errorsSchemaNode instanceof ContainerSchemaNode, "Found Errors SchemaNode isn't ContainerNode");
+        final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> errContBuild =
+                SchemaAwareBuilders.containerBuilder((ContainerSchemaNode) errorsSchemaNode);
 
         final List<DataSchemaNode> schemaList = ControllerContext.findInstanceDataChildrenByName(errorsSchemaNode,
                 Draft02.RestConfModule.ERROR_LIST_SCHEMA_NODE);
         final DataSchemaNode errListSchemaNode = Iterables.getFirst(schemaList, null);
-        Preconditions.checkState(
-                errListSchemaNode instanceof ListSchemaNode, "Found Error SchemaNode isn't ListSchemaNode");
-        final CollectionNodeBuilder<MapEntryNode, MapNode> listErorsBuilder = Builders
+        checkState(errListSchemaNode instanceof ListSchemaNode, "Found Error SchemaNode isn't ListSchemaNode");
+        final CollectionNodeBuilder<MapEntryNode, SystemMapNode> listErorsBuilder = SchemaAwareBuilders
                 .mapBuilder((ListSchemaNode) errListSchemaNode);
 
 
@@ -147,8 +143,8 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
         }
         errContBuild.withChild(listErorsBuilder.build());
 
-        final NormalizedNodeContext errContext =  new NormalizedNodeContext(new InstanceIdentifierContext<>(null,
-                (DataSchemaNode) errorsSchemaNode, null, controllerContext.getGlobalSchema()), errContBuild.build());
+        final NormalizedNodeContext errContext = new NormalizedNodeContext(InstanceIdentifierContext.ofDataSchemaNode(
+            controllerContext.getGlobalSchema(), (DataSchemaNode) errorsSchemaNode), errContBuild.build());
 
         Object responseBody;
         if (mediaType.getSubtype().endsWith("json")) {
@@ -161,40 +157,40 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
     }
 
     private static MapEntryNode toErrorEntryNode(final RestconfError error, final DataSchemaNode errListSchemaNode) {
-        Preconditions.checkArgument(errListSchemaNode instanceof ListSchemaNode,
+        checkArgument(errListSchemaNode instanceof ListSchemaNode,
                 "errListSchemaNode has to be of type ListSchemaNode");
         final ListSchemaNode listStreamSchemaNode = (ListSchemaNode) errListSchemaNode;
-        final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> errNodeValues = Builders
+        final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> errNodeValues = SchemaAwareBuilders
                 .mapEntryBuilder(listStreamSchemaNode);
 
         List<DataSchemaNode> lsChildDataSchemaNode = ControllerContext.findInstanceDataChildrenByName(
                 listStreamSchemaNode, "error-type");
         final DataSchemaNode errTypSchemaNode = Iterables.getFirst(lsChildDataSchemaNode, null);
-        Preconditions.checkState(errTypSchemaNode instanceof LeafSchemaNode);
-        errNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) errTypSchemaNode)
-                .withValue(error.getErrorType().getErrorTypeTag()).build());
+        checkState(errTypSchemaNode instanceof LeafSchemaNode);
+        errNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) errTypSchemaNode)
+                .withValue(error.getErrorType().elementBody()).build());
 
         lsChildDataSchemaNode = ControllerContext.findInstanceDataChildrenByName(
                 listStreamSchemaNode, "error-tag");
         final DataSchemaNode errTagSchemaNode = Iterables.getFirst(lsChildDataSchemaNode, null);
-        Preconditions.checkState(errTagSchemaNode instanceof LeafSchemaNode);
-        errNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) errTagSchemaNode)
-                .withValue(error.getErrorTag().getTagValue()).build());
+        checkState(errTagSchemaNode instanceof LeafSchemaNode);
+        errNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) errTagSchemaNode)
+                .withValue(error.getErrorTag().elementBody()).build());
 
         if (error.getErrorAppTag() != null) {
             lsChildDataSchemaNode = ControllerContext.findInstanceDataChildrenByName(
                     listStreamSchemaNode, "error-app-tag");
             final DataSchemaNode errAppTagSchemaNode = Iterables.getFirst(lsChildDataSchemaNode, null);
-            Preconditions.checkState(errAppTagSchemaNode instanceof LeafSchemaNode);
-            errNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) errAppTagSchemaNode)
+            checkState(errAppTagSchemaNode instanceof LeafSchemaNode);
+            errNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) errAppTagSchemaNode)
                     .withValue(error.getErrorAppTag()).build());
         }
 
         lsChildDataSchemaNode = ControllerContext.findInstanceDataChildrenByName(
                 listStreamSchemaNode, "error-message");
         final DataSchemaNode errMsgSchemaNode = Iterables.getFirst(lsChildDataSchemaNode, null);
-        Preconditions.checkState(errMsgSchemaNode instanceof LeafSchemaNode);
-        errNodeValues.withChild(Builders.leafBuilder((LeafSchemaNode) errMsgSchemaNode)
+        checkState(errMsgSchemaNode instanceof LeafSchemaNode);
+        errNodeValues.withChild(SchemaAwareBuilders.leafBuilder((LeafSchemaNode) errMsgSchemaNode)
                 .withValue(error.getErrorMessage()).build());
 
         if (error.getErrorInfo() != null) {
@@ -213,8 +209,8 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
     private static Object toJsonResponseBody(final NormalizedNodeContext errorsNode,
                                              final DataNodeContainer errorsSchemaNode) {
         final ByteArrayOutputStream outStream = new ByteArrayOutputStream();
-        NormalizedNode<?, ?> data = errorsNode.getData();
-        final InstanceIdentifierContext<?> context = errorsNode.getInstanceIdentifierContext();
+        NormalizedNode data = errorsNode.getData();
+        final InstanceIdentifierContext context = errorsNode.getInstanceIdentifierContext();
         final DataSchemaNode schema = (DataSchemaNode) context.getSchemaNode();
 
         SchemaPath path = context.getSchemaNode().getPath();
@@ -224,7 +220,7 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
         }
 
         boolean isDataRoot = false;
-        URI initialNs = null;
+        XMLNamespace initialNs = null;
         if (SchemaPath.ROOT.equals(path)) {
             isDataRoot = true;
         } else {
@@ -246,18 +242,38 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
         // the schema has a ContainerSchemaNode so, to avoid an error, we override the leafNode behavior
         // for error-info.
         final NormalizedNodeStreamWriter streamWriter = new ForwardingNormalizedNodeStreamWriter() {
+            private boolean inOurLeaf;
+
             @Override
             protected NormalizedNodeStreamWriter delegate() {
                 return jsonStreamWriter;
             }
 
             @Override
-            public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
+            public void startLeafNode(final NodeIdentifier name) throws IOException {
                 if (name.getNodeType().equals(Draft02.RestConfModule.ERROR_INFO_QNAME)) {
+                    inOurLeaf = true;
                     jsonWriter.name(Draft02.RestConfModule.ERROR_INFO_QNAME.getLocalName());
+                } else {
+                    super.startLeafNode(name);
+                }
+            }
+
+            @Override
+            public void scalarValue(final Object value) throws IOException {
+                if (inOurLeaf) {
                     jsonWriter.value(value.toString());
                 } else {
-                    super.leafNode(name, value);
+                    super.scalarValue(value);
+                }
+            }
+
+            @Override
+            public void endNode() throws IOException {
+                if (inOurLeaf) {
+                    inOurLeaf = false;
+                } else {
+                    super.endNode();
                 }
             }
         };
@@ -268,7 +284,9 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
                 writeDataRoot(outputWriter,nnWriter,(ContainerNode) data);
             } else {
                 if (data instanceof MapEntryNode) {
-                    data = ImmutableNodes.mapNodeBuilder(data.getNodeType()).withChild((MapEntryNode) data).build();
+                    data = ImmutableNodes.mapNodeBuilder(data.getIdentifier().getNodeType())
+                        .withChild((MapEntryNode) data)
+                        .build();
                 }
                 nnWriter.write(data);
             }
@@ -279,27 +297,26 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
         }
 
         try {
-            return outStream.toString(StandardCharsets.UTF_8.name());
-        } catch (UnsupportedEncodingException e) {
-            // Shouldn't happen
-            return "Failure encoding error response: " + e;
+            streamWriter.close();
+        } catch (IOException e) {
+            LOG.warn("Failed to close stream writer", e);
         }
+
+        return outStream.toString(StandardCharsets.UTF_8);
     }
 
     private static Object toXMLResponseBody(final NormalizedNodeContext errorsNode,
                                             final DataNodeContainer errorsSchemaNode) {
-        final InstanceIdentifierContext<?> pathContext = errorsNode.getInstanceIdentifierContext();
+        final InstanceIdentifierContext pathContext = errorsNode.getInstanceIdentifierContext();
         final ByteArrayOutputStream outStream = new ByteArrayOutputStream();
 
         final XMLStreamWriter xmlWriter;
         try {
             xmlWriter = XML_FACTORY.createXMLStreamWriter(outStream, StandardCharsets.UTF_8.name());
-        } catch (final XMLStreamException e) {
-            throw new IllegalStateException(e);
-        } catch (final FactoryConfigurationError e) {
+        } catch (final XMLStreamException | FactoryConfigurationError e) {
             throw new IllegalStateException(e);
         }
-        NormalizedNode<?, ?> data = errorsNode.getData();
+        NormalizedNode data = errorsNode.getData();
         SchemaPath schemaPath = pathContext.getSchemaNode().getPath();
 
         boolean isDataRoot = false;
@@ -318,25 +335,53 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
         // the schema has a ContainerSchemaNode so, to avoid an error, we override the leafNode behavior
         // for error-info.
         final NormalizedNodeStreamWriter streamWriter = new ForwardingNormalizedNodeStreamWriter() {
+            private boolean inOurLeaf;
+
             @Override
             protected NormalizedNodeStreamWriter delegate() {
                 return xmlStreamWriter;
             }
 
             @Override
-            public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
+            public void startLeafNode(final NodeIdentifier name) throws IOException {
                 if (name.getNodeType().equals(Draft02.RestConfModule.ERROR_INFO_QNAME)) {
                     String ns = Draft02.RestConfModule.ERROR_INFO_QNAME.getNamespace().toString();
                     try {
                         xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX,
                                 Draft02.RestConfModule.ERROR_INFO_QNAME.getLocalName(), ns);
+                    } catch (XMLStreamException e) {
+                        throw new IOException("Error writing error-info", e);
+                    }
+                    inOurLeaf = true;
+                } else {
+                    super.startLeafNode(name);
+                }
+            }
+
+            @Override
+            public void scalarValue(final Object value) throws IOException {
+                if (inOurLeaf) {
+                    try {
                         xmlWriter.writeCharacters(value.toString());
+                    } catch (XMLStreamException e) {
+                        throw new IOException("Error writing error-info", e);
+                    }
+                } else {
+                    super.scalarValue(value);
+                }
+            }
+
+            @Override
+            public void endNode() throws IOException {
+                if (inOurLeaf) {
+                    try {
                         xmlWriter.writeEndElement();
                     } catch (XMLStreamException e) {
                         throw new IOException("Error writing error-info", e);
                     }
+                    inOurLeaf = false;
                 } else {
-                    super.leafNode(name, value);
+                    super.endNode();
                 }
             }
         };
@@ -349,7 +394,9 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
                 if (data instanceof MapEntryNode) {
                     // Restconf allows returning one list item. We need to wrap it
                     // in map node in order to serialize it properly
-                    data = ImmutableNodes.mapNodeBuilder(data.getNodeType()).addChild((MapEntryNode) data).build();
+                    data = ImmutableNodes.mapNodeBuilder(data.getIdentifier().getNodeType())
+                        .addChild((MapEntryNode) data)
+                        .build();
                 }
                 nnWriter.write(data);
                 nnWriter.flush();
@@ -358,34 +405,28 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper<Restco
             LOG.warn("Error writing error response body.", e);
         }
 
-        try {
-            return outStream.toString(StandardCharsets.UTF_8.name());
-        } catch (UnsupportedEncodingException e) {
-            // Shouldn't happen
-            return "Failure encoding error response: " + e;
-        }
+        return outStream.toString(StandardCharsets.UTF_8);
     }
 
     private static void writeRootElement(final XMLStreamWriter xmlWriter, final NormalizedNodeWriter nnWriter,
-                                         final ContainerNode data)
-            throws IOException {
+                                         final ContainerNode data) throws IOException {
+        final QName name = SchemaContext.NAME;
         try {
-            final QName name = SchemaContext.NAME;
             xmlWriter.writeStartElement(name.getNamespace().toString(), name.getLocalName());
-            for (final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) {
+            for (final DataContainerChild child : data.body()) {
                 nnWriter.write(child);
             }
             nnWriter.flush();
             xmlWriter.writeEndElement();
             xmlWriter.flush();
         } catch (final XMLStreamException e) {
-            Throwables.propagate(e);
+            throw new IOException("Failed to write elements", e);
         }
     }
 
     private static void writeDataRoot(final OutputStreamWriter outputWriter, final NormalizedNodeWriter nnWriter,
                                       final ContainerNode data) throws IOException {
-        for (final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) {
+        for (final DataContainerChild child : data.body()) {
             nnWriter.write(child);
             nnWriter.flush();
         }