/** @param e Error. */
void onError(Throwable e) {
tx.commitError(e);
if (err.compareAndSet(null, e)) {
boolean marked = tx.setRollbackOnly();
if (e instanceof GridCacheTxRollbackException) {
if (marked) {
try {
tx.rollback();
} catch (GridException ex) {
U.error(log, "Failed to automatically rollback transaction: " + tx, ex);
}
}
} else if (tx.implicit()
&& tx.isSystemInvalidate()) { // Finish implicit transaction on heuristic error.
try {
tx.close();
} catch (GridException ex) {
U.error(log, "Failed to invalidate transaction: " + tx, ex);
}
}
onComplete();
}
}
/**
* Processes unlock request.
*
* @param nodeId Sender node ID.
* @param req Unlock request.
*/
@SuppressWarnings({"unchecked"})
private void processUnlockRequest(UUID nodeId, GridDistributedUnlockRequest req) {
assert nodeId != null;
try {
ClassLoader ldr = ctx.deploy().globalLoader();
List<byte[]> keys = req.keyBytes();
for (byte[] keyBytes : keys) {
K key = (K) U.unmarshal(ctx.marshaller(), new ByteArrayInputStream(keyBytes), ldr);
while (true) {
boolean created = false;
GridDistributedCacheEntry<K, V> entry = peekexx(key);
if (entry == null) {
entry = entryexx(key);
created = true;
}
try {
entry.doneRemote(
req.version(), req.version(), req.committedVersions(), req.rolledbackVersions());
// Note that we don't reorder completed versions here,
// as there is no point to reorder relative to the version
// we are about to remove.
if (entry.removeLock(req.version())) {
if (log.isDebugEnabled())
log.debug("Removed lock [lockId=" + req.version() + ", key=" + key + ']');
if (created && entry.markObsolete(req.version())) removeIfObsolete(entry.key());
} else if (log.isDebugEnabled())
log.debug(
"Received unlock request for unknown candidate "
+ "(added to cancelled locks set): "
+ req);
break;
} catch (GridCacheEntryRemovedException ignored) {
if (log.isDebugEnabled())
log.debug(
"Received remove lock request for removed entry (will retry) [entry="
+ entry
+ ", req="
+ req
+ ']');
}
}
}
} catch (GridException e) {
U.error(log, "Failed to unmarshal unlock key (unlock will not be performed): " + req, e);
}
}
/** {@inheritDoc} */
@Override
public void loadCache(GridBiInClosure<K, V> c, @Nullable Object... args) throws GridException {
ExecutorService exec =
new ThreadPoolExecutor(
threadsCnt,
threadsCnt,
0L,
MILLISECONDS,
new ArrayBlockingQueue<Runnable>(batchQueueSize),
new BlockingRejectedExecutionHandler());
Iterator<I> iter = inputIterator(args);
Collection<I> buf = new ArrayList<>(batchSize);
try {
while (iter.hasNext()) {
if (Thread.currentThread().isInterrupted()) {
U.warn(log, "Working thread was interrupted while loading data.");
break;
}
buf.add(iter.next());
if (buf.size() == batchSize) {
exec.submit(new Worker(c, buf, args));
buf = new ArrayList<>(batchSize);
}
}
if (!buf.isEmpty()) exec.submit(new Worker(c, buf, args));
} catch (RejectedExecutionException ignored) {
// Because of custom RejectedExecutionHandler.
assert false : "RejectedExecutionException was thrown while it shouldn't.";
} finally {
exec.shutdown();
try {
exec.awaitTermination(Long.MAX_VALUE, MILLISECONDS);
} catch (InterruptedException ignored) {
U.warn(log, "Working thread was interrupted while waiting for put operations to complete.");
Thread.currentThread().interrupt();
}
}
}
/** @return Nodes to execute on. */
private Collection<GridNode> nodes() {
GridCacheMode cacheMode = cctx.config().getCacheMode();
switch (cacheMode) {
case LOCAL:
if (prj != null)
U.warn(
log,
"Ignoring query projection because it's executed over LOCAL cache "
+ "(only local node will be queried): "
+ this);
return Collections.singletonList(cctx.localNode());
case REPLICATED:
if (prj != null) return nodes(cctx, prj);
GridCacheDistributionMode mode = cctx.config().getDistributionMode();
return mode == PARTITIONED_ONLY || mode == NEAR_PARTITIONED
? Collections.singletonList(cctx.localNode())
: Collections.singletonList(F.rand(nodes(cctx, null)));
case PARTITIONED:
return nodes(cctx, prj);
default:
throw new IllegalStateException("Unknown cache distribution mode: " + cacheMode);
}
}
/** {@inheritDoc} */
@Override
public boolean onDone(GridCacheTx tx, Throwable err) {
if ((initialized() || err != null) && super.onDone(tx, err)) {
if (error() instanceof GridCacheTxHeuristicException) {
long topVer = this.tx.topologyVersion();
for (GridCacheTxEntry<K, V> e : this.tx.writeMap().values()) {
try {
if (e.op() != NOOP && !cctx.affinity().localNode(e.key(), topVer)) {
GridCacheEntryEx<K, V> cacheEntry = cctx.cache().peekEx(e.key());
if (cacheEntry != null) cacheEntry.invalidate(null, this.tx.xidVersion());
}
} catch (Throwable t) {
U.error(log, "Failed to invalidate entry.", t);
if (t instanceof Error) throw (Error) t;
}
}
}
// Don't forget to clean up.
cctx.mvcc().removeFuture(this);
return true;
}
return false;
}
/** Cache write callback. */
public void onWrite() {
writeTime = U.currentTimeMillis();
writes++;
if (delegate != null) delegate.onWrite();
}
/** Transaction rollback callback. */
public void onTxRollback() {
rollbackTime = U.currentTimeMillis();
txRollbacks++;
if (delegate != null) delegate.onTxRollback();
}
/**
* @param nodeId Sender node ID.
* @param msg Response to prepare request.
*/
private void processPrepareResponse(UUID nodeId, GridDistributedTxPrepareResponse<K, V> msg) {
assert nodeId != null;
assert msg != null;
GridReplicatedTxLocal<K, V> tx = ctx.tm().tx(msg.version());
if (tx == null) {
if (log.isDebugEnabled())
log.debug(
"Received prepare response for non-existing transaction [senderNodeId="
+ nodeId
+ ", res="
+ msg
+ ']');
return;
}
GridReplicatedTxPrepareFuture<K, V> future = (GridReplicatedTxPrepareFuture<K, V>) tx.future();
if (future != null) future.onResult(nodeId, msg);
else
U.error(
log,
"Received prepare response for transaction with no future [res="
+ msg
+ ", tx="
+ tx
+ ']');
}
/** Transaction commit callback. */
public void onTxCommit() {
commitTime = U.currentTimeMillis();
txCommits++;
if (delegate != null) delegate.onTxCommit();
}
/** Initializes future. */
@SuppressWarnings({"unchecked"})
void finish() {
if (mappings != null) {
finish(mappings.values());
markInitialized();
if (!isSync()) {
boolean complete = true;
for (GridFuture<?> f : pending())
// Mini-future in non-sync mode gets done when message gets sent.
if (isMini(f) && !f.isDone()) complete = false;
if (complete) onComplete();
}
} else {
assert !commit;
try {
tx.rollback();
} catch (GridException e) {
U.error(log, "Failed to rollback empty transaction: " + tx, e);
}
markInitialized();
}
}
/** {@inheritDoc} */
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
topVer = in.readLong();
implicitTx = in.readBoolean();
implicitSingleTx = in.readBoolean();
syncCommit = in.readBoolean();
syncRollback = in.readBoolean();
filterBytes = (byte[][]) in.readObject();
dhtVers = U.readArray(in, CU.versionArrayFactory());
miniId = U.readGridUuid(in);
assert miniId != null;
}
/** {@inheritDoc} */
@Override
public void writeExternal(ObjectOutput out) throws IOException {
super.writeExternal(out);
out.writeLong(topVer);
out.writeBoolean(implicitTx);
out.writeBoolean(implicitSingleTx);
out.writeBoolean(syncCommit);
out.writeBoolean(syncRollback);
out.writeObject(filterBytes);
U.writeArray(out, dhtVers);
assert miniId != null;
U.writeGridUuid(out, miniId);
}
/**
* @param nodeId Sender node ID.
* @param msg Finish transaction response.
*/
private void processFinishResponse(UUID nodeId, GridDistributedTxFinishResponse<K, V> msg) {
GridReplicatedTxCommitFuture<K, V> fut =
(GridReplicatedTxCommitFuture<K, V>)
ctx.mvcc().<GridCacheTx>future(msg.xid().id(), msg.futureId());
if (fut != null) fut.onResult(nodeId);
else U.warn(log, "Received finish response for unknown transaction: " + msg);
}
/**
* Reconstructs object on demarshalling.
*
* @return Reconstructed object.
* @throws ObjectStreamException Thrown in case of demarshalling error.
*/
private Object readResolve() throws ObjectStreamException {
GridTuple2<GridCacheContext, String> t = stash.get();
try {
return t.get1().dataStructures().sequence(t.get2(), 0L, false, false);
} catch (GridException e) {
throw U.withCause(new InvalidObjectException(e.getMessage()), e);
}
}
/**
* @param nodeId Sender.
* @param res Result.
*/
void onResult(UUID nodeId, GridNearLockResponse<K, V> res) {
if (!isDone()) {
if (log.isDebugEnabled())
log.debug(
"Received lock response from node [nodeId="
+ nodeId
+ ", res="
+ res
+ ", fut="
+ this
+ ']');
for (GridFuture<Boolean> fut : pending()) {
if (isMini(fut)) {
MiniFuture mini = (MiniFuture) fut;
if (mini.futureId().equals(res.miniId())) {
assert mini.node().id().equals(nodeId);
if (log.isDebugEnabled())
log.debug("Found mini future for response [mini=" + mini + ", res=" + res + ']');
mini.onResult(res);
if (log.isDebugEnabled())
log.debug(
"Future after processed lock response [fut="
+ this
+ ", mini="
+ mini
+ ", res="
+ res
+ ']');
return;
}
}
}
U.warn(
log,
"Failed to find mini future for response (perhaps due to stale message) [res="
+ res
+ ", fut="
+ this
+ ']');
} else if (log.isDebugEnabled())
log.debug(
"Ignoring lock response from node (future is done) [nodeId="
+ nodeId
+ ", res="
+ res
+ ", fut="
+ this
+ ']');
}
/**
* Removes locks regardless of whether they are owned or not for given version and keys.
*
* @param ver Lock version.
* @param keys Keys.
*/
@SuppressWarnings({"unchecked"})
public void removeLocks(GridCacheVersion ver, Collection<? extends K> keys) {
if (keys.isEmpty()) return;
Collection<GridRichNode> nodes = ctx.remoteNodes(keys);
try {
// Send request to remove from remote nodes.
GridDistributedUnlockRequest<K, V> req = new GridDistributedUnlockRequest<K, V>(keys.size());
req.version(ver);
for (K key : keys) {
while (true) {
GridDistributedCacheEntry<K, V> entry = peekexx(key);
try {
if (entry != null) {
GridCacheMvccCandidate<K> cand = entry.candidate(ver);
if (cand != null) {
// Remove candidate from local node first.
if (entry.removeLock(cand.version())) {
// If there is only local node in this lock's topology,
// then there is no reason to distribute the request.
if (nodes.isEmpty()) continue;
req.addKey(entry.key(), entry.getOrMarshalKeyBytes(), ctx);
}
}
}
break;
} catch (GridCacheEntryRemovedException ignored) {
if (log.isDebugEnabled())
log.debug(
"Attempted to remove lock from removed entry (will retry) [rmvVer="
+ ver
+ ", entry="
+ entry
+ ']');
}
}
}
if (nodes.isEmpty()) return;
req.completedVersions(ctx.tm().committedVersions(ver), ctx.tm().rolledbackVersions(ver));
if (!req.keyBytes().isEmpty())
// We don't wait for reply to this message.
ctx.io().safeSend(nodes, req, null);
} catch (GridException ex) {
U.error(log, "Failed to unlock the lock for keys: " + keys, ex);
}
}
/**
* Cache read callback.
*
* @param isHit Hit or miss flag.
*/
public void onRead(boolean isHit) {
readTime = U.currentTimeMillis();
reads++;
if (isHit) hits++;
else misses++;
if (delegate != null) delegate.onRead(isHit);
}
/**
* Reconstructs object on demarshalling.
*
* @return Reconstructed object.
* @throws ObjectStreamException Thrown in case of demarshalling error.
*/
@SuppressWarnings({"ConstantConditions"})
private Object readResolve() throws ObjectStreamException {
GridTuple2<GridCacheContext, String> t = stash.get();
try {
return t.get1().dataStructures().countDownLatch(t.get2(), 0, false, false);
} catch (GridException e) {
throw U.withCause(new InvalidObjectException(e.getMessage()), e);
}
}
/** {@inheritDoc} */
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
try {
if (executor.isShutdown()) throw new RejectedExecutionException();
else executor.getQueue().put(r);
} catch (InterruptedException ignored) {
U.warn(log, "Working thread was interrupted while loading data.");
Thread.currentThread().interrupt();
}
}
/**
* Checks entry for empty value.
*
* @param entry Entry to check.
* @return {@code True} if entry is empty.
*/
private boolean empty(GridCacheEntry<K, V> entry) {
try {
return entry.peek(F.asList(GLOBAL)) == null;
} catch (GridException e) {
U.error(null, e.getMessage(), e);
assert false : "Should never happen: " + e;
return false;
}
}
/**
* Reconstructs object on demarshalling.
*
* @return Reconstructed object.
* @throws ObjectStreamException Thrown in case of demarshalling error.
*/
@SuppressWarnings("unchecked")
private Object readResolve() throws ObjectStreamException {
try {
GridBiTuple<GridCacheContext, String> t = stash.get();
return t.get1().dataStructures().atomicReference(t.get2(), null, false);
} catch (GridException e) {
throw U.withCause(new InvalidObjectException(e.getMessage()), e);
} finally {
stash.remove();
}
}
/**
* Flushes every internal buffer if buffer was flushed before passed in threshold.
*
* <p>Does not wait for result and does not fail on errors assuming that this method should be
* called periodically.
*/
@Override
public void tryFlush() throws GridInterruptedException {
if (!busyLock.enterBusy()) return;
try {
for (Buffer buf : bufMappings.values()) buf.flush();
lastFlushTime = U.currentTimeMillis();
} finally {
leaveBusy();
}
}
void cancelAll() {
GridException err =
new GridException("Data loader has been cancelled: " + GridDataLoaderImpl.this);
for (GridFuture<?> f : locFuts) {
try {
f.cancel();
} catch (GridException e) {
U.error(log, "Failed to cancel mini-future.", e);
}
}
for (GridFutureAdapter<?> f : reqs.values()) f.onDone(err);
}
/** {@inheritDoc} */
@Override
public ClassLoader classLoader() {
if (ldr == null) {
ClassLoader ldr0 = deployClass().getClassLoader();
// Safety.
if (ldr0 == null) ldr0 = U.gridClassLoader();
assert ldr0 != null : "Failed to detect classloader [objs=" + objs + ']';
ldr = ldr0;
}
return ldr;
}
/** {@inheritDoc} */
@Override
public Class<?> deployClass() {
if (cls == null) {
Class<?> cls0 = null;
if (depCls != null) cls0 = depCls;
else {
for (Iterator<Object> it = objs.iterator();
(cls0 == null || U.isJdk(cls0)) && it.hasNext(); ) {
Object o = it.next();
if (o != null) cls0 = U.detectClass(o);
}
if (cls0 == null || U.isJdk(cls0)) cls0 = GridDataLoaderImpl.class;
}
assert cls0 != null : "Failed to detect deploy class [objs=" + objs + ']';
cls = cls0;
}
return cls;
}
/**
* @param cctx Context.
* @param tx Transaction.
* @param commit Commit flag.
*/
public GridNearTxFinishFuture(
GridCacheContext<K, V> cctx, GridNearTxLocal<K, V> tx, boolean commit) {
super(cctx.kernalContext(), F.<GridCacheTx>identityReducer(tx));
assert cctx != null;
this.cctx = cctx;
this.tx = tx;
this.commit = commit;
mappings = tx.mappings();
futId = GridUuid.randomUuid();
log = U.logger(ctx, logRef, GridNearTxFinishFuture.class);
}
/**
* Processes lock response.
*
* @param nodeId Sender node ID.
* @param res Lock response.
*/
private void processLockResponse(UUID nodeId, GridDistributedLockResponse<K, V> res) {
GridReplicatedLockFuture<K, V> fut = futurex(res.lockId(), res.futureId());
if (fut == null) {
U.warn(log, "Received lock response for non-existing future (will ignore): " + res);
} else {
fut.onResult(nodeId, res);
if (fut.isDone()) {
ctx.mvcc().removeFuture(fut);
if (log.isDebugEnabled())
log.debug("Received all replies for future (future was removed): " + fut);
}
}
}
/** @param e Error. */
void onResult(Throwable e) {
if (rcvRes.compareAndSet(false, true)) {
if (log.isDebugEnabled())
log.debug("Failed to get future result [fut=" + this + ", err=" + e + ']');
// Fail.
onDone(e);
} else
U.warn(
log,
"Received error after another result has been processed [fut="
+ GridNearLockFuture.this
+ ", mini="
+ this
+ ']',
e);
}
/** {@inheritDoc} */
@Override
public void isolated(boolean isolated) throws GridException {
if (isolated()) return;
GridNode node = F.first(ctx.grid().forCache(cacheName).nodes());
if (node == null) throw new GridException("Failed to get node for cache: " + cacheName);
GridCacheAttributes a = U.cacheAttributes(node, cacheName);
assert a != null;
updater =
a.atomicityMode() == GridCacheAtomicityMode.ATOMIC
? GridDataLoadCacheUpdaters.<K, V>batched()
: GridDataLoadCacheUpdaters.<K, V>groupLocked();
}
/** @param e Error. */
void onError(Throwable e) {
tx.commitError(e);
if (err.compareAndSet(null, e)) {
boolean marked = tx.setRollbackOnly();
if (e instanceof GridCacheTxRollbackException)
if (marked) {
try {
tx.rollback();
} catch (GridException ex) {
U.error(log, "Failed to automatically rollback transaction: " + tx, ex);
}
}
onComplete();
}
}