--- /dev/null
+package org.argeo.slc.core.execution.generator;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.core.execution.DefaultExecutionSpec;
+import org.argeo.slc.execution.ExecutionContext;
+import org.argeo.slc.execution.ExecutionFlow;
+import org.argeo.slc.execution.ExecutionSpec;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+/**
+ * Execution Flow calling a list of <code>Runnable</code> (identified by their
+ * bean name in the Spring Application Context) after configuring the Execution
+ * context and a Map potentially shared by the called <code>Runnable</code>
+ *
+ */
+public class RunnableCallFlow implements ExecutionFlow, ApplicationContextAware {
+
+ private final static Log log = LogFactory.getLog(RunnableCallFlow.class);
+
+ /**
+ * Key in the execution context for the index of the call (e.g. 0 for the
+ * first runnable called, ...)
+ */
+ public final static String VAR_CALL_INDEX = "slcVar.runnableCallFlow.callIndex";
+
+ /**
+ * Name of the flow. Also bean name
+ */
+ private String name;
+
+ /**
+ * Path of the flow
+ */
+ private String path;
+
+ /**
+ * Whether an exception in a <code>Runnable</code> shall stop the execution
+ * of the flow
+ */
+ private Boolean failOnError = true;
+
+ /**
+ * List of <code>Runnable</code> to call, with bean name, execution
+ * variables and context values
+ */
+ private List<RunnableCall> runnableCalls;
+
+ /**
+ * Map potentially referenced by called flows. Updated with the context
+ * values of a Runnable before calling it.
+ */
+ private Map<String, Object> sharedContextValuesMap;
+
+ /**
+ * ExecutionSpec of the flow. Does not contain any attribute.
+ */
+ private ExecutionSpec executionSpec = new DefaultExecutionSpec();
+
+ /**
+ * Reference to the ExecutionContext
+ */
+ private ExecutionContext executionContext;
+
+ /**
+ * Reference to the Spring <code>ApplicationContext</code>. Set via
+ * <code>setApplicationContext</code>, the class implementing
+ * <code>ApplicationContextAware</code>
+ */
+ private ApplicationContext applicationContext;
+
+ /**
+ * Runs a <code>Runnable</code> after configuring the Execution Context and
+ * <code>sharedContextValuesMap</code>
+ *
+ * @param runnable
+ * the <code>Runnable</code> to call
+ * @param executionVariables
+ * the variables to add to the <code>ExecutionContext</code>
+ * @param contextValues
+ * the variables to add to <code>sharedContextValuesMap</code>
+ * @param callIndex
+ * index of the call (0 for the first called
+ * <code>Runnable</code>) set as variable of the
+ * <code>ExecutionContext</code>
+ */
+ private void run(Runnable runnable, Map<String, Object> executionVariables,
+ Map<String, Object> contextValues, int callIndex) {
+ // add all variables to the Execution Context
+ for (Map.Entry<String, Object> entry : executionVariables.entrySet()) {
+ executionContext.setVariable(entry.getKey(), entry.getValue());
+ }
+
+ // add call Index Variable
+ executionContext.setVariable(VAR_CALL_INDEX, callIndex);
+
+ // clear sharedContextValues and add all values of contextValues
+ if (sharedContextValuesMap != null) {
+ sharedContextValuesMap.clear();
+ sharedContextValuesMap.putAll(contextValues);
+ }
+
+ // then run the runnable
+ doExecuteRunnable(runnable);
+ }
+
+ public void doExecuteRunnable(Runnable runnable) {
+ runnable.run();
+ }
+
+ /**
+ * Executes the flow. For each <code>RunnableCall</code>, the corresponding
+ * flow is retrieved from the Spring Application Context, the
+ * <code>ExecutionContext</code> and <code>sharedContextValuesMap</code> are
+ * configured and the <code>Runnable</code> is called.
+ */
+ public void run() {
+ if (applicationContext == null) {
+ throw new SlcException("No ApplicationContext defined");
+ }
+
+ try {
+ for (int callIndex = 0; callIndex < runnableCalls.size(); ++callIndex) {
+ RunnableCall runnableCall = runnableCalls.get(callIndex);
+ Object bean = applicationContext.getBean(
+ runnableCall.getBeanName(), Runnable.class);
+ if (log.isDebugEnabled())
+ log.debug("Running flow '" + runnableCall.getBeanName()
+ + "'");
+ run((Runnable) bean, runnableCall.getExecutionVariables(),
+ runnableCall.getContextValues(), callIndex);
+ }
+ } catch (RuntimeException e) {
+ if (failOnError)
+ throw e;
+ else {
+ log.error("Execution flow failed,"
+ + " but process did not fail"
+ + " because failOnError property"
+ + " is set to false: " + e);
+ if (log.isTraceEnabled())
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public Iterator<Runnable> runnables() {
+ List<Runnable> runnables = new ArrayList<Runnable>();
+ for (int callIndex = 0; callIndex < runnableCalls.size(); ++callIndex) {
+ RunnableCall runnableCall = runnableCalls.get(callIndex);
+ Object bean = applicationContext.getBean(
+ runnableCall.getBeanName(), Runnable.class);
+ runnables.add((Runnable) bean);
+ }
+ return runnables.iterator();
+ }
+
+ public Runnable getRunnable() {
+ if (runnableCalls.size() == 1)
+ return runnables().next();
+ else
+ throw new SlcException("There are " + runnableCalls.size()
+ + " runnables in flow " + getName());
+ }
+
+ @Override
+ public String toString() {
+ return new StringBuffer("RunnableCallFlow ").append(name).toString();
+ }
+
+ public ExecutionSpec getExecutionSpec() {
+ return executionSpec;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public Object getParameter(String key) {
+ throw new SlcException("RunnableCallFlow have no parameters");
+ }
+
+ public String getPath() {
+ return path;
+ }
+
+ public Boolean isSetAsParameter(String key) {
+ // The ExecutionSpec having no attribute,
+ // always return false
+ return false;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public void setPath(String path) {
+ this.path = path;
+ }
+
+ public void setExecutionContext(ExecutionContext executionContext) {
+ this.executionContext = executionContext;
+ }
+
+ public void setRunnableCalls(List<RunnableCall> runnableCalls) {
+ this.runnableCalls = runnableCalls;
+ }
+
+ public void setApplicationContext(ApplicationContext applicationContext) {
+ this.applicationContext = applicationContext;
+ }
+
+ public void setSharedContextValuesMap(Map<String, Object> contextValues) {
+ this.sharedContextValuesMap = contextValues;
+ }
+
+ public void setFailOnError(Boolean failOnError) {
+ this.failOnError = failOnError;
+ }
+
+}
projects / gpl / argeo-slc.git / blobdiff