/**
* 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);
}
}
/** @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);
}
}
/**
* @param args Command arguments.
* @throws GridException If failed.
*/
public static void main(String[] args) throws GridException {
// Starts grid.
Grid grid = args.length == 0 ? G.start() : G.start(args[0]);
try {
// Create portfolio.
GridCredit[] portfolio = new GridCredit[5000];
Random rnd = new Random();
// Generate some test portfolio items.
for (int i = 0; i < portfolio.length; i++) {
portfolio[i] =
new GridCredit(
50000 * rnd.nextDouble(), // Credit amount.
rnd.nextInt(1000), // Credit term in days.
rnd.nextDouble() / 10, // APR.
rnd.nextDouble() / 20 + 0.02 // EDF.
);
}
// Forecast horizon in days.
int horizon = 365;
// Number of Monte-Carlo iterations.
int iter = 10000;
// Percentile.
double percentile = 0.95;
// Mark the stopwatch.
long start = System.currentTimeMillis();
// Calculate credit risk and print it out.
// As you can see the grid enabling is completely hidden from the caller
// and it is fully transparent to him. In fact, the caller is never directly
// aware if method was executed just locally or on the 100s of grid nodes.
// Credit risk crdRisk is the minimal amount that creditor has to have
// available to cover possible defaults.
double crdRisk =
grid.reduce(
SPREAD,
closures(grid.size(), portfolio, horizon, iter, percentile),
new R1<Double, Double>() {
/** Collected values sum. */
private double sum;
/** Collected values count. */
private int count;
/** {@inheritDoc} */
@Override
public boolean collect(Double e) {
sum += e;
count++;
return true;
}
/** {@inheritDoc} */
@Override
public Double apply() {
return sum / count;
}
});
X.println(
"Credit risk [crdRisk="
+ crdRisk
+ ", duration="
+ (System.currentTimeMillis() - start)
+ "ms]");
}
// We specifically don't do any error handling here to
// simplify the example. Real application may want to
// add error handling and application specific recovery.
finally {
// Stops grid.
G.stop(true);
}
}
/**
* Runs basic cache example.
*
* @param args Command line arguments, none required.
* @throws Exception If example execution failed.
*/
public static void main(String[] args) throws Exception {
final Grid g =
args.length == 0 ? G.start("examples/config/spring-cache.xml") : G.start(args[0]);
try {
// Subscribe to events on every node, so we can visualize what's
// happening in remote caches.
g.run(
BROADCAST,
new CA() {
@Override
public void apply() {
GridLocalEventListener lsnr =
new GridLocalEventListener() {
@Override
public void onEvent(GridEvent event) {
switch (event.type()) {
case EVT_CACHE_OBJECT_PUT:
case EVT_CACHE_OBJECT_READ:
case EVT_CACHE_OBJECT_REMOVED:
{
GridCacheEvent e = (GridCacheEvent) event;
X.println("Cache event [name=" + e.name() + ", key=" + e.key() + ']');
}
}
}
};
GridNodeLocal<String, GridLocalEventListener> loc = g.nodeLocal();
GridLocalEventListener prev = loc.remove("lsnr");
// If there is a listener subscribed from previous runs, unsubscribe it.
if (prev != null) g.removeLocalEventListener(prev);
// Record new listener, so we can check it on next run.
loc.put("lsnr", lsnr);
// Subscribe listener.
g.addLocalEventListener(lsnr, EVTS_CACHE);
}
});
final GridCacheProjection<Integer, String> cache =
g.cache(CACHE_NAME).projection(Integer.class, String.class);
final int keyCnt = 20;
// Store keys in cache.
for (int i = 0; i < keyCnt; i++) cache.putx(i, Integer.toString(i));
// Peek and get on local node.
for (int i = 0; i < keyCnt; i++) {
X.println("Peeked [key=" + i + ", val=" + cache.peek(i) + ']');
X.println("Got [key=" + i + ", val=" + cache.get(i) + ']');
}
// Projection (view) for remote nodes.
GridProjection rmts = g.remoteProjection();
if (!rmts.isEmpty()) {
// Peek and get on remote nodes (comment it out if output gets too crowded).
g.remoteProjection()
.run(
BROADCAST,
new GridAbsClosureX() {
@Override
public void applyx() throws GridException {
for (int i = 0; i < keyCnt; i++) {
X.println("Peeked [key=" + i + ", val=" + cache.peek(i) + ']');
X.println("Got [key=" + i + ", val=" + cache.get(i) + ']');
}
}
});
}
} finally {
G.stop(true);
}
}
