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=3737b08b426ae61ca799673ed77af4fafa9ee481;hb=f40e99a51cd3fc2c9be3ac8aa0772bdb6b6ce479;hp=35d9998cd6cda84db2a6d9a7a41c1d729d823b1b;hpb=2658d126f67512fcaac684d2ccb7197fe12f61f4;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 35d9998cd6..3737b08b42 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,57 +82,60 @@ 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); - case DELETE: - return DeletedDataTreeCandidateNode.create(in.readPathArgument()); - case DISAPPEARED: - return readModifiedNode(ModificationType.DISAPPEARED, in); - case SUBTREE_MODIFIED: - return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in); - case UNMODIFIED: - return null; - case WRITE: - return DataTreeCandidateNodes.written(in.readNormalizedNode()); - default: - throw new IllegalArgumentException("Unhandled node type " + type); + return switch (type) { + case APPEARED -> readModifiedNode(ModificationType.APPEARED, in, receiver); + case DELETE -> DeletedDataTreeCandidateNode.create(in.readPathArgument()); + case DISAPPEARED -> readModifiedNode(ModificationType.DISAPPEARED, in, receiver); + case SUBTREE_MODIFIED -> readModifiedNode(ModificationType.SUBTREE_MODIFIED, in, receiver); + case UNMODIFIED -> null; + case WRITE -> DataTreeCandidateNodes.written(in.readNormalizedNode(receiver)); + default -> throw new IllegalArgumentException("Unhandled node type " + type); + }; + } + + @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 DataTreeCandidate readDataTreeCandidate(final DataInput in) throws IOException { - final NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput(in); + 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)); - break; - case DELETE: - rootNode = DeletedDataTreeCandidateNode.create(); - break; - case DISAPPEARED: - rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, readChildren(reader)); - break; - case SUBTREE_MODIFIED: - rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.SUBTREE_MODIFIED, - readChildren(reader)); - break; - case WRITE: - rootNode = DataTreeCandidateNodes.written(reader.readNormalizedNode()); - break; - case UNMODIFIED: - rootNode = AbstractDataTreeCandidateNode.createUnmodified(); - break; - default: - throw new IllegalArgumentException("Unhandled node type " + type); - } - - return DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode); + final DataTreeCandidateNode rootNode = switch (type) { + case APPEARED -> ModifiedDataTreeCandidateNode.create(ModificationType.APPEARED, + readChildren(reader, receiver)); + case DELETE -> DeletedDataTreeCandidateNode.create(); + case DISAPPEARED -> ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, + readChildren(reader, receiver)); + case SUBTREE_MODIFIED -> ModifiedDataTreeCandidateNode.create(ModificationType.SUBTREE_MODIFIED, + readChildren(reader, receiver)); + case WRITE -> DataTreeCandidateNodes.written(reader.readNormalizedNode(receiver)); + case UNMODIFIED -> AbstractDataTreeCandidateNode.createUnmodified(); + default -> throw new IllegalArgumentException("Unhandled node type " + type); + }; + return new DataTreeCandidateWithVersion(DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode), + reader.getVersion()); } private static void writeChildren(final NormalizedNodeDataOutput out, @@ -139,29 +148,29 @@ public final class DataTreeCandidateInputOutput { private static void writeNode(final NormalizedNodeDataOutput out, final DataTreeCandidateNode node) throws IOException { - switch (node.getModificationType()) { + switch (node.modificationType()) { case APPEARED: out.writeByte(APPEARED); - out.writePathArgument(node.getIdentifier()); - writeChildren(out, node.getChildNodes()); + out.writePathArgument(node.name()); + writeChildren(out, node.childNodes()); break; case DELETE: out.writeByte(DELETE); - out.writePathArgument(node.getIdentifier()); + out.writePathArgument(node.name()); break; case DISAPPEARED: out.writeByte(DISAPPEARED); - out.writePathArgument(node.getIdentifier()); - writeChildren(out, node.getChildNodes()); + out.writePathArgument(node.name()); + writeChildren(out, node.childNodes()); break; case SUBTREE_MODIFIED: out.writeByte(SUBTREE_MODIFIED); - out.writePathArgument(node.getIdentifier()); - writeChildren(out, node.getChildNodes()); + out.writePathArgument(node.name()); + writeChildren(out, node.childNodes()); break; case WRITE: out.writeByte(WRITE); - out.writeNormalizedNode(node.getDataAfter().get()); + out.writeNormalizedNode(node.findDataAfter().orElseThrow()); break; case UNMODIFIED: out.writeByte(UNMODIFIED); @@ -171,35 +180,35 @@ public final class DataTreeCandidateInputOutput { } } - public static void writeDataTreeCandidate(final DataOutput out, final DataTreeCandidate candidate) - throws IOException { - try (NormalizedNodeDataOutput writer = NormalizedNodeInputOutput.newDataOutput(out, - PayloadVersion.current().getStreamVersion())) { + @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(); - switch (node.getModificationType()) { + switch (node.modificationType()) { case APPEARED: writer.writeByte(APPEARED); - writeChildren(writer, node.getChildNodes()); + writeChildren(writer, node.childNodes()); break; case DELETE: writer.writeByte(DELETE); break; case DISAPPEARED: writer.writeByte(DISAPPEARED); - writeChildren(writer, node.getChildNodes()); + writeChildren(writer, node.childNodes()); break; case SUBTREE_MODIFIED: writer.writeByte(SUBTREE_MODIFIED); - writeChildren(writer, node.getChildNodes()); + writeChildren(writer, node.childNodes()); break; case UNMODIFIED: writer.writeByte(UNMODIFIED); break; case WRITE: writer.writeByte(WRITE); - writer.writeNormalizedNode(node.getDataAfter().get()); + writer.writeNormalizedNode(node.findDataAfter().orElseThrow()); break; default: throwUnhandledNodeType(node); @@ -207,7 +216,12 @@ 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()); + throw new IllegalArgumentException("Unhandled node type " + node.modificationType()); } }