X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-clustering-commons%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fnode%2Futils%2Fstream%2FNormalizedNodeInputStreamReader.java;h=3f6cbb743bc26568583b248a7276b87a11b3efa3;hp=797258b4438cc61825524136ecb0b6aa4ff2aa5e;hb=70a1d4634bd92bf970077e269dc4433d1719f6fb;hpb=57a36381ae7f6624a14fe9009783f5edb930fe72 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 797258b443..3f6cbb743b 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 @@ -1,50 +1,45 @@ /* + * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved. * - * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.controller.cluster.datastore.node.utils.stream; import com.google.common.base.Preconditions; -import org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory; -import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.Node; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; -import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; -import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode; -import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; -import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; -import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; -import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; -import org.opendaylight.yangtools.yang.data.api.schema.MapNode; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode; -import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode; -import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode; -import org.opendaylight.yangtools.yang.data.impl.schema.Builders; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +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.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.transform.dom.DOMSource; +import org.opendaylight.controller.cluster.datastore.node.utils.QNameFactory; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; +import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +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.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * NormalizedNodeInputStreamReader reads the byte stream and constructs the normalized node including its children nodes. @@ -53,147 +48,189 @@ import java.util.Set; * */ -public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamReader { +public class NormalizedNodeInputStreamReader implements NormalizedNodeDataInput { private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeInputStreamReader.class); private static final String REVISION_ARG = "?revision="; - private final DataInputStream reader; + private final DataInput input; private final Map codedStringMap = new HashMap<>(); private QName lastLeafSetQName; - public NormalizedNodeInputStreamReader(InputStream stream) throws IOException { - Preconditions.checkNotNull(stream); - reader = new DataInputStream(stream); + private NormalizedNodeAttrBuilder> leafBuilder; + + 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; } @Override public NormalizedNode readNormalizedNode() throws IOException { - NormalizedNode node = null; + readSignatureMarkerAndVersionIfNeeded(); + return readNormalizedNodeInternal(); + } + + private void readSignatureMarkerAndVersionIfNeeded() throws IOException { + if(readSignatureMarker) { + readSignatureMarker = false; + + final byte marker = input.readByte(); + if (marker != TokenTypes.SIGNATURE_MARKER) { + throw new InvalidNormalizedNodeStreamException(String.format( + "Invalid signature marker: %d", marker)); + } + + final short version = input.readShort(); + if (version != TokenTypes.LITHIUM_VERSION) { + throw new InvalidNormalizedNodeStreamException(String.format("Unhandled stream version %s", version)); + } + } + } + private NormalizedNode readNormalizedNodeInternal() throws IOException { // each node should start with a byte - byte nodeType = reader.readByte(); + byte nodeType = input.readByte(); if(nodeType == NodeTypes.END_NODE) { LOG.debug("End node reached. return"); return null; } - else if(nodeType == NodeTypes.AUGMENTATION_NODE) { - LOG.debug("Reading augmentation node. will create augmentation identifier"); - YangInstanceIdentifier.AugmentationIdentifier identifier = - new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); - DataContainerNodeBuilder augmentationBuilder = - Builders.augmentationBuilder().withNodeIdentifier(identifier); - augmentationBuilder = addDataContainerChildren(augmentationBuilder); - node = augmentationBuilder.build(); + switch(nodeType) { + case NodeTypes.AUGMENTATION_NODE : + YangInstanceIdentifier.AugmentationIdentifier augIdentifier = + new YangInstanceIdentifier.AugmentationIdentifier(readQNameSet()); - } else { - if(nodeType == NodeTypes.LEAF_SET_ENTRY_NODE) { - LOG.debug("Reading leaf set entry node. Will create NodeWithValue instance identifier"); + LOG.debug("Reading augmentation node {} ", augIdentifier); + + return addDataContainerChildren(Builders.augmentationBuilder(). + withNodeIdentifier(augIdentifier)).build(); + + case NodeTypes.LEAF_SET_ENTRY_NODE : + QName name = lastLeafSetQName; + if(name == null) { + name = readQName(); + } - // Read the object value Object value = readObject(); + NodeWithValue leafIdentifier = new NodeWithValue<>(name, value); + + LOG.debug("Reading leaf set entry node {}, value {}", leafIdentifier, value); - YangInstanceIdentifier.NodeWithValue nodeWithValue = new YangInstanceIdentifier.NodeWithValue( - lastLeafSetQName, value); - node = Builders.leafSetEntryBuilder().withNodeIdentifier(nodeWithValue). - withValue(value).build(); + return leafSetEntryBuilder().withNodeIdentifier(leafIdentifier).withValue(value).build(); - } else if(nodeType == NodeTypes.MAP_ENTRY_NODE) { - LOG.debug("Reading map entry node. Will create node identifier with predicates."); + case NodeTypes.MAP_ENTRY_NODE : + NodeIdentifierWithPredicates entryIdentifier = new NodeIdentifierWithPredicates( + readQName(), readKeyValueMap()); - QName qName = readQName(); - YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier = - new YangInstanceIdentifier.NodeIdentifierWithPredicates(qName, readKeyValueMap()); - DataContainerNodeAttrBuilder mapEntryBuilder - = Builders.mapEntryBuilder().withNodeIdentifier(nodeIdentifier); + LOG.debug("Reading map entry node {} ", entryIdentifier); - mapEntryBuilder = (DataContainerNodeAttrBuilder)addDataContainerChildren(mapEntryBuilder); - node = mapEntryBuilder.build(); + return addDataContainerChildren(Builders.mapEntryBuilder(). + withNodeIdentifier(entryIdentifier)).build(); - } else { - LOG.debug("Creating standard node identifier. "); + default : + return readNodeIdentifierDependentNode(nodeType, new NodeIdentifier(readQName())); + } + } + + private NormalizedNodeAttrBuilder> leafBuilder() { + if(leafBuilder == null) { + leafBuilder = Builders.leafBuilder(); + } - QName qName = readQName(); - YangInstanceIdentifier.NodeIdentifier identifier = new YangInstanceIdentifier.NodeIdentifier(qName); - node = readNodeIdentifierDependentNode(nodeType, identifier); + return leafBuilder; + } - } + private NormalizedNodeAttrBuilder> leafSetEntryBuilder() { + if(leafSetEntryBuilder == null) { + leafSetEntryBuilder = Builders.leafSetEntryBuilder(); } - return node; + + return leafSetEntryBuilder; } - private NormalizedNode readNodeIdentifierDependentNode(byte nodeType, YangInstanceIdentifier.NodeIdentifier identifier) + private NormalizedNode readNodeIdentifierDependentNode(final byte nodeType, final NodeIdentifier identifier) throws IOException { switch(nodeType) { case NodeTypes.LEAF_NODE : - LOG.debug("Read leaf node"); + LOG.debug("Read leaf node {}", identifier); // Read the object value - NormalizedNodeAttrBuilder leafBuilder = Builders.leafBuilder(); - return leafBuilder.withNodeIdentifier(identifier).withValue(readObject()).build(); + return leafBuilder().withNodeIdentifier(identifier).withValue(readObject()).build(); case NodeTypes.ANY_XML_NODE : LOG.debug("Read xml node"); - Node value = (Node) readObject(); - return Builders.anyXmlBuilder().withValue(value).build(); + return Builders.anyXmlBuilder().withValue((DOMSource) readObject()).build(); case NodeTypes.MAP_NODE : - LOG.debug("Read map node"); - CollectionNodeBuilder mapBuilder = Builders.mapBuilder().withNodeIdentifier(identifier); - mapBuilder = addMapNodeChildren(mapBuilder); - return mapBuilder.build(); + LOG.debug("Read map node {}", identifier); + return addDataContainerChildren(Builders.mapBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.CHOICE_NODE : - LOG.debug("Read choice node"); - DataContainerNodeBuilder choiceBuilder = - Builders.choiceBuilder().withNodeIdentifier(identifier); - choiceBuilder = addDataContainerChildren(choiceBuilder); - return choiceBuilder.build(); + LOG.debug("Read choice node {}", identifier); + return addDataContainerChildren(Builders.choiceBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.ORDERED_MAP_NODE : - LOG.debug("Reading ordered map node"); - CollectionNodeBuilder orderedMapBuilder = - Builders.orderedMapBuilder().withNodeIdentifier(identifier); - orderedMapBuilder = addMapNodeChildren(orderedMapBuilder); - return orderedMapBuilder.build(); + LOG.debug("Reading ordered map node {}", identifier); + return addDataContainerChildren(Builders.orderedMapBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.UNKEYED_LIST : - LOG.debug("Read unkeyed list node"); - CollectionNodeBuilder unkeyedListBuilder = - Builders.unkeyedListBuilder().withNodeIdentifier(identifier); - unkeyedListBuilder = addUnkeyedListChildren(unkeyedListBuilder); - return unkeyedListBuilder.build(); + 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"); - DataContainerNodeAttrBuilder unkeyedListEntryBuilder - = Builders.unkeyedListEntryBuilder().withNodeIdentifier(identifier); - - unkeyedListEntryBuilder = (DataContainerNodeAttrBuilder) - addDataContainerChildren(unkeyedListEntryBuilder); - return unkeyedListEntryBuilder.build(); + LOG.debug("Read unkeyed list item node {}", identifier); + return addDataContainerChildren(Builders.unkeyedListEntryBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.CONTAINER_NODE : - LOG.debug("Read container node"); - DataContainerNodeAttrBuilder containerBuilder = - Builders.containerBuilder().withNodeIdentifier(identifier); - - containerBuilder = (DataContainerNodeAttrBuilder) - addDataContainerChildren(containerBuilder); - return containerBuilder.build(); + LOG.debug("Read container node {}", identifier); + return addDataContainerChildren(Builders.containerBuilder(). + withNodeIdentifier(identifier)).build(); case NodeTypes.LEAF_SET : - LOG.debug("Read leaf set node"); - ListNodeBuilder> leafSetBuilder = - Builders.leafSetBuilder().withNodeIdentifier(identifier); - leafSetBuilder = addLeafSetChildren(identifier.getNodeType(), leafSetBuilder); - return leafSetBuilder.build(); + LOG.debug("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(); default : return null; @@ -205,46 +242,49 @@ public class NormalizedNodeInputStreamReader implements NormalizedNodeStreamRead String localName = readCodedString(); String namespace = readCodedString(); String revision = readCodedString(); + String qName; - // Not using stringbuilder as compiler optimizes string concatenation of + - if(revision != null){ - qName = "(" + namespace+ REVISION_ARG + revision + ")" +localName; + if(!Strings.isNullOrEmpty(revision)) { + 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); } private String readCodedString() throws IOException { - boolean readFromMap = reader.readBoolean(); - if(readFromMap) { - return codedStringMap.get(reader.readInt()); - } else { - String value = reader.readUTF(); - if(value != null) { - codedStringMap.put(Integer.valueOf(codedStringMap.size()), value); - } + byte valueType = input.readByte(); + if(valueType == TokenTypes.IS_CODE_VALUE) { + return codedStringMap.get(input.readInt()); + } else if(valueType == TokenTypes.IS_STRING_VALUE) { + String value = input.readUTF().intern(); + codedStringMap.put(Integer.valueOf(codedStringMap.size()), value); return value; } + + return null; } private Set readQNameSet() throws IOException{ // Read the children count - int count = reader.readInt(); + int count = input.readInt(); Set children = new HashSet<>(count); - for(int i = 0; i readKeyValueMap() throws IOException { - int count = reader.readInt(); + int count = input.readInt(); Map keyValueMap = new HashMap<>(count); - for(int i = 0; i pathArguments = new ArrayList<>(size); + case ValueTypes.BINARY_TYPE : + byte[] bytes = new byte[input.readInt()]; + input.readFully(bytes); + return bytes; - for(int i=0; i pathArguments = new ArrayList<>(size); + + for(int i = 0; i < size; i++) { + pathArguments.add(readPathArgument()); + } + return YangInstanceIdentifier.create(pathArguments); + } + private Set readObjSet() throws IOException { - int count = reader.readInt(); + int count = input.readInt(); Set children = new HashSet<>(count); - for(int i = 0; i(readQName(), readObject()); default : return null; } } - private ListNodeBuilder> addLeafSetChildren(QName nodeType, - ListNodeBuilder> builder) - throws IOException { + @SuppressWarnings("unchecked") + private ListNodeBuilder> addLeafSetChildren(final QName nodeType, + final ListNodeBuilder> builder) throws IOException { LOG.debug("Reading children of leaf set"); lastLeafSetQName = nodeType; - LeafSetEntryNode child = (LeafSetEntryNode)readNormalizedNode(); + LeafSetEntryNode child = (LeafSetEntryNode)readNormalizedNodeInternal(); while(child != null) { builder.withChild(child); - child = (LeafSetEntryNode)readNormalizedNode(); + child = (LeafSetEntryNode)readNormalizedNodeInternal(); } return builder; } - private CollectionNodeBuilder addUnkeyedListChildren( - CollectionNodeBuilder builder) - throws IOException{ + @SuppressWarnings({ "unchecked", "rawtypes" }) + private NormalizedNodeContainerBuilder addDataContainerChildren( + final NormalizedNodeContainerBuilder builder) throws IOException { + LOG.debug("Reading data container (leaf nodes) nodes"); - LOG.debug("Reading children of unkeyed list"); - UnkeyedListEntryNode child = (UnkeyedListEntryNode)readNormalizedNode(); + NormalizedNode child = readNormalizedNodeInternal(); while(child != null) { - builder.withChild(child); - child = (UnkeyedListEntryNode)readNormalizedNode(); + builder.addChild(child); + child = readNormalizedNodeInternal(); } return builder; } - private DataContainerNodeBuilder addDataContainerChildren(DataContainerNodeBuilder builder) - throws IOException { - LOG.debug("Reading data container (leaf nodes) nodes"); + @Override + public void readFully(final byte[] b) throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + input.readFully(b); + } - DataContainerChild child = - (DataContainerChild) readNormalizedNode(); + @Override + public void readFully(final byte[] b, final int off, final int len) throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + input.readFully(b, off, len); + } - while(child != null) { - builder.withChild(child); - child = - (DataContainerChild) readNormalizedNode(); - } - return builder; + @Override + public int skipBytes(final int n) throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.skipBytes(n); } + @Override + public boolean readBoolean() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readBoolean(); + } - private CollectionNodeBuilder addMapNodeChildren(CollectionNodeBuilder builder) - throws IOException { - LOG.debug("Reading map node children"); - MapEntryNode child = (MapEntryNode)readNormalizedNode(); + @Override + public byte readByte() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readByte(); + } - while(child != null){ - builder.withChild(child); - child = (MapEntryNode)readNormalizedNode(); - } + @Override + public int readUnsignedByte() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readUnsignedByte(); + } - return builder; + @Override + public short readShort() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readShort(); + } + + @Override + public int readUnsignedShort() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readUnsignedShort(); + } + + @Override + public char readChar() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readChar(); + } + + @Override + public int readInt() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readInt(); } + @Override + public long readLong() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readLong(); + } @Override - public void close() throws IOException { - reader.close(); + public float readFloat() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readFloat(); } + @Override + public double readDouble() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readDouble(); + } + + @Override + public String readLine() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readLine(); + } + + @Override + public String readUTF() throws IOException { + readSignatureMarkerAndVersionIfNeeded(); + return input.readUTF(); + } }