Help working

[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 277e4df0c93ab52a892f894343770ab4262a7e74..cec087f9d8f017c70d52cb3d4c109b80177f6b83 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,5 +1,5 @@
 /*
- * Copyright (C) 2010 Mathieu Baudier <mbaudier@argeo.org>
+ * Copyright (C) 2007-2012 Argeo GmbH
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.argeo.slc.core.execution;
 
 import java.util.Comparator;
@@ -25,8 +24,6 @@ import java.util.TreeSet;
 
 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;
@@ -35,12 +32,12 @@ import org.argeo.slc.execution.ExecutionSpec;
 import org.argeo.slc.execution.ExecutionSpecAttribute;
 import org.springframework.aop.scope.ScopedObject;
 import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
 /**
@@ -59,6 +56,7 @@ public class DefaultExecutionFlowDescriptorConverter implements
 
        private ApplicationContext applicationContext;
 
+       @SuppressWarnings("unused")
        public Map<String, Object> convertValues(
                        ExecutionFlowDescriptor executionFlowDescriptor) {
                Map<String, Object> values = executionFlowDescriptor.getValues();
@@ -74,7 +72,11 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                ExecutionSpecAttribute attribute = executionSpec
                                                .getAttributes().get(key);
 
-                               if (attribute.getIsFrozen())
+                               if (attribute == null)
+                                       throw new FlowConfigurationException(
+                                                       "No spec attribute defined for '" + key + "'");
+
+                               if (attribute.getIsConstant())
                                        continue values;
 
                                Object value = values.get(key);
@@ -127,9 +129,13 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                                Object obj = PrimitiveUtils.convert(type, ref);
                                                convertedValues.put(key, obj);
                                        } else {
-                                               throw new UnsupportedException("Ref value type",
-                                                               refValue.getType());
+                                               throw new FlowConfigurationException(
+                                                               "Ref value type not supported: "
+                                                                               + refValue.getType());
                                        }
+                               } else {
+                                       // default is to take the value as is
+                                       convertedValues.put(key, value);
                                }
                        }
                }
@@ -159,12 +165,18 @@ public class DefaultExecutionFlowDescriptorConverter implements
 
        public ExecutionFlowDescriptor getExecutionFlowDescriptor(
                        ExecutionFlow executionFlow) {
-               Assert.notNull(executionFlow.getName());
+               if (executionFlow.getName() == null)
+                       throw new FlowConfigurationException("Flow name is null: "
+                                       + executionFlow);
                String name = executionFlow.getName();
 
                ExecutionSpec executionSpec = executionFlow.getExecutionSpec();
-               Assert.notNull(executionSpec);
-               Assert.notNull(executionSpec.getName());
+               if (executionSpec == null)
+                       throw new FlowConfigurationException("Execution spec is null: "
+                                       + executionFlow);
+               if (executionSpec.getName() == null)
+                       throw new FlowConfigurationException(
+                                       "Execution spec name is null: " + executionSpec);
 
                Map<String, Object> values = new TreeMap<String, Object>();
                for (String key : executionSpec.getAttributes().keySet()) {
@@ -184,7 +196,7 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                        // all necessary information is in the spec
                                }
                        } else if (attribute instanceof RefSpecAttribute) {
-                               if (attribute.getIsFrozen()) {
+                               if (attribute.getIsConstant()) {
                                        values.put(key, new RefValue(REF_VALUE_INTERNAL));
                                } else
                                        values.put(
@@ -192,22 +204,25 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                                        buildRefValue((RefSpecAttribute) attribute,
                                                                        executionFlow, key));
                        } else {
-                               throw new SlcException("Unkown spec attribute type "
-                                               + attribute.getClass());
+                               throw new FlowConfigurationException(
+                                               "Unkown spec attribute type " + attribute.getClass());
                        }
 
                }
 
-               ExecutionFlowDescriptor efd = new ExecutionFlowDescriptor(name, values,
-                               executionSpec);
-               if (executionFlow.getPath() != null)
-                       efd.setPath(executionFlow.getPath());
-               else
-                       efd.setPath("");
+               ExecutionFlowDescriptor efd = new ExecutionFlowDescriptor(name, null,
+                               values, executionSpec);
+               // if (executionFlow.getPath() != null)
+               // efd.setPath(executionFlow.getPath());
+               // else
+               // efd.setPath("");
 
                // Takes description from spring
-               BeanDefinition bd = getBeanFactory().getBeanDefinition(name);
-               efd.setDescription(bd.getDescription());
+               BeanFactory bf = getBeanFactory();
+               if (bf != null) {
+                       BeanDefinition bd = getBeanFactory().getBeanDefinition(name);
+                       efd.setDescription(bd.getDescription());
+               }
                return efd;
        }
 
@@ -217,7 +232,7 @@ public class DefaultExecutionFlowDescriptorConverter implements
                RefValue refValue = new RefValue();
                // FIXME: UI should be able to deal with other types
                refValue.setType(REF_VALUE_TYPE_BEAN_NAME);
-               Class targetClass = rsa.getTargetClass();
+               Class<?> targetClass = rsa.getTargetClass();
                String primitiveType = PrimitiveUtils.classAsType(targetClass);
                if (primitiveType != null) {
                        if (executionFlow.isSetAsParameter(key)) {
@@ -258,9 +273,15 @@ public class DefaultExecutionFlowDescriptorConverter implements
                                        }
                                }
                                if (ref == null) {
-                                       log.warn("Cannot define reference for ref spec attribute "
-                                                       + key + " in " + executionFlow + " (" + rsa + ")."
-                                                       + " If it is an inner bean consider put it frozen.");
+                                       if (log.isTraceEnabled())
+                                               log.trace("Cannot define reference for ref spec attribute "
+                                                               + key
+                                                               + " in "
+                                                               + executionFlow
+                                                               + " ("
+                                                               + rsa
+                                                               + ")."
+                                                               + " If it is an inner bean consider put it frozen.");
                                        ref = REF_VALUE_INTERNAL;
                                } else {
                                        if (log.isTraceEnabled())
@@ -275,7 +296,10 @@ public class DefaultExecutionFlowDescriptorConverter implements
                }
        }
 
+       /** @return can be null */
        private ConfigurableListableBeanFactory getBeanFactory() {
+               if (applicationContext == null)
+                       return null;
                return ((ConfigurableApplicationContext) applicationContext)
                                .getBeanFactory();
        }
@@ -288,6 +312,7 @@ public class DefaultExecutionFlowDescriptorConverter implements
 
        private static class ExecutionFlowDescriptorComparator implements
                        Comparator<ExecutionFlowDescriptor> {
+               @SuppressWarnings("deprecation")
                public int compare(ExecutionFlowDescriptor o1,
                                ExecutionFlowDescriptor o2) {
                        // TODO: write unit tests for this