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 package org.opendaylight.controller.remote.rpc.registry;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14 import static org.opendaylight.controller.remote.rpc.registry.gossip.BucketStoreAccess.Singletons.GET_ALL_BUCKETS;
  15 import static org.opendaylight.controller.remote.rpc.registry.gossip.BucketStoreAccess.Singletons.GET_BUCKET_VERSIONS;
  16
  17 import akka.actor.ActorRef;
  18 import akka.actor.ActorSystem;
  19 import akka.actor.Address;
  20 import akka.cluster.Cluster;
  21 import akka.cluster.ClusterEvent.CurrentClusterState;
  22 import akka.cluster.Member;
  23 import akka.cluster.MemberStatus;
  24 import akka.cluster.UniqueAddress;
  25 import akka.testkit.javadsl.TestKit;
  26 import com.google.common.base.Stopwatch;
  27 import com.google.common.collect.Sets;
  28 import com.google.common.util.concurrent.Uninterruptibles;
  29 import com.typesafe.config.ConfigFactory;
  30 import java.net.URI;
  31 import java.time.Duration;
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.Collection;
  35 import java.util.Collections;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Optional;
  39 import java.util.Set;
  40 import java.util.concurrent.TimeUnit;
  41 import org.junit.After;
  42 import org.junit.AfterClass;
  43 import org.junit.Before;
  44 import org.junit.BeforeClass;
  45 import org.junit.Test;
  46 import org.opendaylight.controller.cluster.common.actor.AkkaConfigurationReader;
  47 import org.opendaylight.controller.remote.rpc.RemoteOpsProviderConfig;
  48 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.AddOrUpdateRoutes;
  49 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.RemoveRoutes;
  50 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.UpdateRemoteEndpoints;
  51 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.RemoteRpcEndpoint;
  52 import org.opendaylight.controller.remote.rpc.registry.gossip.Bucket;
  53 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
  54 import org.opendaylight.yangtools.yang.common.QName;
  55 import org.slf4j.Logger;
  56 import org.slf4j.LoggerFactory;
  57
  58 public class RpcRegistryTest {
  59     private static final Logger LOG = LoggerFactory.getLogger(RpcRegistryTest.class);
  60
  61     private static ActorSystem node1;
  62     private static ActorSystem node2;
  63     private static ActorSystem node3;
  64
  65     private TestKit invoker1;
  66     private TestKit invoker2;
  67     private TestKit invoker3;
  68     private TestKit registrar1;
  69     private TestKit registrar2;
  70     private TestKit registrar3;
  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() {
  79         AkkaConfigurationReader reader = ConfigFactory::load;
  80
  81         RemoteOpsProviderConfig config1 = new RemoteOpsProviderConfig.Builder("memberA").gossipTickInterval("200ms")
  82                 .withConfigReader(reader).build();
  83         RemoteOpsProviderConfig config2 = new RemoteOpsProviderConfig.Builder("memberB").gossipTickInterval("200ms")
  84                 .withConfigReader(reader).build();
  85         RemoteOpsProviderConfig config3 = new RemoteOpsProviderConfig.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(final ActorSystem node, final 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         TestKit.shutdownActorSystem(node1);
 116         TestKit.shutdownActorSystem(node2);
 117         TestKit.shutdownActorSystem(node3);
 118     }
 119
 120     @Before
 121     public void setup() {
 122         invoker1 = new TestKit(node1);
 123         registrar1 = new TestKit(node1);
 124         registry1 = node1.actorOf(RpcRegistry.props(config(node1), invoker1.getRef(), registrar1.getRef()));
 125         invoker2 = new TestKit(node2);
 126         registrar2 = new TestKit(node2);
 127         registry2 = node2.actorOf(RpcRegistry.props(config(node2), invoker2.getRef(), registrar2.getRef()));
 128         invoker3 = new TestKit(node3);
 129         registrar3 = new TestKit(node3);
 130         registry3 = node3.actorOf(RpcRegistry.props(config(node3), invoker3.getRef(), registrar3.getRef()));
 131     }
 132
 133     private static RemoteOpsProviderConfig config(final ActorSystem node) {
 134         return new RemoteOpsProviderConfig(node.settings().config());
 135     }
 136
 137     @After
 138     public void teardown() {
 139         if (registry1 != null) {
 140             node1.stop(registry1);
 141         }
 142         if (registry2 != null) {
 143             node2.stop(registry2);
 144         }
 145         if (registry3 != null) {
 146             node3.stop(registry3);
 147         }
 148
 149         if (invoker1 != null) {
 150             node1.stop(invoker1.getRef());
 151         }
 152         if (invoker2 != null) {
 153             node2.stop(invoker2.getRef());
 154         }
 155         if (invoker3 != null) {
 156             node3.stop(invoker3.getRef());
 157         }
 158
 159         if (registrar1 != null) {
 160             node1.stop(registrar1.getRef());
 161         }
 162         if (registrar2 != null) {
 163             node2.stop(registrar2.getRef());
 164         }
 165         if (registrar3 != null) {
 166             node3.stop(registrar3.getRef());
 167         }
 168     }
 169
 170     /**
 171      * One node cluster. 1. Register rpc, ensure router can be found 2. Then remove rpc, ensure its
 172      * deleted
 173      */
 174     @Test
 175     public void testAddRemoveRpcOnSameNode() {
 176         LOG.info("testAddRemoveRpcOnSameNode starting");
 177
 178         Address nodeAddress = node1.provider().getDefaultAddress();
 179
 180         // Add rpc on node 1
 181
 182         List<DOMRpcIdentifier> addedRouteIds = createRouteIds();
 183
 184         registry1.tell(new AddOrUpdateRoutes(addedRouteIds), ActorRef.noSender());
 185
 186         // Bucket store should get an update bucket message. Updated bucket contains added rpc.
 187         final TestKit testKit = new TestKit(node1);
 188
 189         Map<Address, Bucket<RoutingTable>> buckets = retrieveBuckets(registry1, testKit, nodeAddress);
 190         verifyBucket(buckets.get(nodeAddress), addedRouteIds);
 191
 192         Map<Address, Long> versions = retrieveVersions(registry1, testKit);
 193         assertEquals("Version for bucket " + nodeAddress, (Long) buckets.get(nodeAddress).getVersion(),
 194                 versions.get(nodeAddress));
 195
 196         // Now remove rpc
 197         registry1.tell(new RemoveRoutes(addedRouteIds), ActorRef.noSender());
 198
 199         // Bucket store should get an update bucket message. Rpc is removed in the updated bucket
 200
 201         verifyEmptyBucket(testKit, registry1, nodeAddress);
 202
 203         LOG.info("testAddRemoveRpcOnSameNode ending");
 204
 205     }
 206
 207     /**
 208      * Three node cluster. 1. Register rpc on 1 node, ensure 2nd node gets updated 2. Remove rpc on
 209      * 1 node, ensure 2nd node gets updated
 210      */
 211     @Test
 212     public void testRpcAddRemoveInCluster() {
 213
 214         LOG.info("testRpcAddRemoveInCluster starting");
 215
 216         List<DOMRpcIdentifier> addedRouteIds = createRouteIds();
 217
 218         Address node1Address = node1.provider().getDefaultAddress();
 219
 220         // Add rpc on node 1
 221         registry1.tell(new AddOrUpdateRoutes(addedRouteIds), ActorRef.noSender());
 222
 223         // Bucket store on node2 should get a message to update its local copy of remote buckets
 224         final TestKit testKit = new TestKit(node2);
 225
 226         Map<Address, Bucket<RoutingTable>> buckets = retrieveBuckets(registry2, testKit, node1Address);
 227         verifyBucket(buckets.get(node1Address), addedRouteIds);
 228
 229         // Now remove
 230         registry1.tell(new RemoveRoutes(addedRouteIds), ActorRef.noSender());
 231
 232         // Bucket store on node2 should get a message to update its local copy of remote buckets.
 233         // Wait for the bucket for node1 to be empty.
 234
 235         verifyEmptyBucket(testKit, registry2, node1Address);
 236
 237         LOG.info("testRpcAddRemoveInCluster ending");
 238     }
 239
 240     private void verifyEmptyBucket(final TestKit testKit, final ActorRef registry, final Address address)
 241             throws AssertionError {
 242         Map<Address, Bucket<RoutingTable>> buckets;
 243         int numTries = 0;
 244         while (true) {
 245             buckets = retrieveBuckets(registry1, testKit, address);
 246
 247             try {
 248                 verifyBucket(buckets.get(address), Collections.emptyList());
 249                 break;
 250             } catch (AssertionError e) {
 251                 if (++numTries >= 50) {
 252                     throw e;
 253                 }
 254             }
 255
 256             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 257         }
 258     }
 259
 260     /**
 261      * Three node cluster. Register rpc on 2 nodes. Ensure 3rd gets updated.
 262      */
 263     @Test
 264     public void testRpcAddedOnMultiNodes() {
 265         final TestKit testKit = new TestKit(node3);
 266
 267         // Add rpc on node 1
 268         List<DOMRpcIdentifier> addedRouteIds1 = createRouteIds();
 269         registry1.tell(new AddOrUpdateRoutes(addedRouteIds1), ActorRef.noSender());
 270
 271         final UpdateRemoteEndpoints req1 = registrar3.expectMsgClass(Duration.ofSeconds(3),
 272             UpdateRemoteEndpoints.class);
 273
 274         // Add rpc on node 2
 275         List<DOMRpcIdentifier> addedRouteIds2 = createRouteIds();
 276         registry2.tell(new AddOrUpdateRoutes(addedRouteIds2), ActorRef.noSender());
 277
 278         final UpdateRemoteEndpoints req2 = registrar3.expectMsgClass(Duration.ofSeconds(3),
 279             UpdateRemoteEndpoints.class);
 280         Address node2Address = node2.provider().getDefaultAddress();
 281         Address node1Address = node1.provider().getDefaultAddress();
 282
 283         Map<Address, Bucket<RoutingTable>> buckets = retrieveBuckets(registry3, testKit, node1Address,
 284                 node2Address);
 285
 286         verifyBucket(buckets.get(node1Address), addedRouteIds1);
 287         verifyBucket(buckets.get(node2Address), addedRouteIds2);
 288
 289         Map<Address, Long> versions = retrieveVersions(registry3, testKit);
 290         assertEquals("Version for bucket " + node1Address, (Long) buckets.get(node1Address).getVersion(),
 291                 versions.get(node1Address));
 292         assertEquals("Version for bucket " + node2Address, (Long) buckets.get(node2Address).getVersion(),
 293                 versions.get(node2Address));
 294
 295         assertEndpoints(req1, node1Address, invoker1);
 296         assertEndpoints(req2, node2Address, invoker2);
 297
 298     }
 299
 300     private static void assertEndpoints(final UpdateRemoteEndpoints msg, final Address address, final TestKit invoker) {
 301         final Map<Address, Optional<RemoteRpcEndpoint>> endpoints = msg.getRpcEndpoints();
 302         assertEquals(1, endpoints.size());
 303
 304         final Optional<RemoteRpcEndpoint> maybeEndpoint = endpoints.get(address);
 305         assertNotNull(maybeEndpoint);
 306         assertTrue(maybeEndpoint.isPresent());
 307
 308         final RemoteRpcEndpoint endpoint = maybeEndpoint.get();
 309         final ActorRef router = endpoint.getRouter();
 310         assertNotNull(router);
 311
 312         router.tell("hello", ActorRef.noSender());
 313         final String s = invoker.expectMsgClass(Duration.ofSeconds(3), String.class);
 314         assertEquals("hello", s);
 315     }
 316
 317     private static Map<Address, Long> retrieveVersions(final ActorRef bucketStore, final TestKit testKit) {
 318         bucketStore.tell(GET_BUCKET_VERSIONS, testKit.getRef());
 319         @SuppressWarnings("unchecked")
 320         final Map<Address, Long> reply = testKit.expectMsgClass(Duration.ofSeconds(3), Map.class);
 321         return reply;
 322     }
 323
 324     private static void verifyBucket(final Bucket<RoutingTable> bucket, final List<DOMRpcIdentifier> expRouteIds) {
 325         RoutingTable table = bucket.getData();
 326         assertNotNull("Bucket RoutingTable is null", table);
 327         for (DOMRpcIdentifier r : expRouteIds) {
 328             if (!table.contains(r)) {
 329                 fail("RoutingTable does not contain " + r + ". Actual: " + table);
 330             }
 331         }
 332
 333         assertEquals("RoutingTable size", expRouteIds.size(), table.size());
 334     }
 335
 336     private static Map<Address, Bucket<RoutingTable>> retrieveBuckets(final ActorRef bucketStore,
 337             final TestKit testKit, final Address... addresses) {
 338         int numTries = 0;
 339         while (true) {
 340             bucketStore.tell(GET_ALL_BUCKETS, testKit.getRef());
 341             @SuppressWarnings("unchecked")
 342             Map<Address, Bucket<RoutingTable>> buckets = testKit.expectMsgClass(Duration.ofSeconds(3), Map.class);
 343
 344             boolean foundAll = true;
 345             for (Address addr : addresses) {
 346                 Bucket<RoutingTable> bucket = buckets.get(addr);
 347                 if (bucket == null) {
 348                     foundAll = false;
 349                     break;
 350                 }
 351             }
 352
 353             if (foundAll) {
 354                 return buckets;
 355             }
 356
 357             if (++numTries >= 50) {
 358                 fail("Missing expected buckets for addresses: " + Arrays.toString(addresses) + ", Actual: " + buckets);
 359             }
 360
 361             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 362         }
 363     }
 364
 365     @Test
 366     public void testAddRoutesConcurrency() {
 367         final TestKit testKit = new TestKit(node1);
 368
 369         final int nRoutes = 500;
 370         final Collection<DOMRpcIdentifier> added = new ArrayList<>(nRoutes);
 371         for (int i = 0; i < nRoutes; i++) {
 372             final DOMRpcIdentifier routeId = DOMRpcIdentifier.create(QName.create(URI.create("/mockrpc"), "type" + i));
 373             added.add(routeId);
 374
 375             //Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
 376             registry1.tell(new AddOrUpdateRoutes(Arrays.asList(routeId)),
 377                     ActorRef.noSender());
 378         }
 379
 380         int numTries = 0;
 381         while (true) {
 382             registry1.tell(GET_ALL_BUCKETS, testKit.getRef());
 383             @SuppressWarnings("unchecked")
 384             Map<Address, Bucket<RoutingTable>> buckets = testKit.expectMsgClass(Duration.ofSeconds(3), Map.class);
 385
 386             Bucket<RoutingTable> localBucket = buckets.values().iterator().next();
 387             RoutingTable table = localBucket.getData();
 388             if (table != null && table.size() == nRoutes) {
 389                 for (DOMRpcIdentifier r : added) {
 390                     assertTrue("RoutingTable contains " + r, table.contains(r));
 391                 }
 392
 393                 break;
 394             }
 395
 396             if (++numTries >= 50) {
 397                 fail("Expected # routes: " + nRoutes + ", Actual: " + table.size());
 398             }
 399
 400             Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
 401         }
 402     }
 403
 404     private List<DOMRpcIdentifier> createRouteIds() {
 405         QName type = QName.create(URI.create("/mockrpc"), "mockrpc" + routeIdCounter++);
 406         List<DOMRpcIdentifier> routeIds = new ArrayList<>(1);
 407         routeIds.add(DOMRpcIdentifier.create(type));
 408         return routeIds;
 409     }
 410 }