yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/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.codec.xml;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.base.Strings;
  14 import java.io.IOException;
  15 import java.io.StringWriter;
  16 import java.net.URI;
  17 import java.util.Map;
  18 import java.util.Map.Entry;
  19 import java.util.Set;
  20 import java.util.concurrent.ConcurrentHashMap;
  21 import javax.xml.XMLConstants;
  22 import javax.xml.namespace.NamespaceContext;
  23 import javax.xml.stream.XMLStreamConstants;
  24 import javax.xml.stream.XMLStreamException;
  25 import javax.xml.stream.XMLStreamWriter;
  26 import javax.xml.transform.OutputKeys;
  27 import javax.xml.transform.Transformer;
  28 import javax.xml.transform.TransformerException;
  29 import javax.xml.transform.TransformerFactory;
  30 import javax.xml.transform.dom.DOMSource;
  31 import javax.xml.transform.stream.StreamResult;
  32 import org.eclipse.jdt.annotation.NonNull;
  33 import org.eclipse.jdt.annotation.Nullable;
  34 import org.opendaylight.yangtools.yang.common.QName;
  35 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  36 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  37 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  38 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter;
  39 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  41 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44 import org.w3c.dom.Element;
  45 import org.w3c.dom.Node;
  46
  47 /**
  48  * A {@link NormalizedNodeStreamWriter} which translates the events into an {@link XMLStreamWriter},
  49  * resulting in a RFC 6020 XML encoding. There are 2 versions of this class, one that takes a
  50  * SchemaContext and encodes values appropriately according to the yang schema. The other is
  51  * schema-less and merely outputs values using toString. The latter is intended for debugging
  52  * where doesn't have a SchemaContext available and isn't meant for production use.
  53  */
  54 public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements NormalizedNodeStreamAttributeWriter {
  55     private static final Logger LOG = LoggerFactory.getLogger(XMLStreamNormalizedNodeStreamWriter.class);
  56     private static final TransformerFactory TRANSFORMER_FACTORY = TransformerFactory.newInstance();
  57     private static final Set<String> BROKEN_NAMESPACES = ConcurrentHashMap.newKeySet();
  58
  59     private final @NonNull XMLStreamWriter writer;
  60     private final RandomPrefix prefixes;
  61
  62     XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer) {
  63         this.writer = requireNonNull(writer);
  64         this.prefixes = new RandomPrefix(writer.getNamespaceContext());
  65     }
  66
  67     /**
  68      * Create a new writer with the specified context as its root.
  69      *
  70      * @param writer Output {@link XMLStreamWriter}
  71      * @param context Associated {@link SchemaContext}.
  72      * @return A new {@link NormalizedNodeStreamWriter}
  73      */
  74     public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context) {
  75         return create(writer, context, SchemaPath.ROOT);
  76     }
  77
  78     /**
  79      * Create a new writer with the specified context and rooted in the specified schema path.
  80      *
  81      * @param writer Output {@link XMLStreamWriter}
  82      * @param context Associated {@link SchemaContext}.
  83      * @param path path
  84      *
  85      * @return A new {@link NormalizedNodeStreamWriter}
  86      */
  87     public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context,
  88             final SchemaPath path) {
  89         return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, path);
  90     }
  91
  92     /**
  93      * Create a new schema-less writer. Note that this version is intended for debugging
  94      * where doesn't have a SchemaContext available and isn't meant for production use.
  95      *
  96      * @param writer Output {@link XMLStreamWriter}
  97      *
  98      * @return A new {@link NormalizedNodeStreamWriter}
  99      */
 100     public static @NonNull NormalizedNodeStreamWriter createSchemaless(final XMLStreamWriter writer) {
 101         return new SchemalessXMLStreamNormalizedNodeStreamWriter(writer);
 102     }
 103
 104     abstract void writeValue(@NonNull XMLStreamWriter xmlWriter, QName qname, @NonNull Object value, T context)
 105             throws IOException, XMLStreamException;
 106
 107     abstract void startList(NodeIdentifier name);
 108
 109     abstract void startListItem(PathArgument name) throws IOException;
 110
 111     private void writeAttributes(final @NonNull Map<QName, String> attributes) throws IOException {
 112         for (final Entry<QName, String> entry : attributes.entrySet()) {
 113             try {
 114                 final QName qname = entry.getKey();
 115                 final String namespace = qname.getNamespace().toString();
 116
 117                 if (!Strings.isNullOrEmpty(namespace)) {
 118                     final String prefix = getPrefix(qname.getNamespace(), namespace);
 119                     writer.writeAttribute(prefix, namespace, qname.getLocalName(), entry.getValue());
 120                 } else {
 121                     writer.writeAttribute(qname.getLocalName(), entry.getValue());
 122                 }
 123             } catch (final XMLStreamException e) {
 124                 throw new IOException("Unable to emit attribute " + entry, e);
 125             }
 126         }
 127     }
 128
 129     private String getPrefix(final URI uri, final String str) throws XMLStreamException {
 130         final String prefix = writer.getPrefix(str);
 131         if (prefix != null) {
 132             return prefix;
 133         }
 134
 135         // This is needed to recover from attributes emitted while the namespace was not declared. Ordinarily
 136         // attribute namespaces would be bound in the writer, so the resulting XML is efficient, but we cannot rely
 137         // on that having been done.
 138         if (BROKEN_NAMESPACES.add(str)) {
 139             LOG.info("Namespace {} was not bound, please fix the caller", str, new Throwable());
 140         }
 141
 142         return prefixes.encodePrefix(uri);
 143     }
 144
 145     private void writeStartElement(final QName qname) throws XMLStreamException {
 146         final String ns = qname.getNamespace().toString();
 147         final NamespaceContext context = writer.getNamespaceContext();
 148         final boolean needDefaultNs;
 149         if (context != null) {
 150             final String parentNs = context.getNamespaceURI(XMLConstants.DEFAULT_NS_PREFIX);
 151             needDefaultNs = !ns.equals(parentNs);
 152         } else {
 153             needDefaultNs = false;
 154         }
 155
 156         writer.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, qname.getLocalName(), ns);
 157         if (needDefaultNs) {
 158             writer.writeDefaultNamespace(ns);
 159         }
 160     }
 161
 162     final void writeElement(final QName qname, final Object value, final @Nullable Map<QName, String> attributes,
 163             final T context) throws IOException {
 164         try {
 165             writeStartElement(qname);
 166             if (attributes != null) {
 167                 writeAttributes(attributes);
 168             }
 169             if (value != null) {
 170                 writeValue(writer, qname, value, context);
 171             }
 172             writer.writeEndElement();
 173         } catch (XMLStreamException e) {
 174             throw new IOException("Failed to emit element", e);
 175         }
 176     }
 177
 178     final void startElement(final QName qname) throws IOException {
 179         try {
 180             writeStartElement(qname);
 181         } catch (XMLStreamException e) {
 182             throw new IOException("Failed to start element", e);
 183         }
 184     }
 185
 186     final void endElement() throws IOException {
 187         try {
 188             writer.writeEndElement();
 189         } catch (XMLStreamException e) {
 190             throw new IOException("Failed to end element", e);
 191         }
 192     }
 193
 194     final void anyxmlNode(final QName qname, final Object value) throws IOException {
 195         if (value != null) {
 196             checkArgument(value instanceof DOMSource, "AnyXML value must be DOMSource, not %s", value);
 197             final DOMSource domSource = (DOMSource) value;
 198             final Node domNode = requireNonNull(domSource.getNode());
 199             checkArgument(domNode.getNodeName().equals(qname.getLocalName()));
 200             checkArgument(domNode.getNamespaceURI().equals(qname.getNamespace().toString()));
 201
 202             try {
 203                 writeStreamReader(new DOMSourceXMLStreamReader(domSource));
 204             } catch (XMLStreamException e) {
 205                 throw new IOException("Unable to transform anyXml(" + qname + ") value: " + domNode, e);
 206             }
 207         }
 208     }
 209
 210     private void writeStreamReader(final DOMSourceXMLStreamReader reader) throws XMLStreamException {
 211         while (reader.hasNext()) {
 212             final int event = reader.next();
 213             switch (event) {
 214                 case XMLStreamConstants.START_ELEMENT:
 215                     forwardStartElement(reader);
 216                     break;
 217                 case XMLStreamConstants.END_ELEMENT:
 218                     writer.writeEndElement();
 219                     break;
 220                 case XMLStreamConstants.PROCESSING_INSTRUCTION:
 221                     forwardProcessingInstruction(reader);
 222                     break;
 223                 case XMLStreamConstants.CHARACTERS:
 224                     writer.writeCharacters(reader.getText());
 225                     break;
 226                 case XMLStreamConstants.COMMENT:
 227                     writer.writeComment(reader.getText());
 228                     break;
 229                 case XMLStreamConstants.SPACE:
 230                     // Ignore insignificant whitespace
 231                     break;
 232                 case XMLStreamConstants.START_DOCUMENT:
 233                 case XMLStreamConstants.END_DOCUMENT:
 234                     // We are embedded: ignore start/end document events
 235                     break;
 236                 case XMLStreamConstants.ENTITY_REFERENCE:
 237                     writer.writeEntityRef(reader.getLocalName());
 238                     break;
 239                 case XMLStreamConstants.ATTRIBUTE:
 240                     forwardAttributes(reader);
 241                     break;
 242                 case XMLStreamConstants.DTD:
 243                     writer.writeDTD(reader.getText());
 244                     break;
 245                 case XMLStreamConstants.CDATA:
 246                     writer.writeCData(reader.getText());
 247                     break;
 248                 case XMLStreamConstants.NAMESPACE:
 249                     forwardNamespaces(reader);
 250                     break;
 251                 case XMLStreamConstants.NOTATION_DECLARATION:
 252                 case XMLStreamConstants.ENTITY_DECLARATION:
 253                 default:
 254                     throw new IllegalStateException("Unhandled event " + event);
 255             }
 256         }
 257     }
 258
 259     private void forwardAttributes(final DOMSourceXMLStreamReader reader) throws XMLStreamException {
 260         for (int i = 0; i < reader.getAttributeCount(); ++i) {
 261             final String localName = reader.getAttributeLocalName(i);
 262             final String value = reader.getAttributeValue(i);
 263             final String prefix = reader.getAttributePrefix(i);
 264             if (prefix != null) {
 265                 writer.writeAttribute(prefix, reader.getAttributeNamespace(i), localName, value);
 266             } else {
 267                 writer.writeAttribute(localName, value);
 268             }
 269         }
 270     }
 271
 272     private void forwardNamespaces(final DOMSourceXMLStreamReader reader) throws XMLStreamException {
 273         for (int i = 0; i < reader.getNamespaceCount(); ++i) {
 274             writer.writeNamespace(reader.getNamespacePrefix(i), reader.getNamespaceURI(i));
 275         }
 276     }
 277
 278     private void forwardProcessingInstruction(final DOMSourceXMLStreamReader reader) throws XMLStreamException {
 279         final String target = reader.getPITarget();
 280         final String data = reader.getPIData();
 281         if (data != null) {
 282             writer.writeProcessingInstruction(target, data);
 283         } else {
 284             writer.writeProcessingInstruction(target);
 285         }
 286     }
 287
 288     private void forwardStartElement(final DOMSourceXMLStreamReader reader) throws XMLStreamException {
 289         final String localName = reader.getLocalName();
 290         final String prefix = reader.getPrefix();
 291         if (prefix != null) {
 292             writer.writeStartElement(prefix, localName, reader.getNamespaceURI());
 293         } else {
 294             writer.writeStartElement(localName);
 295         }
 296
 297         forwardNamespaces(reader);
 298         forwardAttributes(reader);
 299     }
 300
 301     @Override
 302     public final void startContainerNode(final NodeIdentifier name, final int childSizeHint,
 303                                          final Map<QName, String> attributes) throws IOException {
 304         startContainerNode(name, childSizeHint);
 305         writeAttributes(attributes);
 306     }
 307
 308     @Override
 309     public final void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint,
 310                                                  final Map<QName, String> attributes) throws IOException {
 311         startYangModeledAnyXmlNode(name, childSizeHint);
 312         writeAttributes(attributes);
 313     }
 314
 315     @Override
 316     public final void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint,
 317                                            final Map<QName, String> attributes) throws IOException {
 318         startUnkeyedListItem(name, childSizeHint);
 319         writeAttributes(attributes);
 320     }
 321
 322     @Override
 323     public final void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
 324         startListItem(name);
 325     }
 326
 327     @Override
 328     public final void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint,
 329                                         final Map<QName, String> attributes) throws IOException {
 330         startMapEntryNode(identifier, childSizeHint);
 331         writeAttributes(attributes);
 332     }
 333
 334     @Override
 335     public final void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
 336             throws IOException {
 337         startListItem(identifier);
 338     }
 339
 340     @Override
 341     public final void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
 342         startList(name);
 343     }
 344
 345     @Override
 346     public final void startMapNode(final NodeIdentifier name, final int childSizeHint) {
 347         startList(name);
 348     }
 349
 350     @Override
 351     public final void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
 352         startList(name);
 353     }
 354
 355     public static String toString(final Element xml) {
 356         try {
 357             final Transformer transformer = TRANSFORMER_FACTORY.newTransformer();
 358             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 359
 360             final StreamResult result = new StreamResult(new StringWriter());
 361             transformer.transform(new DOMSource(xml), result);
 362
 363             return result.getWriter().toString();
 364         } catch (IllegalArgumentException | TransformerException e) {
 365             throw new IllegalStateException("Unable to serialize xml element " + xml, e);
 366         }
 367     }
 368
 369     @Override
 370     public final void close() throws IOException {
 371         try {
 372             writer.close();
 373         } catch (XMLStreamException e) {
 374             throw new IOException("Failed to close writer", e);
 375         }
 376     }
 377
 378     @Override
 379     public final void flush() throws IOException {
 380         try {
 381             writer.flush();
 382         } catch (XMLStreamException e) {
 383             throw new IOException("Failed to flush writer", e);
 384         }
 385     }
 386 }