runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/core/execution/DefaultModulesManager.java

   1 package org.argeo.slc.core.execution;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.List;
   6 import java.util.Map;
   7
   8 import org.apache.commons.logging.Log;
   9 import org.apache.commons.logging.LogFactory;
  10 import org.argeo.slc.SlcException;
  11 import org.argeo.slc.execution.ExecutionContext;
  12 import org.argeo.slc.execution.ExecutionFlow;
  13 import org.argeo.slc.execution.ExecutionFlowDescriptor;
  14 import org.argeo.slc.execution.ExecutionModule;
  15 import org.argeo.slc.execution.ExecutionModuleDescriptor;
  16 import org.argeo.slc.execution.ExecutionModulesManager;
  17 import org.argeo.slc.process.RealizedFlow;
  18 import org.argeo.slc.process.SlcExecution;
  19 import org.springframework.util.Assert;
  20
  21 public class DefaultModulesManager implements ExecutionModulesManager {
  22         private final static Log log = LogFactory
  23                         .getLog(DefaultModulesManager.class);
  24
  25         private List<ExecutionModule> executionModules = new ArrayList<ExecutionModule>();
  26
  27         protected ExecutionModule getExecutionModule(String moduleName, String version) {
  28                 for (ExecutionModule moduleT : executionModules) {
  29                         if (moduleT.getName().equals(moduleName)) {
  30                                 if(moduleT.getVersion().equals(version)) {
  31                                         return moduleT;
  32                                 }
  33                         }
  34                 }
  35                 return null;
  36         }
  37
  38         public ExecutionModuleDescriptor getExecutionModuleDescriptor(
  39                         String moduleName, String version) {
  40                 ExecutionModule module = getExecutionModule(moduleName, version);
  41
  42                 Assert.notNull(module);
  43
  44                 return module.getDescriptor();
  45         }
  46
  47         public List<ExecutionModule> listExecutionModules() {
  48                 return executionModules;
  49         }
  50
  51         public void setExecutionModules(List<ExecutionModule> executionModules) {
  52                 this.executionModules = executionModules;
  53         }
  54
  55         protected Map<String, Object> convertValues(ExecutionFlowDescriptor executionFlowDescriptor) {
  56                 // convert the values of flow.getFlowDescriptor()
  57                 Map<String, Object> values = executionFlowDescriptor.getValues();
  58
  59                 Map<String, Object> convertedValues = new HashMap<String, Object>();
  60
  61                 for(String key : values.keySet()) {
  62                         Object value = values.get(key);
  63                         if(value instanceof PrimitiveValue) {
  64                                 PrimitiveValue primitiveValue = (PrimitiveValue) value;
  65
  66                                 // TODO: check that the class of the the primitiveValue.value matches
  67                                 // the primitiveValue.type
  68                                 convertedValues.put(key, primitiveValue.getValue());
  69                         }
  70                         else if(value instanceof RefValue) {
  71                                 RefValue refValue = (RefValue) value;
  72                                 convertedValues.put(key, refValue.getLabel());
  73                         }
  74                 }
  75                 return convertedValues;
  76         }
  77
  78         public void process(SlcExecution slcExecution) {
  79                 log.info("##\n## Process SLC Execution " + slcExecution+"\n##");
  80
  81                 for(RealizedFlow flow : slcExecution.getRealizedFlows()) {
  82                         ExecutionModule module = getExecutionModule(flow.getModuleName(),
  83                                         flow.getModuleVersion());
  84                         if(module != null) {
  85                                 ExecutionThread thread = new ExecutionThread(flow.getFlowDescriptor(), module);
  86                                 thread.start();
  87                         }
  88                         else {
  89                                 throw new SlcException("ExecutionModule " + flow.getModuleName() + ", version "
  90                                                 + flow.getModuleVersion() + " not found.");
  91                         }
  92                 }
  93         }
  94
  95         private class ExecutionThread extends Thread {
  96                 private final ExecutionFlowDescriptor executionFlowDescriptor;
  97                 private final ExecutionModule executionModule;
  98
  99                 public ExecutionThread(ExecutionFlowDescriptor executionFlowDescriptor,
 100                                 ExecutionModule executionModule) {
 101                         super("SLC Execution #" /*+ executionContext.getUuid()*/);
 102                         this.executionFlowDescriptor = executionFlowDescriptor;
 103                         this.executionModule = executionModule;
 104                 }
 105
 106                 public void run() {
 107                         ExecutionContext executionContext = executionModule.getExecutionContext();
 108                         executionContext.addVariables(convertValues(executionFlowDescriptor));
 109                         try {
 110                                 executionModule.execute(executionFlowDescriptor);
 111                         } catch (Exception e) {
 112                                 //TODO: re-throw exception ?
 113                                 log.error("Execution " + executionContext.getUuid()
 114                                                 + " failed.", e);
 115                         }
 116                 }
 117         }
 118 }