4 files changed, 515 insertions, 0 deletions
diff --git a/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAGenericApplicationContext.java b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAGenericApplicationContext.java
new file mode 100644
index 0000000000..7bb776f7ed
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAGenericApplicationContext.java
@@ -0,0 +1,47 @@
+/*
+ * 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.tuscany.sca.implementation.spring.runtime.context;
+
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.GenericApplicationContext;
+
+public class SCAGenericApplicationContext extends GenericApplicationContext {
+
+	 ClassLoader classloader = null;
+	 
+	 public SCAGenericApplicationContext(DefaultListableBeanFactory beanFactory, 
+             							 ApplicationContext parent,
+             							 ClassLoader classloader) {
+		 super(beanFactory, parent);
+		 this.classloader = classloader;
+	 }
+	 
+	 public SCAGenericApplicationContext(ApplicationContext parent,
+				 						 ClassLoader classloader) {
+		 super(parent);
+		 this.classloader = classloader;
+	 }
+
+	 @Override
+	 protected void postProcessBeanFactory (ConfigurableListableBeanFactory beanFactory) {
+		 beanFactory.setBeanClassLoader(classloader);
+	 }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAParentApplicationContext.java b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAParentApplicationContext.java
new file mode 100644
index 0000000000..b93874a9f3
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SCAParentApplicationContext.java
@@ -0,0 +1,190 @@
+/*
+ * 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.tuscany.sca.implementation.spring.runtime.context;
+
+import java.io.IOException;
+import java.util.Locale;
+import java.util.Map;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationEvent;
+import org.springframework.context.MessageSourceResolvable;
+import org.springframework.context.NoSuchMessageException;
+import org.springframework.core.io.Resource;
+
+/**
+ * A Spring ParentApplicationContext for a given Spring Implementation
+ *
+ * The Parent application context is responsible for handling those entities within a Spring
+ * application context that actually belong to SCA rather than to Spring.  The principal things
+ * are Properties and References.  These may be present either through explicit <sca:property/>
+ * and <sca:reference/> elements in the application context or they may be implicit through
+ * unresolved Spring bean <property.../> elements.  In either case, it is the Parent application
+ * context that must provide Spring beans that correspond to the property or reference, as derived
+ * from the SCA composite in which the Spring application context is an implementation.
+ *
+ * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $
+ */
+class SCAParentApplicationContext implements ApplicationContext {
+
+    // The Spring implementation for which this is the parent application context
+    private SpringImplementationStub implementation;
+
+    private static final String[] EMPTY_ARRAY = new String[0];
+
+    public SCAParentApplicationContext(SpringImplementationStub implementation) {
+        this.implementation = implementation;
+    } // end constructor
+
+    public Object getBean(String name) throws BeansException {
+        return getBean(name, (Class) null);
+    }
+
+    /**
+     * Get a Bean for a reference or for a property.
+     *
+     * @param name - the name of the Bean required
+     * @param requiredType - the required type of the Bean (either a Java class or a Java interface)
+     * @return Object - a Bean which matches the requested bean
+     */
+    public Object getBean(String name, Class requiredType) throws BeansException {
+        return implementation.getBean(name, requiredType);
+    } // end method getBean( String, Class )
+
+    public Object getBean(String name, Object[] args) throws BeansException {
+         return getBean(name, ((Class)null));
+    }
+
+    public boolean containsBean(String name) {
+        // TODO
+        System.out.println("Spring parent context - containsBean called for name: " + name);
+        return false;
+    }
+
+    public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
+        // TODO
+        return false;
+    }
+
+    public boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Class getType(String name) throws NoSuchBeanDefinitionException {
+        return null;
+    }
+
+    public String[] getAliases(String name) throws NoSuchBeanDefinitionException {
+        return EMPTY_ARRAY;
+    }
+
+    public ApplicationContext getParent() {
+        return null;
+    }
+
+    public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
+        return null;
+    }
+
+    public String getId() {
+          return this.toString();
+    }
+
+    public String getDisplayName() {
+        return implementation.getURI();
+    }
+
+    public long getStartupDate() {
+        return 0;
+    }
+
+    public boolean containsBeanDefinition(String beanName) {
+        return false;
+    }
+
+    public int getBeanDefinitionCount() {
+        return 0;
+    }
+
+    public String[] getBeanDefinitionNames() {
+        return new String[0];
+    }
+
+    public String[] getBeanNamesForType(Class type) {
+        return new String[0];
+    }
+
+    public String[] getBeanNamesForType(Class type, boolean includePrototypes, boolean includeFactoryBeans) {
+        return new String[0];
+    }
+
+    public Map getBeansOfType(Class type) throws BeansException {
+        return null;
+    }
+
+    public Map getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans) throws BeansException {
+        return null;
+    }
+
+    public boolean isPrototype(String theString) {
+        return false;
+    }
+
+    public BeanFactory getParentBeanFactory() {
+        return null;
+    }
+
+    public boolean containsLocalBean(String name) {
+        return false;
+    }
+
+    public String getMessage(String code, Object[] args, String defaultMessage, Locale locale) {
+        return null;
+    }
+
+    public String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException {
+        return null;
+    }
+
+    public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
+        return null;
+    }
+
+    public void publishEvent(ApplicationEvent event) {
+
+    }
+
+    public Resource[] getResources(String locationPattern) throws IOException {
+        return new Resource[0];
+    }
+
+    public Resource getResource(String location) {
+        return null;
+    }
+
+    public ClassLoader getClassLoader() {
+        // REVIEW: this is almost certainly flawed, but it's not clear how the SCA runtime's
+        // resource loading mechanism is exposed right now.
+        return this.getClass().getClassLoader();
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringContextTie.java b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringContextTie.java
new file mode 100644
index 0000000000..c579915970
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringContextTie.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.tuscany.sca.implementation.spring.runtime.context;
+
+import java.net.URL;
+import java.util.List;
+
+import org.apache.tuscany.sca.implementation.spring.processor.ComponentNameAnnotationProcessor;
+import org.apache.tuscany.sca.implementation.spring.processor.ComponentStub;
+import org.apache.tuscany.sca.implementation.spring.processor.ConstructorAnnotationProcessor;
+import org.apache.tuscany.sca.implementation.spring.processor.InitDestroyAnnotationProcessor;
+import org.apache.tuscany.sca.implementation.spring.processor.PropertyAnnotationProcessor;
+import org.apache.tuscany.sca.implementation.spring.processor.PropertyValueStub;
+import org.apache.tuscany.sca.implementation.spring.processor.ReferenceAnnotationProcessor;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.xml.XmlBeanFactory;
+import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
+import org.springframework.context.support.AbstractApplicationContext;
+import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.core.io.UrlResource;
+import org.springframework.core.SpringVersion;
+
+/**
+ * This is the runtime side tie for the corresponding tuscany side stub class.
+ * It enables the Tuscany code to invoke methods on a Spring context without
+ * needing to know about any Spring classes. See the SpringContextStub class
+ * in the implementation-spring module for what the stub does. 
+ */
+public class SpringContextTie {
+
+    private AbstractApplicationContext springContext;
+    private SpringImplementationStub implementation;
+    private boolean isAnnotationSupported;
+    private String versionSupported;
+    
+    public SpringContextTie(SpringImplementationStub implementation, List<URL> resource, boolean annotationSupport, String versionSupported) throws Exception {
+        this.implementation = implementation;
+        this.isAnnotationSupported = annotationSupport;
+        this.versionSupported = versionSupported;
+        if (! this.versionSupported.equals("ANY")) {
+        	if ((SpringVersion.getVersion()!= null) && (! SpringVersion.getVersion().equals(versionSupported)))
+        		throw new RuntimeException("Unsupported version: Use only Spring Framework Version " + versionSupported);
+        }        
+        SCAParentApplicationContext scaParentContext = new SCAParentApplicationContext(implementation);
+        springContext = createApplicationContext(scaParentContext, resource);  
+    }
+
+    public void start() {
+        // Do refresh here to ensure that Spring Beans are not touched before 
+    	// the SCA config process is complete...
+        springContext.refresh();
+        springContext.start();
+    }
+
+    public void close() {
+        springContext.close();
+        if (springContext instanceof GenericApplicationContext) {
+            springContext.stop();
+        }
+    }
+
+    /**
+     * Create appropriate ApplicationContext by reading the bean definitions.
+     */
+    private AbstractApplicationContext createApplicationContext(SCAParentApplicationContext scaParentContext, List<URL> resources) {
+
+    	XmlBeanFactory beanFactory = null;
+    	AbstractApplicationContext appContext = null;
+    	
+    	if (resources.size() > 1) 
+    	{
+    		GenericApplicationContext appCtx = 
+    			new SCAGenericApplicationContext(scaParentContext, implementation.getClassLoader());
+    		XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(appCtx);
+    		for (URL resource : resources) {
+    			xmlReader.loadBeanDefinitions(new UrlResource(resource));
+    		}
+    		xmlReader.setBeanClassLoader(implementation.getClassLoader());    		
+    		if (isAnnotationSupported)
+            	includeAnnotationProcessors(appCtx.getBeanFactory());
+    		return appCtx;
+    		
+    	} else {
+    		beanFactory = new XmlBeanFactory(new UrlResource(resources.get(0)));
+            beanFactory.setBeanClassLoader(implementation.getClassLoader());
+    	}
+        
+        // use the generic application context as default 
+        if (isAnnotationSupported) {            
+        	includeAnnotationProcessors(beanFactory);
+        }        
+        appContext = new SCAGenericApplicationContext(beanFactory, 
+                                                      scaParentContext,
+                                                      implementation.getClassLoader());
+        return appContext;
+    }
+
+    public Object getBean(String id) throws BeansException {
+        return springContext.getBean(id);
+    }
+
+    /**
+     * Include BeanPostProcessor to deal with SCA Annotations in Spring Bean
+     */
+    private void includeAnnotationProcessors(ConfigurableListableBeanFactory beanFactory) {
+        
+        // Processor to deal with @Init and @Destroy SCA Annotations
+        BeanPostProcessor initDestroyProcessor = new InitDestroyAnnotationProcessor();
+        beanFactory.addBeanPostProcessor(initDestroyProcessor);
+
+        // Processor to deal with @Reference SCA Annotations
+        ComponentStub component = new ComponentStub(implementation.getComponentTie());
+        BeanPostProcessor referenceProcessor = new ReferenceAnnotationProcessor(component);
+        beanFactory.addBeanPostProcessor(referenceProcessor);
+        
+        // Processor to deal with @Property SCA Annotations
+        PropertyValueStub pvs = new PropertyValueStub(implementation.getPropertyValueTie());
+        BeanPostProcessor propertyProcessor = new PropertyAnnotationProcessor(pvs);
+        beanFactory.addBeanPostProcessor(propertyProcessor);
+        
+        // Processor to deal with @ComponentName SCA Annotations
+        BeanPostProcessor componentNameProcessor = new ComponentNameAnnotationProcessor(implementation.getComponentName());
+        beanFactory.addBeanPostProcessor(componentNameProcessor);
+        
+        // Processor to deal with @Constructor SCA Annotations
+        BeanPostProcessor constructorProcessor = new ConstructorAnnotationProcessor();
+        beanFactory.addBeanPostProcessor(constructorProcessor);         
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringImplementationStub.java b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringImplementationStub.java
new file mode 100644
index 0000000000..b123be8b5c
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6.2/modules/implementation-spring-runtime/src/main/java/org/apache/tuscany/sca/implementation/spring/runtime/context/SpringImplementationStub.java
@@ -0,0 +1,129 @@
+/*
+ * 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.tuscany.sca.implementation.spring.runtime.context;
+
+import java.lang.reflect.Method;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+
+/**
+ * This is the runtime side stub for the corresponding Tuscany-side stub class.
+ * It enables the Spring code in the runtime module to invoke methods on a
+ * Tuscany SpringImplementation without the Spring runtime module
+ * needing to know about any Tuscany classes. See the SpringImplementationTie class
+ * in the implementation-spring module for what the tie does.
+ */
+public class SpringImplementationStub {
+
+    Object tie;
+    Method getURI;
+    Method getBean;
+    Method getComponentName;
+    Method getComponentTie;
+    Method getPropertyValueTie;
+    Method getClassLoader;
+
+    public SpringImplementationStub(Object tie) {
+        this.tie = tie;
+        Class<?> tieClass = tie.getClass();
+        try {
+            getURI = tieClass.getMethod("getURI", new Class<?>[]{});
+            getBean = tieClass.getMethod("getBean", new Class<?>[]{String.class, Class.class});
+            getComponentName = tieClass.getMethod("getComponentName");
+            getComponentTie = tieClass.getMethod("getComponentTie");
+            getPropertyValueTie = tieClass.getMethod("getPropertyValueTie");
+            getClassLoader = tieClass.getMethod("getClassLoader");
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public String getURI() {
+        try {
+
+            return (String)getURI.invoke(tie);
+
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Get a Bean for a reference or for a property.
+     *
+     * @param name - the name of the Bean required
+     * @param requiredType - the required type of the Bean (either a Java class or a Java interface)
+     * @return Object - a Bean which matches the requested bean
+     */
+    public Object getBean(String name, Class<?> requiredType) throws BeansException {
+        try {
+
+            Object bean = getBean.invoke(tie, new Object[] {name, requiredType});
+            if (bean == null) {
+                throw new NoSuchBeanDefinitionException("Unable to find Bean with name " + name);
+            }
+            return bean;
+
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public String getComponentName() {
+        try {
+
+            return (String)getComponentName.invoke(tie);
+
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public Object getComponentTie() {
+        try {
+
+            return getComponentTie.invoke(tie);
+
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public Object getPropertyValueTie() {
+        try {
+
+            return getPropertyValueTie.invoke(tie);
+
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public ClassLoader getClassLoader() {
+        try {
+
+            return (ClassLoader) getClassLoader.invoke(tie);
+
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}