yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XMLStreamNormalizedNodeStreamWriter.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.impl.codec.xml;
   9
  10 import com.google.common.base.Preconditions;
  11 import com.google.common.base.Strings;
  12 import java.io.IOException;
  13 import java.io.StringWriter;
  14 import java.util.Map;
  15 import javax.xml.XMLConstants;
  16 import javax.xml.namespace.NamespaceContext;
  17 import javax.xml.stream.XMLStreamException;
  18 import javax.xml.stream.XMLStreamWriter;
  19 import javax.xml.transform.OutputKeys;
  20 import javax.xml.transform.Transformer;
  21 import javax.xml.transform.TransformerException;
  22 import javax.xml.transform.TransformerFactory;
  23 import javax.xml.transform.TransformerFactoryConfigurationError;
  24 import javax.xml.transform.dom.DOMSource;
  25 import javax.xml.transform.stax.StAXResult;
  26 import javax.xml.transform.stream.StreamResult;
  27 import org.opendaylight.yangtools.yang.common.QName;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  31 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  32 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter;
  33 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  34 import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
  35 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
  36 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  37 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  38 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  41 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  42 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  43 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  44 import org.w3c.dom.Element;
  45
  46 /**
  47  * A {@link NormalizedNodeStreamWriter} which translates the events into an
  48  * {@link XMLStreamWriter}, resulting in a RFC 6020 XML encoding.
  49  */
  50 public final class XMLStreamNormalizedNodeStreamWriter implements NormalizedNodeStreamAttributeWriter {
  51
  52     private static final TransformerFactory TRANSFORMER_FACTORY = TransformerFactory.newInstance();
  53
  54     private final XMLStreamWriter writer;
  55     private final SchemaTracker tracker;
  56     private final XmlStreamUtils streamUtils;
  57     private final RandomPrefix randomPrefix;
  58
  59     private XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
  60         this.writer = Preconditions.checkNotNull(writer);
  61         this.tracker = SchemaTracker.create(context, path);
  62         this.streamUtils = XmlStreamUtils.create(XmlUtils.DEFAULT_XML_CODEC_PROVIDER, context);
  63         randomPrefix = new RandomPrefix();
  64     }
  65
  66     /**
  67      * Create a new writer with the specified context as its root.
  68      *
  69      * @param writer Output {@link XMLStreamWriter}
  70      * @param context Associated {@link SchemaContext}.
  71      * @return A new {@link NormalizedNodeStreamWriter}
  72      */
  73     public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context) {
  74         return create( writer, context, SchemaPath.ROOT);
  75     }
  76
  77     /**
  78      * Create a new writer with the specified context and rooted in the specified schema path
  79      *
  80      * @param writer Output {@link XMLStreamWriter}
  81      * @param context Associated {@link SchemaContext}.
  82      * @param path path
  83      *
  84      * @return A new {@link NormalizedNodeStreamWriter}
  85      */
  86     public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
  87         return new XMLStreamNormalizedNodeStreamWriter(writer, context, path);
  88     }
  89
  90     private void writeStartElement(final QName qname) throws XMLStreamException {
  91         String ns = qname.getNamespace().toString();
  92         writer.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, qname.getLocalName(), ns);
  93         if(writer.getNamespaceContext() != null) {
  94             String parentNs = writer.getNamespaceContext().getNamespaceURI(XMLConstants.DEFAULT_NS_PREFIX);
  95             if (!ns.equals(parentNs)) {
  96                 writer.writeDefaultNamespace(ns);
  97             }
  98         }
  99     }
 100
 101     private void writeElement(final QName qname, final TypeDefinition<?> type, final Object value) throws IOException {
 102         try {
 103             writeStartElement(qname);
 104             if (value != null) {
 105                 streamUtils.writeValue(writer, type, value, qname.getModule());
 106             }
 107             writer.writeEndElement();
 108         } catch (XMLStreamException e) {
 109             throw new IOException("Failed to emit element", e);
 110         }
 111     }
 112
 113     private void writeElement(final QName qname, final SchemaNode schemaNode, final Object value) throws IOException {
 114         try {
 115             writeStartElement(qname);
 116             if (value != null) {
 117                 streamUtils.writeValue(writer, schemaNode, value, qname.getModule());
 118             }
 119             writer.writeEndElement();
 120         } catch (XMLStreamException e) {
 121             throw new IOException("Failed to emit element", e);
 122         }
 123     }
 124
 125     private void writeElement(final QName qname, final SchemaNode schemaNode, final Object value, final Map<QName, String> attributes) throws IOException {
 126         try {
 127             writeStartElement(qname);
 128
 129             writeAttributes(attributes);
 130             if (value != null) {
 131                 streamUtils.writeValue(writer, schemaNode, value, qname.getModule());
 132             }
 133             writer.writeEndElement();
 134         } catch (XMLStreamException e) {
 135             throw new IOException("Failed to emit element", e);
 136         }
 137     }
 138
 139     private void startElement(final QName qname) throws IOException {
 140         try {
 141             writeStartElement(qname);
 142         } catch (XMLStreamException e) {
 143             throw new IOException("Failed to start element", e);
 144         }
 145     }
 146
 147     private void startList(final NodeIdentifier name) {
 148         tracker.startList(name);
 149     }
 150
 151     private void startListItem(final PathArgument name) throws IOException {
 152         tracker.startListItem(name);
 153         startElement(name.getNodeType());
 154     }
 155
 156     @Override
 157     public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
 158         final LeafSchemaNode schema = tracker.leafNode(name);
 159         writeElement(schema.getQName(), schema, value);
 160     }
 161
 162     @Override
 163     public void leafNode(final NodeIdentifier name, final Object value, final Map<QName, String> attributes) throws IOException {
 164         final LeafSchemaNode schema = tracker.leafNode(name);
 165         writeElement(schema.getQName(), schema, value, attributes);
 166     }
 167
 168     @Override
 169     public void leafSetEntryNode(final Object value, final Map<QName, String> attributes) throws IOException {
 170         final LeafListSchemaNode schema = tracker.leafSetEntryNode();
 171         writeElement(schema.getQName(), schema, value, attributes);
 172     }
 173
 174     @Override
 175     public void startContainerNode(final NodeIdentifier name, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
 176         startContainerNode(name, childSizeHint);
 177         writeAttributes(attributes);
 178     }
 179
 180     @Override
 181     public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
 182         startYangModeledAnyXmlNode(name, childSizeHint);
 183         writeAttributes(attributes);
 184     }
 185
 186     @Override
 187     public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
 188         startUnkeyedListItem(name, childSizeHint);
 189         writeAttributes(attributes);
 190     }
 191
 192     @Override
 193     public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
 194         startMapEntryNode(identifier, childSizeHint);
 195         writeAttributes(attributes);
 196     }
 197
 198     private void writeAttributes(final Map<QName, String> attributes) throws IOException {
 199         for (final Map.Entry<QName, String> qNameStringEntry : attributes.entrySet()) {
 200             try {
 201                 final String namespace = qNameStringEntry.getKey().getNamespace().toString();
 202
 203                 if(Strings.isNullOrEmpty(namespace)) {
 204                     writer.writeAttribute(qNameStringEntry.getKey().getLocalName(), qNameStringEntry.getValue());
 205                 } else {
 206                     final String prefix = randomPrefix.encodePrefix(qNameStringEntry.getKey().getNamespace());
 207                     writer.writeAttribute(prefix, namespace, qNameStringEntry.getKey().getLocalName(), qNameStringEntry.getValue());
 208                 }
 209             } catch (final XMLStreamException e) {
 210                 throw new IOException("Unable to emit attribute " + qNameStringEntry, e);
 211             }
 212         }
 213     }
 214
 215     @Override
 216     public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
 217         tracker.startLeafSet(name);
 218     }
 219
 220     @Override
 221     public void leafSetEntryNode(final Object value) throws IOException {
 222         final LeafListSchemaNode schema = tracker.leafSetEntryNode();
 223         writeElement(schema.getQName(), schema, value);
 224     }
 225
 226     @Override
 227     public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
 228         final SchemaNode schema = tracker.startContainerNode(name);
 229         startElement(schema.getQName());
 230     }
 231
 232     @Override
 233     public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
 234         startList(name);
 235     }
 236
 237     @Override
 238     public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
 239         startListItem(name);
 240     }
 241
 242     @Override
 243     public void startMapNode(final NodeIdentifier name, final int childSizeHint) {
 244         startList(name);
 245     }
 246
 247     @Override
 248     public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException {
 249         startListItem(identifier);
 250     }
 251
 252     @Override
 253     public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
 254         startList(name);
 255     }
 256
 257     @Override
 258     public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) {
 259         tracker.startChoiceNode(name);
 260     }
 261
 262     @Override
 263     public void startAugmentationNode(final AugmentationIdentifier identifier) {
 264         tracker.startAugmentationNode(identifier);
 265     }
 266
 267     @Override
 268     public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
 269         final AnyXmlSchemaNode schema = tracker.anyxmlNode(name);
 270         if (value != null) {
 271             Preconditions.checkArgument(value instanceof DOMSource, "AnyXML value must be DOMSource, not %s", value);
 272             final QName qname = schema.getQName();
 273             final DOMSource domSource = (DOMSource) value;
 274             Preconditions.checkNotNull(domSource.getNode());
 275             Preconditions.checkArgument(domSource.getNode().getNodeName().equals(qname.getLocalName()));
 276             Preconditions.checkArgument(domSource.getNode().getNamespaceURI().equals(qname.getNamespace().toString()));
 277             try {
 278                 // TODO can the transformer be a constant ? is it thread safe ?
 279                 final Transformer transformer = TRANSFORMER_FACTORY.newTransformer();
 280                 // Writer has to be wrapped in a wrapper that ignores endDocument event
 281                 // EndDocument event forbids any other modification to the writer so a nested anyXml breaks serialization
 282                 transformer.transform(domSource, new StAXResult(new DelegateWriterNoEndDoc(writer)));
 283             } catch (final TransformerException e) {
 284                 throw new IOException("Unable to transform anyXml(" + name + ") value: " + value, e);
 285             }
 286         }
 287     }
 288
 289     @Override
 290     public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
 291         final SchemaNode schema = tracker.startYangModeledAnyXmlNode(name);
 292         startElement(schema.getQName());
 293     }
 294
 295     public static String toString(final Element xml) {
 296         try {
 297             final Transformer transformer = TransformerFactory.newInstance().newTransformer();
 298             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 299
 300             final StreamResult result = new StreamResult(new StringWriter());
 301             final DOMSource source = new DOMSource(xml);
 302             transformer.transform(source, result);
 303
 304             return result.getWriter().toString();
 305         } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
 306             throw new RuntimeException("Unable to serialize xml element " + xml, e);
 307         }
 308     }
 309
 310     @Override
 311     public void endNode() throws IOException {
 312         final Object schema = tracker.endNode();
 313
 314         try {
 315             if (schema instanceof ListSchemaNode) {
 316                 // For lists, we only emit end element on the inner frame
 317                 final Object parent = tracker.getParent();
 318                 if (parent == schema) {
 319                     writer.writeEndElement();
 320                 }
 321             } else if (schema instanceof ContainerSchemaNode) {
 322                 // Emit container end element
 323                 writer.writeEndElement();
 324             }
 325         } catch (XMLStreamException e) {
 326             throw new IOException("Failed to end element", e);
 327         }
 328     }
 329
 330     @Override
 331     public void close() throws IOException {
 332         try {
 333             writer.close();
 334         } catch (XMLStreamException e) {
 335             throw new IOException("Failed to close writer", e);
 336         }
 337     }
 338
 339     @Override
 340     public void flush() throws IOException {
 341         try {
 342             writer.flush();
 343         } catch (XMLStreamException e) {
 344             throw new IOException("Failed to flush writer", e);
 345         }
 346     }
 347
 348     /**
 349      * Delegate writer that ignores writeEndDocument event. Used for AnyXml serialization.
 350      */
 351     private static final class DelegateWriterNoEndDoc implements XMLStreamWriter {
 352         private final XMLStreamWriter writer;
 353
 354         public DelegateWriterNoEndDoc(final XMLStreamWriter writer) {
 355             this.writer = writer;
 356         }
 357
 358         @Override
 359         public void writeStartElement(final String localName) throws XMLStreamException {
 360             writer.writeStartElement(localName);
 361         }
 362
 363         @Override
 364         public void writeStartElement(final String namespaceURI, final String localName) throws XMLStreamException {
 365             writer.writeStartElement(namespaceURI, localName);
 366         }
 367
 368         @Override
 369         public void writeStartElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
 370             writer.writeStartElement(prefix, localName, namespaceURI);
 371         }
 372
 373         @Override
 374         public void writeEmptyElement(final String namespaceURI, final String localName) throws XMLStreamException {
 375             writer.writeEmptyElement(namespaceURI, localName);
 376         }
 377
 378         @Override
 379         public void writeEmptyElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
 380             writer.writeEmptyElement(prefix, localName, namespaceURI);
 381         }
 382
 383         @Override
 384         public void writeEmptyElement(final String localName) throws XMLStreamException {
 385             writer.writeEmptyElement(localName);
 386         }
 387
 388         @Override
 389         public void writeEndElement() throws XMLStreamException {
 390             writer.writeEndElement();
 391
 392         }
 393
 394         @Override
 395         public void writeEndDocument() throws XMLStreamException {
 396             // End document is disabled
 397         }
 398
 399         @Override
 400         public void close() throws XMLStreamException {
 401             writer.close();
 402         }
 403
 404         @Override
 405         public void flush() throws XMLStreamException {
 406             writer.flush();
 407         }
 408
 409         @Override
 410         public void writeAttribute(final String localName, final String value) throws XMLStreamException {
 411             writer.writeAttribute(localName, value);
 412         }
 413
 414         @Override
 415         public void writeAttribute(final String prefix, final String namespaceURI, final String localName, final String value) throws XMLStreamException {
 416             writer.writeAttribute(prefix, namespaceURI, localName, value);
 417         }
 418
 419         @Override
 420         public void writeAttribute(final String namespaceURI, final String localName, final String value) throws XMLStreamException {
 421             writer.writeAttribute(namespaceURI, localName, value);
 422         }
 423
 424         @Override
 425         public void writeNamespace(final String prefix, final String namespaceURI) throws XMLStreamException {
 426             // Workaround for default namespace
 427             // If a namespace is not prefixed, it is is still treated as prefix namespace. This results in the NamespaceSupport class ignoring the namespace since xmlns is not a valid prefix
 428             // Write the namespace at least as an attribute
 429             // TODO this is a hotfix, the transformer itself should write namespaces passing the namespace in writeStartElement method
 430             if (prefix.equals("xml") || prefix.equals("xmlns")) {
 431                 writer.writeAttribute(prefix, namespaceURI);
 432             } else {
 433                 writer.writeNamespace(prefix, namespaceURI);
 434             }
 435         }
 436
 437         @Override
 438         public void writeDefaultNamespace(final String namespaceURI) throws XMLStreamException {
 439             writer.writeDefaultNamespace(namespaceURI);
 440         }
 441
 442         @Override
 443         public void writeComment(final String data) throws XMLStreamException {
 444             writer.writeComment(data);
 445         }
 446
 447         @Override
 448         public void writeProcessingInstruction(final String target) throws XMLStreamException {
 449             writer.writeProcessingInstruction(target);
 450         }
 451
 452         @Override
 453         public void writeProcessingInstruction(final String target, final String data) throws XMLStreamException {
 454             writer.writeProcessingInstruction(target, data);
 455         }
 456
 457         @Override
 458         public void writeCData(final String data) throws XMLStreamException {
 459             writer.writeCData(data);
 460         }
 461
 462         @Override
 463         public void writeDTD(final String dtd) throws XMLStreamException {
 464             writer.writeDTD(dtd);
 465         }
 466
 467         @Override
 468         public void writeEntityRef(final String name) throws XMLStreamException {
 469             writer.writeEntityRef(name);
 470         }
 471
 472         @Override
 473         public void writeStartDocument() throws XMLStreamException {
 474         }
 475
 476         @Override
 477         public void writeStartDocument(final String version) throws XMLStreamException {
 478         }
 479
 480         @Override
 481         public void writeStartDocument(final String encoding, final String version) throws XMLStreamException {
 482         }
 483
 484         @Override
 485         public void writeCharacters(final String text) throws XMLStreamException {
 486             writer.writeCharacters(text);
 487         }
 488
 489         @Override
 490         public void writeCharacters(final char[] text, final int start, final int len) throws XMLStreamException {
 491             writer.writeCharacters(text, start, len);
 492         }
 493
 494         @Override
 495         public String getPrefix(final String uri) throws XMLStreamException {
 496             return writer.getPrefix(uri);
 497         }
 498
 499         @Override
 500         public void setPrefix(final String prefix, final String uri) throws XMLStreamException {
 501             // Disabled since it causes exceptions in the underlying writer
 502         }
 503
 504         @Override
 505         public void setDefaultNamespace(final String uri) throws XMLStreamException {
 506             writer.setDefaultNamespace(uri);
 507         }
 508
 509         @Override
 510         public void setNamespaceContext(final NamespaceContext context) throws XMLStreamException {
 511             writer.setNamespaceContext(context);
 512         }
 513
 514         @Override
 515         public NamespaceContext getNamespaceContext() {
 516             return writer.getNamespaceContext();
 517         }
 518
 519         @Override
 520         public Object getProperty(final String name) {
 521             return writer.getProperty(name);
 522         }
 523     }
 524 }