/**
* Change topology.
*
* @param parent Grid to execute tasks on.
* @param add New nodes count.
* @param rmv Remove nodes count.
* @param type Type of nodes to manipulate.
*/
private static void changeTopology(Ignite parent, int add, int rmv, String type) {
Collection<ComputeTaskFuture<?>> tasks = new ArrayList<>();
IgniteCompute comp = parent.compute().withAsync();
// Start nodes in parallel.
while (add-- > 0) {
comp.execute(ClientStartNodeTask.class, type);
tasks.add(comp.future());
}
for (ComputeTaskFuture<?> task : tasks) task.get();
// Stop nodes in sequence.
while (rmv-- > 0) parent.compute().execute(ClientStopNodeTask.class, type);
// Wait for node stops.
// U.sleep(1000);
Collection<String> gridNames = new ArrayList<>();
for (Ignite g : G.allGrids()) gridNames.add(g.name());
parent.log().info(">>> Available grids: " + gridNames);
}
/**
* @param key Key to add to read set.
* @param val Value.
* @param drVer Data center replication version.
* @param skipStore Skip store flag.
* @throws IgniteCheckedException If failed.
* @return {@code True} if entry has been enlisted.
*/
public boolean addEntry(
GridCacheContext cacheCtx,
IgniteTxKey key,
GridCacheOperation op,
CacheObject val,
@Nullable GridCacheVersion drVer,
boolean skipStore)
throws IgniteCheckedException {
checkInternal(key);
GridNearCacheEntry cached = cacheCtx.near().peekExx(key.key());
try {
if (cached == null) {
evicted.add(key);
return false;
} else {
cached.unswap();
CacheObject peek = cached.peek(true, false, false, null);
if (peek == null && cached.evictInternal(false, xidVer, null)) {
cached.context().cache().removeIfObsolete(key.key());
evicted.add(key);
return false;
} else {
IgniteTxEntry txEntry =
new IgniteTxEntry(cacheCtx, this, op, val, -1L, -1L, cached, drVer, skipStore);
writeMap.put(key, txEntry);
return true;
}
}
} catch (GridCacheEntryRemovedException ignore) {
evicted.add(key);
if (log.isDebugEnabled())
log.debug(
"Got removed entry when adding reads to remote transaction (will ignore): " + cached);
return false;
}
}
/**
* Sends query request.
*
* @param fut Distributed future.
* @param req Request.
* @param nodes Nodes.
* @throws IgniteCheckedException In case of error.
*/
@SuppressWarnings("unchecked")
private void sendRequest(
final GridCacheDistributedQueryFuture<?, ?, ?> fut,
final GridCacheQueryRequest req,
Collection<ClusterNode> nodes)
throws IgniteCheckedException {
assert fut != null;
assert req != null;
assert nodes != null;
final UUID locNodeId = cctx.localNodeId();
ClusterNode locNode = null;
Collection<ClusterNode> rmtNodes = null;
for (ClusterNode n : nodes) {
if (n.id().equals(locNodeId)) locNode = n;
else {
if (rmtNodes == null) rmtNodes = new ArrayList<>(nodes.size());
rmtNodes.add(n);
}
}
// Request should be sent to remote nodes before the query is processed on the local node.
// For example, a remote reducer has a state, we should not serialize and then send
// the reducer changed by the local node.
if (!F.isEmpty(rmtNodes)) {
cctx.io()
.safeSend(
rmtNodes,
req,
cctx.ioPolicy(),
new P1<ClusterNode>() {
@Override
public boolean apply(ClusterNode node) {
fut.onNodeLeft(node.id());
return !fut.isDone();
}
});
}
if (locNode != null) {
cctx.closures()
.callLocalSafe(
new Callable<Object>() {
@Override
public Object call() throws Exception {
req.beforeLocalExecution(cctx);
processQueryRequest(locNodeId, req);
return null;
}
});
}
}
/** {@inheritDoc} */
@Override
public synchronized Iterable<String> getGroupNames() {
Collection<String> res = new HashSet<>();
for (HadoopCounter counter : cntrs.values()) res.add(counter.group());
return res;
}
/**
* Returns counters iterator for specified group.
*
* @param grpName Name of the group to iterate.
* @return Counters iterator.
*/
public Iterator<Counter> iterateGroup(String grpName) {
Collection<Counter> grpCounters = new ArrayList<>();
for (HadoopLongCounter counter : cntrs.values()) {
if (grpName.equals(counter.group())) grpCounters.add(new HadoopV2Counter(counter));
}
return grpCounters.iterator();
}
/**
* @param entry Entry to enlist.
* @throws IgniteCheckedException If failed.
* @return {@code True} if entry was enlisted.
*/
private boolean addEntry(IgniteTxEntry entry) throws IgniteCheckedException {
checkInternal(entry.txKey());
GridCacheContext cacheCtx = entry.context();
if (!cacheCtx.isNear()) cacheCtx = cacheCtx.dht().near().context();
GridNearCacheEntry cached = cacheCtx.near().peekExx(entry.key());
if (cached == null) {
evicted.add(entry.txKey());
return false;
} else {
cached.unswap();
try {
CacheObject val = cached.peek(true, false, false, null);
if (val == null && cached.evictInternal(false, xidVer, null)) {
evicted.add(entry.txKey());
return false;
} else {
// Initialize cache entry.
entry.cached(cached);
writeMap.put(entry.txKey(), entry);
addExplicit(entry);
return true;
}
} catch (GridCacheEntryRemovedException ignore) {
evicted.add(entry.txKey());
if (log.isDebugEnabled())
log.debug("Got removed entry when adding to remote transaction (will ignore): " + cached);
return false;
}
}
}
/** {@inheritDoc} */
@Override
public Collection<? extends ComputeJob> split(int gridSize, Serializable arg) {
if (log.isInfoEnabled())
log.info("Splitting task [task=" + this + ", gridSize=" + gridSize + ", arg=" + arg + ']');
Collection<GridCancelTestJob> jobs = new ArrayList<>(SPLIT_COUNT);
for (int i = 0; i < SPLIT_COUNT; i++) jobs.add(new GridCancelTestJob());
return jobs;
}
/** {@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();
}
}
/**
* Processes cache query request.
*
* @param sndId Sender node id.
* @param req Query request.
*/
@SuppressWarnings("unchecked")
@Override
void processQueryRequest(UUID sndId, GridCacheQueryRequest req) {
if (req.cancel()) {
cancelIds.add(new CancelMessageId(req.id(), sndId));
if (req.fields()) removeFieldsQueryResult(sndId, req.id());
else removeQueryResult(sndId, req.id());
} else {
if (!cancelIds.contains(new CancelMessageId(req.id(), sndId))) {
if (!F.eq(req.cacheName(), cctx.name())) {
GridCacheQueryResponse res =
new GridCacheQueryResponse(
cctx.cacheId(),
req.id(),
new IgniteCheckedException(
"Received request for incorrect cache [expected="
+ cctx.name()
+ ", actual="
+ req.cacheName()));
sendQueryResponse(sndId, res, 0);
} else {
threads.put(req.id(), Thread.currentThread());
try {
GridCacheQueryInfo info = distributedQueryInfo(sndId, req);
if (info == null) return;
if (req.fields()) runFieldsQuery(info);
else runQuery(info);
} catch (Throwable e) {
U.error(log(), "Failed to run query.", e);
sendQueryResponse(
sndId, new GridCacheQueryResponse(cctx.cacheId(), req.id(), e.getCause()), 0);
if (e instanceof Error) throw (Error) e;
} finally {
threads.remove(req.id());
}
}
}
}
}
/**
* Decode file charset.
*
* @param f File to process.
* @return File charset.
* @throws IOException in case of error.
*/
public static Charset decode(File f) throws IOException {
SortedMap<String, Charset> charsets = Charset.availableCharsets();
String[] firstCharsets = {
Charset.defaultCharset().name(), "US-ASCII", "UTF-8", "UTF-16BE", "UTF-16LE"
};
Collection<Charset> orderedCharsets = U.newLinkedHashSet(charsets.size());
for (String c : firstCharsets)
if (charsets.containsKey(c)) orderedCharsets.add(charsets.get(c));
orderedCharsets.addAll(charsets.values());
try (RandomAccessFile raf = new RandomAccessFile(f, "r")) {
FileChannel ch = raf.getChannel();
ByteBuffer buf = ByteBuffer.allocate(4096);
ch.read(buf);
buf.flip();
for (Charset charset : orderedCharsets) {
CharsetDecoder decoder = charset.newDecoder();
decoder.reset();
try {
decoder.decode(buf);
return charset;
} catch (CharacterCodingException ignored) {
}
}
}
return Charset.defaultCharset();
}
/** @throws Exception Thrown if test failed. */
public void testA() throws Exception {
Collection<Integer> set = new GridConcurrentWeakHashSet<>();
Integer i = 1;
assert set.add(i);
assert !set.add(i);
assert set.contains(i);
assert set.size() == 1;
Collection<Integer> c = F.asList(2, 3, 4, 5);
assert set.addAll(c);
assert !set.addAll(c);
assert set.containsAll(c);
assert set.size() == 1 + c.size();
assert set.remove(i);
assert !set.remove(i);
assert !set.contains(i);
assert set.size() == c.size();
assert set.removeAll(c);
assert !set.removeAll(c);
assert !set.containsAll(c);
assert set.isEmpty();
Collection<Integer> c1 = Arrays.asList(1, 3, 5, 7, 9);
int cnt = 0;
for (Iterator<Integer> iter = set.iterator(); iter.hasNext(); cnt++) c1.contains(iter.next());
assert set.size() == cnt;
assert set.size() == set.toArray().length;
assert set.addAll(c1);
assert set.retainAll(c);
assert !set.retainAll(c);
Collection<Integer> c2 = F.retain(c1, true, c);
assert set.containsAll(c2);
assert !set.containsAll(c1);
assert !set.containsAll(c);
assert set.size() == c2.size();
set.clear();
assert set.isEmpty();
try {
set.iterator().next();
assert false;
} catch (NoSuchElementException ignored) {
assert true;
}
try {
set.add(null);
assert false;
} catch (NullPointerException ignored) {
assert true;
}
}
/** @throws Exception Thrown if test failed. */
@SuppressWarnings({"UnusedAssignment"})
public void testB() throws Exception {
Collection<SampleBean> set = new GridConcurrentWeakHashSet<>();
SampleBean bean1 = new SampleBean(1);
assert set.add(bean1);
assert !set.add(bean1);
assert set.size() == 1;
assert set.contains(bean1);
bean1 = null;
gc();
assert set.isEmpty();
Collection<SampleBean> c =
F.asList(new SampleBean(1), new SampleBean(2), new SampleBean(3), new SampleBean(4));
assert set.addAll(c);
assert !set.addAll(c);
assert set.size() == c.size();
assert set.containsAll(c);
c = null;
gc();
assert set.isEmpty();
SampleBean b1 = new SampleBean(1);
SampleBean b2 = new SampleBean(2);
SampleBean b3 = new SampleBean(3);
SampleBean b4 = new SampleBean(4);
SampleBean b5 = new SampleBean(5);
set.add(b1);
set.add(b2);
set.add(b3);
set.add(b4);
set.add(b5);
Iterator iter = set.iterator();
assert iter.hasNext();
b2 = null;
b3 = null;
b4 = null;
gc();
int cnt = 0;
while (iter.hasNext()) {
info(iter.next().toString());
cnt++;
}
assert set.size() == cnt;
}
/** {@inheritDoc} */
@SuppressWarnings("ErrorNotRethrown")
@Override
public IpcEndpoint accept() throws IgniteCheckedException {
while (!Thread.currentThread().isInterrupted()) {
Socket sock = null;
boolean accepted = false;
try {
sock = srvSock.accept();
accepted = true;
InputStream inputStream = sock.getInputStream();
ObjectInputStream in = new ObjectInputStream(inputStream);
ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
IpcSharedMemorySpace inSpace = null;
IpcSharedMemorySpace outSpace = null;
boolean err = true;
try {
IpcSharedMemoryInitRequest req = (IpcSharedMemoryInitRequest) in.readObject();
if (log.isDebugEnabled()) log.debug("Processing request: " + req);
IgnitePair<String> p = inOutToken(req.pid(), size);
String file1 = p.get1();
String file2 = p.get2();
assert file1 != null;
assert file2 != null;
// Create tokens.
new File(file1).createNewFile();
new File(file2).createNewFile();
if (log.isDebugEnabled()) log.debug("Created token files: " + p);
inSpace = new IpcSharedMemorySpace(file1, req.pid(), pid, size, true, log);
outSpace = new IpcSharedMemorySpace(file2, pid, req.pid(), size, false, log);
IpcSharedMemoryClientEndpoint ret =
new IpcSharedMemoryClientEndpoint(inSpace, outSpace, log);
out.writeObject(
new IpcSharedMemoryInitResponse(
file2, outSpace.sharedMemoryId(), file1, inSpace.sharedMemoryId(), pid, size));
err = !in.readBoolean();
endpoints.add(ret);
return ret;
} catch (UnsatisfiedLinkError e) {
throw IpcSharedMemoryUtils.linkError(e);
} catch (IOException e) {
if (log.isDebugEnabled())
log.debug(
"Failed to process incoming connection "
+ "(was connection closed by another party):"
+ e.getMessage());
} catch (ClassNotFoundException e) {
U.error(log, "Failed to process incoming connection.", e);
} catch (ClassCastException e) {
String msg =
"Failed to process incoming connection (most probably, shared memory "
+ "rest endpoint has been configured by mistake).";
LT.warn(log, null, msg);
sendErrorResponse(out, e);
} catch (IpcOutOfSystemResourcesException e) {
if (!omitOutOfResourcesWarn) LT.warn(log, null, OUT_OF_RESOURCES_MSG);
sendErrorResponse(out, e);
} catch (IgniteCheckedException e) {
LT.error(log, e, "Failed to process incoming shared memory connection.");
sendErrorResponse(out, e);
} finally {
// Exception has been thrown, need to free system resources.
if (err) {
if (inSpace != null) inSpace.forceClose();
// Safety.
if (outSpace != null) outSpace.forceClose();
}
}
} catch (IOException e) {
if (!Thread.currentThread().isInterrupted() && !accepted)
throw new IgniteCheckedException("Failed to accept incoming connection.", e);
if (!closed)
LT.error(
log, null, "Failed to process incoming shared memory connection: " + e.getMessage());
} finally {
U.closeQuiet(sock);
}
} // while
throw new IgniteInterruptedCheckedException("Socket accept was interrupted.");
}
/**
* Grabs local events and detects if events was lost since last poll.
*
* @param ignite Target grid.
* @param evtOrderKey Unique key to take last order key from node local map.
* @param evtThrottleCntrKey Unique key to take throttle count from node local map.
* @param evtTypes Event types to collect.
* @param evtMapper Closure to map grid events to Visor data transfer objects.
* @return Collections of node events
*/
public static Collection<VisorGridEvent> collectEvents(
Ignite ignite,
String evtOrderKey,
String evtThrottleCntrKey,
final int[] evtTypes,
IgniteClosure<Event, VisorGridEvent> evtMapper) {
assert ignite != null;
assert evtTypes != null && evtTypes.length > 0;
ConcurrentMap<String, Long> nl = ignite.cluster().nodeLocalMap();
final long lastOrder = getOrElse(nl, evtOrderKey, -1L);
final long throttle = getOrElse(nl, evtThrottleCntrKey, 0L);
// When we first time arrive onto a node to get its local events,
// we'll grab only last those events that not older than given period to make sure we are
// not grabbing GBs of data accidentally.
final long notOlderThan = System.currentTimeMillis() - EVENTS_COLLECT_TIME_WINDOW;
// Flag for detecting gaps between events.
final AtomicBoolean lastFound = new AtomicBoolean(lastOrder < 0);
IgnitePredicate<Event> p =
new IgnitePredicate<Event>() {
/** */
private static final long serialVersionUID = 0L;
@Override
public boolean apply(Event e) {
// Detects that events were lost.
if (!lastFound.get() && (lastOrder == e.localOrder())) lastFound.set(true);
// Retains events by lastOrder, period and type.
return e.localOrder() > lastOrder
&& e.timestamp() > notOlderThan
&& F.contains(evtTypes, e.type());
}
};
Collection<Event> evts = ignite.events().localQuery(p);
// Update latest order in node local, if not empty.
if (!evts.isEmpty()) {
Event maxEvt = Collections.max(evts, EVTS_ORDER_COMPARATOR);
nl.put(evtOrderKey, maxEvt.localOrder());
}
// Update throttle counter.
if (!lastFound.get())
nl.put(evtThrottleCntrKey, throttle == 0 ? EVENTS_LOST_THROTTLE : throttle - 1);
boolean lost = !lastFound.get() && throttle == 0;
Collection<VisorGridEvent> res = new ArrayList<>(evts.size() + (lost ? 1 : 0));
if (lost) res.add(new VisorGridEventsLost(ignite.cluster().localNode().id()));
for (Event e : evts) {
VisorGridEvent visorEvt = evtMapper.apply(e);
if (visorEvt != null) res.add(visorEvt);
}
return res;
}
/**
* Adds evicted key bytes to evicted collection.
*
* @param key Evicted key.
*/
public void addEvicted(IgniteTxKey key) {
evicted.add(key);
}
/** {@inheritDoc} */
@Override
void onQueryFutureCanceled(long reqId) {
cancelled.add(reqId);
}
/**
* Load client configuration from the properties map.
*
* @param prefix Prefix for the client properties.
* @param in Properties map to load configuration from.
* @throws GridClientException If parsing configuration failed.
*/
public void load(String prefix, Properties in) throws GridClientException {
while (prefix.endsWith(".")) prefix = prefix.substring(0, prefix.length() - 1);
if (!prefix.isEmpty()) prefix += ".";
String balancer = in.getProperty(prefix + "balancer");
String connectTimeout = in.getProperty(prefix + "connectTimeout");
String cred = in.getProperty(prefix + "credentials");
String autoFetchMetrics = in.getProperty(prefix + "autoFetchMetrics");
String autoFetchAttrs = in.getProperty(prefix + "autoFetchAttributes");
String maxConnIdleTime = in.getProperty(prefix + "idleTimeout");
String proto = in.getProperty(prefix + "protocol");
String srvrs = in.getProperty(prefix + "servers");
String tcpNoDelay = in.getProperty(prefix + "tcp.noDelay");
String topRefreshFreq = in.getProperty(prefix + "topology.refresh");
String sslEnabled = in.getProperty(prefix + "ssl.enabled");
String sslProto = in.getProperty(prefix + "ssl.protocol", "TLS");
String sslKeyAlg = in.getProperty(prefix + "ssl.key.algorithm", "SunX509");
String keyStorePath = in.getProperty(prefix + "ssl.keystore.location");
String keyStorePwd = in.getProperty(prefix + "ssl.keystore.password");
String keyStoreType = in.getProperty(prefix + "ssl.keystore.type");
String trustStorePath = in.getProperty(prefix + "ssl.truststore.location");
String trustStorePwd = in.getProperty(prefix + "ssl.truststore.password");
String trustStoreType = in.getProperty(prefix + "ssl.truststore.type");
String dataCfgs = in.getProperty(prefix + "data.configurations");
setBalancer(resolveBalancer(balancer));
if (!F.isEmpty(connectTimeout)) setConnectTimeout(Integer.parseInt(connectTimeout));
if (!F.isEmpty(cred)) {
int idx = cred.indexOf(':');
if (idx >= 0 && idx < cred.length() - 1) {
setSecurityCredentialsProvider(
new SecurityCredentialsBasicProvider(
new SecurityCredentials(cred.substring(0, idx), cred.substring(idx + 1))));
} else {
setSecurityCredentialsProvider(
new SecurityCredentialsBasicProvider(new SecurityCredentials(null, null, cred)));
}
}
if (!F.isEmpty(autoFetchMetrics)) setAutoFetchMetrics(Boolean.parseBoolean(autoFetchMetrics));
if (!F.isEmpty(autoFetchAttrs)) setAutoFetchAttributes(Boolean.parseBoolean(autoFetchAttrs));
if (!F.isEmpty(maxConnIdleTime)) setMaxConnectionIdleTime(Integer.parseInt(maxConnIdleTime));
if (!F.isEmpty(proto)) setProtocol(GridClientProtocol.valueOf(proto));
if (!F.isEmpty(srvrs)) setServers(Arrays.asList(srvrs.replaceAll("\\s+", "").split(",")));
if (!F.isEmpty(tcpNoDelay)) setTcpNoDelay(Boolean.parseBoolean(tcpNoDelay));
if (!F.isEmpty(topRefreshFreq)) setTopologyRefreshFrequency(Long.parseLong(topRefreshFreq));
//
// SSL configuration section
//
if (!F.isEmpty(sslEnabled) && Boolean.parseBoolean(sslEnabled)) {
GridSslBasicContextFactory factory = new GridSslBasicContextFactory();
factory.setProtocol(F.isEmpty(sslProto) ? "TLS" : sslProto);
factory.setKeyAlgorithm(F.isEmpty(sslKeyAlg) ? "SunX509" : sslKeyAlg);
if (F.isEmpty(keyStorePath))
throw new IllegalArgumentException("SSL key store location is not specified.");
factory.setKeyStoreFilePath(keyStorePath);
if (keyStorePwd != null) factory.setKeyStorePassword(keyStorePwd.toCharArray());
factory.setKeyStoreType(F.isEmpty(keyStoreType) ? "jks" : keyStoreType);
if (F.isEmpty(trustStorePath))
factory.setTrustManagers(GridSslBasicContextFactory.getDisabledTrustManager());
else {
factory.setTrustStoreFilePath(trustStorePath);
if (trustStorePwd != null) factory.setTrustStorePassword(trustStorePwd.toCharArray());
factory.setTrustStoreType(F.isEmpty(trustStoreType) ? "jks" : trustStoreType);
}
setSslContextFactory(factory);
}
//
// Data configuration section
//
if (!F.isEmpty(dataCfgs)) {
String[] names = dataCfgs.replaceAll("\\s+", "").split(",");
Collection<GridClientDataConfiguration> list = new ArrayList<>();
for (String cfgName : names) {
if (F.isEmpty(cfgName)) continue;
String name = in.getProperty(prefix + "data." + cfgName + ".name");
String bal = in.getProperty(prefix + "data." + cfgName + ".balancer");
String aff = in.getProperty(prefix + "data." + cfgName + ".affinity");
GridClientDataConfiguration dataCfg = new GridClientDataConfiguration();
dataCfg.setName(F.isEmpty(name) ? null : name);
dataCfg.setBalancer(resolveBalancer(bal));
dataCfg.setAffinity(resolveAffinity(aff));
list.add(dataCfg);
}
setDataConfigurations(list);
}
}