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