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