XBEAN-142 Allow for non-loadable managed classes in properties files.…

… Implement a proeprty-placeholder using jexl to evaluate expressions

git-svn-id: https://svn.apache.org/repos/asf/geronimo/xbean/trunk@907189 13f79535-47bb-0310-9956-ffa450edef68

xbean-blueprint/pom.xml

@@ -53,7 +53,25 @@
             <version>1.0.0-incubating-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.aries.blueprint</groupId>
+            <artifactId>org.apache.aries.blueprint.cm</artifactId>
+            <version>1.0.0-incubating-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
 
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-jexl</artifactId>
+            <version>2.0</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>commons-logging</groupId>
+                    <artifactId>commons-logging</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
         <dependency>
             <groupId>org.ops4j.pax.logging</groupId>
             <artifactId>pax-logging-api</artifactId>
@@ -67,6 +85,13 @@
             <scope>provided</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.compendium</artifactId>
+            <version>4.2.0</version>
+            <scope>provided</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.ops4j.pax.logging</groupId>
             <artifactId>pax-logging-service</artifactId>

xbean-blueprint/src/main/java/org/apache/xbean/blueprint/cm/JexlExpressionParser.java

@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+package org.apache.xbean.blueprint.cm;
+
+import java.util.Map;
+
+import org.apache.commons.jexl2.JexlContext;
+import org.apache.commons.jexl2.JexlEngine;
+import org.apache.commons.jexl2.MapContext;
+import org.apache.commons.jexl2.UnifiedJEXL;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class JexlExpressionParser {
+    private static final Logger log = LoggerFactory.getLogger(JexlExpressionParser.class);
+
+    private final JexlEngine engine;
+    private final UnifiedJEXL jexl;
+    protected final JexlContext context;
+
+    public JexlExpressionParser(final Map<String, Object> vars) {
+        if (vars == null) {
+            throw new IllegalArgumentException("vars");
+        }
+        engine = new JexlEngine();
+        jexl = new UnifiedJEXL(engine);
+        context = new MapContext(vars);
+
+        log.trace("Using variables: {}", vars);
+    }
+
+//    private FlatResolver resolver = new FlatResolver(true);
+//
+//    protected Expression createExpression(final String expression) throws Exception {
+//        // assert expression != null;
+//
+//        Expression expr = engine.createExpression(expression);
+//        expr.addPreResolver(resolver);
+//
+//        return expr;
+//    }
+
+    public Object evaluate(final String expression) throws Exception {
+        if (expression == null) {
+            throw new IllegalArgumentException("expression");
+        }
+
+        log.trace("Evaluating expression: {}", expression);
+        return jexl.parse(expression).evaluate(context);
+//        Expression expr = createExpression(expression);
+//        Object obj = expr.evaluate(context);
+//        log.trace("Result: {}", obj);
+//
+//        return obj;
+    }
+
+//    public String parse(final String input) {
+//        if (input == null) {
+//            throw new IllegalArgumentException("input");
+//        }
+//
+//        log.trace("Parsing input: {}", input);
+//
+//        StringBuilder buff = new StringBuilder();
+//
+//        int cur = 0;
+//        int prefixLoc;
+//        int suffixLoc;
+//
+//        while (cur < input.length()) {
+//            prefixLoc = input.indexOf("${", cur);
+//
+//            if (prefixLoc < 0) {
+//                break;
+//            }
+//
+//            suffixLoc = findBlockEnd(prefixLoc + 2, input);
+//            if (suffixLoc < 0) {
+//                throw new RuntimeException("Missing '}': " + input);
+//            }
+//
+//            String expr = input.substring(prefixLoc + 2, suffixLoc);
+//            buff.append(input.substring(cur, prefixLoc));
+//
+//            try {
+//                buff.append(evaluate(expr));
+//            }
+//            catch (Exception e) {
+//                throw new RuntimeException("Failed to evaluate: " + expr, e);
+//            }
+//
+//            cur = suffixLoc + 1;
+//        }
+//
+//        buff.append(input.substring(cur));
+//
+//        log.trace("Parsed result: {}", buff);
+//
+//        return buff.toString();
+//    }
+
+//    private int findBlockEnd(int pos, String input) {
+//        int nested = 0;
+//        while (pos < input.length()) {
+//            char ch = input.charAt(pos);
+//            if (ch == '{') {
+//                nested++;
+//            } else if (ch == '}') {
+//                if (nested == 0) {
+//                    return pos;
+//                } else {
+//                    nested--;
+//                }
+//            }
+//            pos++;
+//        }
+//        return -1;
+//    }
+
+//    public String parse(final String input, final boolean trim) {
+//        String output = parse(input);
+//        if (trim && output != null) {
+//            output = output.trim();
+//        }
+//
+//        return output;
+//    }
+}

xbean-blueprint/src/main/java/org/apache/xbean/blueprint/cm/JexlPropertyPlaceholder.java

