/**
* Joins array elements to string.
*
* @param arr Array.
* @return String.
*/
@Nullable
public static String compactArray(Object[] arr) {
if (arr == null || arr.length == 0) return null;
String sep = ", ";
StringBuilder sb = new StringBuilder();
for (Object s : arr) sb.append(s).append(sep);
if (sb.length() > 0) sb.setLength(sb.length() - sep.length());
return U.compact(sb.toString());
}
/**
* Log task mapped.
*
* @param log Logger.
* @param clazz Task class.
* @param nodes Mapped nodes.
*/
public static void logMapped(
@Nullable IgniteLogger log, Class<?> clazz, Collection<ClusterNode> nodes) {
log0(
log,
U.currentTimeMillis(),
String.format("[%s]: MAPPED: %s", clazz.getSimpleName(), U.toShortString(nodes)));
}
/** @param workTokDir Token directory (common for multiple nodes). */
private void cleanupResources(File workTokDir) {
RandomAccessFile lockFile = null;
FileLock lock = null;
try {
lockFile = new RandomAccessFile(new File(workTokDir, LOCK_FILE_NAME), "rw");
lock = lockFile.getChannel().lock();
if (lock != null) processTokenDirectory(workTokDir);
else if (log.isDebugEnabled())
log.debug(
"Token directory is being processed concurrently: " + workTokDir.getAbsolutePath());
} catch (OverlappingFileLockException ignored) {
if (log.isDebugEnabled())
log.debug(
"Token directory is being processed concurrently: " + workTokDir.getAbsolutePath());
} catch (FileLockInterruptionException ignored) {
Thread.currentThread().interrupt();
} catch (IOException e) {
U.error(log, "Failed to process directory: " + workTokDir.getAbsolutePath(), e);
} finally {
U.releaseQuiet(lock);
U.closeQuiet(lockFile);
}
}
/**
* @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 void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
jobName = U.readString(in);
user = U.readString(in);
hasCombiner = in.readBoolean();
numReduces = in.readInt();
props = U.readStringMap(in);
}
/** {@inheritDoc} */
@Override
public void writeExternal(ObjectOutput out) throws IOException {
U.writeString(out, jobName);
U.writeString(out, user);
out.writeBoolean(hasCombiner);
out.writeInt(numReduces);
U.writeStringMap(out, props);
}
/** {@inheritDoc} */
@Override
void onCancelAtStop() {
super.onCancelAtStop();
for (GridCacheQueryFutureAdapter fut : futs.values())
try {
fut.cancel();
} catch (IgniteCheckedException e) {
U.error(log, "Failed to cancel running query future: " + fut, e);
}
U.interrupt(threads.values());
}
/** {@inheritDoc} */
@Override
public void onClose() throws IgniteCheckedException {
if (data == null)
// Nothing to close.
return;
try {
U.closeQuiet(data.getStatement());
} catch (SQLException e) {
throw new IgniteCheckedException(e);
}
U.closeQuiet(data);
}
/**
* Waits until total number of events processed is equal or greater then argument passed.
*
* @param cnt Number of events to wait.
* @param timeout Timeout to wait.
* @return {@code True} if successfully waited, {@code false} if timeout happened.
* @throws InterruptedException If thread is interrupted.
*/
public synchronized boolean awaitEvents(int cnt, long timeout) throws InterruptedException {
long start = U.currentTimeMillis();
long now = start;
while (start + timeout > now) {
if (evtCnt >= cnt) return true;
wait(start + timeout - now);
now = U.currentTimeMillis();
}
return false;
}
private void sendPartitions() {
ClusterNode oldestNode = this.oldestNode.get();
try {
sendLocalPartitions(oldestNode, exchId);
} catch (ClusterTopologyCheckedException ignore) {
if (log.isDebugEnabled())
log.debug(
"Oldest node left during partition exchange [nodeId="
+ oldestNode.id()
+ ", exchId="
+ exchId
+ ']');
} catch (IgniteCheckedException e) {
scheduleRecheck();
U.error(
log,
"Failed to send local partitions to oldest node (will retry after timeout) [oldestNodeId="
+ oldestNode.id()
+ ", exchId="
+ exchId
+ ']',
e);
}
}
/** {@inheritDoc} */
@Override
protected final boolean tryReleaseShared(int ignore) {
endTime = U.currentTimeMillis();
// Always signal after setting final done status.
return true;
}
/** 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 void finishUnmarshal(GridCacheSharedContext ctx, ClassLoader ldr)
throws IgniteCheckedException {
super.finishUnmarshal(ctx, ldr);
if (writes != null) unmarshalTx(writes, false, ctx, ldr);
if (reads != null) unmarshalTx(reads, false, ctx, ldr);
if (grpLockKeyBytes != null && grpLockKey == null)
grpLockKey = ctx.marshaller().unmarshal(grpLockKeyBytes, ldr);
if (dhtVerKeys != null && dhtVers == null) {
assert dhtVerVals != null;
assert dhtVerKeys.size() == dhtVerVals.size();
Iterator<IgniteTxKey> keyIt = dhtVerKeys.iterator();
Iterator<GridCacheVersion> verIt = dhtVerVals.iterator();
dhtVers = U.newHashMap(dhtVerKeys.size());
while (keyIt.hasNext()) {
IgniteTxKey key = keyIt.next();
key.finishUnmarshal(ctx.cacheContext(key.cacheId()), ldr);
dhtVers.put(key, verIt.next());
}
}
if (txNodesBytes != null) txNodes = ctx.marshaller().unmarshal(txNodesBytes, ldr);
}
/** @return Nodes to execute on. */
private Collection<ClusterNode> nodes() {
CacheMode cacheMode = cctx.config().getCacheMode();
switch (cacheMode) {
case LOCAL:
if (prj != null)
U.warn(
log,
"Ignoring query projection because it's executed over LOCAL cache "
+ "(only local node will be queried): "
+ this);
return Collections.singletonList(cctx.localNode());
case REPLICATED:
if (prj != null || partition() != null) return nodes(cctx, prj, partition());
return cctx.affinityNode()
? Collections.singletonList(cctx.localNode())
: Collections.singletonList(F.rand(nodes(cctx, null, partition())));
case PARTITIONED:
return nodes(cctx, prj, partition());
default:
throw new IllegalStateException("Unknown cache distribution mode: " + cacheMode);
}
}
private void recheck() {
// If this is the oldest node.
if (oldestNode.get().id().equals(cctx.localNodeId())) {
Collection<UUID> remaining = remaining();
if (!remaining.isEmpty()) {
try {
cctx.io()
.safeSend(
cctx.discovery().nodes(remaining),
new GridDhtPartitionsSingleRequest(exchId),
SYSTEM_POOL,
null);
} catch (IgniteCheckedException e) {
U.error(
log,
"Failed to request partitions from nodes [exchangeId="
+ exchId
+ ", nodes="
+ remaining
+ ']',
e);
}
}
// Resend full partition map because last attempt failed.
else {
if (spreadPartitions()) onDone(exchId.topologyVersion());
}
} else sendPartitions();
// Schedule another send.
scheduleRecheck();
}
/**
* @param out Output stream.
* @param err Error cause.
*/
private void sendErrorResponse(ObjectOutput out, Exception err) {
try {
out.writeObject(new IpcSharedMemoryInitResponse(err));
} catch (IOException e) {
U.error(log, "Failed to send error response to client.", e);
}
}
/**
* Processes cache query response.
*
* @param sndId Sender node id.
* @param res Query response.
*/
@SuppressWarnings("unchecked")
private void processQueryResponse(UUID sndId, GridCacheQueryResponse res) {
if (log.isDebugEnabled()) log.debug("Received query response: " + res);
GridCacheQueryFutureAdapter fut = getQueryFuture(res.requestId());
if (fut != null)
if (res.fields())
((GridCacheDistributedFieldsQueryFuture) fut)
.onPage(
sndId,
res.metadata(),
(Collection<Map<String, Object>>) ((Collection) res.data()),
res.error(),
res.isFinished());
else fut.onPage(sndId, res.data(), res.error(), res.isFinished());
else if (!cancelled.contains(res.requestId()))
U.warn(
log,
"Received response for finished or unknown query [rmtNodeId="
+ sndId
+ ", res="
+ res
+ ']');
}
/** {@inheritDoc} */
@Override
public void start() throws IgniteCheckedException {
IpcSharedMemoryNativeLoader.load(log);
pid = IpcSharedMemoryUtils.pid();
if (pid == -1) throw new IpcEndpointBindException("Failed to get PID of the current process.");
if (size <= 0) throw new IpcEndpointBindException("Space size should be positive: " + size);
String tokDirPath = this.tokDirPath;
if (F.isEmpty(tokDirPath)) throw new IpcEndpointBindException("Token directory path is empty.");
tokDirPath = tokDirPath + '/' + locNodeId.toString() + '-' + IpcSharedMemoryUtils.pid();
tokDir = U.resolveWorkDirectory(tokDirPath, false);
if (port <= 0 || port >= 0xffff)
throw new IpcEndpointBindException("Port value is illegal: " + port);
try {
srvSock = new ServerSocket();
// Always bind to loopback.
srvSock.bind(new InetSocketAddress("127.0.0.1", port));
} catch (IOException e) {
// Although empty socket constructor never throws exception, close it just in case.
U.closeQuiet(srvSock);
throw new IpcEndpointBindException(
"Failed to bind shared memory IPC endpoint (is port already " + "in use?): " + port, e);
}
gcWorker = new GcWorker(gridName, "ipc-shmem-gc", log);
new IgniteThread(gcWorker).start();
if (log.isInfoEnabled())
log.info(
"IPC shared memory server endpoint started [port="
+ port
+ ", tokDir="
+ tokDir.getAbsolutePath()
+ ']');
}
/**
* Log finished.
*
* @param log Logger.
* @param clazz Class.
* @param start Start time.
*/
public static void logFinish(@Nullable IgniteLogger log, Class<?> clazz, long start) {
final long end = U.currentTimeMillis();
log0(
log,
end,
String.format(
"[%s]: FINISHED, duration: %s", clazz.getSimpleName(), formatDuration(end - start)));
}
/** @throws Exception if error occur. */
@SuppressWarnings("unchecked")
private void checkGar() throws Exception {
initGar = true;
String garDir = "modules/extdata/p2p/deploy";
String garFileName = "p2p.gar";
File origGarPath = U.resolveIgnitePath(garDir + '/' + garFileName);
File tmpPath = new File(System.getProperty("java.io.tmpdir"), UUID.randomUUID().toString());
if (!tmpPath.mkdir()) throw new IOException("Can not create temp directory");
try {
File newGarFile = new File(tmpPath, garFileName);
U.copy(origGarPath, newGarFile, false);
assert newGarFile.exists();
try {
garFile = "file:///" + tmpPath.getAbsolutePath();
try {
Ignite ignite1 = startGrid(1);
Ignite ignite2 = startGrid(2);
Integer res =
ignite1
.compute()
.<UUID, Integer>execute(TASK_NAME, ignite2.cluster().localNode().id());
assert res != null;
} finally {
stopGrid(1);
stopGrid(2);
}
} finally {
if (newGarFile != null && !newGarFile.delete()) error("Can not delete temp gar file");
}
} finally {
if (!tmpPath.delete()) error("Can not delete temp directory");
}
}
/** Perform cleanup of the trash directory. */
private void delete() {
IgfsFileInfo info = null;
try {
info = meta.info(TRASH_ID);
} catch (ClusterTopologyServerNotFoundException e) {
LT.warn(log, e, "Server nodes not found.");
} catch (IgniteCheckedException e) {
U.error(log, "Cannot obtain trash directory info.", e);
}
if (info != null) {
for (Map.Entry<String, IgfsListingEntry> entry : info.listing().entrySet()) {
IgniteUuid fileId = entry.getValue().fileId();
if (log.isDebugEnabled())
log.debug(
"Deleting IGFS trash entry [name=" + entry.getKey() + ", fileId=" + fileId + ']');
try {
if (!cancelled) {
if (delete(entry.getKey(), fileId)) {
if (log.isDebugEnabled())
log.debug(
"Sending delete confirmation message [name="
+ entry.getKey()
+ ", fileId="
+ fileId
+ ']');
sendDeleteMessage(new IgfsDeleteMessage(fileId));
}
} else break;
} catch (IgniteInterruptedCheckedException ignored) {
// Ignore this exception while stopping.
} catch (IgniteCheckedException e) {
U.error(log, "Failed to delete entry from the trash directory: " + entry.getKey(), e);
sendDeleteMessage(new IgfsDeleteMessage(fileId, e));
}
}
}
}
/**
* Log message.
*
* @param log Logger.
* @param msg Message to log.
* @param clazz class.
* @param start start time.
* @return Time when message was logged.
*/
public static long log(@Nullable IgniteLogger log, String msg, Class<?> clazz, long start) {
final long end = U.currentTimeMillis();
log0(
log,
end,
String.format(
"[%s]: %s, duration: %s", clazz.getSimpleName(), msg, formatDuration(end - start)));
return end;
}
/**
* Load grid configuration for specified node type.
*
* @param type Node type to load configuration for.
* @return Grid configuration for specified node type.
*/
static IgniteConfiguration getConfig(String type) {
String path = NODE_CFG.get(type);
if (path == null) throw new IllegalArgumentException("Unsupported node type: " + type);
URL url = U.resolveIgniteUrl(path);
BeanFactory ctx = new FileSystemXmlApplicationContext(url.toString());
return (IgniteConfiguration) ctx.getBean("grid.cfg");
}
/**
* @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()));
}
/**
* Returns compact class host.
*
* @param obj Object to compact.
* @return String.
*/
@Nullable
public static Object compactObject(Object obj) {
if (obj == null) return null;
if (obj instanceof Enum) return obj.toString();
if (obj instanceof String || obj instanceof Boolean || obj instanceof Number) return obj;
if (obj instanceof Collection) {
Collection col = (Collection) obj;
Object[] res = new Object[col.size()];
int i = 0;
for (Object elm : col) res[i++] = compactObject(elm);
return res;
}
if (obj.getClass().isArray()) {
Class<?> arrType = obj.getClass().getComponentType();
if (arrType.isPrimitive()) {
if (obj instanceof boolean[]) return Arrays.toString((boolean[]) obj);
if (obj instanceof byte[]) return Arrays.toString((byte[]) obj);
if (obj instanceof short[]) return Arrays.toString((short[]) obj);
if (obj instanceof int[]) return Arrays.toString((int[]) obj);
if (obj instanceof long[]) return Arrays.toString((long[]) obj);
if (obj instanceof float[]) return Arrays.toString((float[]) obj);
if (obj instanceof double[]) return Arrays.toString((double[]) obj);
}
Object[] arr = (Object[]) obj;
int iMax = arr.length - 1;
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i <= iMax; i++) {
sb.append(compactObject(arr[i]));
if (i != iMax) sb.append(", ");
}
sb.append("]");
return sb.toString();
}
return U.compact(obj.getClass().getName());
}
/** {@inheritDoc} */
@Override
public void close() {
closed = true;
U.closeQuiet(srvSock);
if (gcWorker != null) {
U.cancel(gcWorker);
// This method may be called from already interrupted thread.
// Need to ensure cleaning on close.
boolean interrupted = Thread.interrupted();
try {
U.join(gcWorker);
} catch (IgniteInterruptedCheckedException e) {
U.warn(log, "Interrupted when stopping GC worker.", e);
} finally {
if (interrupted) Thread.currentThread().interrupt();
}
}
}
/** {@inheritDoc} */
@Override
public void onDiscoveryDataReceived(UUID nodeId, UUID rmtNodeId, Serializable data) {
Map<String, Serializable> discData = (Map<String, Serializable>) data;
if (discData != null) {
for (Map.Entry<String, Serializable> e : discData.entrySet()) {
PluginProvider provider = plugins.get(e.getKey());
if (provider != null) provider.receiveDiscoveryData(nodeId, e.getValue());
else U.warn(log, "Received discovery data for unknown plugin: " + e.getKey());
}
}
}
/**
* Notifies single listener.
*
* @param lsnr Listener.
*/
private void notifyListener(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr) {
assert lsnr != null;
try {
lsnr.apply(this);
} catch (IllegalStateException e) {
U.error(
null,
"Failed to notify listener (is grid stopped?) [fut="
+ this
+ ", lsnr="
+ lsnr
+ ", err="
+ e.getMessage()
+ ']',
e);
} catch (RuntimeException | Error e) {
U.error(null, "Failed to notify listener: " + lsnr, e);
throw e;
}
}
/**
* Run command in separated console.
*
* @param workFolder Work folder for command.
* @param args A string array containing the program and its arguments.
* @return Started process.
* @throws IOException If failed to start process.
*/
public static Process openInConsole(@Nullable File workFolder, String... args)
throws IOException {
String[] commands = args;
String cmd = F.concat(Arrays.asList(args), " ");
if (U.isWindows()) commands = F.asArray("cmd", "/c", String.format("start %s", cmd));
if (U.isMacOs())
commands =
F.asArray(
"osascript",
"-e",
String.format("tell application \"Terminal\" to do script \"%s\"", cmd));
if (U.isUnix()) commands = F.asArray("xterm", "-sl", "1024", "-geometry", "200x50", "-e", cmd);
ProcessBuilder pb = new ProcessBuilder(commands);
if (workFolder != null) pb.directory(workFolder);
return pb.start();
}
/**
* @param nanosTimeout Timeout (nanoseconds).
* @return Result.
* @throws InterruptedException If interrupted.
* @throws IgniteFutureTimeoutCheckedException If timeout reached before computation completed.
* @throws IgniteCheckedException If error occurred.
*/
@Nullable
protected R get0(long nanosTimeout) throws InterruptedException, IgniteCheckedException {
if (endTime == 0 && !tryAcquireSharedNanos(0, nanosTimeout))
throw new IgniteFutureTimeoutCheckedException(
"Timeout was reached before computation completed.");
if (getState() == CANCELLED)
throw new IgniteFutureCancelledCheckedException("Future was cancelled: " + this);
assert resFlag != 0;
if (resFlag == ERR) throw U.cast((Throwable) res);
return (R) res;
}
