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 akka.actor.ActorRef;
  12 import akka.actor.ActorSystem;
  13 import akka.actor.Address;
  14 import akka.actor.Props;
  15 import akka.japi.Pair;
  16 import akka.testkit.JavaTestKit;
  17 import com.google.common.util.concurrent.Uninterruptibles;
  18 import java.net.URI;
  19 import java.net.URISyntaxException;
  20 import java.util.ArrayList;
  21 import java.util.Arrays;
  22 import java.util.Collections;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.concurrent.TimeUnit;
  26 import org.junit.After;
  27 import org.junit.AfterClass;
  28 import org.junit.Assert;
  29 import org.junit.Before;
  30 import org.junit.BeforeClass;
  31 import org.junit.Test;
  32 import org.opendaylight.controller.remote.rpc.RemoteRpcProviderConfig;
  33 import org.opendaylight.controller.remote.rpc.RouteIdentifierImpl;
  34 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.AddOrUpdateRoutes;
  35 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRouters;
  36 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRoutersReply;
  37 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.RemoveRoutes;
  38 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.SetLocalRouter;
  39 import org.opendaylight.controller.remote.rpc.registry.gossip.Bucket;
  40 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBuckets;
  41 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBucketsReply;
  42 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersions;
  43 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersionsReply;
  44 import org.opendaylight.controller.sal.connector.api.RpcRouter;
  45 import org.opendaylight.controller.sal.connector.api.RpcRouter.RouteIdentifier;
  46 import org.opendaylight.yangtools.yang.common.QName;
  47 import scala.concurrent.duration.Duration;
  48 import scala.concurrent.duration.FiniteDuration;
  49
  50 public class RpcRegistryTest {
  51
  52     private static ActorSystem node1;
  53     private static ActorSystem node2;
  54     private static ActorSystem node3;
  55
  56     private ActorRef registry1;
  57     private ActorRef registry2;
  58     private ActorRef registry3;
  59
  60     private int routeIdCounter = 1;
  61
  62     @BeforeClass
  63     public static void staticSetup() throws InterruptedException {
  64       RemoteRpcProviderConfig config1 = new RemoteRpcProviderConfig.Builder("memberA").build();
  65       RemoteRpcProviderConfig config2 = new RemoteRpcProviderConfig.Builder("memberB").build();
  66       RemoteRpcProviderConfig config3 = new RemoteRpcProviderConfig.Builder("memberC").build();
  67       node1 = ActorSystem.create("opendaylight-rpc", config1.get());
  68       node2 = ActorSystem.create("opendaylight-rpc", config2.get());
  69       node3 = ActorSystem.create("opendaylight-rpc", config3.get());
  70     }
  71
  72     @AfterClass
  73     public static void staticTeardown() {
  74       JavaTestKit.shutdownActorSystem(node1);
  75       JavaTestKit.shutdownActorSystem(node2);
  76       JavaTestKit.shutdownActorSystem(node3);
  77     }
  78
  79     @Before
  80     public void setup() {
  81         registry1 = node1.actorOf(Props.create(RpcRegistry.class));
  82         registry2 = node2.actorOf(Props.create(RpcRegistry.class));
  83         registry3 = node3.actorOf(Props.create(RpcRegistry.class));
  84     }
  85
  86     @After
  87     public void teardown() {
  88         if (registry1 != null) {
  89             node1.stop(registry1);
  90         }
  91         if (registry2 != null) {
  92             node2.stop(registry2);
  93         }
  94         if (registry3 != null) {
  95             node3.stop(registry3);
  96         }
  97     }
  98
  99     /**
 100      * One node cluster. 1. Register rpc, ensure router can be found 2. Then remove rpc, ensure its
 101      * deleted
 102      *
 103      * @throws URISyntaxException
 104      * @throws InterruptedException
 105      */
 106     @Test
 107     public void testAddRemoveRpcOnSameNode() throws Exception {
 108
 109         System.out.println("testAddRemoveRpcOnSameNode starting");
 110
 111         final JavaTestKit mockBroker = new JavaTestKit(node1);
 112
 113         Address nodeAddress = node1.provider().getDefaultAddress();
 114
 115         // Add rpc on node 1
 116         registry1.tell(new SetLocalRouter(mockBroker.getRef()), mockBroker.getRef());
 117
 118         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds = createRouteIds();
 119
 120         registry1.tell(new AddOrUpdateRoutes(addedRouteIds), mockBroker.getRef());
 121
 122         // Bucket store should get an update bucket message. Updated bucket contains added rpc.
 123
 124         Map<Address, Bucket> buckets = retrieveBuckets(registry1, mockBroker, nodeAddress);
 125         verifyBucket(buckets.get(nodeAddress), addedRouteIds);
 126
 127         Map<Address, Long> versions = retrieveVersions(registry1, mockBroker);
 128         Assert.assertEquals("Version for bucket " + nodeAddress, buckets.get(nodeAddress).getVersion(),
 129                 versions.get(nodeAddress));
 130
 131         // Now remove rpc
 132         registry1.tell(new RemoveRoutes(addedRouteIds), mockBroker.getRef());
 133
 134         // Bucket store should get an update bucket message. Rpc is removed in the updated bucket
 135
 136         verifyEmptyBucket(mockBroker, registry1, nodeAddress);
 137
 138         System.out.println("testAddRemoveRpcOnSameNode ending");
 139
 140     }
 141
 142     /**
 143      * Three node cluster. 1. Register rpc on 1 node, ensure 2nd node gets updated 2. Remove rpc on
 144      * 1 node, ensure 2nd node gets updated
 145      *
 146      * @throws URISyntaxException
 147      * @throws InterruptedException
 148      */
 149     @Test
 150     public void testRpcAddRemoveInCluster() throws Exception {
 151
 152         System.out.println("testRpcAddRemoveInCluster starting");
 153
 154         final JavaTestKit mockBroker1 = new JavaTestKit(node1);
 155         final JavaTestKit mockBroker2 = new JavaTestKit(node2);
 156
 157         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds = createRouteIds();
 158
 159         Address node1Address = node1.provider().getDefaultAddress();
 160
 161         // Add rpc on node 1
 162         registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
 163         registry1.tell(new AddOrUpdateRoutes(addedRouteIds), mockBroker1.getRef());
 164
 165         // Bucket store on node2 should get a message to update its local copy of remote buckets
 166
 167         Map<Address, Bucket> buckets = retrieveBuckets(registry2, mockBroker2, node1Address);
 168         verifyBucket(buckets.get(node1Address), addedRouteIds);
 169
 170         // Now remove
 171         registry1.tell(new RemoveRoutes(addedRouteIds), mockBroker1.getRef());
 172
 173         // Bucket store on node2 should get a message to update its local copy of remote buckets.
 174         // Wait for the bucket for node1 to be empty.
 175
 176         verifyEmptyBucket(mockBroker2, registry2, node1Address);
 177
 178         System.out.println("testRpcAddRemoveInCluster ending");
 179     }
 180
 181     private void verifyEmptyBucket(JavaTestKit testKit, ActorRef registry, Address address)
 182             throws AssertionError {
 183         Map<Address, Bucket> buckets;
 184         int nTries = 0;
 185         while(true) {
 186             buckets = retrieveBuckets(registry1, testKit, address);
 187
 188             try {
 189                 verifyBucket(buckets.get(address), Collections.<RouteIdentifier<?, ?, ?>>emptyList());
 190                 break;
 191             } catch (AssertionError e) {
 192                 if(++nTries >= 50) {
 193                     throw e;
 194                 }
 195             }
 196
 197             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 198         }
 199     }
 200
 201     /**
 202      * Three node cluster. Register rpc on 2 nodes. Ensure 3rd gets updated.
 203      *
 204      * @throws Exception
 205      */
 206     @Test
 207     public void testRpcAddedOnMultiNodes() throws Exception {
 208
 209         final JavaTestKit mockBroker1 = new JavaTestKit(node1);
 210         final JavaTestKit mockBroker2 = new JavaTestKit(node2);
 211         final JavaTestKit mockBroker3 = new JavaTestKit(node3);
 212
 213         registry3.tell(new SetLocalRouter(mockBroker3.getRef()), mockBroker3.getRef());
 214
 215         // Add rpc on node 1
 216         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds1 = createRouteIds();
 217         registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
 218         registry1.tell(new AddOrUpdateRoutes(addedRouteIds1), mockBroker1.getRef());
 219
 220         // Add rpc on node 2
 221         List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds2 = createRouteIds();
 222         registry2.tell(new SetLocalRouter(mockBroker2.getRef()), mockBroker2.getRef());
 223         registry2.tell(new AddOrUpdateRoutes(addedRouteIds2), mockBroker2.getRef());
 224
 225         Address node1Address = node1.provider().getDefaultAddress();
 226         Address node2Address = node2.provider().getDefaultAddress();
 227
 228         Map<Address, Bucket> buckets = retrieveBuckets(registry3, mockBroker3, node1Address,
 229                 node2Address);
 230
 231         verifyBucket(buckets.get(node1Address), addedRouteIds1);
 232         verifyBucket(buckets.get(node2Address), addedRouteIds2);
 233
 234         Map<Address, Long> versions = retrieveVersions(registry3, mockBroker3);
 235         Assert.assertEquals("Version for bucket " + node1Address, buckets.get(node1Address).getVersion(),
 236                 versions.get(node1Address));
 237         Assert.assertEquals("Version for bucket " + node2Address, buckets.get(node2Address).getVersion(),
 238                 versions.get(node2Address));
 239
 240         RouteIdentifier<?, ?, ?> routeID = addedRouteIds1.get(0);
 241         registry3.tell(new FindRouters(routeID), mockBroker3.getRef());
 242
 243         FindRoutersReply reply = mockBroker3.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
 244                 FindRoutersReply.class);
 245
 246         List<Pair<ActorRef, Long>> respList = reply.getRouterWithUpdateTime();
 247         Assert.assertEquals("getRouterWithUpdateTime size", 1, respList.size());
 248
 249         respList.get(0).first().tell("hello", ActorRef.noSender());
 250         mockBroker1.expectMsgEquals(Duration.create(3, TimeUnit.SECONDS), "hello");
 251     }
 252
 253     private Map<Address, Long> retrieveVersions(ActorRef bucketStore, JavaTestKit testKit) {
 254         bucketStore.tell(new GetBucketVersions(), testKit.getRef());
 255         GetBucketVersionsReply reply = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
 256                 GetBucketVersionsReply.class);
 257         return reply.getVersions();
 258     }
 259
 260     private void verifyBucket(Bucket<RoutingTable> bucket, List<RouteIdentifier<?, ?, ?>> expRouteIds) {
 261         RoutingTable table = bucket.getData();
 262         Assert.assertNotNull("Bucket RoutingTable is null", table);
 263         for(RouteIdentifier<?, ?, ?> r: expRouteIds) {
 264             if(!table.contains(r)) {
 265                 Assert.fail("RoutingTable does not contain " + r + ". Actual: " + table);
 266             }
 267         }
 268
 269         Assert.assertEquals("RoutingTable size", expRouteIds.size(), table.size());
 270     }
 271
 272     private Map<Address, Bucket> retrieveBuckets(ActorRef bucketStore, JavaTestKit testKit,
 273             Address... addresses) {
 274         int nTries = 0;
 275         while(true) {
 276             bucketStore.tell(new GetAllBuckets(), testKit.getRef());
 277             GetAllBucketsReply reply = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
 278                     GetAllBucketsReply.class);
 279
 280             Map<Address, Bucket> buckets = reply.getBuckets();
 281             boolean foundAll = true;
 282             for(Address addr: addresses) {
 283                 Bucket bucket = buckets.get(addr);
 284                 if(bucket  == null) {
 285                     foundAll = false;
 286                     break;
 287                 }
 288             }
 289
 290             if(foundAll) {
 291                 return buckets;
 292             }
 293
 294             if(++nTries >= 50) {
 295                 Assert.fail("Missing expected buckets for addresses: " + Arrays.toString(addresses)
 296                         + ", Actual: " + buckets);
 297             }
 298
 299             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 300         }
 301     }
 302
 303     @SuppressWarnings("unchecked")
 304     @Test
 305     public void testAddRoutesConcurrency() throws Exception {
 306         final JavaTestKit testKit = new JavaTestKit(node1);
 307
 308         registry1.tell(new SetLocalRouter(testKit.getRef()), ActorRef.noSender());
 309
 310         final int nRoutes = 500;
 311         final RouteIdentifier<?, ?, ?>[] added = new RouteIdentifier<?, ?, ?>[nRoutes];
 312         for(int i = 0; i < nRoutes; i++) {
 313             final RouteIdentifierImpl routeId = new RouteIdentifierImpl(null,
 314                     new QName(new URI("/mockrpc"), "type" + i), null);
 315             added[i] = routeId;
 316
 317             //Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
 318             registry1.tell(new AddOrUpdateRoutes(Arrays.<RouteIdentifier<?, ?, ?>>asList(routeId)),
 319                     ActorRef.noSender());
 320         }
 321
 322         GetAllBuckets getAllBuckets = new GetAllBuckets();
 323         FiniteDuration duration = Duration.create(3, TimeUnit.SECONDS);
 324         int nTries = 0;
 325         while(true) {
 326             registry1.tell(getAllBuckets, testKit.getRef());
 327             GetAllBucketsReply reply = testKit.expectMsgClass(duration, GetAllBucketsReply.class);
 328
 329             Bucket<RoutingTable> localBucket = reply.getBuckets().values().iterator().next();
 330             RoutingTable table = localBucket.getData();
 331             if(table != null && table.size() == nRoutes) {
 332                 for(RouteIdentifier<?, ?, ?> r: added) {
 333                     Assert.assertEquals("RoutingTable contains " + r, true, table.contains(r));
 334                 }
 335
 336                 break;
 337             }
 338
 339             if(++nTries >= 50) {
 340                 Assert.fail("Expected # routes: " + nRoutes + ", Actual: " + table.size());
 341             }
 342
 343             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 344         }
 345     }
 346
 347     private List<RpcRouter.RouteIdentifier<?, ?, ?>> createRouteIds() throws URISyntaxException {
 348         QName type = new QName(new URI("/mockrpc"), "mockrpc" + routeIdCounter++);
 349         List<RpcRouter.RouteIdentifier<?, ?, ?>> routeIds = new ArrayList<>();
 350         routeIds.add(new RouteIdentifierImpl(null, type, null));
 351         return routeIds;
 352     }
 353 }