import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Uninterruptibles;
import java.io.OutputStream;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
testkit.watch(actor);
actor.tell(PoisonPill.getInstance(), null);
- testkit.expectMsgClass(testkit.duration("5 seconds"), Terminated.class);
+ testkit.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
testkit.unwatch(actor);
}
import com.google.common.collect.Sets;
import com.google.common.io.ByteSource;
import java.io.OutputStream;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
List<Object> snapshotState = MockRaftActor.fromState(applySnapshot.getSnapshot().getState());
assertEquals("Snapshot state", snapshotState, leaderRaftActor.getState());
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
assertEquals("getLeaderHint", LEADER_ID, addServerReply.getLeaderHint().get());
List<Object> snapshotState = MockRaftActor.fromState(applySnapshot.getSnapshot().getState());
assertEquals("Snapshot state", snapshotState, leaderRaftActor.getState());
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
assertEquals("getLeaderHint", LEADER_ID, addServerReply.getLeaderHint().get());
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), false), testKit.getRef());
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
assertEquals("getLeaderHint", LEADER_ID, addServerReply.getLeaderHint().get());
leaderActor.tell(new AddServer(NEW_SERVER_ID2, followerActor.path().toString(), false), testKit.getRef());
- addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
assertEquals("getLeaderHint", java.util.Optional.of(LEADER_ID), addServerReply.getLeaderHint());
newFollowerRaftActor.tell(installSnapshot, leaderActor);
// Verify both complete successfully
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
- addServerReply = testKit2.expectMsgClass(testKit2.duration("5 seconds"), AddServerReply.class);
+ addServerReply = testKit2.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
// Verify ServerConfigurationPayload entries in leader's log
leaderRaftActor.setDropMessageOfType(null);
leaderActor.tell(commitMsg, leaderActor);
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
assertEquals("getLeaderHint", LEADER_ID, addServerReply.getLeaderHint().get());
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.TIMEOUT, addServerReply.getStatus());
assertEquals("Leader peers size", 0, leaderActorContext.getPeerIds().size());
leaderActor.tell(new RaftActorServerConfigurationSupport.ServerOperationTimeout(NEW_SERVER_ID), leaderActor);
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.NO_LEADER, addServerReply.getStatus());
assertEquals("Leader peers size", 0, leaderActorContext.getPeerIds().size());
leaderRaftActor.setDropMessageOfType(null);
leaderActor.tell(snapshotReply, leaderActor);
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.NO_LEADER, addServerReply.getStatus());
assertEquals("Leader peers size", 0, leaderActorContext.getPeerIds().size());
leaderActor.tell(new UnInitializedFollowerSnapshotReply("bogus"), leaderActor);
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.TIMEOUT, addServerReply.getStatus());
assertEquals("Leader peers size", 0, leaderActorContext.getPeerIds().size());
noLeaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true),
testKit.getRef());
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.NO_LEADER, addServerReply.getStatus());
LOG.info("testAddServerWithNoLeader ending");
leaderActor.tell(new AddServer(NEW_SERVER_ID2, "", false), testKit.getRef());
// The first AddServer should succeed with OK even though consensus wasn't reached
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
assertEquals("getLeaderHint", LEADER_ID, addServerReply.getLeaderHint().get());
votingServer(NEW_SERVER_ID));
// The second AddServer should fail since consensus wasn't reached for the first
- addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.PRIOR_REQUEST_CONSENSUS_TIMEOUT, addServerReply.getStatus());
// Re-send the second AddServer - should also fail
leaderActor.tell(new AddServer(NEW_SERVER_ID2, "", false), testKit.getRef());
- addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.PRIOR_REQUEST_CONSENSUS_TIMEOUT, addServerReply.getStatus());
LOG.info("testAddServerWithNoConsensusReached ending");
leaderActor.tell(new AddServer(FOLLOWER_ID, followerActor.path().toString(), true), testKit.getRef());
- AddServerReply addServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"), AddServerReply.class);
+ AddServerReply addServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), AddServerReply.class);
assertEquals("getStatus", ServerChangeStatus.ALREADY_EXISTS, addServerReply.getStatus());
LOG.info("testAddServerWithExistingServer ending");
leaderActor.underlyingActor().waitForInitializeBehaviorComplete();
leaderActor.tell(new RemoveServer(FOLLOWER_ID), testKit.getRef());
- RemoveServerReply removeServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"),
- RemoveServerReply.class);
+ RemoveServerReply removeServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), RemoveServerReply.class);
assertEquals("getStatus", ServerChangeStatus.NO_LEADER, removeServerReply.getStatus());
LOG.info("testRemoveServerWithNoLeader ending");
actorFactory.generateActorId(LEADER_ID));
leaderActor.tell(new RemoveServer(NEW_SERVER_ID), testKit.getRef());
- RemoveServerReply removeServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"),
- RemoveServerReply.class);
+ RemoveServerReply removeServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), RemoveServerReply.class);
assertEquals("getStatus", ServerChangeStatus.DOES_NOT_EXIST, removeServerReply.getStatus());
LOG.info("testRemoveServerNonExistentServer ending");
follower2Actor.underlyingActor().waitForInitializeBehaviorComplete();
leaderActor.tell(new RemoveServer(FOLLOWER_ID), testKit.getRef());
- RemoveServerReply removeServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"),
- RemoveServerReply.class);
+ RemoveServerReply removeServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), RemoveServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, removeServerReply.getStatus());
ApplyState applyState = MessageCollectorActor.expectFirstMatching(leaderCollector, ApplyState.class);
followerActorId);
leaderActor.tell(new RemoveServer(LEADER_ID), testKit.getRef());
- RemoveServerReply removeServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"),
- RemoveServerReply.class);
+ RemoveServerReply removeServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), RemoveServerReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, removeServerReply.getStatus());
final ApplyState applyState = MessageCollectorActor.expectFirstMatching(followerCollector, ApplyState.class);
actorFactory.generateActorId(LEADER_ID));
leaderActor.tell(new RemoveServer(LEADER_ID), testKit.getRef());
- RemoveServerReply removeServerReply = testKit.expectMsgClass(testKit.duration("5 seconds"),
- RemoveServerReply.class);
+ RemoveServerReply removeServerReply = testKit.expectMsgClass(Duration.ofSeconds(5), RemoveServerReply.class);
assertEquals("getStatus", ServerChangeStatus.NOT_SUPPORTED, removeServerReply.getStatus());
LOG.info("testRemoveServerLeaderWithNoFollowers ending");
leaderActor.tell(new ChangeServersVotingStatus(ImmutableMap.of(FOLLOWER_ID, false, FOLLOWER_ID2, false)),
testKit.getRef());
- ServerChangeReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ ServerChangeReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());
final ApplyState applyState = MessageCollectorActor.expectFirstMatching(leaderCollector, ApplyState.class);
// Send second ChangeServersVotingStatus message
leaderActor.tell(new ChangeServersVotingStatus(ImmutableMap.of(FOLLOWER_ID, true)), testKit.getRef());
- reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());
MessageCollectorActor.expectFirstMatching(leaderCollector, ApplyState.class);
// Send ChangeServersVotingStatus message
leaderActor.tell(new ChangeServersVotingStatus(ImmutableMap.of(LEADER_ID, false)), testKit.getRef());
- ServerChangeReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ ServerChangeReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());
MessageCollectorActor.expectFirstMatching(leaderCollector, ApplyState.class);
.withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId(LEADER_ID));
leaderActor.tell(new ChangeServersVotingStatus(ImmutableMap.of(LEADER_ID, false)), testKit.getRef());
- ServerChangeReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ ServerChangeReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.INVALID_REQUEST, reply.getStatus());
LOG.info("testChangeLeaderToNonVotingInSingleNode ending");
ChangeServersVotingStatus changeServers = new ChangeServersVotingStatus(ImmutableMap.of(node1ID, true,
node2ID, true, "downNode1", false, "downNode2", false));
node1RaftActorRef.tell(changeServers, testKit.getRef());
- ServerChangeReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ ServerChangeReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.NO_LEADER, reply.getStatus());
assertEquals("getRaftState", RaftState.Follower, node1RaftActor.getRaftState());
node1RaftActor.setPeerAddress(node2ID, node2RaftActorRef.path().toString());
node1RaftActorRef.tell(changeServers, testKit.getRef());
- reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());
ApplyJournalEntries apply = MessageCollectorActor.expectFirstMatching(node1Collector,
ChangeServersVotingStatus changeServers = new ChangeServersVotingStatus(ImmutableMap.of(node1ID, true));
node1RaftActorRef.tell(changeServers, testKit.getRef());
- ServerChangeReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ ServerChangeReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.NO_LEADER, reply.getStatus());
assertEquals("Server config", Sets.newHashSet(nonVotingServer(node1ID), votingServer(node2ID)),
ChangeServersVotingStatus changeServers = new ChangeServersVotingStatus(
ImmutableMap.of(node1ID, true, node2ID, true));
node1RaftActorRef.tell(changeServers, testKit.getRef());
- ServerChangeReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ ServerChangeReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());
MessageCollectorActor.expectFirstMatching(node2Collector, ApplyJournalEntries.class);
node2RaftActorRef.tell(TimeoutNow.INSTANCE, ActorRef.noSender());
- ServerChangeReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ServerChangeReply.class);
+ ServerChangeReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ServerChangeReply.class);
assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());
MessageCollectorActor.expectFirstMatching(node1Collector, ApplyJournalEntries.class);
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyObject;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import com.google.common.util.concurrent.Uninterruptibles;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import org.opendaylight.yangtools.concepts.Identifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class RaftActorTest extends AbstractActorTest {
// kill the actor
followerActor.tell(PoisonPill.getInstance(), null);
- kit.expectMsgClass(kit.duration("5 seconds"), Terminated.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
kit.unwatch(followerActor);
// Test with timeout
mockRaftActor.getSnapshotMessageSupport().setSnapshotReplyActorTimeout(
- Duration.create(200, TimeUnit.MILLISECONDS));
+ FiniteDuration.create(200, TimeUnit.MILLISECONDS));
reset(mockRaftActor.snapshotCohortDelegate);
raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef());
Failure failure = kit.expectMsgClass(akka.actor.Status.Failure.class);
assertEquals("Failure cause type", TimeoutException.class, failure.cause().getClass());
- mockRaftActor.getSnapshotMessageSupport().setSnapshotReplyActorTimeout(Duration.create(30, TimeUnit.SECONDS));
+ mockRaftActor.getSnapshotMessageSupport().setSnapshotReplyActorTimeout(
+ FiniteDuration.create(30, TimeUnit.SECONDS));
// Test with persistence disabled.
import akka.actor.Props;
import akka.testkit.javadsl.TestKit;
import com.google.common.collect.ImmutableList;
+import java.time.Duration;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.cluster.datastore.messages.DataTreeChanged;
subject.tell(new DataTreeChanged(mockCandidates), testKit.getRef());
- testKit.within(testKit.duration("1 seconds"), () -> {
+ testKit.within(Duration.ofSeconds(1), () -> {
testKit.expectNoMessage();
verify(mockListener, never()).onDataTreeChanged(anyCollection());
return null;
while (true) {
DeadLetter deadLetter;
try {
- deadLetter = testKit.expectMsgClass(testKit.duration("1 seconds"), DeadLetter.class);
+ deadLetter = testKit.expectMsgClass(Duration.ofSeconds(1), DeadLetter.class);
} catch (AssertionError e) {
// Timed out - got no DeadLetter - this is good
break;
import akka.util.Timeout;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.time.Duration;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.mockito.stubbing.Answer;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import scala.concurrent.ExecutionContextExecutor;
import scala.concurrent.Future;
-import scala.concurrent.duration.FiniteDuration;
public class DataTreeChangeListenerProxyTest extends AbstractActorTest {
private final DOMDataTreeChangeListener mockListener = mock(DOMDataTreeChangeListener.class);
new Thread(() -> proxy.init("shard-1")).start();
- FiniteDuration timeout = kit.duration("5 seconds");
+ Duration timeout = Duration.ofSeconds(5);
FindLocalShard findLocalShard = kit.expectMsgClass(timeout, FindLocalShard.class);
assertEquals("getShardName", "shard-1", findLocalShard.getShardName());
new Thread(() -> proxy.init("shard-1")).start();
- FiniteDuration timeout = kit.duration("5 seconds");
+ Duration timeout = Duration.ofSeconds(5);
FindLocalShard findLocalShard = kit.expectMsgClass(timeout, FindLocalShard.class);
assertEquals("getShardName", "shard-1", findLocalShard.getShardName());
new Thread(() -> proxy.init("shard-1")).start();
- FiniteDuration timeout = kit.duration("5 seconds");
+ Duration timeout = Duration.ofSeconds(5);
FindLocalShard findLocalShard = kit.expectMsgClass(timeout, FindLocalShard.class);
assertEquals("getShardName", "shard-1", findLocalShard.getShardName());
kit.reply(new LocalShardNotFound("shard-1"));
- kit.expectNoMessage(kit.duration("1 seconds"));
+ kit.expectNoMessage(Duration.ofSeconds(1));
proxy.close();
}
new Thread(() -> proxy.init("shard-1")).start();
- FiniteDuration timeout = kit.duration("5 seconds");
+ Duration timeout = Duration.ofSeconds(5);
FindLocalShard findLocalShard = kit.expectMsgClass(timeout, FindLocalShard.class);
assertEquals("getShardName", "shard-1", findLocalShard.getShardName());
kit.reply(new NotInitializedException("not initialized"));
- kit.within(kit.duration("1 seconds"), () -> {
+ kit.within(Duration.ofSeconds(1), () -> {
kit.expectNoMessage();
return null;
});
proxy.init(shardName);
- kit.expectMsgClass(kit.duration("5 seconds"), CloseDataTreeNotificationListenerRegistration.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), CloseDataTreeNotificationListenerRegistration.class);
assertEquals("getListenerRegistrationActor", null, proxy.getListenerRegistrationActor());
}
import akka.testkit.TestActorRef;
import akka.testkit.javadsl.TestKit;
import akka.util.Timeout;
+import java.time.Duration;
import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import scala.concurrent.Await;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
/**
* Unit tests for DataTreeChangeListenerSupport.
listener.reset(1);
TestKit kit = new TestKit(getSystem());
entry.getValue().tell(CloseDataTreeNotificationListenerRegistration.getInstance(), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), CloseDataTreeNotificationListenerRegistrationReply.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), CloseDataTreeNotificationListenerRegistrationReply.class);
writeToStore(shard.getDataStore(), TEST_PATH, ImmutableNodes.containerNode(TEST_QNAME));
listener.verifyNoNotifiedData(TEST_PATH);
try {
reply = (RegisterDataTreeNotificationListenerReply)
Await.result(Patterns.ask(shardActor, new RegisterDataTreeChangeListener(path, dclActor, false),
- new Timeout(5, TimeUnit.SECONDS)), Duration.create(5, TimeUnit.SECONDS));
+ new Timeout(5, TimeUnit.SECONDS)), FiniteDuration.create(5, TimeUnit.SECONDS));
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
import akka.testkit.TestActorRef;
import akka.testkit.javadsl.TestKit;
import com.google.common.collect.ImmutableSortedSet;
+import java.time.Duration;
import java.util.SortedSet;
-import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import scala.concurrent.duration.FiniteDuration;
/**
* Unit tests for various 3PC coordination scenarios.
// in the participating shard list.
shardA.tell(new CanCommitTransaction(txId2, CURRENT_VERSION).toSerializable(), kit2.getRef());
- kit2.expectNoMessage(FiniteDuration.create(100, TimeUnit.MILLISECONDS));
+ kit2.expectNoMessage(Duration.ofMillis(100));
// Send tx1 CanCommit to A - it's at the head of the queue so should proceed.
// Send tx2 CanCommit to B - tx1 should now be at the head of he queue.
shardB.tell(new CanCommitTransaction(txId2, CURRENT_VERSION).toSerializable(), kit2.getRef());
- kit2.expectNoMessage(FiniteDuration.create(100, TimeUnit.MILLISECONDS));
+ kit2.expectNoMessage(Duration.ofMillis(100));
// Finish commit of tx1.
// shard list [A] matches that of tx5 so tx3 should be moved ahead of tx5 in the queue.
shardB.tell(new CanCommitTransaction(txId3, CURRENT_VERSION).toSerializable(), kit3.getRef());
- kit3.expectNoMessage(FiniteDuration.create(100, TimeUnit.MILLISECONDS));
+ kit3.expectNoMessage(Duration.ofMillis(100));
// Send tx4 CanCommit to B - tx4's participating shard list [A] matches that of tx3 and tx5 - so tx4 should
// be moved ahead of tx5 in the queue but not tx3 since should be in the CAN_COMMIT_PENDING state.
shardB.tell(new CanCommitTransaction(txId4, CURRENT_VERSION).toSerializable(), kit4.getRef());
- kit4.expectNoMessage(FiniteDuration.create(100, TimeUnit.MILLISECONDS));
+ kit4.expectNoMessage(Duration.ofMillis(100));
// Send tx5 CanCommit to B - it's position in the queue should remain the same.
shardB.tell(new CanCommitTransaction(txId5, CURRENT_VERSION).toSerializable(), kit5.getRef());
- kit5.expectNoMessage(FiniteDuration.create(100, TimeUnit.MILLISECONDS));
+ kit5.expectNoMessage(Duration.ofMillis(100));
// Finish commit of tx1.
// shard list [A] do not match that of tx2 [B] so tx1 should not be allowed to proceed.
shardC.tell(new CanCommitTransaction(txId1, CURRENT_VERSION).toSerializable(), kit1.getRef());
- kit1.expectNoMessage(FiniteDuration.create(100, TimeUnit.MILLISECONDS));
+ kit1.expectNoMessage(Duration.ofMillis(100));
// Send tx2 CanCommit to C - it's at the head of the queue so should proceed.
// shard list [A] do not match that of tx2 [] so tx1 should not be allowed to proceed.
shardB.tell(new CanCommitTransaction(txId1, CURRENT_VERSION).toSerializable(), kit1.getRef());
- kit1.expectNoMessage(FiniteDuration.create(100, TimeUnit.MILLISECONDS));
+ kit1.expectNoMessage(Duration.ofMillis(100));
// Send tx2 CanCommit to B - it's at the head of the queue so should proceed.
import com.google.common.base.Stopwatch;
import com.google.common.base.Throwables;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.time.Duration;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
shard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, false), testKit.getRef());
- final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+ final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(3),
RegisterDataTreeNotificationListenerReply.class);
final String replyPath = reply.getListenerRegistrationPath().toString();
assertTrue("Incorrect reply path: " + replyPath,
assertTrue("Got first ElectionTimeout", onFirstElectionTimeout.await(5, TimeUnit.SECONDS));
shard.tell(new RegisterDataTreeChangeListener(path, dclActor, false), testKit.getRef());
- final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+ final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
RegisterDataTreeNotificationListenerReply.class);
assertNotNull("getListenerRegistratioznPath", reply.getListenerRegistrationPath());
shard.tell(FindLeader.INSTANCE, testKit.getRef());
- final FindLeaderReply findLeadeReply = testKit.expectMsgClass(testKit.duration("5 seconds"),
- FindLeaderReply.class);
+ final FindLeaderReply findLeadeReply = testKit.expectMsgClass(Duration.ofSeconds(5), FindLeaderReply.class);
assertFalse("Expected the shard not to be the leader", findLeadeReply.getLeaderActor().isPresent());
onChangeListenerRegistered.countDown();
shard.tell(new CreateTransaction(nextTransactionId(), TransactionType.READ_ONLY.ordinal(),
DataStoreVersions.CURRENT_VERSION).toSerializable(), testKit.getRef());
- final CreateTransactionReply reply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+ final CreateTransactionReply reply = testKit.expectMsgClass(Duration.ofSeconds(3),
CreateTransactionReply.class);
final String path = reply.getTransactionPath().toString();
shard.tell(new CreateTransaction(nextTransactionId(), TransactionType.READ_ONLY.ordinal(),
DataStoreVersions.CURRENT_VERSION).toSerializable(), testKit.getRef());
- final CreateTransactionReply reply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+ final CreateTransactionReply reply = testKit.expectMsgClass(Duration.ofSeconds(3),
CreateTransactionReply.class);
final String path = reply.getTransactionPath().toString();
final CountDownLatch commitLatch = new CountDownLatch(2);
final long timeoutSec = 5;
- final FiniteDuration duration = FiniteDuration.create(timeoutSec, TimeUnit.SECONDS);
- final Timeout timeout = new Timeout(duration);
+ final Duration duration = Duration.ofSeconds(timeoutSec);
+ final Timeout timeout = Timeout.create(duration);
final TestActorRef<Shard> shard = actorFactory.createTestActor(
newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
ShardTestKit.waitUntilLeader(shard);
final TransactionIdentifier transactionID = nextTransactionId();
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
// Send a BatchedModifications to start a transaction.
ShardTestKit.waitUntilLeader(shard);
final TransactionIdentifier transactionID = nextTransactionId();
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
// Send a BatchedModifications to start a transaction.
shard.tell(batched, testKit.getRef());
- final Failure failure = testKit.expectMsgClass(testKit.duration("5 seconds"), Failure.class);
+ final Failure failure = testKit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
if (failure != null) {
Throwables.propagateIfPossible(failure.cause(), Exception.class);
BatchedModifications batched = new BatchedModifications(transactionID, CURRENT_VERSION);
batched.addModification(new MergeModification(TestModel.TEST_PATH, invalidData));
shard.tell(batched, testKit.getRef());
- Failure failure = testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
+ Failure failure = testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
final Throwable cause = failure.cause();
shard.tell(batched, testKit.getRef());
- failure = testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
+ failure = testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
assertEquals("Failure cause", cause, failure.cause());
}
final TransactionIdentifier transactionID1 = new TransactionIdentifier(historyId, 0);
final TransactionIdentifier transactionID2 = new TransactionIdentifier(historyId, 1);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
// Send a BatchedModifications to start a chained write
// transaction and ready it.
shard.tell(new CreateTransaction(transactionID2, TransactionType.READ_ONLY.ordinal(),
DataStoreVersions.CURRENT_VERSION).toSerializable(), testKit.getRef());
- final CreateTransactionReply createReply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+ final CreateTransactionReply createReply = testKit.expectMsgClass(Duration.ofSeconds(3),
CreateTransactionReply.class);
getSystem().actorSelection(createReply.getTransactionPath())
.tell(new ReadData(path, DataStoreVersions.CURRENT_VERSION), testKit.getRef());
- final ReadDataReply readReply = testKit.expectMsgClass(testKit.duration("3 seconds"), ReadDataReply.class);
+ final ReadDataReply readReply = testKit.expectMsgClass(Duration.ofSeconds(3), ReadDataReply.class);
assertEquals("Read node", containerNode, readReply.getNormalizedNode());
// Commit the write transaction.
testKit.getRef());
}
- testKit.expectMsgClass(testKit.duration("5 seconds"), CommitTransactionReply.class);
+ testKit.expectMsgClass(Duration.ofSeconds(5), CommitTransactionReply.class);
final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.TEST_PATH);
assertEquals(TestModel.TEST_QNAME.getLocalName(), containerNode, actualNode);
// Setup a simulated transactions with a mock cohort.
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
final TransactionIdentifier transactionID = nextTransactionId();
final NormalizedNode<?, ?> containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
final TransactionIdentifier transactionID = nextTransactionId();
if (readWrite) {
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
- final Timeout timeout = new Timeout(duration);
+ final Duration duration = Duration.ofSeconds(5);
+ final Timeout timeout = Timeout.create(duration);
// Setup 2 simulated transactions with mock cohorts. The first
// one fails in the
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
- final Timeout timeout = new Timeout(duration);
+ final Duration duration = Duration.ofSeconds(5);
+ final Timeout timeout = Timeout.create(duration);
doThrow(new RuntimeException("mock preCommit failure")).when(dataTree)
.prepare(any(DataTreeModification.class));
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
final TransactionIdentifier transactionID1 = nextTransactionId();
doThrow(new DataValidationFailedException(YangInstanceIdentifier.EMPTY, "mock canCommit failure"))
doThrow(new DataValidationFailedException(YangInstanceIdentifier.EMPTY, "mock canCommit failure"))
.doNothing().when(dataTree).validate(any(DataTreeModification.class));
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
final TransactionIdentifier transactionID1 = nextTransactionId();
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
final TransactionIdentifier transactionID = nextTransactionId();
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
writeToStore(shard, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
writeToStore(shard, TestModel.OUTER_LIST_PATH,
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
final TransactionIdentifier transactionID1 = nextTransactionId();
shard.tell(newBatchedModifications(transactionID1, TestModel.TEST_PATH,
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
final ShardDataTree dataStore = shard.underlyingActor().getDataStore();
"testCanCommitBeforeReadyFailure");
shard.tell(new CanCommitTransaction(nextTransactionId(), CURRENT_VERSION).toSerializable(), testKit.getRef());
- testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
+ testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
}
@Test
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
- final Timeout timeout = new Timeout(duration);
+ final Duration duration = Duration.ofSeconds(5);
+ final Timeout timeout = Timeout.create(duration);
// Ready 2 transactions - the first one will be aborted.
// Wait for the 2nd Tx to complete the canCommit phase.
- canCommitReply = (CanCommitTransactionReply) Await.result(canCommitFuture, duration);
+ canCommitReply = (CanCommitTransactionReply) Await.result(canCommitFuture,
+ FiniteDuration.create(5, TimeUnit.SECONDS));
assertTrue("Can commit", canCommitReply.getCanCommit());
}
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
// Ready a tx.
ShardTestKit.waitUntilLeader(shard);
- final FiniteDuration duration = testKit.duration("5 seconds");
+ final Duration duration = Duration.ofSeconds(5);
// Ready 3 tx's.
}
}
- final ShardTestKit testKit = new ShardTestKit(getSystem());
-
final Creator<Shard> creator = () -> new TestShard(newShardBuilder());
final TestActorRef<Shard> shard = actorFactory.createTestActor(Props
testKit.waitUntilNoLeader(shard);
shard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, true), testKit.getRef());
- final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+ final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
RegisterDataTreeNotificationListenerReply.class);
assertNotNull("getListenerRegistrationPath", reply.getListenerRegistrationPath());
testKit.waitUntilNoLeader(shard);
shard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, true), testKit.getRef());
- final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+ final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
RegisterDataTreeNotificationListenerReply.class);
assertNotNull("getListenerRegistrationPath", reply.getListenerRegistrationPath());
actorFactory.generateActorId(testName + "-DataTreeChangeListener"));
followerShard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, true), testKit.getRef());
- final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+ final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
RegisterDataTreeNotificationListenerReply.class);
assertNotNull("getListenerRegistrationPath", reply.getListenerRegistrationPath());
import akka.testkit.TestActorRef;
import akka.testkit.javadsl.TestKit;
import com.google.common.base.Throwables;
+import java.time.Duration;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
transaction.tell(new ReadData(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION),
testKit.getRef());
- ReadDataReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ReadDataReply.class);
+ ReadDataReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ReadDataReply.class);
assertNotNull(reply.getNormalizedNode());
}
private void testOnReceiveReadDataWhenDataNotFound(final ActorRef transaction) {
transaction.tell(new ReadData(TestModel.TEST_PATH, DataStoreVersions.CURRENT_VERSION), testKit.getRef());
- ReadDataReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), ReadDataReply.class);
+ ReadDataReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), ReadDataReply.class);
assertNull(reply.getNormalizedNode());
}
transaction.tell(new DataExists(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION),
testKit.getRef());
- DataExistsReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), DataExistsReply.class);
+ DataExistsReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), DataExistsReply.class);
assertTrue(reply.exists());
}
private void testOnReceiveDataExistsNegative(final ActorRef transaction) {
transaction.tell(new DataExists(TestModel.TEST_PATH, DataStoreVersions.CURRENT_VERSION), testKit.getRef());
- DataExistsReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"), DataExistsReply.class);
+ DataExistsReply reply = testKit.expectMsgClass(Duration.ofSeconds(5), DataExistsReply.class);
assertFalse(reply.exists());
}
transaction.tell(batched, testKit.getRef());
- BatchedModificationsReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+ BatchedModificationsReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
BatchedModificationsReply.class);
assertEquals("getNumBatched", 3, reply.getNumBatched());
batched.addModification(new WriteModification(writePath, writeData));
transaction.tell(batched, testKit.getRef());
- BatchedModificationsReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+ BatchedModificationsReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
BatchedModificationsReply.class);
assertEquals("getNumBatched", 1, reply.getNumBatched());
batched.setTotalMessagesSent(2);
transaction.tell(batched, testKit.getRef());
- testKit.expectMsgClass(testKit.duration("5 seconds"), ReadyTransactionReply.class);
- watcher.expectMsgClass(watcher.duration("5 seconds"), Terminated.class);
+ testKit.expectMsgClass(Duration.ofSeconds(5), ReadyTransactionReply.class);
+ watcher.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
}
@Test
batched.setTotalMessagesSent(1);
transaction.tell(batched, testKit.getRef());
- testKit.expectMsgClass(testKit.duration("5 seconds"), CommitTransactionReply.class);
- watcher.expectMsgClass(testKit.duration("5 seconds"), Terminated.class);
+ testKit.expectMsgClass(Duration.ofSeconds(5), CommitTransactionReply.class);
+ watcher.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
}
@Test(expected = TestException.class)
batched.addModification(new WriteModification(path, node));
transaction.tell(batched, testKit.getRef());
- testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
+ testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
batched = new BatchedModifications(tx1, DataStoreVersions.CURRENT_VERSION);
batched.setReady();
batched.setTotalMessagesSent(2);
transaction.tell(batched, testKit.getRef());
- Failure failure = testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
- watcher.expectMsgClass(testKit.duration("5 seconds"), Terminated.class);
+ Failure failure = testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
+ watcher.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
if (failure != null) {
Throwables.propagateIfPossible(failure.cause(), Exception.class);
transaction.tell(batched, testKit.getRef());
- Failure failure = testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
- watcher.expectMsgClass(watcher.duration("5 seconds"), Terminated.class);
+ Failure failure = testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
+ watcher.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
if (failure != null) {
Throwables.throwIfInstanceOf(failure.cause(), Exception.class);
transaction.tell(new CloseTransaction().toSerializable(), testKit.getRef());
- testKit.expectMsgClass(testKit.duration("3 seconds"), CloseTransactionReply.class);
- testKit.expectTerminated(testKit.duration("3 seconds"), transaction);
+ testKit.expectMsgClass(Duration.ofSeconds(3), CloseTransactionReply.class);
+ testKit.expectTerminated(Duration.ofSeconds(3), transaction);
}
@Test
transaction.tell(new CloseTransaction().toSerializable(), testKit.getRef());
- testKit.expectMsgClass(testKit.duration("3 seconds"), CloseTransactionReply.class);
- testKit.expectTerminated(testKit.duration("3 seconds"), transaction);
+ testKit.expectMsgClass(Duration.ofSeconds(3), CloseTransactionReply.class);
+ testKit.expectTerminated(Duration.ofSeconds(3), transaction);
}
@Test
transaction.tell(new CloseTransaction().toSerializable(), testKit.getRef());
- testKit.expectMsgClass(testKit.duration("3 seconds"), Terminated.class);
+ testKit.expectMsgClass(Duration.ofSeconds(3), Terminated.class);
}
@Test
testKit.watch(transaction);
- testKit.expectMsgClass(testKit.duration("3 seconds"), Terminated.class);
+ testKit.expectMsgClass(Duration.ofSeconds(3), Terminated.class);
}
public static class TestException extends RuntimeException {
import akka.actor.ActorRef;
import akka.testkit.javadsl.TestKit;
+import java.time.Duration;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
mockOnClose), ActorRef.noSender());
subject.tell(CloseDataTreeNotificationListenerRegistration.getInstance(), kit.getRef());
- kit.expectMsgClass(kit.duration("5 second"), CloseDataTreeNotificationListenerRegistrationReply.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), CloseDataTreeNotificationListenerRegistrationReply.class);
verify(mockListenerReg, timeout(5000)).close();
verify(mockOnClose, timeout(5000)).run();
- kit.expectTerminated(kit.duration("5 second"), subject);
+ kit.expectTerminated(Duration.ofSeconds(5), subject);
}
@Test
kit.watch(subject);
subject.tell(CloseDataTreeNotificationListenerRegistration.getInstance(), kit.getRef());
- kit.expectMsgClass(kit.duration("5 second"), CloseDataTreeNotificationListenerRegistrationReply.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), CloseDataTreeNotificationListenerRegistrationReply.class);
subject.tell(new DataTreeNotificationListenerRegistrationActor.SetRegistration(mockListenerReg,
mockOnClose), ActorRef.noSender());
verify(mockListenerReg, timeout(5000)).close();
verify(mockOnClose, timeout(5000)).run();
- kit.expectTerminated(kit.duration("5 second"), subject);
+ kit.expectTerminated(Duration.ofSeconds(5), subject);
}
@Test
verify(mockListenerReg2, timeout(5000)).close();
verify(mockOnClose2, timeout(5000)).run();
- kit.expectTerminated(kit.duration("5 second"), subject);
+ kit.expectTerminated(Duration.ofSeconds(5), subject);
}
}
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
+import java.time.Duration;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.controller.cluster.datastore.AbstractActorTest;
ShardSnapshotActor.requestSnapshot(snapshotActor, snapshot,
Optional.ofNullable(installSnapshotStream), kit.getRef());
- final CaptureSnapshotReply reply = kit.expectMsgClass(kit.duration("3 seconds"), CaptureSnapshotReply.class);
+ final CaptureSnapshotReply reply = kit.expectMsgClass(Duration.ofSeconds(3), CaptureSnapshotReply.class);
assertNotNull("getSnapshotState is null", reply.getSnapshotState());
assertEquals("SnapshotState type", ShardSnapshotState.class, reply.getSnapshotState().getClass());
assertEquals("Snapshot", snapshot, ((ShardSnapshotState)reply.getSnapshotState()).getSnapshot());
import akka.testkit.javadsl.TestKit;
import com.google.common.collect.ImmutableSet;
-import java.util.concurrent.TimeUnit;
+import java.time.Duration;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
-import scala.concurrent.duration.FiniteDuration;
/**
* Unit tests for CandidateListChangeListener.
ImmutableSet.copyOf(candidateAdded.getAllCandidates()));
writeNode(ENTITY_OWNERS_PATH, entityOwnersWithCandidate(ENTITY_TYPE, ENTITY_ID1, memberName1));
- kit.expectNoMessage(FiniteDuration.create(500, TimeUnit.MILLISECONDS));
+ kit.expectNoMessage(Duration.ofMillis(500));
String memberName2 = "member-2";
writeNode(ENTITY_OWNERS_PATH, entityOwnersWithCandidate(ENTITY_TYPE, ENTITY_ID1, memberName2));
import static org.junit.Assert.assertEquals;
import static org.mockito.AdditionalMatchers.or;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import akka.testkit.TestActorRef;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
kit.watch(peer2);
peer2.tell(PoisonPill.getInstance(), ActorRef.noSender());
- kit.expectMsgClass(kit.duration("5 seconds"), Terminated.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
kit.unwatch(peer2);
leader.tell(new PeerDown(peerId2.getMemberName(), peerId2.toString()), ActorRef.noSender());
kit.watch(peer1);
peer1.tell(PoisonPill.getInstance(), ActorRef.noSender());
- kit.expectMsgClass(kit.duration("5 seconds"), Terminated.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
kit.unwatch(peer1);
leader.tell(new PeerDown(peerId1.getMemberName(), peerId1.toString()), ActorRef.noSender());
kit.watch(leader);
leader.tell(PoisonPill.getInstance(), ActorRef.noSender());
- kit.expectMsgClass(kit.duration("5 seconds"), Terminated.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Terminated.class);
kit.unwatch(leader);
peer2.tell(new PeerDown(leaderId.getMemberName(), leaderId.toString()), ActorRef.noSender());
peer2.tell(TimeoutNow.INSTANCE, peer2);
import akka.actor.Status.Failure;
import akka.actor.Terminated;
import akka.testkit.javadsl.TestKit;
+import java.time.Duration;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.opendaylight.controller.cluster.raft.client.messages.GetSnapshotReply;
import org.opendaylight.controller.cluster.raft.persisted.ByteState;
import org.opendaylight.controller.cluster.raft.persisted.Snapshot;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
/**
ShardManagerSnapshot shardManagerSnapshot = new ShardManagerSnapshot(shardList, Collections.emptyMap());
ActorRef replyActor = getSystem().actorOf(ShardManagerGetSnapshotReplyActor.props(
shardList, "config", shardManagerSnapshot, kit.getRef(),
- "shard-manager", Duration.create(100, TimeUnit.SECONDS)), "testSuccess");
+ "shard-manager", FiniteDuration.create(100, TimeUnit.SECONDS)), "testSuccess");
kit.watch(replyActor);
Snapshot.create(shard2SnapshotState, Collections.<ReplicatedLogEntry>emptyList(),
2, 1, 2, 1, 1, "member-1", null)), ActorRef.noSender());
- kit.expectNoMessage(FiniteDuration.create(500, TimeUnit.MILLISECONDS));
+ kit.expectNoMessage(Duration.ofMillis(500));
ByteState shard3SnapshotState = ByteState.of(new byte[]{7,8,9});
replyActor.tell(new GetSnapshotReply(ShardIdentifier.create("shard3", MEMBER_1, "config").toString(),
ActorRef replyActor = getSystem().actorOf(ShardManagerGetSnapshotReplyActor.props(
Arrays.asList("shard1", "shard2"), "config", null, kit.getRef(), "shard-manager",
- Duration.create(100, TimeUnit.SECONDS)), "testGetSnapshotFailureReply");
+ FiniteDuration.create(100, TimeUnit.SECONDS)), "testGetSnapshotFailureReply");
kit.watch(replyActor);
ActorRef replyActor = getSystem().actorOf(ShardManagerGetSnapshotReplyActor.props(
Arrays.asList("shard1"), "config", null, kit.getRef(), "shard-manager",
- Duration.create(100, TimeUnit.MILLISECONDS)), "testGetSnapshotTimeout");
+ FiniteDuration.create(100, TimeUnit.MILLISECONDS)), "testGetSnapshotTimeout");
kit.watch(replyActor);
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Uninterruptibles;
import java.net.URI;
+import java.time.Duration;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Collection;
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class ShardManagerTest extends AbstractShardManagerTest {
shardManager.tell(new FindPrimary("non-existent", false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), PrimaryNotFoundException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), PrimaryNotFoundException.class);
}
@Test
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, false), kit.getRef());
- LocalPrimaryShardFound primaryFound = kit.expectMsgClass(kit.duration("5 seconds"),
+ LocalPrimaryShardFound primaryFound = kit.expectMsgClass(Duration.ofSeconds(5),
LocalPrimaryShardFound.class);
assertTrue("Unexpected primary path " + primaryFound.getPrimaryPath(),
primaryFound.getPrimaryPath().contains("member-1-shard-default"));
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NoShardLeaderException.class);
LOG.info("testOnReceiveFindPrimaryForNonLocalLeaderShardBeforeMemberUp ending");
}
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, false), kit.getRef());
- RemotePrimaryShardFound primaryFound = kit.expectMsgClass(kit.duration("5 seconds"),
- RemotePrimaryShardFound.class);
+ RemotePrimaryShardFound primaryFound = kit.expectMsgClass(Duration.ofSeconds(5), RemotePrimaryShardFound.class);
assertTrue("Unexpected primary path " + primaryFound.getPrimaryPath(),
primaryFound.getPrimaryPath().contains("member-2-shard-default"));
assertEquals("getPrimaryVersion", leaderVersion, primaryFound.getPrimaryVersion());
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NotInitializedException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NotInitializedException.class);
}
@Test
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NoShardLeaderException.class);
}
@Test
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NoShardLeaderException.class);
DataTree mockDataTree = mock(DataTree.class);
shardManager.tell(new ShardLeaderStateChanged(memberId, memberId, mockDataTree,
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, false), kit.getRef());
- LocalPrimaryShardFound primaryFound = kit.expectMsgClass(kit.duration("5 seconds"),
+ LocalPrimaryShardFound primaryFound = kit.expectMsgClass(Duration.ofSeconds(5),
LocalPrimaryShardFound.class);
assertTrue("Unexpected primary path " + primaryFound.getPrimaryPath(),
primaryFound.getPrimaryPath().contains("member-1-shard-default"));
// RoleChangeNotification.
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, true), kit.getRef());
- kit.expectNoMessage(FiniteDuration.create(150, TimeUnit.MILLISECONDS));
+ kit.expectNoMessage(Duration.ofMillis(150));
shardManager.tell(new ActorInitialized(), mockShardActor);
- kit.expectNoMessage(FiniteDuration.create(150, TimeUnit.MILLISECONDS));
+ kit.expectNoMessage(Duration.ofMillis(150));
String memberId = "member-1-shard-default-" + shardMrgIDSuffix;
shardManager.tell(
new RoleChangeNotification(memberId, RaftState.Candidate.name(), RaftState.Leader.name()),
mockShardActor);
- kit.expectNoMessage(FiniteDuration.create(150, TimeUnit.MILLISECONDS));
+ kit.expectNoMessage(Duration.ofMillis(150));
DataTree mockDataTree = mock(DataTree.class);
shardManager.tell(new ShardLeaderStateChanged(memberId, memberId, mockDataTree,
DataStoreVersions.CURRENT_VERSION), mockShardActor);
- LocalPrimaryShardFound primaryFound = kit.expectMsgClass(kit.duration("5 seconds"),
- LocalPrimaryShardFound.class);
+ LocalPrimaryShardFound primaryFound = kit.expectMsgClass(Duration.ofSeconds(5), LocalPrimaryShardFound.class);
assertTrue("Unexpected primary path " + primaryFound.getPrimaryPath(),
primaryFound.getPrimaryPath().contains("member-1-shard-default"));
assertSame("getLocalShardDataTree", mockDataTree, primaryFound.getLocalShardDataTree());
- kit.expectNoMessage(FiniteDuration.create(200, TimeUnit.MILLISECONDS));
+ kit.expectNoMessage(Duration.ofMillis(200));
LOG.info("testOnReceiveFindPrimaryWaitForShardLeader ending");
}
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, true), kit.getRef());
- kit.expectMsgClass(kit.duration("2 seconds"), NotInitializedException.class);
+ kit.expectMsgClass(Duration.ofSeconds(2), NotInitializedException.class);
shardManager.tell(new ActorInitialized(), mockShardActor);
- kit.expectNoMessage(FiniteDuration.create(200, TimeUnit.MILLISECONDS));
+ kit.expectNoMessage(Duration.ofMillis(200));
LOG.info("testOnReceiveFindPrimaryWaitForReadyWithUninitializedShard ending");
}
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, true), kit.getRef());
- kit.expectMsgClass(kit.duration("2 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(2), NoShardLeaderException.class);
LOG.info("testOnReceiveFindPrimaryWaitForReadyWithCandidateShard ending");
}
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, true),kit. getRef());
- kit.expectMsgClass(kit.duration("2 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(2), NoShardLeaderException.class);
LOG.info("testOnReceiveFindPrimaryWaitForReadyWithIsolatedLeaderShard ending");
}
shardManager.tell(new FindPrimary(Shard.DEFAULT_NAME, true), kit.getRef());
- kit.expectMsgClass(kit.duration("2 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(2), NoShardLeaderException.class);
LOG.info("testOnReceiveFindPrimaryWaitForReadyWithNoRoleShard ending");
}
shardManager1.underlyingActor().waitForMemberUp();
shardManager1.tell(new FindPrimary("astronauts", false), kit.getRef());
- RemotePrimaryShardFound found = kit.expectMsgClass(kit.duration("5 seconds"), RemotePrimaryShardFound.class);
+ RemotePrimaryShardFound found = kit.expectMsgClass(Duration.ofSeconds(5), RemotePrimaryShardFound.class);
String path = found.getPrimaryPath();
assertTrue("Unexpected primary path " + path, path.contains("member-2-shard-astronauts-config"));
assertEquals("getPrimaryVersion", leaderVersion, found.getPrimaryVersion());
//
// shardManager1.tell(new FindPrimary("astronauts", false), getRef());
//
-// expectMsgClass(duration("5 seconds"), PrimaryNotFoundException.class);
+// expectMsgClass(Duration.ofSeconds(5), PrimaryNotFoundException.class);
LOG.info("testOnReceiveFindPrimaryForRemoteShard ending");
}
shardManager1.tell(new FindPrimary("default", true), kit.getRef());
- RemotePrimaryShardFound found = kit.expectMsgClass(kit.duration("5 seconds"), RemotePrimaryShardFound.class);
+ RemotePrimaryShardFound found = kit.expectMsgClass(Duration.ofSeconds(5), RemotePrimaryShardFound.class);
String path = found.getPrimaryPath();
assertTrue("Unexpected primary path " + path, path.contains("member-2-shard-default-config"));
shardManager1.tell(new FindPrimary("default", true), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NoShardLeaderException.class);
shardManager1.tell(MockClusterWrapper.createReachableMember("member-2", "akka://cluster-test@127.0.0.1:2558"),
kit.getRef());
shardManager1.tell(new FindPrimary("default", true), kit.getRef());
- RemotePrimaryShardFound found1 = kit.expectMsgClass(kit.duration("5 seconds"), RemotePrimaryShardFound.class);
+ RemotePrimaryShardFound found1 = kit.expectMsgClass(Duration.ofSeconds(5), RemotePrimaryShardFound.class);
String path1 = found1.getPrimaryPath();
assertTrue("Unexpected primary path " + path1, path1.contains("member-2-shard-default-config"));
shardManager1.tell(
MockClusterWrapper.createReachableMember("member-2", "akka://cluster-test@127.0.0.1:2558"), kit.getRef());
- RemotePrimaryShardFound found2 = kit.expectMsgClass(kit.duration("5 seconds"), RemotePrimaryShardFound.class);
+ RemotePrimaryShardFound found2 = kit.expectMsgClass(Duration.ofSeconds(5), RemotePrimaryShardFound.class);
String path2 = found2.getPrimaryPath();
assertTrue("Unexpected primary path " + path2, path2.contains("member-2-shard-default-config"));
shardManager1.tell(new FindPrimary("default", true), kit.getRef());
- RemotePrimaryShardFound found = kit.expectMsgClass(kit.duration("5 seconds"), RemotePrimaryShardFound.class);
+ RemotePrimaryShardFound found = kit.expectMsgClass(Duration.ofSeconds(5), RemotePrimaryShardFound.class);
String path = found.getPrimaryPath();
assertTrue("Unexpected primary path " + path, path.contains("member-2-shard-default-config"));
shardManager1.tell(new FindPrimary("default", true), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NoShardLeaderException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NoShardLeaderException.class);
assertNull("Expected primaryShardInfoCache entry removed",
primaryShardInfoCache.getIfPresent("default"));
shardManager1.tell(new FindPrimary("default", true), kit.getRef());
- LocalPrimaryShardFound found1 = kit.expectMsgClass(kit.duration("5 seconds"), LocalPrimaryShardFound.class);
+ LocalPrimaryShardFound found1 = kit.expectMsgClass(Duration.ofSeconds(5), LocalPrimaryShardFound.class);
String path1 = found1.getPrimaryPath();
assertTrue("Unexpected primary path " + path1, path1.contains("member-1-shard-default-config"));
shardManager256.tell(new FindPrimary("default", true), kit256.getRef());
- LocalPrimaryShardFound found = kit256.expectMsgClass(kit256.duration("5 seconds"),
- LocalPrimaryShardFound.class);
+ LocalPrimaryShardFound found = kit256.expectMsgClass(Duration.ofSeconds(5), LocalPrimaryShardFound.class);
String path = found.getPrimaryPath();
assertTrue("Unexpected primary path " + path + " which must on member-256",
path.contains("member-256-shard-default-config"));
// Make sure leader shard on member-256 is still leader and still in the cache.
shardManager256.tell(new FindPrimary("default", true), kit256.getRef());
- found = kit256.expectMsgClass(kit256.duration("5 seconds"), LocalPrimaryShardFound.class);
+ found = kit256.expectMsgClass(Duration.ofSeconds(5), LocalPrimaryShardFound.class);
path = found.getPrimaryPath();
assertTrue("Unexpected primary path " + path + " which must still not on member-256",
path.contains("member-256-shard-default-config"));
shardManager.tell(new FindLocalShard("non-existent", false), kit.getRef());
- LocalShardNotFound notFound = kit.expectMsgClass(kit.duration("5 seconds"), LocalShardNotFound.class);
+ LocalShardNotFound notFound = kit.expectMsgClass(Duration.ofSeconds(5), LocalShardNotFound.class);
assertEquals("getShardName", "non-existent", notFound.getShardName());
}
shardManager.tell(new FindLocalShard(Shard.DEFAULT_NAME, false), kit.getRef());
- LocalShardFound found = kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
+ LocalShardFound found = kit.expectMsgClass(Duration.ofSeconds(5), LocalShardFound.class);
assertTrue("Found path contains " + found.getPath().path().toString(),
found.getPath().path().toString().contains("member-1-shard-default-config"));
shardManager.tell(new FindLocalShard(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NotInitializedException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NotInitializedException.class);
}
@Test
"foo", null, members("member-1", "member-5", "member-6"));
shardManager.tell(new CreateShard(config, shardBuilder, datastoreContext), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), Success.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Success.class);
shardManager.tell(new FindLocalShard("foo", true), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), LocalShardFound.class);
assertFalse("isRecoveryApplicable", shardBuilder.getDatastoreContext().isPersistent());
assertTrue("Epxected ShardPeerAddressResolver", shardBuilder.getDatastoreContext().getShardRaftConfig()
shardManager.tell(new CreateShard(config, shardBuilder, null), kit.getRef());
- Success success = kit.expectMsgClass(kit.duration("5 seconds"), Success.class);
+ Success success = kit.expectMsgClass(Duration.ofSeconds(5), Success.class);
assertNotNull("Success status is null", success.status());
LOG.info("testOnCreateShard ending");
"foo", null, members("member-5", "member-6"));
shardManager.tell(new CreateShard(config, shardBuilder, null), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), Success.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Success.class);
shardManager.tell(new FindLocalShard("foo", true), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), LocalShardFound.class);
assertEquals("peerMembers size", 0, shardBuilder.getPeerAddresses().size());
assertEquals("schemaContext", DisableElectionsRaftPolicy.class.getName(), shardBuilder
"foo", null, members("member-1"));
shardManager.tell(new CreateShard(config, shardBuilder, null), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), Success.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Success.class);
SchemaContext schemaContext = TEST_SCHEMA_CONTEXT;
shardManager.tell(new UpdateSchemaContext(schemaContext), ActorRef.noSender());
shardManager.tell(new FindLocalShard("foo", true), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), LocalShardFound.class);
assertSame("schemaContext", schemaContext, shardBuilder.getSchemaContext());
assertNotNull("schemaContext is null", shardBuilder.getDatastoreContext());
.withDispatcher(Dispatchers.DefaultDispatcherId()));
shardManager.tell(new AddShardReplica("model-inventory"), kit.getRef());
- Status.Failure resp = kit.expectMsgClass(kit.duration("2 seconds"), Status.Failure.class);
+ Status.Failure resp = kit.expectMsgClass(Duration.ofSeconds(2), Status.Failure.class);
assertTrue("Failure obtained", resp.cause() instanceof IllegalArgumentException);
}
AddServer.class);
String addServerId = "member-1-shard-astronauts-" + shardMrgIDSuffix;
assertEquals("AddServer serverId", addServerId, addServerMsg.getNewServerId());
- kit.expectMsgClass(kit.duration("5 seconds"), Status.Success.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Status.Success.class);
InMemorySnapshotStore.waitForSavedSnapshot(shardManagerID, ShardManagerSnapshot.class);
InMemorySnapshotStore.waitForDeletedSnapshot(shardManagerID);
MessageCollectorActor.expectFirstMatching(leaderShardActor, AddServer.class);
- Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Failure.class);
+ Failure resp = kit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
assertEquals("Failure cause", AlreadyExistsException.class, resp.cause().getClass());
shardManager.tell(new FindLocalShard(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), LocalShardFound.class);
// Send message again to verify previous in progress state is
// cleared
shardManager.tell(new AddShardReplica(Shard.DEFAULT_NAME), kit.getRef());
- resp = kit.expectMsgClass(kit.duration("5 seconds"), Failure.class);
+ resp = kit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
assertEquals("Failure cause", AlreadyExistsException.class, resp.cause().getClass());
// Send message again with an AddServer timeout to verify the
datastoreContextBuilder.shardLeaderElectionTimeout(100, TimeUnit.MILLISECONDS).build()), kit.getRef());
leaderShardActor.tell(MockRespondActor.CLEAR_RESPONSE, ActorRef.noSender());
shardManager.tell(new AddShardReplica(Shard.DEFAULT_NAME), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), Failure.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
shardManager.tell(new FindLocalShard(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), LocalShardFound.class);
LOG.info("testAddShardReplicaWithPreExistingReplicaInRemoteShardLeader ending");
}
mockShardActor);
shardManager.tell(new AddShardReplica(Shard.DEFAULT_NAME), kit.getRef());
- Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Failure.class);
+ Failure resp = kit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
assertEquals("Failure cause", AlreadyExistsException.class, resp.cause().getClass());
shardManager.tell(new FindLocalShard(Shard.DEFAULT_NAME, false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), LocalShardFound.class);
LOG.info("testAddShardReplicaWithPreExistingLocalReplicaLeader ending");
}
addServerMsg.getNewServerId());
mockShardLeaderKit.reply(new AddServerReply(ServerChangeStatus.TIMEOUT, null));
- Failure failure = kit.expectMsgClass(kit.duration("5 seconds"), Failure.class);
+ Failure failure = kit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
assertEquals("Failure cause", TimeoutException.class, failure.cause().getClass());
shardManager.tell(new FindLocalShard("astronauts", false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), LocalShardNotFound.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), LocalShardNotFound.class);
terminateWatcher.expectTerminated(mockNewReplicaShardActor);
shardManager.tell(new AddShardReplica("astronauts"), kit.getRef());
mockShardLeaderKit.expectMsgClass(AddServer.class);
mockShardLeaderKit.reply(new AddServerReply(ServerChangeStatus.NO_LEADER, null));
- failure = kit.expectMsgClass(kit.duration("5 seconds"), Failure.class);
+ failure = kit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
assertEquals("Failure cause", NoShardLeaderException.class, failure.cause().getClass());
LOG.info("testAddShardReplicaWithAddServerReplyFailure ending");
AddressFromURIString.parse("akka://non-existent@127.0.0.1:5").toString());
newReplicaShardManager.tell(new AddShardReplica("astronauts"), kit.getRef());
- Status.Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Status.Failure.class);
+ Status.Failure resp = kit.expectMsgClass(Duration.ofSeconds(5), Status.Failure.class);
assertTrue("Failure obtained", resp.cause() instanceof RuntimeException);
LOG.info("testAddShardReplicaWithFindPrimaryTimeout ending");
.withDispatcher(Dispatchers.DefaultDispatcherId()));
shardManager.tell(new RemoveShardReplica("model-inventory", MEMBER_1), kit.getRef());
- Status.Failure resp = kit.expectMsgClass(kit.duration("10 seconds"), Status.Failure.class);
+ Status.Failure resp = kit.expectMsgClass(Duration.ofSeconds(10), Status.Failure.class);
assertTrue("Failure obtained", resp.cause() instanceof PrimaryNotFoundException);
}
RemoveServer.class);
assertEquals(ShardIdentifier.create("default", MEMBER_1, shardMrgIDSuffix).toString(),
removeServer.getServerId());
- kit.expectMsgClass(kit.duration("5 seconds"), Success.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Success.class);
}
@Test
RemoveServer.class);
String removeServerId = ShardIdentifier.create("default", MEMBER_1, shardMrgIDSuffix).toString();
assertEquals("RemoveServer serverId", removeServerId, removeServer.getServerId());
- kit.expectMsgClass(kit.duration("5 seconds"), Status.Success.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Status.Success.class);
}
@Test
shardManager.tell(secondServerChange, secondRequestKit.getRef());
- secondRequestKit.expectMsgClass(secondRequestKit.duration("5 seconds"), Failure.class);
+ secondRequestKit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
}
@Test
shardManager.underlyingActor().waitForRecoveryComplete();
shardManager.tell(new FindLocalShard("people", false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NotInitializedException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NotInitializedException.class);
shardManager.tell(new FindLocalShard("default", false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NotInitializedException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NotInitializedException.class);
// Removed the default shard replica from member-1
ShardIdentifier.Builder builder = new ShardIdentifier.Builder();
newRestoredShardManager.underlyingActor().waitForRecoveryComplete();
newRestoredShardManager.tell(new FindLocalShard("people", false), kit.getRef());
- LocalShardNotFound notFound = kit.expectMsgClass(kit.duration("5 seconds"), LocalShardNotFound.class);
+ LocalShardNotFound notFound = kit.expectMsgClass(Duration.ofSeconds(5), LocalShardNotFound.class);
assertEquals("for uninitialized shard", "people", notFound.getShardName());
// Verify a local shard is created for the restored shards,
// as the actor initialization
// message is not sent for them
newRestoredShardManager.tell(new FindLocalShard("default", false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NotInitializedException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NotInitializedException.class);
newRestoredShardManager.tell(new FindLocalShard("astronauts", false), kit.getRef());
- kit.expectMsgClass(kit.duration("5 seconds"), NotInitializedException.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), NotInitializedException.class);
LOG.info("testShardPersistenceWithRestoredData ending");
}
.create("default", MemberName.forName("member-2"), shardMrgIDSuffix).toString(),
Boolean.TRUE));
- kit.expectMsgClass(kit.duration("5 seconds"), Success.class);
+ kit.expectMsgClass(Duration.ofSeconds(5), Success.class);
}
@Test
MessageCollectorActor.expectFirstMatching(respondActor, ChangeServersVotingStatus.class);
- Status.Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Status.Failure.class);
+ Status.Failure resp = kit.expectMsgClass(Duration.ofSeconds(5), Status.Failure.class);
assertTrue("Failure resposnse", resp.cause() instanceof NoShardLeaderException);
}
final Consumer<String> mockCallback = mock(Consumer.class);
shardManager.tell(new RegisterForShardAvailabilityChanges(mockCallback), kit.getRef());
- final Success reply = kit.expectMsgClass(Duration.apply(5, TimeUnit.SECONDS), Success.class);
+ final Success reply = kit.expectMsgClass(Duration.ofSeconds(5), Success.class);
final Registration reg = (Registration) reply.status();
final DataTree mockDataTree = mock(DataTree.class);
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.typesafe.config.ConfigFactory;
+import java.time.Duration;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.slf4j.LoggerFactory;
import scala.concurrent.Await;
import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
public class ActorContextTest extends AbstractActorTest {
@Test
public void testFindLocalShardWithShardFound() {
final TestKit testKit = new TestKit(getSystem());
- testKit.within(testKit.duration("1 seconds"), () -> {
+ testKit.within(Duration.ofSeconds(1), () -> {
ActorRef shardActorRef = getSystem().actorOf(Props.create(EchoActor.class));
ActorRef shardManagerActorRef = getSystem().actorOf(MockShardManager.props(true, shardActorRef));
Future<Object> future = actorContext.executeOperationAsync(actor, "hello");
- Object result = Await.result(future, Duration.create(3, TimeUnit.SECONDS));
+ Object result = Await.result(future, FiniteDuration.create(3, TimeUnit.SECONDS));
assertEquals("Result", "hello", result);
}
actorContext.setDatastoreContext(mockContextFactory);
- testKit.expectMsgClass(testKit.duration("5 seconds"), DatastoreContextFactory.class);
+ testKit.expectMsgClass(Duration.ofSeconds(5), DatastoreContextFactory.class);
Assert.assertSame("getDatastoreContext", newContext, actorContext.getDatastoreContext());
};
Future<PrimaryShardInfo> foobar = actorContext.findPrimaryShardAsync("foobar");
- PrimaryShardInfo actual = Await.result(foobar, Duration.apply(5000, TimeUnit.MILLISECONDS));
+ PrimaryShardInfo actual = Await.result(foobar, FiniteDuration.apply(5000, TimeUnit.MILLISECONDS));
assertNotNull(actual);
assertFalse("LocalShardDataTree present", actual.getLocalShardDataTree().isPresent());
};
Future<PrimaryShardInfo> foobar = actorContext.findPrimaryShardAsync("foobar");
- PrimaryShardInfo actual = Await.result(foobar, Duration.apply(5000, TimeUnit.MILLISECONDS));
+ PrimaryShardInfo actual = Await.result(foobar, FiniteDuration.apply(5000, TimeUnit.MILLISECONDS));
assertNotNull(actual);
assertTrue("LocalShardDataTree present", actual.getLocalShardDataTree().isPresent());
Future<PrimaryShardInfo> foobar = actorContext.findPrimaryShardAsync("foobar");
try {
- Await.result(foobar, Duration.apply(100, TimeUnit.MILLISECONDS));
+ Await.result(foobar, FiniteDuration.apply(100, TimeUnit.MILLISECONDS));
fail("Expected" + expectedException.getClass().toString());
} catch (Exception e) {
if (!expectedException.getClass().isInstance(e)) {
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
import akka.actor.Status.Failure;
+import java.time.Duration;
import org.junit.Test;
import org.opendaylight.controller.remote.rpc.messages.ExecuteRpc;
import org.opendaylight.controller.remote.rpc.messages.RpcResponse;
rpcInvoker1.tell(executeMsg, rpcRegistry1Probe.getRef());
- final RpcResponse rpcResponse = rpcRegistry1Probe.expectMsgClass(rpcRegistry1Probe.duration("5 seconds"),
- RpcResponse.class);
+ final RpcResponse rpcResponse = rpcRegistry1Probe.expectMsgClass(Duration.ofSeconds(5), RpcResponse.class);
assertEquals(rpcResult.getResult(), rpcResponse.getResultNormalizedNode());
}
rpcInvoker1.tell(executeMsg, rpcRegistry1Probe.getRef());
- final Failure rpcResponse = rpcRegistry1Probe.expectMsgClass(rpcRegistry1Probe.duration("5 seconds"),
- Failure.class);
+ final Failure rpcResponse = rpcRegistry1Probe.expectMsgClass(Duration.ofSeconds(5), Failure.class);
assertTrue(rpcResponse.cause() instanceof DOMRpcException);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.remote.rpc.registry;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.opendaylight.controller.remote.rpc.registry.gossip.BucketStoreAccess.Singletons.GET_ALL_BUCKETS;
import static org.opendaylight.controller.remote.rpc.registry.gossip.BucketStoreAccess.Singletons.GET_BUCKET_VERSIONS;
import com.google.common.util.concurrent.Uninterruptibles;
import com.typesafe.config.ConfigFactory;
import java.net.URI;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
import org.junit.After;
import org.junit.AfterClass;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import scala.concurrent.duration.Duration;
-import scala.concurrent.duration.FiniteDuration;
public class RpcRegistryTest {
private static final Logger LOG = LoggerFactory.getLogger(RpcRegistryTest.class);
verifyBucket(buckets.get(nodeAddress), addedRouteIds);
Map<Address, Long> versions = retrieveVersions(registry1, testKit);
- Assert.assertEquals("Version for bucket " + nodeAddress, (Long) buckets.get(nodeAddress).getVersion(),
+ assertEquals("Version for bucket " + nodeAddress, (Long) buckets.get(nodeAddress).getVersion(),
versions.get(nodeAddress));
// Now remove rpc
List<DOMRpcIdentifier> addedRouteIds1 = createRouteIds();
registry1.tell(new AddOrUpdateRoutes(addedRouteIds1), ActorRef.noSender());
- final UpdateRemoteEndpoints req1 = registrar3.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
+ final UpdateRemoteEndpoints req1 = registrar3.expectMsgClass(Duration.ofSeconds(3),
UpdateRemoteEndpoints.class);
// Add rpc on node 2
List<DOMRpcIdentifier> addedRouteIds2 = createRouteIds();
registry2.tell(new AddOrUpdateRoutes(addedRouteIds2), ActorRef.noSender());
- final UpdateRemoteEndpoints req2 = registrar3.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
+ final UpdateRemoteEndpoints req2 = registrar3.expectMsgClass(Duration.ofSeconds(3),
UpdateRemoteEndpoints.class);
Address node2Address = node2.provider().getDefaultAddress();
Address node1Address = node1.provider().getDefaultAddress();
verifyBucket(buckets.get(node2Address), addedRouteIds2);
Map<Address, Long> versions = retrieveVersions(registry3, testKit);
- Assert.assertEquals("Version for bucket " + node1Address, (Long) buckets.get(node1Address).getVersion(),
+ assertEquals("Version for bucket " + node1Address, (Long) buckets.get(node1Address).getVersion(),
versions.get(node1Address));
- Assert.assertEquals("Version for bucket " + node2Address, (Long) buckets.get(node2Address).getVersion(),
+ assertEquals("Version for bucket " + node2Address, (Long) buckets.get(node2Address).getVersion(),
versions.get(node2Address));
assertEndpoints(req1, node1Address, invoker1);
private static void assertEndpoints(final UpdateRemoteEndpoints msg, final Address address, final TestKit invoker) {
final Map<Address, Optional<RemoteRpcEndpoint>> endpoints = msg.getEndpoints();
- Assert.assertEquals(1, endpoints.size());
+ assertEquals(1, endpoints.size());
final Optional<RemoteRpcEndpoint> maybeEndpoint = endpoints.get(address);
- Assert.assertNotNull(maybeEndpoint);
- Assert.assertTrue(maybeEndpoint.isPresent());
+ assertNotNull(maybeEndpoint);
+ assertTrue(maybeEndpoint.isPresent());
final RemoteRpcEndpoint endpoint = maybeEndpoint.get();
final ActorRef router = endpoint.getRouter();
- Assert.assertNotNull(router);
+ assertNotNull(router);
router.tell("hello", ActorRef.noSender());
- final String s = invoker.expectMsgClass(Duration.create(3, TimeUnit.SECONDS), String.class);
- Assert.assertEquals("hello", s);
+ final String s = invoker.expectMsgClass(Duration.ofSeconds(3), String.class);
+ assertEquals("hello", s);
}
private static Map<Address, Long> retrieveVersions(final ActorRef bucketStore, final TestKit testKit) {
bucketStore.tell(GET_BUCKET_VERSIONS, testKit.getRef());
@SuppressWarnings("unchecked")
- final Map<Address, Long> reply = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS), Map.class);
+ final Map<Address, Long> reply = testKit.expectMsgClass(Duration.ofSeconds(3), Map.class);
return reply;
}
private static void verifyBucket(final Bucket<RoutingTable> bucket, final List<DOMRpcIdentifier> expRouteIds) {
RoutingTable table = bucket.getData();
- Assert.assertNotNull("Bucket RoutingTable is null", table);
+ assertNotNull("Bucket RoutingTable is null", table);
for (DOMRpcIdentifier r : expRouteIds) {
if (!table.contains(r)) {
- Assert.fail("RoutingTable does not contain " + r + ". Actual: " + table);
+ fail("RoutingTable does not contain " + r + ". Actual: " + table);
}
}
- Assert.assertEquals("RoutingTable size", expRouteIds.size(), table.size());
+ assertEquals("RoutingTable size", expRouteIds.size(), table.size());
}
private static Map<Address, Bucket<RoutingTable>> retrieveBuckets(final ActorRef bucketStore,
while (true) {
bucketStore.tell(GET_ALL_BUCKETS, testKit.getRef());
@SuppressWarnings("unchecked")
- Map<Address, Bucket<RoutingTable>> buckets = testKit.expectMsgClass(Duration.create(3, TimeUnit.SECONDS),
- Map.class);
+ Map<Address, Bucket<RoutingTable>> buckets = testKit.expectMsgClass(Duration.ofSeconds(3), Map.class);
boolean foundAll = true;
for (Address addr : addresses) {
}
if (++numTries >= 50) {
- Assert.fail("Missing expected buckets for addresses: " + Arrays.toString(addresses)
- + ", Actual: " + buckets);
+ fail("Missing expected buckets for addresses: " + Arrays.toString(addresses) + ", Actual: " + buckets);
}
Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
ActorRef.noSender());
}
- FiniteDuration duration = Duration.create(3, TimeUnit.SECONDS);
int numTries = 0;
while (true) {
registry1.tell(GET_ALL_BUCKETS, testKit.getRef());
@SuppressWarnings("unchecked")
- Map<Address, Bucket<RoutingTable>> buckets = testKit.expectMsgClass(duration, Map.class);
+ Map<Address, Bucket<RoutingTable>> buckets = testKit.expectMsgClass(Duration.ofSeconds(3), Map.class);
Bucket<RoutingTable> localBucket = buckets.values().iterator().next();
RoutingTable table = localBucket.getData();
if (table != null && table.size() == nRoutes) {
for (DOMRpcIdentifier r : added) {
- Assert.assertTrue("RoutingTable contains " + r, table.contains(r));
+ assertTrue("RoutingTable contains " + r, table.contains(r));
}
break;
}
if (++numTries >= 50) {
- Assert.fail("Expected # routes: " + nRoutes + ", Actual: " + table.size());
+ fail("Expected # routes: " + nRoutes + ", Actual: " + table.size());
}
Uninterruptibles.sleepUninterruptibly(200, TimeUnit.MILLISECONDS);
Code Review / controller.git / commitdiff