/** * 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); } }