// notify listeners that a rehash is about to start
notifier.notifyDataRehashed(oldCacheSet, newCacheSet, newViewId, true);
List<Object> keysToRemove = new ArrayList<Object>();
NotifyingNotifiableFuture<Object> stateTransferFuture = new AggregatingNotifyingFutureImpl(null, newMembers.size());
int numOwners = configuration.getNumOwners();
// Contains the state to be pushed to various servers. The state is a hashmap of keys and values
final Map<Address, Map<Object, InternalCacheValue>> states = new HashMap<Address, Map<Object, InternalCacheValue>>();
for (InternalCacheEntry ice : dataContainer) {
rebalance(ice.getKey(), ice, numOwners, chOld, chNew, null, states, keysToRemove);
}
// Only fetch the data from the cache store if the cache store is not shared
CacheStore cacheStore = distributionManager.getCacheStoreForRehashing();
if (cacheStore != null) {
for (Object key : cacheStore.loadAllKeys(new ReadOnlyDataContainerBackedKeySet(dataContainer))) {
rebalance(key, null, numOwners, chOld, chNew, cacheStore, states, keysToRemove);
}
} else {
if (trace) log.trace("Shared cache store or fetching of persistent state disabled");
}
// Now for each server S in states.keys(): push states.get(S) to S via RPC
for (Map.Entry<Address, Map<Object, InternalCacheValue>> entry : states.entrySet()) {
final Address target = entry.getKey();
Map<Object, InternalCacheValue> state = entry.getValue();
if (trace)
log.tracef("%s pushing to %s keys %s", self, target, state.keySet());
final RehashControlCommand cmd = cf.buildRehashControlCommand(RehashControlCommand.Type.APPLY_STATE, self,
newViewId, state, chOld, chNew);
rpcManager.invokeRemotelyInFuture(Collections.singleton(target), cmd,
false, stateTransferFuture, configuration.getRehashRpcTimeout());
}
// TODO Allow APPLY_STATE RehashControlCommand to skip transaction blocking, so we can unblock new transactions
// only after we have invalidated the keys removed from this cache
// For transactions TransactionTable should have already rolled back the transactions touching those keys,
// but it still might be a problem for non-transactional writes.
needToUnblockTransactions = false;
distributionManager.getTransactionLogger().unblockNewTransactions();
// wait to see if all servers received the new state
// TODO should we retry the state transfer operation if it failed on some of the nodes?
try {
stateTransferFuture.get();
} catch (ExecutionException e) {
log.errorTransferringState(e);
}
// Notify listeners of completion of rehashing