Changes to allow $self$ references to have endpoint references. However main change is in ComponentContext which is not ready to go in yet.

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

10 files changed, 865 insertions, 43 deletions

diff --git a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/EndpointReference2Builder.java b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/EndpointReferenceBuilder.java
index bb130695e7..f84648c203 100644
--- a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/EndpointReference2Builder.java
+++ b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/EndpointReferenceBuilder.java
@@ -19,6 +19,12 @@
 
 package org.apache.tuscany.sca.assembly.builder;
 
+import java.util.Map;
+
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentReference;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
 import org.apache.tuscany.sca.assembly.Endpoint;
 import org.apache.tuscany.sca.assembly.EndpointReference2;
 import org.apache.tuscany.sca.monitor.Monitor;
@@ -30,12 +36,30 @@ import org.apache.tuscany.sca.monitor.Monitor;
  *
  * @version $Rev$ $Date$
  */
-public interface EndpointReference2Builder {
+public interface EndpointReferenceBuilder {
+    
+    /**
+     * Create endpoint references for a component reference
+     * 
+     * @param composite
+     * @param component
+     * @param reference
+     * @param components
+     * @param componentServices
+     * @param monitor
+     */
+    public void createEndpointReferences(Composite composite,
+                                         Component component, 
+                                         ComponentReference reference,
+                                         Map<String, Component> components,
+                                         Map<String, ComponentService> componentServices, 
+                                         Monitor monitor);
     
     /**
-     * Build an endpoint.
+     * Build an endpoint reference matching reference bindings 
+     * with service bindings.
      * 
-     * @param endpoint
+     * @param endpointReference
      * @param monitor
      */
     void build(EndpointReference2 endpointReference, Monitor monitor);
diff --git a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BaseBuilderImpl.java b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BaseBuilderImpl.java
index 10307ed3c3..3e8022863d 100644
--- a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BaseBuilderImpl.java
+++ b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/BaseBuilderImpl.java
@@ -121,8 +121,7 @@ public abstract class BaseBuilderImpl implements CompositeBuilder {
             monitor.problem(problem);
         }
     }   
-    
-    
+       
     /**
      * Index components inside a composite
      * 
diff --git a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeBuilderImpl.java b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeBuilderImpl.java
index 213c7d6ae7..7157d8a217 100644
--- a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeBuilderImpl.java
+++ b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeBuilderImpl.java
@@ -62,7 +62,7 @@ public class CompositeBuilderImpl implements CompositeBuilder {
     
     private CompositeBuilder compositeReferenceEndpointReferenceBuilder;
     private CompositeBuilder compositeServiceEndpointBuilder;
-    private CompositeBuilder endpointReferenceBuilder;
+    //private CompositeBuilder endpointReferenceBuilder;
     
     public CompositeBuilderImpl(FactoryExtensionPoint factories, InterfaceContractMapper mapper) {
         this(factories.getFactory(AssemblyFactory.class),
@@ -177,7 +177,7 @@ public class CompositeBuilderImpl implements CompositeBuilder {
         
         compositeReferenceEndpointReferenceBuilder = new CompositeReferenceEndpointReferenceBuilderImpl(assemblyFactory, interfaceContractMapper);
         compositeServiceEndpointBuilder = new CompositeServiceEndpointBuilderImpl(assemblyFactory);
-        endpointReferenceBuilder = new EndpointReference2BuilderImpl(assemblyFactory, interfaceContractMapper);
+        //endpointReferenceBuilder = new EndpointReference2BuilderImpl(assemblyFactory, interfaceContractMapper);
     }
 
     public String getID() {
@@ -244,7 +244,7 @@ public class CompositeBuilderImpl implements CompositeBuilder {
         // TODO this needs to be offloaded to a plugpoint
         //      could be called upon when rebuilding wires
         // wire endpoint references to endpoints
-        endpointReferenceBuilder.build(composite, definitions, monitor);
+        //endpointReferenceBuilder.build(composite, definitions, monitor);
         // ===============================================        
     }
 
diff --git a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeReferenceEndpointReferenceBuilderImpl.java b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeReferenceEndpointReferenceBuilderImpl.java
index 18083da779..5de60c114d 100644
--- a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeReferenceEndpointReferenceBuilderImpl.java
+++ b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/CompositeReferenceEndpointReferenceBuilderImpl.java
@@ -238,6 +238,11 @@ public class CompositeReferenceEndpointReferenceBuilderImpl extends BaseBuilderI
                     endpointRef.setReference(reference);
                     endpointRef.setTargetName(targetName);
                     endpointRef.setUnresolved(true);
+                                
+                    // create an unresolved endpoint to go with it
+                    Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                    endpoint.setUnresolved(true);
+                    endpointRef.setTargetEndpoint(endpoint);
                     
                     warning(monitor, 
                             "ComponentReferenceTargetNotFound",
@@ -304,6 +309,11 @@ public class CompositeReferenceEndpointReferenceBuilderImpl extends BaseBuilderI
                     endpointRef.setTargetName(targetName);
                     endpointRef.setUnresolved(true);
                     
+                    // create an unresolved endpoint to go with it
+                    Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                    endpoint.setUnresolved(true);
+                    endpointRef.setTargetEndpoint(endpoint);                    
+                    
                     warning(monitor, 
                             "ComponentReferenceTargetNotFound",
                             composite, 
@@ -392,7 +402,14 @@ public class CompositeReferenceEndpointReferenceBuilderImpl extends BaseBuilderI
                     endpointRef.setBinding(binding);
                     endpointRef.setTargetName(null);
                     endpointRef.setTargetEndpoint(null);
-                    endpointRef.setUnresolved(false);                       
+                    endpointRef.setUnresolved(false);
+                    
+                    // create a resolved endpoint to signify that this 
+                    // reference is pointing at some unwired endpoint
+                    Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                    endpoint.setUnresolved(false);
+                    endpointRef.setTargetEndpoint(endpoint);
+                    
                     reference.getEndpointReferences().add(endpointRef);
                 }
             }
diff --git a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/EndpointReference2BuilderImpl.java b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/EndpointReference2BuilderImpl.java
index ad724536c7..f4e8961112 100644
--- a/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/EndpointReference2BuilderImpl.java
+++ b/java/sca/modules/assembly/src/main/java/org/apache/tuscany/sca/assembly/builder/impl/EndpointReference2BuilderImpl.java
@@ -40,7 +40,7 @@ import org.apache.tuscany.sca.assembly.SCABinding;
 import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
 import org.apache.tuscany.sca.assembly.builder.CompositeBuilderException;
 import org.apache.tuscany.sca.assembly.builder.EndpointBuilder;
-import org.apache.tuscany.sca.assembly.builder.EndpointReference2Builder;
+import org.apache.tuscany.sca.assembly.builder.EndpointReferenceBuilder;
 import org.apache.tuscany.sca.definitions.Definitions;
 import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
 import org.apache.tuscany.sca.monitor.Monitor;
@@ -58,7 +58,7 @@ import org.apache.tuscany.sca.policy.PolicySubject;
  * 
  * @version $Rev$ $Date$
  */
-public class EndpointReference2BuilderImpl extends BaseBuilderImpl implements CompositeBuilder, EndpointReference2Builder {
+public class EndpointReference2BuilderImpl extends BaseBuilderImpl implements CompositeBuilder/*, EndpointReference2Builder*/ {
     
     
     public EndpointReference2BuilderImpl(AssemblyFactory assemblyFactory, InterfaceContractMapper interfaceContractMapper) {
@@ -125,36 +125,29 @@ public class EndpointReference2BuilderImpl extends BaseBuilderImpl implements Co
     public void build(EndpointReference2 endpointReference, Monitor monitor) {
         Endpoint2 endpoint = endpointReference.getTargetEndpoint();
       
- 
-        // check if the endpoint was available locally
         if (endpoint == null){
-            if (endpointReference.isUnresolved() == false){
-                // this is a non-wired endpoint reference
-                return;
-            } else {
-                // target service is available remotely
-                
-                // go look it up in the domain
-            }
-        } else {
-            // target service is available locally
-            
-            // check for wired reference that's already resolved
+            // an error?
+        } else {          
             if (endpoint.isUnresolved() == false){
+                // everything is resolved
                 return;
             }
             
-            // find the real endpoint for this reference by matching bindings
-            // and policy sets
-            matchForwardBinding(endpointReference, 
-                                endpointReference.getTargetEndpoint().getService(),
-                                monitor);
-            
-            matchCallbackBinding(endpointReference, 
-                                 endpointReference.getTargetEndpoint().getService(),
-                                 monitor);
+            if (endpointReference.isUnresolved() == false ){  
+                // TODO - bring resolution and binding matching together
+                // just do binding matching
+                matchForwardBinding(endpointReference, 
+                                    endpointReference.getTargetEndpoint().getService(),
+                                    monitor);
+                
+                matchCallbackBinding(endpointReference, 
+                                     endpointReference.getTargetEndpoint().getService(),
+                                     monitor);
+            } else {
+                // resolve the endpoint reference in the domain and then 
+                // match bindings
+            } 
         }        
-        
     }
     
     // TODO - In OASIS case there are no bindings to match with on the 
@@ -214,6 +207,14 @@ public class EndpointReference2BuilderImpl extends BaseBuilderImpl implements Co
                 if (referenceBinding.getURI() == null) {
                     cloned.setURI(serviceEndpoint.getBinding().getURI());
                 }
+                
+                // TODO - can we remove this?
+                if (cloned instanceof OptimizableBinding) {
+                    OptimizableBinding optimizableBinding = (OptimizableBinding)cloned;
+                    optimizableBinding.setTargetComponent(serviceEndpoint.getComponent());
+                    optimizableBinding.setTargetComponentService(serviceEndpoint.getService());
+                    optimizableBinding.setTargetBinding(serviceEndpoint.getBinding());
+                }
 
                 endpointReference.setBinding(referenceBinding);
                 endpointReference.setTargetEndpoint(serviceEndpoint);
diff --git a/java/sca/modules/core/src/main/java/org/apache/tuscany/sca/core/assembly/impl/CompositeActivatorImpl2.java b/java/sca/modules/core/src/main/java/org/apache/tuscany/sca/core/assembly/impl/CompositeActivatorImpl2.java
index 3f93bf7cdd..b84717467f 100644
--- a/java/sca/modules/core/src/main/java/org/apache/tuscany/sca/core/assembly/impl/CompositeActivatorImpl2.java
+++ b/java/sca/modules/core/src/main/java/org/apache/tuscany/sca/core/assembly/impl/CompositeActivatorImpl2.java
@@ -704,16 +704,18 @@ public class CompositeActivatorImpl2 implements CompositeActivator {
                 // if there is a binding an endpoint has been found for the endpoint reference
                 if (endpointReference.getBinding() != null){
                     
-                    // add the binding provider 
+                    // add the binding provider. This is apparently a repeat
+                    // of previous configuration as self references are created
+                    // on the fly and miss the previous point where providers are added
                     RuntimeComponentReference runtimeRef = (RuntimeComponentReference)componentReference;
-                    final ReferenceBindingProvider bindingProvider = runtimeRef.getBindingProvider(endpointReference.getBinding());
                     
-/* TODO - Is this actually required                    
-                    if (bindingProvider == null) {
-                        bindingProvider = addReferenceBindingProvider(component, componentReference, endpointReference.getBinding());
+                    if (runtimeRef.getBindingProvider(endpointReference.getBinding()) == null) {
+                        addReferenceBindingProvider(component, componentReference, endpointReference.getBinding());
                     }
-*/                   
-                    // start the binding provider                    
+                    
+                    // start the binding provider   
+                    final ReferenceBindingProvider bindingProvider = runtimeRef.getBindingProvider(endpointReference.getBinding());
+                    
                     if (bindingProvider != null) {
                         // Allow bindings to add shutdown hooks. Requires RuntimePermission shutdownHooks in policy. 
                         AccessController.doPrivileged(new PrivilegedAction<Object>() {
@@ -797,7 +799,7 @@ public class CompositeActivatorImpl2 implements CompositeActivator {
 */        
 
         // create the wire
-        RuntimeWire wire = new RuntimeWireImpl2(false, 
+        RuntimeWire wire = new RuntimeWireImpl2(true, 
                                                 endpointReference, 
                                                 endpoint, 
                                                 interfaceContractMapper, 
diff --git a/java/sca/modules/endpoint/src/main/java/org/apache/tuscany/sca/endpoint/impl/EndpointReferenceBuilderImpl.java b/java/sca/modules/endpoint/src/main/java/org/apache/tuscany/sca/endpoint/impl/EndpointReferenceBuilderImpl.java
new file mode 100644
index 0000000000..e99d2cc63c
--- /dev/null
+++ b/java/sca/modules/endpoint/src/main/java/org/apache/tuscany/sca/endpoint/impl/EndpointReferenceBuilderImpl.java
@@ -0,0 +1,741 @@
+/*
+ * 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.endpoint.impl;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentReference;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.Endpoint2;
+import org.apache.tuscany.sca.assembly.EndpointReference2;
+import org.apache.tuscany.sca.assembly.Implementation;
+import org.apache.tuscany.sca.assembly.Multiplicity;
+import org.apache.tuscany.sca.assembly.OptimizableBinding;
+import org.apache.tuscany.sca.assembly.SCABinding;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilderException;
+import org.apache.tuscany.sca.assembly.builder.EndpointReferenceBuilder;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.FactoryExtensionPoint;
+import org.apache.tuscany.sca.definitions.Definitions;
+import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.monitor.Problem;
+import org.apache.tuscany.sca.monitor.Problem.Severity;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.PolicySubject;
+
+/**
+ * An builder that takes endpoint references and resolves them. It either finds local 
+ * service endpoints if they are available or asks the domain. The main function here
+ * is to perform binding and policy matching. 
+ * This is a separate builder in case it is required by undresolved endpoints
+ * once the runtime has started. 
+ * 
+ * @version $Rev$ $Date$
+ */
+public class EndpointReferenceBuilderImpl implements CompositeBuilder, EndpointReferenceBuilder {
+    
+    protected ExtensionPointRegistry extensionPoints;
+    protected AssemblyFactory assemblyFactory;
+    protected InterfaceContractMapper interfaceContractMapper;
+    
+    
+    public EndpointReferenceBuilderImpl(ExtensionPointRegistry extensionPoints) {
+        this.extensionPoints = extensionPoints;
+    }
+    
+    public EndpointReferenceBuilderImpl(FactoryExtensionPoint factories, InterfaceContractMapper mapper) {
+        this.assemblyFactory = factories.getFactory(AssemblyFactory.class);
+        this.interfaceContractMapper = mapper;
+    }
+
+    public String getID() {
+        return "org.apache.tuscany.sca.assembly.builder.EndpointReferenceBuilder";
+    }
+    
+    /**
+     * Report a warning.
+     * 
+     * @param monitor
+     * @param problems
+     * @param message
+     * @param model
+     */
+    protected void warning(Monitor monitor, String message, Object model, String... messageParameters) {
+        if (monitor != null) {
+            Problem problem = monitor.createProblem(this.getClass().getName(), "assembly-validation-messages", Severity.WARNING, model, message, (Object[])messageParameters);
+            monitor.problem(problem);
+        }
+    }
+    
+    /**
+     * Report a error.
+     * 
+     * @param monitor
+     * @param problems
+     * @param message
+     * @param model
+     */
+    protected void error(Monitor monitor, String message, Object model, String... messageParameters) {
+        if (monitor != null) {
+            Problem problem = monitor.createProblem(this.getClass().getName(), "assembly-validation-messages", Severity.ERROR, model, message, (Object[])messageParameters);
+            monitor.problem(problem);
+        }
+    }  
+    
+    /**
+     * Report a exception.
+     * 
+     * @param problems
+     * @param message
+     * @param model
+     */
+    protected void error(Monitor monitor, String message, Object model, Exception ex) {
+        if (monitor != null) {
+            Problem problem = null;
+            problem = monitor.createProblem(this.getClass().getName(), "assembly-validation-messages", Severity.ERROR, model, message, ex);
+            monitor.problem(problem);
+        }
+    }    
+    
+    /**
+     * Index components inside a composite
+     * 
+     * @param composite
+     * @param componentServices
+
+     */
+    protected void indexComponents(Composite composite,
+                                 Map<String, Component> components) {
+        for (Component component : composite.getComponents()) {
+            // Index components by name
+            components.put(component.getName(), component);
+        }    
+    }
+    
+    /**
+     * Index services inside a composite
+     * 
+     * @param composite
+     * @param componentServices
+     */
+    protected void indexServices(Composite composite,
+                                 Map<String, ComponentService> componentServices) {
+
+        for (Component component : composite.getComponents()) {
+            
+            ComponentService nonCallbackService = null;
+            int nonCallbackServiceCount = 0;
+            
+            for (ComponentService componentService : component.getServices()) {                 
+                // Index component services by component name / service name
+                String uri = component.getName() + '/' + componentService.getName();
+                componentServices.put(uri, componentService);
+                
+                // count how many non-callback there are
+                if (!componentService.isCallback()) {                            
+                    
+                    if (nonCallbackServiceCount == 0) {
+                        nonCallbackService = componentService;
+                    }
+                    nonCallbackServiceCount++;
+                }
+            }
+            if (nonCallbackServiceCount == 1) {
+                // If we have a single non callback service, index it by
+                // component name as well
+                componentServices.put(component.getName(), nonCallbackService);
+            }
+        }    
+    }    
+        
+
+    /**
+     * Build all the endpoint references
+     * 
+     * @param composite
+     */
+    public void build(Composite composite, Definitions definitions, Monitor monitor) throws CompositeBuilderException 
+    {
+        // process top level composite references
+        // TODO - I don't think OASIS allows for these
+        //
+        //processCompositeReferences(composite);
+        
+        // process component services
+        processComponentReferences(composite, monitor);  
+    }
+    
+    private void processCompositeReferences(Composite composite) {
+        // TODO do we need this for OASIS?
+    }
+    
+    private void processComponentReferences(Composite composite, Monitor monitor) {
+        
+        // index all of the components in the composite
+        Map<String, Component> components = new HashMap<String, Component>();
+        indexComponents(composite, components);
+        
+        // index all of the services in the composite
+        Map<String, ComponentService> componentServices = new HashMap<String, ComponentService>();
+        indexServices(composite, componentServices);
+        
+        // create endpoint references for each component's references
+        for (Component component : composite.getComponents()) {
+            // recurse for composite implementations
+            Implementation implementation = component.getImplementation();
+            if (implementation instanceof Composite) {
+                processComponentReferences((Composite)implementation, monitor);
+            }
+            
+            // build endpoint references 
+            for (ComponentReference reference : component.getReferences()) {
+                for (EndpointReference2 endpointReference : reference.getEndpointReferences()){
+                    build(endpointReference, monitor);
+                }
+            }
+        }
+    }    
+
+    /**
+     * Build a single endpoint reference
+     * 
+     * @param endpoint
+     * @param monitor
+     */
+    public void build(EndpointReference2 endpointReference, Monitor monitor) {
+        Endpoint2 endpoint = endpointReference.getTargetEndpoint();
+      
+        if (endpoint == null){
+            // an error?
+        } else {          
+            if (endpoint.isUnresolved() == false){
+                // everything is resolved
+                return;
+            }
+            
+            if (endpointReference.isUnresolved() == false ){  
+                // TODO - bring resolution and binding matching together
+                // just do binding matching
+                matchForwardBinding(endpointReference, 
+                                    endpointReference.getTargetEndpoint().getService(),
+                                    monitor);
+                
+                matchCallbackBinding(endpointReference, 
+                                     endpointReference.getTargetEndpoint().getService(),
+                                     monitor);
+            } else {
+                // resolve the endpoint reference in the domain and then 
+                // match bindings
+            } 
+        }        
+    }
+    
+    // TODO - In OASIS case there are no bindings to match with on the 
+    //        reference side. This code will be factored out into a pluggable 
+    //        piece
+    private void matchForwardBinding(EndpointReference2 endpointReference,
+                                     ComponentService service, 
+                                     Monitor monitor) {
+
+        List<Binding> matchedReferenceBinding = new ArrayList<Binding>();
+        List<Endpoint2> matchedServiceEndpoint = new ArrayList<Endpoint2>();
+
+        // Find the corresponding bindings from the service side
+        for (Binding referenceBinding : endpointReference.getReference().getBindings()) {
+            for (Endpoint2 serviceEndpoint : service.getEndpoints()) {
+
+                if (referenceBinding.getClass() == serviceEndpoint.getBinding().getClass() && 
+                    hasCompatiblePolicySets(referenceBinding, serviceEndpoint.getBinding())) {
+
+                    matchedReferenceBinding.add(referenceBinding);
+                    matchedServiceEndpoint.add(serviceEndpoint);
+                }
+            }
+        }
+
+        if (matchedReferenceBinding.isEmpty()) {
+            // No matching binding
+            endpointReference.setBinding(null);
+            endpointReference.setTargetEndpoint(null);
+            warning(monitor, 
+                    "NoMatchingBinding", 
+                    endpointReference.getReference(),
+                    endpointReference.getReference().getName(), 
+                    service.getName());
+            return;
+        } else {
+            // default to using the first matched binding
+            int selectedBinding = 0;
+
+            for (int i = 0; i < matchedReferenceBinding.size(); i++) {
+                // If binding.sca is present, use it
+                if (SCABinding.class.isInstance(matchedReferenceBinding.get(i))) {
+                    selectedBinding = i;
+                }
+            }
+
+            Binding referenceBinding = matchedReferenceBinding.get(selectedBinding);
+            Endpoint2 serviceEndpoint = matchedServiceEndpoint.get(selectedBinding);
+
+            // populate the endpoint reference
+            try {
+
+                Binding cloned = (Binding) referenceBinding.clone();
+
+                // Set the binding URI to the URI of the target service
+                // that has been matched
+                if (referenceBinding.getURI() == null) {
+                    cloned.setURI(serviceEndpoint.getBinding().getURI());
+                }
+                
+                // TODO - can we remove this?
+                if (cloned instanceof OptimizableBinding) {
+                    OptimizableBinding optimizableBinding = (OptimizableBinding)cloned;
+                    optimizableBinding.setTargetComponent(serviceEndpoint.getComponent());
+                    optimizableBinding.setTargetComponentService(serviceEndpoint.getService());
+                    optimizableBinding.setTargetBinding(serviceEndpoint.getBinding());
+                }
+
+                endpointReference.setBinding(referenceBinding);
+                endpointReference.setTargetEndpoint(serviceEndpoint);
+
+            } catch (Exception ex) {
+                // do nothing
+            }
+        }
+    } 
+    
+    // TODO
+    // Pretty much a duplicate of matchForwardBinding to handle callback bindings
+    // will rationalize when I understand what we need to do with callbacks
+    private void matchCallbackBinding(EndpointReference2 endpointReference, 
+                                     ComponentService service, 
+                                     Monitor monitor) {
+
+        // if no callback on the interface do nothing
+        if (endpointReference.getReference().getInterfaceContract() == null || 
+            endpointReference.getReference().getInterfaceContract().getCallbackInterface() == null){
+                return;
+        }
+        
+        List<Binding> matchedReferenceBinding = new ArrayList<Binding>();
+        List<Binding> matchedServiceBinding = new ArrayList<Binding>();
+        
+        // Find the corresponding bindings from the service side
+        for (Binding referenceBinding : endpointReference.getReference().getCallback().getBindings()) {
+            for (Binding serviceBinding : service.getCallback().getBindings()) {
+
+                if (referenceBinding.getClass() == serviceBinding.getClass() && 
+                    hasCompatiblePolicySets(referenceBinding, serviceBinding)) {
+                    
+                    matchedReferenceBinding.add(referenceBinding);
+                    matchedServiceBinding.add(serviceBinding);                 
+                }
+            }
+        }
+        
+        if (matchedReferenceBinding.isEmpty()) {
+            // No matching binding
+            endpointReference.setCallbackEndpoint(null);
+            warning(monitor, 
+                    "NoMatchingCallbackBinding", 
+                    endpointReference.getReference(),
+                    endpointReference.getReference().getName(), 
+                    service.getName());
+            return;
+        } else {
+            // default to using the first matched binding
+            int selectedBinding = 0;
+            
+            for (int i = 0; i < matchedReferenceBinding.size(); i++){
+                // If binding.sca is present, use it
+                if (SCABinding.class.isInstance(matchedReferenceBinding.get(i))) {
+                    selectedBinding = i;
+                }
+            }
+            
+            Binding selectedCallbackBinding = matchedReferenceBinding.get(selectedBinding);
+
+            ComponentService callbackService = endpointReference.getReference().getCallbackService();
+            
+            if (callbackService != null) {
+                // find the callback endpoint that has the selected binding
+                for (Endpoint2 endpoint : callbackService.getEndpoints()){
+                    if (endpoint.getBinding().getName().startsWith(selectedCallbackBinding.getName())){
+                        endpointReference.setCallbackEndpoint(endpoint);
+                        break;
+                    }
+                }
+            }
+        }
+    }     
+    
+    private boolean hasCompatiblePolicySets(Binding refBinding, Binding svcBinding) {
+        boolean isCompatible = true;
+        if ( refBinding instanceof PolicySubject && svcBinding instanceof PolicySubject ) {
+            //TODO : need to add more compatibility checks at the policy attachment levels
+            for ( PolicySet svcPolicySet : ((PolicySubject)svcBinding).getPolicySets() ) {
+                isCompatible = false;
+                for ( PolicySet refPolicySet : ((PolicySubject)refBinding).getPolicySets() ) {
+                    if ( svcPolicySet.equals(refPolicySet) ) {
+                        isCompatible = true;
+                        break;
+                    }
+                }
+                //if there exists no matching policy set in the reference binding
+                if ( !isCompatible ) {
+                    return isCompatible;
+                }
+            }
+        }
+        return isCompatible;
+    }    
+
+    public void createEndpointReferences(Composite composite,
+                                         Component component, 
+                                         ComponentReference reference,
+                                         Map<String, Component> components,
+                                         Map<String, ComponentService> componentServices, 
+                                         Monitor monitor) {
+        
+        if (reference.getAutowire() == Boolean.TRUE
+                && reference.getTargets().isEmpty()) {
+
+            // Find suitable targets in the current composite for an
+            // autowired reference
+            Multiplicity multiplicity = reference.getMultiplicity();
+            for (Component targetComponent : composite.getComponents()) {
+
+                // prevent autowire connecting to self
+                boolean skipSelf = false;
+                for (ComponentReference targetComponentReference : targetComponent
+                        .getReferences()) {
+                    if (reference == targetComponentReference) {
+                        skipSelf = true;
+                    }
+                }
+
+                if (!skipSelf) {
+                    for (ComponentService targetComponentService : targetComponent
+                            .getServices()) {
+                        if (reference.getInterfaceContract() == null
+                                || interfaceContractMapper.isCompatible(
+                                        reference.getInterfaceContract(),
+                                        targetComponentService
+                                                .getInterfaceContract())) {
+                            // create endpoint reference
+                            EndpointReference2 endpointRef = assemblyFactory
+                                    .createEndpointReference();
+                            endpointRef.setComponent(component);
+                            endpointRef.setReference(reference);
+                            endpointRef.setTargetName(targetComponentService
+                                    .getName());
+                            endpointRef.setUnresolved(false);
+
+                            // create dummy endpoint. This will be replaced when
+                            // policies
+                            // are matched and bindings are configured later
+                            Endpoint2 endpoint = assemblyFactory
+                                    .createEndpoint();
+                            endpoint.setComponent(targetComponent);
+                            endpoint.setService(targetComponentService);
+                            endpoint.setUnresolved(true);
+                            endpointRef.setTargetEndpoint(endpoint);
+
+                            reference.getEndpointReferences().add(endpointRef);
+
+                            if (multiplicity == Multiplicity.ZERO_ONE
+                                    || multiplicity == Multiplicity.ONE_ONE) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (multiplicity == Multiplicity.ONE_N
+                    || multiplicity == Multiplicity.ONE_ONE) {
+                if (reference.getEndpointReferences().size() == 0) {
+                    warning(monitor, "NoComponentReferenceTarget", reference,
+                            reference.getName());
+                }
+            }
+
+        } else if (!reference.getTargets().isEmpty()) {
+
+            // Check that the component reference does not mix the use of
+            // endpoint references specified via the target attribute with
+            // the presence of binding elements
+            if (reference.getBindings().size() > 0) {
+                warning(monitor, "ReferenceEndPointMixWithTarget", composite,
+                        reference.getName());
+            }
+
+            // Resolve targets specified on the component reference
+            for (ComponentService target : reference.getTargets()) {
+
+                String targetName = target.getName();
+                ComponentService targetComponentService = componentServices
+                        .get(targetName);
+
+                Component targetComponent;
+                int s = targetName.indexOf('/');
+                if (s == -1) {
+                    targetComponent = components.get(targetName);
+                } else {
+                    targetComponent = components
+                            .get(targetName.substring(0, s));
+                }
+
+                if (targetComponentService != null) {
+
+                    // Check that the target component service provides
+                    // a superset of the component reference interface
+                    if (reference.getInterfaceContract() == null
+                            || interfaceContractMapper.isCompatible(reference
+                                    .getInterfaceContract(),
+                                    targetComponentService
+                                            .getInterfaceContract())) {
+
+                        // create endpoint reference
+                        EndpointReference2 endpointRef = assemblyFactory
+                                .createEndpointReference();
+                        endpointRef.setComponent(component);
+                        endpointRef.setReference(reference);
+                        endpointRef.setTargetName(targetComponentService
+                                .getName());
+                        endpointRef.setUnresolved(false);
+
+                        // create dummy endpoint. This will be replaced when
+                        // policies
+                        // are matched and bindings are configured later
+                        Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                        endpoint.setComponent(targetComponent);
+                        endpoint.setService(targetComponentService);
+                        endpoint.setUnresolved(true);
+                        endpointRef.setTargetEndpoint(endpoint);
+
+                        reference.getEndpointReferences().add(endpointRef);
+                    } else {
+                        warning(monitor, "ReferenceIncompatibleInterface",
+                                composite, composite.getName().toString(),
+                                reference.getName(), targetName);
+                    }
+                } else {
+                    // add an unresolved endpoint reference
+                    EndpointReference2 endpointRef = assemblyFactory
+                            .createEndpointReference();
+                    endpointRef.setComponent(component);
+                    endpointRef.setReference(reference);
+                    endpointRef.setTargetName(targetName);
+                    endpointRef.setUnresolved(true);
+
+                    // create an unresolved endpoint to go with it
+                    Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                    endpoint.setUnresolved(true);
+                    endpointRef.setTargetEndpoint(endpoint);
+
+                    warning(monitor, "ComponentReferenceTargetNotFound",
+                            composite, composite.getName().toString(),
+                            targetName);
+                }
+            }
+        } else if ((reference.getReference() != null)
+                && (!reference.getReference().getTargets().isEmpty())) {
+
+            // Resolve targets from the corresponding reference in the
+            // componentType
+            for (ComponentService target : reference.getReference()
+                    .getTargets()) {
+
+                String targetName = target.getName();
+                ComponentService targetComponentService = componentServices
+                        .get(targetName);
+
+                Component targetComponent;
+                int s = targetName.indexOf('/');
+                if (s == -1) {
+                    targetComponent = components.get(targetName);
+                } else {
+                    targetComponent = components
+                            .get(targetName.substring(0, s));
+                }
+
+                if (targetComponentService != null) {
+
+                    // Check that the target component service provides
+                    // a superset of the component reference interface
+                    if (reference.getInterfaceContract() == null
+                            || interfaceContractMapper.isCompatible(reference
+                                    .getInterfaceContract(),
+                                    targetComponentService
+                                            .getInterfaceContract())) {
+
+                        // create endpoint reference
+                        EndpointReference2 endpointRef = assemblyFactory
+                                .createEndpointReference();
+                        endpointRef.setComponent(component);
+                        endpointRef.setReference(reference);
+                        endpointRef.setTargetName(targetComponentService
+                                .getName());
+                        endpointRef.setUnresolved(false);
+
+                        // create dummy endpoint. This will be replaced when
+                        // policies
+                        // are matched and bindings are configured later
+                        Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                        endpoint.setComponent(targetComponent);
+                        endpoint.setService(targetComponentService);
+                        endpoint.setUnresolved(true);
+                        endpointRef.setTargetEndpoint(endpoint);
+
+                        reference.getEndpointReferences().add(endpointRef);
+                    } else {
+                        warning(monitor, "ReferenceIncompatibleInterface",
+                                composite, composite.getName().toString(),
+                                reference.getName(), targetName);
+                    }
+                } else {
+                    // add an unresolved endpoint reference
+                    EndpointReference2 endpointRef = assemblyFactory
+                            .createEndpointReference();
+                    endpointRef.setComponent(component);
+                    endpointRef.setReference(reference);
+                    endpointRef.setTargetName(targetName);
+                    endpointRef.setUnresolved(true);
+
+                    // create an unresolved endpoint to go with it
+                    Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                    endpoint.setUnresolved(true);
+                    endpointRef.setTargetEndpoint(endpoint);
+
+                    warning(monitor, "ComponentReferenceTargetNotFound",
+                            composite, composite.getName().toString(),
+                            targetName);
+                }
+            }
+        }
+
+        // if no endpoints have found so far the bindings become targets.
+        if (reference.getEndpointReferences().isEmpty()) {
+            for (Binding binding : reference.getBindings()) {
+
+                String uri = binding.getURI();
+
+                // user hasn't put a uri on the binding so it's not a target
+                // name
+                if (uri == null) {
+                    continue;
+                }
+
+                // user might have put a local target name in the uri
+                // see if it refers to a target we know about
+                // - if it does the reference binding will be matched with a
+                // service binding
+                // - if it doesn't it is assumed to be an external reference
+                Component targetComponent = null;
+                ComponentService targetComponentService = null;
+
+                if (uri.startsWith("/")) {
+                    uri = uri.substring(1);
+                }
+
+                // Resolve the target component and service
+                targetComponentService = componentServices.get(uri);
+                int s = uri.indexOf('/');
+                if (s == -1) {
+                    targetComponent = components.get(uri);
+                } else {
+                    targetComponent = components.get(uri.substring(0, s));
+                }
+
+                // if the binding URI matches a component in the
+                // composite then configure an endpoint reference with this
+                // component as
+                // the target. If not then the binding URI will be assumed to
+                // reference an
+                // external service
+                if (targetComponentService != null) {
+
+                    // Check that the target component service provides
+                    // a superset of the component reference interface
+                    if (reference.getInterfaceContract() == null
+                            || interfaceContractMapper.isCompatible(reference
+                                    .getInterfaceContract(),
+                                    targetComponentService
+                                            .getInterfaceContract())) {
+                        // create enpoint reference
+                        EndpointReference2 endpointRef = assemblyFactory
+                                .createEndpointReference();
+                        endpointRef.setComponent(component);
+                        endpointRef.setReference(reference);
+                        endpointRef.setBinding(binding);
+                        endpointRef.setTargetName(targetComponentService
+                                .getName());
+                        endpointRef.setUnresolved(false);
+
+                        // create dummy endpoint. This will be replaced when
+                        // policies
+                        // are matched and bindings are configured later
+                        Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                        endpoint.setComponent(targetComponent);
+                        endpoint.setService(targetComponentService);
+                        endpoint.setUnresolved(true);
+                        endpointRef.setTargetEndpoint(endpoint);
+
+                        reference.getEndpointReferences().add(endpointRef);
+                    } else {
+                        warning(monitor, "ReferenceIncompatibleInterface",
+                                composite, composite.getName().toString(),
+                                reference.getName(), uri);
+                    }
+                } else {
+                    // create endpoint reference for manually configured
+                    // bindings
+                    EndpointReference2 endpointRef = assemblyFactory
+                            .createEndpointReference();
+                    endpointRef.setComponent(component);
+                    endpointRef.setReference(reference);
+                    endpointRef.setBinding(binding);
+                    endpointRef.setTargetName(null);
+                    endpointRef.setTargetEndpoint(null);
+                    endpointRef.setUnresolved(false);
+
+                    // create a resolved endpoint to signify that this
+                    // reference is pointing at some unwired endpoint
+                    Endpoint2 endpoint = assemblyFactory.createEndpoint();
+                    endpoint.setUnresolved(false);
+                    endpointRef.setTargetEndpoint(endpoint);
+
+                    reference.getEndpointReferences().add(endpointRef);
+                }
+            }
+        }
+} 
+}
diff --git a/java/sca/modules/endpoint/src/main/resources/META-INF/services/org.apache.tuscany.sca.assembly.builder.CompositeBuilder b/java/sca/modules/endpoint/src/main/resources/META-INF/services/org.apache.tuscany.sca.assembly.builder.CompositeBuilder
new file mode 100644
index 0000000000..541941c3d3
--- /dev/null
+++ b/java/sca/modules/endpoint/src/main/resources/META-INF/services/org.apache.tuscany.sca.assembly.builder.CompositeBuilder
@@ -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. 

+

+org.apache.tuscany.sca.endpoint.impl.EndpointReferenceBuilderImpl;id=org.apache.tuscany.sca.endpoint.impl.EndpointReferenceBuilderImpl

diff --git a/java/sca/modules/endpoint/src/main/resources/META-INF/services/org.apache.tuscany.sca.assembly.builder.EndpointReferenceBuilder b/java/sca/modules/endpoint/src/main/resources/META-INF/services/org.apache.tuscany.sca.assembly.builder.EndpointReferenceBuilder
new file mode 100644
index 0000000000..37f34b9aba
--- /dev/null
+++ b/java/sca/modules/endpoint/src/main/resources/META-INF/services/org.apache.tuscany.sca.assembly.builder.EndpointReferenceBuilder
@@ -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. 

+

+org.apache.tuscany.sca.endpoint.impl.EndpointReferenceBuilderImpl
\ No newline at end of file
diff --git a/java/sca/modules/endpoint/src/test/java/org/apace/tuscany/sca/binding/sca/EndpointTestCase.java b/java/sca/modules/endpoint/src/test/java/org/apace/tuscany/sca/binding/sca/EndpointTestCase.java
index e972670390..388b363e18 100644
--- a/java/sca/modules/endpoint/src/test/java/org/apace/tuscany/sca/binding/sca/EndpointTestCase.java
+++ b/java/sca/modules/endpoint/src/test/java/org/apace/tuscany/sca/binding/sca/EndpointTestCase.java
@@ -56,6 +56,7 @@ import org.apache.tuscany.sca.monitor.Monitor;
 import org.apache.tuscany.sca.monitor.MonitorFactory;
 import org.junit.Assert;
 import org.junit.BeforeClass;
+import org.junit.Ignore;
 import org.junit.Test;
 
 /**
@@ -169,6 +170,7 @@ public class EndpointTestCase {
         
     }
     
+    @Ignore
     @Test
     public void testProvider(){
         try {