/** @throws Exception If failed. */
public void testInvalidateFlag() throws Exception {
GridEx g0 = grid(0);
GridCache<String, String> cache = g0.cache(PARTITIONED_CACHE_NAME);
String key = null;
for (int i = 0; i < 10_000; i++) {
if (!cache.affinity().isPrimaryOrBackup(g0.localNode(), String.valueOf(i))) {
key = String.valueOf(i);
break;
}
}
assertNotNull(key);
cache.put(key, key); // Create entry in near cache, it is invalidated if INVALIDATE flag is set.
assertNotNull(cache.peek(key));
GridClientData d = client.data(PARTITIONED_CACHE_NAME);
d.flagsOn(GridClientCacheFlag.INVALIDATE).put(key, "zzz");
for (Grid g : G.allGrids()) {
cache = g.cache(PARTITIONED_CACHE_NAME);
if (cache.affinity().isPrimaryOrBackup(g.localNode(), key))
assertEquals("zzz", cache.peek(key));
else assertNull(cache.peek(key));
}
}
/** @throws Exception If failed. */
@SuppressWarnings("unchecked")
public void testCancel() throws Exception {
Grid grid = G.grid(getTestGridName());
grid.compute()
.localDeployTask(GridCancelTestTask.class, U.detectClassLoader(GridCancelTestTask.class));
GridComputeTaskFuture<?> fut = grid.compute().execute(GridCancelTestTask.class.getName(), null);
// Wait until jobs begin execution.
boolean await = startSignal.await(WAIT_TIME, TimeUnit.MILLISECONDS);
assert await : "Jobs did not start.";
info("Test task result: " + fut);
assert fut != null;
// Only first job should successfully complete.
Object res = fut.get();
assert (Integer) res == 1;
// Wait for all jobs to finish.
await = stopSignal.await(WAIT_TIME, TimeUnit.MILLISECONDS);
assert await : "Jobs did not stop.";
// One is definitely processed. But there might be some more processed or cancelled or processed
// and cancelled.
// Thus total number should be at least SPLIT_COUNT and at most (SPLIT_COUNT - 1) *2 +1
assert (cancelCnt + processedCnt) >= SPLIT_COUNT
&& (cancelCnt + processedCnt) <= (SPLIT_COUNT - 1) * 2 + 1
: "Invalid cancel count value: " + cancelCnt;
}
public Room getActRoomTypeExitsNext() {
Room nextRoom = null;
Direction exit = getExit();
if (exit != null) {
if (exit == Direction.LEFT) {
nextRoom = grid.getRoom(position.goLeft());
System.err.println("LEFT");
} else if (exit == Direction.RIGHT) {
nextRoom = grid.getRoom(position.goRight());
System.err.println("RIGHT");
} else if (exit == Direction.DOWN) {
nextRoom = grid.getRoom(position.goDown());
System.err.println("DOWN");
}
}
if (nextRoom != null && nextRoom.isGateWay()) {
nextRoom.actEntrance = getExit().opposite();
nextRoom.prev = this;
next = nextRoom;
} else {
nextRoom = null;
}
return nextRoom;
}
private static void solve(Grid grid, List<Grid> solutions) {
// Return if there is already more than two solution
if (solutions.size() >= 2) {
return;
}
// Find first empty cell
int loc = grid.findEmptyCell();
// If no empty cells are found,a solution is found
if (loc < 0) {
solutions.add(grid.clone());
return;
}
// Try each of the 9 digits in this empty cell
for (int n = 1; n < 10; n++) {
if (grid.set(loc, n)) {
// With this cell set,work on the next cell
solve(grid, solutions);
// Clear the cell so that it can be filled with another digit
grid.clear(loc);
}
}
}
/** @throws Exception If failed. */
public void testProjectionRun() throws Exception {
GridClientCompute dflt = client.compute();
Collection<? extends GridClientNode> nodes = dflt.nodes();
assertEquals(NODES_CNT, nodes.size());
for (int i = 0; i < NODES_CNT; i++) {
Grid g = grid(i);
assert g != null;
GridClientNode clientNode = dflt.node(g.localNode().id());
assertNotNull("Client node for " + g.localNode().id() + " was not found", clientNode);
GridClientCompute prj = dflt.projection(clientNode);
String res = prj.execute(TestTask.class.getName(), null);
assertNotNull(res);
assertEquals(g.localNode().id().toString(), res);
}
}
/**
* Ensure that {@link GridComputeJobMasterLeaveAware} callback is invoked on job which is
* initiated by master and is currently running on it.
*
* @throws Exception If failed.
*/
public void testLocalJobOnMaster() throws Exception {
invokeLatch = new CountDownLatch(1);
jobLatch = new CountDownLatch(1);
Grid g = startGrid(0);
g.compute().execute(new TestTask(1), null);
jobLatch.await();
// Count down the latch in a separate thread.
new Thread(
new Runnable() {
@Override
public void run() {
try {
U.sleep(500);
} catch (GridInterruptedException ignore) {
// No-op.
}
latch.countDown();
}
})
.start();
stopGrid(0, true);
latch.countDown();
assert invokeLatch.await(5000, MILLISECONDS);
}
/** @throws Exception If failed. */
@SuppressWarnings({"ObjectEquality"})
public void testDifferentTasks() throws Exception {
Grid grid1 = null;
Grid grid2 = null;
try {
grid1 = startGrid(1, new GridSpringResourceContextImpl(new GenericApplicationContext()));
grid2 = startGrid(2, new GridSpringResourceContextImpl(new GenericApplicationContext()));
// Execute different tasks.
grid1.compute().execute(SharedResourceTask1.class, null).get();
grid1.compute().execute(SharedResourceTask2.class, null).get();
// In ISOLATED_CLASSLOADER mode tasks should have the class
// loaders because they have the same CL locally and thus the same
// resources.
// So 1 resource locally and 1 remotely
assert task1Rsrc1 == task2Rsrc1;
assert task1Rsrc2 == task2Rsrc2;
assert task1Rsrc3 == task2Rsrc3;
assert task1Rsrc4 == task2Rsrc4;
checkUsageCount(createClss, UserResource1.class, 4);
checkUsageCount(createClss, UserResource2.class, 4);
checkUsageCount(deployClss, UserResource1.class, 4);
checkUsageCount(deployClss, UserResource2.class, 4);
} finally {
GridTestUtils.close(grid1, log());
GridTestUtils.close(grid2, log());
}
checkUsageCount(undeployClss, UserResource1.class, 4);
checkUsageCount(undeployClss, UserResource2.class, 4);
}
/** @throws Exception If failed. */
public void testDisabledRest() throws Exception {
restEnabled = false;
final Grid g = startGrid("disabled-rest");
try {
Thread.sleep(2 * TOP_REFRESH_FREQ);
// As long as we have round robin load balancer this will cause every node to be queried.
for (int i = 0; i < NODES_CNT + 1; i++)
assertEquals(NODES_CNT + 1, client.compute().refreshTopology(false, false).size());
final GridClientData data = client.data(PARTITIONED_CACHE_NAME);
// Check rest-disabled node is unavailable.
try {
String affKey;
do {
affKey = UUID.randomUUID().toString();
} while (!data.affinity(affKey).equals(g.localNode().id()));
data.put(affKey, "asdf");
assertEquals("asdf", cache(0, PARTITIONED_CACHE_NAME).get(affKey));
} catch (GridServerUnreachableException e) {
// Thrown for direct client-node connections.
assertTrue(
"Unexpected exception message: " + e.getMessage(),
e.getMessage()
.startsWith("No available endpoints to connect (is rest enabled for this node?)"));
} catch (GridClientException e) {
// Thrown for routed client-router-node connections.
String msg = e.getMessage();
assertTrue(
"Unexpected exception message: " + msg,
protocol() == GridClientProtocol.TCP
? msg.contains("No available endpoints to connect (is rest enabled for this node?)")
: // TCP router.
msg.startsWith(
"No available nodes on the router for destination node ID")); // HTTP router.
}
// Check rest-enabled nodes are available.
String affKey;
do {
affKey = UUID.randomUUID().toString();
} while (data.affinity(affKey).equals(g.localNode().id()));
data.put(affKey, "fdsa");
assertEquals("fdsa", cache(0, PARTITIONED_CACHE_NAME).get(affKey));
} finally {
restEnabled = true;
G.stop(g.name(), true);
}
}
public int getol(Coord tc) {
Grid g = getgridt(tc);
int ol = g.getol(tc.sub(g.ul));
for (Overlay lol : ols) {
if (tc.isect(lol.c1, lol.c2.add(lol.c1.inv()).add(new Coord(1, 1)))) ol |= lol.mask;
}
return (ol);
}
/** Method declaration Adjust this method for large strings...ie multi megabtypes. */
void execute() {
String sCmd = null;
if (4096 <= ifHuge.length()) {
sCmd = ifHuge;
} else {
sCmd = txtCommand.getText();
}
if (sCmd.startsWith("-->>>TEST<<<--")) {
testPerformance();
return;
}
String g[] = new String[1];
lTime = System.currentTimeMillis();
try {
sStatement.execute(sCmd);
lTime = System.currentTimeMillis() - lTime;
int r = sStatement.getUpdateCount();
if (r == -1) {
formatResultSet(sStatement.getResultSet());
} else {
g[0] = "update count";
gResult.setHead(g);
g[0] = String.valueOf(r);
gResult.addRow(g);
}
addToRecent(txtCommand.getText());
} catch (SQLException e) {
lTime = System.currentTimeMillis() - lTime;
g[0] = "SQL Error";
gResult.setHead(g);
String s = e.getMessage();
s += " / Error Code: " + e.getErrorCode();
s += " / State: " + e.getSQLState();
g[0] = s;
gResult.addRow(g);
}
updateResult();
System.gc();
}
/**
* Listen to events coming from all grid nodes.
*
* @throws GridException If failed.
*/
private static void remoteListen() throws GridException {
Grid g = GridGain.grid();
GridCache<Integer, String> cache = g.cache(CACHE_NAME);
// Register remote event listeners on all nodes running cache.
GridFuture<?> fut =
g.forCache(CACHE_NAME)
.events()
.remoteListen(
// This optional local callback is called for each event notification
// that passed remote predicate filter.
new GridBiPredicate<UUID, GridCacheEvent>() {
@Override
public boolean apply(UUID nodeId, GridCacheEvent evt) {
System.out.println();
System.out.println(
"Received event [evt="
+ evt.name()
+ ", key="
+ evt.key()
+ ", oldVal="
+ evt.oldValue()
+ ", newVal="
+ evt.newValue());
return true; // Return true to continue listening.
}
},
// Remote filter which only accepts events for keys that are
// greater or equal than 10 and if local node is primary for this key.
new GridPredicate<GridCacheEvent>() {
/** Auto-inject grid instance. */
@GridInstanceResource private Grid g;
@Override
public boolean apply(GridCacheEvent evt) {
Integer key = evt.key();
return key >= 10
&& g.cache(CACHE_NAME).affinity().isPrimary(g.localNode(), key);
}
},
// Types of events for which listeners are registered.
EVT_CACHE_OBJECT_PUT,
EVT_CACHE_OBJECT_READ,
EVT_CACHE_OBJECT_REMOVED);
// Wait until event listeners are subscribed on all nodes.
fut.get();
int keyCnt = 20;
// Generate cache events.
for (int i = 0; i < keyCnt; i++) cache.putx(i, Integer.toString(i));
}
public void startScan(String mode) {
pathfindStart = System.currentTimeMillis();
if (!gridSet) {
grid.clearScan();
tracing = false;
if (grid.scanStart(mode)) {
gridSet = true;
}
}
}
public void ctick() {
long now = System.currentTimeMillis();
int dt = (int) (now - lastctick);
synchronized (grids) {
for (Grid g : grids.values()) {
g.tick(dt);
}
}
lastctick = now;
}
/** @throws Exception If failed. */
@SuppressWarnings({"ObjectEquality"})
public void testUndeployedTask() throws Exception {
Grid grid1 = null;
Grid grid2 = null;
try {
grid1 = startGrid(1, new GridSpringResourceContextImpl(new GenericApplicationContext()));
grid2 = startGrid(2, new GridSpringResourceContextImpl(new GenericApplicationContext()));
// Execute tasks.
grid1.compute().execute(SharedResourceTask1.class, null).get();
grid1.compute().execute(SharedResourceTask2.class, null).get();
grid1.compute().undeployTask(SharedResourceTask1.class.getName());
// Wait until resources get undeployed remotely
// because undeploy is asynchronous apply.
Thread.sleep(3000);
// 1 local and 1 remote resource instances
checkUsageCount(createClss, UserResource1.class, 4);
checkUsageCount(deployClss, UserResource1.class, 4);
checkUsageCount(createClss, UserResource2.class, 4);
checkUsageCount(deployClss, UserResource2.class, 4);
checkUsageCount(undeployClss, UserResource1.class, 4);
checkUsageCount(undeployClss, UserResource2.class, 4);
grid1.compute().undeployTask(SharedResourceTask2.class.getName());
// Wait until resources get undeployed remotely
// because undeploy is asynchronous apply.
Thread.sleep(3000);
// We undeployed last task for this class loader and resources.
// All resources should be undeployed.
checkUsageCount(undeployClss, UserResource1.class, 4);
checkUsageCount(undeployClss, UserResource2.class, 4);
// Execute the same tasks.
grid1.compute().execute(SharedResourceTask1.class, null).get();
grid1.compute().execute(SharedResourceTask2.class, null).get();
// 2 new resources.
checkUsageCount(createClss, UserResource1.class, 8);
checkUsageCount(deployClss, UserResource1.class, 8);
checkUsageCount(createClss, UserResource2.class, 8);
checkUsageCount(deployClss, UserResource2.class, 8);
} finally {
GridTestUtils.close(grid1, log());
GridTestUtils.close(grid2, log());
}
checkUsageCount(undeployClss, UserResource1.class, 8);
checkUsageCount(undeployClss, UserResource2.class, 8);
}
private static void fillTunelMap(Grid tunnelMap) {
for (int actHeight = 0; actHeight < tunnelMap.getHeight(); actHeight++) {
String[] floor =
getLevelRooms(); // represents a line in the grid and contains "width" integers. Each
// integer represents one room of a given type.
for (int actWidth = 0; actWidth < tunnelMap.getWidth(); actWidth++) {
Position position = new Position(actWidth, actHeight);
Room room = mapStringToRoom(floor[actWidth], position, tunnelMap);
}
}
}
/**
* Calculates length of a given phrase on the grid.
*
* @param phrase Phrase to count the number of letters in.
* @throws GridException If failed.
*/
private static void countLettersReducer(String phrase) throws GridException {
X.println(">>> Starting countLettersReducer() example...");
Grid grid = G.grid();
// Logger to use in your closure. Note that even though we assign it
// to a local variable, GridGain still allows to use it from remotely
// executed code.
final GridLogger log = grid.log();
// Execute Hello World task.
int letterCnt =
grid.reduce(
BALANCE,
new GridClosure<String, Integer>() { // Create executable logic.
@Override
public Integer apply(String word) {
// Print out a given word, just so we can
// see which node is doing what.
log.info(">>> Calculating for word: " + word);
// Return the length of a given word, i.e. number of letters.
return word.length();
}
},
Arrays.asList(phrase.split(" ")), // Collection of words.
// Create custom reducer.
// NOTE: Alternatively, you can use existing reducer: F.sumIntReducer()
new GridReducer<Integer, Integer>() {
private int sum;
@Override
public boolean collect(Integer res) {
sum += res;
return true; // True means continue collecting until last result.
}
@Override
public Integer apply() {
return sum;
}
});
X.println(">>>");
X.println(">>> Finished execution of counting letters with reducer based on GridGain 3.0 API.");
X.println(">>> Total number of letters in the phrase is '" + letterCnt + "'.");
X.println(">>> You should see individual words printed out on different nodes.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
}
/** @throws Exception If failed. */
public void testTopologyListener() throws Exception {
final Collection<UUID> added = new ArrayList<>(1);
final Collection<UUID> rmvd = new ArrayList<>(1);
final CountDownLatch addedLatch = new CountDownLatch(1);
final CountDownLatch rmvLatch = new CountDownLatch(1);
assertEquals(NODES_CNT, client.compute().refreshTopology(false, false).size());
GridClientTopologyListener lsnr =
new GridClientTopologyListener() {
@Override
public void onNodeAdded(GridClientNode node) {
added.add(node.nodeId());
addedLatch.countDown();
}
@Override
public void onNodeRemoved(GridClientNode node) {
rmvd.add(node.nodeId());
rmvLatch.countDown();
}
};
client.addTopologyListener(lsnr);
try {
Grid g = startGrid(NODES_CNT + 1);
UUID id = g.localNode().id();
assertTrue(addedLatch.await(2 * TOP_REFRESH_FREQ, MILLISECONDS));
assertEquals(1, added.size());
assertEquals(id, F.first(added));
stopGrid(NODES_CNT + 1);
assertTrue(rmvLatch.await(2 * TOP_REFRESH_FREQ, MILLISECONDS));
assertEquals(1, rmvd.size());
assertEquals(id, F.first(rmvd));
} finally {
client.removeTopologyListener(lsnr);
stopGrid(NODES_CNT + 1);
}
}
public void mapdata2(Message msg) {
Coord c = msg.coord();
synchronized (grids) {
synchronized (req) {
if (req.containsKey(c)) {
Grid g = grids.get(c);
if (g == null) grids.put(c, g = new Grid(c));
g.fill(msg);
req.remove(c);
olseq++;
}
}
}
}
private void addDatePanel() {
Grid datePanel = new Grid(2, 2);
datePanel.setText(0, 0, "Departure Date:");
DateBox departureBox = new DateBox();
Date departureDate = new Date();
departureBox.setValue(departureDate);
datePanel.setWidget(0, 1, departureBox);
datePanel.setText(1, 0, "Return Date:");
DateBox returnBox = new DateBox();
Date returnDate = DateUtils.datePlusWeek(departureDate);
returnBox.setValue(returnDate);
datePanel.setWidget(1, 1, returnBox);
RootPanel.get("date-panel").add(datePanel);
}
/**
* Executes example.
*
* @param args Command line arguments, none required.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws GridException {
try (Grid g = GridGain.start("examples/config/example-compute.xml")) {
System.out.println();
System.out.println("Compute reducer example started.");
Integer sum =
g.compute()
.apply(
new GridClosure<String, Integer>() {
@Override
public Integer apply(String word) {
System.out.println();
System.out.println(">>> Printing '" + word + "' on this node from grid job.");
// Return number of letters in the word.
return word.length();
}
},
// Job parameters. GridGain will create as many jobs as there are parameters.
Arrays.asList("Count characters using reducer".split(" ")),
// Reducer to process results as they come.
new GridReducer<Integer, Integer>() {
private AtomicInteger sum = new AtomicInteger();
// Callback for every job result.
@Override
public boolean collect(Integer len) {
sum.addAndGet(len);
// Return true to continue waiting until all results are received.
return true;
}
// Reduce all results into one.
@Override
public Integer reduce() {
return sum.get();
}
})
.get();
System.out.println();
System.out.println(">>> Total number of characters in the phrase is '" + sum + "'.");
System.out.println(">>> Check all nodes for output (this node is also part of the grid).");
}
}
/**
* Starts the local node and checks for presence of log file. Also checks that this is really a
* log of a started node.
*
* @param id Test-local node ID.
* @throws Exception If error occurred.
*/
private void checkOneNode(int id) throws Exception {
try (Grid grid = G.start(getConfiguration("grid" + id))) {
String id8 = U.id8(grid.localNode().id());
String logPath = "work/log/gridgain-" + id8 + ".log";
File logFile = U.resolveGridGainPath(logPath);
assertNotNull("Failed to resolve path: " + logPath, logFile);
assertTrue("Log file does not exist: " + logFile, logFile.exists());
String logContent = U.readFileToString(logFile.getAbsolutePath(), "UTF-8");
assertTrue(
"Log file does not contain it's node ID: " + logFile,
logContent.contains(">>> Local node [ID=" + id8.toUpperCase()));
}
}
/** {@inheritDoc} */
@Override
protected Collection<? extends GridComputeJob> split(int gridSize, Object arg)
throws GridException {
Collection<GridComputeJobAdapter> jobs = new ArrayList<>(gridSize);
this.gridSize = gridSize;
final String locNodeId = grid.localNode().id().toString();
for (int i = 0; i < gridSize; i++) {
jobs.add(
new GridComputeJobAdapter() {
@SuppressWarnings("OverlyStrongTypeCast")
@Override
public Object execute() {
try {
Thread.sleep(1000);
} catch (InterruptedException ignored) {
Thread.currentThread().interrupt();
}
return new GridBiTuple<>(locNodeId, 1);
}
});
}
return jobs;
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D gfx = (Graphics2D) g;
gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// Clear screen
gfx.setColor(Constants.BACKGROUND_COLOR);
gfx.fillRect(0, 0, getWidth(), getHeight());
// Render next frame
grid.draw(gfx);
// Trace path line
if (tracing) {
gfx.setColor(Constants.PATH_COLOR);
gfx.setStroke(new BasicStroke(2));
for (int i = 1; i < pathLine.size(); i++) {
Coordinate p = pathLine.get(i - 1);
Coordinate n = pathLine.get(i);
gfx.drawLine(
(Constants.TILESIZE + Constants.MARGIN) * p.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * p.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN);
}
}
}
/** @throws Exception If failed. */
@SuppressWarnings("unchecked")
public void testRedeployedTask() throws Exception {
Grid grid = startGrid(0, new GridSpringResourceContextImpl(new GenericApplicationContext()));
try {
// Execute same task with different class loaders. Second execution should redeploy first one.
grid.compute().execute(SharedResourceTask1.class, null).get();
checkUsageCount(createClss, UserResource1.class, 2);
checkUsageCount(createClss, UserResource2.class, 2);
checkUsageCount(deployClss, UserResource1.class, 2);
checkUsageCount(deployClss, UserResource2.class, 2);
// Change class loader of the task. So it's just implicit redeploy.
ClassLoader tstClsLdr =
new GridTestClassLoader(
null,
getClass().getClassLoader(),
SharedResourceTask1.class.getName(),
GridResourceSharedUndeploySelfTest.SharedResourceTask1.GridSharedJob1.class.getName(),
GridResourceSharedUndeploySelfTest.class.getName());
Class<? extends GridComputeTask<Object, Object>> taskCls =
(Class<? extends GridComputeTask<Object, Object>>)
tstClsLdr.loadClass(SharedResourceTask1.class.getName());
grid.compute().execute(taskCls, null).get();
// Old resources should be undeployed at this point.
checkUsageCount(undeployClss, UserResource1.class, 2);
checkUsageCount(undeployClss, UserResource2.class, 2);
// We should detect redeployment and create new resources.
checkUsageCount(createClss, UserResource1.class, 4);
checkUsageCount(createClss, UserResource2.class, 4);
checkUsageCount(deployClss, UserResource1.class, 4);
checkUsageCount(deployClss, UserResource2.class, 4);
} finally {
GridTestUtils.close(grid, log());
}
checkUsageCount(undeployClss, UserResource1.class, 4);
checkUsageCount(undeployClss, UserResource2.class, 4);
}
/** @throws Exception If failed. */
public void testSameTaskFromTwoNodesLeft() throws Exception {
Grid grid1 = null;
Grid grid2 = null;
Grid grid3 = null;
try {
grid1 = startGrid(1, new GridSpringResourceContextImpl(new GenericApplicationContext()));
grid2 = startGrid(2, new GridSpringResourceContextImpl(new GenericApplicationContext()));
grid3 = startGrid(3, new GridSpringResourceContextImpl(new GenericApplicationContext()));
grid1.compute().execute(SharedResourceTask1.class, null).get();
grid2.compute().execute(SharedResourceTask1.class, null).get();
checkUsageCount(createClss, UserResource1.class, 6);
checkUsageCount(deployClss, UserResource1.class, 6);
checkUsageCount(createClss, UserResource2.class, 6);
checkUsageCount(deployClss, UserResource2.class, 6);
checkUsageCount(undeployClss, UserResource1.class, 0);
checkUsageCount(undeployClss, UserResource2.class, 0);
GridTestUtils.close(grid1, log());
// Wait until other nodes get notified
// this grid1 left.
Thread.sleep(1000);
// Undeployment happened only on Grid1.
checkUsageCount(undeployClss, UserResource1.class, 2);
checkUsageCount(undeployClss, UserResource2.class, 2);
GridTestUtils.close(grid2, log());
// Wait until resources get undeployed remotely
// because undeploy is asynchronous apply.
Thread.sleep(1000);
// Grid1 and Grid2
checkUsageCount(undeployClss, UserResource1.class, 4);
checkUsageCount(undeployClss, UserResource2.class, 4);
} finally {
GridTestUtils.close(grid1, log());
GridTestUtils.close(grid2, log());
GridTestUtils.close(grid3, log());
}
}
/**
* Sends optional message. If message is {@code null} - it's no-op.
*
* @param nodeId ID of the node to send message to.
* @param respMsg Message to send.
* @throws GridException Thrown in case of any errors.
*/
private void send(UUID nodeId, @Nullable Object respMsg) throws GridException {
assert nodeId != null;
if (respMsg != null) {
GridNode node = grid.node(nodeId);
if (node != null) grid.forNode(node).message().send(null, respMsg); // Can still fail.
else
throw new GridException(
"Failed to send message since destination node has "
+ "left topology (ignoring) [nodeId="
+ nodeId
+ ", respMsg="
+ respMsg
+ ']');
}
}
/**
* Executes example.
*
* @param args Command line arguments, none required.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws Exception {
Timer timer = new Timer("priceBars");
// Start grid.
final Grid g = GridGain.start("examples/config/example-streamer.xml");
System.out.println();
System.out.println(">>> Streaming price bars example started.");
try {
TimerTask task = scheduleQuery(g, timer);
streamData(g);
// Force one more run to get final results.
task.run();
timer.cancel();
// Reset all streamers on all nodes to make sure that
// consecutive executions start from scratch.
g.compute()
.broadcast(
new Runnable() {
@Override
public void run() {
if (!ExamplesUtils.hasStreamer(g, "priceBars"))
System.err.println(
"Default streamer not found (is example-streamer.xml "
+ "configuration used on all nodes?)");
else {
GridStreamer streamer = g.streamer("priceBars");
System.out.println("Clearing bars from streamer.");
streamer.reset();
}
}
})
.get();
} finally {
GridGain.stop(true);
}
}
/** @throws Exception If failed. */
public void testDifferentTaskNameLocally() throws Exception {
Grid grid = startGrid(0, new GridSpringResourceContextImpl(new GenericApplicationContext()));
// Versions are different - should not share
// 2 resource created locally
try {
grid.compute().execute(SharedResourceTask1Version1.class, null).get();
try {
grid.compute().execute(SharedResourceTask1Version2.class, null).get();
assert false : "SharedResourceTask4 should not be allowed to deploy.";
} catch (GridException e) {
info("Received expected exception: " + e);
}
} finally {
GridTestUtils.close(grid, log());
}
}
/**
* Method declaration
*
* @param r
*/
void formatResultSet(ResultSet r) {
if (r == null) {
String g[] = new String[1];
g[0] = "Result";
gResult.setHead(g);
g[0] = "(empty)";
gResult.addRow(g);
return;
}
try {
ResultSetMetaData m = r.getMetaData();
int col = m.getColumnCount();
String h[] = new String[col];
for (int i = 1; i <= col; i++) {
h[i - 1] = m.getColumnLabel(i);
}
gResult.setHead(h);
while (r.next()) {
for (int i = 1; i <= col; i++) {
h[i - 1] = r.getString(i);
if (r.wasNull()) {
h[i - 1] = "(null)";
}
}
gResult.addRow(h);
}
r.close();
} catch (SQLException e) {
}
}
/**
* @param g Grid.
* @return Non-system caches.
*/
private Collection<GridCacheConfiguration> caches(Grid g) {
return F.view(
Arrays.asList(g.configuration().getCacheConfiguration()),
new GridPredicate<GridCacheConfiguration>() {
@Override
public boolean apply(GridCacheConfiguration c) {
return c.getName() == null || !c.getName().equals(CU.UTILITY_CACHE_NAME);
}
});
}
