/** {@inheritDoc} */
@SuppressWarnings("TypeMayBeWeakened")
@Nullable
private Collection<Object> unmarshalFieldsCollection(
@Nullable Collection<byte[]> byteCol, GridCacheContext<K, V> ctx, ClassLoader ldr)
throws GridException {
assert ctx != null;
assert ldr != null;
Collection<Object> col = unmarshalCollection(byteCol, ctx, ldr);
Collection<Object> col0 = null;
if (col != null) {
col0 = new ArrayList<>(col.size());
for (Object o : col) {
List<Object> list = (List<Object>) o;
List<Object> list0 = new ArrayList<>(list.size());
for (Object obj : list)
list0.add(obj != null ? ctx.marshaller().unmarshal((byte[]) obj, ldr) : null);
col0.add(list0);
}
}
return col0;
}
/**
* @return Collection of readers after check.
* @throws GridCacheEntryRemovedException If removed.
*/
public Collection<ReaderId> checkReaders() throws GridCacheEntryRemovedException {
synchronized (mux) {
checkObsolete();
if (!readers.isEmpty()) {
List<ReaderId> rmv = null;
for (ReaderId reader : readers) {
if (!cctx.discovery().alive(reader.nodeId())) {
if (rmv == null) rmv = new LinkedList<ReaderId>();
rmv.add(reader);
}
}
if (rmv != null) {
readers = new LinkedList<ReaderId>(readers);
for (ReaderId rdr : rmv) readers.remove(rdr);
readers = Collections.unmodifiableList(readers);
}
}
return readers;
}
}
/** {@inheritDoc} */
@SuppressWarnings("TypeMayBeWeakened")
@Nullable
private Collection<byte[]> marshalFieldsCollection(
@Nullable Collection<Object> col, GridCacheContext<K, V> ctx) throws GridException {
assert ctx != null;
if (col == null) return null;
Collection<List<Object>> col0 = new ArrayList<>(col.size());
for (Object o : col) {
List<GridIndexingEntity<?>> list = (List<GridIndexingEntity<?>>) o;
List<Object> list0 = new ArrayList<>(list.size());
for (GridIndexingEntity<?> ent : list) {
if (ent.bytes() != null) list0.add(ent.bytes());
else {
if (ctx.deploymentEnabled()) prepareObject(ent.value(), ctx);
list0.add(CU.marshal(ctx, ent.value()));
}
}
col0.add(list0);
}
return marshalCollection(col0, ctx);
}
/**
* Adds a Near key.
*
* @param key Key.
* @param keyBytes Key bytes.
* @param ctx Context.
* @throws GridException If failed.
*/
public void addNearKey(K key, byte[] keyBytes, GridCacheContext<K, V> ctx) throws GridException {
if (ctx.deploymentEnabled()) prepareObject(key, ctx);
if (nearKeyBytes == null) nearKeyBytes = new ArrayList<>();
nearKeyBytes.add(keyBytes);
}
/** {@inheritDoc} */
@Override
protected boolean hasReaders() throws GridCacheEntryRemovedException {
synchronized (mux) {
checkReaders();
return !readers.isEmpty();
}
}
/** {@inheritDoc} */
@SuppressWarnings("all")
@Override
public boolean writeTo(ByteBuffer buf) {
commState.setBuffer(buf);
if (!super.writeTo(buf)) return false;
if (!commState.typeWritten) {
if (!commState.putByte(directType())) return false;
commState.typeWritten = true;
}
switch (commState.idx) {
case 8:
if (nearKeyBytes != null) {
if (commState.it == null) {
if (!commState.putInt(nearKeyBytes.size())) return false;
commState.it = nearKeyBytes.iterator();
}
while (commState.it.hasNext() || commState.cur != NULL) {
if (commState.cur == NULL) commState.cur = commState.it.next();
if (!commState.putByteArray((byte[]) commState.cur)) return false;
commState.cur = NULL;
}
commState.it = null;
} else {
if (!commState.putInt(-1)) return false;
}
commState.idx++;
}
return true;
}
/**
* @param nodeId Reader to remove.
* @param msgId Message ID.
* @return {@code True} if reader was removed as a result of this operation.
* @throws GridCacheEntryRemovedException If entry was removed.
*/
public boolean removeReader(UUID nodeId, long msgId) throws GridCacheEntryRemovedException {
synchronized (mux) {
checkObsolete();
ReaderId reader = readerId(nodeId);
if (reader == null || reader.messageId() > msgId) return false;
readers = new LinkedList<ReaderId>(readers);
readers.remove(reader);
// Seal.
readers = Collections.unmodifiableList(readers);
return true;
}
}
/** {@inheritDoc} */
@SuppressWarnings("all")
@Override
public boolean readFrom(ByteBuffer buf) {
commState.setBuffer(buf);
if (!super.readFrom(buf)) return false;
switch (commState.idx) {
case 8:
if (commState.readSize == -1) {
if (buf.remaining() < 4) return false;
commState.readSize = commState.getInt();
}
if (commState.readSize >= 0) {
if (nearKeyBytes == null) nearKeyBytes = new ArrayList<>(commState.readSize);
for (int i = commState.readItems; i < commState.readSize; i++) {
byte[] _val = commState.getByteArray();
if (_val == BYTE_ARR_NOT_READ) return false;
nearKeyBytes.add((byte[]) _val);
commState.readItems++;
}
}
commState.readSize = -1;
commState.readItems = 0;
commState.idx++;
}
return true;
}
/**
* @param nodeId Primary node ID.
* @param req Request.
* @return Remote transaction.
* @throws GridException If failed.
* @throws GridDistributedLockCancelledException If lock has been cancelled.
*/
@SuppressWarnings({"RedundantTypeArguments"})
@Nullable
public GridNearTxRemote<K, V> startRemoteTx(UUID nodeId, GridDhtLockRequest<K, V> req)
throws GridException, GridDistributedLockCancelledException {
List<byte[]> nearKeyBytes = req.nearKeyBytes();
GridNearTxRemote<K, V> tx = null;
ClassLoader ldr = ctx.deploy().globalLoader();
if (ldr != null) {
for (int i = 0; i < nearKeyBytes.size(); i++) {
byte[] bytes = nearKeyBytes.get(i);
if (bytes == null) continue;
K key = req.nearKeys().get(i);
Collection<GridCacheMvccCandidate<K>> cands = req.candidatesByIndex(i);
if (log.isDebugEnabled()) log.debug("Unmarshalled key: " + key);
GridNearCacheEntry<K, V> entry = null;
while (true) {
try {
entry = peekExx(key);
if (entry != null) {
entry.keyBytes(bytes);
// Handle implicit locks for pessimistic transactions.
if (req.inTx()) {
tx = ctx.tm().tx(req.version());
if (tx != null) tx.addWrite(key, bytes, null /*Value.*/, null /*Value bytes.*/);
else {
tx =
new GridNearTxRemote<K, V>(
nodeId,
req.nearNodeId(),
req.threadId(),
req.version(),
null,
PESSIMISTIC,
req.isolation(),
req.isInvalidate(),
req.timeout(),
key,
bytes,
null, // Value.
null, // Value bytes.
ctx);
if (tx.empty()) return tx;
tx = ctx.tm().onCreated(tx);
if (tx == null || !ctx.tm().onStarted(tx))
throw new GridCacheTxRollbackException(
"Failed to acquire lock "
+ "(transaction has been completed): "
+ req.version());
}
}
// Add remote candidate before reordering.
entry.addRemote(
req.nodeId(),
nodeId,
req.threadId(),
req.version(),
req.timeout(),
tx != null && tx.ec(),
tx != null,
tx != null && tx.implicitSingle());
// Remote candidates for ordered lock queuing.
entry.addRemoteCandidates(
cands, req.version(), req.committedVersions(), req.rolledbackVersions());
entry.orderOwned(req.version(), req.owned(entry.key()));
}
// Double-check in case if sender node left the grid.
if (ctx.discovery().node(req.nodeId()) == null) {
if (log.isDebugEnabled())
log.debug("Node requesting lock left grid (lock request will be ignored): " + req);
if (tx != null) tx.rollback();
return null;
}
// Entry is legit.
break;
} catch (GridCacheEntryRemovedException ignored) {
assert entry.obsoleteVersion() != null
: "Obsolete flag not set on removed entry: " + entry;
if (log.isDebugEnabled())
log.debug("Received entry removed exception (will retry on renewed entry): " + entry);
if (tx != null) {
tx.clearEntry(entry.key());
if (log.isDebugEnabled())
log.debug(
"Cleared removed entry from remote transaction (will retry) [entry="
+ entry
+ ", tx="
+ tx
+ ']');
}
}
}
}
} else {
String err = "Failed to acquire deployment class loader for message: " + req;
U.warn(log, err);
throw new GridException(err);
}
return tx;
}
/**
* Performs flush.
*
* @throws GridException If failed.
*/
private void doFlush() throws GridException {
lastFlushTime = U.currentTimeMillis();
List<GridFuture> activeFuts0 = null;
int doneCnt = 0;
for (GridFuture<?> f : activeFuts) {
if (!f.isDone()) {
if (activeFuts0 == null) activeFuts0 = new ArrayList<>((int) (activeFuts.size() * 1.2));
activeFuts0.add(f);
} else {
f.get();
doneCnt++;
}
}
if (activeFuts0 == null || activeFuts0.isEmpty()) return;
while (true) {
Queue<GridFuture<?>> q = null;
for (Buffer buf : bufMappings.values()) {
GridFuture<?> flushFut = buf.flush();
if (flushFut != null) {
if (q == null) q = new ArrayDeque<>(bufMappings.size() * 2);
q.add(flushFut);
}
}
if (q != null) {
assert !q.isEmpty();
boolean err = false;
for (GridFuture fut = q.poll(); fut != null; fut = q.poll()) {
try {
fut.get();
} catch (GridException e) {
if (log.isDebugEnabled()) log.debug("Failed to flush buffer: " + e);
err = true;
}
}
if (err)
// Remaps needed - flush buffers.
continue;
}
doneCnt = 0;
for (int i = 0; i < activeFuts0.size(); i++) {
GridFuture f = activeFuts0.get(i);
if (f == null) doneCnt++;
else if (f.isDone()) {
f.get();
doneCnt++;
activeFuts0.set(i, null);
} else break;
}
if (doneCnt == activeFuts0.size()) return;
}
}
/**
* Processes lock request.
*
* @param nodeId Sender node ID.
* @param msg Lock request.
*/
@SuppressWarnings({"unchecked", "ThrowableInstanceNeverThrown"})
private void processLockRequest(UUID nodeId, GridDistributedLockRequest<K, V> msg) {
assert !nodeId.equals(locNodeId);
List<byte[]> keys = msg.keyBytes();
int cnt = keys.size();
GridReplicatedTxRemote<K, V> tx = null;
GridDistributedLockResponse res;
ClassLoader ldr = null;
try {
ldr = ctx.deploy().globalLoader();
if (ldr != null) {
res = new GridDistributedLockResponse(msg.version(), msg.futureId(), cnt);
for (int i = 0; i < keys.size(); i++) {
byte[] bytes = keys.get(i);
K key = msg.keys().get(i);
Collection<GridCacheMvccCandidate<K>> cands = msg.candidatesByIndex(i);
if (bytes == null) continue;
if (log.isDebugEnabled()) log.debug("Unmarshalled key: " + key);
GridDistributedCacheEntry<K, V> entry = null;
while (true) {
try {
entry = entryexx(key);
// Handle implicit locks for pessimistic transactions.
if (msg.inTx()) {
tx = ctx.tm().tx(msg.version());
if (tx != null) {
if (msg.txRead()) tx.addRead(key, bytes);
else tx.addWrite(key, bytes);
} else {
tx =
new GridReplicatedTxRemote<K, V>(
nodeId,
msg.threadId(),
msg.version(),
null,
PESSIMISTIC,
msg.isolation(),
msg.isInvalidate(),
msg.timeout(),
key,
bytes,
msg.txRead(),
ctx);
tx = ctx.tm().onCreated(tx);
if (tx == null || !ctx.tm().onStarted(tx))
throw new GridCacheTxRollbackException(
"Failed to acquire lock "
+ "(transaction has been completed): "
+ msg.version());
}
}
// Add remote candidate before reordering.
entry.addRemote(
msg.nodeId(),
null,
msg.threadId(),
msg.version(),
msg.timeout(),
tx != null && tx.ec(),
tx != null,
tx != null && tx.implicitSingle());
// Remote candidates for ordered lock queuing.
entry.addRemoteCandidates(
cands, msg.version(), msg.committedVersions(), msg.rolledbackVersions());
// Double-check in case if sender node left the grid.
if (ctx.discovery().node(msg.nodeId()) == null) {
if (log.isDebugEnabled())
log.debug(
"Node requesting lock left grid (lock request will be ignored): " + msg);
if (tx != null) tx.rollback();
return;
}
res.setCandidates(
i,
entry.localCandidates(),
ctx.tm().committedVersions(msg.version()),
ctx.tm().rolledbackVersions(msg.version()));
res.addValueBytes(
entry.rawGet(), msg.returnValue(i) ? entry.valueBytes(null) : null, ctx);
// Entry is legit.
break;
} catch (GridCacheEntryRemovedException ignored) {
assert entry.obsoleteVersion() != null
: "Obsolete flag not set on removed entry: " + entry;
if (log.isDebugEnabled())
log.debug(
"Received entry removed exception (will retry on renewed entry): " + entry);
if (tx != null) {
tx.clearEntry(entry.key());
if (log.isDebugEnabled())
log.debug(
"Cleared removed entry from remote transaction (will retry) [entry="
+ entry
+ ", tx="
+ tx
+ ']');
}
}
}
}
} else {
String err = "Failed to acquire deployment class for message: " + msg;
U.warn(log, err);
res =
new GridDistributedLockResponse(msg.version(), msg.futureId(), new GridException(err));
}
} catch (GridCacheTxRollbackException e) {
if (log.isDebugEnabled())
log.debug("Received lock request for completed transaction (will ignore): " + e);
res = new GridDistributedLockResponse(msg.version(), msg.futureId(), e);
} catch (GridException e) {
String err = "Failed to unmarshal at least one of the keys for lock request message: " + msg;
log.error(err, e);
res =
new GridDistributedLockResponse(msg.version(), msg.futureId(), new GridException(err, e));
if (tx != null) tx.rollback();
} catch (GridDistributedLockCancelledException ignored) {
// Received lock request for cancelled lock.
if (log.isDebugEnabled())
log.debug("Received lock request for canceled lock (will ignore): " + msg);
if (tx != null) tx.rollback();
// Don't send response back.
return;
}
GridNode node = ctx.discovery().node(msg.nodeId());
boolean releaseAll = false;
if (node != null) {
try {
// Reply back to sender.
ctx.io().send(node, res);
} catch (GridException e) {
U.error(log, "Failed to send message to node (did the node leave grid?): " + node.id(), e);
releaseAll = ldr != null;
}
}
// If sender left grid, release all locks acquired so far.
else releaseAll = ldr != null;
// Release all locks because sender node left grid.
if (releaseAll) {
for (K key : msg.keys()) {
while (true) {
GridDistributedCacheEntry<K, V> entry = peekexx(key);
try {
if (entry != null) entry.removeExplicitNodeLocks(msg.nodeId());
break;
} catch (GridCacheEntryRemovedException ignore) {
if (log.isDebugEnabled())
log.debug(
"Attempted to remove lock on removed entity during failure "
+ "of replicated lock request handling (will retry): "
+ entry);
}
}
}
U.warn(
log, "Sender node left grid in the midst of lock acquisition (locks will be released).");
}
}
/**
* Adds a Near key.
*
* @param key Key.
* @param keyBytes Key bytes.
* @param ctx Context.
* @throws GridException If failed.
*/
public void addNearKey(K key, byte[] keyBytes, GridCacheContext<K, V> ctx) throws GridException {
prepareObject(key, ctx);
nearKeyBytes.add(keyBytes);
}
/**
* @param nodeId Reader to add.
* @param msgId Message ID.
* @return Future for all relevant transactions that were active at the time of adding reader, or
* {@code null} if reader was added
* @throws GridCacheEntryRemovedException If entry was removed.
*/
@Nullable
public GridFuture<Boolean> addReader(UUID nodeId, long msgId)
throws GridCacheEntryRemovedException {
// Don't add local node as reader.
if (cctx.nodeId().equals(nodeId)) return null;
GridNode node = cctx.discovery().node(nodeId);
// If remote node has no near cache, don't add it.
if (node == null || !U.hasNearCache(node, cctx.dht().near().name())) return null;
// If remote node is (primary?) or back up, don't add it as a reader.
if (U.nodeIds(cctx.affinity(partition(), CU.allNodes(cctx))).contains(nodeId)) return null;
boolean ret = false;
GridCacheMultiTxFuture<K, V> txFut;
Collection<GridCacheMvccCandidate<K>> cands = null;
synchronized (mux) {
checkObsolete();
txFut = this.txFut;
ReaderId reader = readerId(nodeId);
if (reader == null) {
reader = new ReaderId(nodeId, msgId);
readers = new LinkedList<ReaderId>(readers);
readers.add(reader);
// Seal.
readers = Collections.unmodifiableList(readers);
txFut = this.txFut = new GridCacheMultiTxFuture<K, V>(cctx);
cands = localCandidates();
ret = true;
} else {
long id = reader.messageId();
if (id < msgId) reader.messageId(msgId);
}
}
if (ret) {
assert txFut != null;
if (!F.isEmpty(cands)) {
for (GridCacheMvccCandidate<K> c : cands) {
GridCacheTxEx<K, V> tx = cctx.tm().<GridCacheTxEx<K, V>>tx(c.version());
if (tx != null) {
assert tx.local();
txFut.addTx(tx);
}
}
}
txFut.init();
if (!txFut.isDone()) {
txFut.listenAsync(
new CI1<GridFuture<?>>() {
@Override
public void apply(GridFuture<?> f) {
synchronized (mux) {
// Release memory.
GridDhtCacheEntry.this.txFut = null;
}
}
});
} else
// Release memory.
txFut = this.txFut = null;
}
return txFut;
}