Move Tuscany from Incubator to top level.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68

34 files changed, 4197 insertions, 0 deletions

diff --git a/branches/sca-java-1.0.1/modules/host-embedded/DISCLAIMER b/branches/sca-java-1.0.1/modules/host-embedded/DISCLAIMER
new file mode 100644
index 0000000000..d68a410903
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/DISCLAIMER
@@ -0,0 +1,8 @@
+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.

+

diff --git a/branches/sca-java-1.0.1/modules/host-embedded/LICENSE b/branches/sca-java-1.0.1/modules/host-embedded/LICENSE
new file mode 100644
index 0000000000..8aa906c321
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/LICENSE
@@ -0,0 +1,205 @@
+
+                                 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, service 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/branches/sca-java-1.0.1/modules/host-embedded/NOTICE b/branches/sca-java-1.0.1/modules/host-embedded/NOTICE
new file mode 100644
index 0000000000..94481d6cfa
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/NOTICE
@@ -0,0 +1,6 @@
+${pom.name}
+Copyright (c) 2005 - 2007 The Apache Software Foundation
+
+This product includes software developed by
+The Apache Software Foundation (http://www.apache.org/).
+
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/pom.xml b/branches/sca-java-1.0.1/modules/host-embedded/pom.xml
new file mode 100644
index 0000000000..eb7873d248
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/pom.xml
@@ -0,0 +1,100 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    * 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.    
+-->
+<project>
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache.tuscany.sca</groupId>
+        <artifactId>tuscany-modules</artifactId>
+        <version>1.0.1-incubating-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>tuscany-host-embedded</artifactId>
+    <name>Apache Tuscany SCA Embedded Host</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-core</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-definitions</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-definitions-xml</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-assembly-xml</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-binding-sca</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-binding-sca-xml</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-contribution-impl</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-policy-xml</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-node-api</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-core-databinding</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-assembly-xsd</artifactId>
+            <version>1.0.1-incubating-SNAPSHOT</version>
+            <scope>runtime</scope>
+        </dependency>
+
+    </dependencies>
+</project>
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCADomain.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCADomain.java
new file mode 100644
index 0000000000..6954110bc5
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCADomain.java
@@ -0,0 +1,272 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.Constructor;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+import org.apache.tuscany.sca.host.embedded.impl.DefaultSCADomain;
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+import org.osoa.sca.CallableReference;
+import org.osoa.sca.ServiceReference;
+import org.osoa.sca.ServiceRuntimeException;
+
+/**
+ * A handle to an SCA domain.
+ * 
+ * @version $Rev$ $Date$
+ */
+public abstract class SCADomain {
+    
+    final static String LOCAL_DOMAIN_URI = "http://localhost";
+
+    /**
+     * Static variable to hold the most recent instance of SCADomain
+     */
+    // TODO: Temporary support for SCADomain.connect() API
+    private static SCADomain theDomain;
+
+    
+    /**
+     * Returns a new instance of a local SCA domain.
+     *  
+     * @return
+     */
+    public static SCADomain newInstance() {
+        return createNewInstance(LOCAL_DOMAIN_URI, null);
+    }
+    
+    /**
+     * Returns a new instance of a local SCA domain. The specified deployable
+     * composite will be included in the SCA domain.
+     * 
+     * @param composite the deployable composite to include in the SCA domain.
+     * @return
+     */
+    public static SCADomain newInstance(String composite) {
+        return createNewInstance(LOCAL_DOMAIN_URI, "/", composite);
+    }
+    
+    /**
+     * Returns a new instance of a local SCA domain. The specified deployable
+     * composites will be included in the SCA domain.
+     * 
+     * @param domainURI the URI of the SCA domain
+     * @param contributionLocation the location of an SCA contribution
+     * @param composites the deployable composites to include in the SCA domain.
+     * @return
+     */
+    public static SCADomain newInstance(String domainURI, String contributionLocation, String... composites) {
+        return createNewInstance(domainURI, contributionLocation, composites);
+    }
+
+    /**
+     * Removes the specified local SCA Domain instance
+     * 
+     * @param domainInstance the instance to be removed
+     */
+    // FIXME: Adding this as temporary support for the "connect" API
+    public static void removeInstance(SCADomain domainInstance) {
+        theDomain = null;
+    }
+
+    /**
+     * Returns an SCADomain representing a remote SCA domain.
+     * 
+     * @param domainURI the URI of the SCA domain
+     * @return
+     */
+    // FIXME : this is a temporary implementation to get the capability working
+    public static SCADomain connect(String domainURI) {
+        return theDomain;
+    }
+
+    /**
+     * Close the SCA domain.
+     */
+    public void close() {
+        // TODO: temporary to support initial SCADomain.connect capability
+        SCADomain.removeInstance(this);
+    }
+
+    /**
+     * Returns the URI of the SCA Domain.
+     * 
+     * @return the URI of the SCA Domain
+     */
+    public abstract String getURI();
+
+    /**
+     * Cast a type-safe reference to a CallableReference. Converts a type-safe
+     * reference to an equivalent CallableReference; if the target refers to a
+     * service then a ServiceReference will be returned, if the target refers to
+     * a callback then a CallableReference will be returned.
+     * 
+     * @param target a reference proxy provided by the SCA runtime
+     * @param <B> the Java type of the business interface for the reference
+     * @param <R> the type of reference to be returned
+     * @return a CallableReference equivalent for the proxy
+     * @throws IllegalArgumentException if the supplied instance is not a
+     *             reference supplied by the SCA runtime
+     */
+    public abstract <B, R extends CallableReference<B>> R cast(B target) throws IllegalArgumentException;
+
+    /**
+     * Returns a proxy for a service provided by a component in the SCA domain.
+     * 
+     * @param businessInterface the interface that will be used to invoke the
+     *            service
+     * @param serviceName the name of the service
+     * @param <B> the Java type of the business interface for the service
+     * @return an object that implements the business interface
+     */
+    public abstract <B> B getService(Class<B> businessInterface, String serviceName);
+
+    /**
+     * Returns a ServiceReference for a service provided by a component in the
+     * SCA domain.
+     * 
+     * @param businessInterface the interface that will be used to invoke the
+     *            service
+     * @param serviceName the name of the service
+     * @param <B> the Java type of the business interface for the service
+     * @return a ServiceReference for the designated service
+     */
+    public abstract <B> ServiceReference<B> getServiceReference(Class<B> businessInterface, String referenceName);
+
+    /**
+     * Read the service name from a configuration file
+     * 
+     * @param classLoader
+     * @param name The name of the service class
+     * @return A class name which extends/implements the service class
+     * @throws IOException
+     */
+    private static String getServiceName(ClassLoader classLoader, String name) throws IOException {
+        InputStream is = classLoader.getResourceAsStream("META-INF/services/" + name);
+        if (is == null) {
+            return null;
+        }
+        BufferedReader reader = null;
+        try {
+            reader = new BufferedReader(new InputStreamReader(is));
+            while (true) {
+                String line = reader.readLine();
+                if (line == null) {
+                    break;
+                } else if (!line.startsWith("#")) {
+                    return line.trim();
+                }
+            }
+        } finally {
+            if (reader != null) {
+                reader.close();
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns an SCADomain instance. If the system property
+     * "org.apache.tuscany.sca.host.embedded.SCADomain" is set, its value is used as
+     * the name of the implementation class. Otherwise, if the resource
+     * "META-INF/services/org.apache.tuscany.sca.host.embedded.SCADomain" can be
+     * loaded from the supplied classloader. Otherwise, it will use
+     * "org.apache.tuscany.sca.host.embedded.impl.DefaultSCADomain" as the default.
+     * The named class is loaded from the supplied classloader.
+     * 
+     * @param classLoader
+     * @param domainURI
+     * @param contributionLocation
+     * @param composites
+     * @return
+     */
+    static SCADomain createNewInstance(String domainURI, String contributionLocation, String... composites) {
+
+        SCADomain domain = null;
+
+        try {
+            // Determine the runtime and application classloader
+            final ClassLoader runtimeClassLoader = SCADomain.class.getClassLoader();
+            final ClassLoader applicationClassLoader = Thread.currentThread().getContextClassLoader();
+            
+            // Discover the SCADomain implementation
+            final String name = SCADomain.class.getName();
+            String className = AccessController.doPrivileged(new PrivilegedAction<String>() {
+                public String run() {
+                    return System.getProperty(name);
+                }
+            });
+
+            if (className == null) {
+                className = getServiceName(runtimeClassLoader, name);
+            }
+            
+            if (className == null) {
+                
+                // Create a default SCA domain implementation
+                domain =
+                    new DefaultSCADomain(runtimeClassLoader,
+                                         applicationClassLoader,
+                                         domainURI,
+                                         contributionLocation,
+                                         composites);
+            } else {
+                
+                // Create an instance of the discovered SCA domain implementation
+                Class cls = Class.forName(className, true, runtimeClassLoader);
+                Constructor<?> constructor = null;
+                try {
+                    constructor = cls.getConstructor(ClassLoader.class, ClassLoader.class,
+                                                     String.class, String.class, String[].class);
+                } catch (NoSuchMethodException e) {}
+                if (constructor != null) {
+                    domain = (SCADomain)constructor.newInstance(runtimeClassLoader,
+                                                                applicationClassLoader,
+                                                                domainURI,
+                                                                contributionLocation,
+                                                                composites);
+                } else {
+                    
+                    constructor = cls.getConstructor(ClassLoader.class, String.class);
+                    domain = (SCADomain)constructor.newInstance(runtimeClassLoader, domainURI);
+                }
+            }
+            
+            // FIXME: temporary support for connect() API
+            theDomain = domain;
+            
+            return domain;
+
+        } catch (Exception e) {
+            throw new ServiceRuntimeException(e);
+        }
+    }
+
+    public ComponentManager getComponentManager() {
+        return null; 
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCADomainBean.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCADomainBean.java
new file mode 100644
index 0000000000..9ee7c274fd
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCADomainBean.java
@@ -0,0 +1,121 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded;
+
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+import org.osoa.sca.CallableReference;
+import org.osoa.sca.ServiceReference;
+
+public class SCADomainBean extends SCADomain {
+    
+    private SCADomain instance;
+    
+    private String uri = LOCAL_DOMAIN_URI;
+    private String location = "/";
+    private String[] composites;
+
+    /**
+     * Constructs a new SCA domain
+     */
+    public SCADomainBean() {
+    }
+
+    @Override
+    public String getURI() {
+        return uri;
+    }
+    
+    public void setURI(String uri) {
+        this.uri = uri;
+    }
+    
+    public void setContributionLocation(String contributionLocation) {
+        this.location = contributionLocation;
+    }
+    
+    public String getContributionLocation() {
+        return location;
+    }
+
+    public void setDeployableComposite(String composite) {
+        setDeployableComposites(composite);
+    }
+    
+    public void setDeployableComposites(String... composites) {
+        this.composites = composites;
+    }
+    
+    public String[] getDeployableComposites() {
+        return composites;
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public <B, R extends CallableReference<B>> R cast(B target) throws IllegalArgumentException {
+        if (instance == null) {
+            instance = SCADomain.createNewInstance(uri, location, composites);
+        }
+        Object result = instance.cast(target); 
+        return (R) result;
+    }
+
+    @Override
+    public void close() {
+        if (instance == null) {
+            instance = SCADomain.createNewInstance(uri, location, composites);
+        }
+        instance.close();
+        instance = null;
+    }
+
+    @Override
+    public <B> B getService(Class<B> businessInterface, String serviceName) {
+        if (instance == null) {
+            instance = SCADomain.createNewInstance(uri, location, composites);
+        }
+        return instance.getService(businessInterface, serviceName);
+    }
+
+    @Override
+    public <B> ServiceReference<B> getServiceReference(Class<B> businessInterface, String referenceName) {
+        if (instance == null) {
+            instance = SCADomain.createNewInstance(uri, location, composites);
+        }
+        return instance.getServiceReference(businessInterface, referenceName);
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        
+        // Make sure that the SCA domain is closed
+        if (instance != null) {
+            instance.close();
+            instance = null;
+        }
+    }
+
+    @Override
+    public ComponentManager getComponentManager() {
+        if (instance == null) {
+            instance = SCADomain.createNewInstance(uri, location, composites);
+        }
+        return instance.getComponentManager();
+    }
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCATestCaseRunner.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCATestCaseRunner.java
new file mode 100644
index 0000000000..3aa334a3d5
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/SCATestCaseRunner.java
@@ -0,0 +1,213 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.host.embedded;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+/**
+ * A helper class that can be used to run an SCA JUnit test case. The test case will run in an isolated class loader.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class SCATestCaseRunner {
+
+    private ClassLoader classLoader;
+    private Class<?> testSuiteClass;
+    private Object testSuite;
+    private Class<?> testResultClass;
+    private Class<?> testCaseClass;
+    private Object testCase;
+
+    private Class<?> beforeAnnotation;
+    private Class<?> beforeClassAnnotation;
+    private Class<?> afterAnnotation;
+    private Class<?> afterClassAnnotation;
+    private Class<?> junit4AdapterClass;
+    private Class<?> junit3TestCaseClass;
+
+    /**
+     * Constructs a new TestCase runner.
+     * 
+     * @param testClass
+     */
+    public SCATestCaseRunner(Class testClass) {
+        try {
+            classLoader = testClass.getClassLoader();
+            if (classLoader instanceof URLClassLoader) {
+                URL[] urls = ((URLClassLoader)classLoader).getURLs();
+                classLoader = new URLClassLoader(urls, classLoader.getParent());
+            } else {
+                classLoader = new URLClassLoader(new URL[0], classLoader);
+            }
+
+            ClassLoader tccl = Thread.currentThread().getContextClassLoader();
+            try {
+                Thread.currentThread().setContextClassLoader(classLoader);
+
+                testCaseClass = Class.forName(testClass.getName(), true, classLoader);
+                testCase = testCaseClass.newInstance();
+
+                junit3TestCaseClass = Class.forName("junit.framework.TestCase", true, classLoader);
+
+                testSuiteClass = Class.forName("junit.framework.TestSuite", true, classLoader);
+                Constructor testSuiteConstructor = testSuiteClass.getConstructor(Class.class);
+                testSuite = testSuiteConstructor.newInstance(testCaseClass);
+
+                testResultClass = Class.forName("junit.framework.TestResult", true, classLoader);
+
+                try {
+                    beforeAnnotation = Class.forName("org.junit.Before", true, classLoader);
+                    afterAnnotation = Class.forName("org.junit.After", true, classLoader);
+                    beforeClassAnnotation = Class.forName("org.junit.BeforeClass", true, classLoader);
+                    afterClassAnnotation = Class.forName("org.junit.AfterClass", true, classLoader);
+                    junit4AdapterClass = Class.forName("junit.framework.JUnit4TestAdapter", true, classLoader);
+                } catch (Exception e) {
+                    // Unexpected
+                    throw new AssertionError(e);
+                }
+
+            } finally {
+                Thread.currentThread().setContextClassLoader(tccl);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Run the test case
+     */
+    public void run() {
+        ClassLoader tccl = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(classLoader);
+
+            if (junit3TestCaseClass.isAssignableFrom(testCaseClass)) {
+                Object testResult = testResultClass.newInstance();
+                Method runMethod = testSuiteClass.getMethod("run", testResultClass);
+                runMethod.invoke(testSuite, testResult);
+            } else {
+                Object junit4Adapter = junit4AdapterClass.getConstructor(Class.class).newInstance(testCaseClass);
+                Object testResult = testResultClass.newInstance();
+                Method runMethod = junit4AdapterClass.getMethod("run", testResultClass);
+                runMethod.invoke(junit4Adapter, testResult);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            Thread.currentThread().setContextClassLoader(tccl);
+        }
+    }
+
+    /**
+     * Invoke the setUp method
+     */
+    public void setUp() {
+        execute("setUp");
+    }
+
+    /**
+     * Invoke the before methods
+     */
+    public void before() {
+        execute(beforeAnnotation);
+    }
+
+    /**
+     * Invoke the beforeClass methods
+     */
+    public void beforeClass() {
+        execute(beforeClassAnnotation);
+    }
+
+    /**
+     * Invoke the tearDown method
+     */
+    public void tearDown() {
+        execute("tearDown");
+    }
+
+    /**
+     * Invoke the after methods
+     */
+    public void after() {
+        execute(afterAnnotation);
+    }
+
+    /**
+     * Invoke the afterClass methods
+     */
+    public void afterClass() {
+        execute(afterClassAnnotation);
+    }
+
+    /**
+     * Invoke the specified test method.
+     */
+    public void run(String methodName) {
+        execute(methodName);
+    }
+
+    /**
+     * Invoke the methods annotated with the specified annotation.
+     */
+    private void execute(Class<?> annotationClass) {
+        if (annotationClass == null) {
+            throw new RuntimeException(new NoSuchMethodException());
+        }
+        ClassLoader tccl = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(classLoader);
+
+            for (Method method : testCaseClass.getDeclaredMethods()) {
+                for (Annotation annotation : method.getAnnotations()) {
+                    if (annotation.annotationType() == annotationClass) {
+                        method.invoke(testCase);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            Thread.currentThread().setContextClassLoader(tccl);
+        }
+    }
+
+    /**
+     * Invoke the specified method
+     */
+    private void execute(String methodName) {
+        ClassLoader tccl = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(classLoader);
+            Method setUpMethod = testCaseClass.getDeclaredMethod(methodName);
+            setUpMethod.setAccessible(true);
+            setUpMethod.invoke(testCase);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            Thread.currentThread().setContextClassLoader(tccl);
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ComponentManagerImpl.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ComponentManagerImpl.java
new file mode 100644
index 0000000000..8a512de5f8
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ComponentManagerImpl.java
@@ -0,0 +1,115 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.core.assembly.ActivationException;
+import org.apache.tuscany.sca.core.assembly.RuntimeComponentImpl;
+import org.apache.tuscany.sca.host.embedded.management.ComponentListener;
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+
+public class ComponentManagerImpl implements ComponentManager {
+
+    protected List<ComponentListener> listeners = new CopyOnWriteArrayList<ComponentListener>();
+    protected EmbeddedSCADomain domain;
+
+    public ComponentManagerImpl(EmbeddedSCADomain domain) {
+        this.domain = domain;
+    }
+
+    public void addComponentListener(ComponentListener listener) {
+        this.listeners.add(listener);
+    }
+
+    public void removeComponentListener(ComponentListener listener) {
+        this.listeners.remove(listener);
+    }
+
+    public Set<String> getComponentNames() {
+        Set<String> names = new HashSet<String>();
+        for (Composite composite: domain.getDomainComposite().getIncludes()) {
+            for (Component component: composite.getComponents()) {
+                names.add(component.getName());
+            }
+        }
+        return names;
+    }
+
+    public Component getComponent(String componentName) {
+        for (Composite composite: domain.getDomainComposite().getIncludes()) {
+            for (Component component: composite.getComponents()) {
+                if (component.getName().equals(componentName)) {
+                    return component;
+                }
+            }
+        }
+        return null;
+    }
+
+    public void startComponent(String componentName) throws ActivationException {
+        Component component = getComponent(componentName);
+        if (component == null) {
+            throw new IllegalArgumentException("no component: " + componentName);
+        }
+        domain.getCompositeActivator().start(component);
+        notifyComponentStarted(componentName);
+    }
+
+    public void stopComponent(String componentName) throws ActivationException {
+        Component component = getComponent(componentName);
+        if (component == null) {
+            throw new IllegalArgumentException("no component: " + componentName);
+        }
+        domain.getCompositeActivator().stop(component);
+        notifyComponentStopped(componentName);
+    }
+
+    public void notifyComponentStarted(String componentName) {
+        for (ComponentListener listener : listeners) {
+            try {
+                listener.componentStarted(componentName);
+            } catch (Exception e) {
+                e.printStackTrace(); // TODO: log
+            }
+        }
+    }
+
+    public void notifyComponentStopped(String componentName) {
+        for (ComponentListener listener : listeners) {
+            try {
+                listener.componentStopped(componentName);
+            } catch (Exception e) {
+                e.printStackTrace(); // TODO: log
+            }
+        }
+    }
+
+    public boolean isComponentStarted(String componentName) {
+        RuntimeComponentImpl runtimeComponent = (RuntimeComponentImpl)getComponent(componentName);
+        return runtimeComponent.isStarted();
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/DefaultSCADomain.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/DefaultSCADomain.java
new file mode 100644
index 0000000000..7dcf3d5a68
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/DefaultSCADomain.java
@@ -0,0 +1,566 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.CompositeService;
+import org.apache.tuscany.sca.assembly.SCABinding;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilderException;
+import org.apache.tuscany.sca.assembly.xml.Constants;
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.DeployedArtifact;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.service.ContributionException;
+import org.apache.tuscany.sca.contribution.service.ContributionService;
+import org.apache.tuscany.sca.contribution.service.util.FileHelper;
+import org.apache.tuscany.sca.core.assembly.ActivationException;
+import org.apache.tuscany.sca.core.assembly.CompositeActivator;
+import org.apache.tuscany.sca.core.assembly.RuntimeComponentImpl;
+import org.apache.tuscany.sca.core.context.ServiceReferenceImpl;
+import org.apache.tuscany.sca.host.embedded.SCADomain;
+import org.apache.tuscany.sca.host.embedded.management.ComponentListener;
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.policy.Policy;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentContext;
+import org.apache.tuscany.sca.runtime.RuntimeComponentReference;
+import org.osoa.sca.CallableReference;
+import org.osoa.sca.ServiceReference;
+import org.osoa.sca.ServiceRuntimeException;
+
+/**
+ * A default SCA domain facade implementation.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class DefaultSCADomain extends SCADomain {
+
+    private String uri;
+    private String[] composites;
+    private Composite domainComposite;
+    private Contribution contribution;
+    private Map<String, Component> components = new HashMap<String, Component>();
+    private ReallySmallRuntime runtime;
+    private ComponentManager componentManager;
+
+    /**
+     * Constructs a new domain facade.
+     * 
+     * @param domainURI
+     * @param contributionLocation
+     * @param composites
+     */
+    public DefaultSCADomain(ClassLoader runtimeClassLoader,
+                            ClassLoader applicationClassLoader,
+                            String domainURI,
+                            String contributionLocation,
+                            String... composites) {
+        this.uri = domainURI;
+        this.composites = composites;
+
+        // Create and start the runtime
+        // System.out.println("Test " + ReallySmallRuntime.class.getCanonicalName());
+        // IntentAttachPointTypeFactory iaptf;
+        Policy policy;
+        runtime = new ReallySmallRuntime(runtimeClassLoader);
+        try {
+            runtime.start();
+
+        } catch (ActivationException e) {
+            throw new ServiceRuntimeException(e);
+        }
+
+        // Contribute the given contribution to an in-memory repository
+        ContributionService contributionService = runtime.getContributionService();
+        URL contributionURL;
+        try {
+            contributionURL = getContributionLocation(applicationClassLoader, contributionLocation, this.composites);
+            if (contributionURL != null) {
+                // Make sure the URL is correctly encoded (for example, escape the space characters) 
+                contributionURL = contributionURL.toURI().toURL();
+            }
+        } catch (Exception e) {
+            throw new ServiceRuntimeException(e);
+        }
+
+        try {
+            String contributionURI = FileHelper.getName(contributionURL.getPath());
+            if (contributionURI == null || contributionURI.length() == 0) {
+                contributionURI = contributionURL.toString();
+            }
+            contribution = contributionService.contribute(contributionURI, contributionURL, false);
+        } catch (ContributionException e) {
+            throw new ServiceRuntimeException(e);
+        } catch (IOException e) {
+            throw new ServiceRuntimeException(e);
+        }
+
+        // Create an in-memory domain level composite
+        AssemblyFactory assemblyFactory = runtime.getAssemblyFactory();
+        domainComposite = assemblyFactory.createComposite();
+        domainComposite.setName(new QName(Constants.SCA10_NS, "domain"));
+        domainComposite.setURI(domainURI);
+
+        //when the deployable composites were specified when initializing the runtime
+        if (composites != null && composites.length > 0 && composites[0].length() > 0) {
+            // Include all specified deployable composites in the SCA domain
+            Map<String, Composite> compositeArtifacts = new HashMap<String, Composite>();
+            for (DeployedArtifact artifact : contribution.getArtifacts()) {
+                if (artifact.getModel() instanceof Composite) {
+                    compositeArtifacts.put(artifact.getURI(), (Composite)artifact.getModel());
+                }
+            }
+            for (String compositePath : composites) {
+                Composite composite = compositeArtifacts.get(compositePath);
+                if (composite == null) {
+                    throw new ServiceRuntimeException("Composite not found: " + compositePath);
+                }
+                domainComposite.getIncludes().add(composite);
+            }
+        } else {
+            // in this case, a sca-contribution.xml should have been specified
+            for (Composite composite : contribution.getDeployables()) {
+                domainComposite.getIncludes().add(composite);
+            }
+
+        }
+
+        // Build the SCA composites
+        CompositeBuilder compositeBuilder = runtime.getCompositeBuilder();
+
+        for (Composite composite : domainComposite.getIncludes()) {
+            try {
+                compositeBuilder.build(composite);
+            } catch (CompositeBuilderException e) {
+                throw new ServiceRuntimeException(e);
+            }
+        }
+
+        // Activate and start composites
+        CompositeActivator compositeActivator = runtime.getCompositeActivator();
+        compositeActivator.setDomainComposite(domainComposite);
+        for (Composite composite : domainComposite.getIncludes()) {
+            try {
+                compositeActivator.activate(composite);
+            } catch (ActivationException e) {
+                throw new ServiceRuntimeException(e);
+            }
+        }
+        for (Composite composite : domainComposite.getIncludes()) {
+            try {
+                for (Component component : composite.getComponents()) {
+                    compositeActivator.start(component);
+                }
+            } catch (ActivationException e) {
+                throw new ServiceRuntimeException(e);
+            }
+        }
+
+        // Index the top level components
+        for (Composite composite : domainComposite.getIncludes()) {
+            for (Component component : composite.getComponents()) {
+                components.put(component.getName(), component);
+            }
+        }
+
+        this.componentManager = new DefaultSCADomainComponentManager(this);
+
+        // For debugging purposes, print the composites
+//        ExtensionPointRegistry extensionPoints = runtime.getExtensionPointRegistry();
+//        StAXArtifactProcessorExtensionPoint artifactProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+//        StAXArtifactProcessor processor = artifactProcessors.getProcessor(Composite.class);
+//        for (Composite composite : domainComposite.getIncludes()) {
+//            try {
+//                ByteArrayOutputStream bos = new ByteArrayOutputStream();
+//                XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+//                outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
+//                processor.write(composite, outputFactory.createXMLStreamWriter(bos));
+//                Document document =
+//                    DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(bos
+//                        .toByteArray()));
+//                OutputFormat format = new OutputFormat();
+//                format.setIndenting(true);
+//                format.setIndent(2);
+//                XMLSerializer serializer = new XMLSerializer(System.out, format);
+//                serializer.serialize(document);
+//            } catch (Exception e) {
+//                e.printStackTrace();
+//            }
+//        }
+    
+    }
+
+    @Override
+    public void close() {
+
+        super.close();
+
+        // Stop and deactivate composites
+        CompositeActivator compositeActivator = runtime.getCompositeActivator();
+        for (Composite composite : domainComposite.getIncludes()) {
+            try {
+                for (Component component : composite.getComponents()) {
+                    compositeActivator.stop(component);
+                }
+            } catch (ActivationException e) {
+                throw new ServiceRuntimeException(e);
+            }
+        }
+        for (Composite composite : domainComposite.getIncludes()) {
+            try {
+                compositeActivator.deactivate(composite);
+            } catch (ActivationException e) {
+                throw new ServiceRuntimeException(e);
+            }
+        }
+
+        // Remove the contribution from the in-memory repository
+        ContributionService contributionService = runtime.getContributionService();
+        try {
+            contributionService.remove(contribution.getURI());
+        } catch (ContributionException e) {
+            throw new ServiceRuntimeException(e);
+        }
+
+        // Stop the runtime
+        try {
+            runtime.stop();
+        } catch (ActivationException e) {
+            throw new ServiceRuntimeException(e);
+        }
+    }
+
+    /**
+     * Determine the location of a contribution, given a contribution path and a
+     * list of composites.
+     * 
+     * @param contributionPath
+     * @param composites
+     * @param classLoader
+     * @return
+     * @throws MalformedURLException
+     */
+    private URL getContributionLocation(ClassLoader classLoader, String contributionPath, String[] composites)
+        throws MalformedURLException {
+        if (contributionPath != null && contributionPath.length() > 0) {
+            //encode spaces as they would cause URISyntaxException
+            contributionPath = contributionPath.replace(" ", "%20");
+            URI contributionURI = URI.create(contributionPath);
+            if (contributionURI.isAbsolute() || composites.length == 0) {
+                return new URL(contributionPath);
+            }
+        }
+
+        String contributionArtifactPath = null;
+        URL contributionArtifactURL = null;
+        if (composites != null && composites.length > 0 && composites[0].length() > 0) {
+
+            // Here the SCADomain was started with a reference to a composite file
+            contributionArtifactPath = composites[0];
+            contributionArtifactURL = classLoader.getResource(contributionArtifactPath);
+            if (contributionArtifactURL == null) {
+                throw new IllegalArgumentException("Composite not found: " + contributionArtifactPath);
+            }
+        } else {
+
+            // Here the SCADomain was started without any reference to a composite file
+            // We are going to look for an sca-contribution.xml or sca-contribution-generated.xml
+
+            // Look for META-INF/sca-contribution.xml
+            contributionArtifactPath = Contribution.SCA_CONTRIBUTION_META;
+            contributionArtifactURL = classLoader.getResource(contributionArtifactPath);
+
+            // Look for META-INF/sca-contribution-generated.xml
+            if (contributionArtifactURL == null) {
+                contributionArtifactPath = Contribution.SCA_CONTRIBUTION_GENERATED_META;
+                contributionArtifactURL = classLoader.getResource(contributionArtifactPath);
+            }
+
+            // Look for META-INF/sca-deployables directory
+            if (contributionArtifactURL == null) {
+                contributionArtifactPath = Contribution.SCA_CONTRIBUTION_DEPLOYABLES;
+                contributionArtifactURL = classLoader.getResource(contributionArtifactPath);
+            }
+        }
+
+        if (contributionArtifactURL == null) {
+            throw new IllegalArgumentException(
+                                               "Can't determine contribution deployables. Either specify a composite file, or use an sca-contribution.xml file to specify the deployables.");
+        }
+
+        URL contributionURL = null;
+        // "jar:file://....../something.jar!/a/b/c/app.composite"
+        try {
+            String url = contributionArtifactURL.toExternalForm();
+            String protocol = contributionArtifactURL.getProtocol();
+            if ("file".equals(protocol)) {
+                // directory contribution
+                if (url.endsWith(contributionArtifactPath)) {
+                    String location = url.substring(0, url.lastIndexOf(contributionArtifactPath));
+                    // workaround from evil url/uri form maven
+                    contributionURL = FileHelper.toFile(new URL(location)).toURI().toURL();
+                }
+
+            } else if ("jar".equals(protocol)) {
+                // jar contribution
+                String location = url.substring(4, url.lastIndexOf("!/"));
+                // workaround for evil url/uri from maven
+                contributionURL = FileHelper.toFile(new URL(location)).toURI().toURL();
+            }
+        } catch (MalformedURLException mfe) {
+            throw new IllegalArgumentException(mfe);
+        }
+
+        return contributionURL;
+    }
+
+    @Override
+    public <B, R extends CallableReference<B>> R cast(B target) throws IllegalArgumentException {
+        return (R)runtime.getProxyFactory().cast(target);
+    }
+
+    @Override
+    public <B> B getService(Class<B> businessInterface, String serviceName) {
+        ServiceReference<B> serviceReference = getServiceReference(businessInterface, serviceName);
+        if (serviceReference == null) {
+            throw new ServiceRuntimeException("Service not found: " + serviceName);
+        }
+        return serviceReference.getService();
+    }
+
+    private <B> ServiceReference<B> createServiceReference(Class<B> businessInterface, String targetURI) {
+        try {
+            AssemblyFactory assemblyFactory = runtime.getAssemblyFactory();
+            Composite composite = assemblyFactory.createComposite();
+            composite.setName(new QName(Constants.SCA10_TUSCANY_NS, "default"));
+            RuntimeComponent component = (RuntimeComponent)assemblyFactory.createComponent();
+            component.setName("default");
+            component.setURI("default");
+            runtime.getCompositeActivator().configureComponentContext(component);
+            composite.getComponents().add(component);
+            RuntimeComponentReference reference = (RuntimeComponentReference)assemblyFactory.createComponentReference();
+            reference.setName("default");
+            ModelFactoryExtensionPoint factories =
+                runtime.getExtensionPointRegistry().getExtensionPoint(ModelFactoryExtensionPoint.class);
+            JavaInterfaceFactory javaInterfaceFactory = factories.getFactory(JavaInterfaceFactory.class);
+            InterfaceContract interfaceContract = javaInterfaceFactory.createJavaInterfaceContract();
+            interfaceContract.setInterface(javaInterfaceFactory.createJavaInterface(businessInterface));
+            reference.setInterfaceContract(interfaceContract);
+            component.getReferences().add(reference);
+            reference.setComponent(component);
+            SCABindingFactory scaBindingFactory = factories.getFactory(SCABindingFactory.class);
+            SCABinding binding = scaBindingFactory.createSCABinding();
+            binding.setURI(targetURI);
+            reference.getBindings().add(binding);
+            return new ServiceReferenceImpl<B>(businessInterface, component, reference, binding, runtime
+                .getProxyFactory(), runtime.getCompositeActivator());
+        } catch (Exception e) {
+            throw new ServiceRuntimeException(e);
+        }
+    }
+
+    @Override
+    public <B> ServiceReference<B> getServiceReference(Class<B> businessInterface, String name) {
+
+        // Extract the component name
+        String componentName;
+        String serviceName;
+        int i = name.indexOf('/');
+        if (i != -1) {
+            componentName = name.substring(0, i);
+            serviceName = name.substring(i + 1);
+
+        } else {
+            componentName = name;
+            serviceName = null;
+        }
+
+        // Lookup the component in the domain
+        Component component = components.get(componentName);
+        if (component == null) {
+            // The component is not local in the partition, try to create a remote service ref
+            return createServiceReference(businessInterface, name);
+        }
+        RuntimeComponentContext componentContext = null;
+
+        // If the component is a composite, then we need to find the
+        // non-composite component that provides the requested service
+        if (component.getImplementation() instanceof Composite) {
+            for (ComponentService componentService : component.getServices()) {
+                if (serviceName == null || serviceName.equals(componentService.getName())) {
+                    CompositeService compositeService = (CompositeService)componentService.getService();
+                    if (compositeService != null) {
+                        if (serviceName != null) {
+                            serviceName = "$promoted$." + serviceName;
+                        }
+                        componentContext =
+                            ((RuntimeComponent)compositeService.getPromotedComponent()).getComponentContext();
+                        return componentContext.createSelfReference(businessInterface, compositeService
+                            .getPromotedService());
+                    }
+                    break;
+                }
+            }
+            // No matching service is found
+            throw new ServiceRuntimeException("Composite service not found: " + name);
+        } else {
+            componentContext = ((RuntimeComponent)component).getComponentContext();
+            if (serviceName != null) {
+                return componentContext.createSelfReference(businessInterface, serviceName);
+            } else {
+                return componentContext.createSelfReference(businessInterface);
+            }
+        }
+
+    }
+
+    @Override
+    public String getURI() {
+        return uri;
+    }
+
+    @Override
+    public ComponentManager getComponentManager() {
+        return componentManager;
+    }
+
+    public Set<String> getComponentNames() {
+        Set<String> componentNames = new HashSet<String>();
+        for (DeployedArtifact artifact : contribution.getArtifacts()) {
+            if (artifact.getModel() instanceof Composite) {
+                for (Component component : ((Composite)artifact.getModel()).getComponents()) {
+                    componentNames.add(component.getName());
+                }
+            }
+        }
+        return componentNames;
+    }
+
+    public Component getComponent(String componentName) {
+        for (DeployedArtifact artifact : contribution.getArtifacts()) {
+            if (artifact.getModel() instanceof Composite) {
+                for (Component component : ((Composite)artifact.getModel()).getComponents()) {
+                    if (component.getName().equals(componentName)) {
+                        return component;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public void startComponent(String componentName) throws ActivationException {
+        Component component = getComponent(componentName);
+        if (component == null) {
+            throw new IllegalArgumentException("no component: " + componentName);
+        }
+        CompositeActivator compositeActivator = runtime.getCompositeActivator();
+        compositeActivator.start(component);
+    }
+
+    public void stopComponent(String componentName) throws ActivationException {
+        Component component = getComponent(componentName);
+        if (component == null) {
+            throw new IllegalArgumentException("no component: " + componentName);
+        }
+        CompositeActivator compositeActivator = runtime.getCompositeActivator();
+        compositeActivator.stop(component);
+    }
+}
+
+class DefaultSCADomainComponentManager implements ComponentManager {
+
+    protected DefaultSCADomain scaDomain;
+    protected List<ComponentListener> listeners = new CopyOnWriteArrayList<ComponentListener>();
+
+    public DefaultSCADomainComponentManager(DefaultSCADomain scaDomain) {
+        this.scaDomain = scaDomain;
+    }
+
+    public void addComponentListener(ComponentListener listener) {
+        this.listeners.add(listener);
+    }
+
+    public void removeComponentListener(ComponentListener listener) {
+        this.listeners.remove(listener);
+    }
+
+    public Set<String> getComponentNames() {
+        return scaDomain.getComponentNames();
+    }
+
+    public Component getComponent(String componentName) {
+        return scaDomain.getComponent(componentName);
+    }
+
+    public void startComponent(String componentName) throws ActivationException {
+        scaDomain.startComponent(componentName);
+    }
+
+    public void stopComponent(String componentName) throws ActivationException {
+        scaDomain.stopComponent(componentName);
+    }
+
+    public void notifyComponentStarted(String componentName) {
+        for (ComponentListener listener : listeners) {
+            try {
+                listener.componentStarted(componentName);
+            } catch (Exception e) {
+                e.printStackTrace(); // TODO: log
+            }
+        }
+    }
+
+    public void notifyComponentStopped(String componentName) {
+        for (ComponentListener listener : listeners) {
+            try {
+                listener.componentStopped(componentName);
+            } catch (Exception e) {
+                e.printStackTrace(); // TODO: log
+            }
+        }
+    }
+
+    public boolean isComponentStarted(String componentName) {
+        RuntimeComponentImpl runtimeComponent = (RuntimeComponentImpl)getComponent(componentName);
+        return runtimeComponent.isStarted();
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/EmbeddedSCADomain.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/EmbeddedSCADomain.java
new file mode 100644
index 0000000000..415a78357e
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/EmbeddedSCADomain.java
@@ -0,0 +1,229 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.CompositeService;
+import org.apache.tuscany.sca.assembly.SCABinding;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.assembly.xml.Constants;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.service.ContributionService;
+import org.apache.tuscany.sca.core.assembly.ActivationException;
+import org.apache.tuscany.sca.core.assembly.CompositeActivator;
+import org.apache.tuscany.sca.core.context.ServiceReferenceImpl;
+import org.apache.tuscany.sca.host.embedded.SCADomain;
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentContext;
+import org.apache.tuscany.sca.runtime.RuntimeComponentReference;
+import org.osoa.sca.CallableReference;
+import org.osoa.sca.ServiceReference;
+import org.osoa.sca.ServiceRuntimeException;
+
+/**
+ * An SCA domain facade implementation.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class EmbeddedSCADomain extends SCADomain {
+
+    private String uri;
+    private Composite domainComposite;
+    private ReallySmallRuntime runtime;
+    private ComponentManagerImpl componentManager = new ComponentManagerImpl(this);
+    
+    /**
+     * Constructs a new domain facade.
+     *
+     * @param runtimeClassLoader
+     * @param domainURI
+     */
+    public EmbeddedSCADomain(ClassLoader runtimeClassLoader,
+                            String domainURI) {
+        this.uri = domainURI;
+        
+        // Create a runtime
+        runtime = new ReallySmallRuntime(runtimeClassLoader);
+    }
+    
+    public void start() throws ActivationException {
+
+        // Start the runtime
+        runtime.start();
+        
+        // Create an in-memory domain level composite
+        AssemblyFactory assemblyFactory = runtime.getAssemblyFactory();
+        domainComposite = assemblyFactory.createComposite();
+        domainComposite.setName(new QName(Constants.SCA10_NS, "domain"));
+        domainComposite.setURI(uri);
+        
+        getCompositeActivator().setDomainComposite(domainComposite);
+        
+    }
+
+    public void stop() throws ActivationException {
+        
+        // Stop the runtime
+        runtime.stop();
+        
+        // Cleanup
+        domainComposite = null;
+    }
+
+    public ContributionService getContributionService() {
+        return runtime.getContributionService();
+    }
+    
+    public CompositeBuilder getCompositeBuilder() {
+        return runtime.getCompositeBuilder();
+    }
+    
+    public CompositeActivator getCompositeActivator() {
+        return runtime.getCompositeActivator();
+    }
+    
+    public Composite getDomainComposite() {
+        return domainComposite;
+    }
+    
+    @Override
+    public ComponentManager getComponentManager() {
+        return componentManager;
+    }
+    
+    @Override
+    public void close() {
+        super.close();
+    }
+
+    @Override
+    public <B, R extends CallableReference<B>> R cast(B target) throws IllegalArgumentException {
+        return (R)runtime.getProxyFactory().cast(target);
+    }
+
+    @Override
+    public <B> B getService(Class<B> businessInterface, String serviceName) {
+        ServiceReference<B> serviceReference = getServiceReference(businessInterface, serviceName);
+        if (serviceReference == null) {
+            throw new ServiceRuntimeException("Service not found: " + serviceName);
+        }
+        return serviceReference.getService();
+    }
+
+    private <B> ServiceReference<B> createServiceReference(Class<B> businessInterface, String targetURI) {
+        try {
+            AssemblyFactory assemblyFactory = runtime.getAssemblyFactory();
+            Composite composite = assemblyFactory.createComposite();
+            composite.setName(new QName(Constants.SCA10_TUSCANY_NS, "default"));
+            RuntimeComponent component = (RuntimeComponent)assemblyFactory.createComponent();
+            component.setName("default");
+            component.setURI("default");
+            runtime.getCompositeActivator().configureComponentContext(component);
+            composite.getComponents().add(component);
+            RuntimeComponentReference reference = (RuntimeComponentReference)assemblyFactory.createComponentReference();
+            reference.setName("default");
+            ModelFactoryExtensionPoint factories =
+                runtime.getExtensionPointRegistry().getExtensionPoint(ModelFactoryExtensionPoint.class);
+            JavaInterfaceFactory javaInterfaceFactory = factories.getFactory(JavaInterfaceFactory.class);
+            InterfaceContract interfaceContract = javaInterfaceFactory.createJavaInterfaceContract();
+            interfaceContract.setInterface(javaInterfaceFactory.createJavaInterface(businessInterface));
+            reference.setInterfaceContract(interfaceContract);
+            component.getReferences().add(reference);
+            reference.setComponent(component);
+            SCABindingFactory scaBindingFactory = factories.getFactory(SCABindingFactory.class);
+            SCABinding binding = scaBindingFactory.createSCABinding();
+            binding.setURI(targetURI);
+            reference.getBindings().add(binding);
+            return new ServiceReferenceImpl<B>(businessInterface, component, reference, binding, runtime
+                .getProxyFactory(), runtime.getCompositeActivator());
+        } catch (Exception e) {
+            throw new ServiceRuntimeException(e);
+        }
+    }
+    @Override
+    public <B> ServiceReference<B> getServiceReference(Class<B> businessInterface, String name) {
+
+        // Extract the component name
+        String componentName;
+        String serviceName;
+        int i = name.indexOf('/');
+        if (i != -1) {
+            componentName = name.substring(0, i);
+            serviceName = name.substring(i + 1);
+
+        } else {
+            componentName = name;
+            serviceName = null;
+        }
+
+        // Lookup the component in the domain
+        Component component = componentManager.getComponent(componentName);
+        if (component == null) {
+            // The component is not local in the partition, try to create a remote service ref
+            return createServiceReference(businessInterface, name);
+        }
+        RuntimeComponentContext componentContext = null;
+
+        // If the component is a composite, then we need to find the
+        // non-composite component that provides the requested service
+        if (component.getImplementation() instanceof Composite) {
+            for (ComponentService componentService : component.getServices()) {
+                if (serviceName == null || serviceName.equals(componentService.getName())) {
+                    CompositeService compositeService = (CompositeService)componentService.getService();
+                    if (compositeService != null) {
+                        if (serviceName != null) {
+                            serviceName = "$promoted$." + serviceName;
+                        }
+                        componentContext =
+                            ((RuntimeComponent)compositeService.getPromotedComponent()).getComponentContext();
+                        return componentContext.createSelfReference(businessInterface, compositeService
+                            .getPromotedService());
+                    }
+                    break;
+                }
+            }
+            // No matching service is found
+            throw new ServiceRuntimeException("Composite service not found: " + name);
+        } else {
+            componentContext = ((RuntimeComponent)component).getComponentContext();
+            if (serviceName != null) {
+                return componentContext.createSelfReference(businessInterface, serviceName);
+            } else {
+                return componentContext.createSelfReference(businessInterface);
+            }
+        }
+
+    }
+
+    @Override
+    public String getURI() {
+        return uri;
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/HotUpdatableSCADomain.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/HotUpdatableSCADomain.java
new file mode 100644
index 0000000000..2942e61db2
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/HotUpdatableSCADomain.java
@@ -0,0 +1,391 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilderException;
+import org.apache.tuscany.sca.contribution.resolver.impl.ModelResolverImpl;
+import org.apache.tuscany.sca.contribution.service.ContributionService;
+import org.apache.tuscany.sca.contribution.service.util.FileHelper;
+import org.apache.tuscany.sca.core.assembly.ActivationException;
+import org.apache.tuscany.sca.host.embedded.SCADomain;
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+import org.osoa.sca.CallableReference;
+import org.osoa.sca.ServiceReference;
+import org.osoa.sca.ServiceRuntimeException;
+
+/**
+ * An SCADomain that starts a Tuscany runtime supporting multiple
+ * SCA contribution jars. All contribution jars found in a repository
+ * directory will be contributed to the SCA domain. Any changes to the
+ * contributions in that repository will be automatically detected and
+ * the sca domain updated accordingly.
+ * 
+ *  TODO: find how to properly add/remove contributions and start/activate the doamain
+ *  TODO: support contributions that are folders as well as jar's
+ *  TODO: needs to restart the entire scadomain when a contribution changes
+ *        as the domain classpath includes all the contribution jar's, would
+ *        be nice to find a way to avoid this
+ *  TODO: hot update requires copying contribution jars to a temp location
+ *        to avoid the classpath lock preventing updating the contribution
+ *        jars, would be nice to find a way to avoid that
+ */
+public class HotUpdatableSCADomain extends SCADomain {
+    private static final Logger logger = Logger.getLogger(HotUpdatableSCADomain.class.getName());
+    protected String domainURI;
+    protected File contributionRepository;
+    
+    protected EmbeddedSCADomain scaDomain;
+
+    protected boolean hotUpdateActive;
+    protected Thread hotUpdateThread;
+    protected int hotUpdateInterval; //  milliseconds, 0 = hotupdate disabled
+
+    protected HashMap<URL, Long> existingContributions; // value is last modified time
+    protected ClassLoader originalCCL;
+
+    protected static final String REPOSITORY_FOLDER = "sca-contributions";
+    
+    public HotUpdatableSCADomain(String domainURI, File contributionRepository, int hotupdateInterval) {
+        this.domainURI = domainURI;
+        this.contributionRepository = contributionRepository;
+        this.hotUpdateInterval = hotupdateInterval;
+        this.originalCCL = Thread.currentThread().getContextClassLoader();
+        start();
+    }
+    
+    protected void start() {
+        try {
+            initEmbeddedSCADomain();
+            activateHotUpdate();
+            for (URL url : existingContributions.keySet()) {
+                File f = new File(url.toURI());
+                logger.info("added contribution: " + f.getName());
+            }
+        } catch (ActivationException e) {
+            throw new ServiceRuntimeException(e);
+        } catch (URISyntaxException e) {
+            throw new ServiceRuntimeException(e);
+        }
+    }
+    
+    @Override
+    public void close() {
+        try {
+            hotUpdateActive = false;
+            scaDomain.stop();
+        } catch (ActivationException e) {
+            throw new ServiceRuntimeException(e);
+        }
+        Thread.currentThread().setContextClassLoader(originalCCL);
+        super.close();
+    }
+
+
+    protected SCADomain initEmbeddedSCADomain() throws ActivationException {
+
+        URL[] contributionJars = getContributionJarURLs(contributionRepository);
+
+        this.existingContributions = getLastModified(contributionJars);
+
+        if (hotUpdateInterval > 0) {
+            contributionJars = copyContributionsToTemp(contributionJars);
+        }
+
+        // Using the CCL as the parent exposes Tuscany to the contributions, want to do this? 
+        URLClassLoader cl = new URLClassLoader(contributionJars, originalCCL);
+        Thread.currentThread().setContextClassLoader(cl);
+
+        scaDomain = new EmbeddedSCADomain(cl, domainURI);
+
+        scaDomain.start();
+
+        initContributions(scaDomain, cl, contributionJars);
+        
+        return scaDomain;
+    }
+
+    protected URL[] getContributionJarURLs(File repositoryDir) {
+
+        String[] jars = repositoryDir.list(new FilenameFilter() {
+            public boolean accept(File dir, String name) {
+                return name.endsWith(".jar");
+            }});
+
+        List<URL> contributionJars = new ArrayList<URL>();
+        if (jars != null) {
+            for (String jar : jars) {
+                try {
+                    contributionJars.add(new File(repositoryDir, jar).toURL());
+                } catch (MalformedURLException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+
+        return contributionJars.toArray(new URL[contributionJars.size()]);
+    }
+
+    /**
+     * TODO: No idea what the 'correct' way to add/contribute and activate/start things to an scaDomain is
+     *       but this seems to work. Doesn't seem to start <service>s or <reference>s which are outside of
+     *       a <component> so something is missing/wrong. Also this doesn't seem to be picking up composites
+     *       located in META-INF/deployables or specified in the sca-deployables.xml. Maybe the EmbeddedSCADomain
+     *       and ContributionService APIs should make all this easier?
+     */
+    protected void initContributions(EmbeddedSCADomain scaDomain,  ClassLoader cl, URL[] contributionJars) {
+        ModelResolverImpl modelResolver = new ModelResolverImpl(cl);
+        ContributionService contributionService = scaDomain.getContributionService();
+        for (URL jar : contributionJars) {
+            InputStream is = null;
+            try {
+                is = jar.openStream();
+                contributionService.contribute(jar.toString(), jar, is , modelResolver);
+            } catch (Exception e) {
+                System.err.println("exception adding contribution: " + jar);
+                e.printStackTrace();
+            }
+            if (is != null) {
+                try {
+                    is.close();
+                } catch (IOException e) {
+                    // ignore
+                }
+            }
+        }
+        
+        try {
+
+            for (Object m : modelResolver.getModels()) {
+                if (m instanceof Composite) {
+                    Composite composite = (Composite)m;
+                    scaDomain.getDomainComposite().getIncludes().add(composite);
+                    scaDomain.getCompositeBuilder().build(composite);
+                    scaDomain.getCompositeActivator().activate(composite);
+                }
+            }
+
+            for (Object m : modelResolver.getModels()) {
+                if (m instanceof Composite) {
+                    Composite composite = (Composite)m;
+                    scaDomain.getCompositeActivator().start(composite);
+                }
+            }
+
+        } catch (ActivationException e) {
+            throw new RuntimeException(e);
+        } catch (CompositeBuilderException e) {
+            throw new RuntimeException(e);
+        }
+        
+    }
+
+    /**
+     * Copies Files to a temp location returning the URLs of the new temp files.
+     * For hot update to work need to be able to delete/update the contribution jar's
+     * but as they're in the classpath the URLClassLoader has an open lock on the jar's
+     * so you can't update them. This solution copies each contribution to a temp
+     * location for use on the classpath, nicer would be a ClassLoder impl that doesn't
+     * lock the jar's.
+     */
+    protected URL[] copyContributionsToTemp(URL[] contributionJars) {
+        try {
+
+            URL[] newURLs = new URL[contributionJars.length];
+            File tempDir = new File(System.getProperty("java.io.tmpdir"));
+            for (int i=0; i<contributionJars.length; i++) {
+                File fin = new File(contributionJars[i].toURI());
+                File fout = File.createTempFile("tuscany", fin.getName(), tempDir);
+                fout.deleteOnExit();
+                FileHelper.copyFile(fin, fout);
+                fout.setLastModified(System.currentTimeMillis());
+                newURLs[i] = fout.toURL();
+            }
+            return newURLs;
+
+        } catch (IOException e) {
+            throw new RuntimeException(e);            
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);            
+        }
+    }
+
+    /**
+     * Returns the last modified times of the files pointed to by the URLs  
+     */
+    protected HashMap<URL, Long> getLastModified(URL[] contrabutions) {
+        try {
+
+            HashMap<URL, Long> contributionLastUpdates = new HashMap<URL, Long>();
+            for (URL url: contrabutions) {
+                File f = new File(url.toURI());
+                contributionLastUpdates.put(url, new Long(f.lastModified()));
+            }
+            return contributionLastUpdates;
+
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    protected void activateHotUpdate() {
+        if (hotUpdateInterval == 0) {
+            return; // hotUpdateInterval of 0 disables hotupdate
+        }
+
+        Runnable runable = new Runnable() {
+            public void run() {
+                logger.info("Tuscany contribution hotupdate running");
+                while (hotUpdateActive) {
+                    try {
+                        Thread.sleep(hotUpdateInterval);
+                    } catch (InterruptedException e) {
+                    }
+                    if (hotUpdateActive) {
+                        checkForUpdates();
+                    }
+                }
+                logger.info("Tuscany contribution hotupdate stopped");
+            }
+        };
+        hotUpdateThread = new Thread(runable, "TuscanyHotUpdate");
+        hotUpdateActive = true;
+        hotUpdateThread.start();
+    }
+
+
+    /**
+     * Checks if any of the contributions have been updated and if so restarts the sca domain
+     * TODO: Ideally just the altered contribution would be restarted but thats not possible
+     *       as the classloader used by the SCADomain includes the old contribution so need
+     *       to restart the entire domain to use a new ClassLoader. Should there be seperate 
+     *       ClassLoader per contribution? But then have all the issues with sharing classes
+     *       across contributions.
+     */
+    protected void checkForUpdates() {
+        URL[] currentContributions = getContributionJarURLs(contributionRepository);
+        
+        if (areContributionsAltered(currentContributions)) {
+            try {
+                scaDomain.stop();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            try {
+                initEmbeddedSCADomain();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    protected boolean areContributionsAltered(URL[] currentContrabutions) {
+        try {
+            
+            List addedContributions = getAddedContributions(currentContrabutions);
+            List removedContributions = getRemovedContributions(currentContrabutions);
+            List updatedContributions = getUpdatedContributions(currentContrabutions);
+            
+            return (addedContributions.size() > 0 || removedContributions.size() > 0 || updatedContributions.size() > 0);
+
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    protected List<URL> getUpdatedContributions(URL[] currentContrabutions) throws URISyntaxException {
+        List<URL> urls = new ArrayList<URL>();
+        for (URL url : currentContrabutions) {
+            if (existingContributions.containsKey(url)) {
+                File curentFile = new File(url.toURI());
+                if (curentFile.lastModified() != existingContributions.get(url)) {
+                    urls.add(url);
+                    logger.info("updated contribution: " + curentFile.getName());
+                }
+            }
+        }
+        return urls;
+    }
+
+    protected List getRemovedContributions(URL[] currentContrabutions) throws URISyntaxException {
+        List<URL> currentUrls = Arrays.asList(currentContrabutions);
+        List<URL> urls = new ArrayList<URL>();
+        for (URL url : existingContributions.keySet()) {
+            if (!currentUrls.contains(url)) {
+                urls.add(url);
+            }
+        }
+        for (URL url : urls) {
+            logger.info("removed contributions: " + new File(url.toURI()).getName());
+        }
+        return urls;
+    }
+
+    protected List getAddedContributions(URL[] currentContrabutions) throws URISyntaxException {
+        List<URL> urls = new ArrayList<URL>();
+        for (URL url : currentContrabutions) {
+            if (!existingContributions.containsKey(url)) {
+                urls.add(url);
+                logger.info("added contribution: " + new File(url.toURI()).getName());
+            }
+        }
+        return urls;
+    }
+
+    @Override
+    public <B, R extends CallableReference<B>> R cast(B target) throws IllegalArgumentException {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+    @Override
+    public <B> B getService(Class<B> businessInterface, String serviceName) {
+        return scaDomain.getService(businessInterface, serviceName);
+    }
+
+    @Override
+    public <B> ServiceReference<B> getServiceReference(Class<B> businessInterface, String referenceName) {
+        return scaDomain.getServiceReference(businessInterface, referenceName);
+    }
+
+    @Override
+    public String getURI() {
+        return domainURI;
+    }
+
+    @Override
+    public ComponentManager getComponentManager(){
+        return  scaDomain.getComponentManager();
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ReallySmallRuntime.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ReallySmallRuntime.java
new file mode 100644
index 0000000000..bc8776d958
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ReallySmallRuntime.java
@@ -0,0 +1,297 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.context.ContextFactoryExtensionPoint;
+import org.apache.tuscany.sca.context.DefaultContextFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.ContributionFactory;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionService;
+import org.apache.tuscany.sca.contribution.util.ServiceConfigurationUtil;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ModuleActivator;
+import org.apache.tuscany.sca.core.assembly.ActivationException;
+import org.apache.tuscany.sca.core.assembly.CompositeActivator;
+import org.apache.tuscany.sca.core.assembly.RuntimeAssemblyFactory;
+import org.apache.tuscany.sca.core.invocation.MessageFactoryImpl;
+import org.apache.tuscany.sca.core.invocation.ProxyFactory;
+import org.apache.tuscany.sca.core.scope.ScopeRegistry;
+import org.apache.tuscany.sca.definitions.SCADefinitions;
+import org.apache.tuscany.sca.definitions.xml.SCADefinitionsDocumentProcessor;
+import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
+import org.apache.tuscany.sca.interfacedef.impl.InterfaceContractMapperImpl;
+import org.apache.tuscany.sca.invocation.MessageFactory;
+import org.apache.tuscany.sca.policy.DefaultIntentAttachPointTypeFactory;
+import org.apache.tuscany.sca.policy.DefaultPolicyFactory;
+import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.work.WorkScheduler;
+
+public class ReallySmallRuntime {
+	private final static Logger logger = Logger.getLogger(ReallySmallRuntime.class.getName());
+    private List<ModuleActivator> modules;
+    private ExtensionPointRegistry registry;
+
+    private ClassLoader classLoader;
+    private AssemblyFactory assemblyFactory;
+    private ContributionService contributionService;
+    private CompositeActivator compositeActivator;
+    private CompositeBuilder compositeBuilder;
+    private WorkScheduler workScheduler;
+    private ScopeRegistry scopeRegistry;
+    private ProxyFactory proxyFactory;
+
+    public ReallySmallRuntime(ClassLoader classLoader) {
+        this.classLoader = classLoader;
+    }
+
+    public void start() throws ActivationException {
+    	long start = System.currentTimeMillis();
+    	
+        // Create our extension point registry
+        registry = new DefaultExtensionPointRegistry();
+
+//      Get work scheduler
+        workScheduler = registry.getExtensionPoint(WorkScheduler.class);
+
+        // Create an interface contract mapper
+        InterfaceContractMapper mapper = new InterfaceContractMapperImpl();
+
+        // Get factory extension point
+        ModelFactoryExtensionPoint factories = registry.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        
+        // Create context factory extension point
+        ContextFactoryExtensionPoint contextFactories = new DefaultContextFactoryExtensionPoint();
+        registry.addExtensionPoint(contextFactories);
+        
+        // Create Message factory
+        MessageFactory messageFactory = new MessageFactoryImpl();
+        factories.addFactory(messageFactory);
+
+        // Create a proxy factory
+        proxyFactory = ReallySmallRuntimeBuilder.createProxyFactory(registry, mapper, messageFactory);
+
+        // Create model factories
+        assemblyFactory = new RuntimeAssemblyFactory();
+        factories.addFactory(assemblyFactory);
+        PolicyFactory policyFactory = new DefaultPolicyFactory();
+        factories.addFactory(policyFactory);
+        SCABindingFactory scaBindingFactory = factories.getFactory(SCABindingFactory.class);
+        IntentAttachPointTypeFactory intentAttachPointTypeFactory = new DefaultIntentAttachPointTypeFactory();
+        factories.addFactory(intentAttachPointTypeFactory);
+        ContributionFactory contributionFactory = factories.getFactory(ContributionFactory.class); 
+        
+        // Create a contribution service
+        contributionService = ReallySmallRuntimeBuilder.createContributionService(classLoader,
+                                                                                  registry,
+                                                                                  contributionFactory,
+                                                                                  assemblyFactory,
+                                                                                  policyFactory,
+                                                                                  mapper);
+        
+        // Create the ScopeRegistry
+        scopeRegistry = ReallySmallRuntimeBuilder.createScopeRegistry(registry); 
+        
+        // Create a composite activator
+        compositeActivator = ReallySmallRuntimeBuilder.createCompositeActivator(registry,
+                                                                                assemblyFactory,
+                                                                                messageFactory,
+                                                                                scaBindingFactory,
+                                                                                mapper,
+                                                                                proxyFactory,
+                                                                                scopeRegistry,
+                                                                                workScheduler);
+
+        
+        // Load the runtime modules
+        modules = loadModules(registry, classLoader);
+        
+        // Start the runtime modules
+        startModules(registry, modules);
+
+        // Load the definitions.xml
+        URLArtifactProcessorExtensionPoint documentProcessors = registry.getExtensionPoint(URLArtifactProcessorExtensionPoint.class);
+        SCADefinitionsDocumentProcessor definitionsProcessor = (SCADefinitionsDocumentProcessor)documentProcessors.getProcessor(SCADefinitions.class);
+        SCADefinitions definitions = loadDomainDefinitions(definitionsProcessor);
+        List<PolicySet> domainPolicySets;
+        if ( definitions != null ) {
+            domainPolicySets = definitions.getPolicySets();
+        } else {
+            domainPolicySets = null;
+        }
+        
+        //Create a composite builder
+        compositeBuilder = ReallySmallRuntimeBuilder.createCompositeBuilder(assemblyFactory,
+                                                                            scaBindingFactory,
+                                                                            intentAttachPointTypeFactory,
+                                                                            mapper,
+                                                                            domainPolicySets);
+        if (logger.isLoggable(Level.FINE)) {
+            long end = System.currentTimeMillis();
+            logger.fine("The tuscany runtime is started in " + (end - start) + " ms.");
+        }
+    }
+    
+    private SCADefinitions loadDomainDefinitions(SCADefinitionsDocumentProcessor definitionsProcessor) throws ActivationException {
+        URL url = this.classLoader.getResource("definitions.xml");
+        SCADefinitions definitions = null;
+        
+        if ( url != null ) {
+            try {
+                definitions = definitionsProcessor.read(null, null, url);
+                definitionsProcessor.resolve(definitions, definitionsProcessor.getDomainModelResolver());
+            } catch ( ContributionReadException e ) {
+                throw new ActivationException(e);
+            } catch ( ContributionResolveException e ) {
+                throw new ActivationException(e);
+            }
+        } 
+        return definitions;
+    }
+
+    public void stop() throws ActivationException {
+    	long start = System.currentTimeMillis();
+
+        // Stop the runtime modules
+        stopModules(registry, modules);
+
+        // Stop and destroy the work manager
+        workScheduler.destroy(); 
+
+        // Cleanup
+        modules = null;
+        registry = null;
+        assemblyFactory = null;
+        contributionService = null;
+        compositeActivator = null;
+        workScheduler = null;
+        scopeRegistry = null;
+        
+        if (logger.isLoggable(Level.FINE)) {
+            long end = System.currentTimeMillis();
+            logger.fine("The tuscany runtime is stopped in " + (end - start) + " ms.");
+        }
+    }
+
+    public ContributionService getContributionService() {
+        return contributionService;
+    }
+
+    public CompositeActivator getCompositeActivator() {
+        return compositeActivator;
+    }
+    
+    public CompositeBuilder getCompositeBuilder() {
+        return compositeBuilder;
+    }
+
+    public AssemblyFactory getAssemblyFactory() {
+        return assemblyFactory;
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<ModuleActivator> loadModules(ExtensionPointRegistry registry, ClassLoader classLoader) throws ActivationException {
+
+        // Load and instantiate the modules found on the classpath
+        modules = new ArrayList<ModuleActivator>();
+        try {
+            List<String> classNames = ServiceConfigurationUtil.getServiceClassNames(classLoader, ModuleActivator.class.getName());
+            for (String className : classNames) {       
+                Class moduleClass = Class.forName(className, true, classLoader);
+                ModuleActivator module = (ModuleActivator)moduleClass.newInstance();
+                modules.add(module);
+            }
+        } catch (IOException e) {
+            throw new ActivationException(e);
+        } catch (ClassNotFoundException e) {
+            throw new ActivationException(e);
+        } catch (InstantiationException e) {
+            throw new ActivationException(e);
+        } catch (IllegalAccessException e) {
+            throw new ActivationException(e);
+        }
+
+        return modules;
+    }
+    
+    private void startModules(ExtensionPointRegistry registry, List<ModuleActivator> modules)
+        throws ActivationException {
+        boolean debug = logger.isLoggable(Level.FINE);
+        // Start all the extension modules
+        for (ModuleActivator module : modules) {
+            long start = 0L;
+            if (debug) {
+                logger.fine(module.getClass().getName() + " is starting.");
+                start = System.currentTimeMillis();
+            }
+            module.start(registry);
+            if (debug) {
+                long end = System.currentTimeMillis();
+                logger.fine(module.getClass().getName() + " is started in " + (end - start) + " ms.");
+            }
+        }
+    }
+
+    private void stopModules(ExtensionPointRegistry registry, List<ModuleActivator> modules) {
+        boolean debug = logger.isLoggable(Level.FINE);
+        for (ModuleActivator module : modules) {
+            long start = 0L;
+            if (debug) {
+                logger.fine(module.getClass().getName() + " is stopping.");
+                start = System.currentTimeMillis();
+            }
+            module.stop(registry);
+            if (debug) {
+                long end = System.currentTimeMillis();
+                logger.fine(module.getClass().getName() + " is stopped in " + (end - start) + " ms.");
+            }
+        }
+    }
+
+    /**
+     * @return the proxyFactory
+     */
+    public ProxyFactory getProxyFactory() {
+        return proxyFactory;
+    }
+
+    /**
+     * @return the registry
+     */
+    public ExtensionPointRegistry getExtensionPointRegistry() {
+        return registry;
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ReallySmallRuntimeBuilder.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ReallySmallRuntimeBuilder.java
new file mode 100644
index 0000000000..858bca02ac
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/impl/ReallySmallRuntimeBuilder.java
@@ -0,0 +1,265 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import java.io.IOException;
+import java.util.List;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.assembly.builder.impl.CompositeBuilderImpl;
+import org.apache.tuscany.sca.assembly.xml.ComponentTypeDocumentProcessor;
+import org.apache.tuscany.sca.assembly.xml.ComponentTypeProcessor;
+import org.apache.tuscany.sca.assembly.xml.CompositeDocumentProcessor;
+import org.apache.tuscany.sca.assembly.xml.CompositeProcessor;
+import org.apache.tuscany.sca.assembly.xml.ConstrainingTypeDocumentProcessor;
+import org.apache.tuscany.sca.assembly.xml.ConstrainingTypeProcessor;
+import org.apache.tuscany.sca.binding.sca.xml.SCABindingProcessor;
+import org.apache.tuscany.sca.context.ContextFactoryExtensionPoint;
+import org.apache.tuscany.sca.context.RequestContextFactory;
+import org.apache.tuscany.sca.contribution.ContributionFactory;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.DefaultValidatingXMLInputFactory;
+import org.apache.tuscany.sca.contribution.processor.ExtensiblePackageProcessor;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleURLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.PackageProcessor;
+import org.apache.tuscany.sca.contribution.processor.PackageProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ValidationSchemaExtensionPoint;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolverExtensionPoint;
+import org.apache.tuscany.sca.contribution.service.ContributionListenerExtensionPoint;
+import org.apache.tuscany.sca.contribution.service.ContributionRepository;
+import org.apache.tuscany.sca.contribution.service.ContributionService;
+import org.apache.tuscany.sca.contribution.service.ExtensibleContributionListener;
+import org.apache.tuscany.sca.contribution.service.TypeDescriber;
+import org.apache.tuscany.sca.contribution.service.impl.ContributionMetadataProcessor;
+import org.apache.tuscany.sca.contribution.service.impl.ContributionRepositoryImpl;
+import org.apache.tuscany.sca.contribution.service.impl.ContributionServiceImpl;
+import org.apache.tuscany.sca.contribution.service.impl.PackageTypeDescriberImpl;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.assembly.ActivationException;
+import org.apache.tuscany.sca.core.assembly.CompositeActivator;
+import org.apache.tuscany.sca.core.assembly.CompositeActivatorImpl;
+import org.apache.tuscany.sca.core.conversation.ConversationManager;
+import org.apache.tuscany.sca.core.conversation.ConversationManagerImpl;
+import org.apache.tuscany.sca.core.invocation.DefaultProxyFactoryExtensionPoint;
+import org.apache.tuscany.sca.core.invocation.ExtensibleWireProcessor;
+import org.apache.tuscany.sca.core.invocation.ProxyFactory;
+import org.apache.tuscany.sca.core.scope.CompositeScopeContainerFactory;
+import org.apache.tuscany.sca.core.scope.ConversationalScopeContainerFactory;
+import org.apache.tuscany.sca.core.scope.RequestScopeContainerFactory;
+import org.apache.tuscany.sca.core.scope.ScopeContainerFactory;
+import org.apache.tuscany.sca.core.scope.ScopeRegistry;
+import org.apache.tuscany.sca.core.scope.ScopeRegistryImpl;
+import org.apache.tuscany.sca.core.scope.StatelessScopeContainerFactory;
+import org.apache.tuscany.sca.definitions.xml.SCADefinitionsDocumentProcessor;
+import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.invocation.MessageFactory;
+import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.provider.ProviderFactoryExtensionPoint;
+import org.apache.tuscany.sca.runtime.RuntimeWireProcessor;
+import org.apache.tuscany.sca.runtime.RuntimeWireProcessorExtensionPoint;
+import org.apache.tuscany.sca.work.WorkScheduler;
+
+public class ReallySmallRuntimeBuilder {
+
+    public static ProxyFactory createProxyFactory(ExtensionPointRegistry registry,
+                                                  InterfaceContractMapper mapper,
+                                                  MessageFactory messageFactory) {
+
+        ProxyFactory proxyFactory = new DefaultProxyFactoryExtensionPoint(messageFactory, mapper);
+
+        // FIXME Pass these around differently as they are not extension points
+        registry.addExtensionPoint(proxyFactory);
+        registry.addExtensionPoint(mapper);
+
+        return proxyFactory;
+    }
+
+    public static CompositeActivator createCompositeActivator(ExtensionPointRegistry registry,
+                                                              AssemblyFactory assemblyFactory,
+                                                              MessageFactory messageFactory,
+                                                              SCABindingFactory scaBindingFactory,
+                                                              InterfaceContractMapper mapper,
+                                                              ProxyFactory proxyFactory,
+                                                              ScopeRegistry scopeRegistry,
+                                                              WorkScheduler workScheduler) {
+
+        // Create a wire post processor extension point
+        RuntimeWireProcessorExtensionPoint wireProcessors =
+            registry.getExtensionPoint(RuntimeWireProcessorExtensionPoint.class);
+        RuntimeWireProcessor wireProcessor = new ExtensibleWireProcessor(wireProcessors);
+
+        // Add the SCABindingProcessor extension
+        PolicyFactory policyFactory = registry.getExtensionPoint(PolicyFactory.class);
+        SCABindingProcessor scaBindingProcessor =
+            new SCABindingProcessor(assemblyFactory, policyFactory, scaBindingFactory);
+        StAXArtifactProcessorExtensionPoint processors =
+            registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        processors.addArtifactProcessor(scaBindingProcessor);
+
+        // Create a provider factory extension point
+        ProviderFactoryExtensionPoint providerFactories =
+            registry.getExtensionPoint(ProviderFactoryExtensionPoint.class);
+
+        JavaInterfaceFactory javaInterfaceFactory =
+            registry.getExtensionPoint(ModelFactoryExtensionPoint.class).getFactory(JavaInterfaceFactory.class);
+        RequestContextFactory requestContextFactory =
+            registry.getExtensionPoint(ContextFactoryExtensionPoint.class).getFactory(RequestContextFactory.class);
+
+        ConversationManager conversationManager = new ConversationManagerImpl();
+        registry.addExtensionPoint(conversationManager);
+        
+        // Create the composite activator
+        CompositeActivator compositeActivator =
+            new CompositeActivatorImpl(assemblyFactory, messageFactory, javaInterfaceFactory, scaBindingFactory,
+                                       mapper, scopeRegistry, workScheduler, wireProcessor, requestContextFactory,
+                                       proxyFactory, providerFactories, processors, conversationManager);
+
+        return compositeActivator;
+    }
+
+    public static CompositeBuilder createCompositeBuilder(AssemblyFactory assemblyFactory,
+                                                          SCABindingFactory scaBindingFactory,
+                                                          IntentAttachPointTypeFactory intentAttachPointTypeFactory,
+                                                          InterfaceContractMapper interfaceContractMapper, 
+                                                          List<PolicySet> domainPolicySets) {
+        return new CompositeBuilderImpl(assemblyFactory, scaBindingFactory, intentAttachPointTypeFactory, interfaceContractMapper, domainPolicySets, null);
+    }
+
+    /**
+     * Create the contribution service used by this domain.
+     * 
+     * @throws ActivationException
+     */
+    public static ContributionService createContributionService(ClassLoader classLoader,
+                                                                ExtensionPointRegistry registry,
+                                                                ContributionFactory contributionFactory,
+                                                                AssemblyFactory assemblyFactory,
+                                                                PolicyFactory policyFactory,
+                                                                InterfaceContractMapper mapper)
+        throws ActivationException {
+
+        // Create a new XML input factory
+        XMLInputFactory inputFactory = XMLInputFactory.newInstance();
+
+        // Create a validation XML schema extension point
+        ValidationSchemaExtensionPoint schemas = registry.getExtensionPoint(ValidationSchemaExtensionPoint.class);
+        schemas.addSchema(ReallySmallRuntimeBuilder.class.getClassLoader().getResource("tuscany-sca.xsd").toString());
+        
+        // Create a validating XML input factory
+        XMLInputFactory validatingInputFactory = new DefaultValidatingXMLInputFactory(inputFactory, schemas);
+        
+        // Create STAX artifact processor extension point
+        StAXArtifactProcessorExtensionPoint staxProcessors =
+            registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+
+        // Create and register STAX processors for SCA assembly XML
+        ExtensibleStAXArtifactProcessor staxProcessor =
+            new ExtensibleStAXArtifactProcessor(staxProcessors, inputFactory, XMLOutputFactory.newInstance());
+        staxProcessors.addArtifactProcessor(new CompositeProcessor(contributionFactory, assemblyFactory, policyFactory,
+                                                                   mapper, staxProcessor));
+        staxProcessors.addArtifactProcessor(new ComponentTypeProcessor(assemblyFactory, policyFactory, staxProcessor));
+        staxProcessors
+            .addArtifactProcessor(new ConstrainingTypeProcessor(assemblyFactory, policyFactory, staxProcessor));
+
+        // Register STAX processors for Contribution Metadata
+        staxProcessors.addArtifactProcessor(new ContributionMetadataProcessor(assemblyFactory, contributionFactory,
+                                                                              staxProcessor));
+
+        // Create URL artifact processor extension point
+        URLArtifactProcessorExtensionPoint documentProcessors =
+            registry.getExtensionPoint(URLArtifactProcessorExtensionPoint.class);
+
+        // Create and register document processors for SCA assembly XML
+        documentProcessors.addArtifactProcessor(new CompositeDocumentProcessor(staxProcessor, validatingInputFactory));
+        documentProcessors.addArtifactProcessor(new ComponentTypeDocumentProcessor(staxProcessor, validatingInputFactory));
+        documentProcessors.addArtifactProcessor(new ConstrainingTypeDocumentProcessor(staxProcessor, validatingInputFactory));
+
+        // Create and register document processor for definitions.xml
+        //TODO No XMLSchema validation for definitions.xml for now
+        // as the XSD for it is not quite right yet
+        SCADefinitionsDocumentProcessor definitionsDocumentProcessor =
+            new SCADefinitionsDocumentProcessor(staxProcessors, staxProcessor, inputFactory, policyFactory);
+        documentProcessors.addArtifactProcessor(definitionsDocumentProcessor);
+        ModelResolver domainModelResolver = definitionsDocumentProcessor.getDomainModelResolver();
+
+        // Create Model Resolver extension point
+        ModelResolverExtensionPoint modelResolvers = registry.getExtensionPoint(ModelResolverExtensionPoint.class);
+
+        // Create contribution package processor extension point
+        TypeDescriber describer = new PackageTypeDescriberImpl();
+        PackageProcessor packageProcessor =
+            new ExtensiblePackageProcessor(registry.getExtensionPoint(PackageProcessorExtensionPoint.class), describer);
+
+        // Get the model factory extension point
+        ModelFactoryExtensionPoint modelFactories = registry.getExtensionPoint(ModelFactoryExtensionPoint.class);
+
+        // Create contribution listener
+        ExtensibleContributionListener contributionListener =
+            new ExtensibleContributionListener(registry.getExtensionPoint(ContributionListenerExtensionPoint.class));
+
+        // Create a contribution repository
+        ContributionRepository repository;
+        try {
+            repository = new ContributionRepositoryImpl("target", inputFactory);
+        } catch (IOException e) {
+            throw new ActivationException(e);
+        }
+
+        ExtensibleURLArtifactProcessor documentProcessor = new ExtensibleURLArtifactProcessor(documentProcessors);
+
+        // Create the contribution service
+        ContributionService contributionService =
+            new ContributionServiceImpl(repository, packageProcessor, documentProcessor, staxProcessor,
+                                        contributionListener, domainModelResolver, modelResolvers, modelFactories,
+                                        assemblyFactory, contributionFactory, inputFactory);
+        return contributionService;
+    }
+
+    public static ScopeRegistry createScopeRegistry(ExtensionPointRegistry registry) {
+        ScopeRegistry scopeRegistry = new ScopeRegistryImpl();
+        ScopeContainerFactory[] factories =
+            new ScopeContainerFactory[] {new CompositeScopeContainerFactory(), new StatelessScopeContainerFactory(),
+                                         new RequestScopeContainerFactory(),
+                                         new ConversationalScopeContainerFactory(null),
+            // new HttpSessionScopeContainer(monitor)
+            };
+        for (ScopeContainerFactory f : factories) {
+            scopeRegistry.register(f);
+        }
+
+        //FIXME Pass the scope container differently as it's not an extension point
+        registry.addExtensionPoint(scopeRegistry);
+
+        return scopeRegistry;
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/management/ComponentListener.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/management/ComponentListener.java
new file mode 100644
index 0000000000..452f1a1ab1
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/management/ComponentListener.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.management;
+
+import java.util.EventListener;
+
+public interface ComponentListener extends EventListener {
+    
+    void componentStarted(String componentName);
+    void componentStopped(String componentName);
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/management/ComponentManager.java b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/management/ComponentManager.java
new file mode 100644
index 0000000000..57b6a6d746
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/main/java/org/apache/tuscany/sca/host/embedded/management/ComponentManager.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.management;
+
+import java.util.Set;
+
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.core.assembly.ActivationException;
+
+public interface ComponentManager {
+
+    Set<String> getComponentNames();
+
+    Component getComponent(String componentName);
+    
+    boolean isComponentStarted(String componentName);
+
+    void startComponent(String componentName) throws ActivationException;
+
+    void stopComponent(String componentName) throws ActivationException;
+
+    void addComponentListener(ComponentListener listener);
+
+    void removeComponentListener(ComponentListener listener);
+    
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/SCADomainBeanTestCase.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/SCADomainBeanTestCase.java
new file mode 100644
index 0000000000..c47ea2ab7a
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/SCADomainBeanTestCase.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded;
+
+import junit.framework.TestCase;
+
+import org.osoa.sca.ServiceReference;
+
+import test.crud.CRUD;
+
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class SCADomainBeanTestCase extends TestCase {
+
+    private SCADomainBean domain;
+    
+    @Override
+    protected void setUp() throws Exception {
+        domain = new SCADomainBean();
+        domain.setDeployableComposites("crud.composite");
+    }
+
+    public void testStart() throws Exception {
+        ServiceReference<CRUD> serviceReference = domain.getServiceReference(CRUD.class, "CRUDServiceComponent");
+        assertNotNull(serviceReference);
+        CRUD service = serviceReference.getService();
+        String id = service.create("ABC");
+        Object result = service.retrieve(id);
+        assertEquals("ABC", result);
+        service.update(id, "EFG");
+        result = service.retrieve(id);
+        assertEquals("EFG", result);
+        service.delete(id);
+        result = service.retrieve(id);
+        assertNull(result);
+    }
+
+    /**
+     * @throws java.lang.Exception
+     */
+    @Override
+    protected void tearDown() throws Exception {
+        domain.close();
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/SCADomainTestCase.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/SCADomainTestCase.java
new file mode 100644
index 0000000000..896a34515c
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/SCADomainTestCase.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded;
+
+import junit.framework.TestCase;
+
+import org.osoa.sca.ServiceReference;
+
+import test.crud.CRUD;
+
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class SCADomainTestCase extends TestCase {
+
+    private SCADomain domain;
+    
+    @Override
+    protected void setUp() throws Exception {
+        domain = SCADomain.newInstance("crud.composite");
+    }
+
+    public void testStart() throws Exception {
+        ServiceReference<CRUD> serviceReference = domain.getServiceReference(CRUD.class, "CRUDServiceComponent");
+        assertNotNull(serviceReference);
+        CRUD service = serviceReference.getService();
+        String id = service.create("ABC");
+        Object result = service.retrieve(id);
+        assertEquals("ABC", result);
+        service.update(id, "EFG");
+        result = service.retrieve(id);
+        assertEquals("EFG", result);
+        service.delete(id);
+        result = service.retrieve(id);
+        assertNull(result);
+    }
+
+    /**
+     * @throws java.lang.Exception
+     */
+    @Override
+    protected void tearDown() throws Exception {
+        domain.close();
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/DefaultSCADomainTestCase.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/DefaultSCADomainTestCase.java
new file mode 100644
index 0000000000..b8626b00d6
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/DefaultSCADomainTestCase.java
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+
+import test.crud.CRUD;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class DefaultSCADomainTestCase extends TestCase {
+    private DefaultSCADomain domain;
+
+    /**
+     * @throws java.lang.Exception
+     */
+    @Override
+    protected void setUp() throws Exception {
+        domain = new DefaultSCADomain(getClass().getClassLoader(), getClass().getClassLoader(),
+                                      "http://localhost", ".", "crud.composite");
+    }
+
+    public void testStart() throws Exception {
+        CRUD service = domain.getService(CRUD.class, "CRUDServiceComponent");
+        assertNotNull(service);
+    }
+
+    public void testComponentManager() throws Exception {
+        ComponentManager componentManager = domain.getComponentManager();
+        assertEquals(1, componentManager.getComponentNames().size());
+        assertEquals("CRUDServiceComponent", componentManager.getComponentNames().iterator().next());
+        assertNotNull(componentManager.getComponent("CRUDServiceComponent"));
+        
+        assertTrue(componentManager.isComponentStarted("CRUDServiceComponent"));
+        componentManager.stopComponent("CRUDServiceComponent");
+        assertFalse(componentManager.isComponentStarted("CRUDServiceComponent"));
+    }
+    
+    /**
+     * @throws java.lang.Exception
+     */
+    @Override
+    protected void tearDown() throws Exception {
+        domain.close();
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/EmbeddedSCADomainTestCase.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/EmbeddedSCADomainTestCase.java
new file mode 100644
index 0000000000..fc11337426
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/EmbeddedSCADomainTestCase.java
@@ -0,0 +1,199 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import java.net.URL;
+
+import javax.xml.namespace.QName;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.service.ContributionService;
+import org.apache.tuscany.sca.host.embedded.management.ComponentListener;
+import org.apache.tuscany.sca.host.embedded.management.ComponentManager;
+
+import test.crud.CRUD;
+
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class EmbeddedSCADomainTestCase extends TestCase {
+    private EmbeddedSCADomain domain;
+
+    /**
+     * @throws java.lang.Exception
+     */
+    @Override
+    protected void setUp() throws Exception {
+        
+        // Create a test embedded SCA domain 
+        domain = new EmbeddedSCADomain(getClass().getClassLoader(), "http://localhost");
+    }
+
+    public void testDomain() throws Exception {
+        // Start the domain
+        domain.start();
+        
+        // Determine my class loader and my test SCA contribution location  
+        ClassLoader myClassLoader = getClass().getClassLoader();
+        String url = myClassLoader.getResource("test.txt").toString();
+        url = url.substring(0, url.length()-8);
+        
+        // Contribute the SCA contribution
+        TestModelResolver myResolver = new TestModelResolver(myClassLoader);
+        ContributionService contributionService = domain.getContributionService();
+        Contribution contribution = contributionService.contribute("http://test/contribution", new URL(url), myResolver, false);
+        assertNotNull(contribution);
+        
+        // Decide which SCA composite I want to deploy
+        Composite myComposite = myResolver.getComposite(new QName("http://sample/crud", "crud"));
+        
+        // Add the deployable composite to the domain
+        domain.getDomainComposite().getIncludes().add(myComposite);
+        domain.getCompositeBuilder().build(myComposite);
+
+        // Start the composite
+        domain.getCompositeActivator().activate(myComposite);
+        domain.getCompositeActivator().start(myComposite);
+        
+        // At this point the domain contains my contribution, my composite and
+        // it's started, my application code can start using it
+        
+        // Get the CRUDServiceComponent service
+        CRUD service = domain.getService(CRUD.class, "CRUDServiceComponent");
+        
+        // Invoke the service
+        String id = service.create("ABC");
+        Object result = service.retrieve(id);
+        assertEquals("ABC", result);
+        service.update(id, "EFG");
+        result = service.retrieve(id);
+        assertEquals("EFG", result);
+        service.delete(id);
+        result = service.retrieve(id);
+        assertNull(result);
+        
+        // Stop my composite
+        domain.getCompositeActivator().stop(myComposite);
+        domain.getCompositeActivator().deactivate(myComposite);
+        
+        // Remove my composite
+        domain.getDomainComposite().getIncludes().remove(myComposite);
+        
+        // Remove my contribution
+        contributionService.remove("http://test/contribution");
+        
+        // Stop the domain
+        domain.stop();
+    }
+
+    public void testComponentManager() throws Exception {
+        // Start the domain
+        domain.start();
+        
+        // Determine my class loader and my test SCA contribution location  
+        ClassLoader myClassLoader = getClass().getClassLoader();
+        String url = myClassLoader.getResource("test.txt").toString();
+        url = url.substring(0, url.length()-8);
+        
+        // Contribute the SCA contribution
+        TestModelResolver myResolver = new TestModelResolver(myClassLoader);
+        ContributionService contributionService = domain.getContributionService();
+        Contribution contribution = contributionService.contribute("http://test/contribution", new URL(url), myResolver, false);
+        assertNotNull(contribution);
+        
+        // Decide which SCA composite I want to deploy
+        Composite myComposite = myResolver.getComposite(new QName("http://sample/crud", "crud"));
+        
+        // Add the deployable composite to the domain
+        domain.getDomainComposite().getIncludes().add(myComposite);
+        domain.getCompositeBuilder().build(myComposite);
+
+        // Start the composite
+        domain.getCompositeActivator().activate(myComposite);
+        domain.getCompositeActivator().start(myComposite);
+        
+        // At this point the domain contains my contribution, my composite and
+        // it's started, my application code can start using it
+
+        ComponentManager componentManager = domain.getComponentManager();
+        assertEquals(1, componentManager.getComponentNames().size());
+        assertEquals("CRUDServiceComponent", componentManager.getComponentNames().iterator().next());
+        
+        Component component = componentManager.getComponent("CRUDServiceComponent");
+        assertNotNull(component);
+        assertEquals("CRUDServiceComponent", component.getName());
+        
+        MyComponentListener cl = new MyComponentListener();
+        componentManager.addComponentListener(cl);
+
+        assertTrue(componentManager.isComponentStarted("CRUDServiceComponent"));
+        
+        assertFalse(cl.stopCalled);
+        componentManager.stopComponent("CRUDServiceComponent");
+        assertTrue(cl.stopCalled);
+        assertFalse(componentManager.isComponentStarted("CRUDServiceComponent"));
+        
+        assertFalse(cl.startCalled);
+        componentManager.startComponent("CRUDServiceComponent");
+        assertTrue(cl.startCalled);
+        assertTrue(componentManager.isComponentStarted("CRUDServiceComponent"));
+
+        // Stop my composite
+        domain.getCompositeActivator().stop(myComposite);
+        domain.getCompositeActivator().deactivate(myComposite);
+        
+        // Remove my composite
+        domain.getDomainComposite().getIncludes().remove(myComposite);
+        
+        // Remove my contribution
+        contributionService.remove("http://test/contribution");
+        
+        // Stop the domain
+        domain.stop();
+    }
+    
+    class MyComponentListener implements ComponentListener {
+        boolean startCalled;
+        boolean stopCalled;
+
+        public void componentStarted(String componentName) {
+            startCalled = true;
+        }
+
+        public void componentStopped(String componentName) {
+            stopCalled = true;
+        }
+        
+    }
+
+    /**
+     * @throws java.lang.Exception
+     */
+    @Override
+    protected void tearDown() throws Exception {
+        domain.close();
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/TestModelResolver.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/TestModelResolver.java
new file mode 100644
index 0000000000..6969cba054
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/org/apache/tuscany/sca/host/embedded/impl/TestModelResolver.java
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.host.embedded.impl;
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.resolver.ClassReference;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+
+
+/**
+ * A test model resolver, based on a map.
+ *
+ * @version $Rev$ $Date$
+ */
+public class TestModelResolver implements ModelResolver {
+    private static final long serialVersionUID = -7826976465762296634L;
+    
+    private Map<Object, Object> map = new HashMap<Object, Object>();
+    private WeakReference<ClassLoader> classLoader;
+    
+    private Map<QName, Composite> composites = new HashMap<QName, Composite>();
+    
+    public TestModelResolver(ClassLoader classLoader) {
+        this.classLoader = new WeakReference<ClassLoader>(classLoader);
+    }
+
+    public <T> T resolveModel(Class<T> modelClass, T unresolved) {
+        Object resolved = map.get(unresolved);
+        if (resolved != null) {
+            
+            // Return the resolved object
+            return modelClass.cast(resolved);
+            
+        } else if (unresolved instanceof ClassReference) {
+            
+            // Load a class on demand
+            ClassReference classReference = (ClassReference)unresolved;
+            Class clazz;
+            try {
+                clazz = Class.forName(classReference.getClassName(), true, classLoader.get());
+            } catch (ClassNotFoundException e) {
+                
+                // Return the unresolved object
+                return unresolved;
+            }
+            
+            // Store a new ClassReference wrappering the loaded class
+            resolved = new ClassReference(clazz);
+            map.put(resolved, resolved);
+            
+            // Return the resolved ClassReference
+            return modelClass.cast(resolved);
+                
+        } else {
+            
+            // Return the unresolved object
+            return unresolved;
+        }
+    }
+    
+    public void addModel(Object resolved) {
+        map.put(resolved, resolved);
+        if (resolved instanceof Composite) {
+            Composite composite = (Composite)resolved;
+            composites.put(composite.getName(), composite);
+        }
+    }
+    
+    public Object removeModel(Object resolved) {
+        if (resolved instanceof Composite) {
+            Composite composite = (Composite)resolved;
+            composites.remove(composite.getName());
+        }
+        return map.remove(resolved);
+    }
+    
+    public Composite getComposite(QName qname) {
+        return composites.get(qname);
+    }
+    
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUD.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUD.java
new file mode 100644
index 0000000000..7f652ff489
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUD.java
@@ -0,0 +1,56 @@
+/*
+ * 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 test.crud;
+
+/**
+ * The service interface of the single CRUD service provided by CRUD components.
+ * 
+ * @version $Rev$ $Date$
+ */
+public interface CRUD {
+
+    /**
+     * Create a new resource.
+     * @param resource
+     * @return
+     */
+    String create(Object resource);
+
+    /**
+     * Retrieve a resource.
+     * @param id
+     * @return
+     */
+    Object retrieve(String id);
+
+    /**
+     * Update a resource.
+     * @param id
+     * @param resource
+     * @return
+     */
+    Object update(String id, Object resource);
+
+    /**
+     * Delete a resource.
+     * @param id
+     */
+    void delete(String id);
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUDImplementation.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUDImplementation.java
new file mode 100644
index 0000000000..29f620c78d
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUDImplementation.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 test.crud;
+
+import org.apache.tuscany.sca.assembly.Implementation;
+
+/**
+ * The model representing a sample CRUD implementation in an SCA assembly model.
+ * The sample CRUD implementation is not a full blown implementation, it only
+ * supports a subset of what a component implementation can support: - a single
+ * fixed service (as opposed to a list of services typed by different
+ * interfaces) - a directory attribute used to specify where a CRUD component is
+ * going to persist resources - no references or properties - no policy intents
+ * or policy sets
+ * 
+ * @version $$Rev$$ $$Date: 2007-04-23 19:18:54 -0700 (Mon, 23 Apr
+ *          2007) $$
+ */
+public interface CRUDImplementation extends Implementation {
+
+    /**
+     * Returns the directory used by CRUD implementations to persist resources.
+     * 
+     * @return the directory used to persist resources
+     */
+    public String getDirectory();
+
+    /**
+     * Sets the directory used by CRUD implementations to persist resources.
+     * 
+     * @param directory the directory used to persist resources
+     */
+    public void setDirectory(String directory);
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUDImplementationFactory.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUDImplementationFactory.java
new file mode 100644
index 0000000000..7890391ed5
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/CRUDImplementationFactory.java
@@ -0,0 +1,37 @@
+/*
+ * 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 test.crud;
+
+
+/**
+ * A factory for the sample CRUD implementation model.
+ *
+ * @version $Rev$ $Date$
+ */
+public interface CRUDImplementationFactory {
+    
+    /**
+     * Creates a new CRUD implementation.
+     * 
+     * @return
+     */
+    CRUDImplementation createCRUDImplementation();
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/DefaultCRUDImplementationFactory.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/DefaultCRUDImplementationFactory.java
new file mode 100644
index 0000000000..17df409c8c
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/DefaultCRUDImplementationFactory.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 test.crud;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+
+import test.crud.impl.CRUDImplementationImpl;
+
+/**
+ * A default factory for the CRUD implementation model.
+ *
+ * @version $Rev$ $Date$
+ */
+public class DefaultCRUDImplementationFactory implements CRUDImplementationFactory {
+    
+    private AssemblyFactory assemblyFactory;
+    private JavaInterfaceFactory javaFactory;
+    
+    public DefaultCRUDImplementationFactory(AssemblyFactory assemblyFactory,
+                                            JavaInterfaceFactory javaFactory) {
+        this.assemblyFactory = assemblyFactory;
+        this.javaFactory = javaFactory;
+    }
+
+    public CRUDImplementation createCRUDImplementation() {
+        return new CRUDImplementationImpl(assemblyFactory, javaFactory);
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/backend/ResourceManager.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/backend/ResourceManager.java
new file mode 100644
index 0000000000..f5914be043
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/backend/ResourceManager.java
@@ -0,0 +1,92 @@
+/*
+ * 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 test.crud.backend;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A fake resource manager implementation used as a backend by the sample
+ * CRUD component implementation.
+ *  
+ * @version $Rev$ $Date$
+ */
+public class ResourceManager {
+    private static int counter;
+    private static final Map<String, Object> store = new HashMap<String, Object>();
+    private String directory;
+
+    /**
+     * Constructs a new resource manager.
+     * 
+     * @param directory the directory where to persist resources
+     */
+    public ResourceManager(String directory) {
+        super();
+        this.directory = directory;
+    }
+
+    /**
+     * Creates a new resource.
+     * 
+     * @param resource
+     * @return
+     */
+    public String createResource(Object resource) {
+        System.out.println("create(" + resource + ") in " + directory);
+        String key = String.valueOf(counter++);
+        store.put(key, resource);
+        return key;
+    }
+
+    /**
+     * Deletes a resource.
+     * 
+     * @param id
+     */
+    public void deleteResource(String id) {
+        System.out.println("delete(" + id + ")");
+        store.remove(id);
+    }
+
+    /**
+     * Retrieves a resource.
+     * 
+     * @param id
+     * @return
+     */
+    public Object retrieveResource(String id) {
+        System.out.println("retrieve(" + id + ")");
+        return store.get(id);
+    }
+
+    /**
+     * Updates a resource.
+     * 
+     * @param id
+     * @param resource
+     * @return
+     */
+    public Object updateResource(String id, Object resource) {
+        System.out.println("update(" + id + ")");
+        return store.put(id, resource);
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/impl/CRUDImplementationImpl.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/impl/CRUDImplementationImpl.java
new file mode 100644
index 0000000000..2060432b1b
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/impl/CRUDImplementationImpl.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 test.crud.impl;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+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.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+
+import test.crud.CRUD;
+import test.crud.CRUDImplementation;
+
+/**
+ * The model representing a sample CRUD implementation in an SCA assembly model.
+ * 
+ * @version $$Rev$$ $$Date: 2007-04-23 19:18:54 -0700 (Mon, 23 Apr
+ *          2007) $$
+ */
+public class CRUDImplementationImpl implements CRUDImplementation {
+
+    private Service crudService;
+    private String directory;
+    
+    /**
+     * Constructs a new CRUD implementation.
+     */
+    public CRUDImplementationImpl(AssemblyFactory assemblyFactory,
+                              JavaInterfaceFactory javaFactory) {
+
+        // CRUD implementation always provide a single service exposing
+        // the CRUD interface, and have no references and properties
+        crudService = assemblyFactory.createService();
+        crudService.setName("CRUD");
+        JavaInterface javaInterface;
+        try {
+            javaInterface = javaFactory.createJavaInterface(CRUD.class);
+        } catch (InvalidInterfaceException e) {
+            throw new IllegalArgumentException(e);
+        }
+        JavaInterfaceContract interfaceContract = javaFactory.createJavaInterfaceContract();
+        interfaceContract.setInterface(javaInterface);
+        crudService.setInterfaceContract(interfaceContract);
+    }
+
+    public String getDirectory() {
+        return directory;
+    }
+
+    public void setDirectory(String directory) {
+        this.directory = directory;
+    }
+
+    public ConstrainingType getConstrainingType() {
+        // The sample CRUD implementation does not support constrainingTypes
+        return null;
+    }
+
+    public List<Property> getProperties() {
+        // The sample CRUD implementation does not support properties
+        return Collections.emptyList();
+    }
+
+    public List<Service> getServices() {
+        // The sample CRUD implementation provides a single fixed CRUD service
+        return Collections.singletonList(crudService);
+    }
+    
+    public List<Reference> getReferences() {
+        // The sample CRUD implementation does not support properties
+        return Collections.emptyList();
+    }
+
+    public String getURI() {
+        // The sample CRUD implementation does not have a URI
+        return null;
+    }
+
+    public void setConstrainingType(ConstrainingType constrainingType) {
+        // The sample CRUD implementation does not support constrainingTypes
+    }
+
+    public void setURI(String uri) {
+        // The sample CRUD implementation does not have a URI
+    }
+
+    public boolean isUnresolved() {
+        // The sample CRUD implementation is always resolved
+        return false;
+    }
+
+    public void setUnresolved(boolean unresolved) {
+        // The sample CRUD implementation is always resolved
+    }
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/impl/CRUDImplementationProcessor.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/impl/CRUDImplementationProcessor.java
new file mode 100644
index 0000000000..4222154ee5
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/impl/CRUDImplementationProcessor.java
@@ -0,0 +1,102 @@
+/*
+ * 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 test.crud.impl;
+
+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.contribution.processor.StAXArtifactProcessor;
+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.ContributionWriteException;
+
+import test.crud.CRUDImplementation;
+import test.crud.CRUDImplementationFactory;
+
+
+/**
+ * Implements a STAX artifact processor for CRUD implementations.
+ * 
+ * The artifact processor is responsible for processing <implementation.crud>
+ * elements in SCA assembly XML composite files and populating the CRUD
+ * implementation model, resolving its references to other artifacts in the SCA
+ * contribution, and optionally write the model back to SCA assembly XML. 
+ *
+ * @version $Rev$ $Date$
+ */
+public class CRUDImplementationProcessor implements StAXArtifactProcessor<CRUDImplementation> {
+    private static final QName IMPLEMENTATION_CRUD = new QName("http://crud", "implementation.crud");
+    
+    private CRUDImplementationFactory crudFactory;
+    
+    public CRUDImplementationProcessor(CRUDImplementationFactory crudFactory) {
+        this.crudFactory = crudFactory;
+    }
+
+    public QName getArtifactType() {
+        // Returns the qname of the XML element processed by this processor
+        return IMPLEMENTATION_CRUD;
+    }
+
+    public Class<CRUDImplementation> getModelType() {
+        // Returns the type of model processed by this processor
+        return CRUDImplementation.class;
+    }
+
+    public CRUDImplementation read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+        
+        // Read an <implementation.crud> element
+
+        // Read the directory attribute. This is where the sample
+        // CRUD implementation will persist resources.
+        String directory = reader.getAttributeValue(null, "directory");
+
+        // Create an initialize the CRUD implementation model
+        CRUDImplementation implementation = crudFactory.createCRUDImplementation();
+        implementation.setDirectory(directory);
+        
+        // Skip to end element
+        while (reader.hasNext()) {
+            if (reader.next() == END_ELEMENT && IMPLEMENTATION_CRUD.equals(reader.getName())) {
+                break;
+            }
+        }
+        
+        return implementation;
+    }
+
+    public void resolve(CRUDImplementation impl, ModelResolver resolver) throws ContributionResolveException {
+    }
+
+    public void write(CRUDImplementation implementation, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+        
+        writer.writeStartElement(IMPLEMENTATION_CRUD.getNamespaceURI(), IMPLEMENTATION_CRUD.getLocalPart());
+        
+        if (implementation != null) {
+            writer.writeAttribute("directory", implementation.getDirectory());
+        }
+        
+        writer.writeEndElement();
+    }
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/module/CRUDModuleActivator.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/module/CRUDModuleActivator.java
new file mode 100644
index 0000000000..00a1da9217
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/module/CRUDModuleActivator.java
@@ -0,0 +1,69 @@
+/*
+ * 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 test.crud.module;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+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.interfacedef.java.DefaultJavaInterfaceFactory;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory;
+import org.apache.tuscany.sca.provider.ProviderFactoryExtensionPoint;
+
+import test.crud.CRUDImplementationFactory;
+import test.crud.DefaultCRUDImplementationFactory;
+import test.crud.impl.CRUDImplementationProcessor;
+import test.crud.provider.CRUDImplementationProviderFactory;
+
+
+/**
+ * Implements a module activator for the CRUD implementation extension module.
+ * The module activator is responsible for contributing the CRUD implementation
+ * extensions and plugging them in the extension points defined by the Tuscany
+ * runtime.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class CRUDModuleActivator implements ModuleActivator {
+
+    public void start(ExtensionPointRegistry registry) {
+
+        // Create the CRUD implementation factory
+        ModelFactoryExtensionPoint factories = registry.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        AssemblyFactory assemblyFactory = factories.getFactory(AssemblyFactory.class);
+        JavaInterfaceFactory javaFactory = new DefaultJavaInterfaceFactory();
+        CRUDImplementationFactory crudFactory = new DefaultCRUDImplementationFactory(assemblyFactory, javaFactory);
+        factories.addFactory(crudFactory);
+
+        // Add the CRUD implementation extension to the StAXArtifactProcessor
+        // extension point
+        StAXArtifactProcessorExtensionPoint processors = registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        CRUDImplementationProcessor implementationArtifactProcessor = new CRUDImplementationProcessor(crudFactory);
+        processors.addArtifactProcessor(implementationArtifactProcessor);
+
+        // Add the CRUD provider factory to the ProviderFactory extension point
+        ProviderFactoryExtensionPoint providerFactories = registry.getExtensionPoint(ProviderFactoryExtensionPoint.class);
+        providerFactories.addProviderFactory(new CRUDImplementationProviderFactory());
+    }
+
+    public void stop(ExtensionPointRegistry registry) {
+    }
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDImplementationProvider.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDImplementationProvider.java
new file mode 100644
index 0000000000..6d663c0979
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDImplementationProvider.java
@@ -0,0 +1,73 @@
+/*
+ * 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 test.crud.provider;
+
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.provider.ImplementationProvider;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+
+import test.crud.CRUDImplementation;
+import test.crud.backend.ResourceManager;
+
+
+/**
+ * The model representing a sample CRUD implementation in an SCA assembly model.
+ * The sample CRUD implementation is not a full blown implementation, it only
+ * supports a subset of what a component implementation can support: - a single
+ * fixed service (as opposed to a list of services typed by different
+ * interfaces) - a directory attribute used to specify where a CRUD component is
+ * going to persist resources - no references or properties - no policy intents
+ * or policy sets
+ * 
+ * @version $$Rev$$ $$Date: 2007-04-23 19:18:54 -0700 (Mon, 23 Apr
+ *          2007) $$
+ */
+public class CRUDImplementationProvider implements ImplementationProvider {
+    
+    private RuntimeComponent component;
+    private CRUDImplementation implementation;
+
+    /**
+     * Constructs a new CRUD implementation.
+     */
+    public CRUDImplementationProvider(RuntimeComponent component, CRUDImplementation implementation) {
+        this.component = component;
+        this.implementation = implementation;
+    }
+
+    public Invoker createInvoker(RuntimeComponentService service, Operation operation) {
+        CRUDInvoker invoker = new CRUDInvoker(operation, new ResourceManager(implementation.getDirectory()));
+        return invoker;
+    }
+    
+    public boolean supportsOneWayInvocation() {
+        return false;
+    }
+
+    public void start() {
+        System.out.println("Starting " + component.getName());
+    }
+
+    public void stop() {
+        System.out.println("Stopping " + component.getName());
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDImplementationProviderFactory.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDImplementationProviderFactory.java
new file mode 100644
index 0000000000..290716ed7f
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDImplementationProviderFactory.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 test.crud.provider;
+
+import org.apache.tuscany.sca.provider.ImplementationProvider;
+import org.apache.tuscany.sca.provider.ImplementationProviderFactory;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+
+import test.crud.CRUDImplementation;
+
+
+/**
+ * The model representing a sample CRUD implementation in an SCA assembly model.
+ * 
+ * @version $$Rev$$ $$Date: 2007-04-23 19:18:54 -0700 (Mon, 23 Apr
+ *          2007) $$
+ */
+public class CRUDImplementationProviderFactory implements ImplementationProviderFactory<CRUDImplementation> {
+
+    /**
+     * Constructs a new CRUD implementation.
+     */
+    public CRUDImplementationProviderFactory() {
+    }
+
+    public ImplementationProvider createImplementationProvider(RuntimeComponent component, CRUDImplementation implementation) {
+        return new CRUDImplementationProvider(component, implementation);
+    }
+    
+    public Class<CRUDImplementation> getModelType() {
+        return CRUDImplementation.class;
+    }
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDInvoker.java b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDInvoker.java
new file mode 100644
index 0000000000..8f32089e9c
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/java/test/crud/provider/CRUDInvoker.java
@@ -0,0 +1,80 @@
+/*
+ * 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 test.crud.provider;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+
+import test.crud.backend.ResourceManager;
+
+
+/**
+ * Implements a target invoker for CRUD component implementations.
+ * 
+ * The target invoker is responsible for dispatching invocations to the particular
+ * component implementation logic. In this example we are simply delegating the
+ * CRUD operation invocations to the corresponding methods on our fake
+ * resource manager.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class CRUDInvoker implements Invoker {
+    private Operation operation;
+    private ResourceManager resourceManager;
+    
+    public CRUDInvoker(Operation operation, ResourceManager resourceManager) {
+        this.operation = operation;
+        this.resourceManager = resourceManager;
+    }
+    
+    public Message invoke(Message msg) {
+        try {
+            Object[] args = msg.getBody();
+            Object resp = doTheWork(args);
+            msg.setBody(resp);
+        } catch (InvocationTargetException e) {
+            msg.setFaultBody(e.getCause());
+        }
+        return msg;
+    }
+
+    public Object doTheWork(Object[] args) throws InvocationTargetException {
+        if (operation.getName().equals("create")) {
+            return resourceManager.createResource(args[0]);
+            
+        } else if (operation.getName().equals("retrieve")) {
+            return resourceManager.retrieveResource((String)args[0]);
+            
+        } else if (operation.getName().equals("update")) {
+            return resourceManager.updateResource((String)args[0], args[1]);
+            
+        } else if (operation.getName().equals("delete")) {
+            resourceManager.deleteResource((String)args[0]);
+            return null;
+            
+        } else {
+            return null;
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator b/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator
new file mode 100644
index 0000000000..eca487b829
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/META-INF/services/org.apache.tuscany.sca.core.ModuleActivator
@@ -0,0 +1,18 @@
+# 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.

+# Implementation class for the ExtensionActivator

+test.crud.module.CRUDModuleActivator

diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/crud.composite b/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/crud.composite
new file mode 100644
index 0000000000..65f24ec93c
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/crud.composite
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+    * 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.    

+-->

+<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"

+	targetNamespace="http://sample/crud"

+	xmlns:sc="http://sample/crud"

+	xmlns:c="http://crud"

+	name="crud">

+

+    <component name="CRUDServiceComponent">

+        <c:implementation.crud directory="tmp" />

+    </component>

+

+</composite>

diff --git a/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/test.txt b/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/test.txt
new file mode 100644
index 0000000000..287f9b1f65
--- /dev/null
+++ b/branches/sca-java-1.0.1/modules/host-embedded/src/test/resources/test.txt
@@ -0,0 +1,16 @@
+# 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.
\ No newline at end of file