Thank you very much, Martin! I think the first suggestion is the one I should be going with. Although there is no method with the signature signal( execId, signalName, data). All I've seen is that I can only hand over a map to the signal and evaluate that one. The signalEvent and the signalData of
public void signal(ActivityExecution execution, String signalEvent, Object signalData)
are null.
I'm using a process manager now which uses a registry with system process id <> activiti execution id mapping.
Basically this:
public class ProcessManager {
public static Map<Integer,String> registry = new HashMap<>();
public static void register( Integer processId, String executionId) {
registry.put( processId, executionId);
}
public static void unregister( Integer processId) {
registry.remove( processId);
}
}
public class ShellTask implements SignallableActivityBehavior {
@Override
public void execute(ActivityExecution execution) throws Exception {
Thread thread = new Thread( new ProcessExecutor( execution.getId()));
thread.start();
}
@Override
public void signal(ActivityExecution execution, String signalEvent, Object signalData) throws Exception {
Map<String,Object> map = execution.getVariables();
System.out.println( "EXECUTION_RESULT = " + map.get( "EXECUTION_RESULT"));
if( !map.containsKey( "EXECUTION_RESULT")
return;
PvmTransition transition = execution.getActivity().getOutgoingTransitions().get( 0);
execution.take( transition);
}
}
public class ProcessExecutor implements Runnable {
private Integer processId;
private String executionId;
public ProcessExecutor( String executionId) {
this.executionId = executionId;
}
@Override
public void run() {
try {
Process process = Runtime.getRuntime().exec( "notepad.exe");
processId = process.getId();
ProcessManager.register( processId, executionId);
process.waitFor(); // just for testing; the actual process will run asynchronously
} catch( IOException | InterruptedException e) {
e.printStackTrace();
} finally {
// send signal after process finishes
// just for testing; this block will be executed in a process monitor which checks if the async process has completed
Map<String,Object> map = new HashMap<>();
map.put( "EXECUTION_RESULT", "SUCCESS");
processEngine.getRuntimeService().signal( executionId, map);
ProcessManager.unregister( processId);
}
}
}
Of course the registry should store the data in the database in order to survive a server restart.
If there's a better approach or something like this that's already available in Activiti, I'd be glad to hear it.
