BUG 5656 : Entity ownership candidates not removed consistently on leadership change

[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / main / java / org / opendaylight / controller / cluster / datastore / DataTreeCandidatePayload.java

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 bc3d7b02f8dda76d57f91a57ad7d30b3e98bc671..21083618f04f26605a809f68c4277378c64df8f4 100644 (file)
--- 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,11 +18,11 @@ 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;
@@ -56,39 +53,39 @@ 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<DataTreeCandidateNode> 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);
-            writer.writePathArgument(node.getIdentifier());
-            writeChildren(writer, out, node.getChildNodes());
+            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);
-            writer.writePathArgument(node.getIdentifier());
-            writeChildren(writer, out, node.getChildNodes());
+            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:
             out.writeByte(UNMODIFIED);
@@ -98,40 +95,39 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable {
         }
     }
 
-    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:
-                out.writeByte(APPEARED);
-                writeChildren(writer, out, node.getChildNodes());
+                writer.writeByte(APPEARED);
+                writeChildren(writer, node.getChildNodes());
                 break;
             case DELETE:
-                out.writeByte(DELETE);
+                writer.writeByte(DELETE);
                 break;
             case DISAPPEARED:
-                out.writeByte(DISAPPEARED);
-                writeChildren(writer, out, node.getChildNodes());
+                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);
         }
@@ -139,13 +135,12 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable {
         return new DataTreeCandidatePayload(out.toByteArray());
     }
 
-    private static Collection<DataTreeCandidateNode> readChildren(final NormalizedNodeInputStreamReader reader,
-        final DataInput in) throws IOException {
+    private static Collection<DataTreeCandidateNode> readChildren(final NormalizedNodeDataInput in) throws IOException {
         final int size = in.readInt();
         if (size != 0) {
             final Collection<DataTreeCandidateNode> 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);
                 }
@@ -157,10 +152,10 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable {
     }
 
     private static DataTreeCandidateNode readModifiedNode(final ModificationType type,
-            final NormalizedNodeInputStreamReader reader, final DataInput in) throws IOException {
+            final NormalizedNodeDataInput in) throws IOException {
 
-        final PathArgument identifier = reader.readPathArgument();
-        final Collection<DataTreeCandidateNode> children = readChildren(reader, in);
+        final PathArgument identifier = in.readPathArgument();
+        final Collection<DataTreeCandidateNode> children = readChildren(in);
         if (children.isEmpty()) {
             LOG.debug("Modified node {} does not have any children, not instantiating it", identifier);
             return null;
@@ -169,31 +164,30 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable {
         }
     }
 
-    private static DataTreeCandidateNode readNode(final NormalizedNodeInputStreamReader reader,
-            final DataInput in) throws IOException {
+    private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in) throws IOException {
         final byte type = in.readByte();
         switch (type) {
         case APPEARED:
-            return readModifiedNode(ModificationType.APPEARED, reader, in);
+            return readModifiedNode(ModificationType.APPEARED, in);
         case DELETE:
-            return DeletedDataTreeCandidateNode.create(reader.readPathArgument());
+            return DeletedDataTreeCandidateNode.create(in.readPathArgument());
         case DISAPPEARED:
-            return readModifiedNode(ModificationType.DISAPPEARED, reader, in);
+            return readModifiedNode(ModificationType.DISAPPEARED, in);
         case SUBTREE_MODIFIED:
-            return readModifiedNode(ModificationType.SUBTREE_MODIFIED, reader, in);
+            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) {
@@ -201,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());
@@ -217,19 +211,6 @@ final class DataTreeCandidatePayload extends Payload implements Externalizable {
         return parseCandidate(ByteStreams.newDataInput(serialized));
     }
 
-    @Override
-    @Deprecated
-    @SuppressWarnings("rawtypes")
-    public <T> Map<GeneratedExtension, T> encode() {
-        return null;
-    }
-
-    @Override
-    @Deprecated
-    public Payload decode(final AppendEntries.ReplicatedLogEntry.Payload payload) {
-        return null;
-    }
-
     @Override
     public int size() {
         return serialized.length;