import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectFirstMatching;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectMatching;
+import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.Props;
-import akka.actor.UntypedActor;
import akka.dispatch.Dispatchers;
import akka.testkit.TestActorRef;
import akka.testkit.javadsl.TestKit;
-import com.google.common.base.Optional;
import com.google.common.base.Stopwatch;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
import com.google.common.io.ByteSource;
+import com.google.common.util.concurrent.MoreExecutors;
import java.io.OutputStream;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang3.SerializationUtils;
import org.junit.After;
}
@After
- public void tearDown() throws Exception {
+ public void tearDown() {
actorFactory.close();
}
@Test
- public void testAddServerWithExistingFollower() throws Exception {
+ public void testAddServerWithExistingFollower() {
LOG.info("testAddServerWithExistingFollower starting");
setupNewFollower();
RaftActorContextImpl followerActorContext = newFollowerContext(FOLLOWER_ID, followerActor);
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());
// Verify new server config was applied in both followers
- assertEquals("Follower peers", Sets.newHashSet(LEADER_ID, NEW_SERVER_ID), followerActorContext.getPeerIds());
+ assertEquals("Follower peers", ImmutableSet.of(LEADER_ID, NEW_SERVER_ID), followerActorContext.getPeerIds());
- assertEquals("New follower peers", Sets.newHashSet(LEADER_ID, FOLLOWER_ID),
+ assertEquals("New follower peers", ImmutableSet.of(LEADER_ID, FOLLOWER_ID),
newFollowerActorContext.getPeerIds());
assertEquals("Follower commit index", 3, followerActorContext.getCommitIndex());
}
@Test
- public void testAddServerWithNoExistingFollower() throws Exception {
+ public void testAddServerWithNoExistingFollower() {
LOG.info("testAddServerWithNoExistingFollower starting");
setupNewFollower();
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());
// Verify new server config was applied in the new follower
- assertEquals("New follower peers", Sets.newHashSet(LEADER_ID), newFollowerActorContext.getPeerIds());
+ assertEquals("New follower peers", ImmutableSet.of(LEADER_ID), newFollowerActorContext.getPeerIds());
LOG.info("testAddServerWithNoExistingFollower ending");
}
@Test
- public void testAddServersAsNonVoting() throws Exception {
+ public void testAddServersAsNonVoting() {
LOG.info("testAddServersAsNonVoting starting");
setupNewFollower();
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());
// Verify new server config was applied in the new follower
- assertEquals("New follower peers", Sets.newHashSet(LEADER_ID), newFollowerActorContext.getPeerIds());
+ assertEquals("New follower peers", ImmutableSet.of(LEADER_ID), newFollowerActorContext.getPeerIds());
assertNoneMatching(newFollowerCollectorActor, InstallSnapshot.class, 500);
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());
+ assertEquals("getLeaderHint", Optional.of(LEADER_ID), addServerReply.getLeaderHint());
expectFirstMatching(leaderCollectorActor, ApplyState.class);
assertEquals("Leader journal last index", 1, leaderActorContext.getReplicatedLog().lastIndex());
}
@Test
- public void testAddServerWithOperationInProgress() throws Exception {
+ public void testAddServerWithOperationInProgress() {
LOG.info("testAddServerWithOperationInProgress starting");
setupNewFollower();
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
// Verify ServerConfigurationPayload entry in the new follower
expectMatching(newFollowerCollectorActor, ApplyState.class, 2);
- assertEquals("New follower peers", Sets.newHashSet(LEADER_ID, NEW_SERVER_ID2),
+ assertEquals("New follower peers", ImmutableSet.of(LEADER_ID, NEW_SERVER_ID2),
newFollowerActorContext.getPeerIds());
LOG.info("testAddServerWithOperationInProgress ending");
}
@Test
- public void testAddServerWithPriorSnapshotInProgress() throws Exception {
+ public void testAddServerWithPriorSnapshotInProgress() {
LOG.info("testAddServerWithPriorSnapshotInProgress starting");
setupNewFollower();
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());
}
@Test
- public void testAddServerWithPriorSnapshotCompleteTimeout() throws Exception {
+ public void testAddServerWithPriorSnapshotCompleteTimeout() {
LOG.info("testAddServerWithPriorSnapshotCompleteTimeout starting");
setupNewFollower();
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());
}
@Test
- public void testAddServerWithLeaderChangeBeforePriorSnapshotComplete() throws Exception {
+ public void testAddServerWithLeaderChangeBeforePriorSnapshotComplete() {
LOG.info("testAddServerWithLeaderChangeBeforePriorSnapshotComplete starting");
setupNewFollower();
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());
}
@Test
- public void testAddServerWithLeaderChangeDuringInstallSnapshot() throws Exception {
+ public void testAddServerWithLeaderChangeDuringInstallSnapshot() {
LOG.info("testAddServerWithLeaderChangeDuringInstallSnapshot starting");
setupNewFollower();
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());
}
@Test
- public void testAddServerWithInstallSnapshotTimeout() throws Exception {
+ public void testAddServerWithInstallSnapshotTimeout() {
LOG.info("testAddServerWithInstallSnapshotTimeout starting");
setupNewFollower();
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");
}
@Test
- public void testRemoveServer() throws Exception {
+ public void testRemoveServer() {
LOG.info("testRemoveServer starting");
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
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)),
- Sets.newHashSet(node1RaftActor.getRaftActorContext().getPeerServerInfo(true).getServerConfig()));
+ assertEquals("Server config", ImmutableSet.of(nonVotingServer(node1ID), votingServer(node2ID)),
+ new HashSet<>(node1RaftActor.getRaftActorContext().getPeerServerInfo(true).getServerConfig()));
assertEquals("getRaftState", RaftState.Follower, node1RaftActor.getRaftState());
LOG.info("testChangeToVotingWithNoLeaderAndElectionTimeout ending");
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);
LOG.info("testChangeToVotingWithNoLeaderAndOtherLeaderElected ending");
}
- private static void verifyRaftState(RaftState expState, RaftActor... raftActors) {
+ private static void verifyRaftState(final RaftState expState, final RaftActor... raftActors) {
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.SECONDS) <= 5) {
for (RaftActor raftActor : raftActors) {
fail("None of the RaftActors have state " + expState);
}
- private static ServerInfo votingServer(String id) {
+ private static ServerInfo votingServer(final String id) {
return new ServerInfo(id, true);
}
- private static ServerInfo nonVotingServer(String id) {
+ private static ServerInfo nonVotingServer(final String id) {
return new ServerInfo(id, false);
}
- private ActorRef newLeaderCollectorActor(MockLeaderRaftActor leaderRaftActor) {
+ private ActorRef newLeaderCollectorActor(final MockLeaderRaftActor leaderRaftActor) {
return newCollectorActor(leaderRaftActor, LEADER_ID);
}
- private ActorRef newCollectorActor(AbstractMockRaftActor raftActor, String id) {
+ private ActorRef newCollectorActor(final AbstractMockRaftActor raftActor, final String id) {
ActorRef collectorActor = actorFactory.createTestActor(
MessageCollectorActor.props(), actorFactory.generateActorId(id + "Collector"));
raftActor.setCollectorActor(collectorActor);
return collectorActor;
}
- private static void verifyServerConfigurationPayloadEntry(ReplicatedLog log, ServerInfo... expected) {
+ private static void verifyServerConfigurationPayloadEntry(final ReplicatedLog log, final ServerInfo... expected) {
ReplicatedLogEntry logEntry = log.get(log.lastIndex());
assertEquals("Last log entry payload class", ServerConfigurationPayload.class, logEntry.getData().getClass());
ServerConfigurationPayload payload = (ServerConfigurationPayload)logEntry.getData();
- assertEquals("Server config", Sets.newHashSet(expected), Sets.newHashSet(payload.getServerConfig()));
+ assertEquals("Server config", ImmutableSet.copyOf(expected), new HashSet<>(payload.getServerConfig()));
}
- private static RaftActorContextImpl newFollowerContext(String id, TestActorRef<? extends UntypedActor> actor) {
+ private static RaftActorContextImpl newFollowerContext(final String id,
+ final TestActorRef<? extends AbstractActor> actor) {
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
configParams.setElectionTimeoutFactor(100000);
termInfo.update(1, LEADER_ID);
return new RaftActorContextImpl(actor, actor.underlyingActor().getContext(),
id, termInfo, -1, -1, ImmutableMap.of(LEADER_ID, ""), configParams,
- noPersistence, applyState -> actor.tell(applyState, actor), LOG);
+ noPersistence, applyState -> actor.tell(applyState, actor), LOG, MoreExecutors.directExecutor());
}
abstract static class AbstractMockRaftActor extends MockRaftActor {
private volatile ActorRef collectorActor;
private volatile Class<?> dropMessageOfType;
- AbstractMockRaftActor(String id, Map<String, String> peerAddresses, Optional<ConfigParams> config,
- boolean persistent, ActorRef collectorActor) {
+ AbstractMockRaftActor(final String id, final Map<String, String> peerAddresses,
+ final Optional<ConfigParams> config, final boolean persistent, final ActorRef collectorActor) {
super(builder().id(id).peerAddresses(peerAddresses).config(config.get())
.persistent(Optional.of(persistent)));
this.collectorActor = collectorActor;
}
- void setDropMessageOfType(Class<?> dropMessageOfType) {
+ void setDropMessageOfType(final Class<?> dropMessageOfType) {
this.dropMessageOfType = dropMessageOfType;
}
- void setCollectorActor(ActorRef collectorActor) {
+ void setCollectorActor(final ActorRef collectorActor) {
this.collectorActor = collectorActor;
}
@Override
- public void handleCommand(Object message) {
+ public void handleCommand(final Object message) {
if (dropMessageOfType == null || !dropMessageOfType.equals(message.getClass())) {
super.handleCommand(message);
}
public static class CollectingMockRaftActor extends AbstractMockRaftActor {
- CollectingMockRaftActor(String id, Map<String, String> peerAddresses, Optional<ConfigParams> config,
- boolean persistent, ActorRef collectorActor) {
+ CollectingMockRaftActor(final String id, final Map<String, String> peerAddresses,
+ final Optional<ConfigParams> config, final boolean persistent, final ActorRef collectorActor) {
super(id, peerAddresses, config, persistent, collectorActor);
snapshotCohortDelegate = new RaftActorSnapshotCohort() {
@Override
- public void createSnapshot(ActorRef actorRef, java.util.Optional<OutputStream> installSnapshotStream) {
+ public void createSnapshot(final ActorRef actorRef,
+ final Optional<OutputStream> installSnapshotStream) {
actorRef.tell(new CaptureSnapshotReply(ByteState.empty(), installSnapshotStream), actorRef);
}
@Override
public void applySnapshot(
- org.opendaylight.controller.cluster.raft.persisted.Snapshot.State snapshotState) {
+ final org.opendaylight.controller.cluster.raft.persisted.Snapshot.State snapshotState) {
}
@Override
public org.opendaylight.controller.cluster.raft.persisted.Snapshot.State deserializeSnapshot(
- ByteSource snapshotBytes) {
+ final ByteSource snapshotBytes) {
throw new UnsupportedOperationException();
}
};
}
public static Props props(final String id, final Map<String, String> peerAddresses,
- ConfigParams config, boolean persistent, ActorRef collectorActor) {
+ final ConfigParams config, final boolean persistent, final ActorRef collectorActor) {
return Props.create(CollectingMockRaftActor.class, id, peerAddresses, Optional.of(config),
persistent, collectorActor);
}
public static class MockLeaderRaftActor extends AbstractMockRaftActor {
- public MockLeaderRaftActor(Map<String, String> peerAddresses, ConfigParams config,
- RaftActorContext fromContext) {
+ public MockLeaderRaftActor(final Map<String, String> peerAddresses, final ConfigParams config,
+ final RaftActorContext fromContext) {
super(LEADER_ID, peerAddresses, Optional.of(config), NO_PERSISTENCE, null);
setPersistence(false);
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public void createSnapshot(ActorRef actorRef, java.util.Optional<OutputStream> installSnapshotStream) {
+ public void createSnapshot(final ActorRef actorRef, final Optional<OutputStream> installSnapshotStream) {
MockSnapshotState snapshotState = new MockSnapshotState(new ArrayList<>(getState()));
if (installSnapshotStream.isPresent()) {
SerializationUtils.serialize(snapshotState, installSnapshotStream.get());
actorRef.tell(new CaptureSnapshotReply(snapshotState, installSnapshotStream), actorRef);
}
- static Props props(Map<String, String> peerAddresses, RaftActorContext fromContext) {
+ static Props props(final Map<String, String> peerAddresses, final RaftActorContext fromContext) {
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
configParams.setElectionTimeoutFactor(10);
}
public static class MockNewFollowerRaftActor extends AbstractMockRaftActor {
- public MockNewFollowerRaftActor(ConfigParams config, ActorRef collectorActor) {
- super(NEW_SERVER_ID, Maps.<String, String>newHashMap(), Optional.of(config), NO_PERSISTENCE,
- collectorActor);
+ public MockNewFollowerRaftActor(final ConfigParams config, final ActorRef collectorActor) {
+ super(NEW_SERVER_ID, new HashMap<>(), Optional.of(config), NO_PERSISTENCE, collectorActor);
setPersistence(false);
}
- static Props props(ConfigParams config, ActorRef collectorActor) {
+ static Props props(final ConfigParams config, final ActorRef collectorActor) {
return Props.create(MockNewFollowerRaftActor.class, config, collectorActor);
}
}
Code Review / controller.git / blobdiff