/**
* Sets remote candidate to done.
*
* @param ver Version.
* @param pending Pending versions.
* @param committed Committed versions.
* @param rolledback Rolledback versions.
* @return Lock owner.
*/
@Nullable
public CacheLockCandidates doneRemote(
GridCacheVersion ver,
Collection<GridCacheVersion> pending,
Collection<GridCacheVersion> committed,
Collection<GridCacheVersion> rolledback) {
assert ver != null;
if (log.isDebugEnabled())
log.debug("Setting remote candidate to done [mvcc=" + this + ", ver=" + ver + "]");
// Check remote candidate.
GridCacheMvccCandidate cand = candidate(rmts, ver);
if (cand != null) {
assert rmts != null;
assert !rmts.isEmpty();
assert !cand.local() : "Remote candidate is marked as local: " + cand;
assert !cand.nearLocal() : "Remote candidate is marked as near local: " + cand;
cand.setOwner();
cand.setUsed();
List<GridCacheMvccCandidate> mvAfter = null;
for (ListIterator<GridCacheMvccCandidate> it = rmts.listIterator(); it.hasNext(); ) {
GridCacheMvccCandidate c = it.next();
assert !c.nearLocal() : "Remote candidate marked as near local: " + c;
if (c == cand) {
if (mvAfter != null) for (GridCacheMvccCandidate mv : mvAfter) it.add(mv);
break;
} else if (!committed.contains(c.version())
&& !rolledback.contains(c.version())
&& pending.contains(c.version())) {
it.remove();
if (mvAfter == null) mvAfter = new LinkedList<>();
mvAfter.add(c);
}
}
}
return allOwners();
}
/**
* For all remote candidates standing behind the candidate being salvaged marks their transactions
* as system invalidate and marks these candidates as owned and used.
*
* @param ver Version to salvage.
*/
public void salvageRemote(GridCacheVersion ver) {
assert ver != null;
GridCacheMvccCandidate cand = candidate(rmts, ver);
if (cand != null) {
assert rmts != null;
assert !rmts.isEmpty();
for (Iterator<GridCacheMvccCandidate> iter = rmts.iterator(); iter.hasNext(); ) {
GridCacheMvccCandidate rmt = iter.next();
// For salvaged candidate doneRemote will be called explicitly.
if (rmt == cand) break;
// Only Near and DHT remote candidates should be released.
assert !rmt.nearLocal();
IgniteInternalTx tx = cctx.tm().tx(rmt.version());
if (tx != null) {
tx.systemInvalidate(true);
rmt.setOwner();
rmt.setUsed();
} else iter.remove();
}
}
}
/** {@inheritDoc} */
@SuppressWarnings({"unchecked"})
@Override
public void onOwnerChanged(
GridCacheEntryEx entry, GridCacheMvccCandidate prev, GridCacheMvccCandidate owner) {
assert entry != null;
assert owner != prev : "New and previous owner are identical instances: " + owner;
assert owner == null || prev == null || !owner.version().equals(prev.version())
: "New and previous owners have identical versions [owner="
+ owner
+ ", prev="
+ prev
+ ']';
if (log.isDebugEnabled())
log.debug(
"Received owner changed callback ["
+ entry.key()
+ ", owner="
+ owner
+ ", prev="
+ prev
+ ']');
if (owner != null && (owner.local() || owner.nearLocal())) {
Collection<? extends GridCacheFuture> futCol = futs.get(owner.version());
if (futCol != null) {
for (GridCacheFuture fut : futCol) {
if (fut instanceof GridCacheMvccFuture && !fut.isDone()) {
GridCacheMvccFuture<Boolean> mvccFut = (GridCacheMvccFuture<Boolean>) fut;
// Since this method is called outside of entry synchronization,
// we can safely invoke any method on the future.
// Also note that we don't remove future here if it is done.
// The removal is initiated from within future itself.
if (mvccFut.onOwnerChanged(entry, owner)) return;
}
}
}
}
if (log.isDebugEnabled())
log.debug(
"Lock future not found for owner change callback (will try transaction futures) [owner="
+ owner
+ ", prev="
+ prev
+ ", entry="
+ entry
+ ']');
// If no future was found, delegate to transaction manager.
if (cctx.tm().onOwnerChanged(entry, owner)) {
if (log.isDebugEnabled()) log.debug("Found transaction for changed owner: " + owner);
} else if (log.isDebugEnabled())
log.debug("Failed to find transaction for changed owner: " + owner);
for (FinishLockFuture f : finishFuts) f.recheck(entry);
}
/** Assigns local lock. */
private void reassign() {
GridCacheMvccCandidate firstRmt = null;
if (rmts != null) {
for (GridCacheMvccCandidate cand : rmts) {
if (firstRmt == null) firstRmt = cand;
// If there is a remote owner, then local cannot be an owner,
// so no reassignment happens.
if (cand.owner()) return;
}
}
if (locs != null) {
boolean first = true;
ListIterator<GridCacheMvccCandidate> it = locs.listIterator();
while (it.hasNext()) {
GridCacheMvccCandidate cand = it.next();
if (first) {
if (cand.read()) {
if (cand.ready() && !cand.owner()) cand.setOwner();
while (it.hasNext()) {
cand = it.next();
if (!cand.read()) break;
if (cand.ready() && !cand.owner()) cand.setOwner();
}
return;
} else if (cand.serializable()) {
if (cand.owner() || !cand.ready()) return;
cand.setOwner();
return;
}
first = false;
}
if (cand.owner()) return;
if (cand.ready()) {
GridCacheMvccCandidate prev = nonRollbackPrevious(cand);
// If previous has not been acquired, this candidate cannot acquire lock either,
// so we move on to the next one.
if (prev != null && !prev.owner()) continue;
boolean assigned = false;
if (!cctx.isNear() && firstRmt != null && cand.version().isGreater(firstRmt.version())) {
// Check previous candidates for 2 cases:
// 1. If this candidate is waiting for a smaller remote version,
// then we must check if previous candidate is the owner and
// has the same remote candidate version. In that case, we can
// safely set this candidate to owner as well.
// 2. If this candidate is waiting for a smaller remote version,
// then we must check if previous candidate is the owner and
// any of the local candidates with versions smaller than first
// remote version have the same key as the previous owner. In
// that case, we can safely set this candidate to owner as well.
while (prev != null && prev.owner()) {
for (GridCacheMvccCandidate c : prev.parent().remoteMvccSnapshot()) {
if (c.version().equals(firstRmt.version())) {
cand.setOwner();
assigned = true;
break; // For.
}
}
if (!assigned) {
for (GridCacheMvccCandidate c : locs) {
if (c == cand || c.version().isGreater(firstRmt.version())) break;
for (GridCacheMvccCandidate p = c.previous(); p != null; p = p.previous()) {
if (p.key().equals(prev.key())) {
cand.setOwner();
assigned = true;
break; // For.
}
}
if (assigned) break; // For.
}
}
if (assigned) break; // While.
prev = prev.previous();
}
}
if (!assigned) {
if (!cctx.isNear() && firstRmt != null) {
if (cand.version().isLess(firstRmt.version())) {
assert !cand.nearLocal();
cand.setOwner();
assigned = true;
}
} else {
cand.setOwner();
assigned = true;
}
}
if (assigned) {
assert !cand.serializable() : cand;
it.remove();
// Owner must be first in the list.
locs.addFirst(cand);
}
return;
}
}
}
}
/**
* Marks near-local candidate as ready and makes locks reassignment. Following reorderings are
* performed when candidate is marked ready:
*
* <ul>
* <li/>All candidates preceding ready one are moved right after it.
* <li/>Near local candidate is assigned a mapped dht version. All remote non-pending candidates
* with version less then mapped dht version are marked as owned.
* </ul>
*
* @param ver Version to mark as ready.
* @param mappedVer Mapped dht version.
* @param committedVers Committed versions.
* @param rolledBackVers Rolled back versions.
* @param pending Pending dht versions that are not owned and which version is less then mapped.
* @return Lock owner after reassignment.
*/
@Nullable
public CacheLockCandidates readyNearLocal(
GridCacheVersion ver,
GridCacheVersion mappedVer,
Collection<GridCacheVersion> committedVers,
Collection<GridCacheVersion> rolledBackVers,
Collection<GridCacheVersion> pending) {
GridCacheMvccCandidate cand = candidate(locs, ver);
if (cand != null) {
assert cand.nearLocal() : "Near local candidate is not marked as near local: " + cand;
cand.setReady();
boolean setMapped = cand.otherVersion(mappedVer);
assert setMapped
: "Failed to set mapped dht version for near local candidate [mappedVer="
+ mappedVer
+ ", cand="
+ cand
+ ']';
// For near locals we move all not owned candidates after this one.
List<GridCacheMvccCandidate> mvAfter = null;
for (ListIterator<GridCacheMvccCandidate> it = locs.listIterator(); it.hasNext(); ) {
GridCacheMvccCandidate c = it.next();
assert c.nearLocal() : "Near local candidate is not marked as near local: " + c;
if (c == cand) {
if (mvAfter != null) for (GridCacheMvccCandidate mv : mvAfter) it.add(mv);
break;
} else {
if (c.owner()) continue;
assert !c.ready() || (c.read() && cand.read())
: "Cannot have more then one ready near-local candidate [c="
+ c
+ ", cand="
+ cand
+ ", mvcc="
+ this
+ ']';
it.remove();
if (mvAfter == null) mvAfter = new LinkedList<>();
mvAfter.add(c);
}
}
// Mark all remote candidates with less version as owner unless it is pending.
if (rmts != null) {
for (GridCacheMvccCandidate rmt : rmts) {
GridCacheVersion rmtVer = rmt.version();
if (rmtVer.isLess(mappedVer)) {
if (!pending.contains(rmtVer) && !mappedVer.equals(rmt.ownerVersion())) rmt.setOwner();
} else {
// Remote version is greater, so need to check if it was committed or rolled back.
if (committedVers.contains(rmtVer) || rolledBackVers.contains(rmtVer)) rmt.setOwner();
}
}
}
reassign();
}
return allOwners();
}
/**
* @param cand Candidate to add.
* @return {@code False} if failed to add candidate and transaction should be cancelled.
*/
private boolean add0(GridCacheMvccCandidate cand) {
assert cand != null;
// Local.
if (cand.local()) {
if (locs == null) locs = new LinkedList<>();
if (!cand.nearLocal()) {
if (!locs.isEmpty()) {
if (cand.serializable()) {
Iterator<GridCacheMvccCandidate> it = locs.descendingIterator();
if (cand.read()) {
while (it.hasNext()) {
GridCacheMvccCandidate c = it.next();
if (!c.serializable()) return false;
if (!c.read()) {
if (compareSerializableVersion(c, cand)) break;
else return false;
}
}
} else {
while (it.hasNext()) {
GridCacheMvccCandidate c = it.next();
if (!c.serializable() || !compareSerializableVersion(c, cand)) return false;
if (!c.read()) break;
}
}
locs.addLast(cand);
return true;
}
GridCacheMvccCandidate first = locs.getFirst();
if (first.owner()) {
// If reentry, add at the beginning. Note that
// no reentry happens for DHT-local candidates.
if (!cand.dhtLocal() && first.threadId() == cand.threadId()) {
assert !first.serializable();
cand.setOwner();
cand.setReady();
cand.setReentry();
locs.addFirst(cand);
return true;
}
}
// Iterate in reverse order.
for (ListIterator<GridCacheMvccCandidate> it = locs.listIterator(locs.size());
it.hasPrevious(); ) {
GridCacheMvccCandidate c = it.previous();
assert !c.version().equals(cand.version())
: "Versions can't match [existing=" + c + ", new=" + cand + ']';
// Add after the owner or serializable tx.
if (c.owner() || c.serializable()) {
// Threads are checked above.
assert cand.dhtLocal() || c.threadId() != cand.threadId();
// Reposition.
it.next();
it.add(cand);
return true;
}
// If not the owner, add after the lesser version.
if (c.version().isLess(cand.version())) {
// Reposition.
it.next();
it.add(cand);
return true;
}
}
}
// Either list is empty or candidate is first.
locs.addFirst(cand);
} else
// For near local candidates just add it to the end of list.
locs.add(cand);
}
// Remote.
else {
assert !cand.serializable() && !cand.read() : cand;
if (rmts == null) rmts = new LinkedList<>();
assert !cand.owner() || localOwners() == null
: "Cannot have local and remote owners "
+ "at the same time [cand="
+ cand
+ ", locs="
+ locs
+ ", rmts="
+ rmts
+ ']';
GridCacheMvccCandidate cur = candidate(rmts, cand.version());
// For existing candidates, we only care about owners and keys.
if (cur != null) {
if (cand.owner()) cur.setOwner();
return true;
}
// Either list is empty or candidate is last.
rmts.add(cand);
}
return true;
}