import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.UUID;
-import org.apache.commons.lang.math.RandomUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.structure.tree.TreeSPath;
import org.argeo.slc.core.structure.tree.TreeSRegistry;
import org.argeo.slc.execution.ExecutionSpecAttribute;
import org.argeo.slc.structure.StructureAware;
import org.argeo.slc.structure.StructureRegistry;
-import org.argeo.slc.test.ExecutableTestRun;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.validation.MapBindingResult;
public class DefaultExecutionFlow implements ExecutionFlow, InitializingBean,
BeanNameAware, StructureAware<TreeSPath> {
+
+ private final static Log log = LogFactory
+ .getLog(DefaultExecutionFlow.class);
+
private ExecutionSpec executionSpec = new DefaultExecutionSpec();
private String name = null;
private Map<String, Object> parameters = new HashMap<String, Object>();
private String path;
private StructureRegistry<TreeSPath> registry = new TreeSRegistry();
-
+
public DefaultExecutionFlow() {
-
- }
-
- public DefaultExecutionFlow(Map<String, Object> parameters) {
- this.parameters.putAll(parameters);
+ }
+
+ public DefaultExecutionFlow(ExecutionSpec executionSpec) {
+ this.executionSpec = executionSpec;
}
-
- public void execute() {
- for (Executable executable : executables) {
- executable.execute();
+
+ public DefaultExecutionFlow(ExecutionSpec executionSpec, Map<String, Object> parameters) {
+ // be sure to have an execution spec
+ this.executionSpec = (executionSpec == null) ? new DefaultExecutionSpec() : executionSpec;
+
+ //only parameters contained in the executionSpec can be set
+ for(String parameter : parameters.keySet()) {
+ if(!executionSpec.getAttributes().containsKey(parameter)) {
+ throw new SlcException("Parameter " + parameter + " is not defined in the ExecutionSpec");
+ }
}
- }
-
- public void afterPropertiesSet() throws Exception {
- // Validate execution specs
- if (executionSpec == null)
- return;
-
+
+ // set the parameters
+ this.parameters.putAll(parameters);
+
+ //check that all the required parameters are defined
MapBindingResult errors = new MapBindingResult(parameters, "execution#"
+ getName());
for (String key : executionSpec.getAttributes().keySet()) {
errors.rejectValue(key, "Hidden but not set as parameter");
break;
}
-
- /*
- * if (!parameters.containsKey(key)) { Object defaultValue =
- * attr.getValue(); if (defaultValue == null)
- * errors.rejectValue(key, "Not set and no default value"); else
- * parameters.put(key, defaultValue); } else {// contains key Object
- * obj = parameters.get(key); if (attr instanceof RefSpecAttribute)
- * { RefSpecAttribute rsa = (RefSpecAttribute) attr; // TODO: make
- * sure this will not cause pb with OSGi Class targetClass =
- * rsa.getTargetClass(); if
- * (!targetClass.isAssignableFrom(obj.getClass())) {
- * errors.reject(key + " not compatible with target class " +
- * targetClass); } } }
- */
}
if (errors.hasErrors())
throw new SlcException("Could not prepare execution flow: "
- + errors.toString());
+ + errors.toString());
+
+
+ }
- // if (path == null) {
- // path = "/" + executionSpec.getName() + "/" + name;
- // }
+ public void execute() {
+ for (Executable executable : executables) {
+ executable.execute();
+ }
+ }
+ public void afterPropertiesSet() throws Exception {
if (path != null) {
for (Executable executable : executables) {
if (executable instanceof StructureAware) {
this.executables = executables;
}
- public void setExecutionSpec(ExecutionSpec executionSpec) {
- this.executionSpec = executionSpec;
- }
-
public void setParameters(Map<String, Object> attributes) {
this.parameters = attributes;
}
return executionSpec;
}
- public Object getParameter(String name) {
- if (parameters.containsKey(name)) {
- return parameters.get(name);
+ public Object getParameter(String parameterName) {
+ if (parameters.containsKey(parameterName)) {
+ return parameters.get(parameterName);
} else {
- if (executionSpec.getAttributes().containsKey(name)) {
+ if (executionSpec.getAttributes().containsKey(parameterName)) {
ExecutionSpecAttribute esa = executionSpec.getAttributes().get(
- name);
- if (esa.getValue() != null)
+ parameterName);
+ if (esa.getValue() != null) {
return esa.getValue();
+ }
} else {
- throw new SlcException("Key " + name
+ throw new SlcException("Key " + parameterName
+ " is not defined in the specifications of "
+ toString());
}
}
- throw new SlcException("Key " + name + " is not set as parameter in "
+ throw new SlcException("Key " + parameterName + " is not set as parameter in "
+ toString());
}