/**
* @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}
*
* @param ctx
*/
@Override
public void prepareMarshal(GridCacheSharedContext ctx) throws IgniteCheckedException {
super.prepareMarshal(ctx);
GridCacheContext cctx = ctx.cacheContext(cacheId);
prepareMarshalCacheObjects(keys, cctx);
if (op == TRANSFORM) entryProcessorsBytes = marshalCollection(entryProcessors, ctx);
else prepareMarshalCacheObjects(vals, cctx);
if (filter != null) {
boolean hasFilter = false;
for (CacheEntryPredicate p : filter) {
if (p != null) {
hasFilter = true;
p.prepareMarshal(cctx);
}
}
if (!hasFilter) filter = null;
}
invokeArgsBytes = marshalInvokeArguments(invokeArgs, ctx);
if (expiryPlc != null)
expiryPlcBytes = CU.marshal(ctx, new IgniteExternalizableExpiryPolicy(expiryPlc));
}
/**
* @param cacheId Cache ID.
* @return {@code True} if local client has been added.
*/
public boolean isLocalClientAdded(int cacheId) {
if (!F.isEmpty(reqs)) {
for (DynamicCacheChangeRequest req : reqs) {
if (req.start() && F.eq(req.initiatingNodeId(), cctx.localNodeId())) {
if (CU.cacheId(req.cacheName()) == cacheId) return true;
}
}
}
return false;
}
/** {@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 cacheCtx Cache context.
* @return {@code True} if local node can calculate affinity on it's own for this partition map
* exchange.
*/
private boolean canCalculateAffinity(GridCacheContext cacheCtx) {
AffinityFunction affFunc = cacheCtx.config().getAffinity();
// Do not request affinity from remote nodes if affinity function is not centralized.
if (!U.hasAnnotation(affFunc, AffinityCentralizedFunction.class)) return true;
// If local node did not initiate exchange or local node is the only cache node in grid.
Collection<ClusterNode> affNodes = CU.affinityNodes(cacheCtx, exchId.topologyVersion());
return !exchId.nodeId().equals(cctx.localNodeId())
|| (affNodes.size() == 1 && affNodes.contains(cctx.localNode()));
}
/**
* @param cacheCtx Cache context.
* @throws IgniteCheckedException If failed.
*/
private void initTopology(GridCacheContext cacheCtx) throws IgniteCheckedException {
if (stopping(cacheCtx.cacheId())) return;
if (canCalculateAffinity(cacheCtx)) {
if (log.isDebugEnabled())
log.debug(
"Will recalculate affinity [locNodeId="
+ cctx.localNodeId()
+ ", exchId="
+ exchId
+ ']');
cacheCtx.affinity().calculateAffinity(exchId.topologyVersion(), discoEvt);
} else {
if (log.isDebugEnabled())
log.debug(
"Will request affinity from remote node [locNodeId="
+ cctx.localNodeId()
+ ", exchId="
+ exchId
+ ']');
// Fetch affinity assignment from remote node.
GridDhtAssignmentFetchFuture fetchFut =
new GridDhtAssignmentFetchFuture(
cacheCtx,
exchId.topologyVersion(),
CU.affinityNodes(cacheCtx, exchId.topologyVersion()));
fetchFut.init();
List<List<ClusterNode>> affAssignment = fetchFut.get();
if (log.isDebugEnabled())
log.debug(
"Fetched affinity from remote node, initializing affinity assignment [locNodeId="
+ cctx.localNodeId()
+ ", topVer="
+ exchId.topologyVersion()
+ ']');
if (affAssignment == null) {
affAssignment = new ArrayList<>(cacheCtx.affinity().partitions());
List<ClusterNode> empty = Collections.emptyList();
for (int i = 0; i < cacheCtx.affinity().partitions(); i++) affAssignment.add(empty);
}
cacheCtx.affinity().initializeAffinity(exchId.topologyVersion(), affAssignment);
}
}
/**
* @param cacheId Cache ID to check.
* @param topVer Topology version.
* @return {@code True} if cache was added during this exchange.
*/
public boolean isCacheAdded(int cacheId, AffinityTopologyVersion topVer) {
if (!F.isEmpty(reqs)) {
for (DynamicCacheChangeRequest req : reqs) {
if (req.start() && !req.clientStartOnly()) {
if (CU.cacheId(req.cacheName()) == cacheId) return true;
}
}
}
GridCacheContext<?, ?> cacheCtx = cctx.cacheContext(cacheId);
return cacheCtx != null && F.eq(cacheCtx.startTopologyVersion(), topVer);
}
/**
* @param cacheId Cache ID to check.
* @return {@code True} if cache is stopping by this exchange.
*/
private boolean stopping(int cacheId) {
boolean stopping = false;
if (!F.isEmpty(reqs)) {
for (DynamicCacheChangeRequest req : reqs) {
if (cacheId == CU.cacheId(req.cacheName())) {
stopping = req.stop();
break;
}
}
}
return stopping;
}
/**
* Updates partition map in all caches.
*
* @param msg Partitions full messages.
*/
private void updatePartitionFullMap(GridDhtPartitionsFullMessage msg) {
for (Map.Entry<Integer, GridDhtPartitionFullMap> entry : msg.partitions().entrySet()) {
Integer cacheId = entry.getKey();
GridCacheContext cacheCtx = cctx.cacheContext(cacheId);
if (cacheCtx != null) cacheCtx.topology().update(exchId, entry.getValue());
else {
ClusterNode oldest = CU.oldestAliveCacheServerNode(cctx, AffinityTopologyVersion.NONE);
if (oldest != null && oldest.isLocal())
cctx.exchange().clientTopology(cacheId, this).update(exchId, entry.getValue());
}
}
}
/**
* @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();
}
}
/** {@inheritDoc} */
@Override
public boolean onDone(AffinityTopologyVersion res, Throwable err) {
Map<Integer, Boolean> m = null;
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (cacheCtx.config().getTopologyValidator() != null && !CU.isSystemCache(cacheCtx.name())) {
if (m == null) m = new HashMap<>();
m.put(
cacheCtx.cacheId(),
cacheCtx.config().getTopologyValidator().validate(discoEvt.topologyNodes()));
}
}
cacheValidRes = m != null ? m : Collections.<Integer, Boolean>emptyMap();
cctx.cache().onExchangeDone(exchId.topologyVersion(), reqs, err);
cctx.exchange().onExchangeDone(this, err);
if (super.onDone(res, err) && !dummy && !forcePreload) {
if (log.isDebugEnabled())
log.debug(
"Completed partition exchange [localNode="
+ cctx.localNodeId()
+ ", exchange= "
+ this
+ ']');
initFut.onDone(err == null);
GridTimeoutObject timeoutObj = this.timeoutObj;
// Deschedule timeout object.
if (timeoutObj != null) cctx.kernalContext().timeout().removeTimeoutObject(timeoutObj);
if (exchId.isLeft()) {
for (GridCacheContext cacheCtx : cctx.cacheContexts())
cacheCtx.config().getAffinity().removeNode(exchId.nodeId());
}
return true;
}
return dummy;
}
/** @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();
}
}
/**
* Starts activity.
*
* @throws IgniteInterruptedCheckedException If interrupted.
*/
public void init() throws IgniteInterruptedCheckedException {
if (isDone()) return;
if (init.compareAndSet(false, true)) {
if (isDone()) return;
try {
// Wait for event to occur to make sure that discovery
// will return corresponding nodes.
U.await(evtLatch);
assert discoEvt != null : this;
assert !dummy && !forcePreload : this;
ClusterNode oldest = CU.oldestAliveCacheServerNode(cctx, exchId.topologyVersion());
oldestNode.set(oldest);
startCaches();
// True if client node joined or failed.
boolean clientNodeEvt;
if (F.isEmpty(reqs)) {
int type = discoEvt.type();
assert type == EVT_NODE_JOINED || type == EVT_NODE_LEFT || type == EVT_NODE_FAILED
: discoEvt;
clientNodeEvt = CU.clientNode(discoEvt.eventNode());
} else {
assert discoEvt.type() == EVT_DISCOVERY_CUSTOM_EVT : discoEvt;
boolean clientOnlyStart = true;
for (DynamicCacheChangeRequest req : reqs) {
if (!req.clientStartOnly()) {
clientOnlyStart = false;
break;
}
}
clientNodeEvt = clientOnlyStart;
}
if (clientNodeEvt) {
ClusterNode node = discoEvt.eventNode();
// Client need to initialize affinity for local join event or for stated client caches.
if (!node.isLocal()) {
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (cacheCtx.isLocal()) continue;
GridDhtPartitionTopology top = cacheCtx.topology();
top.updateTopologyVersion(exchId, this, -1, stopping(cacheCtx.cacheId()));
if (cacheCtx.affinity().affinityTopologyVersion() == AffinityTopologyVersion.NONE) {
initTopology(cacheCtx);
top.beforeExchange(this);
} else
cacheCtx.affinity().clientEventTopologyChange(discoEvt, exchId.topologyVersion());
}
if (exchId.isLeft())
cctx.mvcc().removeExplicitNodeLocks(exchId.nodeId(), exchId.topologyVersion());
onDone(exchId.topologyVersion());
skipPreload = cctx.kernalContext().clientNode();
return;
}
}
if (cctx.kernalContext().clientNode()) {
skipPreload = true;
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (cacheCtx.isLocal()) continue;
GridDhtPartitionTopology top = cacheCtx.topology();
top.updateTopologyVersion(exchId, this, -1, stopping(cacheCtx.cacheId()));
}
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (cacheCtx.isLocal()) continue;
initTopology(cacheCtx);
}
if (oldestNode.get() != null) {
rmtNodes =
new ConcurrentLinkedQueue<>(
CU.aliveRemoteServerNodesWithCaches(cctx, exchId.topologyVersion()));
rmtIds = Collections.unmodifiableSet(new HashSet<>(F.nodeIds(rmtNodes)));
ready.set(true);
initFut.onDone(true);
if (log.isDebugEnabled()) log.debug("Initialized future: " + this);
sendPartitions();
} else onDone(exchId.topologyVersion());
return;
}
assert oldestNode.get() != null;
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (isCacheAdded(cacheCtx.cacheId(), exchId.topologyVersion())) {
if (cacheCtx
.discovery()
.cacheAffinityNodes(cacheCtx.name(), topologyVersion())
.isEmpty())
U.quietAndWarn(log, "No server nodes found for cache client: " + cacheCtx.namex());
}
cacheCtx.preloader().onExchangeFutureAdded();
}
List<String> cachesWithoutNodes = null;
if (exchId.isLeft()) {
for (String name : cctx.cache().cacheNames()) {
if (cctx.discovery().cacheAffinityNodes(name, topologyVersion()).isEmpty()) {
if (cachesWithoutNodes == null) cachesWithoutNodes = new ArrayList<>();
cachesWithoutNodes.add(name);
// Fire event even if there is no client cache started.
if (cctx.gridEvents().isRecordable(EventType.EVT_CACHE_NODES_LEFT)) {
Event evt =
new CacheEvent(
name,
cctx.localNode(),
cctx.localNode(),
"All server nodes have left the cluster.",
EventType.EVT_CACHE_NODES_LEFT,
0,
false,
null,
null,
null,
null,
false,
null,
false,
null,
null,
null);
cctx.gridEvents().record(evt);
}
}
}
}
if (cachesWithoutNodes != null) {
StringBuilder sb =
new StringBuilder(
"All server nodes for the following caches have left the cluster: ");
for (int i = 0; i < cachesWithoutNodes.size(); i++) {
String cache = cachesWithoutNodes.get(i);
sb.append('\'').append(cache).append('\'');
if (i != cachesWithoutNodes.size() - 1) sb.append(", ");
}
U.quietAndWarn(log, sb.toString());
U.quietAndWarn(log, "Must have server nodes for caches to operate.");
}
assert discoEvt != null;
assert exchId.nodeId().equals(discoEvt.eventNode().id());
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
GridClientPartitionTopology clientTop =
cctx.exchange().clearClientTopology(cacheCtx.cacheId());
long updSeq = clientTop == null ? -1 : clientTop.lastUpdateSequence();
// Update before waiting for locks.
if (!cacheCtx.isLocal())
cacheCtx
.topology()
.updateTopologyVersion(exchId, this, updSeq, stopping(cacheCtx.cacheId()));
}
// Grab all alive remote nodes with order of equal or less than last joined node.
rmtNodes =
new ConcurrentLinkedQueue<>(
CU.aliveRemoteServerNodesWithCaches(cctx, exchId.topologyVersion()));
rmtIds = Collections.unmodifiableSet(new HashSet<>(F.nodeIds(rmtNodes)));
for (Map.Entry<UUID, GridDhtPartitionsSingleMessage> m : singleMsgs.entrySet())
// If received any messages, process them.
onReceive(m.getKey(), m.getValue());
for (Map.Entry<UUID, GridDhtPartitionsFullMessage> m : fullMsgs.entrySet())
// If received any messages, process them.
onReceive(m.getKey(), m.getValue());
AffinityTopologyVersion topVer = exchId.topologyVersion();
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (cacheCtx.isLocal()) continue;
// Must initialize topology after we get discovery event.
initTopology(cacheCtx);
cacheCtx.preloader().updateLastExchangeFuture(this);
}
IgniteInternalFuture<?> partReleaseFut = cctx.partitionReleaseFuture(topVer);
// Assign to class variable so it will be included into toString() method.
this.partReleaseFut = partReleaseFut;
if (log.isDebugEnabled()) log.debug("Before waiting for partition release future: " + this);
while (true) {
try {
partReleaseFut.get(2 * cctx.gridConfig().getNetworkTimeout(), TimeUnit.MILLISECONDS);
break;
} catch (IgniteFutureTimeoutCheckedException ignored) {
// Print pending transactions and locks that might have led to hang.
dumpPendingObjects();
}
}
if (log.isDebugEnabled()) log.debug("After waiting for partition release future: " + this);
if (!F.isEmpty(reqs)) blockGateways();
if (exchId.isLeft())
cctx.mvcc().removeExplicitNodeLocks(exchId.nodeId(), exchId.topologyVersion());
IgniteInternalFuture<?> locksFut = cctx.mvcc().finishLocks(exchId.topologyVersion());
while (true) {
try {
locksFut.get(2 * cctx.gridConfig().getNetworkTimeout(), TimeUnit.MILLISECONDS);
break;
} catch (IgniteFutureTimeoutCheckedException ignored) {
U.warn(
log,
"Failed to wait for locks release future. "
+ "Dumping pending objects that might be the cause: "
+ cctx.localNodeId());
U.warn(log, "Locked entries:");
Map<IgniteTxKey, Collection<GridCacheMvccCandidate>> locks =
cctx.mvcc().unfinishedLocks(exchId.topologyVersion());
for (Map.Entry<IgniteTxKey, Collection<GridCacheMvccCandidate>> e : locks.entrySet())
U.warn(log, "Locked entry [key=" + e.getKey() + ", mvcc=" + e.getValue() + ']');
}
}
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (cacheCtx.isLocal()) continue;
// Notify replication manager.
GridCacheContext drCacheCtx =
cacheCtx.isNear() ? cacheCtx.near().dht().context() : cacheCtx;
if (drCacheCtx.isDrEnabled()) drCacheCtx.dr().beforeExchange(topVer, exchId.isLeft());
// Partition release future is done so we can flush the write-behind store.
cacheCtx.store().forceFlush();
// Process queued undeploys prior to sending/spreading map.
cacheCtx.preloader().unwindUndeploys();
GridDhtPartitionTopology top = cacheCtx.topology();
assert topVer.equals(top.topologyVersion())
: "Topology version is updated only in this class instances inside single ExchangeWorker thread.";
top.beforeExchange(this);
}
for (GridClientPartitionTopology top : cctx.exchange().clientTopologies()) {
top.updateTopologyVersion(exchId, this, -1, stopping(top.cacheId()));
top.beforeExchange(this);
}
} catch (IgniteInterruptedCheckedException e) {
onDone(e);
throw e;
} catch (Throwable e) {
U.error(
log,
"Failed to reinitialize local partitions (preloading will be stopped): " + exchId,
e);
onDone(e);
if (e instanceof Error) throw (Error) e;
return;
}
if (F.isEmpty(rmtIds)) {
onDone(exchId.topologyVersion());
return;
}
ready.set(true);
initFut.onDone(true);
if (log.isDebugEnabled()) log.debug("Initialized future: " + this);
// If this node is not oldest.
if (!oldestNode.get().id().equals(cctx.localNodeId())) sendPartitions();
else {
boolean allReceived = allReceived();
if (allReceived && replied.compareAndSet(false, true)) {
if (spreadPartitions()) onDone(exchId.topologyVersion());
}
}
scheduleRecheck();
} else assert false : "Skipped init future: " + this;
}
/** {@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();
}
/**
* 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 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;
}