X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-remoterpc-connector%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fremote%2Frpc%2Fregistry%2Fgossip%2FMessages.java;h=361f5b7e1c07bf4b3cf07539a58bdf421cf177bb;hp=00437e7e5639fc382e8b1434d4b02495ef1ac56e;hb=5fd4213b5bfaf2db21f1b37139f6b98535a872c0;hpb=a8cdfe15e97b0ca8f683a2d0aed1b37ab15618e0

diff --git a/opendaylight/md-sal/sal-remoterpc-connector/src/main/java/org/opendaylight/controller/remote/rpc/registry/gossip/Messages.java b/opendaylight/md-sal/sal-remoterpc-connector/src/main/java/org/opendaylight/controller/remote/rpc/registry/gossip/Messages.java
index 00437e7e56..361f5b7e1c 100644
--- a/opendaylight/md-sal/sal-remoterpc-connector/src/main/java/org/opendaylight/controller/remote/rpc/registry/gossip/Messages.java
+++ b/opendaylight/md-sal/sal-remoterpc-connector/src/main/java/org/opendaylight/controller/remote/rpc/registry/gossip/Messages.java
@@ -9,117 +9,127 @@ package org.opendaylight.controller.remote.rpc.registry.gossip;
 
 import akka.actor.Address;
 import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import java.io.Serializable;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.ContainsBucketVersions;
 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.ContainsBuckets;
 
