X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fpersisted%2FDataTreeCandidateInputOutput.java;h=a3b30466c87e9d94bccdbe1702bae08adeab8282;hb=1d5ca4009be6c61d7b61989799037ad8f1ab7a75;hp=3b7269295d437d1e3177a34a8708d26583e399df;hpb=906ac818a31d76ca4aa1b014649272a6aad2de6c;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 3b7269295d..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 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,11 +53,10 @@ 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; @@ -60,7 +65,8 @@ public final class DataTreeCandidateInputOutput { 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) { return ImmutableList.of(); @@ -68,7 +74,7 @@ public final class DataTreeCandidateInputOutput { final Collection ret = new ArrayList<>(size); for (int i = 0; i < size; ++i) { - final DataTreeCandidateNode child = readNode(in); + final DataTreeCandidateNode child = readNode(in, receiver); if (child != null) { ret.add(child); } @@ -76,48 +82,72 @@ public final class DataTreeCandidateInputOutput { 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.written(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.written(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,9 +202,10 @@ public final class DataTreeCandidateInputOutput { } } - public static void writeDataTreeCandidate(final DataOutput out, final 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(); @@ -207,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()); }