Print

[ernst]

hi all,

could a task itself decide it's failed? or cancel itself  an restart maybe on another node?

[lolo]

Hello,

Yes, a task can decide that it failed and act accordingly. JPPF does not provide any API to cancel a single task, however it is possible to cancel the job currently executing in the node.
This requires a custom implementation of a node life cycle listener. Here is a simple example:

Code: [Select]

import org.jppf.management.JMXNodeConnectionWrapper;
import org.jppf.node.event.*;

// Simple node listener implementation that enables tasks
// to cancel the current job while executing in the node.
public class SelfCancelNodeListener implements NodeLifeCycleListener {
  // holds the uuid of the job being executed.
  private  static String currentJobUuid = null;

  @Override
  public void jobStarting(final NodeLifeCycleEvent event)
  {
    SelfCancelNodeListener.setCurrentJobUuid(event.getJob().getUuid());
  }

  @Override
  public void jobEnding(final NodeLifeCycleEvent event)
  {
    // reset the uuid
    SelfCancelNodeListener.setCurrentJobUuid(null);
  }

  // get the uuid of the job being executed.
  public static synchronized String getCurrentJobUuid() {
    return currentJobUuid;
  }

  // set the uuid of the job being executed.
  public static synchronized void setCurrentJobUuid(final String currentJobUuid) {
    SelfCancelNodeListener.currentJobUuid = currentJobUuid;
  }

  // cancel the job. "resubmit = true" means the job should be resubmitted to another node.
  public static void cancelCurrentJob(final boolean resubmit) {
    String uuid = getCurrentJobUuid();
    if (uuid != null) {
      // no-args contructor implies connection to local (same JVM) JMX server
      JMXNodeConnectionWrapper nodeJmx = new JMXNodeConnectionWrapper();
      nodeJmx.connect();
      try {
        nodeJmx.cancelJob(uuid, resubmit);
      } catch (Exception e) {
        System.out.println("error while attempting to cancel job with uuid=" + uuid);
        e.printStackTrace();
      }
    }
  }

  @Override
  public void nodeStarting(final NodeLifeCycleEvent event) {
  }

  @Override
  public void nodeEnding(final NodeLifeCycleEvent event) {
  }
}
Here, we can see that we need the NodeLifeCycleListener implementation so we can gain access to the job uuid, in order to cancel it. Also note the use of the boolean flag in JMXNodeConnectionWrapper.cancelJob(), to indicate whether the job should be resubmitted by the driver.

In your tasks this could be used as follows:

Code: [Select]

import org.jppf.server.protocol.JPPFTask;

// A simple task that may cancel the current job while executing in the node.
public class SelfCancelTask extends JPPFTask {
  @Override
  public void run() {
    // ... some code here ...

    // cancel the job and specify that we want the driver to resubmit it to another node
    SelfCancelNodeListener.cancelCurrentJob(true);
  }

  @Override
  public void onCancel() {
    System.out.println("this task has been cancelled");
  }
}
I hope this helps.

Sincerely,
-Laurent

[ernst]

no, i would restart the task. all my tasks are completely independent, so if one fails, it's no a good idea to kill the whole job...
so ok i have to solve this problem in another way

[lolo]

Hello,

I agree this solution is not fitting for your use case.
One possibility would be to have the cancellation logic within the tasks, making it mark the cancelled tasks with a flag, then on the client side check the resulting tasks for this flag, and submit a new job with only those tasks that were cancelled.

Also, if you have advance knowledge of what would cause a task to abort in a specific node, you might want to consider using execution policies to avoid sending those tasks to inappropriate nodes and cancel them as a result. If you could elaborate a little on why your tasks would need to be cancelled, maybe we can devise a more appropriate strategy?

Sincerely,
-Laurent