import org.gridgain.grid.*;

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

static final String TASK_NAME = "GridDeploymentExampleTask";

grid.deployTask(GridDeploymentExampleTask.class);

grid.execute(TASK_NAME, null).get();

grid.undeployTask(TASK_NAME);

package org.gridgain.examples.deployment.direct;

import org.gridgain.grid.*;

/**
 * This example demonstrates how to explicitly deploy a task. Note that
 * it is very rare when you would need such functionality as tasks are
 * auto-deployed on demand first time you execute them. So in most cases
 * you would just call any of the <tt>Grid.execute(...)</tt> methods directly.
 * However, sometimes a task is not in local class path, so you may not even
 * know the code it will execute, but you still need to execute it. For example,
 * you have two independent components in the system, and one loads the task
 * classes from some external source and deploys it; then another component
 * can execute it just knowing the name of the task.
 * <p>
 * Also note that for simplicity of the example, the task we execute is
 * in system classpath, so even in this case the deployment step is unnecessary.
 */
public final class GridDeploymentExample {
    /** Name of the deployed task. */
    static final String TASK_NAME = "GridDeploymentExampleTask";

    /**
     * Ensure singleton.
     */
    private GridDeploymentExample() {
        // No-op.
    }

    /**
     * Deploy, execute and undeploy <tt>HelloWorld</tt> example on the grid.
     *
     * @param args Command line arguments, none required but if provided
     *      first one should point to the Spring configuration file. See
     *      <tt>"examples/config/"</tt> for configuration file examples.
     * @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 {
            Grid grid = GridFactory.getGrid();


            // This task will be deployed on local node and then peer-loaded
            // onto remote nodes on demand.  For this example this task as
            // available on the classpath, however in real life that may not
            // always be the case. In those cases you should use explicit
            // 'Grid.deployTask(Class)}' call and then use 'Grid.execute(String, Object)'
            // method passing your task name as first parameter.
            grid.deployTask(GridDeploymentExampleTask.class);

            for (Class<? extends GridTask> taskCls : grid.getLocalTasks().values()) {
                System.out.println(">>> Found locally deployed task: " + taskCls);
            }

            // Execute the task passing name as a parameter. The system will find
            // the deployed task by its name and execute it.
            grid.execute(TASK_NAME, null).get();

            // Undeploy task
            grid.undeployTask(TASK_NAME);

            System.out.println(">>>");
            System.out.println(">>> Finished executing Grid Direct Deployment Example.");
            System.out.println(">>> Check participating nodes output.");
            System.out.println(">>>");
        }
        finally {
            GridFactory.stop(true);
        }
    }
}

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

@GridTaskName(GridDeploymentExample.TASK_NAME)

package org.gridgain.examples.deployment.direct;

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

/**
 * Example task used to demonstrate direct task deployment through API.
 * For this example this task as available on the classpath, however
 * in real life that may not always be the case. In those cases
 * you should use explicit {@link Grid#deployTask(Class)} call and
 * then use {@link Grid#execute(String, Object)} method passing your
 * task name as first parameter.
 * <p>
 * Note that this task specifies explicit task name. Task name is optional
 * and is added here for demonstration purpose. If not provided, it will
 * default to the task class name.
 */
@GridTaskName(GridDeploymentExample.TASK_NAME)
public class GridDeploymentExampleTask extends GridTaskAdapter<String> {
    /** Grid logger. */
    @GridLoggerResource
    private GridLogger log = null;

    /** Instance of grid. */
    @GridInstanceResource
    private Grid grid = null;

    /**
     * {@inheritDoc}
     */
    public Map<? extends GridJob, GridNode> map(List<GridNode> subgrid, String arg) throws GridException {
        GridJob job = new GridJobAdapter() {
            /*
             * Simply prints the job's argument.
             */
            public Serializable execute() {
                if (log.isInfoEnabled() == true) {
                    log.info(">>> Exectuting deployment example job on this node.");
                }

                // This job does not return any result.
                return null;
            }
        };

        Map<GridJob, GridNode> jobs = new HashMap<GridJob, GridNode>(1);

        // Use only local node for this example.
        jobs.put(job, grid.getLocalNode());

        return jobs;
    }

    /**
     * {@inheritDoc}
     */
    public Serializable reduce(List<GridJobResult> results) throws GridException {
        // Nothing to reduce.
        return null;
    }