yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JsonParserStream.java

   1 /*
   2  * Copyright (c) 2014 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.yangtools.yang.data.codec.gson;
   9
  10 import com.google.common.annotations.Beta;
  11 import com.google.common.base.Preconditions;
  12 import com.google.gson.JsonIOException;
  13 import com.google.gson.JsonParseException;
  14 import com.google.gson.JsonSyntaxException;
  15 import com.google.gson.stream.JsonReader;
  16 import com.google.gson.stream.MalformedJsonException;
  17 import java.io.Closeable;
  18 import java.io.EOFException;
  19 import java.io.Flushable;
  20 import java.io.IOException;
  21 import java.net.URI;
  22 import java.util.ArrayDeque;
  23 import java.util.Collections;
  24 import java.util.Deque;
  25 import java.util.HashSet;
  26 import java.util.Set;
  27 import javax.xml.transform.dom.DOMSource;
  28 import org.opendaylight.yangtools.util.xml.UntrustedXML;
  29 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  30 import org.opendaylight.yangtools.yang.data.util.AbstractNodeDataWithSchema;
  31 import org.opendaylight.yangtools.yang.data.util.AnyXmlNodeDataWithSchema;
  32 import org.opendaylight.yangtools.yang.data.util.CompositeNodeDataWithSchema;
  33 import org.opendaylight.yangtools.yang.data.util.LeafListEntryNodeDataWithSchema;
  34 import org.opendaylight.yangtools.yang.data.util.LeafListNodeDataWithSchema;
  35 import org.opendaylight.yangtools.yang.data.util.LeafNodeDataWithSchema;
  36 import org.opendaylight.yangtools.yang.data.util.ListEntryNodeDataWithSchema;
  37 import org.opendaylight.yangtools.yang.data.util.ListNodeDataWithSchema;
  38 import org.opendaylight.yangtools.yang.data.util.ParserStreamUtils;
  39 import org.opendaylight.yangtools.yang.data.util.RpcAsContainer;
  40 import org.opendaylight.yangtools.yang.data.util.SimpleNodeDataWithSchema;
  41 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  42 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  43 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  44 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  45 import org.opendaylight.yangtools.yang.model.api.Module;
  46 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  47 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  48 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  49 import org.opendaylight.yangtools.yang.model.api.TypedSchemaNode;
  50 import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
  51 import org.w3c.dom.Document;
  52 import org.w3c.dom.Element;
  53 import org.w3c.dom.Text;
  54
  55 /**
  56  * This class parses JSON elements from a GSON JsonReader. It disallows multiple elements of the same name unlike the
  57  * default GSON JsonParser.
  58  */
  59 @Beta
  60 public final class JsonParserStream implements Closeable, Flushable {
  61     static final String ANYXML_ARRAY_ELEMENT_ID = "array-element";
  62
  63     private final Deque<URI> namespaces = new ArrayDeque<>();
  64     private final NormalizedNodeStreamWriter writer;
  65     private final JSONCodecFactory codecs;
  66     private final SchemaContext schema;
  67     private final DataSchemaNode parentNode;
  68
  69     private JsonParserStream(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
  70             final DataSchemaNode parentNode) {
  71         this.schema = Preconditions.checkNotNull(schemaContext);
  72         this.writer = Preconditions.checkNotNull(writer);
  73         this.codecs = JSONCodecFactory.create(schemaContext);
  74         this.parentNode = parentNode;
  75     }
  76
  77     public static JsonParserStream create(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
  78             final SchemaNode parentNode ) {
  79         if (parentNode instanceof RpcDefinition) {
  80             return new JsonParserStream(writer, schemaContext, new RpcAsContainer((RpcDefinition) parentNode));
  81         }
  82         Preconditions.checkArgument(parentNode instanceof DataSchemaNode, "Instance of DataSchemaNode class awaited.");
  83         return new JsonParserStream(writer, schemaContext, (DataSchemaNode) parentNode);
  84     }
  85
  86     public static JsonParserStream create(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext) {
  87         return new JsonParserStream(writer, schemaContext, schemaContext);
  88     }
  89
  90     public JsonParserStream parse(final JsonReader reader) {
  91         // code copied from gson's JsonParser and Stream classes
  92
  93         final boolean lenient = reader.isLenient();
  94         reader.setLenient(true);
  95         boolean isEmpty = true;
  96         try {
  97             reader.peek();
  98             isEmpty = false;
  99             final CompositeNodeDataWithSchema compositeNodeDataWithSchema = new CompositeNodeDataWithSchema(parentNode);
 100             read(reader, compositeNodeDataWithSchema);
 101             compositeNodeDataWithSchema.write(writer);
 102
 103             return this;
 104         } catch (final EOFException e) {
 105             if (isEmpty) {
 106                 return this;
 107             }
 108             // The stream ended prematurely so it is likely a syntax error.
 109             throw new JsonSyntaxException(e);
 110         } catch (final MalformedJsonException | NumberFormatException e) {
 111             throw new JsonSyntaxException(e);
 112         } catch (final IOException e) {
 113             throw new JsonIOException(e);
 114         } catch (StackOverflowError | OutOfMemoryError e) {
 115             throw new JsonParseException("Failed parsing JSON source: " + reader + " to Json", e);
 116         } finally {
 117             reader.setLenient(lenient);
 118         }
 119     }
 120
 121     private void traverseAnyXmlValue(final JsonReader in, final Document doc, final Element parentElement)
 122             throws IOException {
 123         switch (in.peek()) {
 124             case STRING:
 125             case NUMBER:
 126                 Text textNode = doc.createTextNode(in.nextString());
 127                 parentElement.appendChild(textNode);
 128                 break;
 129             case BOOLEAN:
 130                 textNode = doc.createTextNode(Boolean.toString(in.nextBoolean()));
 131                 parentElement.appendChild(textNode);
 132                 break;
 133             case NULL:
 134                 in.nextNull();
 135                 textNode = doc.createTextNode("null");
 136                 parentElement.appendChild(textNode);
 137                 break;
 138             case BEGIN_ARRAY:
 139                 in.beginArray();
 140                 while (in.hasNext()) {
 141                     final Element childElement = doc.createElement(ANYXML_ARRAY_ELEMENT_ID);
 142                     parentElement.appendChild(childElement);
 143                     traverseAnyXmlValue(in, doc, childElement);
 144                 }
 145                 in.endArray();
 146                 break;
 147             case BEGIN_OBJECT:
 148                 in.beginObject();
 149                 while (in.hasNext()) {
 150                     final Element childElement = doc.createElement(in.nextName());
 151                     parentElement.appendChild(childElement);
 152                     traverseAnyXmlValue(in, doc, childElement);
 153                 }
 154                 in.endObject();
 155             case END_DOCUMENT:
 156             case NAME:
 157             case END_OBJECT:
 158             case END_ARRAY:
 159                 break;
 160         }
 161     }
 162
 163     private void readAnyXmlValue(final JsonReader in, final AnyXmlNodeDataWithSchema parent,
 164             final String anyXmlObjectName) throws IOException {
 165         final String anyXmlObjectNS = getCurrentNamespace().toString();
 166         final Document doc = UntrustedXML.newDocumentBuilder().newDocument();
 167         final Element rootElement = doc.createElementNS(anyXmlObjectNS, anyXmlObjectName);
 168         doc.appendChild(rootElement);
 169         traverseAnyXmlValue(in, doc, rootElement);
 170
 171         final DOMSource domSource = new DOMSource(doc.getDocumentElement());
 172         parent.setValue(domSource);
 173     }
 174
 175     public void read(final JsonReader in, AbstractNodeDataWithSchema parent) throws IOException {
 176         switch (in.peek()) {
 177         case STRING:
 178         case NUMBER:
 179             setValue(parent, in.nextString());
 180             break;
 181         case BOOLEAN:
 182             setValue(parent, Boolean.toString(in.nextBoolean()));
 183             break;
 184         case NULL:
 185             in.nextNull();
 186             setValue(parent, null);
 187             break;
 188         case BEGIN_ARRAY:
 189             in.beginArray();
 190             while (in.hasNext()) {
 191                 if (parent instanceof LeafNodeDataWithSchema) {
 192                     read(in, parent);
 193                 } else {
 194                     final AbstractNodeDataWithSchema newChild = newArrayEntry(parent);
 195                     read(in, newChild);
 196                 }
 197             }
 198             in.endArray();
 199             return;
 200         case BEGIN_OBJECT:
 201             final Set<String> namesakes = new HashSet<>();
 202             in.beginObject();
 203             /*
 204              * This allows parsing of incorrectly /as showcased/
 205              * in testconf nesting of list items - eg.
 206              * lists with one value are sometimes serialized
 207              * without wrapping array.
 208              *
 209              */
 210             if (isArray(parent)) {
 211                 parent = newArrayEntry(parent);
 212             }
 213             while (in.hasNext()) {
 214                 final String jsonElementName = in.nextName();
 215                 DataSchemaNode parentSchema = parent.getSchema();
 216                 if (parentSchema instanceof YangModeledAnyXmlSchemaNode) {
 217                     parentSchema = ((YangModeledAnyXmlSchemaNode) parentSchema).getSchemaOfAnyXmlData();
 218                 }
 219                 final NamespaceAndName namespaceAndName = resolveNamespace(jsonElementName, parentSchema);
 220                 final String localName = namespaceAndName.getName();
 221                 addNamespace(namespaceAndName.getUri());
 222                 if (namesakes.contains(jsonElementName)) {
 223                     throw new JsonSyntaxException("Duplicate name " + jsonElementName + " in JSON input.");
 224                 }
 225                 namesakes.add(jsonElementName);
 226
 227                 final Deque<DataSchemaNode> childDataSchemaNodes =
 228                         ParserStreamUtils.findSchemaNodeByNameAndNamespace(parentSchema, localName, getCurrentNamespace());
 229                 if (childDataSchemaNodes.isEmpty()) {
 230                     throw new IllegalStateException("Schema for node with name " + localName + " and namespace "
 231                             + getCurrentNamespace() + " doesn't exist.");
 232                 }
 233
 234                 final AbstractNodeDataWithSchema newChild = ((CompositeNodeDataWithSchema) parent).addChild(childDataSchemaNodes);
 235                 if (newChild instanceof AnyXmlNodeDataWithSchema) {
 236                     readAnyXmlValue(in, (AnyXmlNodeDataWithSchema) newChild, jsonElementName);
 237                 } else {
 238                     read(in, newChild);
 239                 }
 240                 removeNamespace();
 241             }
 242             in.endObject();
 243             return;
 244         case END_DOCUMENT:
 245         case NAME:
 246         case END_OBJECT:
 247         case END_ARRAY:
 248             break;
 249         }
 250     }
 251
 252     private static boolean isArray(final AbstractNodeDataWithSchema parent) {
 253         return parent instanceof ListNodeDataWithSchema || parent instanceof LeafListNodeDataWithSchema;
 254     }
 255
 256     private static AbstractNodeDataWithSchema newArrayEntry(final AbstractNodeDataWithSchema parent) {
 257         AbstractNodeDataWithSchema newChild;
 258         if (parent instanceof ListNodeDataWithSchema) {
 259             newChild = new ListEntryNodeDataWithSchema(parent.getSchema());
 260         } else if (parent instanceof LeafListNodeDataWithSchema) {
 261             newChild = new LeafListEntryNodeDataWithSchema(parent.getSchema());
 262         } else {
 263             throw new IllegalStateException("Found an unexpected array nested under "+ parent.getSchema().getQName());
 264         }
 265         ((CompositeNodeDataWithSchema) parent).addChild(newChild);
 266         return newChild;
 267     }
 268
 269     private void setValue(final AbstractNodeDataWithSchema parent, final String value) {
 270         Preconditions.checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
 271                 parent.getSchema().getQName());
 272         final SimpleNodeDataWithSchema parentSimpleNode = (SimpleNodeDataWithSchema) parent;
 273         Preconditions.checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
 274                 parentSimpleNode.getSchema().getQName(), parentSimpleNode.getValue());
 275
 276         final Object translatedValue = translateValueByType(value, parentSimpleNode.getSchema());
 277         parentSimpleNode.setValue(translatedValue);
 278     }
 279
 280     private Object translateValueByType(final String value, final DataSchemaNode node) {
 281         Preconditions.checkArgument(node instanceof TypedSchemaNode);
 282         return codecs.codecFor((TypedSchemaNode) node).parseValue(null, value);
 283     }
 284
 285     private void removeNamespace() {
 286         namespaces.pop();
 287     }
 288
 289     private void addNamespace(final URI namespace) {
 290         namespaces.push(namespace);
 291     }
 292
 293     private NamespaceAndName resolveNamespace(final String childName, final DataSchemaNode dataSchemaNode) {
 294         final int lastIndexOfColon = childName.lastIndexOf(':');
 295         String moduleNamePart = null;
 296         String nodeNamePart = null;
 297         URI namespace = null;
 298         if (lastIndexOfColon != -1) {
 299             moduleNamePart = childName.substring(0, lastIndexOfColon);
 300             nodeNamePart = childName.substring(lastIndexOfColon + 1);
 301
 302             final Module m = schema.findModuleByName(moduleNamePart, null);
 303             namespace = m == null ? null : m.getNamespace();
 304         } else {
 305             nodeNamePart = childName;
 306         }
 307
 308         if (namespace == null) {
 309             Set<URI> potentialUris = Collections.emptySet();
 310             potentialUris = resolveAllPotentialNamespaces(nodeNamePart, dataSchemaNode);
 311             if (potentialUris.contains(getCurrentNamespace())) {
 312                 namespace = getCurrentNamespace();
 313             } else if (potentialUris.size() == 1) {
 314                 namespace = potentialUris.iterator().next();
 315             } else if (potentialUris.size() > 1) {
 316                 throw new IllegalStateException("Choose suitable module name for element "+nodeNamePart+":"+toModuleNames(potentialUris));
 317             } else if (potentialUris.isEmpty()) {
 318                 throw new IllegalStateException("Schema node with name "+nodeNamePart+" wasn't found under "+dataSchemaNode.getQName()+".");
 319             }
 320         }
 321
 322         return new NamespaceAndName(nodeNamePart, namespace);
 323     }
 324
 325     private String toModuleNames(final Set<URI> potentialUris) {
 326         final StringBuilder builder = new StringBuilder();
 327         for (final URI potentialUri : potentialUris) {
 328             builder.append("\n");
 329             //FIXME how to get information about revision from JSON input? currently first available is used.
 330             builder.append(schema.findModuleByNamespace(potentialUri).iterator().next().getName());
 331         }
 332         return builder.toString();
 333     }
 334
 335     private Set<URI> resolveAllPotentialNamespaces(final String elementName, final DataSchemaNode dataSchemaNode) {
 336         final Set<URI> potentialUris = new HashSet<>();
 337         final Set<ChoiceSchemaNode> choices = new HashSet<>();
 338         if (dataSchemaNode instanceof DataNodeContainer) {
 339             for (final DataSchemaNode childSchemaNode : ((DataNodeContainer) dataSchemaNode).getChildNodes()) {
 340                 if (childSchemaNode instanceof ChoiceSchemaNode) {
 341                     choices.add((ChoiceSchemaNode)childSchemaNode);
 342                 } else if (childSchemaNode.getQName().getLocalName().equals(elementName)) {
 343                     potentialUris.add(childSchemaNode.getQName().getNamespace());
 344                 }
 345             }
 346
 347             for (final ChoiceSchemaNode choiceNode : choices) {
 348                 for (final ChoiceCaseNode concreteCase : choiceNode.getCases()) {
 349                     potentialUris.addAll(resolveAllPotentialNamespaces(elementName, concreteCase));
 350                 }
 351             }
 352         }
 353         return potentialUris;
 354     }
 355
 356     private URI getCurrentNamespace() {
 357         return namespaces.peek();
 358     }
 359
 360
 361
 362     private static class NamespaceAndName {
 363         private final URI uri;
 364         private final String name;
 365
 366         public NamespaceAndName(final String name, final URI uri) {
 367             this.name = name;
 368             this.uri = uri;
 369         }
 370
 371         public String getName() {
 372             return name;
 373         }
 374
 375         public URI getUri() {
 376             return uri;
 377         }
 378     }
 379
 380     @Override
 381     public void flush() throws IOException {
 382         writer.flush();
 383     }
 384
 385     @Override
 386     public void close() throws IOException {
 387         writer.flush();
 388         writer.close();
 389     }
 390 }