X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FDataTreeCandidatePayload.java;h=21083618f04f26605a809f68c4277378c64df8f4;hp=54167b2011d0585645f2633e6169ab1ebde8cbc1;hb=b14856a01f6515e6063f82e5fb448f7e9a57029b;hpb=dea515c8870769408b9bea29f555d6b71ff43211 diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCandidatePayload.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCandidatePayload.java index 54167b2011..21083618f0 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCandidatePayload.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCandidatePayload.java @@ -11,9 +11,6 @@ import com.google.common.base.Preconditions; import com.google.common.io.ByteArrayDataInput; import com.google.common.io.ByteArrayDataOutput; import com.google.common.io.ByteStreams; -import com.google.protobuf.GeneratedMessage.GeneratedExtension; -import java.io.DataInput; -import java.io.DataOutput; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; @@ -21,17 +18,18 @@ import java.io.ObjectOutput; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; -import java.util.Map; +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.NormalizedNodeInputStreamReader; -import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeOutputStreamWriter; +import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputOutput; import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload; -import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages.AppendEntries; 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.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -42,6 +40,8 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable { private static final byte SUBTREE_MODIFIED = 1; private static final byte UNMODIFIED = 2; private static final byte WRITE = 3; + private static final byte APPEARED = 4; + private static final byte DISAPPEARED = 5; private transient byte[] serialized; @@ -53,63 +53,81 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable { this.serialized = Preconditions.checkNotNull(serialized); } - private static void writeChildren(final NormalizedNodeOutputStreamWriter writer, final DataOutput out, + private static void writeChildren(final NormalizedNodeDataOutput out, final Collection children) throws IOException { out.writeInt(children.size()); for (DataTreeCandidateNode child : children) { - writeNode(writer, out, child); + writeNode(out, child); } } - private static void writeNode(final NormalizedNodeOutputStreamWriter writer, final DataOutput out, - final DataTreeCandidateNode node) throws IOException { + private static void writeNode(final NormalizedNodeDataOutput out, final DataTreeCandidateNode node) + throws IOException { switch (node.getModificationType()) { + case APPEARED: + out.writeByte(APPEARED); + out.writePathArgument(node.getIdentifier()); + writeChildren(out, node.getChildNodes()); + break; case DELETE: out.writeByte(DELETE); - writer.writePathArgument(node.getIdentifier()); + out.writePathArgument(node.getIdentifier()); + break; + case DISAPPEARED: + out.writeByte(DISAPPEARED); + out.writePathArgument(node.getIdentifier()); + writeChildren(out, node.getChildNodes()); break; case SUBTREE_MODIFIED: out.writeByte(SUBTREE_MODIFIED); - writer.writePathArgument(node.getIdentifier()); - writeChildren(writer, out, node.getChildNodes()); + out.writePathArgument(node.getIdentifier()); + writeChildren(out, node.getChildNodes()); break; case WRITE: out.writeByte(WRITE); - writer.writeNormalizedNode(node.getDataAfter().get()); + out.writeNormalizedNode(node.getDataAfter().get()); break; case UNMODIFIED: - throw new IllegalArgumentException("Unmodified candidate should never be in the payload"); + out.writeByte(UNMODIFIED); + break; default: throw new IllegalArgumentException("Unhandled node type " + node.getModificationType()); } } - static DataTreeCandidatePayload create(DataTreeCandidate candidate) { + static DataTreeCandidatePayload create(final DataTreeCandidate candidate) { final ByteArrayDataOutput out = ByteStreams.newDataOutput(); - try (final NormalizedNodeOutputStreamWriter writer = new NormalizedNodeOutputStreamWriter(out)) { + try (final NormalizedNodeDataOutput writer = NormalizedNodeInputOutput.newDataOutput(out)) { writer.writeYangInstanceIdentifier(candidate.getRootPath()); final DataTreeCandidateNode node = candidate.getRootNode(); switch (node.getModificationType()) { + case APPEARED: + writer.writeByte(APPEARED); + writeChildren(writer, node.getChildNodes()); + break; case DELETE: - out.writeByte(DELETE); + writer.writeByte(DELETE); + break; + case DISAPPEARED: + writer.writeByte(DISAPPEARED); + writeChildren(writer, node.getChildNodes()); break; case SUBTREE_MODIFIED: - out.writeByte(SUBTREE_MODIFIED); - writeChildren(writer, out, node.getChildNodes()); + writer.writeByte(SUBTREE_MODIFIED); + writeChildren(writer, node.getChildNodes()); break; case UNMODIFIED: - out.writeByte(UNMODIFIED); + writer.writeByte(UNMODIFIED); break; case WRITE: - out.writeByte(WRITE); + writer.writeByte(WRITE); writer.writeNormalizedNode(node.getDataAfter().get()); break; default: throw new IllegalArgumentException("Unhandled node type " + node.getModificationType()); } - writer.close(); } catch (IOException e) { throw new IllegalArgumentException(String.format("Failed to serialize candidate %s", candidate), e); } @@ -117,13 +135,12 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable { return new DataTreeCandidatePayload(out.toByteArray()); } - private static Collection readChildren(final NormalizedNodeInputStreamReader reader, - final DataInput in) throws IOException { + private static Collection readChildren(final NormalizedNodeDataInput in) 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(reader, in); + final DataTreeCandidateNode child = readNode(in); if (child != null) { ret.add(child); } @@ -134,34 +151,43 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable { } } - private static DataTreeCandidateNode readNode(final NormalizedNodeInputStreamReader reader, - final DataInput in) throws IOException { + private static DataTreeCandidateNode readModifiedNode(final ModificationType type, + final NormalizedNodeDataInput in) throws IOException { + + final PathArgument identifier = in.readPathArgument(); + final Collection children = readChildren(in); + 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); + } + } + + private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in) throws IOException { final byte type = in.readByte(); switch (type) { + case APPEARED: + return readModifiedNode(ModificationType.APPEARED, in); case DELETE: - return DeletedDataTreeCandidateNode.create(reader.readPathArgument()); + return DeletedDataTreeCandidateNode.create(in.readPathArgument()); + case DISAPPEARED: + return readModifiedNode(ModificationType.DISAPPEARED, in); case SUBTREE_MODIFIED: - final PathArgument identifier = reader.readPathArgument(); - final Collection children = readChildren(reader, in); - if (children.isEmpty()) { - LOG.debug("Modified node {} does not have any children, not instantiating it", identifier); - return null; - } else { - return ModifiedDataTreeCandidateNode.create(identifier, children); - } + return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in); case UNMODIFIED: return null; case WRITE: - return DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode()); + return DataTreeCandidateNodes.fromNormalizedNode(in.readNormalizedNode()); default: throw new IllegalArgumentException("Unhandled node type " + type); } } private static DataTreeCandidate parseCandidate(final ByteArrayDataInput in) throws IOException { - final NormalizedNodeInputStreamReader reader = new NormalizedNodeInputStreamReader(in); + final NormalizedNodeDataInput reader = new NormalizedNodeInputStreamReader(in); final YangInstanceIdentifier rootPath = reader.readYangInstanceIdentifier(); - final byte type = in.readByte(); + final byte type = reader.readByte(); final DataTreeCandidateNode rootNode; switch (type) { @@ -169,7 +195,7 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable { rootNode = DeletedDataTreeCandidateNode.create(); break; case SUBTREE_MODIFIED: - rootNode = ModifiedDataTreeCandidateNode.create(readChildren(reader, in)); + rootNode = ModifiedDataTreeCandidateNode.create(readChildren(reader)); break; case WRITE: rootNode = DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode()); @@ -185,19 +211,6 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable { return parseCandidate(ByteStreams.newDataInput(serialized)); } - @Override - @Deprecated - @SuppressWarnings("rawtypes") - public Map encode() { - return null; - } - - @Override - @Deprecated - public Payload decode(final AppendEntries.ReplicatedLogEntry.Payload payload) { - return null; - } - @Override public int size() { return serialized.length;