restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.restconf.nb.rfc8040.jersey.providers;
   9
  10 import static com.google.common.base.Preconditions.checkState;
  11
  12 import java.io.IOException;
  13 import java.io.InputStream;
  14 import java.net.URISyntaxException;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17 import javax.ws.rs.Consumes;
  18 import javax.ws.rs.WebApplicationException;
  19 import javax.ws.rs.core.MediaType;
  20 import javax.ws.rs.ext.Provider;
  21 import javax.xml.stream.XMLStreamException;
  22 import javax.xml.transform.dom.DOMSource;
  23 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
  24 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
  25 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
  26 import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
  27 import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
  28 import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
  29 import org.opendaylight.yangtools.util.xml.UntrustedXML;
  30 import org.opendaylight.yangtools.yang.common.ErrorTag;
  31 import org.opendaylight.yangtools.yang.common.ErrorType;
  32 import org.opendaylight.yangtools.yang.common.QName;
  33 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  35 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  36 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  37 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  38 import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
  39 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  40 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  41 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
  42 import org.opendaylight.yangtools.yang.model.api.ContainerLike;
  43 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  44 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  45 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  46 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
  47 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  48 import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
  49 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52 import org.w3c.dom.Document;
  53 import org.xml.sax.SAXException;
  54
  55 @Provider
  56 @Consumes({ MediaTypes.APPLICATION_YANG_DATA_XML, MediaType.APPLICATION_XML, MediaType.TEXT_XML })
  57 public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReader {
  58     private static final Logger LOG = LoggerFactory.getLogger(XmlNormalizedNodeBodyReader.class);
  59
  60     public XmlNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler,
  61             final DOMMountPointService mountPointService) {
  62         super(schemaContextHandler, mountPointService);
  63     }
  64
  65     @SuppressWarnings("checkstyle:IllegalCatch")
  66     @Override
  67     protected NormalizedNodePayload readBody(final InstanceIdentifierContext path, final InputStream entityStream)
  68             throws WebApplicationException {
  69         try {
  70             final Document doc = UntrustedXML.newDocumentBuilder().parse(entityStream);
  71             return parse(path, doc);
  72         } catch (final RestconfDocumentedException e) {
  73             throw e;
  74         } catch (final Exception e) {
  75             LOG.debug("Error parsing xml input", e);
  76             RestconfDocumentedException.throwIfYangError(e);
  77             throw new RestconfDocumentedException("Error parsing input: " + e.getMessage(), ErrorType.PROTOCOL,
  78                     ErrorTag.MALFORMED_MESSAGE, e);
  79         }
  80     }
  81
  82     private NormalizedNodePayload parse(final InstanceIdentifierContext pathContext, final Document doc)
  83             throws XMLStreamException, IOException, SAXException, URISyntaxException {
  84         final SchemaNode schemaNodeContext = pathContext.getSchemaNode();
  85         DataSchemaNode schemaNode;
  86         final List<PathArgument> iiToDataList = new ArrayList<>();
  87         Inference inference;
  88         if (schemaNodeContext instanceof OperationDefinition) {
  89             schemaNode = ((OperationDefinition) schemaNodeContext).getInput();
  90
  91             final var stack = pathContext.inference().toSchemaInferenceStack();
  92             stack.enterSchemaTree(schemaNode.getQName());
  93             inference = stack.toInference();
  94         } else if (schemaNodeContext instanceof DataSchemaNode) {
  95             schemaNode = (DataSchemaNode) schemaNodeContext;
  96
  97             final String docRootElm = doc.getDocumentElement().getLocalName();
  98             final XMLNamespace docRootNamespace = XMLNamespace.of(doc.getDocumentElement().getNamespaceURI());
  99             if (isPost()) {
 100                 final var context = pathContext.getSchemaContext();
 101                 final var it = context.findModuleStatements(docRootNamespace).iterator();
 102                 checkState(it.hasNext(), "Failed to find module for %s", docRootNamespace);
 103                 final var qname = QName.create(it.next().localQNameModule(), docRootElm);
 104
 105                 final var nodeAndStack = DataSchemaContextTree.from(context)
 106                     .enterPath(pathContext.getInstanceIdentifier()).orElseThrow();
 107
 108                 final var stack = nodeAndStack.stack();
 109                 var current = nodeAndStack.node();
 110                 do {
 111                     final var next = current.enterChild(stack, qname);
 112                     checkState(next != null, "Child \"%s\" was not found in parent schema node \"%s\"", qname,
 113                         schemaNode);
 114                     iiToDataList.add(next.getIdentifier());
 115                     schemaNode = next.getDataSchemaNode();
 116                     current = next;
 117                 } while (current.isMixin());
 118
 119                 // We need to unwind the last identifier if it a NodeIdentifierWithPredicates, as it does not have
 120                 // any predicates at all. The real identifier is then added below
 121                 if (stack.currentStatement() instanceof ListEffectiveStatement) {
 122                     iiToDataList.remove(iiToDataList.size() - 1);
 123                 }
 124
 125                 inference = stack.toInference();
 126             } else {
 127                 // PUT
 128                 final QName scQName = schemaNode.getQName();
 129                 checkState(docRootElm.equals(scQName.getLocalName()) && docRootNamespace.equals(scQName.getNamespace()),
 130                     "Not correct message root element \"%s\", should be \"%s\"", docRootElm, scQName);
 131                 inference = pathContext.inference();
 132             }
 133         } else {
 134             throw new IllegalStateException("Unknown SchemaNode " + schemaNodeContext);
 135         }
 136
 137
 138         NormalizedNode parsed;
 139         final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
 140         final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
 141
 142         if (schemaNode instanceof ContainerLike || schemaNode instanceof ListSchemaNode
 143                 || schemaNode instanceof LeafSchemaNode) {
 144             final XmlParserStream xmlParser = XmlParserStream.create(writer, inference);
 145             xmlParser.traverse(new DOMSource(doc.getDocumentElement()));
 146             parsed = resultHolder.getResult();
 147
 148             // When parsing an XML source with a list root node
 149             // the new XML parser always returns a MapNode with one MapEntryNode inside.
 150             // However, the old XML parser returned a MapEntryNode directly in this place.
 151             // Therefore we now have to extract the MapEntryNode from the parsed MapNode.
 152             if (parsed instanceof MapNode) {
 153                 final MapNode mapNode = (MapNode) parsed;
 154                 // extracting the MapEntryNode
 155                 parsed = mapNode.body().iterator().next();
 156             }
 157
 158             if (schemaNode instanceof ListSchemaNode && isPost()) {
 159                 iiToDataList.add(parsed.getIdentifier());
 160             }
 161         } else {
 162             LOG.warn("Unknown schema node extension {} was not parsed", schemaNode.getClass());
 163             parsed = null;
 164         }
 165
 166         // FIXME: can result really be null?
 167         return NormalizedNodePayload.ofNullable(pathContext.withConcatenatedArgs(iiToDataList), parsed);
 168     }
 169 }
 170