The Stardust provides the Service Provider Interface IProcessExecutionMonitor
to monitor process execution.
Please refer to the according JavaDoc
IProcessExecutionMonitor for detailed information on the interface.
package org.eclipse.stardust.engine.core.spi.monitoring;
import org.eclipse.stardust.common.annotations.SPI;
import org.eclipse.stardust.common.annotations.Status;
import org.eclipse.stardust.common.annotations.UseRestriction;
import org.eclipse.stardust.engine.core.runtime.beans.IProcessInstance;
@SPI(useRestriction = UseRestriction.Public, status = Status.Stable)
public interface IProcessExecutionMonitor
{
void processStarted(IProcessInstance process);
void processCompleted(IProcessInstance process);
void processAborted(IProcessInstance process);
void processInterrupted(IProcessInstance process);
}
The interface has several methods for propagating process execution states:
processStarted - propagates that the process has startedprocessCompleted - propagates that the process has completedprocessAborted - propagates that the process abortedprocessInterrupted - propagates that the process has been interruptedTo implement the
IProcessExecutionMonitor
interface and publish the implementation to the engine, a file named by the interface's
factory has to be created in the /META-INF/services folder of the jar.
Perform the following steps:
org.eclipse.stardust.engine.core.spi.monitoring.IProcessExecutionMonitor.
The file contents needs to be the fully qualified name of your implementation class,
e.g. org.eclipse.stardust.example.ProcessExecutionMonitorImpl.META-INF/services folder of the jar that will contain your implementation class
package org.eclipse.stardust.example;
import org.eclipse.stardust.engine.core.runtime.beans.IProcessInstance;
import org.eclipse.stardust.engine.core.spi.monitoring.IProcessExecutionMonitor;
public class ProcessExecutionMonitorImpl implements IProcessExecutionMonitor {
@Override
public void processStarted(IProcessInstance process) {
}
@Override
public void processCompleted(IProcessInstance process) {
}
@Override
public void processAborted(IProcessInstance process) {
}
@Override
public void processInterrupted(IProcessInstance process) {
}
}
A process execution monitor implementation is called in the same transaction of the previously executed activity thread. If you like to publish the last performed activity in the process, it might not have been committed yet and possibly cannot be fetched.
In that case, you could look up the activity instance cache (thread local) to get the activity instances that have been created as part of the currently running transaction. The code should look similar as the following:
Session session = (Session) PropertyLayerProviderInterceptor.getCurrent().getAuditTrailSession();
Collection cache = session.getCache(ActivityInstanceBean.class);
for (Iterator i = cache.iterator(); i.hasNext();) {
ActivityInstanceBean ai = (ActivityInstanceBean) ((DefaultPersistenceController) i.next()).getPersistent();
...
}
Please note that, if the cache does not contain any activity instance you would still have to look what has been persisted so far by using the following method:
IProcessInstance.getAllPerformedActivityInstances()
Note
The above code is not part of our public API, but it can be considered to be
a very stable internal API. Please take in account that implementation details might change.
To retrieve custom Spring beans from the Monitor implementation class, you can use method getApplicationContext of the SpringUtils class.
It returns the context bootstrapped by Stardust containing the Spring beans.
private ApplicationContext appContext;
appContext = SpringUtils.getApplicationContext();
if (null == appContext)
{
throw new PublicException("No Spring application context available.");
}
serviceBean = appContext.getBean(SpringBeanName(), type);