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=bb2f5d41d920d5ce97c723fe6bc91cafc5cd6031;hb=285424b294ad2253a2ad405cb2a687d0acb0c982;hp=9201a94de326111856ad7d4d5246264cb9edfe46;hpb=ee0877c07ff700157dd9fc2e445df095c88f79bc;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 index 9201a94de3..bb2f5d41d9 100644 --- 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 @@ -12,6 +12,18 @@ package org.opendaylight.controller.cluster.datastore.node.utils.stream; import com.google.common.base.Preconditions; import com.google.common.base.Strings; +import java.io.DataInput; +import java.io.DataInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.math.BigDecimal; +import java.math.BigInteger; +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 org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.Node; @@ -29,18 +41,6 @@ import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNo import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.DataInput; -import java.io.DataInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; /** * NormalizedNodeInputStreamReader reads the byte stream and constructs the normalized node including its children nodes. @@ -67,6 +67,10 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead private NormalizedNodeAttrBuilder> leafSetEntryBuilder; + private final StringBuilder reusableStringBuilder = new StringBuilder(50); + + private boolean readSignatureMarker = true; + public NormalizedNodeInputStreamReader(InputStream stream) throws IOException { Preconditions.checkNotNull(stream); input = new DataInputStream(stream); @@ -78,6 +82,25 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead @Override public NormalizedNode readNormalizedNode() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return readNormalizedNodeInternal(); + } + + private void readSignatureMarkerAndVersionIfNeeded() throws IOException { + if(readSignatureMarker) { + readSignatureMarker = false; + + byte marker = input.readByte(); + if(marker != NormalizedNodeOutputStreamWriter.SIGNATURE_MARKER) { + throw new InvalidNormalizedNodeStreamException(String.format( + "Invalid signature marker: %d", marker)); + } + + input.readShort(); // read the version - not currently used/needed. + } + } + + private NormalizedNode readNormalizedNodeInternal() throws IOException { // each node should start with a byte byte nodeType = input.readByte(); @@ -147,7 +170,6 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead case NodeTypes.ANY_XML_NODE : LOG.debug("Read xml node"); - Node value = (Node) readObject(); return Builders.anyXmlBuilder().withValue((Node) readObject()).build(); case NodeTypes.MAP_NODE : @@ -196,14 +218,16 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead String namespace = readCodedString(); String revision = readCodedString(); - // Not using stringbuilder as compiler optimizes string concatenation of + String qName; if(!Strings.isNullOrEmpty(revision)) { - qName = "(" + namespace + REVISION_ARG + revision + ")" +localName; + qName = reusableStringBuilder.append('(').append(namespace).append(REVISION_ARG). + append(revision).append(')').append(localName).toString(); } else { - qName = "(" + namespace + ")" + localName; + qName = reusableStringBuilder.append('(').append(namespace).append(')'). + append(localName).toString(); } + reusableStringBuilder.delete(0, reusableStringBuilder.length()); return QNameFactory.create(qName); } @@ -213,7 +237,7 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead if(valueType == NormalizedNodeOutputStreamWriter.IS_CODE_VALUE) { return codedStringMap.get(input.readInt()); } else if(valueType == NormalizedNodeOutputStreamWriter.IS_STRING_VALUE) { - String value = input.readUTF(); + String value = input.readUTF().intern(); codedStringMap.put(Integer.valueOf(codedStringMap.size()), value); return value; } @@ -249,22 +273,22 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead return readObjSet(); case ValueTypes.BOOL_TYPE : - return input.readBoolean(); + return Boolean.valueOf(input.readBoolean()); case ValueTypes.BYTE_TYPE : - return input.readByte(); + return Byte.valueOf(input.readByte()); case ValueTypes.INT_TYPE : - return input.readInt(); + return Integer.valueOf(input.readInt()); case ValueTypes.LONG_TYPE : - return input.readLong(); + return Long.valueOf(input.readLong()); case ValueTypes.QNAME_TYPE : return readQName(); case ValueTypes.SHORT_TYPE : - return input.readShort(); + return Short.valueOf(input.readShort()); case ValueTypes.STRING_TYPE : return input.readUTF(); @@ -275,8 +299,13 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead case ValueTypes.BIG_INTEGER_TYPE : return new BigInteger(input.readUTF()); + case ValueTypes.BINARY_TYPE : + byte[] bytes = new byte[input.readInt()]; + input.readFully(bytes); + return bytes; + case ValueTypes.YANG_IDENTIFIER_TYPE : - return readYangInstanceIdentifier(); + return readYangInstanceIdentifierInternal(); default : return null; @@ -284,6 +313,11 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead } public YangInstanceIdentifier readYangInstanceIdentifier() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return readYangInstanceIdentifierInternal(); + } + + private YangInstanceIdentifier readYangInstanceIdentifierInternal() throws IOException { int size = input.readInt(); List pathArguments = new ArrayList<>(size); @@ -313,13 +347,13 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead return new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); case PathArgumentTypes.NODE_IDENTIFIER : - return new NodeIdentifier(readQName()); + return new NodeIdentifier(readQName()); case PathArgumentTypes.NODE_IDENTIFIER_WITH_PREDICATES : - return new NodeIdentifierWithPredicates(readQName(), readKeyValueMap()); + return new NodeIdentifierWithPredicates(readQName(), readKeyValueMap()); case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE : - return new NodeWithValue(readQName(), readObject()); + return new NodeWithValue(readQName(), readObject()); default : return null; @@ -334,11 +368,11 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead lastLeafSetQName = nodeType; - LeafSetEntryNode child = (LeafSetEntryNode)readNormalizedNode(); + LeafSetEntryNode child = (LeafSetEntryNode)readNormalizedNodeInternal(); while(child != null) { builder.withChild(child); - child = (LeafSetEntryNode)readNormalizedNode(); + child = (LeafSetEntryNode)readNormalizedNodeInternal(); } return builder; } @@ -348,11 +382,11 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead NormalizedNodeContainerBuilder builder) throws IOException { LOG.debug("Reading data container (leaf nodes) nodes"); - NormalizedNode child = readNormalizedNode(); + NormalizedNode child = readNormalizedNodeInternal(); while(child != null) { builder.addChild(child); - child = readNormalizedNode(); + child = readNormalizedNodeInternal(); } return builder; }