@Stop(priority = 20)
@Override
public void stop() {
if (trace) {
log.tracef(
"Shutting down StateConsumer of cache %s on node %s", cacheName, rpcManager.getAddress());
}
try {
synchronized (this) {
// cancel all inbound transfers
taskQueue.clear();
for (Iterator<List<InboundTransferTask>> it = transfersBySource.values().iterator();
it.hasNext(); ) {
List<InboundTransferTask> inboundTransfers = it.next();
it.remove();
for (InboundTransferTask inboundTransfer : inboundTransfers) {
inboundTransfer.cancel();
}
}
transfersBySource.clear();
transfersBySegment.clear();
}
} catch (Throwable t) {
log.errorf(
t,
"Failed to stop StateConsumer of cache %s on node %s",
cacheName,
rpcManager.getAddress());
}
}
public void cleanupCompletedTransactions() {
if (!completedTransactions.isEmpty()) {
try {
log.tracef(
"About to cleanup completed transaction. Initial size is %d",
completedTransactions.size());
// this iterator is weekly consistent and will never throw ConcurrentModificationException
Iterator<Map.Entry<GlobalTransaction, Long>> iterator =
completedTransactions.entrySet().iterator();
long timeout = configuration.transaction().completedTxTimeout();
int removedEntries = 0;
long beginning = timeService.time();
while (iterator.hasNext()) {
Map.Entry<GlobalTransaction, Long> e = iterator.next();
long ageMillis = timeService.timeDuration(e.getValue(), TimeUnit.MILLISECONDS);
if (ageMillis >= timeout) {
iterator.remove();
removedEntries++;
}
}
long duration = timeService.timeDuration(beginning, TimeUnit.MILLISECONDS);
log.tracef(
"Finished cleaning up completed transactions. %d transactions were removed, total duration was %d millis, "
+ "current number of completed transactions is %d",
removedEntries, duration, completedTransactions.size());
} catch (Exception e) {
log.errorf(e, "Failed to cleanup completed transactions: %s", e.getMessage());
}
}
}
@Override
public void afterInvocation(IInvokedMethod method, ITestResult testResult) {
if (!method.isTestMethod()) return;
if (testResult.getThrowable() != null)
log.errorf(
testResult.getThrowable(), "Method %s threw an exception", getTestDesc(testResult));
}
private void doApplyState(
Address sender, int segmentId, Collection<InternalCacheEntry> cacheEntries) {
log.debugf(
"Applying new state for segment %d of cache %s from node %s: received %d cache entries",
segmentId, cacheName, sender, cacheEntries.size());
if (trace) {
List<Object> keys = new ArrayList<Object>(cacheEntries.size());
for (InternalCacheEntry e : cacheEntries) {
keys.add(e.getKey());
}
log.tracef(
"Received keys %s for segment %d of cache %s from node %s",
keys, segmentId, cacheName, sender);
}
// CACHE_MODE_LOCAL avoids handling by StateTransferInterceptor and any potential locks in
// StateTransferLock
EnumSet<Flag> flags =
EnumSet.of(
PUT_FOR_STATE_TRANSFER,
CACHE_MODE_LOCAL,
IGNORE_RETURN_VALUES,
SKIP_REMOTE_LOOKUP,
SKIP_SHARED_CACHE_STORE,
SKIP_OWNERSHIP_CHECK,
SKIP_XSITE_BACKUP);
for (InternalCacheEntry e : cacheEntries) {
try {
InvocationContext ctx;
if (transactionManager != null) {
// cache is transactional
transactionManager.begin();
Transaction transaction = transactionManager.getTransaction();
ctx = icc.createInvocationContext(transaction);
((TxInvocationContext) ctx).setImplicitTransaction(true);
} else {
// non-tx cache
ctx = icc.createSingleKeyNonTxInvocationContext();
}
PutKeyValueCommand put =
useVersionedPut
? commandsFactory.buildVersionedPutKeyValueCommand(
e.getKey(),
e.getValue(),
e.getLifespan(),
e.getMaxIdle(),
e.getVersion(),
flags)
: commandsFactory.buildPutKeyValueCommand(
e.getKey(), e.getValue(), e.getLifespan(), e.getMaxIdle(), flags);
boolean success = false;
try {
interceptorChain.invoke(ctx, put);
success = true;
} finally {
if (ctx.isInTxScope()) {
if (success) {
((LocalTransaction) ((TxInvocationContext) ctx).getCacheTransaction())
.setFromStateTransfer(true);
try {
transactionManager.commit();
} catch (Throwable ex) {
log.errorf(
ex,
"Could not commit transaction created by state transfer of key %s",
e.getKey());
if (transactionManager.getTransaction() != null) {
transactionManager.rollback();
}
}
} else {
transactionManager.rollback();
}
}
}
} catch (Exception ex) {
log.problemApplyingStateForKey(ex.getMessage(), e.getKey(), ex);
}
}
log.debugf("Finished applying state for segment %d of cache %s", segmentId, cacheName);
}