@NotNull
public static char[] adaptiveLoadText(@NotNull Reader reader) throws IOException {
char[] chars = new char[4096];
List<char[]> buffers = null;
int count = 0;
int total = 0;
while (true) {
int n = reader.read(chars, count, chars.length - count);
if (n <= 0) break;
count += n;
if (total > 1024 * 1024 * 10) throw new FileTooBigException("File too big " + reader);
total += n;
if (count == chars.length) {
if (buffers == null) {
buffers = new ArrayList<char[]>();
}
buffers.add(chars);
int newLength = Math.min(1024 * 1024, chars.length * 2);
chars = new char[newLength];
count = 0;
}
}
char[] result = new char[total];
if (buffers != null) {
for (char[] buffer : buffers) {
System.arraycopy(buffer, 0, result, result.length - total, buffer.length);
total -= buffer.length;
}
}
System.arraycopy(chars, 0, result, result.length - total, total);
return result;
}
/**
* @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<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;
}
/** {@inheritDoc} */
@Override
public void explicitUndeploy(UUID nodeId, String rsrcName) {
Collection<SharedDeployment> undeployed = new LinkedList<SharedDeployment>();
synchronized (mux) {
for (Iterator<List<SharedDeployment>> i1 = cache.values().iterator(); i1.hasNext(); ) {
List<SharedDeployment> deps = i1.next();
for (Iterator<SharedDeployment> i2 = deps.iterator(); i2.hasNext(); ) {
SharedDeployment dep = i2.next();
if (dep.hasName(rsrcName)) {
if (!dep.isUndeployed()) {
dep.undeploy();
dep.onRemoved();
// Undeploy.
i2.remove();
undeployed.add(dep);
if (log.isInfoEnabled()) log.info("Undeployed per-version class loader: " + dep);
}
break;
}
}
if (deps.isEmpty()) i1.remove();
}
}
recordUndeployed(null, undeployed);
}
/** {@inheritDoc} */
@Override
public void addAttributeListener(GridTaskSessionAttributeListener lsnr, boolean rewind) {
A.notNull(lsnr, "lsnr");
Map<Object, Object> attrs = null;
List<GridTaskSessionAttributeListener> lsnrs;
synchronized (mux) {
lsnrs = new ArrayList<GridTaskSessionAttributeListener>(this.lsnrs.size());
lsnrs.addAll(this.lsnrs);
lsnrs.add(lsnr);
lsnrs = Collections.unmodifiableList(lsnrs);
this.lsnrs = lsnrs;
if (rewind) attrs = new HashMap<Object, Object>(this.attrs);
}
if (rewind) {
for (Map.Entry<Object, Object> entry : attrs.entrySet()) {
for (GridTaskSessionAttributeListener l : lsnrs) {
l.onAttributeSet(entry.getKey(), entry.getValue());
}
}
}
}
/** {@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);
}
@NotNull
public static byte[] adaptiveLoadBytes(@NotNull InputStream stream) throws IOException {
byte[] bytes = new byte[4096];
List<byte[]> buffers = null;
int count = 0;
int total = 0;
while (true) {
int n = stream.read(bytes, count, bytes.length - count);
if (n <= 0) break;
count += n;
if (total > 1024 * 1024 * 10) throw new FileTooBigException("File too big " + stream);
total += n;
if (count == bytes.length) {
if (buffers == null) {
buffers = new ArrayList<byte[]>();
}
buffers.add(bytes);
int newLength = Math.min(1024 * 1024, bytes.length * 2);
bytes = new byte[newLength];
count = 0;
}
}
byte[] result = new byte[total];
if (buffers != null) {
for (byte[] buffer : buffers) {
System.arraycopy(buffer, 0, result, result.length - total, buffer.length);
total -= buffer.length;
}
}
System.arraycopy(bytes, 0, result, result.length - total, total);
return result;
}
/** {@inheritDoc} */
@Override
protected IgniteBiTuple<Long, List<IgniteExceptionRegistry.ExceptionInfo>> run(
Map<UUID, Long> arg) {
Long lastOrder = arg.get(ignite.localNode().id());
long order = lastOrder != null ? lastOrder : 0;
List<IgniteExceptionRegistry.ExceptionInfo> errors =
ignite.context().exceptionRegistry().getErrors(order);
List<IgniteExceptionRegistry.ExceptionInfo> wrapped = new ArrayList<>(errors.size());
for (IgniteExceptionRegistry.ExceptionInfo error : errors) {
if (error.order() > order) order = error.order();
wrapped.add(
new IgniteExceptionRegistry.ExceptionInfo(
error.order(),
new VisorExceptionWrapper(error.error()),
error.message(),
error.threadId(),
error.threadName(),
error.time()));
}
return new IgniteBiTuple<>(order, wrapped);
}
/**
* @param idx Index.
* @return Conflict version.
*/
@Nullable
public GridCacheVersion conflictVersion(int idx) {
if (conflictVers != null) {
assert idx >= 0 && idx < conflictVers.size();
return conflictVers.get(idx);
}
return null;
}
/** {@inheritDoc} */
@Override
public <T extends Extension> void registerExtension(Class<T> extensionItf, T extensionImpl) {
List<Object> list = extensionsCollector.get(extensionItf);
if (list == null) {
list = new ArrayList<>();
extensionsCollector.put(extensionItf, list);
}
list.add(extensionImpl);
}
private void spawnRareDeposit(
final List<AbstractDepositEffectArea> depositAreas, final short casterLevel) {
AbstractDepositEffectArea rareDeposit = null;
for (int i = 0, n = depositAreas.size(); i < n; ++i) {
final AbstractDepositEffectArea area = depositAreas.get(i);
if (rareDeposit == null) {
rareDeposit = area;
} else if (area.getDepositLevel() > rareDeposit.getDepositLevel()) {
rareDeposit = area;
}
}
this.spawnDeposit((int) rareDeposit.getBaseId());
}
@NotNull
public static Future<Void> asyncDelete(@NotNull Collection<File> files) {
List<File> tempFiles = new ArrayList<File>();
for (File file : files) {
final File tempFile = renameToTempFileOrDelete(file);
if (tempFile != null) {
tempFiles.add(tempFile);
}
}
if (!tempFiles.isEmpty()) {
return startDeletionThread(tempFiles.toArray(new File[tempFiles.size()]));
}
return new FixedFuture<Void>(null);
}
@NotNull
public static List<String> loadLines(@NotNull Reader reader) throws IOException {
List<String> lines = new ArrayList<String>();
BufferedReader bufferedReader = new BufferedReader(reader);
try {
String line;
while ((line = bufferedReader.readLine()) != null) {
lines.add(line);
}
} finally {
bufferedReader.close();
}
return lines;
}
/**
* Gets values referenced by sequential keys, e.g. {@code key1...keyN}.
*
* @param keyPrefix Key prefix, e.g. {@code key} for {@code key1...keyN}.
* @param params Parameters map.
* @return Values.
*/
@Nullable
protected List<Object> values(String keyPrefix, Map<String, Object> params) {
assert keyPrefix != null;
List<Object> vals = new LinkedList<>();
for (int i = 1; ; i++) {
String key = keyPrefix + i;
if (params.containsKey(key)) vals.add(params.get(key));
else break;
}
return vals;
}
/** {@inheritDoc} */
@Override
public boolean removeAttributeListener(GridTaskSessionAttributeListener lsnr) {
A.notNull(lsnr, "lsnr");
synchronized (mux) {
List<GridTaskSessionAttributeListener> lsnrs =
new ArrayList<GridTaskSessionAttributeListener>(this.lsnrs);
boolean rmv = lsnrs.remove(lsnr);
this.lsnrs = Collections.unmodifiableList(lsnrs);
return rmv;
}
}
private void spawnDeposit(
final List<AbstractDepositEffectArea> depositAreas, final short casterLevel) {
final int roll = MathHelper.random(100);
AbstractDepositEffectArea deposit = null;
for (int i = 0, n = depositAreas.size(); i < n; ++i) {
final AbstractDepositEffectArea area = depositAreas.get(i);
if (deposit == null) {
deposit = area;
} else if ((roll < deposit.getDepositLevel() && roll > area.getDepositLevel())
|| (roll > area.getDepositLevel()
&& area.getDepositLevel() > deposit.getDepositLevel())) {
deposit = area;
}
}
this.spawnDeposit((int) deposit.getBaseId());
}
/**
* @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();
}
}
/** @return Map extension interface to array of implementation. */
public Map<Class<?>, Object[]> createExtensionMap() {
Map<Class<?>, Object[]> extensions = new HashMap<>(extensionsCollector.size() * 2, 0.5f);
for (Map.Entry<Class<?>, List<Object>> entry : extensionsCollector.entrySet()) {
Class<?> extensionItf = entry.getKey();
List<Object> implementations = entry.getValue();
Object[] implArr = (Object[]) Array.newInstance(extensionItf, implementations.size());
implArr = implementations.toArray(implArr);
extensions.put(extensionItf, implArr);
}
return extensions;
}
/** {@inheritDoc} */
@Override
protected boolean hasReaders() throws GridCacheEntryRemovedException {
synchronized (mux) {
checkReaders();
return !readers.isEmpty();
}
}
/**
* Finds all files in folder and in it's sub-tree of specified depth.
*
* @param file Starting folder
* @param maxDepth Depth of the tree. If 1 - just look in the folder, no sub-folders.
* @param filter file filter.
* @return List of found files.
*/
public static List<VisorLogFile> fileTree(File file, int maxDepth, @Nullable FileFilter filter) {
if (file.isDirectory()) {
File[] files = (filter == null) ? file.listFiles() : file.listFiles(filter);
if (files == null) return Collections.emptyList();
List<VisorLogFile> res = new ArrayList<>(files.length);
for (File f : files) {
if (f.isFile() && f.length() > 0) res.add(new VisorLogFile(f));
else if (maxDepth > 1) res.addAll(fileTree(f, maxDepth - 1, filter));
}
return res;
}
return F.asList(new VisorLogFile(file));
}
private void findTestedAndInjectableFields(@NotNull Field[] fieldsDeclaredInTestClass) {
for (Field field : fieldsDeclaredInTestClass) {
if (field.isAnnotationPresent(Injectable.class)) {
MockedType mockedType = new MockedType(field);
injectableFields.add(mockedType);
} else {
addAsTestedFieldIfApplicable(field);
}
}
}
private boolean findAllTestedAndInjectableFieldsInTestClassHierarchy(
@NotNull Class<?> testClass) {
Class<?> classWithFields = testClass;
do {
Field[] fields = classWithFields.getDeclaredFields();
findTestedAndInjectableFields(fields);
classWithFields = classWithFields.getSuperclass();
} while (classWithFields.getClassLoader() != null);
return !testedFields.isEmpty();
}
/** @param removeProcessor parent, child */
public static <T> Collection<T> removeAncestors(
final Collection<T> files,
final Convertor<T, String> convertor,
final PairProcessor<T, T> removeProcessor) {
if (files.isEmpty()) return files;
final TreeMap<String, T> paths = new TreeMap<String, T>();
for (T file : files) {
final String path = convertor.convert(file);
assert path != null;
final String canonicalPath = toCanonicalPath(path);
paths.put(canonicalPath, file);
}
final List<Map.Entry<String, T>> ordered =
new ArrayList<Map.Entry<String, T>>(paths.entrySet());
final List<T> result = new ArrayList<T>(ordered.size());
result.add(ordered.get(0).getValue());
for (int i = 1; i < ordered.size(); i++) {
final Map.Entry<String, T> entry = ordered.get(i);
final String child = entry.getKey();
boolean parentNotFound = true;
for (int j = i - 1; j >= 0; j--) {
// possible parents
final String parent = ordered.get(j).getKey();
if (parent == null) continue;
if (startsWith(child, parent)
&& removeProcessor.process(ordered.get(j).getValue(), entry.getValue())) {
parentNotFound = false;
break;
}
}
if (parentNotFound) {
result.add(entry.getValue());
}
}
return result;
}
/** {@inheritDoc} */
@Nullable
@Override
protected Map<UUID, IgniteBiTuple<Long, List<IgniteExceptionRegistry.ExceptionInfo>>> reduce0(
List<ComputeJobResult> results) {
Map<UUID, IgniteBiTuple<Long, List<IgniteExceptionRegistry.ExceptionInfo>>> taskRes =
new HashMap<>(results.size());
for (ComputeJobResult res : results) {
IgniteBiTuple<Long, List<IgniteExceptionRegistry.ExceptionInfo>> jobRes = res.getData();
taskRes.put(res.getNode().id(), jobRes);
}
return taskRes;
}
/**
* @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;
}
}
private void addAsTestedFieldIfApplicable(@NotNull Field fieldFromTestClass) {
for (Annotation fieldAnnotation : fieldFromTestClass.getDeclaredAnnotations()) {
Tested testedMetadata;
if (fieldAnnotation instanceof Tested) {
testedMetadata = (Tested) fieldAnnotation;
} else {
testedMetadata = fieldAnnotation.annotationType().getAnnotation(Tested.class);
}
if (testedMetadata != null) {
TestedField testedField =
new TestedField(injectionState, fieldFromTestClass, testedMetadata);
testedFields.add(testedField);
break;
}
}
}
private static void collectMatchedFiles(
@NotNull File absoluteRoot,
@NotNull File root,
@NotNull Pattern pattern,
@NotNull List<File> files) {
final File[] dirs = root.listFiles();
if (dirs == null) return;
for (File dir : dirs) {
if (dir.isFile()) {
final String relativePath = getRelativePath(absoluteRoot, dir);
if (relativePath != null) {
final String path = toSystemIndependentName(relativePath);
if (pattern.matcher(path).matches()) {
files.add(dir);
}
}
} else {
collectMatchedFiles(absoluteRoot, dir, pattern, files);
}
}
}
/**
* @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;
}
/**
* Creates REST request.
*
* @param cmd Command.
* @param params Parameters.
* @return REST request.
* @throws GridException If creation failed.
*/
@Nullable
private GridRestRequest createRequest(
GridRestCommand cmd, Map<String, Object> params, ServletRequest req) throws GridException {
GridRestRequest restReq;
switch (cmd) {
case CACHE_GET:
case CACHE_GET_ALL:
case CACHE_PUT:
case CACHE_PUT_ALL:
case CACHE_REMOVE:
case CACHE_REMOVE_ALL:
case CACHE_ADD:
case CACHE_CAS:
case CACHE_METRICS:
case CACHE_REPLACE:
case CACHE_DECREMENT:
case CACHE_INCREMENT:
case CACHE_APPEND:
case CACHE_PREPEND:
{
GridRestCacheRequest restReq0 = new GridRestCacheRequest();
restReq0.cacheName((String) params.get("cacheName"));
restReq0.key(params.get("key"));
restReq0.value(params.get("val"));
restReq0.value2(params.get("val2"));
Object val1 = params.get("val1");
if (val1 != null) restReq0.value(val1);
restReq0.cacheFlags(intValue("cacheFlags", params, 0));
restReq0.ttl(longValue("exp", params, null));
restReq0.initial(longValue("init", params, null));
restReq0.delta(longValue("delta", params, null));
if (cmd == CACHE_GET_ALL || cmd == CACHE_PUT_ALL || cmd == CACHE_REMOVE_ALL) {
List<Object> keys = values("k", params);
List<Object> vals = values("v", params);
if (keys.size() < vals.size())
throw new GridException(
"Number of keys must be greater or equals to number of values.");
Map<Object, Object> map = U.newHashMap(keys.size());
Iterator<Object> keyIt = keys.iterator();
Iterator<Object> valIt = vals.iterator();
while (keyIt.hasNext()) map.put(keyIt.next(), valIt.hasNext() ? valIt.next() : null);
restReq0.values(map);
}
restReq = restReq0;
break;
}
case TOPOLOGY:
case NODE:
{
GridRestTopologyRequest restReq0 = new GridRestTopologyRequest();
restReq0.includeMetrics(Boolean.parseBoolean((String) params.get("mtr")));
restReq0.includeAttributes(Boolean.parseBoolean((String) params.get("attr")));
restReq0.nodeIp((String) params.get("ip"));
restReq0.nodeId(uuidValue("id", params));
restReq = restReq0;
break;
}
case EXE:
case RESULT:
case NOOP:
{
GridRestTaskRequest restReq0 = new GridRestTaskRequest();
restReq0.taskId((String) params.get("id"));
restReq0.taskName((String) params.get("name"));
restReq0.params(values("p", params));
restReq0.async(Boolean.parseBoolean((String) params.get("async")));
restReq0.timeout(longValue("timeout", params, 0L));
restReq = restReq0;
break;
}
case LOG:
{
GridRestLogRequest restReq0 = new GridRestLogRequest();
restReq0.path((String) params.get("path"));
restReq0.from(intValue("from", params, -1));
restReq0.to(intValue("to", params, -1));
restReq = restReq0;
break;
}
case VERSION:
{
restReq = new GridRestRequest();
break;
}
default:
throw new GridException("Invalid command: " + cmd);
}
restReq.address(new InetSocketAddress(req.getRemoteAddr(), req.getRemotePort()));
restReq.command(cmd);
if (params.containsKey("gridgain.login") || params.containsKey("gridgain.password")) {
GridSecurityCredentials cred =
new GridSecurityCredentials(
(String) params.get("gridgain.login"), (String) params.get("gridgain.password"));
restReq.credentials(cred);
}
String clientId = (String) params.get("clientId");
try {
if (clientId != null) restReq.clientId(UUID.fromString(clientId));
} catch (Exception ignored) {
// Ignore invalid client id. Rest handler will process this logic.
}
String destId = (String) params.get("destId");
try {
if (destId != null) restReq.destinationId(UUID.fromString(destId));
} catch (IllegalArgumentException ignored) {
// Don't fail - try to execute locally.
}
String sesTokStr = (String) params.get("sessionToken");
try {
if (sesTokStr != null) restReq.sessionToken(U.hexString2ByteArray(sesTokStr));
} catch (IllegalArgumentException ignored) {
// Ignore invalid session token.
}
return restReq;
}
/**
* 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;
}
