import org.gridgain.grid.*;
import org.gridgain.grid.gridify.*;

GridFactory.start();
        
try {
    ...
}
finally {
    GridFactory.stop(true);
}

@Gridify(taskClass = GridifyHelloWorldCheckpointTask.class, timeout = 60000)
public static int sayIt(String phrase) {
    // Simply print out the argument.
    System.out.println(">>>");
    System.out.println(">>> Printing '" + phrase + "' on this node from grid-enabled method.");
    System.out.println(">>>");

    return phrase.length();
}

package org.gridgain.examples.helloworld.gridify.checkpoint;

import org.gridgain.grid.*;
import org.gridgain.grid.gridify.*;
import org.gridgain.grid.gridify.aop.spring.*;

public final class GridifyHelloWorldCheckpointExample {
    /**
     * Enforces singleton.
     */
    private GridifyHelloWorldCheckpointExample() {
        // No-op.
    }
    
    /**
     * Method grid-enabled with {@link Gridify} annotation. Simply prints
     * out the argument passed in.
     *
     * @param arg String to print.
     */
    @Gridify(taskClass = GridifyHelloWorldCheckpointTask.class, timeout = 60000)
    public static int sayIt(String phrase) {
        // Simply print out the argument.
        System.out.println(">>>");
        System.out.println(">>> Printing '" + phrase + "' on this node from grid-enabled method.");
        System.out.println(">>>");

        return phrase.length();
    }

    /**
     * Execute <tt>HelloWorld</tt> example grid-enabled with <tt>Gridify</tt> annotation.
     *
     * @param args Command line arguments, none required but user may
     *      set configuration file path as the only parameter. For GigaSpaces
     *      checkpoint SPI user should pass <tt>"examples/config/gigaspaces.xml"</tt>
     *      as VM configuration parameter.
     * @throws GridException If example execution failed.
     */
    public static void main(String[] args) throws GridException {
        if (args.length == 0) {
            GridFactory.start();
        }
        else {
            GridFactory.start(args[0]);
        }

        try {
            // This method will be executed on a remote grid node.
            int phraseLen = sayIt("Hello World");

            System.out.println(">>>");
            System.out.println(">>> Finished executing Gridify \"Hello World\" example with checkpoints.");
            System.out.println(">>> Total number of characters in the phrase is '" + phraseLen + "'.");
            System.out.println(">>> You should see exception stack trace from failed job on one node.");
            System.out.println(">>> Failed job will be failed over to another node.");
            System.out.println(">>> You should see print out of 'Hello World' on another node.");
            System.out.println(">>> Check all nodes for output (this node is also part of the grid).");
            System.out.println(">>>");
        }
        finally {
            GridFactory.stop(true);
        }
    }
}

import org.gridgain.grid.gridify.*;
import org.gridgain.grid.*;
import org.gridgain.grid.resources.*;

package org.gridgain.examples.helloworld.gridify.checkpoint;

import org.gridgain.grid.*;
import org.gridgain.grid.resources.*;
import org.gridgain.grid.gridify.*;
import java.util.*;
import java.io.*;

/**
 * This grid task demonstrates some basic usage of task session checkpoints and failover.
 * It does the following:
 * <ol>
 * <li>Save checkpoint with key '<tt>fail</tt>' and value '<tt>true</tt>'.</li>
 * <li>Pass the passed in string as an argument into remote job for execution.</li>
 * <li>
 *   The job will check the value of checkpoint with key '<tt>fail</tt>'. If it
 *   is <tt>true</tt>, then it will set it to <tt>false</tt> and throw
 *   exception to simulate a failure. If it is <tt>false</tt>, then
 *   it will execute the grid-enabled method.
 * </li>
 * </ol>
 * Note that when job throws an exception it will be treated as a failure
 * by {@link #result(GridJobResult,List)} method which will return
 * {@link GridJobResultPolicy#FAILOVER} policy. This will cause the job to
 * automatically failover to another node for execution. The new job will
 * simply print out the argument passed in.
 */
public class GridifyHelloWorldCheckpointTask extends GridifyTaskSplitAdapter<Integer> {
    /** Injected task session. */
    @GridTaskSessionResource
    private GridTaskSession taskSes = null;

    /**
     * {@inheritDoc}
     */
    @Override
    public Collection<? extends GridJob> split(int gridSize, GridifyArgument arg) throws GridException {
        // Make reasonably unique checkpoint key.
        final String cpKey = getClass().getName() + arg;

        taskSes.saveCheckpoint(cpKey, true);

        String phrase = ((String)arg.getMethodParameters()[0]);

        return Collections.singletonList(new GridJobAdapter<String>(phrase) {
            /** Injected distributed task session. */
            @GridTaskSessionResource
            private GridTaskSession jobSes = null;

            /**
             * The job will check the checkpoint with key '<tt>fail</tt>' and if
             * it's <tt>true</tt> it will throw exception to simulate a failure.
             * Otherwise, it will execute the grid-enabled method.
             */
            public Serializable execute() throws GridException {
                boolean fail = (Boolean)jobSes.loadCheckpoint(cpKey);

                if (fail == true) {
                    jobSes.saveCheckpoint(cpKey, false);

                    throw new GridException("Example job exception.");
                }

                // Execute gridified method.
                // Note that since we are calling this method from within the grid job
                // AOP-based grid enabling will not cross-cut it and method will just
                // execute normally.
                return GridifyHelloWorldCheckpointExample.sayIt(getArgument());
            }
        });
    }

    /**
     * To facilitate example's logic, returns {@link GridJobResultPolicy#FAILOVER}
     * policy in case of any exception.
     *
     * @param result Job result.
     * @param received All previously received results.
     * @throws GridException {@inheritDoc}
     * @return {@inheritDoc}
     */
    @Override
    public GridJobResultPolicy result(GridJobResult result, List<GridJobResult> received) throws GridException {
        return result.getException() != null ? GridJobResultPolicy.FAILOVER : GridJobResultPolicy.WAIT;
    }

    /**
     * Sums up all characters from all jobs and returns a
     * total number of characters in the initial phrase.
     *
     * @param results Job results.
     * @return Number of letters for the phrase passed into
     *      {@link GridifyHelloWorldCheckpointExample#sayIt(String)} method.
     * @throws GridException If reduce failed.
     */
    public Integer reduce(List<GridJobResult> results) throws GridException {
        // We only had one job in the split. Therefore,
        // we only have one result.
        Integer charCnt = results.get(0).getData();

        // Total number of characters in the phrase
        // passed into task execution.
        return charCnt;
    }
}