/**
* Entries for key.
*
* @param key Key.
* @return Entries.
* @throws IgniteCheckedException If failed.
*/
private String entries(int key) throws IgniteCheckedException {
if (partitioned()) {
GridNearCacheAdapter<Integer, String> near1 = near(1);
GridNearCacheAdapter<Integer, String> near2 = near(2);
GridDhtCacheAdapter<Integer, String> dht1 = dht(1);
GridDhtCacheAdapter<Integer, String> dht2 = dht(2);
return "Entries [ne1="
+ near1.peekEx(key)
+ ", de1="
+ dht1.peekEx(key)
+ ", ne2="
+ near2.peekEx(key)
+ ", de2="
+ dht2.peekEx(key)
+ ']';
}
return "Entries [e1="
+ "("
+ key
+ ", "
+ ((IgniteKernal) ignite1).internalCache(null).get(key)
+ ")"
+ ", e2="
+ "("
+ key
+ ", "
+ ((IgniteKernal) ignite2).internalCache(null).get(key)
+ ")"
+ ']';
}
/** {@inheritDoc} */
@Override
protected IgniteInternalFuture<Boolean> lockAllAsync(
Collection<KeyCacheObject> keys,
long timeout,
@Nullable IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
@Nullable TransactionIsolation isolation,
long accessTtl) {
return dht.lockAllAsync(null, timeout);
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public IgniteInternalFuture<Boolean> removeAsync(K key, @Nullable CacheEntryPredicate... filter) {
return dht.removeAsync(key, filter);
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public IgniteInternalFuture<GridCacheReturn> removexAsync(K key, V val) {
return dht.removexAsync(key, val);
}
/** {@inheritDoc} */
@Override
public IgniteInternalFuture<?> removeAllAsync(Collection<? extends K> keys) {
return dht.removeAllAsync(keys);
}
/** {@inheritDoc} */
@Override
public IgniteInternalFuture<?> removeAllConflictAsync(Map<KeyCacheObject, GridCacheVersion> drMap)
throws IgniteCheckedException {
return dht.removeAllConflictAsync(drMap);
}
/** {@inheritDoc} */
@Override
public void putAll(Map<? extends K, ? extends V> m) throws IgniteCheckedException {
dht.putAll(m);
}
/** {@inheritDoc} */
@Override
public void removeAll() throws IgniteCheckedException {
dht.removeAll();
}
/** {@inheritDoc} */
@Override
public IgniteInternalFuture<?> localRemoveAll(CacheEntryPredicate filter) {
return dht.localRemoveAll(filter);
}
/** {@inheritDoc} */
@Override
public <T> IgniteInternalFuture<Map<K, EntryProcessorResult<T>>> invokeAllAsync(
Map<? extends K, ? extends EntryProcessor<K, V, T>> map, Object... args) {
return dht.invokeAllAsync(map, args);
}
/** {@inheritDoc} */
@Override
public <T> IgniteInternalFuture<EntryProcessorResult<T>> invokeAsync(
K key, EntryProcessor<K, V, T> entryProcessor, Object... args)
throws EntryProcessorException {
return dht.invokeAsync(key, entryProcessor, args);
}
/** {@inheritDoc} */
@Override
public <T> EntryProcessorResult<T> invoke(
K key, EntryProcessor<K, V, T> entryProcessor, Object... args) throws IgniteCheckedException {
return dht.invoke(key, entryProcessor, args);
}
/** {@inheritDoc} */
@Override
public <T> Map<K, EntryProcessorResult<T>> invokeAll(
Set<? extends K> keys, EntryProcessor<K, V, T> entryProcessor, Object... args)
throws IgniteCheckedException {
return dht.invokeAll(keys, entryProcessor, args);
}
/** {@inheritDoc} */
@Override
public IgniteInternalFuture<?> putAllConflictAsync(Map<KeyCacheObject, GridCacheDrInfo> drMap)
throws IgniteCheckedException {
return dht.putAllConflictAsync(drMap);
}
/** {@inheritDoc} */
@Override
public void putAllConflict(Map<KeyCacheObject, GridCacheDrInfo> drMap)
throws IgniteCheckedException {
dht.putAllConflict(drMap);
}
/** {@inheritDoc} */
@Override
public IgniteInternalFuture<?> putAllAsync(Map<? extends K, ? extends V> m) {
return dht.putAllAsync(m);
}
/** {@inheritDoc} */
@Override
public boolean remove(K key, V val) throws IgniteCheckedException {
return dht.remove(key, val);
}
/** {@inheritDoc} */
@Override
public <T> Map<K, EntryProcessorResult<T>> invokeAll(
Map<? extends K, ? extends EntryProcessor<K, V, T>> map, Object... args)
throws IgniteCheckedException {
return dht.invokeAllAsync(map, args).get();
}
/** {@inheritDoc} */
@Override
public IgniteInternalFuture<Boolean> removeAsync(K key, V val) {
return dht.removeAsync(key, val);
}
/** {@inheritDoc} */
@Override
public <T> IgniteInternalFuture<Map<K, EntryProcessorResult<T>>> invokeAllAsync(
Set<? extends K> keys, EntryProcessor<K, V, T> entryProcessor, Object... args) {
return dht.invokeAllAsync(keys, entryProcessor, args);
}
/** {@inheritDoc} */
@Override
public IgniteInternalFuture<?> removeAllAsync() {
return dht.removeAllAsync();
}
/** {@inheritDoc} */
@Override
public void unlockAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException {
dht.unlockAll(keys);
}
/** {@inheritDoc} */
@Override
public void removeAllConflict(Map<KeyCacheObject, GridCacheVersion> drMap)
throws IgniteCheckedException {
dht.removeAllConflict(drMap);
}
/**
* @param ignite Grid.
* @param cacheName Cache name.
* @param sample Sample size.
* @return Data transfer object for given cache.
* @throws IgniteCheckedException If failed to create data transfer object.
*/
public VisorCache from(IgniteEx ignite, String cacheName, int sample)
throws IgniteCheckedException {
assert ignite != null;
GridCacheAdapter ca = ignite.context().cache().internalCache(cacheName);
// Cache was not started.
if (ca == null || !ca.context().started()) return null;
name = cacheName;
try {
swapSize = ca.swapSize();
swapKeys = ca.swapKeys();
} catch (IgniteCheckedException ignored) {
swapSize = -1;
swapKeys = -1;
}
primaryPartitions = Collections.emptyList();
backupPartitions = Collections.emptyList();
CacheConfiguration cfg = ca.configuration();
mode = cfg.getCacheMode();
boolean partitioned =
(mode == CacheMode.PARTITIONED || mode == CacheMode.REPLICATED)
&& ca.context().affinityNode();
if (partitioned) {
GridDhtCacheAdapter dca = null;
if (ca instanceof GridNearCacheAdapter) dca = ((GridNearCacheAdapter) ca).dht();
else if (ca instanceof GridDhtCacheAdapter) dca = (GridDhtCacheAdapter) ca;
if (dca != null) {
GridDhtPartitionTopology top = dca.topology();
if (cfg.getCacheMode() != CacheMode.LOCAL && cfg.getBackups() > 0) {
GridDhtPartitionMap2 map2 = top.localPartitionMap();
partitionsMap = new GridDhtPartitionMap(map2.nodeId(), map2.updateSequence(), map2.map());
}
List<GridDhtLocalPartition> parts = top.localPartitions();
primaryPartitions = new ArrayList<>(parts.size());
backupPartitions = new ArrayList<>(parts.size());
for (GridDhtLocalPartition part : parts) {
int p = part.id();
int sz = part.size();
// Pass -1 as topology version in order not to wait for topology version.
if (part.primary(AffinityTopologyVersion.NONE))
primaryPartitions.add(new IgnitePair<>(p, sz));
else if (part.state() == GridDhtPartitionState.OWNING
&& part.backup(AffinityTopologyVersion.NONE))
backupPartitions.add(new IgnitePair<>(p, sz));
}
} else {
// Old way of collecting partitions info.
ClusterNode node = ignite.cluster().localNode();
int[] pp = ca.affinity().primaryPartitions(node);
primaryPartitions = new ArrayList<>(pp.length);
for (int p : pp) {
Set set = ca.entrySet(p);
primaryPartitions.add(new IgnitePair<>(p, set != null ? set.size() : 0));
}
int[] bp = ca.affinity().backupPartitions(node);
backupPartitions = new ArrayList<>(bp.length);
for (int p : bp) {
Set set = ca.entrySet(p);
backupPartitions.add(new IgnitePair<>(p, set != null ? set.size() : 0));
}
}
}
size = ca.size();
nearSize = ca.nearSize();
dynamicDeploymentId = ca.context().dynamicDeploymentId();
dhtSize = size - nearSize;
primarySize = ca.primarySize();
offHeapAllocatedSize = ca.offHeapAllocatedSize();
offHeapEntriesCnt = ca.offHeapEntriesCount();
partitions = ca.affinity().partitions();
metrics = VisorCacheMetrics.from(ignite, cacheName);
estimateMemorySize(ignite, ca, sample);
return this;
}
/** {@inheritDoc} */
@Override
public V getAndRemove(K key) throws IgniteCheckedException {
return dht.getAndRemove(key);
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public IgniteInternalFuture<GridCacheReturn> replacexAsync(K key, V oldVal, V newVal) {
return dht.replacexAsync(key, oldVal, newVal);
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public IgniteInternalFuture<V> getAndRemoveAsync(K key) {
return dht.getAndRemoveAsync(key);
}
/** {@inheritDoc} */
@Override
public void removeAll(Collection<? extends K> keys) throws IgniteCheckedException {
dht.removeAll(keys);
}
/** @throws InterruptedException If interrupted. */
@SuppressWarnings("BusyWait")
protected void awaitPartitionMapExchange() throws InterruptedException {
for (Ignite g : G.allGrids()) {
IgniteKernal g0 = (IgniteKernal) g;
for (IgniteCacheProxy<?, ?> c : g0.context().cache().jcaches()) {
CacheConfiguration cfg = c.context().config();
if (cfg.getCacheMode() == PARTITIONED
&& cfg.getRebalanceMode() != NONE
&& g.cluster().nodes().size() > 1) {
AffinityFunction aff = cfg.getAffinity();
GridDhtCacheAdapter<?, ?> dht = dht(c);
GridDhtPartitionTopology top = dht.topology();
for (int p = 0; p < aff.partitions(); p++) {
long start = 0;
for (int i = 0; ; i++) {
boolean match = false;
AffinityTopologyVersion readyVer =
dht.context().shared().exchange().readyAffinityVersion();
if (readyVer.topologyVersion() > 0 && c.context().started()) {
// Must map on updated version of topology.
Collection<ClusterNode> affNodes =
g0.affinity(cfg.getName()).mapPartitionToPrimaryAndBackups(p);
int exp = affNodes.size();
GridDhtTopologyFuture topFut = top.topologyVersionFuture();
Collection<ClusterNode> owners =
(topFut != null && topFut.isDone())
? top.nodes(p, AffinityTopologyVersion.NONE)
: Collections.<ClusterNode>emptyList();
int actual = owners.size();
if (affNodes.size() != owners.size() || !affNodes.containsAll(owners)) {
LT.warn(
log(),
null,
"Waiting for topology map update ["
+ "grid="
+ g.name()
+ ", cache="
+ cfg.getName()
+ ", cacheId="
+ dht.context().cacheId()
+ ", topVer="
+ top.topologyVersion()
+ ", topFut="
+ topFut
+ ", p="
+ p
+ ", affNodesCnt="
+ exp
+ ", ownersCnt="
+ actual
+ ", affNodes="
+ affNodes
+ ", owners="
+ owners
+ ", locNode="
+ g.cluster().localNode()
+ ']');
} else match = true;
} else {
LT.warn(
log(),
null,
"Waiting for topology map update ["
+ "grid="
+ g.name()
+ ", cache="
+ cfg.getName()
+ ", cacheId="
+ dht.context().cacheId()
+ ", topVer="
+ top.topologyVersion()
+ ", started="
+ dht.context().started()
+ ", p="
+ p
+ ", readVer="
+ readyVer
+ ", locNode="
+ g.cluster().localNode()
+ ']');
}
if (!match) {
if (i == 0) start = System.currentTimeMillis();
if (System.currentTimeMillis() - start > 30_000)
throw new IgniteException(
"Timeout of waiting for topology map update ["
+ "grid="
+ g.name()
+ ", cache="
+ cfg.getName()
+ ", cacheId="
+ dht.context().cacheId()
+ ", topVer="
+ top.topologyVersion()
+ ", p="
+ p
+ ", readVer="
+ readyVer
+ ", locNode="
+ g.cluster().localNode()
+ ']');
Thread.sleep(200); // Busy wait.
continue;
}
if (i > 0)
log()
.warning(
"Finished waiting for topology map update [grid="
+ g.name()
+ ", p="
+ p
+ ", duration="
+ (System.currentTimeMillis() - start)
+ "ms]");
break;
}
}
}
}
}
}
/** {@inheritDoc} */
@Override
public GridCacheReturn replacex(K key, V oldVal, V newVal) throws IgniteCheckedException {
return dht.replacex(key, oldVal, newVal);
}