-
 /**
  * These messages are used by {@link org.opendaylight.controller.remote.rpc.registry.gossip.BucketStore} and
  * {@link org.opendaylight.controller.remote.rpc.registry.gossip.Gossiper} actors.
  */
 public class Messages {
 
-    public static class BucketStoreMessages{
+    public static class BucketStoreMessages {
 
-        public static class GetAllBuckets implements Serializable {
+        public static final class GetAllBuckets implements Serializable {
             private static final long serialVersionUID = 1L;
         }
 
-        public static class GetBucketsByMembers implements Serializable{
+        public static final class GetBucketsByMembers implements Serializable {
             private static final long serialVersionUID = 1L;
             private final Set<Address> members;
 
-            public GetBucketsByMembers(Set<Address> members){
+            public GetBucketsByMembers(final Set<Address> members) {
                 Preconditions.checkArgument(members != null, "members can not be null");
-                this.members = members;
+                this.members = ImmutableSet.copyOf(members);
             }
 
             public Set<Address> getMembers() {
-                return new HashSet<>(members);
+                return members;
             }
         }
 
-        public static class ContainsBuckets implements Serializable{
+        public static class ContainsBuckets<T extends BucketData<T>> implements Serializable {
             private static final long serialVersionUID = -4940160367495308286L;
 
-            private final Map<Address, Bucket> buckets;
+            private final Map<Address, Bucket<T>> buckets;
 
-            public ContainsBuckets(Map<Address, Bucket> buckets){
+            protected ContainsBuckets(final Map<Address, Bucket<T>> buckets) {
                 Preconditions.checkArgument(buckets != null, "buckets can not be null");
-                this.buckets = buckets;
+                this.buckets = Collections.unmodifiableMap(new HashMap<>(buckets));
             }
 
-            public Map<Address, Bucket> getBuckets() {
-                Map<Address, Bucket> copy = new HashMap<>(buckets.size());
-
-                for (Map.Entry<Address, Bucket> entry : buckets.entrySet()){
-                    //ignore null entries
-                    if ( (entry.getKey() == null) || (entry.getValue() == null) ) {
-                        continue;
-                    }
-                    copy.put(entry.getKey(), entry.getValue());
-                }
-                return copy;
+            public final Map<Address, Bucket<T>> getBuckets() {
+                return buckets;
             }
         }
 
-        public static class GetAllBucketsReply extends ContainsBuckets implements Serializable{
+        public static final class GetAllBucketsReply<T extends BucketData<T>> extends ContainsBuckets<T> {
             private static final long serialVersionUID = 1L;
-            public GetAllBucketsReply(Map<Address, Bucket> buckets) {
+
+            public GetAllBucketsReply(final Map<Address, Bucket<T>> buckets) {
                 super(buckets);
             }
         }
 
-        public static class GetBucketsByMembersReply extends ContainsBuckets implements Serializable{
+        public static final class GetBucketsByMembersReply<T extends BucketData<T>> extends ContainsBuckets<T>  {
             private static final long serialVersionUID = 1L;
-            public GetBucketsByMembersReply(Map<Address, Bucket> buckets) {
+
+            public GetBucketsByMembersReply(final Map<Address, Bucket<T>> buckets) {
                 super(buckets);
             }
         }
 
-        public static class GetBucketVersions implements Serializable {
+        public static final class GetBucketVersions implements Serializable {
             private static final long serialVersionUID = 1L;
         }
 
-        public static class ContainsBucketVersions implements Serializable{
+        public static class ContainsBucketVersions implements Serializable {
             private static final long serialVersionUID = -8172148925383801613L;
 
             Map<Address, Long> versions;
 
-            public ContainsBucketVersions(Map<Address, Long> versions) {
+            public ContainsBucketVersions(final Map<Address, Long> versions) {
                 Preconditions.checkArgument(versions != null, "versions can not be null or empty");
 
-                this.versions = versions;
+                this.versions = ImmutableMap.copyOf(versions);
             }
 
             public Map<Address, Long> getVersions() {
-                return Collections.unmodifiableMap(versions);
+                return versions;
             }
-
         }
 
-        public static class GetBucketVersionsReply extends ContainsBucketVersions implements Serializable{
+        public static final class GetBucketVersionsReply extends ContainsBucketVersions {
             private static final long serialVersionUID = 1L;
-            public GetBucketVersionsReply(Map<Address, Long> versions) {
+
+            public GetBucketVersionsReply(final Map<Address, Long> versions) {
                 super(versions);
             }
         }
 
-        public static class UpdateRemoteBuckets extends ContainsBuckets implements Serializable{
+        public static final class UpdateRemoteBuckets<T extends BucketData<T>> extends ContainsBuckets<T> {
             private static final long serialVersionUID = 1L;
-            public UpdateRemoteBuckets(Map<Address, Bucket> buckets) {
+
+            public UpdateRemoteBuckets(final Map<Address, Bucket<T>> buckets) {
                 super(buckets);
             }
         }
+
+        /**
+         * Message sent from the gossiper to its parent, therefore not Serializable, requesting removal
+         * of a bucket corresponding to an address.
+         */
+        public static final class RemoveRemoteBucket {
+            private final Address address;
+
+            public RemoveRemoteBucket(final Address address) {
+                this.address = Preconditions.checkNotNull(address);
+            }
+
+            public Address getAddress() {
+                return address;
+            }
+        }
     }
 
-    public static class GossiperMessages{
+    public static class GossiperMessages {
         public static class Tick implements Serializable {
             private static final long serialVersionUID = -4770935099506366773L;
         }
@@ -128,12 +138,12 @@ public class Messages {
             private static final long serialVersionUID = 5803354404380026143L;
         }
 
-        public static final class GossipStatus extends ContainsBucketVersions implements Serializable{
+        public static final class GossipStatus extends ContainsBucketVersions {
             private static final long serialVersionUID = -593037395143883265L;
 
             private final Address from;
 
-            public GossipStatus(Address from, Map<Address, Long> versions) {
+            public GossipStatus(final Address from, final Map<Address, Long> versions) {
                 super(versions);
                 this.from = from;
             }
@@ -143,13 +153,13 @@ public class Messages {
             }
         }
 
-        public static final class GossipEnvelope extends ContainsBuckets implements Serializable {
+        public static final class GossipEnvelope<T extends BucketData<T>> extends ContainsBuckets<T> {
             private static final long serialVersionUID = 8346634072582438818L;
 
             private final Address from;
             private final Address to;
 
-            public GossipEnvelope(Address from, Address to, Map<Address, Bucket> buckets) {
+            public GossipEnvelope(final Address from, final Address to, final Map<Address, Bucket<T>> buckets) {
                 super(buckets);
                 Preconditions.checkArgument(to != null, "Recipient of message must not be null");
                 this.to = to;