opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/registry/RpcRegistryTest.java

   1 /*
   2  * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.remote.rpc.registry;
  10
  11 import static org.junit.Assert.fail;
  12 import akka.actor.ActorRef;
  13 import akka.actor.ActorSystem;
  14 import akka.actor.Address;
  15 import akka.actor.Props;
  16 import akka.cluster.Cluster;
  17 import akka.cluster.ClusterEvent.CurrentClusterState;
  18 import akka.cluster.Member;
  19 import akka.cluster.MemberStatus;
  20 import akka.cluster.UniqueAddress;
  21 import akka.japi.Pair;
  22 import akka.testkit.JavaTestKit;
  23 import com.google.common.base.Stopwatch;
  24 import com.google.common.collect.Sets;
  25 import com.google.common.util.concurrent.Uninterruptibles;
  26 import com.typesafe.config.Config;
  27 import com.typesafe.config.ConfigFactory;
  28 import java.net.URI;
  29 import java.net.URISyntaxException;
  30 import java.util.ArrayList;
  31 import java.util.Arrays;
  32 import java.util.Collections;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Set;
  36 import java.util.concurrent.TimeUnit;
  37 import org.junit.After;
  38 import org.junit.AfterClass;
  39 import org.junit.Assert;
  40 import org.junit.Before;
  41 import org.junit.BeforeClass;
  42 import org.junit.Test;
  43 import org.opendaylight.controller.cluster.common.actor.AkkaConfigurationReader;
  44 import org.opendaylight.controller.remote.rpc.RemoteRpcProviderConfig;
  45 import org.opendaylight.controller.remote.rpc.RouteIdentifierImpl;
  46 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.AddOrUpdateRoutes;
  47 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRouters;
  48 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRoutersReply;
  49 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.RemoveRoutes;
  50 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.SetLocalRouter;
  51 import org.opendaylight.controller.remote.rpc.registry.gossip.Bucket;
  52 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBuckets;
  53 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBucketsReply;
  54 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersions;
  55 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersionsReply;
  56 import org.opendaylight.controller.sal.connector.api.RpcRouter;
  57 import org.opendaylight.controller.sal.connector.api.RpcRouter.RouteIdentifier;
  58 import org.opendaylight.yangtools.yang.common.QName;
  59 import scala.concurrent.duration.Duration;
  60 import scala.concurrent.duration.FiniteDuration;
  61
  62 public class RpcRegistryTest {
  63
  64     private static ActorSystem node1;
  65     private static ActorSystem node2;
  66     private static ActorSystem node3;
  67
  68     private ActorRef registry1;
  69     private ActorRef registry2;
  70     private ActorRef registry3;
  71
  72     private int routeIdCounter = 1;
  73
  74     @BeforeClass
  75     public static void staticSetup() throws InterruptedException {
  76         AkkaConfigurationReader reader = new AkkaConfigurationReader() {
  77             @Override
  78             public Config read() {
  79                 return ConfigFactory.load();
  80             }
  81         };
  82
  83         RemoteRpcProviderConfig config1 = new RemoteRpcProviderConfig.Builder("memberA").gossipTickInterval("200ms").
  84                 withConfigReader(reader).build();
  85         RemoteRpcProviderConfig config2 = new RemoteRpcProviderConfig.Builder("memberB").gossipTickInterval("200ms")
  86                 .withConfigReader(reader).build();
  87         RemoteRpcProviderConfig config3 = new RemoteRpcProviderConfig.Builder("memberC").gossipTickInterval("200ms")
  88                 .withConfigReader(reader).build();
  89         node1 = ActorSystem.create("opendaylight-rpc", config1.get());
  90         node2 = ActorSystem.create("opendaylight-rpc", config2.get());
  91         node3 = ActorSystem.create("opendaylight-rpc", config3.get());
  92
  93         waitForMembersUp(node1, Cluster.get(node2).selfUniqueAddress(), Cluster.get(node3).selfUniqueAddress());
  94         waitForMembersUp(node2, Cluster.get(node1).selfUniqueAddress(), Cluster.get(node3).selfUniqueAddress());
  95     }
  96
  97     static void waitForMembersUp(ActorSystem node, UniqueAddress... addresses) {
  98         Set<UniqueAddress> otherMembersSet = Sets.newHashSet(addresses);
  99         Stopwatch sw = Stopwatch.createStarted();
 100         while(sw.elapsed(TimeUnit.SECONDS) <= 10) {
 101             CurrentClusterState state = Cluster.get(node).state();
 102             for(Member m: state.getMembers()) {
 103                 if(m.status() == MemberStatus.up() && otherMembersSet.remove(m.uniqueAddress()) &&
 104                         otherMembersSet.isEmpty()) {
 105                     return;
 106                 }
 107             }
 108
 109             Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
 110         }
 111
 112         fail("Member(s) " + otherMembersSet + " are not Up");
 113     }
 114
 115     @AfterClass
 116     public static void staticTeardown() {
 117         JavaTestKit.shutdownActorSystem(node1);
 118         JavaTestKit.shutdownActorSystem(node2);
 119         JavaTestKit.shutdownActorSystem(node3);
 120     }
 121
 122     @Before
 123     public void setup() {
 124         registry1 = node1.actorOf(Props.create(RpcRegistry.class, config(node1)));
 125         registry2 = node2.actorOf(Props.create(RpcRegistry.class, config(node2)));
 126         registry3 = node3.actorOf(Props.create(RpcRegistry.class, config(node3)));
 127     }
 128
 129     private RemoteRpcProviderConfig config(ActorSystem node){
 130         return new RemoteRpcProviderConfig(node.settings().config());
 131     }
 132
 133     @After
 134     public void teardown() {
 135         if (registry1 != null) {
 136             node1.stop(registry1);
 137         }
 138         if (registry2 != null) {
 139             node2.stop(registry2);
 140         }
 141         if (registry3 != null) {
 142             node3.stop(registry3);
 143         }
 144     }
 145
 146     /**
 147      * One node cluster. 1. Register rpc, ensure router can be found 2. Then remove rpc, ensure its
 148      * deleted
 149      *
 150      * @throws URISyntaxException
 151      * @throws InterruptedException
 152      */
 153     @Test
 154     public void testAddRemoveRpcOnSameNode() throws Exception {
 155
 156         System.out.println("testAddRemoveRpcOnSameNode starting");
 157
 158         final JavaTestKit mockBroker = new JavaTestKit(node1);
 159
 160         Address nodeAddress = node1.provider().getDefaultAddress();
 161
 162         // Add rpc on node 1
 163         registry1.tell(new SetLocalRouter(mockBroker.getRef()), mockBroker.getRef());
 164
 165         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds = createRouteIds();
 166
 167         registry1.tell(new AddOrUpdateRoutes(addedRouteIds), mockBroker.getRef());
 168
 169         // Bucket store should get an update bucket message. Updated bucket contains added rpc.
 170
 171         Map<Address, Bucket<RoutingTable>> buckets = retrieveBuckets(registry1, mockBroker, nodeAddress);
 172         verifyBucket(buckets.get(nodeAddress), addedRouteIds);
 173
 174         Map<Address, Long> versions = retrieveVersions(registry1, mockBroker);
 175         Assert.assertEquals("Version for bucket " + nodeAddress, buckets.get(nodeAddress).getVersion(),
 176                 versions.get(nodeAddress));
 177
 178         // Now remove rpc
 179         registry1.tell(new RemoveRoutes(addedRouteIds), mockBroker.getRef());
 180
 181         // Bucket store should get an update bucket message. Rpc is removed in the updated bucket
 182
 183         verifyEmptyBucket(mockBroker, registry1, nodeAddress);
 184
 185         System.out.println("testAddRemoveRpcOnSameNode ending");
 186
 187     }
 188
 189     /**
 190      * Three node cluster. 1. Register rpc on 1 node, ensure 2nd node gets updated 2. Remove rpc on
 191      * 1 node, ensure 2nd node gets updated
 192      *
 193      * @throws URISyntaxException
 194      * @throws InterruptedException
 195      */
 196     @Test
 197     public void testRpcAddRemoveInCluster() throws Exception {
 198
 199         System.out.println("testRpcAddRemoveInCluster starting");
 200
 201         final JavaTestKit mockBroker1 = new JavaTestKit(node1);
 202         final JavaTestKit mockBroker2 = new JavaTestKit(node2);
 203
 204         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds = createRouteIds();
 205
 206         Address node1Address = node1.provider().getDefaultAddress();
 207
 208         // Add rpc on node 1
 209         registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
 210         registry1.tell(new AddOrUpdateRoutes(addedRouteIds), mockBroker1.getRef());
 211
 212         // Bucket store on node2 should get a message to update its local copy of remote buckets
 213
 214         Map<Address, Bucket<RoutingTable>> buckets = retrieveBuckets(registry2, mockBroker2, node1Address);
 215         verifyBucket(buckets.get(node1Address), addedRouteIds);
 216
 217         // Now remove
 218         registry1.tell(new RemoveRoutes(addedRouteIds), mockBroker1.getRef());
 219
 220         // Bucket store on node2 should get a message to update its local copy of remote buckets.
 221         // Wait for the bucket for node1 to be empty.
 222
 223         verifyEmptyBucket(mockBroker2, registry2, node1Address);
 224
 225         System.out.println("testRpcAddRemoveInCluster ending");
 226     }
 227
 228     private void verifyEmptyBucket(JavaTestKit testKit, ActorRef registry, Address address)
 229             throws AssertionError {
 230         Map<Address, Bucket<RoutingTable>> buckets;
 231         int nTries = 0;
 232         while(true) {
 233             buckets = retrieveBuckets(registry1, testKit, address);
 234
 235             try {
 236                 verifyBucket(buckets.get(address), Collections.<RouteIdentifier<?, ?, ?>>emptyList());
 237                 break;
 238             } catch (AssertionError e) {
 239                 if(++nTries >= 50) {
 240                     throw e;
 241                 }
 242             }
 243
 244             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 245         }
 246     }
 247
 248     /**
 249      * Three node cluster. Register rpc on 2 nodes. Ensure 3rd gets updated.
 250      *
 251      * @throws Exception
 252      */
 253     @Test
 254     public void testRpcAddedOnMultiNodes() throws Exception {
 255
 256         final JavaTestKit mockBroker1 = new JavaTestKit(node1);
 257         final JavaTestKit mockBroker2 = new JavaTestKit(node2);
 258         final JavaTestKit mockBroker3 = new JavaTestKit(node3);
 259
 260         registry3.tell(new SetLocalRouter(mockBroker3.getRef()), mockBroker3.getRef());
 261
 262         // Add rpc on node 1
 263         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds1 = createRouteIds();
 264         registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
 265         registry1.tell(new AddOrUpdateRoutes(addedRouteIds1), mockBroker1.getRef());
 266
 267         // Add rpc on node 2
 268         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds2 = createRouteIds();
 269         registry2.tell(new SetLocalRouter(mockBroker2.getRef()), mockBroker2.getRef());
 270         registry2.tell(new AddOrUpdateRoutes(addedRouteIds2), mockBroker2.getRef());
 271
 272         Address node1Address = node1.provider().getDefaultAddress();
 273         Address node2Address = node2.provider().getDefaultAddress();
 274
 275         Map<Address, Bucket<RoutingTable>> buckets = retrieveBuckets(registry3, mockBroker3, node1Address,
 276                 node2Address);
 277
 278         verifyBucket(buckets.get(node1Address), addedRouteIds1);
 279         verifyBucket(buckets.get(node2Address), addedRouteIds2);
 280
 281         Map<Address, Long> versions = retrieveVersions(registry3, mockBroker3);
 282         Assert.assertEquals("Version for bucket " + node1Address, buckets.get(node1Address).getVersion(),
 283                 versions.get(node1Address));
 284         Assert.assertEquals("Version for bucket " + node2Address, buckets.get(node2Address).getVersion(),
 285                 versions.get(node2Address));
 286
 287         RouteIdentifier<?, ?, ?> routeID = addedRouteIds1.get(0);
 288         registry3.tell(new FindRouters(routeID), mockBroker3.getRef());
 289
 290         FindRoutersReply reply = mockBroker3.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
 291                 FindRoutersReply.class);
 292
 293         List<Pair<ActorRef, Long>> respList = reply.getRouterWithUpdateTime();
 294         Assert.assertEquals("getRouterWithUpdateTime size", 1, respList.size());
 295
 296         respList.get(0).first().tell("hello", ActorRef.noSender());
 297         mockBroker1.expectMsgEquals(Duration.create(3, TimeUnit.SECONDS), "hello");
 298     }
 299
 300     private Map<Address, Long> retrieveVersions(ActorRef bucketStore, JavaTestKit testKit) {
 301         bucketStore.tell(new GetBucketVersions(), testKit.getRef());
 302         GetBucketVersionsReply reply = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
 303                 GetBucketVersionsReply.class);
 304         return reply.getVersions();
 305     }
 306
 307     private void verifyBucket(Bucket<RoutingTable> bucket, List<RouteIdentifier<?, ?, ?>> expRouteIds) {
 308         RoutingTable table = bucket.getData();
 309         Assert.assertNotNull("Bucket RoutingTable is null", table);
 310         for(RouteIdentifier<?, ?, ?> r: expRouteIds) {
 311             if(!table.contains(r)) {
 312                 Assert.fail("RoutingTable does not contain " + r + ". Actual: " + table);
 313             }
 314         }
 315
 316         Assert.assertEquals("RoutingTable size", expRouteIds.size(), table.size());
 317     }
 318
 319     private Map<Address, Bucket<RoutingTable>> retrieveBuckets(ActorRef bucketStore, JavaTestKit testKit,
 320             Address... addresses) {
 321         int nTries = 0;
 322         while(true) {
 323             bucketStore.tell(new GetAllBuckets(), testKit.getRef());
 324             @SuppressWarnings("unchecked")
 325             GetAllBucketsReply<RoutingTable> reply = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
 326                     GetAllBucketsReply.class);
 327
 328             Map<Address, Bucket<RoutingTable>> buckets = reply.getBuckets();
 329             boolean foundAll = true;
 330             for(Address addr: addresses) {
 331                 Bucket<RoutingTable> bucket = buckets.get(addr);
 332                 if(bucket  == null) {
 333                     foundAll = false;
 334                     break;
 335                 }
 336             }
 337
 338             if(foundAll) {
 339                 return buckets;
 340             }
 341
 342             if(++nTries >= 50) {
 343                 Assert.fail("Missing expected buckets for addresses: " + Arrays.toString(addresses)
 344                         + ", Actual: " + buckets);
 345             }
 346
 347             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 348         }
 349     }
 350
 351     @Test
 352     public void testAddRoutesConcurrency() throws Exception {
 353         final JavaTestKit testKit = new JavaTestKit(node1);
 354
 355         registry1.tell(new SetLocalRouter(testKit.getRef()), ActorRef.noSender());
 356
 357         final int nRoutes = 500;
 358         final RouteIdentifier<?, ?, ?>[] added = new RouteIdentifier<?, ?, ?>[nRoutes];
 359         for(int i = 0; i < nRoutes; i++) {
 360             final RouteIdentifierImpl routeId = new RouteIdentifierImpl(null,
 361                     new QName(new URI("/mockrpc"), "type" + i), null);
 362             added[i] = routeId;
 363
 364             //Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
 365             registry1.tell(new AddOrUpdateRoutes(Arrays.<RouteIdentifier<?, ?, ?>>asList(routeId)),
 366                     ActorRef.noSender());
 367         }
 368
 369         GetAllBuckets getAllBuckets = new GetAllBuckets();
 370         FiniteDuration duration = Duration.create(3, TimeUnit.SECONDS);
 371         int nTries = 0;
 372         while(true) {
 373             registry1.tell(getAllBuckets, testKit.getRef());
 374             @SuppressWarnings("unchecked")
 375             GetAllBucketsReply<RoutingTable> reply = testKit.expectMsgClass(duration, GetAllBucketsReply.class);
 376
 377             Bucket<RoutingTable> localBucket = reply.getBuckets().values().iterator().next();
 378             RoutingTable table = localBucket.getData();
 379             if(table != null && table.size() == nRoutes) {
 380                 for(RouteIdentifier<?, ?, ?> r: added) {
 381                     Assert.assertEquals("RoutingTable contains " + r, true, table.contains(r));
 382                 }
 383
 384                 break;
 385             }
 386
 387             if(++nTries >= 50) {
 388                 Assert.fail("Expected # routes: " + nRoutes + ", Actual: " + table.size());
 389             }
 390
 391             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 392         }
 393     }
 394
 395     private List<RpcRouter.RouteIdentifier<?, ?, ?>> createRouteIds() throws URISyntaxException {
 396         QName type = new QName(new URI("/mockrpc"), "mockrpc" + routeIdCounter++);
 397         List<RpcRouter.RouteIdentifier<?, ?, ?>> routeIds = new ArrayList<>();
 398         routeIds.add(new RouteIdentifierImpl(null, type, null));
 399         return routeIds;
 400     }
 401
 402     @Test
 403     public void testFindRoutersNotPresentInitially() throws Exception {
 404
 405         final JavaTestKit mockBroker1 = new JavaTestKit(node1);
 406         final JavaTestKit mockBroker2 = new JavaTestKit(node2);
 407
 408         registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
 409         registry2.tell(new SetLocalRouter(mockBroker2.getRef()), mockBroker2.getRef());
 410
 411         List<RpcRouter.RouteIdentifier<?, ?, ?>> routeIds = createRouteIds();
 412         routeIds.addAll(createRouteIds());
 413
 414         JavaTestKit replyKit1 = new JavaTestKit(node1);
 415         registry1.tell(new FindRouters(routeIds.get(0)), replyKit1.getRef());
 416         JavaTestKit replyKit2 = new JavaTestKit(node1);
 417         registry1.tell(new FindRouters(routeIds.get(1)), replyKit2.getRef());
 418
 419         registry2.tell(new AddOrUpdateRoutes(routeIds), mockBroker2.getRef());
 420
 421         FindRoutersReply reply = replyKit1.expectMsgClass(Duration.create(7, TimeUnit.SECONDS),
 422                 FindRoutersReply.class);
 423         Assert.assertEquals("getRouterWithUpdateTime size", 1, reply.getRouterWithUpdateTime().size());
 424
 425         reply = replyKit2.expectMsgClass(Duration.create(7, TimeUnit.SECONDS),
 426                 FindRoutersReply.class);
 427         Assert.assertEquals("getRouterWithUpdateTime size", 1, reply.getRouterWithUpdateTime().size());
 428     }
 429
 430     @Test
 431     public void testFindRoutersNonExistent() throws Exception {
 432
 433         final JavaTestKit mockBroker1 = new JavaTestKit(node1);
 434
 435         registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
 436
 437         List<RpcRouter.RouteIdentifier<?, ?, ?>> routeIds = createRouteIds();
 438
 439         registry1.tell(new FindRouters(routeIds.get(0)), mockBroker1.getRef());
 440
 441         FindRoutersReply reply = mockBroker1.expectMsgClass(Duration.create(7, TimeUnit.SECONDS),
 442                 FindRoutersReply.class);
 443         List<Pair<ActorRef, Long>> respList = reply.getRouterWithUpdateTime();
 444         Assert.assertEquals("getRouterWithUpdateTime size", 0, respList.size());
 445     }
 446 }