/** {@inheritDoc} */
@Override
public GridDhtPartitionFullMap partitionMap(boolean onlyActive) {
lock.readLock().lock();
try {
assert node2part != null && node2part.valid()
: "Invalid node2part [node2part: "
+ node2part
+ ", cache="
+ cctx.name()
+ ", started="
+ cctx.started()
+ ", stopping="
+ stopping
+ ", locNodeId="
+ cctx.localNode().id()
+ ", locName="
+ cctx.gridName()
+ ']';
GridDhtPartitionFullMap m = node2part;
return new GridDhtPartitionFullMap(
m.nodeId(), m.nodeOrder(), m.updateSequence(), m, onlyActive);
} finally {
lock.readLock().unlock();
}
}
/**
* @param updateSeq Update sequence.
* @return {@code True} if entry has been transitioned to state EVICTED.
*/
boolean tryEvict(boolean updateSeq) {
if (state.getReference() != RENTING || state.getStamp() != 0 || groupReserved()) return false;
// Attempt to evict partition entries from cache.
clearAll();
if (map.isEmpty() && state.compareAndSet(RENTING, EVICTED, 0, 0)) {
if (log.isDebugEnabled()) log.debug("Evicted partition: " + this);
if (!GridQueryProcessor.isEnabled(cctx.config())) clearSwap();
if (cctx.isDrEnabled()) cctx.dr().partitionEvicted(id);
cctx.dataStructures().onPartitionEvicted(id);
rent.onDone();
((GridDhtPreloader) cctx.preloader()).onPartitionEvicted(this, updateSeq);
clearDeferredDeletes();
return true;
}
return false;
}
/**
* @param cctx Context.
* @param id Partition ID.
*/
@SuppressWarnings("ExternalizableWithoutPublicNoArgConstructor")
GridDhtLocalPartition(GridCacheContext cctx, int id) {
assert cctx != null;
this.id = id;
this.cctx = cctx;
log = U.logger(cctx.kernalContext(), logRef, this);
rent =
new GridFutureAdapter<Object>() {
@Override
public String toString() {
return "PartitionRentFuture [part=" + GridDhtLocalPartition.this + ", map=" + map + ']';
}
};
map = new ConcurrentHashMap8<>(cctx.config().getStartSize() / cctx.affinity().partitions());
int delQueueSize =
CU.isSystemCache(cctx.name())
? 100
: Math.max(MAX_DELETE_QUEUE_SIZE / cctx.affinity().partitions(), 20);
rmvQueue = new GridCircularBuffer<>(U.ceilPow2(delQueueSize));
}
/** {@inheritDoc} */
@Override
public Collection<ClusterNode> nodes(int p, AffinityTopologyVersion topVer) {
Collection<ClusterNode> affNodes = cctx.affinity().nodes(p, topVer);
lock.readLock().lock();
try {
assert node2part != null && node2part.valid()
: "Invalid node-to-partitions map [topVer1="
+ topVer
+ ", topVer2="
+ this.topVer
+ ", cache="
+ cctx.name()
+ ", node2part="
+ node2part
+ ']';
Collection<ClusterNode> nodes = null;
Collection<UUID> nodeIds = part2node.get(p);
if (!F.isEmpty(nodeIds)) {
Collection<UUID> affIds = new HashSet<>(F.viewReadOnly(affNodes, F.node2id()));
for (UUID nodeId : nodeIds) {
if (!affIds.contains(nodeId) && hasState(p, nodeId, OWNING, MOVING, RENTING)) {
ClusterNode n = cctx.discovery().node(nodeId);
if (n != null
&& (topVer.topologyVersion() < 0 || n.order() <= topVer.topologyVersion())) {
if (nodes == null) {
nodes = new ArrayList<>(affNodes.size() + 2);
nodes.addAll(affNodes);
}
nodes.add(n);
}
}
}
}
return nodes != null ? nodes : affNodes;
} finally {
lock.readLock().unlock();
}
}
/** {@inheritDoc} */
@Override
public void printMemoryStats(int threshold) {
X.println(
">>> Cache partition topology stats [grid="
+ cctx.gridName()
+ ", cache="
+ cctx.name()
+ ']');
for (GridDhtLocalPartition part : locParts.values()) {
int size = part.size();
if (size >= threshold)
X.println(">>> Local partition [part=" + part.id() + ", size=" + size + ']');
}
}
/** @param cctx Context. */
GridDhtPartitionTopologyImpl(GridCacheContext<?, ?> cctx) {
assert cctx != null;
this.cctx = cctx;
log = cctx.logger(getClass());
}
/**
* @param p Partition.
* @param topVer Topology version ({@code -1} for all nodes).
* @param state Partition state.
* @param states Additional partition states.
* @return List of nodes for the partition.
*/
private List<ClusterNode> nodes(
int p,
AffinityTopologyVersion topVer,
GridDhtPartitionState state,
GridDhtPartitionState... states) {
Collection<UUID> allIds =
topVer.topologyVersion() > 0 ? F.nodeIds(CU.affinityNodes(cctx, topVer)) : null;
lock.readLock().lock();
try {
assert node2part != null && node2part.valid()
: "Invalid node-to-partitions map [topVer="
+ topVer
+ ", allIds="
+ allIds
+ ", node2part="
+ node2part
+ ", cache="
+ cctx.name()
+ ']';
Collection<UUID> nodeIds = part2node.get(p);
// Node IDs can be null if both, primary and backup, nodes disappear.
int size = nodeIds == null ? 0 : nodeIds.size();
if (size == 0) return Collections.emptyList();
List<ClusterNode> nodes = new ArrayList<>(size);
for (UUID id : nodeIds) {
if (topVer.topologyVersion() > 0 && !allIds.contains(id)) continue;
if (hasState(p, id, state, states)) {
ClusterNode n = cctx.discovery().node(id);
if (n != null && (topVer.topologyVersion() < 0 || n.order() <= topVer.topologyVersion()))
nodes.add(n);
}
}
return nodes;
} finally {
lock.readLock().unlock();
}
}
/**
* @param p Partition number.
* @param topVer Topology version.
* @param create Create flag.
* @param updateSeq Update sequence.
* @return Local partition.
*/
private GridDhtLocalPartition localPartition(
int p, AffinityTopologyVersion topVer, boolean create, boolean updateSeq) {
while (true) {
boolean belongs = cctx.affinity().localNode(p, topVer);
GridDhtLocalPartition loc = locParts.get(p);
if (loc != null && loc.state() == EVICTED) {
locParts.remove(p, loc);
if (!create) return null;
if (!belongs)
throw new GridDhtInvalidPartitionException(
p,
"Adding entry to evicted partition [part="
+ p
+ ", topVer="
+ topVer
+ ", this.topVer="
+ this.topVer
+ ']');
continue;
}
if (loc == null && create) {
if (!belongs)
throw new GridDhtInvalidPartitionException(
p,
"Creating partition which does not belong [part="
+ p
+ ", topVer="
+ topVer
+ ", this.topVer="
+ this.topVer
+ ']');
lock.writeLock().lock();
try {
GridDhtLocalPartition old =
locParts.putIfAbsent(p, loc = new GridDhtLocalPartition(cctx, p));
if (old != null) loc = old;
else {
if (updateSeq) this.updateSeq.incrementAndGet();
if (log.isDebugEnabled()) log.debug("Created local partition: " + loc);
}
} finally {
lock.writeLock().unlock();
}
}
return loc;
}
}
/** Clears swap entries for evicted partition. */
private void clearSwap() {
assert state() == EVICTED;
assert !GridQueryProcessor.isEnabled(cctx.config())
: "Indexing needs to have unswapped values.";
try {
GridCloseableIterator<Map.Entry<byte[], GridCacheSwapEntry>> it = cctx.swap().iterator(id);
boolean isLocStore = cctx.store().isLocal();
if (it != null) {
// We can safely remove these values because no entries will be created for evicted
// partition.
while (it.hasNext()) {
Map.Entry<byte[], GridCacheSwapEntry> entry = it.next();
byte[] keyBytes = entry.getKey();
KeyCacheObject key = cctx.toCacheKeyObject(keyBytes);
cctx.swap().remove(key);
if (isLocStore) cctx.store().remove(null, key.value(cctx.cacheObjectContext(), false));
}
}
} catch (IgniteCheckedException e) {
U.error(log, "Failed to clear swap for evicted partition: " + this, e);
}
}
/** {@inheritDoc} */
@Override
public GridDhtPartitionMap localPartitionMap() {
lock.readLock().lock();
try {
return new GridDhtPartitionMap(
cctx.nodeId(), updateSeq.get(), F.viewReadOnly(locParts, CU.part2state()), true);
} finally {
lock.readLock().unlock();
}
}
/**
* @param key Removed key.
* @param ver Removed version.
* @throws IgniteCheckedException If failed.
*/
public void onDeferredDelete(KeyCacheObject key, GridCacheVersion ver)
throws IgniteCheckedException {
try {
T2<KeyCacheObject, GridCacheVersion> evicted = rmvQueue.add(new T2<>(key, ver));
if (evicted != null) cctx.dht().removeVersionedEntry(evicted.get1(), evicted.get2());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IgniteInterruptedCheckedException(e);
}
}
/**
* @param updateSeq Update sequence.
* @return Future for evict attempt.
*/
IgniteInternalFuture<Boolean> tryEvictAsync(boolean updateSeq) {
if (map.isEmpty()
&& !GridQueryProcessor.isEnabled(cctx.config())
&& state.compareAndSet(RENTING, EVICTED, 0, 0)) {
if (log.isDebugEnabled()) log.debug("Evicted partition: " + this);
clearSwap();
if (cctx.isDrEnabled()) cctx.dr().partitionEvicted(id);
cctx.dataStructures().onPartitionEvicted(id);
rent.onDone();
((GridDhtPreloader) cctx.preloader()).onPartitionEvicted(this, updateSeq);
clearDeferredDeletes();
return new GridFinishedFuture<>(true);
}
return cctx.closures()
.callLocalSafe(
new GPC<Boolean>() {
@Override
public Boolean call() {
return tryEvict(true);
}
}, /*system pool*/
true);
}
/** {@inheritDoc} */
@Override
public void onRemoved(GridDhtCacheEntry e) {
/*
* Make sure not to acquire any locks here as this method
* may be called from sensitive synchronization blocks.
* ===================================================
*/
GridDhtLocalPartition loc =
localPartition(cctx.affinity().partition(e.key()), topologyVersion(), false);
if (loc != null) loc.onRemoved(e);
}
/** {@inheritDoc} */
@Override
public AffinityTopologyVersion topologyVersion() {
lock.readLock().lock();
try {
assert topVer.topologyVersion() > 0
: "Invalid topology version [topVer=" + topVer + ", cacheName=" + cctx.name() + ']';
return topVer;
} finally {
lock.readLock().unlock();
}
}
/** @param nodeId Node to remove. */
private void removeNode(UUID nodeId) {
assert nodeId != null;
assert lock.writeLock().isHeldByCurrentThread();
ClusterNode oldest = CU.oldestAliveCacheServerNode(cctx.shared(), topVer);
assert oldest != null;
ClusterNode loc = cctx.localNode();
if (node2part != null) {
if (oldest.equals(loc) && !node2part.nodeId().equals(loc.id())) {
updateSeq.setIfGreater(node2part.updateSequence());
node2part =
new GridDhtPartitionFullMap(
loc.id(), loc.order(), updateSeq.incrementAndGet(), node2part, false);
} else node2part = new GridDhtPartitionFullMap(node2part, node2part.updateSequence());
part2node = new HashMap<>(part2node);
GridDhtPartitionMap parts = node2part.remove(nodeId);
if (parts != null) {
for (Integer p : parts.keySet()) {
Set<UUID> nodeIds = part2node.get(p);
if (nodeIds != null) {
nodeIds.remove(nodeId);
if (nodeIds.isEmpty()) part2node.remove(p);
}
}
}
consistencyCheck();
}
}
/** {@inheritDoc} */
@Override
public GridDhtLocalPartition onAdded(AffinityTopologyVersion topVer, GridDhtCacheEntry e) {
/*
* Make sure not to acquire any locks here as this method
* may be called from sensitive synchronization blocks.
* ===================================================
*/
int p = cctx.affinity().partition(e.key());
GridDhtLocalPartition loc = localPartition(p, topVer, true);
assert loc != null;
loc.onAdded(e);
return loc;
}
/** {@inheritDoc} */
@Override
public void onEvicted(GridDhtLocalPartition part, boolean updateSeq) {
assert updateSeq || lock.isWriteLockedByCurrentThread();
lock.writeLock().lock();
try {
if (stopping) return;
assert part.state() == EVICTED;
long seq = updateSeq ? this.updateSeq.incrementAndGet() : this.updateSeq.get();
updateLocal(part.id(), cctx.localNodeId(), part.state(), seq);
consistencyCheck();
} finally {
lock.writeLock().unlock();
}
}
/** {@inheritDoc} */
@Override
public boolean own(GridDhtLocalPartition part) {
ClusterNode loc = cctx.localNode();
lock.writeLock().lock();
try {
if (part.own()) {
updateLocal(part.id(), loc.id(), part.state(), updateSeq.incrementAndGet());
consistencyCheck();
return true;
}
consistencyCheck();
return false;
} finally {
lock.writeLock().unlock();
}
}
/** {@inheritDoc} */
@SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
@Nullable
@Override
public GridDhtPartitionMap update(
@Nullable GridDhtPartitionExchangeId exchId, GridDhtPartitionFullMap partMap) {
if (log.isDebugEnabled())
log.debug(
"Updating full partition map [exchId=" + exchId + ", parts=" + fullMapString() + ']');
assert partMap != null;
lock.writeLock().lock();
try {
if (stopping) return null;
if (exchId != null && lastExchangeId != null && lastExchangeId.compareTo(exchId) >= 0) {
if (log.isDebugEnabled())
log.debug(
"Stale exchange id for full partition map update (will ignore) [lastExchId="
+ lastExchangeId
+ ", exchId="
+ exchId
+ ']');
return null;
}
if (node2part != null && node2part.compareTo(partMap) >= 0) {
if (log.isDebugEnabled())
log.debug(
"Stale partition map for full partition map update (will ignore) [lastExchId="
+ lastExchangeId
+ ", exchId="
+ exchId
+ ", curMap="
+ node2part
+ ", newMap="
+ partMap
+ ']');
return null;
}
long updateSeq = this.updateSeq.incrementAndGet();
if (exchId != null) lastExchangeId = exchId;
if (node2part != null) {
for (GridDhtPartitionMap part : node2part.values()) {
GridDhtPartitionMap newPart = partMap.get(part.nodeId());
// If for some nodes current partition has a newer map,
// then we keep the newer value.
if (newPart != null && newPart.updateSequence() < part.updateSequence()) {
if (log.isDebugEnabled())
log.debug(
"Overriding partition map in full update map [exchId="
+ exchId
+ ", curPart="
+ mapString(part)
+ ", newPart="
+ mapString(newPart)
+ ']');
partMap.put(part.nodeId(), part);
}
}
for (Iterator<UUID> it = partMap.keySet().iterator(); it.hasNext(); ) {
UUID nodeId = it.next();
if (!cctx.discovery().alive(nodeId)) {
if (log.isDebugEnabled())
log.debug(
"Removing left node from full map update [nodeId="
+ nodeId
+ ", partMap="
+ partMap
+ ']');
it.remove();
}
}
}
node2part = partMap;
Map<Integer, Set<UUID>> p2n = new HashMap<>(cctx.affinity().partitions(), 1.0f);
for (Map.Entry<UUID, GridDhtPartitionMap> e : partMap.entrySet()) {
for (Integer p : e.getValue().keySet()) {
Set<UUID> ids = p2n.get(p);
if (ids == null)
// Initialize HashSet to size 3 in anticipation that there won't be
// more than 3 nodes per partitions.
p2n.put(p, ids = U.newHashSet(3));
ids.add(e.getKey());
}
}
part2node = p2n;
boolean changed = checkEvictions(updateSeq);
consistencyCheck();
if (log.isDebugEnabled()) log.debug("Partition map after full update: " + fullMapString());
return changed ? localPartitionMap() : null;
} finally {
lock.writeLock().unlock();
}
}
/** {@inheritDoc} */
@Override
public GridDhtLocalPartition localPartition(Object key, boolean create) {
return localPartition(cctx.affinity().partition(key), AffinityTopologyVersion.NONE, create);
}
/** Clears values for this partition. */
private void clearAll() {
GridCacheVersion clearVer = cctx.versions().next();
boolean swap = cctx.isSwapOrOffheapEnabled();
boolean rec = cctx.events().isRecordable(EVT_CACHE_REBALANCE_OBJECT_UNLOADED);
Iterator<GridDhtCacheEntry> it = map.values().iterator();
GridCloseableIterator<Map.Entry<byte[], GridCacheSwapEntry>> swapIt = null;
if (swap
&& GridQueryProcessor.isEnabled(cctx.config())) { // Indexing needs to unswap cache values.
Iterator<GridDhtCacheEntry> unswapIt = null;
try {
swapIt = cctx.swap().iterator(id);
unswapIt = unswapIterator(swapIt);
} catch (Exception e) {
U.error(log, "Failed to clear swap for evicted partition: " + this, e);
}
if (unswapIt != null) it = F.concat(it, unswapIt);
}
try {
while (it.hasNext()) {
GridDhtCacheEntry cached = it.next();
try {
if (cached.clearInternal(clearVer, swap)) {
map.remove(cached.key(), cached);
if (!cached.isInternal()) {
mapPubSize.decrement();
if (rec)
cctx.events()
.addEvent(
cached.partition(),
cached.key(),
cctx.localNodeId(),
(IgniteUuid) null,
null,
EVT_CACHE_REBALANCE_OBJECT_UNLOADED,
null,
false,
cached.rawGet(),
cached.hasValue(),
null,
null,
null);
}
}
} catch (IgniteCheckedException e) {
U.error(log, "Failed to clear cache entry for evicted partition: " + cached, e);
}
}
} finally {
U.close(swapIt, log);
}
}
/** {@inheritDoc} */
@Override
public List<ClusterNode> owners(int p, AffinityTopologyVersion topVer) {
if (!cctx.rebalanceEnabled()) return ownersAndMoving(p, topVer);
return nodes(p, topVer, OWNING);
}
/** {@inheritDoc} */
@Override
public void beforeExchange(GridDhtPartitionsExchangeFuture exchFut)
throws IgniteCheckedException {
waitForRent();
ClusterNode loc = cctx.localNode();
int num = cctx.affinity().partitions();
lock.writeLock().lock();
try {
GridDhtPartitionExchangeId exchId = exchFut.exchangeId();
if (stopping) return;
assert topVer.equals(exchId.topologyVersion())
: "Invalid topology version [topVer=" + topVer + ", exchId=" + exchId + ']';
if (exchId.isLeft()) removeNode(exchId.nodeId());
// In case if node joins, get topology at the time of joining node.
ClusterNode oldest = CU.oldestAliveCacheServerNode(cctx.shared(), topVer);
assert oldest != null;
if (log.isDebugEnabled())
log.debug(
"Partition map beforeExchange [exchId="
+ exchId
+ ", fullMap="
+ fullMapString()
+ ']');
long updateSeq = this.updateSeq.incrementAndGet();
// If this is the oldest node.
if (oldest.id().equals(loc.id())
|| exchFut.isCacheAdded(cctx.cacheId(), exchId.topologyVersion())) {
if (node2part == null) {
node2part = new GridDhtPartitionFullMap(oldest.id(), oldest.order(), updateSeq);
if (log.isDebugEnabled())
log.debug(
"Created brand new full topology map on oldest node [exchId="
+ exchId
+ ", fullMap="
+ fullMapString()
+ ']');
} else if (!node2part.valid()) {
node2part =
new GridDhtPartitionFullMap(oldest.id(), oldest.order(), updateSeq, node2part, false);
if (log.isDebugEnabled())
log.debug(
"Created new full topology map on oldest node [exchId="
+ exchId
+ ", fullMap="
+ node2part
+ ']');
} else if (!node2part.nodeId().equals(loc.id())) {
node2part =
new GridDhtPartitionFullMap(oldest.id(), oldest.order(), updateSeq, node2part, false);
if (log.isDebugEnabled())
log.debug(
"Copied old map into new map on oldest node (previous oldest node left) [exchId="
+ exchId
+ ", fullMap="
+ fullMapString()
+ ']');
}
}
if (cctx.rebalanceEnabled()) {
for (int p = 0; p < num; p++) {
// If this is the first node in grid.
boolean added = exchFut.isCacheAdded(cctx.cacheId(), exchId.topologyVersion());
if ((oldest.id().equals(loc.id())
&& oldest.id().equals(exchId.nodeId())
&& exchId.isJoined())
|| added) {
assert exchId.isJoined() || added;
try {
GridDhtLocalPartition locPart = localPartition(p, topVer, true, false);
assert locPart != null;
boolean owned = locPart.own();
assert owned
: "Failed to own partition for oldest node [cacheName"
+ cctx.name()
+ ", part="
+ locPart
+ ']';
if (log.isDebugEnabled()) log.debug("Owned partition for oldest node: " + locPart);
updateLocal(p, loc.id(), locPart.state(), updateSeq);
} catch (GridDhtInvalidPartitionException e) {
if (log.isDebugEnabled())
log.debug(
"Ignoring invalid partition on oldest node (no need to create a partition "
+ "if it no longer belongs to local node: "
+ e.partition());
}
}
// If this is not the first node in grid.
else {
if (node2part != null && node2part.valid()) {
if (cctx.affinity().localNode(p, topVer)) {
try {
// This will make sure that all non-existing partitions
// will be created in MOVING state.
GridDhtLocalPartition locPart = localPartition(p, topVer, true, false);
updateLocal(p, loc.id(), locPart.state(), updateSeq);
} catch (GridDhtInvalidPartitionException e) {
if (log.isDebugEnabled())
log.debug(
"Ignoring invalid partition (no need to create a partition if it "
+ "no longer belongs to local node: "
+ e.partition());
}
}
}
// If this node's map is empty, we pre-create local partitions,
// so local map will be sent correctly during exchange.
else if (cctx.affinity().localNode(p, topVer)) {
try {
localPartition(p, topVer, true, false);
} catch (GridDhtInvalidPartitionException e) {
if (log.isDebugEnabled())
log.debug(
"Ignoring invalid partition (no need to pre-create a partition if it "
+ "no longer belongs to local node: "
+ e.partition());
}
}
}
}
} else {
// If preloader is disabled, then we simply clear out
// the partitions this node is not responsible for.
for (int p = 0; p < num; p++) {
GridDhtLocalPartition locPart = localPartition(p, topVer, false, false);
boolean belongs = cctx.affinity().localNode(p, topVer);
if (locPart != null) {
if (!belongs) {
GridDhtPartitionState state = locPart.state();
if (state.active()) {
locPart.rent(false);
updateLocal(p, loc.id(), locPart.state(), updateSeq);
if (log.isDebugEnabled())
log.debug(
"Evicting partition with rebalancing disabled "
+ "(it does not belong to affinity): "
+ locPart);
}
}
} else if (belongs) {
try {
// Pre-create partitions.
localPartition(p, topVer, true, false);
} catch (GridDhtInvalidPartitionException e) {
if (log.isDebugEnabled())
log.debug(
"Ignoring invalid partition with disabled rebalancer (no need to "
+ "pre-create a partition if it no longer belongs to local node: "
+ e.partition());
}
}
}
}
if (node2part != null && node2part.valid()) checkEvictions(updateSeq);
consistencyCheck();
if (log.isDebugEnabled())
log.debug(
"Partition map after beforeExchange [exchId="
+ exchId
+ ", fullMap="
+ fullMapString()
+ ']');
} finally {
lock.writeLock().unlock();
}
// Wait for evictions.
waitForRent();
}
/**
* @param updateSeq Update sequence.
* @return Checks if any of the local partitions need to be evicted.
*/
private boolean checkEvictions(long updateSeq) {
assert lock.isWriteLockedByCurrentThread();
boolean changed = false;
UUID locId = cctx.nodeId();
for (GridDhtLocalPartition part : locParts.values()) {
GridDhtPartitionState state = part.state();
if (state.active()) {
int p = part.id();
List<ClusterNode> affNodes = cctx.affinity().nodes(p, topVer);
if (!affNodes.contains(cctx.localNode())) {
Collection<UUID> nodeIds = F.nodeIds(nodes(p, topVer, OWNING));
// If all affinity nodes are owners, then evict partition from local node.
if (nodeIds.containsAll(F.nodeIds(affNodes))) {
part.rent(false);
updateLocal(part.id(), locId, part.state(), updateSeq);
changed = true;
if (log.isDebugEnabled())
log.debug("Evicted local partition (all affinity nodes are owners): " + part);
} else {
int ownerCnt = nodeIds.size();
int affCnt = affNodes.size();
if (ownerCnt > affCnt) {
List<ClusterNode> sorted = new ArrayList<>(cctx.discovery().nodes(nodeIds));
// Sort by node orders in ascending order.
Collections.sort(sorted, CU.nodeComparator(true));
int diff = sorted.size() - affCnt;
for (int i = 0; i < diff; i++) {
ClusterNode n = sorted.get(i);
if (locId.equals(n.id())) {
part.rent(false);
updateLocal(part.id(), locId, part.state(), updateSeq);
changed = true;
if (log.isDebugEnabled())
log.debug(
"Evicted local partition (this node is oldest non-affinity node): " + part);
break;
}
}
}
}
}
}
}
return changed;
}
/**
* Updates value for single partition.
*
* @param p Partition.
* @param nodeId Node ID.
* @param state State.
* @param updateSeq Update sequence.
*/
@SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
private void updateLocal(int p, UUID nodeId, GridDhtPartitionState state, long updateSeq) {
assert lock.isWriteLockedByCurrentThread();
assert nodeId.equals(cctx.nodeId());
// In case if node joins, get topology at the time of joining node.
ClusterNode oldest = CU.oldestAliveCacheServerNode(cctx.shared(), topVer);
assert oldest != null;
// If this node became the oldest node.
if (oldest.id().equals(cctx.nodeId())) {
long seq = node2part.updateSequence();
if (seq != updateSeq) {
if (seq > updateSeq) {
if (this.updateSeq.get() < seq) {
// Update global counter if necessary.
boolean b = this.updateSeq.compareAndSet(this.updateSeq.get(), seq + 1);
assert b
: "Invalid update sequence [updateSeq="
+ updateSeq
+ ", seq="
+ seq
+ ", curUpdateSeq="
+ this.updateSeq.get()
+ ", node2part="
+ node2part.toFullString()
+ ']';
updateSeq = seq + 1;
} else updateSeq = seq;
}
node2part.updateSequence(updateSeq);
}
}
GridDhtPartitionMap map = node2part.get(nodeId);
if (map == null)
node2part.put(
nodeId,
map =
new GridDhtPartitionMap(
nodeId,
updateSeq,
Collections.<Integer, GridDhtPartitionState>emptyMap(),
false));
map.updateSequence(updateSeq);
map.put(p, state);
Set<UUID> ids = part2node.get(p);
if (ids == null) part2node.put(p, ids = U.newHashSet(3));
ids.add(nodeId);
}
/**
* @param topVer Topology version.
* @return {@code True} if local node is primary for this partition.
*/
public boolean primary(AffinityTopologyVersion topVer) {
return cctx.affinity().primary(cctx.localNode(), id, topVer);
}
/** {@inheritDoc} */
@Override
public List<ClusterNode> moving(int p) {
if (!cctx.rebalanceEnabled()) return ownersAndMoving(p, AffinityTopologyVersion.NONE);
return nodes(p, AffinityTopologyVersion.NONE, MOVING);
}
/** {@inheritDoc} */
@SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
@Nullable
@Override
public GridDhtPartitionMap update(
@Nullable GridDhtPartitionExchangeId exchId, GridDhtPartitionMap parts) {
if (log.isDebugEnabled())
log.debug(
"Updating single partition map [exchId=" + exchId + ", parts=" + mapString(parts) + ']');
if (!cctx.discovery().alive(parts.nodeId())) {
if (log.isDebugEnabled())
log.debug(
"Received partition update for non-existing node (will ignore) [exchId="
+ exchId
+ ", parts="
+ parts
+ ']');
return null;
}
lock.writeLock().lock();
try {
if (stopping) return null;
if (lastExchangeId != null && exchId != null && lastExchangeId.compareTo(exchId) > 0) {
if (log.isDebugEnabled())
log.debug(
"Stale exchange id for single partition map update (will ignore) [lastExchId="
+ lastExchangeId
+ ", exchId="
+ exchId
+ ']');
return null;
}
if (exchId != null) lastExchangeId = exchId;
if (node2part == null)
// Create invalid partition map.
node2part = new GridDhtPartitionFullMap();
GridDhtPartitionMap cur = node2part.get(parts.nodeId());
if (cur != null && cur.updateSequence() >= parts.updateSequence()) {
if (log.isDebugEnabled())
log.debug(
"Stale update sequence for single partition map update (will ignore) [exchId="
+ exchId
+ ", curSeq="
+ cur.updateSequence()
+ ", newSeq="
+ parts.updateSequence()
+ ']');
return null;
}
long updateSeq = this.updateSeq.incrementAndGet();
node2part = new GridDhtPartitionFullMap(node2part, updateSeq);
boolean changed = false;
if (cur == null || !cur.equals(parts)) changed = true;
node2part.put(parts.nodeId(), parts);
part2node = new HashMap<>(part2node);
// Add new mappings.
for (Integer p : parts.keySet()) {
Set<UUID> ids = part2node.get(p);
if (ids == null)
// Initialize HashSet to size 3 in anticipation that there won't be
// more than 3 nodes per partition.
part2node.put(p, ids = U.newHashSet(3));
changed |= ids.add(parts.nodeId());
}
// Remove obsolete mappings.
if (cur != null) {
for (Integer p : F.view(cur.keySet(), F0.notIn(parts.keySet()))) {
Set<UUID> ids = part2node.get(p);
if (ids != null) changed |= ids.remove(parts.nodeId());
}
}
changed |= checkEvictions(updateSeq);
consistencyCheck();
if (log.isDebugEnabled()) log.debug("Partition map after single update: " + fullMapString());
return changed ? localPartitionMap() : null;
} finally {
lock.writeLock().unlock();
}
}
/** {@inheritDoc} */
@Override
public boolean afterExchange(GridDhtPartitionsExchangeFuture exchFut)
throws IgniteCheckedException {
boolean changed = waitForRent();
ClusterNode loc = cctx.localNode();
int num = cctx.affinity().partitions();
AffinityTopologyVersion topVer = exchFut.topologyVersion();
lock.writeLock().lock();
try {
if (stopping) return false;
assert topVer.equals(exchFut.topologyVersion())
: "Invalid topology version [topVer=" + topVer + ", exchId=" + exchFut.exchangeId() + ']';
if (log.isDebugEnabled())
log.debug(
"Partition map before afterExchange [exchId="
+ exchFut.exchangeId()
+ ", fullMap="
+ fullMapString()
+ ']');
long updateSeq = this.updateSeq.incrementAndGet();
for (int p = 0; p < num; p++) {
GridDhtLocalPartition locPart = localPartition(p, topVer, false, false);
if (cctx.affinity().localNode(p, topVer)) {
// This partition will be created during next topology event,
// which obviously has not happened at this point.
if (locPart == null) {
if (log.isDebugEnabled())
log.debug("Skipping local partition afterExchange (will not create): " + p);
continue;
}
GridDhtPartitionState state = locPart.state();
if (state == MOVING) {
if (cctx.rebalanceEnabled()) {
Collection<ClusterNode> owners = owners(p);
// If there are no other owners, then become an owner.
if (F.isEmpty(owners)) {
boolean owned = locPart.own();
assert owned
: "Failed to own partition [cacheName"
+ cctx.name()
+ ", locPart="
+ locPart
+ ']';
updateLocal(p, loc.id(), locPart.state(), updateSeq);
changed = true;
if (cctx.events().isRecordable(EVT_CACHE_REBALANCE_PART_DATA_LOST)) {
DiscoveryEvent discoEvt = exchFut.discoveryEvent();
cctx.events()
.addPreloadEvent(
p,
EVT_CACHE_REBALANCE_PART_DATA_LOST,
discoEvt.eventNode(),
discoEvt.type(),
discoEvt.timestamp());
}
if (log.isDebugEnabled()) log.debug("Owned partition: " + locPart);
} else if (log.isDebugEnabled())
log.debug(
"Will not own partition (there are owners to rebalance from) [locPart="
+ locPart
+ ", owners = "
+ owners
+ ']');
} else updateLocal(p, loc.id(), locPart.state(), updateSeq);
}
} else {
if (locPart != null) {
GridDhtPartitionState state = locPart.state();
if (state == MOVING) {
locPart.rent(false);
updateLocal(p, loc.id(), locPart.state(), updateSeq);
changed = true;
if (log.isDebugEnabled())
log.debug("Evicting moving partition (it does not belong to affinity): " + locPart);
}
}
}
}
consistencyCheck();
} finally {
lock.writeLock().unlock();
}
return changed;
}