/*
* Launches against the agent& main
*/
public void testAgentAndMain() throws Exception {
Project project = workspace.getProject("p1");
Run bndrun = new Run(workspace, project.getBase(), project.getFile("one.bndrun"));
bndrun.setProperty("-runpath", "biz.aQute.remote.launcher");
bndrun.setProperty("-runbundles", "bsn-1,bsn-2");
bndrun.setProperty("-runremote", "agent,main;agent=1090");
final RemoteProjectLauncherPlugin pl =
(RemoteProjectLauncherPlugin) bndrun.getProjectLauncher();
pl.prepare();
List<? extends RunSession> sessions = pl.getRunSessions();
assertEquals(2, sessions.size());
RunSession agent = sessions.get(0);
RunSession main = sessions.get(1);
CountDownLatch agentLatch = launch(agent);
CountDownLatch mainLatch = launch(main);
agent.waitTillStarted(1000);
main.waitTillStarted(1000);
Thread.sleep(500);
agent.cancel();
main.cancel();
agentLatch.await();
mainLatch.await();
assertEquals(-3, agent.getExitCode());
assertEquals(-3, main.getExitCode());
bndrun.close();
}
/**
* Increases priority if job has bumped down.
*
* @param waitJobs Ordered collection of collision contexts for jobs that are currently waiting
* for execution.
* @param passiveJobs Reordered collection of collision contexts for waiting jobs.
*/
private void bumpPriority(
Collection<GridCollisionJobContext> waitJobs, List<GridCollisionJobContext> passiveJobs) {
assert waitJobs != null;
assert passiveJobs != null;
assert waitJobs.size() == passiveJobs.size();
for (int i = 0; i < passiveJobs.size(); i++) {
GridCollisionJobContext ctx = passiveJobs.get(i);
if (i > indexOf(waitJobs, ctx))
ctx.getJobContext().setAttribute(jobAttrKey, getJobPriority(ctx) + starvationInc);
}
}
public static void main(String[] args) {
// Generics, varargs & boxing working together:
List<Integer> li = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
Integer result = reduce(li, new IntegerAdder());
print(result);
result = reduce(li, new IntegerSubtracter());
print(result);
print(filter(li, new GreaterThan<Integer>(4)));
print(forEach(li, new MultiplyingIntegerCollector()).result());
print(
forEach(filter(li, new GreaterThan<Integer>(4)), new MultiplyingIntegerCollector())
.result());
MathContext mc = new MathContext(7);
List<BigDecimal> lbd =
Arrays.asList(
new BigDecimal(1.1, mc),
new BigDecimal(2.2, mc),
new BigDecimal(3.3, mc),
new BigDecimal(4.4, mc));
BigDecimal rbd = reduce(lbd, new BigDecimalAdder());
print(rbd);
print(filter(lbd, new GreaterThan<BigDecimal>(new BigDecimal(3))));
// Use the prime-generation facility of BigInteger:
List<BigInteger> lbi = new ArrayList<BigInteger>();
BigInteger bi = BigInteger.valueOf(11);
for (int i = 0; i < 11; i++) {
lbi.add(bi);
bi = bi.nextProbablePrime();
}
print(lbi);
BigInteger rbi = reduce(lbi, new BigIntegerAdder());
print(rbi);
// The sum of this list of primes is also prime:
print(rbi.isProbablePrime(5));
List<AtomicLong> lal =
Arrays.asList(
new AtomicLong(11), new AtomicLong(47), new AtomicLong(74), new AtomicLong(133));
AtomicLong ral = reduce(lal, new AtomicLongAdder());
print(ral);
print(transform(lbd, new BigDecimalUlp()));
}
/*
* Launches against the agent
*/
public void testSimpleLauncher() throws Exception {
Project project = workspace.getProject("p1");
Run bndrun = new Run(workspace, project.getBase(), project.getFile("one.bndrun"));
bndrun.setProperty("-runpath", "biz.aQute.remote.launcher");
bndrun.setProperty("-runbundles", "bsn-1,bsn-2");
bndrun.setProperty("-runremote", "test");
final RemoteProjectLauncherPlugin pl =
(RemoteProjectLauncherPlugin) bndrun.getProjectLauncher();
pl.prepare();
final CountDownLatch latch = new CountDownLatch(1);
final AtomicInteger exitCode = new AtomicInteger(-1);
List<? extends RunSession> sessions = pl.getRunSessions();
assertEquals(1, sessions.size());
final RunSession session = sessions.get(0);
Thread t =
new Thread("test-launch") {
public void run() {
try {
exitCode.set(session.launch());
} catch (Exception e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}
};
t.start();
Thread.sleep(500);
for (Bundle b : context.getBundles()) {
System.out.println(b.getLocation());
}
assertEquals(4, context.getBundles().length);
String p1 = t1.getAbsolutePath();
System.out.println(p1);
assertNotNull(context.getBundle(p1));
assertNotNull(context.getBundle(t2.getAbsolutePath()));
pl.cancel();
latch.await();
assertEquals(-3, exitCode.get());
bndrun.close();
}
/*
* Update of user tree for ordered menu nodes (favorites, create new list)
* favorites @param menuIDs List<Integer> ordered list of menuIDs to put in
* the tree @param menuTree MTree the tree to be reordered @return true if
* updated
*/
private boolean updateUserTree(List<Integer> menuIDs, MTree menuTree) {
CTreeNode root = menuTree.getRoot();
if (root != null) {
Enumeration<?> nodes = root.preorderEnumeration();
while (nodes.hasMoreElements()) {
CTreeNode nd = (CTreeNode) nodes.nextElement();
if (!menuIDs.contains(nd.getNode_ID())) {
MTreeNodeMM node = null;
if ((node = MTreeNodeMM.get(menuTree, nd.getNode_ID())) != null) {
if (!node.delete(true)) return false;
}
}
}
}
int seq = 0;
for (int id : menuIDs) {
MTreeNodeMM node = null;
if ((node = MTreeNodeMM.get(menuTree, id)) == null) {
node = new MTreeNodeMM(menuTree, id);
}
node.setSeqNo(++seq);
if (!node.save()) return false;
}
return true;
}
/**
* 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));
}
@Override
public void onError(Throwable e) {
Object[] active;
synchronized (subscribers) {
active = subscribers.toArray();
subscribers.clear();
}
try {
s.onError(e);
unsubscribe();
} finally {
for (Object o : active) {
@SuppressWarnings("unchecked")
MergeItemSubscriber a = (MergeItemSubscriber) o;
a.release();
}
}
}
/**
* Determines and stores the network sites to test for public network connectivity. The sites are
* drawn from the JVM's gov.nasa.worldwind.avkey.NetworkStatusTestSites property ({@link
* AVKey#NETWORK_STATUS_TEST_SITES}). If that property is not defined, the sites are drawn from
* the same property in the World Wind or application configuration file. If the sites are not
* specified there, the set of sites specified in {@link #DEFAULT_NETWORK_TEST_SITES} are used. To
* indicate an empty list in the JVM property or configuration file property, specify an empty
* site list, "".
*/
protected void establishNetworkTestSites() {
String testSites = System.getProperty(AVKey.NETWORK_STATUS_TEST_SITES);
if (testSites == null)
testSites = Configuration.getStringValue(AVKey.NETWORK_STATUS_TEST_SITES);
if (testSites == null) {
this.networkTestSites.addAll(Arrays.asList(DEFAULT_NETWORK_TEST_SITES));
} else {
String[] sites = testSites.split(",");
List<String> actualSites = new ArrayList<String>(sites.length);
for (String site : sites) {
site = WWUtil.removeWhiteSpace(site);
if (!WWUtil.isEmpty(site)) actualSites.add(site);
}
this.setNetworkTestSites(actualSites);
}
}
@Test
public void testCollectToList() {
Observable<List<Integer>> o =
Observable.just(1, 2, 3).collect(ArrayList::new, (list, v) -> list.add(v));
List<Integer> list = o.toBlocking().last();
assertEquals(3, list.size());
assertEquals(1, list.get(0).intValue());
assertEquals(2, list.get(1).intValue());
assertEquals(3, list.get(2).intValue());
// test multiple subscribe
List<Integer> list2 = o.toBlocking().last();
assertEquals(3, list2.size());
assertEquals(1, list2.get(0).intValue());
assertEquals(2, list2.get(1).intValue());
assertEquals(3, list2.get(2).intValue());
}
void subscribeNext() {
Observable<? extends T> t;
synchronized (guard) {
t = queue.peek();
if (t == null || active >= maxConcurrency) {
return;
}
active++;
queue.poll();
}
MergeItemSubscriber itemSub = new MergeItemSubscriber(SOURCE_INDEX.getAndIncrement(this));
subscribers.add(itemSub);
csub.add(itemSub);
WIP.incrementAndGet(this);
t.unsafeSubscribe(itemSub);
request(1);
}
// Applies a unary predicate to each item in a sequence,
// and returns a list of items that produced "true":
public static <T> List<T> filter(Iterable<T> seq, UnaryPredicate<T> pred) {
List<T> result = new ArrayList<T>();
for (T t : seq) if (pred.test(t)) result.add(t);
return result;
}
// Creates a list of results by calling a
// function object for each object in the list:
public static <R, T> List<R> transform(Iterable<T> seq, UnaryFunction<R, T> func) {
List<R> result = new ArrayList<R>();
for (T t : seq) result.add(func.function(t));
return result;
}
/** this is really for embedded objects */
int putObject(String name, BSONObject o) {
if (o == null) throw new NullPointerException("can't save a null object");
if (DEBUG)
System.out.println(
"putObject : " + name + " [" + o.getClass() + "]" + " # keys " + o.keySet().size());
final int start = _buf.getPosition();
byte myType = OBJECT;
if (o instanceof List) myType = ARRAY;
if (handleSpecialObjects(name, o)) return _buf.getPosition() - start;
if (name != null) {
_put(myType, name);
}
final int sizePos = _buf.getPosition();
_buf.writeInt(0); // leaving space for this. set it at the end
List transientFields = null;
boolean rewriteID = myType == OBJECT && name == null;
if (myType == OBJECT) {
if (rewriteID && o.containsField("_id")) _putObjectField("_id", o.get("_id"));
{
Object temp = o.get("_transientFields");
if (temp instanceof List) transientFields = (List) temp;
}
}
// TODO: reduce repeated code below.
if (o instanceof Map) {
for (Entry<String, Object> e : ((Map<String, Object>) o).entrySet()) {
if (rewriteID && e.getKey().equals("_id")) continue;
if (transientFields != null && transientFields.contains(e.getKey())) continue;
_putObjectField(e.getKey(), e.getValue());
}
} else {
for (String s : o.keySet()) {
if (rewriteID && s.equals("_id")) continue;
if (transientFields != null && transientFields.contains(s)) continue;
Object val = o.get(s);
_putObjectField(s, val);
}
}
_buf.write(EOO);
_buf.writeInt(sizePos, _buf.getPosition() - sizePos);
return _buf.getPosition() - start;
}
/** {@inheritDoc} */
@Override
public void onCollision(
Collection<GridCollisionJobContext> waitJobs,
Collection<GridCollisionJobContext> activeJobs) {
assert waitJobs != null;
assert activeJobs != null;
int activeSize = F.size(activeJobs, RUNNING_JOBS);
waitingCnt.set(waitJobs.size());
runningCnt.set(activeSize);
heldCnt.set(activeJobs.size() - activeSize);
int waitSize = waitJobs.size();
int activateCnt = parallelJobsNum - activeSize;
if (activateCnt > 0 && !waitJobs.isEmpty()) {
if (waitJobs.size() <= activateCnt) {
for (GridCollisionJobContext waitJob : waitJobs) {
waitJob.activate();
waitSize--;
}
} else {
List<GridCollisionJobContext> passiveList =
new ArrayList<GridCollisionJobContext>(waitJobs);
Collections.sort(
passiveList,
new Comparator<GridCollisionJobContext>() {
/** {@inheritDoc} */
@Override
public int compare(GridCollisionJobContext o1, GridCollisionJobContext o2) {
int p1 = getJobPriority(o1);
int p2 = getJobPriority(o2);
return p1 < p2 ? 1 : p1 == p2 ? 0 : -1;
}
});
if (preventStarvation) bumpPriority(waitJobs, passiveList);
for (int i = 0; i < activateCnt; i++) {
passiveList.get(i).activate();
waitSize--;
}
}
}
if (waitSize > waitJobsNum) {
List<GridCollisionJobContext> waitList = new ArrayList<GridCollisionJobContext>(waitJobs);
// Put jobs with highest priority first.
Collections.sort(
waitList,
new Comparator<GridCollisionJobContext>() {
/** {@inheritDoc} */
@Override
public int compare(GridCollisionJobContext o1, GridCollisionJobContext o2) {
int p1 = getJobPriority(o1);
int p2 = getJobPriority(o2);
return p1 < p2 ? 1 : p1 == p2 ? 0 : -1;
}
});
int skip = waitJobs.size() - waitSize;
int i = 0;
for (GridCollisionJobContext waitCtx : waitList) {
if (++i >= skip) {
waitCtx.cancel();
if (--waitSize <= waitJobsNum) break;
}
}
}
}
/**
* Performs flush.
*
* @throws GridException If failed.
*/
private void doFlush() throws GridException {
lastFlushTime = U.currentTimeMillis();
List<GridFuture> activeFuts0 = null;
int doneCnt = 0;
for (GridFuture<?> f : activeFuts) {
if (!f.isDone()) {
if (activeFuts0 == null) activeFuts0 = new ArrayList<>((int) (activeFuts.size() * 1.2));
activeFuts0.add(f);
} else {
f.get();
doneCnt++;
}
}
if (activeFuts0 == null || activeFuts0.isEmpty()) return;
while (true) {
Queue<GridFuture<?>> q = null;
for (Buffer buf : bufMappings.values()) {
GridFuture<?> flushFut = buf.flush();
if (flushFut != null) {
if (q == null) q = new ArrayDeque<>(bufMappings.size() * 2);
q.add(flushFut);
}
}
if (q != null) {
assert !q.isEmpty();
boolean err = false;
for (GridFuture fut = q.poll(); fut != null; fut = q.poll()) {
try {
fut.get();
} catch (GridException e) {
if (log.isDebugEnabled()) log.debug("Failed to flush buffer: " + e);
err = true;
}
}
if (err)
// Remaps needed - flush buffers.
continue;
}
doneCnt = 0;
for (int i = 0; i < activeFuts0.size(); i++) {
GridFuture f = activeFuts0.get(i);
if (f == null) doneCnt++;
else if (f.isDone()) {
f.get();
doneCnt++;
activeFuts0.set(i, null);
} else break;
}
if (doneCnt == activeFuts0.size()) return;
}
}
/** @throws Exception If failed. */
public void testCreateFileFragmented() throws Exception {
GridGgfsEx impl = (GridGgfsEx) grid(0).ggfs("ggfs");
GridGgfsFragmentizerManager fragmentizer = impl.context().fragmentizer();
GridTestUtils.setFieldValue(fragmentizer, "fragmentizerEnabled", false);
GridGgfsPath path = new GridGgfsPath("/file");
try {
GridGgfs fs0 = grid(0).ggfs("ggfs");
GridGgfs fs1 = grid(1).ggfs("ggfs");
GridGgfs fs2 = grid(2).ggfs("ggfs");
try (GridGgfsOutputStream out =
fs0.create(
path,
128,
false,
1,
CFG_GRP_SIZE,
F.asMap(GridGgfs.PROP_PREFER_LOCAL_WRITES, "true"))) {
// 1.5 blocks
byte[] data = new byte[CFG_BLOCK_SIZE * 3 / 2];
Arrays.fill(data, (byte) 1);
out.write(data);
}
try (GridGgfsOutputStream out = fs1.append(path, false)) {
// 1.5 blocks.
byte[] data = new byte[CFG_BLOCK_SIZE * 3 / 2];
Arrays.fill(data, (byte) 2);
out.write(data);
}
// After this we should have first two block colocated with grid 0 and last block colocated
// with grid 1.
GridGgfsFileImpl fileImpl = (GridGgfsFileImpl) fs.info(path);
GridCache<Object, Object> metaCache = grid(0).cachex(META_CACHE_NAME);
GridGgfsFileInfo fileInfo = (GridGgfsFileInfo) metaCache.get(fileImpl.fileId());
GridGgfsFileMap map = fileInfo.fileMap();
List<GridGgfsFileAffinityRange> ranges = map.ranges();
assertEquals(2, ranges.size());
assertTrue(ranges.get(0).startOffset() == 0);
assertTrue(ranges.get(0).endOffset() == 2 * CFG_BLOCK_SIZE - 1);
assertTrue(ranges.get(1).startOffset() == 2 * CFG_BLOCK_SIZE);
assertTrue(ranges.get(1).endOffset() == 3 * CFG_BLOCK_SIZE - 1);
// Validate data read after colocated writes.
try (GridGgfsInputStream in = fs2.open(path)) {
// Validate first part of file.
for (int i = 0; i < CFG_BLOCK_SIZE * 3 / 2; i++) assertEquals((byte) 1, in.read());
// Validate second part of file.
for (int i = 0; i < CFG_BLOCK_SIZE * 3 / 2; i++) assertEquals((byte) 2, in.read());
assertEquals(-1, in.read());
}
} finally {
GridTestUtils.setFieldValue(fragmentizer, "fragmentizerEnabled", true);
boolean hasData = false;
for (int i = 0; i < NODES_CNT; i++) hasData |= !grid(i).cachex(DATA_CACHE_NAME).isEmpty();
assertTrue(hasData);
fs.delete(path, true);
}
GridTestUtils.retryAssert(
log,
ASSERT_RETRIES,
ASSERT_RETRY_INTERVAL,
new CAX() {
@Override
public void applyx() {
for (int i = 0; i < NODES_CNT; i++)
assertTrue(grid(i).cachex(DATA_CACHE_NAME).isEmpty());
}
});
}
/**
* @param time Test time.
* @param writers Number of writers threads.
* @throws Exception If failed.
*/
public void testQueue(long time, int writers) throws Exception {
System.out.println("Start test [writers=" + writers + ", time=" + time + "]");
Thread rdr =
new Thread() {
@SuppressWarnings({"InfiniteLoopStatement", "unchecked"})
@Override
public void run() {
try {
while (true) {
Future fut;
while ((fut = queue.poll()) != null) {
qSize.decrementAndGet();
fut.onDone(true);
}
long size = qSize.get();
if (size == 0) {
synchronized (mux) {
while (queue.isEmpty()) {
mux.wait();
}
}
}
}
} catch (InterruptedException ignore) {
}
}
};
rdr.start();
List<Thread> putThreads = new ArrayList<>();
for (int i = 0; i < writers; i++) {
putThreads.add(
new Thread() {
@SuppressWarnings("CallToNotifyInsteadOfNotifyAll")
@Override
public void run() {
try {
while (!stop) {
long id = cnt.incrementAndGet();
Future<Boolean> fut = new Future<Boolean>(new Message(id));
queue.offer(fut);
long size = qSize.incrementAndGet();
if (size == 1) {
synchronized (mux) {
mux.notify();
}
}
Boolean res = fut.get();
if (!res) {
System.out.println("Error");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
for (Thread t : putThreads) t.start();
Thread.sleep(time);
stop = true;
for (Thread t : putThreads) t.join();
rdr.interrupt();
rdr.join();
System.out.println("Total: " + cnt.get());
System.gc();
System.gc();
System.gc();
}
private <E extends Enum<E>> Enum<E> getNextEnumPlaceholder(Class<E> clazz) {
List<E> enums = new ArrayList<E>(EnumSet.allOf(clazz));
return enums.get(enumPlaceholder++ % enums.size());
}
/**
* 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 String reduce(List<GridComputeJobResult> results) throws GridException {
assert results.size() == 1;
return results.get(0).getData();
}
