/**
* Execute {@code HelloWorld} example on the grid.
*
* @param args Command line arguments, none required but if provided first one should point to the
* Spring XML configuration file. See {@code "examples/config/"} for configuration file
* examples.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws GridException {
if (args.length == 0) {
G.start();
} else {
G.start(args[0]);
}
try {
Grid grid = G.grid();
// Execute Hello World task.
GridTaskFuture<Integer> fut = grid.execute(GridHelloWorldTask.class, "Hello World");
// Wait for task completion.
int phraseLen = fut.get();
X.println(">>>");
X.println(">>> Finished executing Grid \"Hello World\" example with custom task.");
X.println(">>> Total number of characters in the phrase is '" + phraseLen + "'.");
X.println(">>> You should see print out of 'Hello' on one node and 'World' on another node.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
} finally {
G.stop(true);
}
}
/**
* Execute {@code HelloWorld} example on the grid.
*
* @param args Command line arguments, none required but if provided first one should point to the
* Spring XML configuration file. See {@code "examples/config/"} for configuration file
* examples.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws GridException {
if (args.length == 0) {
G.start();
} else {
G.start(args[0]);
}
try {
// Broadcast this message to all nodes using GridClosure.
broadcastWordsClosure("Broadcasting This Message To All Nodes!");
// Print individual words from this phrase on different nodes
// using GridClosure
spreadWordsClosure("Print Worlds Functional Style!");
// Print this message using anonymous runnable object.
unicastWordsRunnable("Printing This Message From Runnable!");
// Split the message into words and pass them as arguments
// for remote execution of Callable objects.
countLettersCallable("Letter Count With Callable!");
// Split the message into words and pass them as arguments
// for remote execution of GridClosure objects.
countLettersClosure("Letter Count With Closure!");
// Split the message into words and pass them as arguments
// for remote execution of GridClosure objects and
// then aggregate results using GridReducer.
countLettersReducer("Letter Count With Reducer!");
} finally {
G.stop(true);
}
}
/**
* Execute {@code HelloWorld} example grid-enabled with {@code Gridify} annotation.
*
* @param args Command line arguments, none required but if provided first one should point to the
* Spring XML configuration file. See {@code "examples/config/"} for configuration file
* examples.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws GridException {
if (args.length == 0) {
G.start();
} else {
G.start(args[0]);
}
try {
// Simple example stateful instance to demonstrate
// how object state can be handled with grid-enabled methods.
GridifyHelloWorld helloWorld = new GridifyHelloWorld();
// Set simple state.
helloWorld.setState("Hello World");
// This method is grid-enabled and
// will be executed on remote grid nodes.
int phraseLen = helloWorld.sayIt();
X.println(">>>");
X.println(">>> Finished executing Gridify \"Hello World\" stateful example.");
X.println(">>> Total number of characters in the phrase is '" + phraseLen + "'.");
X.println(">>> You should see print out of 'Hello' on one node and 'World' on another node.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
} finally {
G.stop(true);
}
}
/**
* Prints a phrase on one of the grid nodes running anonymous runnable.
*
* @param phrase Phrase to print on one of the grid nodes.
* @throws GridException If failed.
*/
private static void unicastWordsRunnable(final String phrase) throws GridException {
X.println(">>> Starting unicastWordsRunnable() example...");
G.grid()
.run(
UNICAST,
new GridRunnable() {
@Override
public void run() {
X.println(">>> Printing phrase: " + phrase);
}
});
// NOTE:
//
// Alternatively, you can use existing closure 'F.println()' to
// print any text like so:
//
// G.grid().run(UNICAST, F.println(">>> Printing phrase: " + phrase));
//
X.println(">>>");
X.println(">>> Finished execution of runnable object based on GridGain 3.0 API.");
X.println(">>> You should see the phrase '" + phrase + "' printed out on one of the nodes.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
}
/** @throws Exception If failed. */
public void testRemoteIfDataCacheNameEquals() throws Exception {
GridConfiguration g2Cfg = getConfiguration("g2");
GridGgfsConfiguration g2GgfsCfg1 = new GridGgfsConfiguration(g1GgfsCfg1);
GridGgfsConfiguration g2GgfsCfg2 = new GridGgfsConfiguration(g1GgfsCfg2);
g2GgfsCfg1.setName("g2GgfsCfg1");
g2GgfsCfg2.setName("g2GgfsCfg2");
g2GgfsCfg1.setMetaCacheName("g2MetaCache1");
g2GgfsCfg2.setMetaCacheName("g2MetaCache2");
g1Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setCacheConfiguration(
concat(
dataCaches(1024),
metaCaches("g2MetaCache1", "g2MetaCache2"),
GridCacheConfiguration.class));
g2Cfg.setGgfsConfiguration(g2GgfsCfg1, g2GgfsCfg2);
G.start(g1Cfg);
checkGridStartFails(
g2Cfg, "Data cache names should be different for different GGFS instances", false);
}
/**
* Broadcasts a give phrase to all nodes.
*
* @param phrase Phrase to broadcast.
* @throws GridException If failed.
*/
private static void broadcastWordsClosure(final String phrase) throws GridException {
X.println(">>> Starting broadcastWordsClosure() example...");
G.grid()
.run(
BROADCAST,
new GridAbsClosure() {
@Override
public void apply() {
X.println(">>> Printing phrase: " + phrase);
}
});
// NOTE:
//
// Alternatively, you can use existing closure 'F.println()' to
// print any text like so:
//
// G.grid().run(BROADCAST, F.println(">>> Printing phrase: " + phrase));
//
X.println(">>>");
X.println(">>> Finished broadcasting a phrase to all grid nodes based on GridGain 3.0 API.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
}
/** @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));
}
}
/**
* Prints every word a phrase on different nodes.
*
* @param phrase Phrase from which to print words on different nodes.
* @throws GridException If failed.
*/
private static void spreadWordsClosure(String phrase) throws GridException {
X.println(">>> Starting spreadWordsClosure() example...");
// Splits the passed in phrase into words and prints every word
// on a individual grid node. If there are more words than nodes -
// some nodes will print more than one word.
G.grid()
.run(
SPREAD,
F.yield(
phrase.split(" "),
new GridInClosure<String>() {
@Override
public void apply(String word) {
X.println(word);
}
}));
// NOTE:
//
// Alternatively, you can use existing closure 'F.println()' to
// print any yield result in 'F.yield()' like so:
//
// G.grid().run(SPREAD, F.yield(phrase.split(" "), F.println()));
//
X.println(">>>");
X.println(
">>> Finished printing individual words on different nodes based on GridGain 3.0 API.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
}
/**
* Prints a phrase on the grid nodes running anonymous callable objects and calculating total
* number of letters.
*
* @param phrase Phrase to print on of the grid nodes.
* @throws GridException If failed.
*/
private static void countLettersCallable(String phrase) throws GridException {
X.println(">>> Starting countLettersCallable() example...");
Collection<Callable<Integer>> calls = new HashSet<Callable<Integer>>();
for (final String word : phrase.split(" "))
calls.add(
new GridCallable<Integer>() { // Create executable logic.
@Override
public Integer call() throws Exception {
// Print out a given word, just so we can
// see which node is doing what.
X.println(">>> Executing word: " + word);
// Return the length of a given word, i.e. number of letters.
return word.length();
}
});
// Explicitly execute the collection of callable objects and receive a result.
Collection<Integer> results = G.grid().call(SPREAD, calls);
// Add up all results using convenience 'sum()' method on GridFunc class.
int letterCnt = F.sum(results);
X.println(">>>");
X.println(
">>> Finished execution of counting letters with callables based on GridGain 3.0 API.");
X.println(">>> You should see the phrase '" + phrase + "' printed out on the nodes.");
X.println(">>> Total number of letters in the phrase is '" + letterCnt + "'.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
}
/**
* Check if flags in correct state.
*
* @param msg Message.
*/
private void checkSyncFlags(GridIoMessage msg) {
if (!commSpiEnabled) return;
Object o = msg.message();
if (!(o instanceof GridDistributedLockRequest)) return;
GridKernal g = (GridKernal) G.grid(nodeId);
GridCacheTxManager<Object, Object> tm =
g.internalCache(REPLICATED_ASYNC_CACHE_NAME).context().tm();
GridCacheVersion v = ((GridCacheVersionable) o).version();
GridCacheTxEx t = tm.tx(v);
if (t.hasWriteKey("x1")) {
assertFalse(t.syncCommit());
} else if (t.hasWriteKey("x2")) {
assertTrue(t.syncCommit());
} else if (t.hasWriteKey("x3")) {
assertFalse(t.syncCommit());
} else if (t.hasWriteKey("x4")) {
assertTrue(t.syncCommit());
}
}
/** @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);
}
}
/**
* Prints a phrase on the grid nodes running anonymous closure objects and calculating total
* number of letters.
*
* @param phrase Phrase to print on of the grid nodes.
* @throws GridException If failed.
*/
private static void countLettersClosure(String phrase) throws GridException {
X.println(">>> Starting countLettersClosure() example...");
// Explicitly execute the collection of callable objects and receive a result.
Collection<Integer> results =
G.grid()
.call(
SPREAD,
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.
X.println(">>> Executing word: " + word);
// Return the length of a given word, i.e. number of letters.
return word.length();
}
},
Arrays.asList(phrase.split(" "))); // Collection of arguments for closures.
// Add up all results using convenience 'sum()' method.
int letterCnt = F.sum(results);
X.println(">>>");
X.println(">>> Finished execution of counting letters with closure based on GridGain 3.0 API.");
X.println(">>> You should see the phrase '" + phrase + "' printed out on the nodes.");
X.println(">>> Total number of letters in the phrase is '" + letterCnt + "'.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
}
/** @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;
}
/** @throws Exception If failed. */
@SuppressWarnings("NullableProblems")
public void testLocalNullGgfsNameIsSupported() throws Exception {
g1Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g1GgfsCfg1.setName(null);
assertFalse(G.start(g1Cfg).nodes().isEmpty());
}
/**
* Execute {@code HelloWorld} example grid-enabled with {@code Gridify} annotation.
*
* @param args Command line arguments, none required but if provided first one should point to the
* Spring XML configuration file. See {@code "examples/config/"} for configuration file
* examples.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws GridException {
if (args.length == 0) {
G.start();
} else {
G.start(args[0]);
}
try {
// This method will be executed on a remote grid nodes.
int phraseLen = sayIt("Hello World");
X.println(">>>");
X.println(">>> Finished executing Gridify \"Hello World\" example with custom task.");
X.println(">>> Total number of characters in the phrase is '" + phraseLen + "'.");
X.println(">>> You should see print out of 'Hello' on one node and 'World' on another node.");
X.println(">>> Check all nodes for output (this node is also part of the grid).");
X.println(">>>");
} finally {
G.stop(true);
}
}
/**
* Executes example of calculation of the greatest common divisor (GCD) and the lowest common
* multiple (LCM) for each generated pair of integers using new functional APIs.
*
* @param args Command line arguments, none required but if provided first one should point to the
* Spring XML configuration file. See {@code "examples/config/"} for configuration file
* examples.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws Exception {
// Typedefs:
// ---------
// G -> GridFactory
// CI1 -> GridInClosure
// CO -> GridOutClosure
// CA -> GridAbsClosure
// F -> GridFunc
G.in(
args.length == 0 ? null : args[0],
new CIX1<Grid>() {
@Override
public void applyx(Grid g) throws GridException {
// Bound for random numbers.
int bound = 100;
// Collection size.
int size = 10;
// Initialises collection of pair random numbers.
Collection<int[]> pairs = new ArrayList<int[]>(size);
// Fills collection.
for (int i = 0; i < size; i++) {
pairs.add(
new int[] {
GridNumberUtilExample.getRand(bound), GridNumberUtilExample.getRand(bound)
});
}
// Calculates and prints GCD and LCM for each pair of numbers with closure.
g.run(
SPREAD,
F.yield(
pairs,
new CI1<int[]>() {
@Override
public void apply(int[] pair) {
int gcd = GridNumberUtilExample.getGCD(pair[0], pair[1]);
int lcm = GridNumberUtilExample.getLCM(pair[0], pair[1]);
System.out.printf(
">>>>> Numbers: %d and %d. GCD: %d. LCM: %d.%n",
pair[0], pair[1], gcd, lcm);
}
}));
// Prints.
X.println(">>>>> Check all nodes for numbers and their GCD and LCM output.");
}
});
}
/**
* Runs JDBC example.
*
* @param args Command line arguments.
* @throws Exception In case of error.
*/
public static void main(String[] args) throws Exception {
Grid grid = G.start("examples/config/spring-cache.xml");
Connection conn = null;
try {
// Populate cache with data.
populate(grid.cache(CACHE_NAME));
// Register JDBC driver.
Class.forName("org.gridgain.jdbc.GridJdbcDriver");
// Open JDBC connection.
conn =
DriverManager.getConnection("jdbc:gridgain://localhost/" + CACHE_NAME, configuration());
X.println(">>>");
// Query all persons.
queryAllPersons(conn);
X.println(">>>");
// Query person older than 30 years.
queryPersons(conn, 30);
X.println(">>>");
// Query persons working in GridGain.
queryPersonsInOrganization(conn, "GridGain");
X.println(">>>");
} finally {
// Close JDBC connection.
if (conn != null) conn.close();
G.stop(true);
}
}
/**
* 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(">>>");
}
/**
* Starts Grid instance. Note that if grid is already started, then it will be looked up and
* returned from this method.
*
* @return Started grid.
*/
private Grid startGrid() {
Properties props = System.getProperties();
gridName = props.getProperty(GRIDGAIN_NAME.name());
if (!props.containsKey(GRIDGAIN_NAME.name()) || G.state(gridName) != GridFactoryState.STARTED) {
selfStarted = true;
// Set class loader for the spring.
ClassLoader curCl = Thread.currentThread().getContextClassLoader();
// Add no-op logger to remove no-appender warning.
Appender app = new NullAppender();
Logger.getRootLogger().addAppender(app);
try {
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
Grid grid = G.start(cfgPath);
gridName = grid.name();
System.setProperty(GRIDGAIN_NAME.name(), grid.name());
return grid;
} catch (GridException e) {
throw new GridRuntimeException("Failed to start grid: " + cfgPath, e);
} finally {
Logger.getRootLogger().removeAppender(app);
Thread.currentThread().setContextClassLoader(curCl);
}
}
return G.grid(gridName);
}
/**
* Starts up grid and checks all provided values for prime.
*
* @param args Command line arguments, none required but if provided first one should point to the
* Spring XML configuration file. See {@code "examples/config/"} for configuration file
* examples.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws GridException {
// Starts grid.
Grid grid = args.length == 0 ? G.start() : G.start(args[0]);
// Values we want to check for prime.
long[] checkVals = {32452841, 32452843, 32452847, 32452849, 236887699, 217645199};
X.println(">>>");
X.println(
">>> Starting to check the following numbers for primes: " + Arrays.toString(checkVals));
try {
long start = System.currentTimeMillis();
for (long checkVal : checkVals) {
// This method will be executed on the Grid as it is
// annotated with @Gridify annotation.
Long divisor = GridPrimeChecker.checkPrime(checkVal, 2, checkVal);
// If divisor is null, then the number is prime.
if (divisor == null) {
X.println("Value '" + checkVal + "'is a prime number.");
} else {
X.println("Value '" + checkVal + "' is divisible by '" + divisor + '\'');
}
}
long totalTime = System.currentTimeMillis() - start;
X.println(">>> Total time to calculate all primes (milliseconds): " + totalTime);
X.println(">>>");
} finally {
// Stops grid.
G.stop(grid.name(), true);
}
}
/** @throws Exception If failed. */
public void testRemoteIfAffinityMapperGroupSizeDiffers() throws Exception {
GridConfiguration g2Cfg = getConfiguration("g2");
g1Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setCacheConfiguration(
concat(dataCaches(4021), metaCaches(), GridCacheConfiguration.class));
G.start(g1Cfg);
checkGridStartFails(
g2Cfg,
"Affinity mapper group size should be the same on all nodes in grid for GGFS",
false);
}
/**
* Executes {@link GridSegmentATask} and {@link GridSegmentBTask} tasks on the grid.
*
* @param args Command line arguments, none required or used.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws GridException {
AbstractApplicationContext ctx =
new ClassPathXmlApplicationContext("org/gridgain/examples/multispi/master.xml");
// Get configuration from Spring.
GridConfiguration cfg = ctx.getBean("grid.cfg", GridConfiguration.class);
G.start(cfg);
try {
Grid grid = G.grid();
// Execute task on segment "A".
GridTaskFuture<Integer> futA = grid.execute(GridSegmentATask.class, null);
// Execute task on segment "B".
GridTaskFuture<Integer> futB = grid.execute(GridSegmentBTask.class, null);
// Wait for task completion.
futA.get();
futB.get();
X.println(">>>");
X.println(">>> Finished executing Grid \"Multiple Topology\" example with custom tasks.");
X.println(
">>> You should see print out of 'Executing job on node that is from segment A.'"
+ "on node that has attribute \"segment=A\"");
X.println(
">>> and 'Executing job on node that is from segment B.' on node that has "
+ "attribute \"segment=B\"");
X.println(">>> Check all nodes for output (this node is not a part of the grid).");
X.println(">>>");
} finally {
G.stop(true);
}
}
/**
* 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()));
}
}
/**
* Starts new grid node.
*
* @param gridName name of new node.
* @param springCfg file with spring configuration to use for this node.
* @return a grid instance local to new node {@link GridGain#start(GridConfiguration)}.
* @throws Exception if node run failed.
*/
protected Grid startNode(String gridName, File springCfg) throws Exception {
assert springCfg != null;
ListableBeanFactory springCtx =
new FileSystemXmlApplicationContext("file:///" + springCfg.getAbsolutePath());
Map cfgMap = springCtx.getBeansOfType(GridConfiguration.class);
assert cfgMap != null;
assert !cfgMap.isEmpty();
GridConfiguration cfg = (GridConfiguration) cfgMap.values().iterator().next();
cfg.setGridName(gridName + "-" + getNextNodeNum());
return G.start(cfg);
}
/** @throws Exception If failed. */
public void testRemoteIfDataBlockSizeDiffers() throws Exception {
GridConfiguration g2Cfg = getConfiguration("g2");
g1Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
GridGgfsConfiguration g2GgfsCfg1 = new GridGgfsConfiguration(g1GgfsCfg1);
g2GgfsCfg1.setBlockSize(g2GgfsCfg1.getBlockSize() + 100);
g2Cfg.setGgfsConfiguration(g2GgfsCfg1, g1GgfsCfg2);
G.start(g1Cfg);
checkGridStartFails(
g2Cfg, "Data block size should be same on all nodes in grid for GGFS", false);
}
/**
* Checks that the given grid configuration will lead to {@link GridException} upon grid startup.
*
* @param cfg Grid configuration to check.
* @param excMsgSnippet Root cause (assertion) exception message snippet.
* @param testLoc {@code True} if checking is done for "testLocal" tests.
*/
private void checkGridStartFails(
GridConfiguration cfg, CharSequence excMsgSnippet, boolean testLoc) {
assertNotNull(cfg);
assertNotNull(excMsgSnippet);
try {
G.start(cfg);
fail("No exception has been thrown.");
} catch (GridException e) {
if (testLoc) {
if ("Failed to start processor: GridProcessorAdapter []".equals(e.getMessage())
&& e.getCause().getMessage().contains(excMsgSnippet)) return; // Expected exception.
} else if (e.getMessage().contains(excMsgSnippet)) return; // Expected exception.
error("Caught unexpected exception.", e);
fail();
}
}
/** @throws Exception If failed. */
public void testRemoteIfPathModeDiffers() throws Exception {
GridConfiguration g2Cfg = getConfiguration("g2");
GridGgfsConfiguration g2GgfsCfg1 = new GridGgfsConfiguration(g1GgfsCfg1);
GridGgfsConfiguration g2GgfsCfg2 = new GridGgfsConfiguration(g1GgfsCfg2);
g2GgfsCfg1.setPathModes(ImmutableMap.of("/somePath", DUAL_SYNC));
g2GgfsCfg2.setPathModes(ImmutableMap.of("/somePath", DUAL_SYNC));
g1Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setGgfsConfiguration(g2GgfsCfg1, g2GgfsCfg2);
G.start(g1Cfg);
checkGridStartFails(
g2Cfg, "Path modes should be the same on all nodes in grid for GGFS", false);
}
/** @throws Exception If failed. */
public void testRemoteIfMetaCacheNameDiffers() throws Exception {
GridConfiguration g2Cfg = getConfiguration("g2");
GridGgfsConfiguration g2GgfsCfg1 = new GridGgfsConfiguration(g1GgfsCfg1);
GridGgfsConfiguration g2GgfsCfg2 = new GridGgfsConfiguration(g1GgfsCfg2);
g2GgfsCfg1.setMetaCacheName("g2MetaCache1");
g2GgfsCfg2.setMetaCacheName("g2MetaCache2");
g1Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setCacheConfiguration(
concat(
dataCaches(1024),
metaCaches("g2MetaCache1", "g2MetaCache2"),
GridCacheConfiguration.class));
g2Cfg.setGgfsConfiguration(g2GgfsCfg1, g2GgfsCfg2);
G.start(g1Cfg);
checkGridStartFails(
g2Cfg, "Meta cache name should be the same on all nodes in grid for GGFS", false);
}
/** @throws Exception If failed. */
public void testRemoteIfDefaultModeDiffers() throws Exception {
GridConfiguration g2Cfg = getConfiguration("g2");
GridGgfsConfiguration g2GgfsCfg1 = new GridGgfsConfiguration(g1GgfsCfg1);
GridGgfsConfiguration g2GgfsCfg2 = new GridGgfsConfiguration(g1GgfsCfg2);
g1GgfsCfg1.setDefaultMode(DUAL_ASYNC);
g1GgfsCfg2.setDefaultMode(DUAL_ASYNC);
g2GgfsCfg1.setDefaultMode(DUAL_SYNC);
g2GgfsCfg2.setDefaultMode(DUAL_SYNC);
g1Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setCacheConfiguration(
concat(dataCaches(1024), metaCaches(), GridCacheConfiguration.class));
g2Cfg.setGgfsConfiguration(g2GgfsCfg1, g2GgfsCfg2);
G.start(g1Cfg);
checkGridStartFails(
g2Cfg, "Default mode should be the same on all nodes in grid for GGFS", false);
}
/**
* Executes information gathering example with closures.
*
* @param args Command line arguments, none required but if provided first one should point to the
* Spring XML configuration file. See {@code "examples/config/"} for configuration file
* examples.
* @throws GridException If example execution failed.
*/
public static void main(String[] args) throws Exception {
// Typedefs:
// ---------
// G -> GridFactory
// CI1 -> GridInClosure
// CO -> GridOutClosure
// CA -> GridAbsClosure
// F -> GridFunc
G.in(
args.length == 0 ? null : args[0],
new CIX1<Grid>() {
@Override
public void applyx(Grid g) throws GridException {
// Broadcast closure to all nodes for gathering their system information.
String res =
g.reduce(
GridClosureCallMode.BROADCAST,
Collections.<GridOutClosure<String>>singleton(
new CO<String>() {
@Override
public String apply() {
StringBuilder buf = new StringBuilder();
buf.append("OS: ")
.append(System.getProperty("os.name"))
.append(" ")
.append(System.getProperty("os.version"))
.append(" ")
.append(System.getProperty("os.arch"))
.append("\nUser: "******"user.name"))
.append("\nJRE: ")
.append(System.getProperty("java.runtime.name"))
.append(" ")
.append(System.getProperty("java.runtime.version"));
return buf.toString();
}
}),
new R1<String, String>() {
private StringBuilder buf = new StringBuilder();
@Override
public boolean collect(String s) {
buf.append("\n").append(s).append("\n");
return true;
}
@Override
public String apply() {
return buf.toString();
}
});
// Print result.
X.println("Nodes system information:");
X.println(res);
}
});
}