X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;ds=sidebyside;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fpersisted%2FDataTreeCandidateInputOutput.java;h=a3b30466c87e9d94bccdbe1702bae08adeab8282;hb=1d5ca4009be6c61d7b61989799037ad8f1ab7a75;hp=bc1fca165544174c96043136a9f98e176c57e777;hpb=8232a626b43fdd2f5799da0fbcfb0f02d3c8f4fb;p=controller.git diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java index bc1fca1655..a3b30466c8 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java @@ -7,23 +7,29 @@ */ package org.opendaylight.controller.cluster.datastore.persisted; +import static java.util.Objects.requireNonNull; + import com.google.common.annotations.Beta; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableList; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; -import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataInput; -import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput; -import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputOutput; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNodes; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; +import org.opendaylight.yangtools.yang.data.api.schema.stream.ReusableStreamReceiver; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataOutput; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion; +import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate; +import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode; +import org.opendaylight.yangtools.yang.data.tree.api.ModificationType; +import org.opendaylight.yangtools.yang.data.tree.spi.DataTreeCandidateNodes; +import org.opendaylight.yangtools.yang.data.tree.spi.DataTreeCandidates; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -47,77 +53,101 @@ public final class DataTreeCandidateInputOutput { throw new UnsupportedOperationException(); } - private static DataTreeCandidateNode readModifiedNode(final ModificationType type, - final NormalizedNodeDataInput in) throws IOException { - + private static DataTreeCandidateNode readModifiedNode(final ModificationType type, final NormalizedNodeDataInput in, + final ReusableStreamReceiver receiver) throws IOException { final PathArgument identifier = in.readPathArgument(); - final Collection children = readChildren(in); + final Collection children = readChildren(in, receiver); if (children.isEmpty()) { LOG.debug("Modified node {} does not have any children, not instantiating it", identifier); return null; - } else { - return ModifiedDataTreeCandidateNode.create(identifier, type, children); } + + return ModifiedDataTreeCandidateNode.create(identifier, type, children); } - private static Collection readChildren(final NormalizedNodeDataInput in) throws IOException { + private static Collection readChildren(final NormalizedNodeDataInput in, + final ReusableStreamReceiver receiver) throws IOException { final int size = in.readInt(); - if (size != 0) { - final Collection ret = new ArrayList<>(size); - for (int i = 0; i < size; ++i) { - final DataTreeCandidateNode child = readNode(in); - if (child != null) { - ret.add(child); - } + if (size == 0) { + return ImmutableList.of(); + } + + final Collection ret = new ArrayList<>(size); + for (int i = 0; i < size; ++i) { + final DataTreeCandidateNode child = readNode(in, receiver); + if (child != null) { + ret.add(child); } - return ret; - } else { - return Collections.emptyList(); } + return ret; } - private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in) throws IOException { + private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in, + final ReusableStreamReceiver receiver) throws IOException { final byte type = in.readByte(); switch (type) { case APPEARED: - return readModifiedNode(ModificationType.APPEARED, in); + return readModifiedNode(ModificationType.APPEARED, in, receiver); case DELETE: return DeletedDataTreeCandidateNode.create(in.readPathArgument()); case DISAPPEARED: - return readModifiedNode(ModificationType.DISAPPEARED, in); + return readModifiedNode(ModificationType.DISAPPEARED, in, receiver); case SUBTREE_MODIFIED: - return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in); + return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in, receiver); case UNMODIFIED: return null; case WRITE: - return DataTreeCandidateNodes.fromNormalizedNode(in.readNormalizedNode()); + return DataTreeCandidateNodes.written(in.readNormalizedNode(receiver)); default: throw new IllegalArgumentException("Unhandled node type " + type); } } - public static DataTreeCandidate readDataTreeCandidate(final DataInput in) throws IOException { - final NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput(in); + @NonNullByDefault + public static final class DataTreeCandidateWithVersion implements Immutable { + private final DataTreeCandidate candidate; + private final NormalizedNodeStreamVersion version; + + public DataTreeCandidateWithVersion(final DataTreeCandidate candidate, + final NormalizedNodeStreamVersion version) { + this.candidate = requireNonNull(candidate); + this.version = requireNonNull(version); + } + + public DataTreeCandidate getCandidate() { + return candidate; + } + + public NormalizedNodeStreamVersion getVersion() { + return version; + } + } + + public static DataTreeCandidateWithVersion readDataTreeCandidate(final DataInput in, + final ReusableStreamReceiver receiver) throws IOException { + final NormalizedNodeDataInput reader = NormalizedNodeDataInput.newDataInput(in); final YangInstanceIdentifier rootPath = reader.readYangInstanceIdentifier(); final byte type = reader.readByte(); final DataTreeCandidateNode rootNode; switch (type) { case APPEARED: - rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.APPEARED, readChildren(reader)); + rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.APPEARED, + readChildren(reader, receiver)); break; case DELETE: rootNode = DeletedDataTreeCandidateNode.create(); break; case DISAPPEARED: - rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, readChildren(reader)); + rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, + readChildren(reader, receiver)); break; case SUBTREE_MODIFIED: rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.SUBTREE_MODIFIED, - readChildren(reader)); + readChildren(reader, receiver)); break; case WRITE: - rootNode = DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode()); + rootNode = DataTreeCandidateNodes.written(reader.readNormalizedNode(receiver)); break; case UNMODIFIED: rootNode = AbstractDataTreeCandidateNode.createUnmodified(); @@ -126,10 +156,10 @@ public final class DataTreeCandidateInputOutput { throw new IllegalArgumentException("Unhandled node type " + type); } - return DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode); + return new DataTreeCandidateWithVersion(DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode), + reader.getVersion()); } - private static void writeChildren(final NormalizedNodeDataOutput out, final Collection children) throws IOException { out.writeInt(children.size()); @@ -172,8 +202,10 @@ public final class DataTreeCandidateInputOutput { } } - public static void writeDataTreeCandidate(final DataOutput out, DataTreeCandidate candidate) throws IOException { - try (NormalizedNodeDataOutput writer = NormalizedNodeInputOutput.newDataOutput(out)) { + @VisibleForTesting + public static void writeDataTreeCandidate(final DataOutput out, final PayloadVersion version, + final DataTreeCandidate candidate) throws IOException { + try (NormalizedNodeDataOutput writer = version.getStreamVersion().newDataOutput(out)) { writer.writeYangInstanceIdentifier(candidate.getRootPath()); final DataTreeCandidateNode node = candidate.getRootNode(); @@ -206,6 +238,11 @@ public final class DataTreeCandidateInputOutput { } } + public static void writeDataTreeCandidate(final DataOutput out, final DataTreeCandidate candidate) + throws IOException { + writeDataTreeCandidate(out, PayloadVersion.current(), candidate); + } + private static void throwUnhandledNodeType(final DataTreeCandidateNode node) { throw new IllegalArgumentException("Unhandled node type " + node.getModificationType()); }