Fix warnings in sal-akka-raft test classes
[controller.git] / opendaylight / md-sal / sal-akka-raft / src / test / java / org / opendaylight / controller / cluster / raft / TestActorFactory.java
1 /*
2  * Copyright (c) 2014 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.cluster.raft;
10
11 /*
12  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
13  *
14  * This program and the accompanying materials are made available under the
15  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
16  * and is available at http://www.eclipse.org/legal/epl-v10.html
17  */
18
19 import akka.actor.Actor;
20 import akka.actor.ActorIdentity;
21 import akka.actor.ActorRef;
22 import akka.actor.ActorSelection;
23 import akka.actor.ActorSystem;
24 import akka.actor.Identify;
25 import akka.actor.PoisonPill;
26 import akka.actor.Props;
27 import akka.pattern.Patterns;
28 import akka.testkit.JavaTestKit;
29 import akka.testkit.TestActorRef;
30 import akka.util.Timeout;
31 import com.google.common.base.Stopwatch;
32 import com.google.common.util.concurrent.Uninterruptibles;
33 import java.util.LinkedList;
34 import java.util.List;
35 import java.util.concurrent.TimeUnit;
36 import org.junit.Assert;
37 import org.slf4j.Logger;
38 import org.slf4j.LoggerFactory;
39 import scala.concurrent.Await;
40 import scala.concurrent.Future;
41
42 /**
43  * TestActorFactory provides methods to create both normal and test actors and to kill them when the factory is closed
44  * The ideal usage for TestActorFactory is with try with resources.
45  * <p/>
46  * For example <br/>
47  * <pre>
48  *     try (TestActorFactory factory = new TestActorFactory(getSystem())){
49  *         factory.createActor(props);
50  *         factory.createTestActor(props);
51  *         factory.generateActorId("leader-");
52  *     }
53  * </pre>
54  */
55 public class TestActorFactory implements AutoCloseable {
56     private static final Logger LOG = LoggerFactory.getLogger(TestActorFactory.class);
57
58     private final ActorSystem system;
59     List<ActorRef> createdActors = new LinkedList<>();
60     private static int actorCount = 1;
61
62     public TestActorFactory(ActorSystem system) {
63         this.system = system;
64     }
65
66     /**
67      * Create a normal actor with an auto-generated name.
68      *
69      * @param props the actor Props
70      * @return the ActorRef
71      */
72     public ActorRef createActor(Props props) {
73         ActorRef actorRef = system.actorOf(props);
74         return addActor(actorRef);
75     }
76
77     /**
78      * Create a normal actor with the passed in name.
79      *
80      * @param props the actor Props
81      * @param actorId name of actor
82      * @return the ActorRef
83      */
84     public ActorRef createActor(Props props, String actorId) {
85         ActorRef actorRef = system.actorOf(props, actorId);
86         return addActor(actorRef);
87     }
88
89     /**
90      * Create a test actor with the passed in name.
91      *
92      * @param props the actor Props
93      * @param actorId name of actor
94      * @param <T> the actor type
95      * @return the ActorRef
96      */
97     @SuppressWarnings("unchecked")
98     public <T extends Actor> TestActorRef<T> createTestActor(Props props, String actorId) {
99         TestActorRef<T> actorRef = TestActorRef.create(system, props, actorId);
100         return (TestActorRef<T>) addActor(actorRef);
101     }
102
103     /**
104      * Create a test actor with an auto-generated name.
105      *
106      * @param props the actor Props
107      * @param <T> the actor type
108      * @return the TestActorRef
109      */
110     @SuppressWarnings("unchecked")
111     public <T extends Actor> TestActorRef<T> createTestActor(Props props) {
112         TestActorRef<T> actorRef = TestActorRef.create(system, props);
113         return (TestActorRef<T>) addActor(actorRef);
114     }
115
116     private <T extends ActorRef> ActorRef addActor(T actorRef) {
117         createdActors.add(actorRef);
118         verifyActorReady(actorRef);
119         return actorRef;
120     }
121
122     @SuppressWarnings("checkstyle:IllegalCatch")
123     private void verifyActorReady(ActorRef actorRef) {
124         // Sometimes we see messages go to dead letters soon after creation - it seems the actor isn't quite
125         // in a state yet to receive messages or isn't actually created yet. This seems to happen with
126         // actorSelection so, to alleviate it, we use an actorSelection and send an Identify message with
127         // retries to ensure it's ready.
128
129         Timeout timeout = new Timeout(100, TimeUnit.MILLISECONDS);
130         Throwable lastError = null;
131         Stopwatch sw = Stopwatch.createStarted();
132         while (sw.elapsed(TimeUnit.SECONDS) <= 10) {
133             try {
134                 ActorSelection actorSelection = system.actorSelection(actorRef.path().toString());
135                 Future<Object> future = Patterns.ask(actorSelection, new Identify(""), timeout);
136                 ActorIdentity reply = (ActorIdentity)Await.result(future, timeout.duration());
137                 Assert.assertNotNull("Identify returned null", reply.getRef());
138                 return;
139             } catch (Exception | AssertionError e) {
140                 Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
141                 lastError = e;
142             }
143         }
144
145         throw new RuntimeException(lastError);
146     }
147
148     /**
149      * Generate a friendly but unique actor id/name.
150      *
151      * @param prefix the name prefix
152      * @return the actor name
153      */
154     public String generateActorId(String prefix) {
155         return prefix + actorCount++;
156     }
157
158     public void killActor(ActorRef actor, JavaTestKit kit) {
159         killActor(actor, kit, true);
160     }
161
162     private void killActor(ActorRef actor, JavaTestKit kit, boolean remove) {
163         LOG.info("Killing actor {}", actor);
164         kit.watch(actor);
165         actor.tell(PoisonPill.getInstance(), ActorRef.noSender());
166         kit.expectTerminated(JavaTestKit.duration("5 seconds"), actor);
167
168         if (remove) {
169             createdActors.remove(actor);
170         }
171     }
172
173     public String createTestActorPath(String actorId) {
174         return "akka://test/user/" + actorId;
175     }
176
177     @Override
178     public void close() {
179         JavaTestKit kit = new JavaTestKit(system);
180         for (ActorRef actor : createdActors) {
181             killActor(actor, kit, false);
182         }
183     }
184 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.