/** {@inheritDoc} */
@Override
protected Collection<E> pollEvictedBatch0() {
E res = pollEvictedInternal();
if (res == null) return Collections.emptyList();
return Collections.singleton(res);
}
/**
* Build the resource map from the KML Model's <i>ResourceMap</i> element.
*
* @param model Model from which to create the resource map.
* @return Map that relates relative paths in the COLLADA document to paths relative to the KML
* document.
*/
protected Map<String, String> createResourceMap(KMLModel model) {
Map<String, String> map = new HashMap<String, String>();
KMLResourceMap resourceMap = model.getResourceMap();
if (resourceMap == null) return Collections.emptyMap();
for (KMLAlias alias : resourceMap.getAliases()) {
if (alias != null
&& !WWUtil.isEmpty(alias.getSourceRef())
&& !WWUtil.isEmpty(alias.getTargetHref())) {
map.put(alias.getSourceRef(), alias.getTargetHref());
}
}
return map.size() > 0 ? map : Collections.<String, String>emptyMap();
}
public SourceSubscriber(int maxConcurrency, Subscriber<T> s, CompositeSubscription csub) {
super(s);
this.maxConcurrency = maxConcurrency;
this.s = s;
this.csub = csub;
this.guard = new Object();
this.queue = new ArrayDeque<Observable<? extends T>>(maxConcurrency);
this.subscribers = Collections.synchronizedList(new ArrayList<MergeItemSubscriber>());
this.wip = 1;
}
/**
* Test file creation.
*
* @throws Exception In case of exception.
*/
public void testCreateFile() throws Exception {
GridGgfsPath root = new GridGgfsPath("/");
GridGgfsPath path = new GridGgfsPath("/asdf");
long max = 100L * CFG_BLOCK_SIZE / WRITING_THREADS_CNT;
for (long size = 0; size <= max; size = size * 15 / 10 + 1) {
assertEquals(Collections.<GridGgfsPath>emptyList(), fs.listPaths(root));
testCreateFile(path, size, new Random().nextInt());
}
}
/**
* @param cacheCtx Cache context.
* @throws IgniteCheckedException If failed.
*/
private void initTopology(GridCacheContext cacheCtx) throws IgniteCheckedException {
if (stopping(cacheCtx.cacheId())) return;
if (canCalculateAffinity(cacheCtx)) {
if (log.isDebugEnabled())
log.debug(
"Will recalculate affinity [locNodeId="
+ cctx.localNodeId()
+ ", exchId="
+ exchId
+ ']');
cacheCtx.affinity().calculateAffinity(exchId.topologyVersion(), discoEvt);
} else {
if (log.isDebugEnabled())
log.debug(
"Will request affinity from remote node [locNodeId="
+ cctx.localNodeId()
+ ", exchId="
+ exchId
+ ']');
// Fetch affinity assignment from remote node.
GridDhtAssignmentFetchFuture fetchFut =
new GridDhtAssignmentFetchFuture(
cacheCtx,
exchId.topologyVersion(),
CU.affinityNodes(cacheCtx, exchId.topologyVersion()));
fetchFut.init();
List<List<ClusterNode>> affAssignment = fetchFut.get();
if (log.isDebugEnabled())
log.debug(
"Fetched affinity from remote node, initializing affinity assignment [locNodeId="
+ cctx.localNodeId()
+ ", topVer="
+ exchId.topologyVersion()
+ ']');
if (affAssignment == null) {
affAssignment = new ArrayList<>(cacheCtx.affinity().partitions());
List<ClusterNode> empty = Collections.emptyList();
for (int i = 0; i < cacheCtx.affinity().partitions(); i++) affAssignment.add(empty);
}
cacheCtx.affinity().initializeAffinity(exchId.topologyVersion(), affAssignment);
}
}
public static void main(String[] args) throws Exception {
final Config config = Config.loadFromDisk("nexus-importer");
final HTTPCache http = HttpClient.createHttpCache(config);
final XmlParser xmlParser = new XmlParser();
final BoneCPDataSource boneCp = config.createBoneCp();
XmlParser.debugXml = false;
ObjectManager<NexusServerDto, ActorRef<NexusServer>> serverManager =
new ObjectManager<>(
"Nexus server",
Collections.<NexusServerDto>emptySet(),
new ObjectFactory<NexusServerDto, ActorRef<NexusServer>>() {
public ActorRef<NexusServer> create(NexusServerDto server) {
final NexusClient client = new NexusClient(http, server.url);
String name = server.name;
return ObjectUtil.threadedActor(
name,
config.nexusUpdateInterval,
boneCp,
"Nexus Server: " + name,
new NexusServer(client, server, xmlParser));
}
});
final AtomicBoolean shouldRun = new AtomicBoolean(true);
config.addShutdownHook(currentThread(), shouldRun);
while (shouldRun.get()) {
try {
List<NexusServerDto> newKeys;
try (Connection c = boneCp.getConnection()) {
newKeys = new NexusDao(c).selectServer();
}
serverManager.update(newKeys);
} catch (SQLException e) {
e.printStackTrace(System.out);
}
synchronized (shouldRun) {
shouldRun.wait(60 * 1000);
}
}
serverManager.close();
}
private void generateRemainingPagesQueueForAllFiles() {
List<Integer>[] array = new ArrayList[FILE_COUNT];
for (int k = 0; k < FILE_COUNT; ++k) {
array[k] = new ArrayList<Integer>(PAGE_COUNT);
for (Integer i = 0; i < PAGE_COUNT; ++i) {
array[k].add(i);
}
}
for (int i = 0; i < FILE_COUNT; ++i) {
Collections.shuffle(array[i]);
pagesQueue.set(i, new ConcurrentLinkedQueue<Integer>(array[i]));
}
}
/** {@inheritDoc} */
@Override
public Map<? extends GridComputeJob, GridNode> map(List<GridNode> subgrid, String arg)
throws GridException {
assert locNodeId != null;
if (log.isInfoEnabled()) {
log.info("Mapping jobs [subgrid=" + subgrid + ", arg=" + arg + ']');
}
GridNode remoteNode = null;
for (GridNode node : subgrid) {
if (!node.id().equals(locNodeId)) {
remoteNode = node;
}
}
return Collections.singletonMap(
new GridComputeJobAdapter(locNodeId) {
/** */
@GridLocalNodeIdResource private UUID nodeId;
/** {@inheritDoc} */
@SuppressWarnings("NakedNotify")
@Override
public Serializable execute() throws GridException {
assert nodeId != null;
if (!nodeId.equals(argument(0))) {
try {
synchronized (mux) {
mux.notifyAll();
}
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
throw new GridComputeExecutionRejectedException(
"Expected interruption during execution.", e);
}
} else {
return "success";
}
throw new GridComputeExecutionRejectedException(
"Expected exception during execution.");
}
},
remoteNode);
}
/**
* @param fld Folder with files to match.
* @param ptrn Pattern to match against file name.
* @return Collection of matched files.
*/
public static List<VisorLogFile> matchedFiles(File fld, final String ptrn) {
List<VisorLogFile> files =
fileTree(
fld,
MAX_FOLDER_DEPTH,
new FileFilter() {
@Override
public boolean accept(File f) {
return !f.isHidden()
&& (f.isDirectory() || f.isFile() && f.getName().matches(ptrn));
}
});
Collections.sort(files, LAST_MODIFIED);
return files;
}
/** {@inheritDoc} */
@Override
public boolean onDone(AffinityTopologyVersion res, Throwable err) {
Map<Integer, Boolean> m = null;
for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
if (cacheCtx.config().getTopologyValidator() != null && !CU.isSystemCache(cacheCtx.name())) {
if (m == null) m = new HashMap<>();
m.put(
cacheCtx.cacheId(),
cacheCtx.config().getTopologyValidator().validate(discoEvt.topologyNodes()));
}
}
cacheValidRes = m != null ? m : Collections.<Integer, Boolean>emptyMap();
cctx.cache().onExchangeDone(exchId.topologyVersion(), reqs, err);
cctx.exchange().onExchangeDone(this, err);
if (super.onDone(res, err) && !dummy && !forcePreload) {
if (log.isDebugEnabled())
log.debug(
"Completed partition exchange [localNode="
+ cctx.localNodeId()
+ ", exchange= "
+ this
+ ']');
initFut.onDone(err == null);
GridTimeoutObject timeoutObj = this.timeoutObj;
// Deschedule timeout object.
if (timeoutObj != null) cctx.kernalContext().timeout().removeTimeoutObject(timeoutObj);
if (exchId.isLeft()) {
for (GridCacheContext cacheCtx : cctx.cacheContexts())
cacheCtx.config().getAffinity().removeNode(exchId.nodeId());
}
return true;
}
return dummy;
}
/**
* 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));
}
/** @throws Exception If failed. */
public void testEmptyProjections() throws Exception {
final GridClientCompute dflt = client.compute();
Collection<? extends GridClientNode> nodes = dflt.nodes();
assertEquals(NODES_CNT, nodes.size());
Iterator<? extends GridClientNode> iter = nodes.iterator();
final GridClientCompute singleNodePrj = dflt.projection(Collections.singletonList(iter.next()));
final GridClientNode second = iter.next();
final GridClientPredicate<GridClientNode> noneFilter =
new GridClientPredicate<GridClientNode>() {
@Override
public boolean apply(GridClientNode node) {
return false;
}
};
final GridClientPredicate<GridClientNode> targetFilter =
new GridClientPredicate<GridClientNode>() {
@Override
public boolean apply(GridClientNode node) {
return node.nodeId().equals(second.nodeId());
}
};
GridTestUtils.assertThrows(
log(),
new Callable<Object>() {
@Override
public Object call() throws Exception {
return dflt.projection(noneFilter).log(-1, -1);
}
},
GridServerUnreachableException.class,
null);
GridTestUtils.assertThrows(
log(),
new Callable<Object>() {
@Override
public Object call() throws Exception {
return singleNodePrj.projection(second);
}
},
GridClientException.class,
null);
GridTestUtils.assertThrows(
log(),
new Callable<Object>() {
@Override
public Object call() throws Exception {
return singleNodePrj.projection(targetFilter);
}
},
GridClientException.class,
null);
}
/**
* 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;
}
/**
* 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;
}
/** @return Remaining node IDs. */
Collection<UUID> remaining() {
if (rmtIds == null) return Collections.emptyList();
return F.lose(rmtIds, true, rcvdIds);
}
/** {@inheritDoc} */
@Override
protected List<String> getConsistentAttributeNames() {
return Collections.singletonList(createSpiAttributeName(PRIORITY_ATTRIBUTE_KEY));
}
/** {@inheritDoc} */
@Override
public Map<K, Collection<GridCacheMvccCandidate<K>>> localCandidates() {
return Collections.emptyMap();
}
/** {@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;
}
}
}
}
/** Initializes future. */
public void prepare() {
if (log.isDebugEnabled())
log.debug("Checking if transaction was committed on remote nodes: " + tx);
// Check local node first (local node can be a backup node for some part of this transaction).
long originatingThreadId = tx.threadId();
if (tx instanceof GridCacheTxRemoteEx)
originatingThreadId = ((GridCacheTxRemoteEx) tx).remoteThreadId();
GridCacheCommittedTxInfo<K, V> txInfo =
cctx.tm().txCommitted(tx.nearXidVersion(), tx.eventNodeId(), originatingThreadId);
if (txInfo != null) {
onDone(txInfo);
markInitialized();
return;
}
Collection<GridNode> checkNodes = CU.remoteNodes(cctx, tx.topologyVersion());
if (tx instanceof GridDhtTxRemote) {
// If we got primary node failure and near node has not failed.
if (tx.nodeId().equals(failedNodeId) && !tx.eventNodeId().equals(failedNodeId)) {
nearCheck = true;
GridNode nearNode = cctx.discovery().node(tx.eventNodeId());
if (nearNode == null) {
// Near node failed, separate check prepared future will take care of it.
onDone(
new GridTopologyException(
"Failed to check near transaction state (near node left grid): "
+ tx.eventNodeId()));
return;
}
checkNodes = Collections.singletonList(nearNode);
}
}
for (GridNode rmtNode : checkNodes) {
// Skip left nodes and local node.
if (rmtNode.id().equals(failedNodeId)) continue;
/*
* Send message to all cache nodes in the topology.
*/
MiniFuture fut = new MiniFuture(rmtNode.id());
GridCachePessimisticCheckCommittedTxRequest<K, V> req =
new GridCachePessimisticCheckCommittedTxRequest<>(
tx, originatingThreadId, futureId(), fut.futureId());
add(fut);
try {
cctx.io().send(rmtNode.id(), req);
} catch (GridTopologyException ignored) {
fut.onNodeLeft();
} catch (GridException e) {
fut.onError(e);
break;
}
}
markInitialized();
}
/** {@inheritDoc} */
@Override
public Collection<String> getExcludePaths() {
return Collections.unmodifiableCollection(excludePaths);
}
public void sortResults(
int WindowNo, int AD_Tab_ID, int AD_Field_ID, int queryResultID, final boolean ascending) {
class SortCell {
String[] row;
String sort;
}
ArrayList<String[]> results = m_results.get(queryResultID);
if (results == null)
log.severe("cannot sort. results non-existent for queryResultID:" + queryResultID);
UITab tab = getTab(AD_Tab_ID);
final UIField field = getField(AD_Field_ID, WindowNo);
final int displayType = field.getAD_Reference_ID();
final int idx = tab.getFieldIndex(AD_Field_ID);
// if not a lookup, directly sort
if (!field.isLookup()) {
if (FieldType.isNumeric(displayType)) {
Collections.sort(
results,
new Comparator<String[]>() {
@Override
public int compare(String[] o1, String[] o2) {
if (o1[idx] == null) o1[idx] = "";
if (o2[idx] == null) o2[idx] = "";
BigDecimal s1 = new BigDecimal(o1[idx].equals("") ? "-1e-10" : o1[idx]);
BigDecimal s2 = new BigDecimal(o2[idx].equals("") ? "-1e-10" : o2[idx]);
return ascending ? s1.compareTo(s2) : s2.compareTo(s1);
}
});
} else if (FieldType.isDate(displayType)) {
Collections.sort(
results,
new Comparator<String[]>() {
@Override
public int compare(String[] o1, String[] o2) {
if (o1[idx] == null) o1[idx] = "";
if (o2[idx] == null) o2[idx] = "";
Long s1 = new Long(o1[idx].equals("") ? "-1000000" : o1[idx]);
Long s2 = new Long(o2[idx].equals("") ? "-1000000" : o2[idx]);
return ascending ? s1.compareTo(s2) : s2.compareTo(s1);
}
});
} else {
Collections.sort(
results,
new Comparator<String[]>() {
@Override
public int compare(String[] o1, String[] o2) {
if (o1[idx] == null) o1[idx] = "";
if (o2[idx] == null) o2[idx] = "";
String s1 = o1[idx];
String s2 = o2[idx];
return ascending ? s1.compareTo(s2) : s2.compareTo(s1);
}
});
}
return;
}
Comparator<SortCell> c =
new Comparator<SortCell>() {
public int compare(SortCell o1, SortCell o2) {
if (ascending) return o1.sort.compareTo(o2.sort);
else return o2.sort.compareTo(o1.sort);
}
};
// for look up, first get id values
ArrayList<String> fieldValues = new ArrayList<String>(results.size());
for (String[] row : results) {
fieldValues.add(row[idx]);
}
// then translate into real values
ArrayList<String> sorts = getLookupValueOnlyDirect(AD_Field_ID, fieldValues, true);
ArrayList<SortCell> toBeSorteds = new ArrayList<SortCell>(sorts.size());
for (int i = 0; i < sorts.size(); i++) {
SortCell toBeSorted = new SortCell();
toBeSorted.row = results.get(i);
toBeSorted.sort = sorts.get(i);
toBeSorteds.add(toBeSorted);
}
// sort
Collections.sort(toBeSorteds, c);
// after sorting, replace col with original values
int i = 0;
for (SortCell toBeSorted : toBeSorteds) {
results.set(i, toBeSorted.row);
i++;
}
}
// Method to return a list of matches according to fields for a tab, using
// the cached results
// this does not store the result in the cache - this behavior is deferred
// to the caller
private int searchTabResults(
int WindowNo,
UITab tab,
List<Integer> fieldIds,
int queryResultID,
int searchResultID,
String query,
int rowCount) {
ArrayList<String[]> results = m_results.get(queryResultID);
if (query.trim().equals("")) {
m_results.put(searchResultID, results);
return results.size();
}
ScoreStrategy scorer = new ScoreStrategy(query);
ScoreCell[] scores = new ScoreCell[results.size()];
// first initialize score cells
int j = 0;
for (String[] result : results) {
// initialize score cells
ScoreCell score = new ScoreCell();
score.row = result;
score.score = scorer.createScore();
scores[j++] = score;
}
for (int id : fieldIds) {
UIField field = getField(id, WindowNo);
final int idx = tab.getFieldIndex(id);
if (field.isLookup()) {
ArrayList<String> fieldValues = new ArrayList<String>(results.size());
for (String[] row : results) {
fieldValues.add(row[idx]);
}
ArrayList<String> sorts = getLookupValueOnlyDirect(id, fieldValues, true);
int i = 0;
for (String value : sorts) {
scorer.getScore(value, scores[i].score);
i++;
}
} else {
int i = 0;
for (String[] row : results) {
String value = row[idx];
scorer.getScore(value, scores[i].score);
i++;
}
}
}
ArrayList<ScoreCell> matchingScores = new ArrayList<ScoreCell>();
for (ScoreCell cell : scores) {
if (cell.score.isMatch) {
matchingScores.add(cell);
}
}
Collections.sort(matchingScores, scorer);
ArrayList<String[]> matches = new ArrayList<String[]>();
for (ScoreCell score : matchingScores) {
matches.add(score.row);
}
m_results.put(searchResultID, matches);
return matches.size();
}
