Introduce DetachedLauncher based on osgiboot

[gpl/argeo-slc.git] / runtime / org.argeo.slc.core / src / main / java / org / argeo / slc / core / execution / DefaultExecutionFlowDescriptorConverter.java

diff --git a/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java
index 2b540f3c8171a3351f9f27ca3cf42080cdf04537..b2b613494c5c5d90be063d418b0290236447db90 100644 (file)
--- a/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java
+++ b/runtime/org.argeo.slc.core/src/main/java/org/argeo/slc/core/execution/DefaultExecutionFlowDescriptorConverter.java
@@ -1,14 +1,13 @@
 package org.argeo.slc.core.execution;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.argeo.slc.SlcException;
+import org.argeo.slc.UnsupportedException;
 import org.argeo.slc.execution.ExecutionFlow;
 import org.argeo.slc.execution.ExecutionFlowDescriptor;
 import org.argeo.slc.execution.ExecutionFlowDescriptorConverter;
@@ -26,6 +25,11 @@ import org.springframework.util.Assert;
 
 public class DefaultExecutionFlowDescriptorConverter implements
                ExecutionFlowDescriptorConverter, ApplicationContextAware {
+       public final static String REF_VALUE_TYPE_BEAN_NAME = "beanName";
+
+       /** Workaround for https://www.spartadn.com/bugzilla/show_bug.cgi?id=206 */
+       private final static String REF_VALUE_IS_FROZEN = "__frozen";
+
        private final static Log log = LogFactory
                        .getLog(DefaultExecutionFlowDescriptorConverter.class);
 
@@ -33,27 +37,36 @@ public class DefaultExecutionFlowDescriptorConverter implements
 
        public Map<String, Object> convertValues(
                        ExecutionFlowDescriptor executionFlowDescriptor) {
-               // convert the values of flow.getFlowDescriptor()
                Map<String, Object> values = executionFlowDescriptor.getValues();
-
                Map<String, Object> convertedValues = new HashMap<String, Object>();
 
                if (values != null) {
-                       for (String key : values.keySet()) {
+                       values: for (String key : values.keySet()) {
+                               ExecutionSpecAttribute attribute = executionFlowDescriptor
+                                               .getExecutionSpec().getAttributes().get(key);
+
+                               if (attribute.getIsFrozen())
+                                       continue values;
+
                                Object value = values.get(key);
                                if (value instanceof PrimitiveValue) {
                                        PrimitiveValue primitiveValue = (PrimitiveValue) value;
-
-                                       // TODO: check that the class of the the
-                                       // primitiveValue.value
-                                       // matches
-                                       // the primitiveValue.type
+                                       // TODO: check class <=> type
                                        convertedValues.put(key, primitiveValue.getValue());
                                } else if (value instanceof RefValue) {
-                                       // not yet implemented
-
-                                       // RefValue refValue = (RefValue) value;
-                                       // convertedValues.put(key, refValue.getLabel());
+                                       RefValue refValue = (RefValue) value;
+
+                                       if (REF_VALUE_TYPE_BEAN_NAME.equals(refValue.getType()))
+                                               if (refValue.getRef() != null) {
+                                                       Object obj = applicationContext.getBean(refValue
+                                                                       .getRef());
+                                                       convertedValues.put(key, obj);
+                                               } else {
+                                                       log.warn("Cannot interpret " + refValue);
+                                               }
+                                       else
+                                               throw new UnsupportedException("Ref value type",
+                                                               refValue.getType());
                                }
                        }
                }
@@ -91,8 +104,12 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                                // all necessary information is in the spec
                                        }
                                } else if (attribute instanceof RefSpecAttribute) {
-                                       values.put(key, buildRefValue((RefSpecAttribute) attribute,
-                                                       executionFlow, key));
+                                       if (attribute.getIsFrozen()) {
+                                               values.put(key, new RefValue(REF_VALUE_IS_FROZEN));
+                                       } else
+                                               values.put(key, buildRefValue(
+                                                               (RefSpecAttribute) attribute, executionFlow,
+                                                               key));
                                } else {
                                        throw new SlcException("Unkown spec attribute type "
                                                        + attribute.getClass());
@@ -105,6 +122,10 @@ public class DefaultExecutionFlowDescriptorConverter implements
                        if (executionFlow.getPath() != null)
                                efd.setPath(executionFlow.getPath());
 
+                       // Takes description from spring
+                       BeanDefinition bd = getBeanFactory().getBeanDefinition(name);
+                       efd.setDescription(bd.getDescription());
+
                        // Add execution spec if necessary
                        if (!md.getExecutionSpecs().contains(executionSpec))
                                md.getExecutionSpecs().add(executionSpec);
@@ -118,6 +139,7 @@ public class DefaultExecutionFlowDescriptorConverter implements
        protected RefValue buildRefValue(RefSpecAttribute rsa,
                        ExecutionFlow executionFlow, String key) {
                RefValue refValue = new RefValue();
+               refValue.setType(REF_VALUE_TYPE_BEAN_NAME);
 
                if (executionFlow.isSetAsParameter(key)) {
                        String ref = null;
@@ -149,9 +171,13 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                        }
                                }
                        }
-                       if (ref == null)
-                               log.warn("Cannot define reference for ref spec attribute "
-                                               + key);
+                       if (ref == null) {
+                               if (log.isTraceEnabled())
+                                       log.warn("Cannot define reference for ref spec attribute "
+                                                       + key + " in " + executionFlow + " (" + rsa + ")");
+                       } else if (log.isDebugEnabled())
+                               log.debug(ref + " is the reference for ref spec attribute "
+                                               + key + " in " + executionFlow + " (" + rsa + ")");
                        refValue.setRef(ref);
                }
                return refValue;