@@ -0,0 +1,138 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+package org.apache.xbean.blueprint.cm;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.aries.blueprint.compendium.cm.CmPropertyPlaceholder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class JexlPropertyPlaceholder extends CmPropertyPlaceholder {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(JexlPropertyPlaceholder.class);
+
+    private transient JexlExpressionParser parser;
+
+    @Override
+    protected String processString(String str) {
+        LOGGER.debug("Processing {} from configuration with pid {}", str, getPersistentId());
+        JexlExpressionParser parser = getParser();
+        try {
+            return parser.evaluate(str).toString();
+        } catch (Exception e) {
+            LOGGER.info("Could not evaluate expressions {}  for {}", str, getPersistentId());
+            LOGGER.info("Exception:", e);
+        }
+        return str;
+    }
+
+    protected synchronized JexlExpressionParser getParser() {
+        if (parser == null) {
+//            try {
+                parser = new JexlExpressionParser(toMap());
+//            } catch (IOException e) {
+                // ignore
+//            }
+        }
+        return parser;
+    }
+
+    private Map<String, Object> toMap() {
+        return new ConfigMap();
+//        Map<String, Object> map = new HashMap<String, Object>();
+//        if (config != null) {
+//            Dictionary<String, Object> properties = config.getProperties();
+//            for (Enumeration<String> e = properties.keys(); e.hasMoreElements(); ) {
+//                String key = e.nextElement();
+//                Object value = properties.get(key);
+//                map.put(key, value);
+//            }
+//        }
+//        return map;
+    }
+
+    private class ConfigMap implements Map<String, Object> {
+
+        @Override
+        public int size() {
+            return 0;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return false;
+        }
+
+        @Override
+        public boolean containsKey(Object o) {
+            return getProperty((String) o) != null;
+        }
+
+        @Override
+        public boolean containsValue(Object o) {
+            return false;
+        }
+
+        @Override
+        public Object get(Object o) {
+            return getProperty((String) o);
+        }
+
+        @Override
+        public Object put(String s, Object o) {
+            return null;
+        }
+
+        @Override
+        public Object remove(Object o) {
+            return null;
+        }
+
+        @Override
+        public void putAll(Map<? extends String, ? extends Object> map) {
+        }
+
+        @Override
+        public void clear() {
+        }
+
+        @Override
+        public Set<String> keySet() {
+            return null;
+        }
+
+        @Override
+        public Collection<Object> values() {
+            return null;
+        }
+
+        @Override
+        public Set<Entry<String, Object>> entrySet() {
+            return null;
+        }
+    }
+}

xbean-blueprint/src/main/java/org/apache/xbean/blueprint/context/impl/XBeanNamespaceHandler.java

@@ -53,6 +53,8 @@
 import org.osgi.service.blueprint.reflect.Metadata;
 import org.osgi.service.blueprint.reflect.NonNullMetadata;
 import org.osgi.service.blueprint.reflect.NullMetadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.w3c.dom.Attr;
 import org.w3c.dom.Element;
 import org.w3c.dom.NamedNodeMap;
@@ -64,6 +66,8 @@
  */
 public class XBeanNamespaceHandler implements NamespaceHandler {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(XBeanNamespaceHandler.class);
+
     public static final String BLUEPRINT_NAMESPACE = "http://www.osgi.org/xmlns/blueprint/v1.0.0";
     private static final String BEAN_REFERENCE_PREFIX = "#";
     private static final String NULL_REFERENCE = "#null";
@@ -123,27 +127,37 @@ public XBeanNamespaceHandler(String namespace, String schemaLocation, String pro
         this.mappingMetaData = new MappingMetaData(properties);
     }
 
-    private static Set<Class> managedClassesFromProperties(ClassLoader cl, Properties properties) throws ClassNotFoundException {
+    private static Set<Class> managedClassesFromProperties(ClassLoader cl, Properties properties) {
         Set<Class> managedClasses = new HashSet<Class>();
         for (Map.Entry entry : properties.entrySet()) {
             String key = (String) entry.getKey();
             if (key.indexOf(".") < 0) {
                 String className = (String) entry.getValue();
-                Class clazz = cl.loadClass(className);
-                managedClasses.add(clazz);
+                try {
+                    managedClasses.add(cl.loadClass(className));
+                } catch (NoClassDefFoundError e) {
+                    LOGGER.warn("Could not load class: {} due to {}",className, e.getMessage());
+                } catch (ClassNotFoundException e) {
+                    LOGGER.warn("Could not load class: {}", className);
+                }
             }
         }
         return managedClasses;
     }
 
-    private static Set<Class> managedClassesFromProperties(Bundle bundle, Properties properties) throws ClassNotFoundException {
+    private static Set<Class> managedClassesFromProperties(Bundle bundle, Properties properties) {
         Set<Class> managedClasses = new HashSet<Class>();
         for (Map.Entry entry : properties.entrySet()) {
             String key = (String) entry.getKey();
             if (key.indexOf(".") < 0) {
                 String className = (String) entry.getValue();
-                Class clazz = bundle.loadClass(className);
-                managedClasses.add(clazz);
+                try {
+                    managedClasses.add(bundle.loadClass(className));
+                } catch (NoClassDefFoundError e) {
+                    LOGGER.warn("Could not load class: {} due to {}",className, e.getMessage());
+                } catch (ClassNotFoundException e) {
+                    LOGGER.warn("Could not load class: {}", className);
+                }
             }
         }
         return managedClasses;
@@ -205,6 +219,8 @@ public Metadata parse(Element element, ParserContext parserContext) {
     private Metadata parseInternal(Element element, ParserContext parserContext, String beanTypeName, String className) {
         MutableBeanMetadata beanMetaData = parserContext.createMetadata(MutableBeanMetadata.class);
         beanMetaData.setClassName(className);
+        beanMetaData.setScope(BeanMetadata.SCOPE_SINGLETON);
+        beanMetaData.setActivation(BeanMetadata.ACTIVATION_EAGER);
         beanMetaData.setRuntimeClass(managedClassesByName.get(className));
         if (beanMetaData.getRuntimeClass() == null) {
             throw new ComponentDefinitionException("Unknown bean class: " + className);