package org.opendaylight.controller.cluster.datastore;
import static akka.pattern.Patterns.ask;
-import akka.actor.ActorPath;
import akka.actor.ActorRef;
import akka.actor.Address;
import akka.actor.Cancellable;
}
private void onShutDown() {
- Shutdown shutdown = new Shutdown();
List<Future<Boolean>> stopFutures = new ArrayList<>(localShards.size());
for (ShardInformation info : localShards.values()) {
if (info.getActor() != null) {
LOG.debug("{}: Issuing gracefulStop to shard {}", persistenceId(), info.getShardId());
FiniteDuration duration = info.getDatastoreContext().getShardRaftConfig().getElectionTimeOutInterval().$times(2);
- stopFutures.add(Patterns.gracefulStop(info.getActor(), duration, shutdown));
+ stopFutures.add(Patterns.gracefulStop(info.getActor(), duration, Shutdown.INSTANCE));
}
}
private void onWrappedShardResponse(WrappedShardResponse message) {
if (message.getResponse() instanceof RemoveServerReply) {
- onRemoveServerReply(getSender(), message.getShardName(), (RemoveServerReply) message.getResponse());
+ onRemoveServerReply(getSender(), message.getShardId(), (RemoveServerReply) message.getResponse(),
+ message.getLeaderPath());
}
}
- private void onRemoveServerReply(ActorRef originalSender, String shardName, RemoveServerReply response) {
- shardReplicaOperationsInProgress.remove(shardName);
- originalSender.tell(new Status.Success(null), self());
+ private void onRemoveServerReply(ActorRef originalSender, ShardIdentifier shardId, RemoveServerReply replyMsg,
+ String leaderPath) {
+ shardReplicaOperationsInProgress.remove(shardId);
+
+ LOG.debug ("{}: Received {} for shard {}", persistenceId(), replyMsg, shardId.getShardName());
+
+ if (replyMsg.getStatus() == ServerChangeStatus.OK) {
+ LOG.debug ("{}: Leader shard successfully removed the replica shard {}", persistenceId(),
+ shardId.getShardName());
+ originalSender.tell(new akka.actor.Status.Success(null), getSelf());
+ } else {
+ LOG.warn ("{}: Leader failed to remove shard replica {} with status {}",
+ persistenceId(), shardId, replyMsg.getStatus());
+
+ Exception failure = getServerChangeException(RemoveServer.class, replyMsg.getStatus(),
+ leaderPath, shardId);
+ originalSender.tell(new akka.actor.Status.Failure(failure), getSelf());
+ }
}
private void onPrimaryShardFoundContext(PrimaryShardFoundForContext primaryShardFoundContext) {
sender.tell(new Status.Failure(new RuntimeException(msg, failure)), self());
} else {
// SUCCESS
- self().tell(new WrappedShardResponse(shardName, response), sender);
+ self().tell(new WrappedShardResponse(shardId, response, primaryPath), sender);
}
}
}, new Dispatchers(context().system().dispatchers()).getDispatcher(Dispatchers.DispatcherType.Client));
LOG.debug("{} : Shard replica {} is not present in list", persistenceId(), shardId.toString());
return;
} else if(shardInformation.getActor() != null) {
- LOG.debug("{} : Sending PoisonPill to Shard actor {}", persistenceId(), shardInformation.getActor());
- shardInformation.getActor().tell(PoisonPill.getInstance(), self());
+ LOG.debug("{} : Sending Shutdown to Shard actor {}", persistenceId(), shardInformation.getActor());
+ shardInformation.getActor().tell(Shutdown.INSTANCE, self());
}
LOG.debug("{} : Local Shard replica for shard {} has been removed", persistenceId(), shardId.getShardName());
persistShardList();
}
private void memberRemoved(ClusterEvent.MemberRemoved message) {
- String memberName = message.member().roles().head();
+ String memberName = message.member().roles().iterator().next();
LOG.debug("{}: Received MemberRemoved: memberName: {}, address: {}", persistenceId(), memberName,
message.member().address());
}
private void memberExited(ClusterEvent.MemberExited message) {
- String memberName = message.member().roles().head();
+ String memberName = message.member().roles().iterator().next();
LOG.debug("{}: Received MemberExited: memberName: {}, address: {}", persistenceId(), memberName,
message.member().address());
}
private void memberUp(ClusterEvent.MemberUp message) {
- String memberName = message.member().roles().head();
+ String memberName = message.member().roles().iterator().next();
LOG.debug("{}: Received MemberUp: memberName: {}, address: {}", persistenceId(), memberName,
message.member().address());
}
private void memberReachable(ClusterEvent.ReachableMember message) {
- String memberName = message.member().roles().head();
+ String memberName = message.member().roles().iterator().next();
LOG.debug("Received ReachableMember: memberName {}, address: {}", memberName, message.member().address());
addPeerAddress(memberName, message.member().address());
}
private void memberUnreachable(ClusterEvent.UnreachableMember message) {
- String memberName = message.member().roles().head();
+ String memberName = message.member().roles().iterator().next();
LOG.debug("Received UnreachableMember: memberName {}, address: {}", memberName, message.member().address());
markMemberUnavailable(memberName);
if(shardInformation != null && shardInformation.getActor() != null) {
shardInformation.getActor().tell(
- new SwitchBehavior(RaftState.valueOf(message.getNewState()), message.getTerm()), getSelf());
+ new SwitchBehavior(message.getNewState(), message.getTerm()), getSelf());
} else {
LOG.warn("Could not switch the behavior of shard {} to {} - shard is not yet available",
message.getShardName(), message.getNewState());
continue;
}
- LOG.debug("{}: findPrimary for {} forwarding to remote ShardManager {}", persistenceId(),
- shardName, address);
+ LOG.debug("{}: findPrimary for {} forwarding to remote ShardManager {}, visitedAddresses: {}",
+ persistenceId(), shardName, address, visitedAddresses);
getContext().actorSelection(address).forward(new RemoteFindPrimary(shardName,
message.isWaitUntilReady(), visitedAddresses), getContext());
}
}
- private Exception getServerChangeException(Class<?> serverChange, ServerChangeStatus serverChangeStatus,
+ private static Exception getServerChangeException(Class<?> serverChange, ServerChangeStatus serverChangeStatus,
String leaderPath, ShardIdentifier shardId) {
Exception failure;
switch (serverChangeStatus) {
private void onSaveSnapshotSuccess (SaveSnapshotSuccess successMessage) {
LOG.debug ("{} saved ShardManager snapshot successfully. Deleting the prev snapshot if available",
persistenceId());
- deleteSnapshots(new SnapshotSelectionCriteria(scala.Long.MaxValue(), (successMessage.metadata().timestamp() - 1)));
+ deleteSnapshots(new SnapshotSelectionCriteria(scala.Long.MaxValue(), successMessage.metadata().timestamp() - 1,
+ 0, 0));
}
private static class ForwardedAddServerReply {
private final ShardIdentifier shardId;
private final String shardName;
private ActorRef actor;
- private ActorPath actorPath;
private final Map<String, String> initialPeerAddresses;
private Optional<DataTree> localShardDataTree;
private boolean leaderAvailable = false;
return actor;
}
- ActorPath getActorPath() {
- return actorPath;
- }
-
void setActor(ActorRef actor) {
this.actor = actor;
- this.actorPath = actor.path();
}
ShardIdentifier getShardId() {
private CountDownLatch waitTillReadyCountdownLatch;
private PrimaryShardInfoFutureCache primaryShardInfoCache;
private DatastoreSnapshot restoreFromSnapshot;
-
private volatile boolean sealed;
@SuppressWarnings("unchecked")
* The WrappedShardResponse class wraps a response from a Shard.
*/
private static class WrappedShardResponse {
- private final String shardName;
+ private final ShardIdentifier shardId;
private final Object response;
+ private final String leaderPath;
- private WrappedShardResponse(String shardName, Object response) {
- this.shardName = shardName;
+ private WrappedShardResponse(ShardIdentifier shardId, Object response, String leaderPath) {
+ this.shardId = shardId;
this.response = response;
+ this.leaderPath = leaderPath;
}
- String getShardName() {
- return shardName;
+ ShardIdentifier getShardId() {
+ return shardId;
}
Object getResponse() {
return response;
}
+
+ String getLeaderPath() {
+ return leaderPath;
+ }
}
}