1 package org.opendaylight.controller.remote.rpc.registry;
3 import akka.actor.ActorRef;
4 import akka.actor.ActorSystem;
5 import akka.actor.Address;
6 import akka.actor.Props;
8 import akka.testkit.JavaTestKit;
9 import com.google.common.util.concurrent.Uninterruptibles;
11 import java.net.URISyntaxException;
12 import java.util.ArrayList;
13 import java.util.Arrays;
14 import java.util.Collections;
15 import java.util.List;
17 import java.util.concurrent.TimeUnit;
18 import org.junit.After;
19 import org.junit.AfterClass;
20 import org.junit.Assert;
21 import org.junit.Before;
22 import org.junit.BeforeClass;
23 import org.junit.Test;
24 import org.opendaylight.controller.remote.rpc.RemoteRpcProviderConfig;
25 import org.opendaylight.controller.remote.rpc.RouteIdentifierImpl;
26 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.AddOrUpdateRoutes;
27 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRouters;
28 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRoutersReply;
29 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.RemoveRoutes;
30 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.SetLocalRouter;
31 import org.opendaylight.controller.remote.rpc.registry.gossip.Bucket;
32 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBuckets;
33 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBucketsReply;
34 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersions;
35 import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersionsReply;
36 import org.opendaylight.controller.sal.connector.api.RpcRouter;
37 import org.opendaylight.controller.sal.connector.api.RpcRouter.RouteIdentifier;
38 import org.opendaylight.yangtools.yang.common.QName;
39 import scala.concurrent.duration.Duration;
40 import scala.concurrent.duration.FiniteDuration;
42 public class RpcRegistryTest {
44 private static ActorSystem node1;
45 private static ActorSystem node2;
46 private static ActorSystem node3;
48 private ActorRef registry1;
49 private ActorRef registry2;
50 private ActorRef registry3;
52 private int routeIdCounter = 1;
55 public static void staticSetup() throws InterruptedException {
56 RemoteRpcProviderConfig config1 = new RemoteRpcProviderConfig.Builder("memberA").build();
57 RemoteRpcProviderConfig config2 = new RemoteRpcProviderConfig.Builder("memberB").build();
58 RemoteRpcProviderConfig config3 = new RemoteRpcProviderConfig.Builder("memberC").build();
59 node1 = ActorSystem.create("opendaylight-rpc", config1.get());
60 node2 = ActorSystem.create("opendaylight-rpc", config2.get());
61 node3 = ActorSystem.create("opendaylight-rpc", config3.get());
65 public static void staticTeardown() {
66 JavaTestKit.shutdownActorSystem(node1);
67 JavaTestKit.shutdownActorSystem(node2);
68 JavaTestKit.shutdownActorSystem(node3);
73 registry1 = node1.actorOf(Props.create(RpcRegistry.class));
74 registry2 = node2.actorOf(Props.create(RpcRegistry.class));
75 registry3 = node3.actorOf(Props.create(RpcRegistry.class));
79 public void teardown() {
80 if (registry1 != null) {
81 node1.stop(registry1);
83 if (registry2 != null) {
84 node2.stop(registry2);
86 if (registry3 != null) {
87 node3.stop(registry3);
92 * One node cluster. 1. Register rpc, ensure router can be found 2. Then remove rpc, ensure its
95 * @throws URISyntaxException
96 * @throws InterruptedException
99 public void testAddRemoveRpcOnSameNode() throws Exception {
101 System.out.println("testAddRemoveRpcOnSameNode starting");
103 final JavaTestKit mockBroker = new JavaTestKit(node1);
105 Address nodeAddress = node1.provider().getDefaultAddress();
108 registry1.tell(new SetLocalRouter(mockBroker.getRef()), mockBroker.getRef());
110 List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds = createRouteIds();
112 registry1.tell(new AddOrUpdateRoutes(addedRouteIds), mockBroker.getRef());
114 // Bucket store should get an update bucket message. Updated bucket contains added rpc.
116 Map<Address, Bucket> buckets = retrieveBuckets(registry1, mockBroker, nodeAddress);
117 verifyBucket(buckets.get(nodeAddress), addedRouteIds);
119 Map<Address, Long> versions = retrieveVersions(registry1, mockBroker);
120 Assert.assertEquals("Version for bucket " + nodeAddress, buckets.get(nodeAddress).getVersion(),
121 versions.get(nodeAddress));
124 registry1.tell(new RemoveRoutes(addedRouteIds), mockBroker.getRef());
126 // Bucket store should get an update bucket message. Rpc is removed in the updated bucket
128 verifyEmptyBucket(mockBroker, registry1, nodeAddress);
130 System.out.println("testAddRemoveRpcOnSameNode ending");
135 * Three node cluster. 1. Register rpc on 1 node, ensure 2nd node gets updated 2. Remove rpc on
136 * 1 node, ensure 2nd node gets updated
138 * @throws URISyntaxException
139 * @throws InterruptedException
142 public void testRpcAddRemoveInCluster() throws Exception {
144 System.out.println("testRpcAddRemoveInCluster starting");
146 final JavaTestKit mockBroker1 = new JavaTestKit(node1);
147 final JavaTestKit mockBroker2 = new JavaTestKit(node2);
149 List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds = createRouteIds();
151 Address node1Address = node1.provider().getDefaultAddress();
154 registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
155 registry1.tell(new AddOrUpdateRoutes(addedRouteIds), mockBroker1.getRef());
157 // Bucket store on node2 should get a message to update its local copy of remote buckets
159 Map<Address, Bucket> buckets = retrieveBuckets(registry2, mockBroker2, node1Address);
160 verifyBucket(buckets.get(node1Address), addedRouteIds);
163 registry1.tell(new RemoveRoutes(addedRouteIds), mockBroker1.getRef());
165 // Bucket store on node2 should get a message to update its local copy of remote buckets.
166 // Wait for the bucket for node1 to be empty.
168 verifyEmptyBucket(mockBroker2, registry2, node1Address);
170 System.out.println("testRpcAddRemoveInCluster ending");
173 private void verifyEmptyBucket(JavaTestKit testKit, ActorRef registry, Address address)
174 throws AssertionError {
175 Map<Address, Bucket> buckets;
178 buckets = retrieveBuckets(registry1, testKit, address);
181 verifyBucket(buckets.get(address), Collections.<RouteIdentifier<?, ?, ?>>emptyList());
183 } catch (AssertionError e) {
189 Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
194 * Three node cluster. Register rpc on 2 nodes. Ensure 3rd gets updated.
199 public void testRpcAddedOnMultiNodes() throws Exception {
201 final JavaTestKit mockBroker1 = new JavaTestKit(node1);
202 final JavaTestKit mockBroker2 = new JavaTestKit(node2);
203 final JavaTestKit mockBroker3 = new JavaTestKit(node3);
205 registry3.tell(new SetLocalRouter(mockBroker3.getRef()), mockBroker3.getRef());
208 List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds1 = createRouteIds();
209 registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
210 registry1.tell(new AddOrUpdateRoutes(addedRouteIds1), mockBroker1.getRef());
213 List<RpcRouter.RouteIdentifier<?, ?, ?>> addedRouteIds2 = createRouteIds();
214 registry2.tell(new SetLocalRouter(mockBroker2.getRef()), mockBroker2.getRef());
215 registry2.tell(new AddOrUpdateRoutes(addedRouteIds2), mockBroker2.getRef());
217 Address node1Address = node1.provider().getDefaultAddress();
218 Address node2Address = node2.provider().getDefaultAddress();
220 Map<Address, Bucket> buckets = retrieveBuckets(registry3, mockBroker3, node1Address,
223 verifyBucket(buckets.get(node1Address), addedRouteIds1);
224 verifyBucket(buckets.get(node2Address), addedRouteIds2);
226 Map<Address, Long> versions = retrieveVersions(registry3, mockBroker3);
227 Assert.assertEquals("Version for bucket " + node1Address, buckets.get(node1Address).getVersion(),
228 versions.get(node1Address));
229 Assert.assertEquals("Version for bucket " + node2Address, buckets.get(node2Address).getVersion(),
230 versions.get(node2Address));
232 RouteIdentifier<?, ?, ?> routeID = addedRouteIds1.get(0);
233 registry3.tell(new FindRouters(routeID), mockBroker3.getRef());
235 FindRoutersReply reply = mockBroker3.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
236 FindRoutersReply.class);
238 List<Pair<ActorRef, Long>> respList = reply.getRouterWithUpdateTime();
239 Assert.assertEquals("getRouterWithUpdateTime size", 1, respList.size());
241 respList.get(0).first().tell("hello", ActorRef.noSender());
242 mockBroker1.expectMsgEquals(Duration.create(3, TimeUnit.SECONDS), "hello");
245 private Map<Address, Long> retrieveVersions(ActorRef bucketStore, JavaTestKit testKit) {
246 bucketStore.tell(new GetBucketVersions(), testKit.getRef());
247 GetBucketVersionsReply reply = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
248 GetBucketVersionsReply.class);
249 return reply.getVersions();
252 private void verifyBucket(Bucket<RoutingTable> bucket, List<RouteIdentifier<?, ?, ?>> expRouteIds) {
253 RoutingTable table = bucket.getData();
254 Assert.assertNotNull("Bucket RoutingTable is null", table);
255 for(RouteIdentifier<?, ?, ?> r: expRouteIds) {
256 if(!table.contains(r)) {
257 Assert.fail("RoutingTable does not contain " + r + ". Actual: " + table);
261 Assert.assertEquals("RoutingTable size", expRouteIds.size(), table.size());
264 private Map<Address, Bucket> retrieveBuckets(ActorRef bucketStore, JavaTestKit testKit,
265 Address... addresses) {
268 bucketStore.tell(new GetAllBuckets(), testKit.getRef());
269 GetAllBucketsReply reply = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
270 GetAllBucketsReply.class);
272 Map<Address, Bucket> buckets = reply.getBuckets();
273 boolean foundAll = true;
274 for(Address addr: addresses) {
275 Bucket bucket = buckets.get(addr);
287 Assert.fail("Missing expected buckets for addresses: " + Arrays.toString(addresses)
288 + ", Actual: " + buckets);
291 Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
295 @SuppressWarnings("unchecked")
297 public void testAddRoutesConcurrency() throws Exception {
298 final JavaTestKit testKit = new JavaTestKit(node1);
300 registry1.tell(new SetLocalRouter(testKit.getRef()), ActorRef.noSender());
302 final int nRoutes = 500;
303 final RouteIdentifier<?, ?, ?>[] added = new RouteIdentifier<?, ?, ?>[nRoutes];
304 for(int i = 0; i < nRoutes; i++) {
305 final RouteIdentifierImpl routeId = new RouteIdentifierImpl(null,
306 new QName(new URI("/mockrpc"), "type" + i), null);
309 //Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
310 registry1.tell(new AddOrUpdateRoutes(Arrays.<RouteIdentifier<?, ?, ?>>asList(routeId)),
311 ActorRef.noSender());
314 GetAllBuckets getAllBuckets = new GetAllBuckets();
315 FiniteDuration duration = Duration.create(3, TimeUnit.SECONDS);
318 registry1.tell(getAllBuckets, testKit.getRef());
319 GetAllBucketsReply reply = testKit.expectMsgClass(duration, GetAllBucketsReply.class);
321 Bucket<RoutingTable> localBucket = reply.getBuckets().values().iterator().next();
322 RoutingTable table = localBucket.getData();
323 if(table != null && table.size() == nRoutes) {
324 for(RouteIdentifier<?, ?, ?> r: added) {
325 Assert.assertEquals("RoutingTable contains " + r, true, table.contains(r));
332 Assert.fail("Expected # routes: " + nRoutes + ", Actual: " + table.size());
335 Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
339 private List<RpcRouter.RouteIdentifier<?, ?, ?>> createRouteIds() throws URISyntaxException {
340 QName type = new QName(new URI("/mockrpc"), "mockrpc" + routeIdCounter++);
341 List<RpcRouter.RouteIdentifier<?, ?, ?>> routeIds = new ArrayList<>();
342 routeIds.add(new RouteIdentifierImpl(null, type, null));