From bdd0a41aed7edf21ec2a65cfa17a86af2ef8c48a Mon Sep 17 00:00:00 2001 From: dims Date: Tue, 17 Jun 2008 00:23:01 +0000 Subject: Move Tuscany from Incubator to top level. git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68 --- sandbox/implementation-spring2/.ruleset | 190 +++++++++ sandbox/implementation-spring2/LICENSE.txt | 202 +++++++++ sandbox/implementation-spring2/NOTICE.txt | 14 + sandbox/implementation-spring2/README.txt | 35 ++ sandbox/implementation-spring2/pom.xml | 109 +++++ .../spring/SCAApplicationContext.java | 50 +++ .../spring/SCANamespaceHandlerResolver.java | 51 +++ .../spring/SCAParentApplicationContext.java | 155 +++++++ .../implementation/spring/ScaNamespaceHandler.java | 38 ++ .../spring/ScaReferenceBeanDefinitionParser.java | 38 ++ .../spring/ScaServiceBeanDefinitionParser.java | 38 ++ .../spring/SpringArtifactProcessor.java | 204 +++++++++ .../spring/SpringBeanNotFoundException.java | 11 + .../spring/SpringImplementation.java | 118 +++++ .../spring/SpringImplementationProvider.java | 71 +++ .../SpringImplementationProviderFactory.java | 40 ++ .../spring/SpringInvocationException.java | 11 + .../implementation/spring/SpringInvoker.java | 101 +++++ .../spring/SpringModuleActivator.java | 127 ++++++ .../spring/SpringOperationNotFoundException.java | 12 + .../spring/SpringPropertyValueObjectFactory.java | 46 ++ .../spring/xml/SpringBeanElement.java | 60 +++ .../spring/xml/SpringBeanIntrospector.java | 151 +++++++ .../spring/xml/SpringPropertyElement.java | 46 ++ .../spring/xml/SpringSCAReferenceElement.java | 47 ++ .../spring/xml/SpringSCAServiceElement.java | 53 +++ .../spring/xml/SpringXMLComponentTypeLoader.java | 475 +++++++++++++++++++++ .../main/resources/META-INF/sca/spring.system.scdl | 46 ++ .../org.apache.tuscany.sca.core.ModuleActivator | 2 + .../src/main/resources/META-INF/spring.handlers | 3 + .../src/main/resources/META-INF/spring.schemas | 1 + .../org/springframework/sca/xml/spring-sca.xsd | 83 ++++ .../spring/itests/AbstractSCATestCase.java | 49 +++ .../helloworld/AbstractHelloWorldTestCase.java | 42 ++ .../spring/itests/helloworld/HelloWorld.java | 32 ++ .../spring/itests/helloworld/HelloWorldProxy.java | 42 ++ .../helloworld/SpringHelloWorldTestCase.java | 32 ++ .../spring/itests/mock/TestBean.java | 31 ++ .../spring/itests/mock/TestBeanImpl.java | 42 ++ .../spring/itests/mock/TestHelloWorldBean.java | 21 + .../spring/itests/mock/TestReference.java | 27 ++ .../resources/META-INF/sca/application-context.xml | 13 + .../src/test/resources/META-INF/sca/default.scdl | 37 ++ .../META-INF/sca/testReferenceContext.xml | 15 + .../resources/META-INF/sca/testServiceContext.xml | 13 + .../test/resources/META-INF/tuscany/xsystem.scdl | 37 ++ .../tuscany/container/spring/ExplicitSpring.xml | 14 + .../container/spring/SpringConfigSchemaTest.xml | 17 + .../itests/helloworld/SpringHelloWorld.composite | 32 ++ .../src/test/resources/test.xml | 11 + 50 files changed, 3135 insertions(+) create mode 100644 sandbox/implementation-spring2/.ruleset create mode 100644 sandbox/implementation-spring2/LICENSE.txt create mode 100644 sandbox/implementation-spring2/NOTICE.txt create mode 100644 sandbox/implementation-spring2/README.txt create mode 100644 sandbox/implementation-spring2/pom.xml create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAApplicationContext.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCANamespaceHandlerResolver.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAParentApplicationContext.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaNamespaceHandler.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaReferenceBeanDefinitionParser.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaServiceBeanDefinitionParser.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringArtifactProcessor.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringBeanNotFoundException.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementation.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProvider.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProviderFactory.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvocationException.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvoker.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringModuleActivator.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringOperationNotFoundException.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringPropertyValueObjectFactory.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanElement.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanIntrospector.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringPropertyElement.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAReferenceElement.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAServiceElement.java create mode 100644 sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringXMLComponentTypeLoader.java create mode 100644 sandbox/implementation-spring2/src/main/resources/META-INF/sca/spring.system.scdl create mode 100644 sandbox/implementation-spring2/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator create mode 100644 sandbox/implementation-spring2/src/main/resources/META-INF/spring.handlers create mode 100644 sandbox/implementation-spring2/src/main/resources/META-INF/spring.schemas create mode 100644 sandbox/implementation-spring2/src/main/resources/org/springframework/sca/xml/spring-sca.xsd create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/AbstractSCATestCase.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/AbstractHelloWorldTestCase.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorld.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorldProxy.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorldTestCase.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBean.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBeanImpl.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestHelloWorldBean.java create mode 100644 sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestReference.java create mode 100644 sandbox/implementation-spring2/src/test/resources/META-INF/sca/application-context.xml create mode 100644 sandbox/implementation-spring2/src/test/resources/META-INF/sca/default.scdl create mode 100644 sandbox/implementation-spring2/src/test/resources/META-INF/sca/testReferenceContext.xml create mode 100644 sandbox/implementation-spring2/src/test/resources/META-INF/sca/testServiceContext.xml create mode 100644 sandbox/implementation-spring2/src/test/resources/META-INF/tuscany/xsystem.scdl create mode 100644 sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/ExplicitSpring.xml create mode 100644 sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/SpringConfigSchemaTest.xml create mode 100644 sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorld.composite create mode 100644 sandbox/implementation-spring2/src/test/resources/test.xml (limited to 'sandbox/implementation-spring2') diff --git a/sandbox/implementation-spring2/.ruleset b/sandbox/implementation-spring2/.ruleset new file mode 100644 index 0000000000..ac8671859d --- /dev/null +++ b/sandbox/implementation-spring2/.ruleset @@ -0,0 +1,190 @@ + + + + PMD Plugin preferences rule set + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/sandbox/implementation-spring2/LICENSE.txt b/sandbox/implementation-spring2/LICENSE.txt new file mode 100644 index 0000000000..0084319535 --- /dev/null +++ b/sandbox/implementation-spring2/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, serviceDefinition marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed 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. diff --git a/sandbox/implementation-spring2/NOTICE.txt b/sandbox/implementation-spring2/NOTICE.txt new file mode 100644 index 0000000000..d83ebbe236 --- /dev/null +++ b/sandbox/implementation-spring2/NOTICE.txt @@ -0,0 +1,14 @@ +${pom.name} +Copyright (c) 2005 - 2006 The Apache Software Foundation + +Apache Tuscany is an effort undergoing incubation at The Apache Software +Foundation (ASF), sponsored by the Apache Web Services PMC. Incubation is +required of all newly accepted projects until a further review indicates that +the infrastructure, communications, and decision making process have stabilized +in a manner consistent with other successful ASF projects. While incubation +status is not necessarily a reflection of the completeness or stability of the +code, it does indicate that the project has yet to be fully endorsed by the ASF. + +This product includes software developed by +The Apache Software Foundation (http://www.apache.org/). + diff --git a/sandbox/implementation-spring2/README.txt b/sandbox/implementation-spring2/README.txt new file mode 100644 index 0000000000..9b26d1690a --- /dev/null +++ b/sandbox/implementation-spring2/README.txt @@ -0,0 +1,35 @@ +Apache Tuscany M1 build (May, 2006) +=================================== + +http://incubator.apache.org/tuscany/ + +Tuscany is an effort undergoing incubation at the Apache Software Foundation +(ASF), sponsored by the Web Services PMC. + +Incubation is required of all newly accepted projects until a further review +indicates that the infrastructure, communications, and decision making process +have stabilized in a manner consistent with other successful ASF projects. + +While incubation status is not necessarily a reflection of the completeness or +stability of the code, it does indicate that the project has yet to be fully +endorsed by the ASF. + + +Support +------- + +Any problem with this release can be reported to the Tuscany mailing list +or in the JIRA issue tracker. + +Mailing list subscription: + tuscany-dev-subscribe@ws.apache.org + +Jira: + http://issues.apache.org/jira/browse/Tuscany + + +Thank you for using Tuscany! + + +The Tuscany Team. + diff --git a/sandbox/implementation-spring2/pom.xml b/sandbox/implementation-spring2/pom.xml new file mode 100644 index 0000000000..7cb58039da --- /dev/null +++ b/sandbox/implementation-spring2/pom.xml @@ -0,0 +1,109 @@ + + + + 4.0.0 + + org.apache.tuscany.sca + tuscany-modules + 1.0-incubating-SNAPSHOT + ../pom.xml + + tuscany-implementation-spring + Apache Tuscany Spring Framework Implementation Model + Container for managing Spring composites + jar + + + + org.apache.tuscany.sca + tuscany-assembly + 1.0-incubating-SNAPSHOT + + + org.apache.tuscany.sca + tuscany-core + 1.0-incubating-SNAPSHOT + + + org.apache.tuscany.sca + tuscany-interface + 1.0-incubating-SNAPSHOT + + + org.apache.tuscany.sca + tuscany-assembly-xml + 1.0-incubating-SNAPSHOT + + + org.apache.tuscany.sca + tuscany-contribution-impl + 1.0-incubating-SNAPSHOT + + + org.osoa + sca-api + 1.0-incubating-SNAPSHOT + + + org.apache.tuscany.sca + tuscany-databinding + 1.0-incubating-SNAPSHOT + + + org.apache.tuscany.sca + tuscany-implementation-java-runtime + 1.0-incubating-SNAPSHOT + + + + org.apache.tuscany.sca + tuscany-host-embedded + 1.0-incubating-SNAPSHOT + + + + + org.apache.tuscany.sca + tuscany-implementation-script + 1.0-incubating-SNAPSHOT + + + + + org.springframework + spring-core + 2.0.3 + + + + org.springframework + spring-beans + 2.0.3 + + + + org.springframework + spring-context + 2.0.3 + + + + + diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAApplicationContext.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAApplicationContext.java new file mode 100644 index 0000000000..fb5f53c7aa --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAApplicationContext.java @@ -0,0 +1,50 @@ +/* + * 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.implementation.spring; + +import org.springframework.beans.factory.xml.XmlBeanDefinitionReader; +import org.springframework.context.ApplicationContext; +import org.springframework.context.support.AbstractXmlApplicationContext; +import org.springframework.core.io.Resource; + +/** + * An ApplicationContext specialization that registers namespace handlers for + * SCA elements - in particular the , and elements which + * are provided as SCA extensions to the Spring application context schema + * + */ +public class SCAApplicationContext extends AbstractXmlApplicationContext { + public static final String APP_CONTEXT_PROP = "org.springframework.sca.application.context"; + private Resource appXml; + + public SCAApplicationContext(ApplicationContext parent, Resource appXml) { + super(parent); + this.appXml = appXml; + refresh(); + } + + protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) { + ClassLoader cl = getClassLoader(); + beanDefinitionReader.setNamespaceHandlerResolver(new SCANamespaceHandlerResolver(cl)); + } + + protected Resource[] getConfigResources() { + return new Resource[]{appXml}; + } +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCANamespaceHandlerResolver.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCANamespaceHandlerResolver.java new file mode 100644 index 0000000000..7f6f9263da --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCANamespaceHandlerResolver.java @@ -0,0 +1,51 @@ +/* + * 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.implementation.spring; + +import org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver; +import org.springframework.beans.factory.xml.NamespaceHandler; + +/** + * Overrides the default Spring namespace resolver to automatically register {@link ScaNamespaceHandler} instead of + * requiring a value to be supplied in a Spring configuration + * + * @version $$Rev: 511195 $$ $$Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $$ + */ +public class SCANamespaceHandlerResolver extends DefaultNamespaceHandlerResolver { + private static final String SCA_NAMESPACE = "http://www.springframework.org/schema/sca"; + + private ScaNamespaceHandler handler; + + public SCANamespaceHandlerResolver(ClassLoader classLoader) { + super(classLoader); + handler = new ScaNamespaceHandler(/*componentType*/); + } + + public SCANamespaceHandlerResolver(String handlerMappingsLocation, ClassLoader classLoader) { + super(classLoader, handlerMappingsLocation); + handler = new ScaNamespaceHandler(/*componentType*/); + } + + public NamespaceHandler resolve(String namespaceUri) { + if (SCA_NAMESPACE.equals(namespaceUri)) { + return handler; + } + return super.resolve(namespaceUri); + } +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAParentApplicationContext.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAParentApplicationContext.java new file mode 100644 index 0000000000..27dc6fc130 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SCAParentApplicationContext.java @@ -0,0 +1,155 @@ +package org.apache.tuscany.implementation.spring; + +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.BeanNotOfRequiredTypeException; +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 + * TODO - incomplete at present + * @author MikeEdwards + * + */ +class SCAParentApplicationContext implements ApplicationContext { + + // The Spring implementation for which this is the parent application context + private SpringImplementation implementation; + + private static final String[] EMPTY_ARRAY = new String[0]; + + public SCAParentApplicationContext( SpringImplementation implementation ) { + this.implementation = implementation; + } // end constructor + + public Object getBean(String name) throws BeansException { + return getBean(name, null); + } + + @SuppressWarnings("unchecked") + public Object getBean(String name, Class requiredType) throws BeansException { + // TODO provide a real implementation of this + System.out.println("Spring parent context - getBean called for name: " + name ); + return null; + } // end method getBean( String, Class ) + + 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 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/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaNamespaceHandler.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaNamespaceHandler.java new file mode 100644 index 0000000000..521daedb75 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaNamespaceHandler.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2006 the original author or authors. + * + * Licensed 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. + * + * Created on 10-Apr-2006 by Adrian Colyer + */ +package org.apache.tuscany.implementation.spring; + +import org.springframework.beans.factory.xml.NamespaceHandlerSupport; + +/** + * Handler for the <sca:> namespace in an application context + * + * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $ + */ +public class ScaNamespaceHandler extends NamespaceHandlerSupport { + + public ScaNamespaceHandler() { + init(); + } + + public final void init() { + registerBeanDefinitionParser("reference", new ScaReferenceBeanDefinitionParser()); + registerBeanDefinitionParser("service", new ScaServiceBeanDefinitionParser()); + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaReferenceBeanDefinitionParser.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaReferenceBeanDefinitionParser.java new file mode 100644 index 0000000000..c23b39e57f --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaReferenceBeanDefinitionParser.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2006 the original author or authors. + * + * Licensed 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. + * + * Created on 10-Apr-2006 by Adrian Colyer + */ +package org.apache.tuscany.implementation.spring; + +import org.w3c.dom.Element; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.xml.BeanDefinitionParser; +import org.springframework.beans.factory.xml.ParserContext; + +/** + * Parser for the <sca:reference> element + * + * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $ + */ +public class ScaReferenceBeanDefinitionParser implements BeanDefinitionParser { + + public BeanDefinition parse(Element element, ParserContext parserContext) { + // do nothing, this is handled by Tuscany + return null; + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaServiceBeanDefinitionParser.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaServiceBeanDefinitionParser.java new file mode 100644 index 0000000000..7b34c45a70 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/ScaServiceBeanDefinitionParser.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2006 the original author or authors. + * + * Licensed 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. + * + * Created on 10-Apr-2006 by Adrian Colyer + */ +package org.apache.tuscany.implementation.spring; + +import org.w3c.dom.Element; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.xml.BeanDefinitionParser; +import org.springframework.beans.factory.xml.ParserContext; + +/** + * Parser for the <sca:service/> element + * + * @version $Rev: 511195 $ $Date: 2007-02-24 02:29:46 +0000 (Sat, 24 Feb 2007) $ + */ +public class ScaServiceBeanDefinitionParser implements BeanDefinitionParser { + + public BeanDefinition parse(Element element, ParserContext parserContext) { + // do nothing, handled by Tuscany + return null; + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringArtifactProcessor.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringArtifactProcessor.java new file mode 100644 index 0000000000..65c65dd289 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringArtifactProcessor.java @@ -0,0 +1,204 @@ +/* + * 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.implementation.spring; + +import static javax.xml.stream.XMLStreamConstants.END_ELEMENT; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Property; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.xml.Constants; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.contribution.service.ContributionReadException; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; +import org.apache.tuscany.sca.contribution.service.ContributionWireException; +import org.apache.tuscany.sca.contribution.service.ContributionWriteException; +import org.apache.tuscany.implementation.spring.xml.SpringXMLComponentTypeLoader; +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor; + +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; + + +/* + * SpringArtifactProcessor is responsible for processing the XML of an + * element in an SCA SCDL file. + */ +public class SpringArtifactProcessor implements StAXArtifactProcessor { + + private static final String LOCATION = "location"; + private static final String IMPLEMENTATION_SPRING = "implementation.spring"; + private static final QName IMPLEMENTATION_SPRING_QNAME = + new QName(Constants.SCA10_NS, IMPLEMENTATION_SPRING); + private static final String MSG_LOCATION_MISSING = "Reading implementation.spring - location attribute missing"; + + private AssemblyFactory assemblyFactory; + private JavaInterfaceFactory javaFactory; + private JavaInterfaceIntrospector interfaceIntrospector; + private PolicyFactory policyFactory; + // TODO: runtime needs to provide a better way to get the PropertyValueObjectFactory + private SpringPropertyValueObjectFactory propertyFactory; + + + public SpringArtifactProcessor( AssemblyFactory assemblyFactory, + JavaInterfaceFactory javaFactory, + JavaInterfaceIntrospector interfaceIntrospector, + PolicyFactory policyFactory, + SpringPropertyValueObjectFactory propertyFactory ) { + this.assemblyFactory = assemblyFactory; + this.javaFactory = javaFactory; + this.interfaceIntrospector = interfaceIntrospector; + this.policyFactory = policyFactory; + this.propertyFactory = propertyFactory; + + } + + /* + * Read the XML and parse out the attributes. + * + * has a single required attribute: + * "location" - which is the target URI of of an archive file or a directory that contains the Spring + * application context files. + * If the resource identified by the location attribute is an archive file, then the file + * META-INF/MANIFEST.MF is read from the archive. + * If the location URI identifies a directory, then META-INF/MANIFEST.MF must exist + * underneath that directory. + * If the manifest file contains a header "Spring-Context" of the format: + * Spring-Context ::= path ( ';' path )* + * + * Where path is a relative path with respect to the location URI, then the set of paths + * specified in the header identify the context configuration files. + * If there is no MANIFEST.MF file or no Spring-Context header within that file, + * then the default behaviour is to build an application context using all the *.xml files + * in the METAINF/spring directory. + */ + public SpringImplementation read(XMLStreamReader reader) throws ContributionReadException { + + try { + /* Read the location attribute for the spring implementation */ + String springLocation = reader.getAttributeValue(null, LOCATION); + if (springLocation == null) { + throw new ContributionReadException( MSG_LOCATION_MISSING ); + } + /* Create the Spring implementation and set the location into it */ + SpringImplementation springImplementation = new SpringImplementation(); + springImplementation.setSpringLocation( springLocation ); + + // Skip to end element + while (reader.hasNext()) { + if (reader.next() == END_ELEMENT && IMPLEMENTATION_SPRING_QNAME.equals(reader.getName())) { + break; + } + } // end while + + processComponentType(springImplementation); + + return springImplementation; + + } catch (XMLStreamException e) { + throw new ContributionReadException(e); + } + } // end read + + /* + * Handles the component type for the Spring implementation + * @param springImplementation - a Spring implementation. The component type information + * is created for this implementation + * + */ + private void processComponentType(SpringImplementation springImplementation) { + + // Create a ComponentType and mark it unresolved + ComponentType componentType = assemblyFactory.createComponentType(); + componentType.setUnresolved(true); + springImplementation.setComponentType(componentType); + } // end processComponentType + + /* + * Write out the XML representation of the Spring implementation + * + */ + public void write(SpringImplementation springImplementation, XMLStreamWriter writer) throws ContributionWriteException { + try { + + writer.writeStartElement(Constants.SCA10_NS, IMPLEMENTATION_SPRING); + if (springImplementation.getSpringLocation() != null) { + writer.writeAttribute(LOCATION, springImplementation.getSpringLocation()); + } + writer.writeEndElement(); + + } catch (XMLStreamException e) { + throw new ContributionWriteException(e); + } + } // end write + + /** + * Resolves the Spring implementation - loads the Spring application-context XML and + * derives the spring implementation componentType from it + */ + public void resolve(SpringImplementation springImplementation, ModelResolver resolver) + throws ContributionResolveException { + + /* Load the Spring component type by reading the Spring application context */ + SpringXMLComponentTypeLoader springLoader = + new SpringXMLComponentTypeLoader( assemblyFactory, interfaceIntrospector, + javaFactory, policyFactory ); + try { + // Load the Spring Implementation information from its application context file... + springLoader.load( springImplementation ); + } catch ( ContributionReadException e ) { + throw new ContributionResolveException( e ); + } + + ComponentType ct = springImplementation.getComponentType(); + if( ct.isUnresolved() ) { + // If the introspection fails to resolve, try to find a side file... + ComponentType componentType = resolver.resolveModel(ComponentType.class, ct); + if (componentType.isUnresolved()) { + throw new ContributionResolveException("SpringArtifactProcessor: unable to resolve componentType for Spring component"); + } + springImplementation.setComponentType(componentType); + + springImplementation.setUnresolved(false); + } // end if + + } // end method resolve + + public void wire(SpringImplementation model) throws ContributionWireException { + // TODO Auto-generated method stub + } + + public QName getArtifactType() { + return IMPLEMENTATION_SPRING_QNAME; + } + + public Class getModelType() { + return SpringImplementation.class; + } + +} // end class SpringArtifactProcessor diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringBeanNotFoundException.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringBeanNotFoundException.java new file mode 100644 index 0000000000..44d6803848 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringBeanNotFoundException.java @@ -0,0 +1,11 @@ +package org.apache.tuscany.implementation.spring; + +public class SpringBeanNotFoundException extends Exception { + + private static final long serialVersionUID = -1157790036638157553L; + + public SpringBeanNotFoundException( String msg ) { + super( msg ); + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementation.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementation.java new file mode 100644 index 0000000000..5107bc8599 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementation.java @@ -0,0 +1,118 @@ +/* + * 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.implementation.spring; + +import java.util.List; +import java.util.Hashtable; + +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Implementation; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.assembly.impl.ComponentTypeImpl; + +import org.springframework.core.io.Resource; + +import org.apache.tuscany.implementation.spring.xml.SpringBeanElement; + +/** + * Represents a Spring implementation. + * + * TBD: Incomplete and needs substantial work... MJE, 4th May 2007 + */ +public class SpringImplementation extends ComponentTypeImpl implements Implementation { + + // The location attribute which points to the Spring application-context XML file + private String springLocation; + // The application-context file as a Spring Resource + private Resource resource; + private ComponentType componentType; + // Mapping of Services to Beans + private Hashtable serviceMap; + + protected SpringImplementation() { + this.springLocation = null; + this.resource = null; + setUnresolved(true); + serviceMap = new Hashtable(); + } + + /* Returns the location attribute for this Spring implementation */ + public String getSpringLocation() { + return springLocation; + } + + /** + * Sets the location attribute for this Spring implementation + * location - a URI to the Spring application-context file + */ + public void setSpringLocation(String location) { + this.springLocation = location; + return; + } + + public void setResource( Resource resource ) { + this.resource = resource; + } + + public Resource getResource() { + return resource; + } + + /* + * Returns the componentType for this Spring implementation + */ + public ComponentType getComponentType() { + return componentType; + } + + /* + * Sets the componentType for this Spring implementation + */ + public void setComponentType(ComponentType componentType) { + this.componentType = componentType; + } + + public List getServices() { + return componentType.getServices(); + } + + public List getReferences() { + return componentType.getReferences(); + } + + /** + * Returns the Spring Bean which implements a particular service + * @param service the service + * @return the bean which implements the service, as a SpringBeanElement + */ + public SpringBeanElement getBeanFromService( Service service ) { + SpringBeanElement theBean = serviceMap.get( service.getName() ); + return theBean; + } + + /** + * Sets the mapping from a service to the Spring Bean that implements the service + * @param service the service + * @param theBean a SpringBeanElement for the Bean implementing the service + */ + public void setBeanForService( Service service, SpringBeanElement theBean ) { + serviceMap.put( service.getName(), theBean ); + } +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProvider.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProvider.java new file mode 100644 index 0000000000..fb5a81b2b6 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProvider.java @@ -0,0 +1,71 @@ +package org.apache.tuscany.implementation.spring; + +import java.net.URI; + +import org.apache.tuscany.sca.assembly.ComponentService; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.core.invocation.ProxyFactory; +import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint; +import org.apache.tuscany.sca.factory.ObjectFactory; +import org.apache.tuscany.sca.interfacedef.Operation; +import org.apache.tuscany.sca.invocation.Invoker; +import org.apache.tuscany.sca.runtime.RuntimeComponent; +import org.apache.tuscany.sca.runtime.RuntimeComponentService; +import org.apache.tuscany.sca.provider.ImplementationProvider; +import org.osoa.sca.ComponentContext; + +import org.springframework.context.support.AbstractApplicationContext; + +// TODO - create a working version of this class... +/** + * A provider class for runtime Spring implementation instances + */ +public class SpringImplementationProvider implements ImplementationProvider { + private SpringImplementation implementation; + private RuntimeComponent component; + + // A Spring application context object + private AbstractApplicationContext springContext; + + /** + * Constructor for the provider - takes a component definition and a Spring implementation + * description + * @param component - the component in the assembly + * @param implementation - the implementation + */ + public SpringImplementationProvider( RuntimeComponent component, + SpringImplementation implementation ) { + super(); + this.implementation = implementation; + this.component = component; + SCAParentApplicationContext scaParentContext = + new SCAParentApplicationContext( implementation ); + springContext = new SCAApplicationContext(scaParentContext, implementation.getResource() ); + } // end constructor + + public Invoker createInvoker(RuntimeComponentService service, Operation operation) { + return new SpringInvoker( component, springContext, service, operation ); + } + + public Invoker createCallbackInvoker(Operation operation) { + return new SpringInvoker( component, springContext, null, operation ); + } + + /** + * Start this Spring implementation instance + */ + public void start() { + springContext.start(); + System.out.println("SpringImplementationProvider: Spring context started"); + } // end method start() + + /** + * Stop this implementation instance + */ + public void stop() { + // TODO - complete + springContext.stop(); + System.out.println("SpringImplementationProvider: Spring context stopped"); + } // end method stop + +} // end class SpringImplementationProvider diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProviderFactory.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProviderFactory.java new file mode 100644 index 0000000000..d005dc5c75 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringImplementationProviderFactory.java @@ -0,0 +1,40 @@ +package org.apache.tuscany.implementation.spring; + +import org.apache.tuscany.sca.provider.ImplementationProvider; +import org.apache.tuscany.sca.provider.ImplementationProviderFactory; +import org.apache.tuscany.sca.runtime.RuntimeComponent; + +/** + * ImplementationProviderFactory for Spring implementation type + * @author MikeEdwards + * + */ +public class SpringImplementationProviderFactory implements ImplementationProviderFactory { + + /** + * Simple constructor + * + */ + public SpringImplementationProviderFactory() { + super(); + } + + /** + * Returns a SpringImplementationProvider for a given component and Spring implementation + * @param component the component for which implementation instances are required + * @param implementation the Spring implementation with details of the component + * implementation + * @return the SpringImplementationProvider for the specified component + */ + public ImplementationProvider createImplementationProvider(RuntimeComponent component, + SpringImplementation implementation) { + return new SpringImplementationProvider( component, implementation ); + } + + /** + * Returns the class of the Spring implementation + */ + public Class getModelType() { + return SpringImplementation.class; + } +} // end class SpringImplementationProviderFactory diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvocationException.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvocationException.java new file mode 100644 index 0000000000..953d3e5083 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvocationException.java @@ -0,0 +1,11 @@ +package org.apache.tuscany.implementation.spring; + +public class SpringInvocationException extends Exception { + + private static final long serialVersionUID = -1157790036638157513L; + + public SpringInvocationException( String msg ) { + super( msg ); + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvoker.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvoker.java new file mode 100644 index 0000000000..f93e61f230 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringInvoker.java @@ -0,0 +1,101 @@ +package org.apache.tuscany.implementation.spring; + + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import org.apache.tuscany.sca.core.invocation.ThreadMessageContext; +import org.apache.tuscany.sca.interfacedef.ConversationSequence; +import org.apache.tuscany.sca.interfacedef.Operation; +import org.apache.tuscany.sca.interfacedef.java.impl.JavaInterfaceUtil; +import org.apache.tuscany.sca.invocation.Invoker; +import org.apache.tuscany.sca.invocation.Message; +import org.apache.tuscany.sca.runtime.RuntimeComponent; +import org.apache.tuscany.sca.runtime.RuntimeComponentService; +import org.apache.tuscany.sca.scope.InstanceWrapper; + +import org.apache.tuscany.implementation.spring.xml.SpringBeanElement; + +import org.springframework.context.support.AbstractApplicationContext; +import org.springframework.beans.BeansException; + +/** + * Initial implementation of a Spring bean invoker + * @author MikeEdwards + * + */ +public class SpringInvoker implements Invoker { + + private Method theMethod; + private Object bean; + private SpringBeanElement beanElement; + private boolean badInvoker = false; + + /** + * SpringInvoker constructor + * @param component - the Spring component to invoke + * @param service - the service to invoke + * @param operation - the operation to invoke + */ + public SpringInvoker( RuntimeComponent component, + AbstractApplicationContext springContext, + RuntimeComponentService service, + Operation operation) { + + // From the component and the service, identify the Spring Bean which is the target + SpringImplementation theImplementation = (SpringImplementation) component.getImplementation(); + beanElement = theImplementation.getBeanFromService( service.getService() ); + + if( beanElement == null ) { + badInvoker = true; + return; + } + // Now load the class for the bean and get the method relating to the operation.... + try { + bean = springContext.getBean( beanElement.getId() ); + Class beanClass = bean.getClass(); + theMethod = JavaInterfaceUtil.findMethod( beanClass, operation ); + System.out.println("SpringInvoker - found method " + theMethod.getName() ); + } catch ( BeansException e ) { + badInvoker = true; + } catch ( NoSuchMethodException e ) { + badInvoker = true; + } + } // end constructor SpringInvoker + + private Object doInvoke(Object payload) throws SpringInvocationException { + if( badInvoker ) throw new SpringInvocationException("Spring invoker incorrectly configured"); + // Invoke the method on the Spring bean using the payload, returning the results + try { + Object ret; + + if (payload != null && !payload.getClass().isArray()) { + ret = theMethod.invoke(bean, payload); + } else { + ret = theMethod.invoke(bean, (Object[])payload); + } + return ret; + } catch (InvocationTargetException e) { + throw new SpringInvocationException( e.getMessage() ); + } catch (Exception e) { + throw new SpringInvocationException( e.getMessage() ); + } + + } // end method doInvoke + + /** + * @param msg the message to invoke on the target bean + */ + public Message invoke(Message msg) { + try { + Object resp = doInvoke(msg.getBody()); + msg.setBody(resp); + } catch (SpringInvocationException e) { + msg.setFaultBody(e.getCause()); + } + System.out.println("Spring Invoker - invoke called"); + return msg; + } // end method invoke + + +} // end class SpringInvoker diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringModuleActivator.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringModuleActivator.java new file mode 100644 index 0000000000..7d37909d36 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringModuleActivator.java @@ -0,0 +1,127 @@ +/* + * 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.implementation.spring; + +import java.util.Map; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.DefaultAssemblyFactory; +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint; +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.core.ModuleActivator; +import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint; +import org.apache.tuscany.sca.databinding.TransformerExtensionPoint; +import org.apache.tuscany.sca.databinding.Mediator; +import org.apache.tuscany.sca.databinding.impl.MediatorImpl; +import org.apache.tuscany.sca.implementation.java.context.JavaPropertyValueObjectFactory; +import org.apache.tuscany.sca.implementation.java.introspect.DefaultJavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.invocation.JavaImplementationProviderFactory; + +import org.apache.tuscany.sca.interfacedef.java.DefaultJavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospectorExtensionPoint; +import org.apache.tuscany.sca.interfacedef.java.introspect.ExtensibleJavaInterfaceIntrospector; +import org.apache.tuscany.sca.policy.DefaultPolicyFactory; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.provider.ProviderFactoryExtensionPoint; + +/* + * ModuleActivator class for the Spring module + * - this class is invoked by the Tuscany SCA core when the Spring module is included in the + * runtime package + * - it registers a series of extension points which the core will use when dealing with + * components which use + * + */ +public class SpringModuleActivator implements ModuleActivator { + + private SpringArtifactProcessor springArtifactProcessor; + private AssemblyFactory assemblyFactory; + private JavaInterfaceFactory javaFactory; + private PolicyFactory policyFactory; + private JavaInterfaceIntrospector interfaceIntrospector; + private JavaClassIntrospectorExtensionPoint classVisitors; + + public SpringModuleActivator() { + assemblyFactory = new DefaultAssemblyFactory(); + javaFactory = new DefaultJavaInterfaceFactory(); + policyFactory = new DefaultPolicyFactory(); + + } // end constructor + + /* + * start() is called when the Tuscany core starts the Spring module + * + * It is in this method that the registration of the extension points takes place: + * - SpringArtifactProcessor processes the XML for + * - SpringComponentBuilder actually builds components based on + * - SpringPropertyValueObjectFactory handles properties for implementation.spring components + */ + public void start(ExtensionPointRegistry registry) { + + DataBindingExtensionPoint dataBindingRegistry = registry.getExtensionPoint(DataBindingExtensionPoint.class); + + // TODO: could the runtime have a default PropertyValueObjectFactory in the registry + DataBindingExtensionPoint dataBindings = registry.getExtensionPoint(DataBindingExtensionPoint.class); + TransformerExtensionPoint transformers = registry.getExtensionPoint(TransformerExtensionPoint.class); + MediatorImpl mediator = new MediatorImpl(dataBindings, transformers); + SpringPropertyValueObjectFactory propertyFactory = new SpringPropertyValueObjectFactory(mediator); + + // Tools for Java interface handling + JavaInterfaceIntrospectorExtensionPoint interfaceVisitors = + registry.getExtensionPoint(JavaInterfaceIntrospectorExtensionPoint.class); + interfaceIntrospector = new ExtensibleJavaInterfaceIntrospector(javaFactory, interfaceVisitors); + + // Create the artifact processor for Spring artifacts and add to artifact processors + springArtifactProcessor = new SpringArtifactProcessor( assemblyFactory, javaFactory, + interfaceIntrospector, policyFactory, propertyFactory ); + + StAXArtifactProcessorExtensionPoint staxProcessors = registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class); + staxProcessors.addArtifactProcessor(springArtifactProcessor); + + // Create SpringImplementationFactory and add to provider factories + SpringImplementationProviderFactory springImplementationProviderFactory = + new SpringImplementationProviderFactory(); + + ProviderFactoryExtensionPoint providerFactories = registry.getExtensionPoint(ProviderFactoryExtensionPoint.class); + providerFactories.addProviderFactory(springImplementationProviderFactory); + } + + /* + * stop() is called when the Tuscany core stops the Spring module + * At present, no action is taken + */ + public void stop(ExtensionPointRegistry registry) { + StAXArtifactProcessorExtensionPoint staxProcessors = registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class); + staxProcessors.removeArtifactProcessor(springArtifactProcessor); + } + + /* + * Return a map of the extension points for the Spring module. + * Not implemented at present (the core does not seem to require it) + */ + public Object[] getExtensionPoints() { + classVisitors = new DefaultJavaClassIntrospectorExtensionPoint(); + return new Object[] { classVisitors }; + } + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringOperationNotFoundException.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringOperationNotFoundException.java new file mode 100644 index 0000000000..36b3e1f786 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringOperationNotFoundException.java @@ -0,0 +1,12 @@ +package org.apache.tuscany.implementation.spring; + +public class SpringOperationNotFoundException extends Exception { + + private static final long serialVersionUID = -1157790036638157554L; + + public SpringOperationNotFoundException( String msg ) { + super( msg ); + } + + +} diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringPropertyValueObjectFactory.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringPropertyValueObjectFactory.java new file mode 100644 index 0000000000..658a96a0d4 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/SpringPropertyValueObjectFactory.java @@ -0,0 +1,46 @@ +/* + * 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.implementation.spring; + +import org.apache.tuscany.sca.implementation.java.context.JavaPropertyValueObjectFactory; +import org.apache.tuscany.sca.databinding.Mediator; + +/** + * + * @author MikeEdwards + * + * Factory class for PropertyValueObjects for Spring implementations + * + * 6th May 2007: Chosen a very simple design for this class - since Spring implementations are a form + * of Java POJO, the simple design chosen for this class is to re-use the PropertyValueObjectFactory + * implementation from the base implementation-java-runtime package of Tuscany SCA Java, since the + * same properties are going to be rendered in the same way to simple Tuscany POJOs and to Spring + * Bean POJOs. Mike Edwards + */ +public class SpringPropertyValueObjectFactory extends JavaPropertyValueObjectFactory { + + /** + * Constructor simply defers to the superclass, along with the complete implementation... + */ + public SpringPropertyValueObjectFactory(Mediator mediator) { + super(mediator); + } // end constructor JavaPropertyValueObjectFactory(Mediator mediator) + +} // end class SpringPropertyValueObjectFactory \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanElement.java new file mode 100644 index 0000000000..d658859e60 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanElement.java @@ -0,0 +1,60 @@ +/* + * 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.implementation.spring.xml; + +import java.util.List; +import java.util.ArrayList; + + +/** + * Represents a element in a Spring application-context + * - this has id and className attributes + * - plus zero or more property elements as children + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringBeanElement { + + private String id; + private String className; + private List properties = new ArrayList(); + + public SpringBeanElement( String id, String className ) { + this.id = id; + this.className = className; + } + + public String getClassName() { + return className; + } + + public String getId() { + return id; + } + + public List getProperties() { + return properties; + } + + public void addProperty( SpringPropertyElement property ) { + properties.add( property ); + } + + +} // end class SpringBeanElement \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanIntrospector.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanIntrospector.java new file mode 100644 index 0000000000..0fdeb4da71 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringBeanIntrospector.java @@ -0,0 +1,151 @@ +/* + * 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.implementation.spring.xml; + +import java.util.List; +import java.util.ArrayList; +import java.util.Iterator; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; +import org.apache.tuscany.sca.implementation.java.DefaultJavaImplementationFactory; +import org.apache.tuscany.sca.implementation.java.JavaImplementation; +import org.apache.tuscany.sca.implementation.java.JavaImplementationFactory; +import org.apache.tuscany.sca.implementation.java.introspect.DefaultJavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.introspect.ExtensibleJavaClassIntrospector; +import org.apache.tuscany.sca.implementation.java.introspect.IntrospectionException; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassIntrospector; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassIntrospectorExtensionPoint; +import org.apache.tuscany.sca.implementation.java.introspect.JavaClassVisitor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.AllowsPassByReferenceProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.BaseJavaClassVisitor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ConstructorProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ContextProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ConversationProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.DestroyProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.EagerInitProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.HeuristicPojoProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.InitProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.PolicyProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.PropertyProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ReferenceProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ResourceProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ScopeProcessor; +import org.apache.tuscany.sca.implementation.java.introspect.impl.ServiceProcessor; +import org.apache.tuscany.sca.policy.PolicyFactory; + +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; + +/** + * Provides introspection functions for Spring beans + * This version leans heavily on the implementation-java classes + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringBeanIntrospector { + + private JavaClassIntrospector classIntrospector; + private JavaClassIntrospectorExtensionPoint classVisitors = + new DefaultJavaClassIntrospectorExtensionPoint(); + private JavaImplementationFactory javaImplementationFactory; + + /** + * The constructor sets up the various visitor elements that will be used to inrospect + * the Spring bean and extract SCA information + * @param assemblyFactory - an AssemblyFactory + * @param interfaceIntrospector - an Java InterfaceIntrospector + * @param javaFactory - a Java Interface Factory + */ + public SpringBeanIntrospector( AssemblyFactory assemblyFactory, + JavaInterfaceIntrospector interfaceIntrospector, + JavaInterfaceFactory javaFactory, + PolicyFactory policyFactory ) { + + // Create the list of class visitors + BaseJavaClassVisitor[] extensions = new BaseJavaClassVisitor[] { + new ConstructorProcessor(assemblyFactory), + new AllowsPassByReferenceProcessor(assemblyFactory), + new ContextProcessor(assemblyFactory), + new ConversationProcessor(assemblyFactory), + new DestroyProcessor(assemblyFactory), + new EagerInitProcessor(assemblyFactory), + new InitProcessor(assemblyFactory), + new PropertyProcessor(assemblyFactory), + new ReferenceProcessor(assemblyFactory, javaFactory, interfaceIntrospector), + new ResourceProcessor(assemblyFactory), + new ScopeProcessor(assemblyFactory), + new ServiceProcessor(assemblyFactory, javaFactory, interfaceIntrospector), + new HeuristicPojoProcessor(assemblyFactory, javaFactory, interfaceIntrospector), + new PolicyProcessor(assemblyFactory, policyFactory) + }; + for (JavaClassVisitor extension : extensions) { + classVisitors.addClassVisitor(extension); + } + this.classIntrospector = new ExtensibleJavaClassIntrospector(classVisitors); + + javaImplementationFactory = new DefaultJavaImplementationFactory(); + + } // end constructor + + /** + * Introspect a Spring Bean and extract the features important to SCA + * @param beanClass the Spring Bean class to introspect + * @param componentType the componentType that is filled in through the introspection + * process (assumed empty on invocation, filled on return + * @throws ContributionResolveException - if there was a problem resolving the + * Spring Bean or its componentType + * + */ + public void introspectBean( Class beanClass, ComponentType componentType ) + throws ContributionResolveException { + + if( componentType == null ) throw new ContributionResolveException( + "Introspect Spring bean: supplied componentType is null" ); + + // Create a Java implementation ready for the introspection + JavaImplementation javaImplementation = javaImplementationFactory.createJavaImplementation(); + + try { + // Introspect the bean...the results of the introspection are placed into the Java implementation + classIntrospector.introspect( beanClass, javaImplementation); + + // Extract the services, references & properties found through introspection + // put the services, references and properties into the component type + componentType.getServices().addAll( javaImplementation.getServices() ); + componentType.getReferences().addAll( javaImplementation.getReferences() ); + componentType.getProperties().addAll( javaImplementation.getProperties() ); + } catch (IntrospectionException e) { + throw new ContributionResolveException(e); + } // end try + + List services = javaImplementation.getServices(); + for ( Service service : services ) { + String name = service.getName(); + System.out.println("Spring Bean: found service with name: " + name); + } // end for + + } // end method introspectBean + + + +} // end class SpringBeanIntrospector \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringPropertyElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringPropertyElement.java new file mode 100644 index 0000000000..45cb4f01b6 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringPropertyElement.java @@ -0,0 +1,46 @@ +/* + * 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.implementation.spring.xml; + + +/** + * Represents a element in a Spring application-context + * - this has name and ref attributes + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringPropertyElement { + + private String name; + private String ref; + + public SpringPropertyElement( String name, String ref ) { + this.name = name; + this.ref = ref; + } + + public String getName() { + return name; + } + + public String getRef() { + return ref; + } + +} // end class SpringPropertyElement \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAReferenceElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAReferenceElement.java new file mode 100644 index 0000000000..4105034f54 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAReferenceElement.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.implementation.spring.xml; + + +/** + * Represents a element in a Spring application-context + * - this has id and className attributes + * - plus zero or more property elements as children + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringSCAReferenceElement { + + private String name; + private String type; + + public SpringSCAReferenceElement( String name, String type ) { + this.name = name; + this.type = type; + } + + public String getName() { + return name; + } + + public String getType() { + return type; + } + +} // end class SpringSCAReferenceElement \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAServiceElement.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAServiceElement.java new file mode 100644 index 0000000000..ad2060b8d7 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringSCAServiceElement.java @@ -0,0 +1,53 @@ +/* + * 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.implementation.spring.xml; + + +/** + * Represents a element in a Spring application-context + * - this has id and className attributes + * - plus zero or more property elements as children + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringSCAServiceElement { + + private String name; + private String type; + private String target; + + public SpringSCAServiceElement( String name, String type, String target ) { + this.name = name; + this.type = type; + this.target = target; + } + + public String getName() { + return name; + } + + public String getType() { + return type; + } + + public String getTarget() { + return target; + } + +} // end class SpringSCAServiceElement \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringXMLComponentTypeLoader.java b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringXMLComponentTypeLoader.java new file mode 100644 index 0000000000..ee6a0423bd --- /dev/null +++ b/sandbox/implementation-spring2/src/main/java/org/apache/tuscany/implementation/spring/xml/SpringXMLComponentTypeLoader.java @@ -0,0 +1,475 @@ +/* + * 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.implementation.spring.xml; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.util.jar.Attributes; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; +import java.util.jar.Manifest; +import java.util.List; +import java.util.ArrayList; +import java.util.Iterator; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLInputFactory; +import static javax.xml.stream.XMLStreamConstants.END_ELEMENT; +import static javax.xml.stream.XMLStreamConstants.START_ELEMENT; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.tuscany.implementation.spring.SpringImplementation; +import org.apache.tuscany.sca.assembly.ComponentType; +import org.apache.tuscany.sca.assembly.Reference; +import org.apache.tuscany.sca.assembly.Service; +import org.apache.tuscany.sca.contribution.service.ContributionReadException; +import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException; + +import org.springframework.core.io.Resource; +import org.springframework.core.io.UrlResource; + +import org.apache.tuscany.sca.assembly.AssemblyFactory; +import org.apache.tuscany.sca.assembly.Multiplicity; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; +import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceIntrospector; +import org.apache.tuscany.sca.interfacedef.java.JavaInterface; +import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; + +/** + * Introspects a Spring XML application-context configuration file to create + * component type information. + * + * + * @version $Rev: 512919 $ $Date: 2007-02-28 19:32:56 +0000 (Wed, 28 Feb 2007) $ + */ +public class SpringXMLComponentTypeLoader { + private static final String SCA_NS = "http://www.springframework.org/schema/sca"; + private static final String SPRING_NS = "http://www.springframework.org/schema/beans"; + private static final QName SERVICE_ELEMENT = new QName(SCA_NS, "service"); + private static final QName REFERENCE_ELEMENT = new QName(SCA_NS, "reference"); + private static final QName BEANS_ELEMENT = new QName(SPRING_NS, "beans"); + private static final QName BEAN_ELEMENT = new QName(SPRING_NS, "bean"); + private static final QName PROPERTY_ELEMENT = new QName(SPRING_NS, "property"); + private static final String APPLICATION_CONTEXT = "application-context.xml"; + + private AssemblyFactory assemblyFactory; + private JavaInterfaceIntrospector interfaceIntrospector; + private JavaInterfaceFactory javaFactory; + private PolicyFactory policyFactory; + private ClassLoader cl; + + private SpringBeanIntrospector beanIntrospector; + + public SpringXMLComponentTypeLoader( AssemblyFactory assemblyFactory, + JavaInterfaceIntrospector interfaceIntrospector, + JavaInterfaceFactory javaFactory, + PolicyFactory policyFactory) { + super(); + this.assemblyFactory = assemblyFactory; + this.interfaceIntrospector = interfaceIntrospector; + this.javaFactory = javaFactory; + this.policyFactory = policyFactory; + beanIntrospector = new SpringBeanIntrospector( assemblyFactory, + interfaceIntrospector, javaFactory, policyFactory ); + } + + protected Class getImplementationClass() { + return SpringImplementation.class; + } + + /** + * Base method which loads the component type from the application-context attached to the + * Spring implementation + * + */ + public void load( SpringImplementation implementation ) throws ContributionReadException { + System.out.println("Spring TypeLoader - load method start"); + ComponentType componentType = implementation.getComponentType(); + /* Check that there is a component type object already set */ + if ( componentType == null) { + throw new ContributionReadException("SpringXMLLoader load: implementation has no ComponentType object"); + } + if ( componentType.isUnresolved() ) { + /* Fetch the location of the application-context file from the implementation */ + loadFromXML( implementation ); + if( !componentType.isUnresolved() ) implementation.setUnresolved( false ); + } // end if + System.out.println("Spring TypeLoader - load method complete"); + } // end method load + + /** + * Method which fills out the component type for a Spring implementation by reading the + * Spring application-context.xml file + * @param componentType - the component type to complete + * @param location - a string containing the relative location of the application-context.xml + * @return a Spring Resource for the application-context + * file + */ + private void loadFromXML( SpringImplementation implementation ) + throws ContributionReadException { + XMLStreamReader reader; + List beans = new ArrayList(); + List services = new ArrayList(); + List references = new ArrayList(); + SpringBeanElement bean = null; + + Resource resource; + + String location = implementation.getSpringLocation(); + + try { + // FIXME - is the ContextClassLoader the right place to start the search? + cl = Thread.currentThread().getContextClassLoader(); + + resource = getApplicationContextResource( location, cl ); + implementation.setResource( resource ); + // FIXME - need a better way to handle the XMLInputFactory than allocating a new one every time + XMLInputFactory xmlFactory = XMLInputFactory.newInstance(); + reader = xmlFactory.createXMLStreamReader(resource.getInputStream()); + + // System.out.println("Spring TypeLoader - starting to read context file"); + + boolean completed = false; + while ( !completed ) { + switch (reader.next()) { + case START_ELEMENT: + QName qname = reader.getName(); + //System.out.println("Spring TypeLoader - found element with name: " + qname.toString()); + if (SERVICE_ELEMENT.equals(qname)) { + SpringSCAServiceElement service = new SpringSCAServiceElement( + reader.getAttributeValue(SCA_NS, "name"), + reader.getAttributeValue(SCA_NS, "type"), + reader.getAttributeValue(SCA_NS, "target") ); + services.add( service ); + } else if (REFERENCE_ELEMENT.equals(qname)) { + SpringSCAReferenceElement reference = new SpringSCAReferenceElement( + reader.getAttributeValue(SCA_NS, "name"), + reader.getAttributeValue(SCA_NS, "type") ); + references.add( reference ); + } else if (BEAN_ELEMENT.equals(qname)) { + // TODO FIX THIS !! + int count=reader.getAttributeCount(); + bean = new SpringBeanElement( + reader.getAttributeValue( null, "id"), + reader.getAttributeValue( null, "class") ); + beans.add( bean ); + } else if (PROPERTY_ELEMENT.equals(qname)) { + SpringPropertyElement property = new SpringPropertyElement( + reader.getAttributeValue(SPRING_NS, "name"), + reader.getAttributeValue(SPRING_NS, "ref")); + bean.addProperty( property ); + } // end if + break; + case END_ELEMENT: + if (BEANS_ELEMENT.equals(reader.getName())) { + //System.out.println("Spring TypeLoader - finished read of context file"); + completed = true; + break; + } // end if + } // end switch + } // end while + + } catch (IOException e) { + throw new ContributionReadException(e); + } catch (XMLStreamException e) { + throw new ContributionReadException(e); + } + + /* At this point, the complete application-context.xml file has been read and its contents */ + /* stored in the lists of beans, services, references. These are now used to generate */ + /* the implied componentType for the application context */ + generateComponentType( implementation, beans, services, references ); + + return; + } // end method loadFromXML + + /** + * Generates the Spring implementation component type from the configuration contained in the + * lists of beans, services and references derived from the application context + */ + private void generateComponentType( SpringImplementation implementation, + List beans, + List services, + List references ) + throws ContributionReadException { + /* + * Each service becomes a service in the component type + * Each reference becomes a reference in the component type + * Each bean becomes a service, unless it is the target of a service element or unless it + * is the target of a bean reference property + * Each bean property which is a reference not pointing at another bean in the + * application context becomes a reference unless it is pointing at one of the references + */ + + ComponentType componentType = implementation.getComponentType(); + + try { + // Deal with the services first.... + Iterator its = services.iterator(); + while( its.hasNext() ) { + SpringSCAServiceElement serviceElement = its.next(); + Class interfaze = cl.loadClass( serviceElement.getType() ); + Service theService = createService( interfaze, serviceElement.getName() ); + componentType.getServices().add( theService ); + // Add this service to the Service / Bean map + String beanName = serviceElement.getTarget(); + for( SpringBeanElement beanElement : beans ) { + if( beanName == beanElement.getId() ) { + implementation.setBeanForService( theService, beanElement ); + } + } // end for + } // end while + + // Next handle the references + Iterator itr = references.iterator(); + while( itr.hasNext() ) { + SpringSCAReferenceElement referenceElement = itr.next(); + Class interfaze = cl.loadClass( referenceElement.getType() ); + Reference theReference = createReference( interfaze, referenceElement.getName() ); + componentType.getReferences().add( theReference ); + } // end while + + // Finally deal with the beans + Iterator itb; + // If there are no explicit service elements, then expose all the beans + if( services.isEmpty() ) { + itb = beans.iterator(); + // Loop through all the beans found + while( itb.hasNext() ) { + SpringBeanElement beanElement = itb.next(); + // Load the Spring bean class + Class beanClass = cl.loadClass( beanElement.getClassName() ); + // Introspect the bean + ComponentType beanComponentType = assemblyFactory.createComponentType(); + beanIntrospector.introspectBean( beanClass, beanComponentType ); + // Get the service interface defined by this Spring Bean and add to + // the component type of the Spring Assembly + List beanServices = beanComponentType.getServices(); + componentType.getServices().addAll( beanServices ); + // Add these services to the Service / Bean map + for( Service beanService : beanServices ) { + implementation.setBeanForService( beanService, beanElement ); + } + } // end while + } // end if + // Now check to see if there are any more references + itb = beans.iterator(); + while( itb.hasNext() ) { + SpringBeanElement beanElement = itb.next(); + if( !beanElement.getProperties().isEmpty() ) { + Iterator itp = beanElement.getProperties().iterator(); + while( itp.hasNext() ) { + SpringPropertyElement propertyElement = itp.next(); + if( propertyRefUnresolved( propertyElement.getRef(), beans, references ) ) { + // This means an unresolved reference from the spring bean... + // TODO + } // end if + } // end while + } // end if + + //Reference theReference = createReference( interfaze, referenceElement.getName() ); + //componentType.getReferences().add( theReference ); + } // end while + + } catch ( ClassNotFoundException e ) { + // Means that either an interface class or a bean was not found + throw new ContributionReadException( e ); + } catch ( InvalidInterfaceException e ) { + throw new ContributionReadException( e ); + } catch ( ContributionResolveException e ) { + + } // end try + + // If we get here, the Spring assembly component type is resolved + componentType.setUnresolved( false ); + implementation.setComponentType( componentType ); + return; + } // end method generateComponentType + + /* + * Determines whether a reference attribute of a Spring property element is resolved either + * by a bean in the application context or by an SCA reference element + * @param ref - a String containing the name of the reference - may be null + * @param beans - a List of SpringBean elements + * @param references - a List of SCA reference elements + * @return true if the property is not resolved, false if it is resolved + */ + private boolean propertyRefUnresolved( String ref, + List beans, + List references ) { + boolean unresolved = true; + + if( ref != null ) { + // Scan over the beans looking for a match + Iterator itb = beans.iterator(); + while( itb.hasNext() ) { + SpringBeanElement beanElement = itb.next(); + // Does the bean name match the ref? + if( ref.equals(beanElement.getId()) ) { + unresolved = false; + break; + } // end if + } // end while + // Scan over the references looking for a match + if( unresolved ) { + Iterator itr = references.iterator(); + while( itr.hasNext() ) { + SpringSCAReferenceElement referenceElement = itr.next(); + if( ref.equals(referenceElement.getName()) ) { + unresolved = false; + break; + } // end if + } // end while + } // end if + } // end if + + return unresolved; + + } // end method propertyRefUnresolved + + /** + * Gets hold of the application-context.xml file as a Spring resource + * @param locationAttr - the location attribute from the element + * @param cl - the classloader for the Spring implementation + */ + protected Resource getApplicationContextResource( String locationAttr, ClassLoader cl ) + throws ContributionReadException { + File manifestFile = null; + File appXmlFile; + File locationFile = new File(locationAttr); + + if (!locationFile.exists()) { + // FIXME hack + URL url = cl.getResource(locationAttr); + if (url != null) { + return new UrlResource(url); + } + throw new ContributionReadException("SpringXMLLoader getApplicationContextResource: " + + "unable to find resource file " + locationFile.toString()); + } + + if (locationFile.isDirectory()) { + try { + manifestFile = new File(locationFile, "META-INF/MANIFEST.MF"); + if (manifestFile.exists()) { + Manifest mf = new Manifest(new FileInputStream(manifestFile)); + Attributes mainAttrs = mf.getMainAttributes(); + String appCtxPath = mainAttrs.getValue("Spring-Context"); + if (appCtxPath != null) { + appXmlFile = new File(locationFile, appCtxPath); + if (appXmlFile.exists()) { + return new UrlResource(appXmlFile.toURL()); + } + } + } + // no manifest-specified Spring context, use default + appXmlFile = new File(locationFile, APPLICATION_CONTEXT); + if (appXmlFile.exists()) { + return new UrlResource(appXmlFile.toURL()); + } + } catch (IOException e) { + throw new ContributionReadException("Error reading manifest " + manifestFile); + } + } else { + try { + JarFile jf = new JarFile(locationFile); + JarEntry je; + Manifest mf = jf.getManifest(); + if (mf != null) { + Attributes mainAttrs = mf.getMainAttributes(); + String appCtxPath = mainAttrs.getValue("Spring-Context"); + if (appCtxPath != null) { + je = jf.getJarEntry(appCtxPath); + if (je != null) { + // TODO return a Spring specific Resouce type for jars + return new UrlResource(new URL("jar:" + locationFile.toURL() + "!/" + appCtxPath)); + } + } + } + je = jf.getJarEntry(APPLICATION_CONTEXT); + if (je != null) { + return new UrlResource(new URL("jar:" + locationFile.toURI().toURL() + "!" + APPLICATION_CONTEXT)); + } + } catch (IOException e) { + // bad archive + // TODO: create a more appropriate exception type + throw new ContributionReadException("SpringXMLLoader getApplicationContextResource: " + + " IO exception reading context file.", e); + } + } + + throw new ContributionReadException("SpringXMLLoader getApplicationContextResource: " + + APPLICATION_CONTEXT + "not found"); + } // end method getApplicationContextResource + + /** + * Creates a Service for the component type based on its name and Java interface + */ + public Service createService( Class interfaze, String name ) + throws InvalidInterfaceException { + Service service = assemblyFactory.createService(); + JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); + service.setInterfaceContract(interfaceContract); + + // Set the name for the service + service.setName( name ); + + // Set the call interface and, if present, the callback interface + JavaInterface callInterface = interfaceIntrospector.introspect(interfaze); + service.getInterfaceContract().setInterface(callInterface); + if (callInterface.getCallbackClass() != null) { + JavaInterface callbackInterface = interfaceIntrospector.introspect(callInterface.getCallbackClass()); + service.getInterfaceContract().setCallbackInterface(callbackInterface); + } + return service; + } // end method createService + + /** + * Creates a Reference for the component type based on its name and Java interface + */ + private org.apache.tuscany.sca.assembly.Reference createReference( Class interfaze, String name ) + throws InvalidInterfaceException { + org.apache.tuscany.sca.assembly.Reference reference = assemblyFactory.createReference(); + JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract(); + reference.setInterfaceContract(interfaceContract); + + // Set the name of the reference to the supplied name and the multiplicity of the reference + // to 1..1 - for Spring implementations, this is the only multiplicity supported + reference.setName(name); + reference.setMultiplicity(Multiplicity.ONE_ONE); + + // Set the call interface and, if present, the callback interface + JavaInterface callInterface = interfaceIntrospector.introspect( interfaze ); + reference.getInterfaceContract().setInterface( callInterface ); + if (callInterface.getCallbackClass() != null) { + JavaInterface callbackInterface = + interfaceIntrospector.introspect(callInterface.getCallbackClass()); + reference.getInterfaceContract().setCallbackInterface(callbackInterface); + } + + return reference; + } +} // end class SpringXMLComponentTypeLoader \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/resources/META-INF/sca/spring.system.scdl b/sandbox/implementation-spring2/src/main/resources/META-INF/sca/spring.system.scdl new file mode 100644 index 0000000000..123ade7d12 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/resources/META-INF/sca/spring.system.scdl @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator b/sandbox/implementation-spring2/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator new file mode 100644 index 0000000000..aee5912319 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator @@ -0,0 +1,2 @@ +# Implementation class for the ExtensionActivator for Spring module +org.apache.tuscany.implementation.spring.SpringModuleActivator \ No newline at end of file diff --git a/sandbox/implementation-spring2/src/main/resources/META-INF/spring.handlers b/sandbox/implementation-spring2/src/main/resources/META-INF/spring.handlers new file mode 100644 index 0000000000..4e7df50291 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/resources/META-INF/spring.handlers @@ -0,0 +1,3 @@ +http\://www.springframework.org/schema/sca=org.springframework.sca.config.ScaNamespaceHandler + + diff --git a/sandbox/implementation-spring2/src/main/resources/META-INF/spring.schemas b/sandbox/implementation-spring2/src/main/resources/META-INF/spring.schemas new file mode 100644 index 0000000000..4374e4f1b0 --- /dev/null +++ b/sandbox/implementation-spring2/src/main/resources/META-INF/spring.schemas @@ -0,0 +1 @@ +http\://www.springframework.org/schema/sca/spring-sca.xsd=org/springframework/sca/xml/spring-sca.xsd diff --git a/sandbox/implementation-spring2/src/main/resources/org/springframework/sca/xml/spring-sca.xsd b/sandbox/implementation-spring2/src/main/resources/org/springframework/sca/xml/spring-sca.xsd new file mode 100644 index 0000000000..3e61ee96dc --- /dev/null +++ b/sandbox/implementation-spring2/src/main/resources/org/springframework/sca/xml/spring-sca.xsd @@ -0,0 +1,83 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/AbstractSCATestCase.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/AbstractSCATestCase.java new file mode 100644 index 0000000000..144a43d582 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/AbstractSCATestCase.java @@ -0,0 +1,49 @@ +/* + * 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.implementation.spring.itests; + +import junit.framework.TestCase; + +import org.apache.tuscany.sca.host.embedded.SCADomain; + +public abstract class AbstractSCATestCase extends TestCase { + + protected SCADomain domain; + protected T service; + + protected void setUp() throws Exception { + domain = SCADomain.newInstance(getCompositeName()); + service = (T) domain.getService(getServiceClass(), "ClientComponent"); + } + + abstract protected Class getServiceClass(); + + protected void tearDown() throws Exception { + domain.close(); + } + + protected String getCompositeName() { + String className = this.getClass().getName(); + String compositeName = className.substring(0, className.length() - 8).replace('.', '/') + ".composite"; + System.out.println( compositeName ); + return compositeName; + } + +} diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/AbstractHelloWorldTestCase.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/AbstractHelloWorldTestCase.java new file mode 100644 index 0000000000..b2f821668f --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/AbstractHelloWorldTestCase.java @@ -0,0 +1,42 @@ +/* + * 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.implementation.spring.itests.helloworld; + +import org.apache.tuscany.implementation.spring.itests.AbstractSCATestCase; + +/** + * Basic "hello world" style test case for testing Spring component implementation + * @author MikeEdwards + * + */ +public abstract class AbstractHelloWorldTestCase extends AbstractSCATestCase { + + /** + * Calls the hello world service and checks that it gives the right response... + */ + public void testCalculator() throws Exception { + assertEquals("Hello petra", service.sayHello("petra")); + } + + @Override + protected Class getServiceClass() { + return HelloWorld.class; + } +} diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorld.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorld.java new file mode 100644 index 0000000000..a743880378 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorld.java @@ -0,0 +1,32 @@ +/* + * 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.implementation.spring.itests.helloworld; + +/** + * Interface for the "hello world" service - predictably simple with a single operation + * "sayHello" + * @author MikeEdwards + * + */ +public interface HelloWorld { + + public String sayHello(String s); + +} diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorldProxy.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorldProxy.java new file mode 100644 index 0000000000..305c245ea3 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/HelloWorldProxy.java @@ -0,0 +1,42 @@ +/* + * 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.implementation.spring.itests.helloworld; + +import org.osoa.sca.annotations.Reference; + +/** + * A simple proxy Java class which implements the HelloWorld interface but which uses + * a reference "delegate" to actually provide the HelloWorld service + * @author MikeEdwards + * + */ +public class HelloWorldProxy implements HelloWorld { + + // Here is the reference "delegate" - it implements the HelloWorld interface... + @Reference + public HelloWorld delegate; + + public String sayHello(String s) { + // Simply call the reference to satisfy the service request... + System.out.println("HelloWorldProxy - calling sayHello"); + return delegate.sayHello(s); + } + +} diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorldTestCase.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorldTestCase.java new file mode 100644 index 0000000000..9d0c52322b --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorldTestCase.java @@ -0,0 +1,32 @@ +/* + * 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.implementation.spring.itests.helloworld; + +/** + * A basic test case of: + * 1) A composite containing a component with a Spring implementation + * 2) The composite has a component with a Java POJO implementation which uses the + * Spring implementation to satisfy a reference + * + * @author MikeEdwards + */ +public class SpringHelloWorldTestCase extends AbstractHelloWorldTestCase { + // super class does it all getting composite based on this class name +} diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBean.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBean.java new file mode 100644 index 0000000000..f619658106 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBean.java @@ -0,0 +1,31 @@ +/* + * 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.implementation.spring.itests.mock; + +/** + * @version $$Rev: 430937 $$ $$Date: 2006-08-12 02:17:56 +0100 (Sat, 12 Aug 2006) $$ + */ +public interface TestBean { + String echo(String msg); + + TestBean getBean(); + + void setBean(TestBean bean); + +} diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBeanImpl.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBeanImpl.java new file mode 100644 index 0000000000..289259d78b --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestBeanImpl.java @@ -0,0 +1,42 @@ +/* + * 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.implementation.spring.itests.mock; + +/** + * @version $$Rev: 441406 $$ $$Date: 2006-09-08 08:20:10 +0100 (Fri, 08 Sep 2006) $$ + */ +public class TestBeanImpl implements TestBean { + + private TestBean bean; + + public TestBeanImpl() { + } + + public String echo(String msg) { + return msg; + } + + public TestBean getBean() { + return bean; + } + + public void setBean(TestBean bean) { + this.bean = bean; + } +} diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestHelloWorldBean.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestHelloWorldBean.java new file mode 100644 index 0000000000..529281b8ca --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestHelloWorldBean.java @@ -0,0 +1,21 @@ +package org.apache.tuscany.implementation.spring.itests.mock; + +/** + * A simple test Spring bean which provides the HelloWorld service + * @author MikeEdwards + * + */ + +import org.apache.tuscany.implementation.spring.itests.helloworld.HelloWorld; + +public class TestHelloWorldBean implements HelloWorld { + + static String hello = "Hello "; + + // Classic "Hello xxx" response to any input message + public String sayHello( String message ) { + System.out.println("TestHelloWorldBean - sayHello called"); + return( hello + message ); + } + +} // end class TestHelloWorldBean diff --git a/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestReference.java b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestReference.java new file mode 100644 index 0000000000..d5eb7130f7 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/java/org/apache/tuscany/implementation/spring/itests/mock/TestReference.java @@ -0,0 +1,27 @@ +/* + * 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.implementation.spring.itests.mock; + +/** + * @version $$Rev: 536115 $$ $$Date: 2007-05-08 09:04:20 +0100 (Tue, 08 May 2007) $$ + */ +public interface TestReference { + String echo(String msg); +} diff --git a/sandbox/implementation-spring2/src/test/resources/META-INF/sca/application-context.xml b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/application-context.xml new file mode 100644 index 0000000000..b31b570993 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/application-context.xml @@ -0,0 +1,13 @@ + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/META-INF/sca/default.scdl b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/default.scdl new file mode 100644 index 0000000000..964ac2e5aa --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/default.scdl @@ -0,0 +1,37 @@ + + + + + + + + + + testBean + + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/META-INF/sca/testReferenceContext.xml b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/testReferenceContext.xml new file mode 100644 index 0000000000..00cd6fabbc --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/testReferenceContext.xml @@ -0,0 +1,15 @@ + + + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/META-INF/sca/testServiceContext.xml b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/testServiceContext.xml new file mode 100644 index 0000000000..deca82f191 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/META-INF/sca/testServiceContext.xml @@ -0,0 +1,13 @@ + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/META-INF/tuscany/xsystem.scdl b/sandbox/implementation-spring2/src/test/resources/META-INF/tuscany/xsystem.scdl new file mode 100644 index 0000000000..0ef2781492 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/META-INF/tuscany/xsystem.scdl @@ -0,0 +1,37 @@ + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/ExplicitSpring.xml b/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/ExplicitSpring.xml new file mode 100644 index 0000000000..127592c1f0 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/ExplicitSpring.xml @@ -0,0 +1,14 @@ + + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/SpringConfigSchemaTest.xml b/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/SpringConfigSchemaTest.xml new file mode 100644 index 0000000000..c9a4c7e076 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/container/spring/SpringConfigSchemaTest.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorld.composite b/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorld.composite new file mode 100644 index 0000000000..4ac0037fab --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/org/apache/tuscany/implementation/spring/itests/helloworld/SpringHelloWorld.composite @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + diff --git a/sandbox/implementation-spring2/src/test/resources/test.xml b/sandbox/implementation-spring2/src/test/resources/test.xml new file mode 100644 index 0000000000..00dd841ba3 --- /dev/null +++ b/sandbox/implementation-spring2/src/test/resources/test.xml @@ -0,0 +1,11 @@ + + + + + + -- cgit v1.2.3