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