X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-clustering-commons%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fnode%2Futils%2Fstream%2FNormalizedNodeInputStreamReader.java;h=2f9403707c79e87a4dc6e12057d14608f85c063d;hb=refs%2Fchanges%2F17%2F78117%2F1;hp=7ed50ff731bb5bdafc620e53e388cf2b1cd3d4c8;hpb=7a0fb19fe86fbf7c7bd78f7e522884b6e477b067;p=controller.git diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java old mode 100644 new mode 100755 index 7ed50ff731..2f9403707c --- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/stream/NormalizedNodeInputStreamReader.java @@ -10,21 +10,23 @@ package org.opendaylight.controller.cluster.datastore.node.utils.stream; import com.google.common.base.Preconditions; import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableList.Builder; import java.io.DataInput; -import java.io.DataInputStream; import java.io.IOException; -import java.io.InputStream; +import java.io.StringReader; import java.math.BigDecimal; import java.math.BigInteger; import java.nio.charset.StandardCharsets; -import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; -import java.util.List; import java.util.Map; import java.util.Set; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; import javax.xml.transform.dom.DOMSource; import org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory; +import org.opendaylight.yangtools.yang.common.Empty; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; @@ -38,17 +40,19 @@ import org.opendaylight.yangtools.yang.data.impl.schema.Builders; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.w3c.dom.Element; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; /** - * NormalizedNodeInputStreamReader reads the byte stream and constructs the normalized node including its children nodes. - * This process goes in recursive manner, where each NodeTypes object signifies the start of the object, except END_NODE. - * If a node can have children, then that node's end is calculated based on appearance of END_NODE. - * + * NormalizedNodeInputStreamReader reads the byte stream and constructs the normalized node including its children + * nodes. This process goes in recursive manner, where each NodeTypes object signifies the start of the object, except + * END_NODE. If a node can have children, then that node's end is calculated based on appearance of END_NODE. */ - -public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, NormalizedNodeStreamReader { +public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput { private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeInputStreamReader.class); @@ -63,29 +67,13 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, private NormalizedNodeAttrBuilder> leafBuilder; - private NormalizedNodeAttrBuilder> leafSetEntryBuilder; + @SuppressWarnings("rawtypes") + private NormalizedNodeAttrBuilder> leafSetEntryBuilder; private final StringBuilder reusableStringBuilder = new StringBuilder(50); private boolean readSignatureMarker = true; - /** - * @deprecated Use {@link #NormalizedNodeInputStreamReader(DataInput)} instead. - */ - @Deprecated - public NormalizedNodeInputStreamReader(final InputStream stream) throws IOException { - this((DataInput) new DataInputStream(Preconditions.checkNotNull(stream))); - } - - /** - * @deprecated Use {@link NormalizedNodeInputOutput#newDataInput(DataInput)} instead. - */ - @Deprecated - public NormalizedNodeInputStreamReader(final DataInput input) { - this(input, false); - } - NormalizedNodeInputStreamReader(final DataInput input, final boolean versionChecked) { this.input = Preconditions.checkNotNull(input); readSignatureMarker = !versionChecked; @@ -98,7 +86,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, } private void readSignatureMarkerAndVersionIfNeeded() throws IOException { - if(readSignatureMarker) { + if (readSignatureMarker) { readSignatureMarker = false; final byte marker = input.readByte(); @@ -118,31 +106,32 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, // each node should start with a byte byte nodeType = input.readByte(); - if(nodeType == NodeTypes.END_NODE) { - LOG.debug("End node reached. return"); + if (nodeType == NodeTypes.END_NODE) { + LOG.trace("End node reached. return"); + lastLeafSetQName = null; return null; } - switch(nodeType) { + switch (nodeType) { case NodeTypes.AUGMENTATION_NODE : YangInstanceIdentifier.AugmentationIdentifier augIdentifier = new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); - LOG.debug("Reading augmentation node {} ", augIdentifier); + LOG.trace("Reading augmentation node {} ", augIdentifier); - return addDataContainerChildren(Builders.augmentationBuilder(). - withNodeIdentifier(augIdentifier)).build(); + return addDataContainerChildren(Builders.augmentationBuilder() + .withNodeIdentifier(augIdentifier)).build(); case NodeTypes.LEAF_SET_ENTRY_NODE : QName name = lastLeafSetQName; - if(name == null) { + if (name == null) { name = readQName(); } Object value = readObject(); - NodeWithValue leafIdentifier = new NodeWithValue<>(name, value); + NodeWithValue leafIdentifier = new NodeWithValue<>(name, value); - LOG.debug("Reading leaf set entry node {}, value {}", leafIdentifier, value); + LOG.trace("Reading leaf set entry node {}, value {}", leafIdentifier, value); return leafSetEntryBuilder().withNodeIdentifier(leafIdentifier).withValue(value).build(); @@ -150,10 +139,10 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, NodeIdentifierWithPredicates entryIdentifier = new NodeIdentifierWithPredicates( readQName(), readKeyValueMap()); - LOG.debug("Reading map entry node {} ", entryIdentifier); + LOG.trace("Reading map entry node {} ", entryIdentifier); - return addDataContainerChildren(Builders.mapEntryBuilder(). - withNodeIdentifier(entryIdentifier)).build(); + return addDataContainerChildren(Builders.mapEntryBuilder() + .withNodeIdentifier(entryIdentifier)).build(); default : return readNodeIdentifierDependentNode(nodeType, new NodeIdentifier(readQName())); @@ -162,16 +151,17 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, private NormalizedNodeAttrBuilder> leafBuilder() { - if(leafBuilder == null) { + if (leafBuilder == null) { leafBuilder = Builders.leafBuilder(); } return leafBuilder; } + @SuppressWarnings("rawtypes") private NormalizedNodeAttrBuilder> leafSetEntryBuilder() { - if(leafSetEntryBuilder == null) { + if (leafSetEntryBuilder == null) { leafSetEntryBuilder = Builders.leafSetEntryBuilder(); } @@ -181,101 +171,106 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, private NormalizedNode readNodeIdentifierDependentNode(final byte nodeType, final NodeIdentifier identifier) throws IOException { - switch(nodeType) { + switch (nodeType) { case NodeTypes.LEAF_NODE : - LOG.debug("Read leaf node {}", identifier); + LOG.trace("Read leaf node {}", identifier); // Read the object value return leafBuilder().withNodeIdentifier(identifier).withValue(readObject()).build(); case NodeTypes.ANY_XML_NODE : - LOG.debug("Read xml node"); - return Builders.anyXmlBuilder().withValue((DOMSource) readObject()).build(); + LOG.trace("Read xml node"); + return Builders.anyXmlBuilder().withNodeIdentifier(identifier).withValue(readDOMSource()).build(); case NodeTypes.MAP_NODE : - LOG.debug("Read map node {}", identifier); - return addDataContainerChildren(Builders.mapBuilder(). - withNodeIdentifier(identifier)).build(); - - case NodeTypes.CHOICE_NODE : - LOG.debug("Read choice node {}", identifier); - return addDataContainerChildren(Builders.choiceBuilder(). - withNodeIdentifier(identifier)).build(); - - case NodeTypes.ORDERED_MAP_NODE : - LOG.debug("Reading ordered map node {}", identifier); - return addDataContainerChildren(Builders.orderedMapBuilder(). - withNodeIdentifier(identifier)).build(); - - case NodeTypes.UNKEYED_LIST : - LOG.debug("Read unkeyed list node {}", identifier); - return addDataContainerChildren(Builders.unkeyedListBuilder(). - withNodeIdentifier(identifier)).build(); - - case NodeTypes.UNKEYED_LIST_ITEM : - LOG.debug("Read unkeyed list item node {}", identifier); - return addDataContainerChildren(Builders.unkeyedListEntryBuilder(). - withNodeIdentifier(identifier)).build(); - - case NodeTypes.CONTAINER_NODE : - LOG.debug("Read container node {}", identifier); - return addDataContainerChildren(Builders.containerBuilder(). - withNodeIdentifier(identifier)).build(); + LOG.trace("Read map node {}", identifier); + return addDataContainerChildren(Builders.mapBuilder().withNodeIdentifier(identifier)).build(); + + case NodeTypes.CHOICE_NODE: + LOG.trace("Read choice node {}", identifier); + return addDataContainerChildren(Builders.choiceBuilder().withNodeIdentifier(identifier)).build(); + + case NodeTypes.ORDERED_MAP_NODE: + LOG.trace("Reading ordered map node {}", identifier); + return addDataContainerChildren(Builders.orderedMapBuilder().withNodeIdentifier(identifier)).build(); + + case NodeTypes.UNKEYED_LIST: + LOG.trace("Read unkeyed list node {}", identifier); + return addDataContainerChildren(Builders.unkeyedListBuilder().withNodeIdentifier(identifier)).build(); + + case NodeTypes.UNKEYED_LIST_ITEM: + LOG.trace("Read unkeyed list item node {}", identifier); + return addDataContainerChildren(Builders.unkeyedListEntryBuilder() + .withNodeIdentifier(identifier)).build(); + + case NodeTypes.CONTAINER_NODE: + LOG.trace("Read container node {}", identifier); + return addDataContainerChildren(Builders.containerBuilder().withNodeIdentifier(identifier)).build(); case NodeTypes.LEAF_SET : - LOG.debug("Read leaf set node {}", identifier); + LOG.trace("Read leaf set node {}", identifier); return addLeafSetChildren(identifier.getNodeType(), Builders.leafSetBuilder().withNodeIdentifier(identifier)).build(); case NodeTypes.ORDERED_LEAF_SET: - LOG.debug("Read ordered leaf set node {}", identifier); - ListNodeBuilder> orderedLeafSetBuilder = - Builders.orderedLeafSetBuilder().withNodeIdentifier(identifier); - orderedLeafSetBuilder = addLeafSetChildren(identifier.getNodeType(), orderedLeafSetBuilder); - return orderedLeafSetBuilder.build(); + LOG.trace("Read ordered leaf set node {}", identifier); + return addLeafSetChildren(identifier.getNodeType(), + Builders.orderedLeafSetBuilder().withNodeIdentifier(identifier)).build(); - default : + default: return null; } } + private DOMSource readDOMSource() throws IOException { + String xml = readObject().toString(); + try { + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + factory.setNamespaceAware(true); + Element node = factory.newDocumentBuilder().parse( + new InputSource(new StringReader(xml))).getDocumentElement(); + return new DOMSource(node); + } catch (SAXException | ParserConfigurationException e) { + throw new IOException("Error parsing XML: " + xml, e); + } + } + private QName readQName() throws IOException { // Read in the same sequence of writing String localName = readCodedString(); String namespace = readCodedString(); String revision = readCodedString(); - String qName; - if(!Strings.isNullOrEmpty(revision)) { - qName = reusableStringBuilder.append('(').append(namespace).append(REVISION_ARG). - append(revision).append(')').append(localName).toString(); + String qname; + if (!Strings.isNullOrEmpty(revision)) { + qname = reusableStringBuilder.append('(').append(namespace).append(REVISION_ARG).append(revision) + .append(')').append(localName).toString(); } else { - qName = reusableStringBuilder.append('(').append(namespace).append(')'). - append(localName).toString(); + qname = reusableStringBuilder.append('(').append(namespace).append(')').append(localName).toString(); } reusableStringBuilder.delete(0, reusableStringBuilder.length()); - return QNameFactory.create(qName); + return QNameFactory.create(qname); } private String readCodedString() throws IOException { byte valueType = input.readByte(); - if(valueType == TokenTypes.IS_CODE_VALUE) { + if (valueType == TokenTypes.IS_CODE_VALUE) { return codedStringMap.get(input.readInt()); - } else if(valueType == TokenTypes.IS_STRING_VALUE) { + } else if (valueType == TokenTypes.IS_STRING_VALUE) { String value = input.readUTF().intern(); - codedStringMap.put(Integer.valueOf(codedStringMap.size()), value); + codedStringMap.put(codedStringMap.size(), value); return value; } return null; } - private Set readQNameSet() throws IOException{ + private Set readQNameSet() throws IOException { // Read the children count int count = input.readInt(); Set children = new HashSet<>(count); - for(int i = 0; i < count; i++) { + for (int i = 0; i < count; i++) { children.add(readQName()); } return children; @@ -285,7 +280,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, int count = input.readInt(); Map keyValueMap = new HashMap<>(count); - for(int i = 0; i < count; i++) { + for (int i = 0; i < count; i++) { keyValueMap.put(readQName(), readObject()); } @@ -294,27 +289,27 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, private Object readObject() throws IOException { byte objectType = input.readByte(); - switch(objectType) { + switch (objectType) { case ValueTypes.BITS_TYPE: return readObjSet(); case ValueTypes.BOOL_TYPE : - return Boolean.valueOf(input.readBoolean()); + return input.readBoolean(); case ValueTypes.BYTE_TYPE : - return Byte.valueOf(input.readByte()); + return input.readByte(); case ValueTypes.INT_TYPE : - return Integer.valueOf(input.readInt()); + return input.readInt(); case ValueTypes.LONG_TYPE : - return Long.valueOf(input.readLong()); + return input.readLong(); case ValueTypes.QNAME_TYPE : return readQName(); case ValueTypes.SHORT_TYPE : - return Short.valueOf(input.readShort()); + return input.readShort(); case ValueTypes.STRING_TYPE : return input.readUTF(); @@ -336,6 +331,15 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, case ValueTypes.YANG_IDENTIFIER_TYPE : return readYangInstanceIdentifierInternal(); + case ValueTypes.EMPTY_TYPE: + // Leaf nodes no longer allow null values and thus we no longer emit null values. Previously, the "empty" + // yang type was represented as null so we translate an incoming null value to Empty. It was possible for + // a BI user to set a string leaf to null and we're rolling the dice here but the chances for that are + // very low. We'd have to know the yang type but, even if we did, we can't let a null value pass upstream + // so we'd have to drop the leaf which might cause other issues. + case ValueTypes.NULL_TYPE: + return Empty.getInstance(); + default : return null; } @@ -347,6 +351,20 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, return new String(bytes, StandardCharsets.UTF_8); } + @Override + public SchemaPath readSchemaPath() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + + final boolean absolute = input.readBoolean(); + final int size = input.readInt(); + + final Builder qnames = ImmutableList.builderWithExpectedSize(size); + for (int i = 0; i < size; ++i) { + qnames.add(readQName()); + } + return SchemaPath.create(qnames.build(), absolute); + } + @Override public YangInstanceIdentifier readYangInstanceIdentifier() throws IOException { readSignatureMarkerAndVersionIfNeeded(); @@ -355,19 +373,17 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, private YangInstanceIdentifier readYangInstanceIdentifierInternal() throws IOException { int size = input.readInt(); - - List pathArguments = new ArrayList<>(size); - - for(int i = 0; i < size; i++) { + final Builder pathArguments = ImmutableList.builderWithExpectedSize(size); + for (int i = 0; i < size; i++) { pathArguments.add(readPathArgument()); } - return YangInstanceIdentifier.create(pathArguments); + return YangInstanceIdentifier.create(pathArguments.build()); } private Set readObjSet() throws IOException { int count = input.readInt(); Set children = new HashSet<>(count); - for(int i = 0; i < count; i++) { + for (int i = 0; i < count; i++) { children.add(readCodedString()); } return children; @@ -378,7 +394,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, // read Type int type = input.readByte(); - switch(type) { + switch (type) { case PathArgumentTypes.AUGMENTATION_IDENTIFIER : return new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); @@ -390,7 +406,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, return new NodeIdentifierWithPredicates(readQName(), readKeyValueMap()); case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE : - return new NodeWithValue(readQName(), readObject()); + return new NodeWithValue<>(readQName(), readObject()); default : return null; @@ -401,13 +417,13 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, private ListNodeBuilder> addLeafSetChildren(final QName nodeType, final ListNodeBuilder> builder) throws IOException { - LOG.debug("Reading children of leaf set"); + LOG.trace("Reading children of leaf set"); lastLeafSetQName = nodeType; LeafSetEntryNode child = (LeafSetEntryNode)readNormalizedNodeInternal(); - while(child != null) { + while (child != null) { builder.withChild(child); child = (LeafSetEntryNode)readNormalizedNodeInternal(); } @@ -417,11 +433,11 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, @SuppressWarnings({ "unchecked", "rawtypes" }) private NormalizedNodeContainerBuilder addDataContainerChildren( final NormalizedNodeContainerBuilder builder) throws IOException { - LOG.debug("Reading data container (leaf nodes) nodes"); + LOG.trace("Reading data container (leaf nodes) nodes"); NormalizedNode child = readNormalizedNodeInternal(); - while(child != null) { + while (child != null) { builder.addChild(child); child = readNormalizedNodeInternal(); } @@ -429,21 +445,21 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput, } @Override - public void readFully(final byte[] b) throws IOException { + public void readFully(final byte[] value) throws IOException { readSignatureMarkerAndVersionIfNeeded(); - input.readFully(b); + input.readFully(value); } @Override - public void readFully(final byte[] b, final int off, final int len) throws IOException { + public void readFully(final byte[] str, final int off, final int len) throws IOException { readSignatureMarkerAndVersionIfNeeded(); - input.readFully(b, off, len); + input.readFully(str, off, len); } @Override - public int skipBytes(final int n) throws IOException { + public int skipBytes(final int num) throws IOException { readSignatureMarkerAndVersionIfNeeded(); - return input.skipBytes(n); + return input.skipBytes(num); } @Override