| /* |
| * 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.core.assembly.impl; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.Externalizable; |
| import java.io.IOException; |
| import java.io.ObjectInput; |
| import java.io.ObjectOutput; |
| import java.io.StringReader; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.ConcurrentHashMap; |
| |
| import javax.wsdl.xml.WSDLWriter; |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.stream.XMLStreamReader; |
| import javax.xml.transform.stream.StreamSource; |
| |
| 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.CompositeReference; |
| import org.apache.tuscany.sca.assembly.CompositeService; |
| import org.apache.tuscany.sca.assembly.Contract; |
| import org.apache.tuscany.sca.assembly.Endpoint; |
| import org.apache.tuscany.sca.assembly.EndpointReference; |
| import org.apache.tuscany.sca.assembly.Reference; |
| import org.apache.tuscany.sca.assembly.Service; |
| import org.apache.tuscany.sca.assembly.builder.BindingBuilder; |
| import org.apache.tuscany.sca.assembly.builder.BuilderContext; |
| import org.apache.tuscany.sca.assembly.builder.BuilderExtensionPoint; |
| import org.apache.tuscany.sca.assembly.impl.EndpointImpl; |
| import org.apache.tuscany.sca.context.CompositeContext; |
| import org.apache.tuscany.sca.contribution.processor.ContributionReadException; |
| import org.apache.tuscany.sca.contribution.processor.ProcessorContext; |
| import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor; |
| import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint; |
| import org.apache.tuscany.sca.contribution.processor.ValidatingXMLInputFactory; |
| import org.apache.tuscany.sca.core.ExtensionPointRegistry; |
| import org.apache.tuscany.sca.core.ExtensionPointRegistryLocator; |
| import org.apache.tuscany.sca.core.FactoryExtensionPoint; |
| import org.apache.tuscany.sca.core.UtilityExtensionPoint; |
| import org.apache.tuscany.sca.core.assembly.RuntimeAssemblyFactory; |
| import org.apache.tuscany.sca.core.invocation.AsyncResponseService; |
| import org.apache.tuscany.sca.core.invocation.Constants; |
| import org.apache.tuscany.sca.core.invocation.ExtensibleWireProcessor; |
| import org.apache.tuscany.sca.core.invocation.NonBlockingInterceptor; |
| import org.apache.tuscany.sca.core.invocation.RuntimeInvoker; |
| import org.apache.tuscany.sca.core.invocation.impl.InvocationChainImpl; |
| import org.apache.tuscany.sca.core.invocation.impl.PhaseManager; |
| import org.apache.tuscany.sca.interfacedef.Compatibility; |
| import org.apache.tuscany.sca.interfacedef.InterfaceContract; |
| import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper; |
| import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException; |
| import org.apache.tuscany.sca.interfacedef.Operation; |
| import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract; |
| import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; |
| import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition; |
| import org.apache.tuscany.sca.interfacedef.wsdl.WSDLInterface; |
| import org.apache.tuscany.sca.interfacedef.wsdl.WSDLInterfaceContract; |
| import org.apache.tuscany.sca.invocation.Interceptor; |
| import org.apache.tuscany.sca.invocation.InterceptorAsync; |
| import org.apache.tuscany.sca.invocation.InvocationChain; |
| import org.apache.tuscany.sca.invocation.Invoker; |
| import org.apache.tuscany.sca.invocation.InvokerAsyncResponse; |
| import org.apache.tuscany.sca.invocation.Message; |
| import org.apache.tuscany.sca.invocation.MessageFactory; |
| import org.apache.tuscany.sca.invocation.Phase; |
| import org.apache.tuscany.sca.provider.BindingProviderFactory; |
| import org.apache.tuscany.sca.provider.EndpointAsyncProvider; |
| import org.apache.tuscany.sca.provider.EndpointProvider; |
| import org.apache.tuscany.sca.provider.ImplementationAsyncProvider; |
| import org.apache.tuscany.sca.provider.ImplementationProvider; |
| import org.apache.tuscany.sca.provider.OptimisingBindingProvider; |
| import org.apache.tuscany.sca.provider.PolicyProvider; |
| import org.apache.tuscany.sca.provider.PolicyProviderFactory; |
| import org.apache.tuscany.sca.provider.ProviderFactoryExtensionPoint; |
| import org.apache.tuscany.sca.provider.ServiceBindingProvider; |
| import org.apache.tuscany.sca.runtime.DomainRegistry; |
| import org.apache.tuscany.sca.runtime.DomainRegistryFactory; |
| import org.apache.tuscany.sca.runtime.EndpointSerializer; |
| import org.apache.tuscany.sca.runtime.ExtensibleDomainRegistryFactory; |
| import org.apache.tuscany.sca.runtime.RuntimeComponent; |
| import org.apache.tuscany.sca.runtime.RuntimeComponentService; |
| import org.apache.tuscany.sca.runtime.RuntimeEndpoint; |
| import org.apache.tuscany.sca.runtime.RuntimeEndpointReference; |
| import org.apache.tuscany.sca.runtime.RuntimeWireProcessor; |
| import org.apache.tuscany.sca.runtime.RuntimeWireProcessorExtensionPoint; |
| import org.apache.tuscany.sca.work.WorkScheduler; |
| import org.oasisopen.sca.ServiceRuntimeException; |
| |
| /** |
| * Runtime model for Endpoint that supports java serialization |
| */ |
| public class RuntimeEndpointImpl extends EndpointImpl implements RuntimeEndpoint, Externalizable { |
| private static final long serialVersionUID = 1L; |
| private transient CompositeContext compositeContext; |
| private transient RuntimeWireProcessor wireProcessor; |
| private transient ProviderFactoryExtensionPoint providerFactories; |
| private transient InterfaceContractMapper interfaceContractMapper; |
| private transient WorkScheduler workScheduler; |
| private transient PhaseManager phaseManager; |
| private transient MessageFactory messageFactory; |
| private transient RuntimeInvoker invoker; |
| private transient EndpointSerializer serializer; |
| |
| private transient List<InvocationChain> chains; |
| private transient Map<Operation, InvocationChain> invocationChainMap = |
| new ConcurrentHashMap<Operation, InvocationChain>(); |
| private transient InvocationChain bindingInvocationChain; |
| |
| private transient ServiceBindingProvider bindingProvider; |
| private transient List<PolicyProvider> policyProviders; |
| private String xml; |
| private String wsdl; |
| |
| protected InterfaceContract bindingInterfaceContract; |
| protected InterfaceContract serviceInterfaceContract; |
| |
| private RuntimeEndpoint delegateEndpoint; |
| |
| /** |
| * No-arg constructor for Java serialization |
| */ |
| public RuntimeEndpointImpl() { |
| super(null); |
| } |
| |
| public RuntimeEndpointImpl(ExtensionPointRegistry registry) { |
| super(registry); |
| } |
| |
| protected void copyFrom(RuntimeEndpointImpl copy) { |
| this.xml = copy.xml; |
| |
| this.component = copy.component; |
| this.service = copy.service; |
| this.interfaceContract = copy.interfaceContract; |
| this.serviceInterfaceContract = copy.serviceInterfaceContract; |
| |
| this.binding = copy.binding; |
| this.bindingInterfaceContract = copy.interfaceContract; |
| this.bindingInvocationChain = copy.bindingInvocationChain; |
| |
| this.callbackEndpointReferences = copy.callbackEndpointReferences; |
| |
| this.requiredIntents = copy.requiredIntents; |
| this.policySets = copy.policySets; |
| |
| this.uri = copy.uri; |
| this.remote = copy.remote; |
| this.unresolved = copy.unresolved; |
| |
| this.chains = copy.chains; |
| this.invocationChainMap = copy.invocationChainMap; |
| this.bindingProvider = copy.bindingProvider; |
| this.policyProviders = copy.policyProviders; |
| |
| if (this.compositeContext == null && copy.compositeContext != null) { |
| bind(copy.compositeContext); |
| } |
| } |
| |
| public void bind(CompositeContext compositeContext) { |
| this.compositeContext = compositeContext; |
| bind(compositeContext.getExtensionPointRegistry(), compositeContext.getEndpointRegistry()); |
| } |
| |
| public void bind(ExtensionPointRegistry registry, DomainRegistry domainRegistry) { |
| if (compositeContext == null) { |
| compositeContext = new CompositeContext(registry, domainRegistry); |
| } |
| |
| // if interfaceContractMapper is already initialized then all the rest will be too |
| if (interfaceContractMapper != null) { |
| return; |
| } |
| this.registry = registry; |
| UtilityExtensionPoint utilities = registry.getExtensionPoint(UtilityExtensionPoint.class); |
| this.interfaceContractMapper = utilities.getUtility(InterfaceContractMapper.class); |
| this.workScheduler = utilities.getUtility(WorkScheduler.class); |
| this.wireProcessor = |
| new ExtensibleWireProcessor(registry.getExtensionPoint(RuntimeWireProcessorExtensionPoint.class)); |
| |
| this.messageFactory = registry.getExtensionPoint(FactoryExtensionPoint.class).getFactory(MessageFactory.class); |
| this.invoker = new RuntimeInvoker(registry, this); |
| |
| this.phaseManager = utilities.getUtility(PhaseManager.class); |
| this.serializer = utilities.getUtility(EndpointSerializer.class); |
| this.providerFactories = registry.getExtensionPoint(ProviderFactoryExtensionPoint.class); |
| this.builders = registry.getExtensionPoint(BuilderExtensionPoint.class); |
| this.contractBuilder = builders.getContractBuilder(); |
| } |
| |
| public void unbind() { |
| compositeContext = null; |
| bindingInvocationChain = null; |
| chains = null; |
| bindingProvider = null; |
| policyProviders = null; |
| invocationChainMap.clear(); |
| } |
| |
| public synchronized List<InvocationChain> getInvocationChains() { |
| if (chains == null) { |
| initInvocationChains(); |
| } |
| return chains; |
| } |
| |
| public synchronized InvocationChain getBindingInvocationChain() { |
| if (bindingInvocationChain == null) { |
| bindingInvocationChain = new InvocationChainImpl(null, null, false, phaseManager, isAsyncInvocation()); |
| initServiceBindingInvocationChains(); |
| } |
| |
| // Init the operation invocation chains now. We know they will |
| // be needed as well as the binding invocation chain and this |
| // makes the wire processors run |
| getInvocationChains(); |
| |
| return bindingInvocationChain; |
| } |
| |
| /** |
| * A dummy invocation chain representing null as ConcurrentHashMap doesn't allow null values |
| */ |
| private static final InvocationChain NULL_CHAIN = new InvocationChainImpl(null, null, false, null, false); |
| |
| public InvocationChain getInvocationChain(Operation operation) { |
| InvocationChain cached = invocationChainMap.get(operation); |
| if (cached == null) { |
| for (InvocationChain chain : getInvocationChains()) { |
| Operation op = chain.getTargetOperation(); |
| |
| // We used to check compatibility here but this is now validated when the |
| // chain is created. As the chain operations are the real interface types |
| // they may be incompatible just because they are described in different |
| // IDLs |
| if (operation.getInterface().isRemotable()) { |
| if (operation.getName().equals(op.getName())) { |
| invocationChainMap.put(operation, chain); |
| return chain; |
| } |
| if (interfaceContractMapper.isCompatible(operation, op, Compatibility.SUBSET)) { |
| invocationChainMap.put(operation, chain); |
| return chain; |
| } |
| } else { |
| // [rfeng] We need to run the compatibility check for local operations as they |
| // can be overloaded |
| if (interfaceContractMapper.isCompatible(operation, op, Compatibility.SUBSET)) { |
| invocationChainMap.put(operation, chain); |
| return chain; |
| } |
| } |
| } |
| // Cache it with the NULL_CHAIN to avoid NPE |
| invocationChainMap.put(operation, NULL_CHAIN); |
| return null; |
| } else { |
| if (cached == NULL_CHAIN) { |
| cached = null; |
| } |
| return cached; |
| } |
| } |
| |
| public Message invoke(Message msg) { |
| // Deal with async callback |
| // Ensure invocation chains are built... |
| getInvocationChains(); |
| // async callback handling |
| if( this.isAsyncInvocation() && !this.getCallbackEndpointReferences().isEmpty() ) { |
| RuntimeEndpointReference asyncEPR = (RuntimeEndpointReference) this.getCallbackEndpointReferences().get(0); |
| // Place a link to the callback EPR into the message headers... |
| msg.getHeaders().put(Constants.ASYNC_CALLBACK, asyncEPR ); |
| } |
| // end of async callback handling |
| return invoker.invokeBinding(msg); |
| } |
| |
| public Object invoke(Operation operation, Object[] args) throws InvocationTargetException { |
| return invoker.invoke(operation, args); |
| } |
| |
| public Message invoke(Operation operation, Message msg) { |
| return invoker.invoke(operation, msg); |
| } |
| |
| public void invokeAsync(Message msg){ |
| invoker.invokeBindingAsync(msg); |
| } // end method invokeAsync(Message) |
| |
| public void invokeAsync(Operation operation, Message msg){ |
| msg.setOperation(operation); |
| invoker.invokeAsync(msg); |
| } // end method invokeAsync(Operation, Message) |
| |
| public void invokeAsyncResponse(Message msg){ |
| resolve(); |
| invoker.invokeAsyncResponse(msg); |
| } |
| |
| /** |
| * Navigate the component/componentType inheritance chain to find the leaf contract |
| * @param contract |
| * @return |
| */ |
| private Contract getLeafContract(Contract contract) { |
| Contract prev = null; |
| Contract current = contract; |
| while (current != null) { |
| prev = current; |
| if (current instanceof ComponentReference) { |
| current = ((ComponentReference)current).getReference(); |
| } else if (current instanceof CompositeReference) { |
| current = ((CompositeReference)current).getPromotedReferences().get(0); |
| } else if (current instanceof ComponentService) { |
| current = ((ComponentService)current).getService(); |
| } else if (current instanceof CompositeService) { |
| current = ((CompositeService)current).getPromotedService(); |
| } else { |
| break; |
| } |
| if (current == null) { |
| return prev; |
| } |
| } |
| return current; |
| } |
| |
| /** |
| * Initialize the invocation chains |
| */ |
| private void initInvocationChains() { |
| chains = new ArrayList<InvocationChain>(); |
| InterfaceContract sourceContract = getBindingInterfaceContract(); |
| |
| // It's the service wire |
| RuntimeComponentService service = (RuntimeComponentService)getService(); |
| RuntimeComponent serviceComponent = (RuntimeComponent)getComponent(); |
| |
| //InterfaceContract targetContract = getInterfaceContract(); |
| // TODO - EPR - why is this looking at the component types. The endpoint should have the right interface contract by this time |
| InterfaceContract targetContract = getComponentTypeServiceInterfaceContract(); |
| // setInterfaceContract(targetContract); |
| validateServiceInterfaceCompatibility(); |
| for (Operation operation : sourceContract.getInterface().getOperations()) { |
| Operation targetOperation = interfaceContractMapper.map(targetContract.getInterface(), operation); |
| if (targetOperation == null) { |
| throw new ServiceRuntimeException("No matching operation for " + operation.getName() |
| + " is found in service " |
| + serviceComponent.getURI() |
| + "#" |
| + service.getName()); |
| } |
| InvocationChain chain = new InvocationChainImpl(operation, targetOperation, false, phaseManager, isAsyncInvocation()); |
| if (operation.isNonBlocking()) { |
| addNonBlockingInterceptor(chain); |
| } |
| addServiceBindingInterceptor(chain, operation); |
| addImplementationInterceptor(serviceComponent, service, chain, targetOperation); |
| chains.add(chain); |
| |
| // Handle cases where the operation is an async server |
| if( targetOperation.isAsyncServer() ) { |
| createAsyncServerCallback(); |
| } // end if |
| } |
| |
| wireProcessor.process(this); |
| |
| // If we have to support async and there is no binding chain |
| // then set the response path to point directly to the |
| // binding provided async response handler |
| if (isAsyncInvocation() && |
| bindingInvocationChain == null){ |
| // fix up the operation chain response path to point back to the |
| // binding provided async response handler |
| ServiceBindingProvider serviceBindingProvider = getBindingProvider(); |
| if (serviceBindingProvider instanceof EndpointAsyncProvider){ |
| EndpointAsyncProvider asyncEndpointProvider = (EndpointAsyncProvider)serviceBindingProvider; |
| InvokerAsyncResponse asyncResponseInvoker = asyncEndpointProvider.createAsyncResponseInvoker(); |
| |
| for (InvocationChain chain : getInvocationChains()){ |
| Invoker invoker = chain.getHeadInvoker(); |
| if (invoker instanceof InterceptorAsync){ |
| ((InterceptorAsync)invoker).setPrevious(asyncResponseInvoker); |
| } else { |
| //TODO - throw error once the old async code is removed |
| } // end if |
| } // end for |
| } else { |
| // TODO - throw error once the old async code is removed |
| } // end if |
| } // end if |
| |
| ServiceBindingProvider provider = getBindingProvider(); |
| if ((provider != null) && (provider instanceof OptimisingBindingProvider)) { |
| //TODO - remove this comment once optimisation codepath is tested |
| ((OptimisingBindingProvider)provider).optimiseBinding( this ); |
| } // end if |
| |
| } // end method initInvocationChains |
| |
| /** |
| * Creates the async callback for this Endpoint, if it does not already exist |
| * and stores it into the Endpoint |
| */ |
| public void createAsyncServerCallback( ) { |
| // No need to create a callback if the Binding supports async natively... |
| if( hasNativeAsyncBinding(this) ) return; |
| |
| // Check to see if the callback already exists |
| if( asyncCallbackExists( this ) ) return; |
| |
| RuntimeEndpointReference asyncEPR = createAsyncEPR( this ); |
| |
| // Store the new callback EPR into the Endpoint |
| this.getCallbackEndpointReferences().add(asyncEPR); |
| |
| // Also store the callback EPR into the DomainRegistry |
| DomainRegistry epReg = getEndpointRegistry( registry ); |
| if( epReg != null ) epReg.addEndpointReference(asyncEPR); |
| } // end method createAsyncServerCallback |
| |
| public RuntimeEndpointReference getAsyncServerCallback() { |
| |
| return (RuntimeEndpointReference) this.getCallbackEndpointReferences().get(0); |
| } // end method getAsyncServerCallback |
| |
| |
| /** |
| * Indicates if a given endpoint has a Binding that supports native async invocation |
| * @param endpoint - the endpoint |
| * @return - true if the endpoint has a binding that supports native async, false otherwise |
| */ |
| private boolean hasNativeAsyncBinding(RuntimeEndpoint endpoint) { |
| ServiceBindingProvider provider = endpoint.getBindingProvider(); |
| if( provider instanceof EndpointAsyncProvider ) { |
| EndpointAsyncProvider asyncProvider = (EndpointAsyncProvider) provider; |
| if( asyncProvider.supportsNativeAsync() ) return true; |
| } // end if |
| return false; |
| } // end method hasNativeAsyncBinding |
| |
| /** |
| * Creates the Endpoint object for the async callback |
| * @param endpoint - the endpoint which has the async server operations |
| * @return the EndpointReference object representing the callback |
| */ |
| private RuntimeEndpointReference createAsyncEPR( RuntimeEndpoint endpoint ){ |
| CompositeContext compositeContext = endpoint.getCompositeContext(); |
| RuntimeAssemblyFactory assemblyFactory = getAssemblyFactory( compositeContext ); |
| RuntimeEndpointReference epr = (RuntimeEndpointReference)assemblyFactory.createEndpointReference(); |
| epr.bind( compositeContext ); |
| |
| // Create pseudo-component |
| epr.setComponent(component); |
| |
| // Create pseudo-reference |
| ComponentReference reference = assemblyFactory.createComponentReference(); |
| ExtensionPointRegistry registry = compositeContext.getExtensionPointRegistry(); |
| FactoryExtensionPoint modelFactories = registry.getExtensionPoint(FactoryExtensionPoint.class); |
| JavaInterfaceFactory javaInterfaceFactory = (JavaInterfaceFactory)modelFactories.getFactory(JavaInterfaceFactory.class); |
| JavaInterfaceContract interfaceContract = javaInterfaceFactory.createJavaInterfaceContract(); |
| try { |
| interfaceContract.setInterface(javaInterfaceFactory.createJavaInterface(AsyncResponseService.class)); |
| } catch (InvalidInterfaceException e1) { |
| // Nothing to do here - will not happen |
| } // end try |
| reference.setInterfaceContract(interfaceContract); |
| String referenceName = endpoint.getService().getName() + "_asyncCallback"; |
| reference.setName(referenceName); |
| reference.setForCallback(true); |
| // Add in "implementation" reference (really a dummy, but with correct interface) |
| Reference implReference = assemblyFactory.createReference(); |
| implReference.setInterfaceContract(interfaceContract); |
| implReference.setName(referenceName); |
| implReference.setForCallback(true); |
| |
| reference.setReference(implReference); |
| // Set the created ComponentReference into the EPR |
| epr.setReference(reference); |
| |
| // Create a binding |
| Binding binding = createMatchingBinding( endpoint.getBinding(), (RuntimeComponent)endpoint.getComponent(), reference, registry ); |
| epr.setBinding(binding); |
| |
| // Need to establish policies here (binding has some...) |
| epr.getRequiredIntents().addAll( endpoint.getRequiredIntents() ); |
| epr.getPolicySets().addAll( endpoint.getPolicySets() ); |
| |
| // Attach a dummy endpoint to the epr |
| RuntimeEndpoint ep = (RuntimeEndpoint)assemblyFactory.createEndpoint(); |
| ep.setUnresolved(false); |
| epr.setTargetEndpoint(ep); |
| //epr.setStatus(EndpointReference.Status.RESOLVED_BINDING); |
| epr.setStatus(EndpointReference.Status.WIRED_TARGET_FOUND_AND_MATCHED); |
| epr.setUnresolved(false); |
| |
| // Set the URI for the EPR |
| String eprURI = endpoint.getComponent().getName() + "#reference-binding(" + referenceName + "/" + referenceName + ")"; |
| epr.setURI(eprURI); |
| |
| return epr; |
| } // end method RuntimeEndpointReference |
| |
| private boolean asyncCallbackExists( RuntimeEndpoint endpoint ) { |
| if( endpoint.getCallbackEndpointReferences().isEmpty() ) return false; |
| return true; |
| } // end method asyncCallbackExists |
| |
| /** |
| * Create a matching binding to a supplied binding |
| * - the matching binding has the same binding type, but is for the supplied component and service |
| * @param matchBinding - the binding to match |
| * @param component - the component |
| * @param service - the service |
| * @param registry - registry for extensions |
| * @return - the matching binding, or null if it could not be created |
| */ |
| @SuppressWarnings("unchecked") |
| private Binding createMatchingBinding( Binding matchBinding, RuntimeComponent component, |
| ComponentReference reference, ExtensionPointRegistry registry ) { |
| // Since there is no simple way to obtain a Factory for a binding where the type is not known ahead of |
| // time, the process followed here is to generate the <binding.xxx/> XML element from the binding type QName |
| // and then read the XML using the processor for that XML... |
| QName bindingName = matchBinding.getType(); |
| String bindingXML = "<ns1:" + bindingName.getLocalPart() + " xmlns:ns1='" + bindingName.getNamespaceURI() + "'/>"; |
| |
| StAXArtifactProcessorExtensionPoint processors = registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class); |
| StAXArtifactProcessor<?> processor = (StAXArtifactProcessor<?>)processors.getProcessor(bindingName); |
| |
| FactoryExtensionPoint modelFactories = registry.getExtensionPoint(FactoryExtensionPoint.class); |
| ValidatingXMLInputFactory inputFactory = modelFactories.getFactory(ValidatingXMLInputFactory.class); |
| StreamSource source = new StreamSource( new StringReader(bindingXML) ); |
| |
| ProcessorContext context = new ProcessorContext(); |
| try { |
| XMLStreamReader reader = inputFactory.createXMLStreamReader(source); |
| reader.next(); |
| Binding newBinding = (Binding) processor.read(reader, context ); |
| newBinding.setName(reference.getName()); |
| |
| // Create a URI address for the callback based on the Component_Name/Reference_Name pattern |
| //String callbackURI = "/" + component.getName() + "/" + reference.getName(); |
| //newBinding.setURI(callbackURI); |
| |
| BuilderExtensionPoint builders = registry.getExtensionPoint(BuilderExtensionPoint.class); |
| BindingBuilder builder = builders.getBindingBuilder(newBinding.getType()); |
| if (builder != null) { |
| org.apache.tuscany.sca.assembly.builder.BuilderContext builderContext = new BuilderContext(registry); |
| builder.build(component, reference, newBinding, builderContext, true); |
| } // end if |
| |
| return newBinding; |
| } catch (ContributionReadException e) { |
| e.printStackTrace(); |
| } catch (XMLStreamException e) { |
| e.printStackTrace(); |
| } |
| |
| return null; |
| } // end method createMatchingBinding |
| |
| /** |
| * Gets a RuntimeAssemblyFactory from the CompositeContext |
| * @param compositeContext |
| * @return the RuntimeAssemblyFactory |
| */ |
| private RuntimeAssemblyFactory getAssemblyFactory( CompositeContext compositeContext ) { |
| ExtensionPointRegistry registry = compositeContext.getExtensionPointRegistry(); |
| FactoryExtensionPoint modelFactories = registry.getExtensionPoint(FactoryExtensionPoint.class); |
| return (RuntimeAssemblyFactory)modelFactories.getFactory(AssemblyFactory.class); |
| } // end method RuntimeAssemblyFactory |
| |
| /** |
| * Check that endpoint has compatible interface at the component and binding ends. |
| * The user can specify the interfaces at both ends so there is a danger that they won't be compatible. |
| */ |
| public void validateServiceInterfaceCompatibility() { |
| |
| InterfaceContract serviceContract = getComponentServiceInterfaceContract(); |
| InterfaceContract bindingContract = getBindingInterfaceContract(); |
| |
| if ((serviceContract != bindingContract) && |
| (serviceContract != null) && (bindingContract != null)) { |
| |
| boolean bindingHasCallback = bindingContract.getCallbackInterface() != null; |
| |
| try { |
| |
| // Use the normalized contract if the interface types are different or if |
| // a normalized contract has been previously generate, for example, by virtue |
| // of finding a JAXWS annotation on a Java class that references a WSDL file |
| if (serviceContract.getClass() != bindingContract.getClass() || |
| serviceContract.getNormalizedWSDLContract() != null || |
| bindingContract.getNormalizedWSDLContract() != null) { |
| interfaceContractMapper.checkCompatibility(getGeneratedWSDLContract(serviceContract), |
| getGeneratedWSDLContract(bindingContract), |
| Compatibility.SUBSET, |
| !bindingHasCallback, // ignore callbacks if binding doesn't have one |
| false); |
| } else { |
| interfaceContractMapper.checkCompatibility(serviceContract, |
| bindingContract, |
| Compatibility.SUBSET, |
| !bindingHasCallback, // ignore callbacks if binding doesn't have one |
| false); |
| } |
| } catch (Exception ex){ |
| throw new ServiceRuntimeException("Component " + |
| this.getComponent().getName() + |
| " Service " + |
| getService().getName() + |
| " interface is incompatible with the interface of the service binding - " + |
| getBinding().getName() + |
| " - " + |
| ex.getMessage() + |
| " - [" + this.toString() + "]"); |
| } |
| } |
| |
| } |
| |
| private void initServiceBindingInvocationChains() { |
| |
| // add the binding interceptors to the service binding wire |
| ServiceBindingProvider provider = getBindingProvider(); |
| if ((provider != null) && (provider instanceof EndpointProvider)) { |
| ((EndpointProvider)provider).configure(); |
| } |
| |
| // add the policy interceptors to the service binding wire |
| List<PolicyProvider> pps = getPolicyProviders(); |
| if (pps != null) { |
| for (PolicyProvider p : pps) { |
| Interceptor interceptor = p.createBindingInterceptor(); |
| if (interceptor != null) { |
| bindingInvocationChain.addInterceptor(interceptor); |
| } // end if |
| } // end for |
| } // end if |
| |
| // This is strategically placed before the RuntimeInvoker is added to the end of the |
| // binding chain as the RuntimeInvoker doesn't need to take part in the response |
| // processing and doesn't implement InvokerAsyncResponse |
| ServiceBindingProvider serviceBindingProvider = getBindingProvider(); |
| if (isAsyncInvocation() && |
| serviceBindingProvider instanceof EndpointAsyncProvider && |
| ((EndpointAsyncProvider)serviceBindingProvider).supportsNativeAsync()){ |
| // fix up the invocation chains to point back to the |
| // binding chain so that async response messages |
| // are processed correctly |
| for (InvocationChain chain : getInvocationChains()){ |
| Invoker invoker = chain.getHeadInvoker(); |
| ((InterceptorAsync)invoker).setPrevious((InvokerAsyncResponse)bindingInvocationChain.getTailInvoker()); |
| } // end for |
| |
| // fix up the binding chain response path to point back to the |
| // binding provided async response handler |
| EndpointAsyncProvider asyncEndpointProvider = (EndpointAsyncProvider)serviceBindingProvider; |
| InvokerAsyncResponse asyncResponseInvoker = asyncEndpointProvider.createAsyncResponseInvoker(); |
| ((InterceptorAsync)bindingInvocationChain.getHeadInvoker()).setPrevious(asyncResponseInvoker); |
| } // end if |
| |
| // Add the runtime invoker to the end of the binding chain. |
| // It mediates between the binding chain and selects the |
| // correct invocation chain based on the operation that's |
| // been selected |
| bindingInvocationChain.addInvoker(invoker); |
| |
| } // end method initServiceBindingInvocationChains |
| |
| /** |
| * Add the interceptor for a binding |
| * |
| * @param reference |
| * @param binding |
| * @param chain |
| * @param operation |
| */ |
| private void addServiceBindingInterceptor(InvocationChain chain, Operation operation) { |
| List<PolicyProvider> pps = getPolicyProviders(); |
| if (pps != null) { |
| for (PolicyProvider p : pps) { |
| Interceptor interceptor = p.createInterceptor(operation); |
| if (interceptor != null) { |
| chain.addInterceptor(interceptor); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Add a non-blocking interceptor if the service binding needs it |
| * |
| * @param service |
| * @param binding |
| * @param chain |
| */ |
| private void addNonBlockingInterceptor(InvocationChain chain) { |
| ServiceBindingProvider provider = getBindingProvider(); |
| if (provider != null) { |
| if (!provider.supportsOneWayInvocation()) { |
| chain.addInterceptor(Phase.SERVICE, new NonBlockingInterceptor(workScheduler)); |
| } |
| } |
| } |
| |
| /** |
| * Add the interceptor for a component implementation |
| * |
| * @param component |
| * @param service |
| * @param chain |
| * @param operation |
| */ |
| private void addImplementationInterceptor(Component component, |
| ComponentService service, |
| InvocationChain chain, |
| Operation operation) { |
| |
| if (service.getService() instanceof CompositeService) { |
| CompositeService compositeService = (CompositeService)service.getService(); |
| component = getPromotedComponent(compositeService); |
| service = getPromotedComponentService(compositeService); |
| } |
| |
| ImplementationProvider provider = ((RuntimeComponent)component).getImplementationProvider(); |
| |
| if (provider != null) { |
| Invoker invoker = null; |
| RuntimeComponentService runtimeService = (RuntimeComponentService)service; |
| if (runtimeService.getName().endsWith("_asyncCallback")){ |
| if (provider instanceof ImplementationAsyncProvider){ |
| invoker = (Invoker)((ImplementationAsyncProvider)provider).createAsyncResponseInvoker(operation); |
| } else { |
| // TODO - This should be an error but taking account of the |
| // existing non-native async support |
| invoker = provider.createInvoker((RuntimeComponentService)service, operation); |
| /* |
| throw new ServiceRuntimeException("Component " + |
| this.getComponent().getName() + |
| " Service " + |
| getService().getName() + |
| " implementation provider doesn't implement ImplementationAsyncProvider but the implementation uses a " + |
| "refrence interface with the asyncInvocation intent set" + |
| " - [" + this.toString() + "]"); |
| */ |
| } |
| } else if (isAsyncInvocation() && |
| provider instanceof ImplementationAsyncProvider){ |
| invoker = (Invoker)((ImplementationAsyncProvider)provider).createAsyncInvoker((RuntimeComponentService)service, operation); |
| } else { |
| invoker = provider.createInvoker((RuntimeComponentService)service, operation); |
| } |
| chain.addInvoker(invoker); |
| } |
| |
| List<PolicyProvider> pps = ((RuntimeComponent)component).getPolicyProviders(); |
| if (pps != null) { |
| for (PolicyProvider p : pps) { |
| Interceptor interceptor = p.createInterceptor(operation); |
| if (interceptor != null) { |
| chain.addInterceptor(interceptor); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @see java.lang.Object#clone() |
| */ |
| @Override |
| public Object clone() throws CloneNotSupportedException { |
| RuntimeEndpointImpl copy = (RuntimeEndpointImpl)super.clone(); |
| copy.invoker = new RuntimeInvoker(registry, copy); |
| return copy; |
| } |
| |
| /** |
| * Follow a service promotion chain down to the inner most (non composite) |
| * component service. |
| * |
| * @param topCompositeService |
| * @return |
| */ |
| private ComponentService getPromotedComponentService(CompositeService compositeService) { |
| ComponentService componentService = compositeService.getPromotedService(); |
| if (componentService != null) { |
| Service service = componentService.getService(); |
| if (componentService.getName() != null && service instanceof CompositeService) { |
| |
| // Continue to follow the service promotion chain |
| return getPromotedComponentService((CompositeService)service); |
| |
| } else { |
| |
| // Found a non-composite service |
| return componentService; |
| } |
| } else { |
| |
| // No promoted service |
| return null; |
| } |
| } |
| |
| /** |
| * Follow a service promotion chain down to the innermost (non-composite) component. |
| * |
| * @param compositeService |
| * @return |
| */ |
| private Component getPromotedComponent(CompositeService compositeService) { |
| ComponentService componentService = compositeService.getPromotedService(); |
| if (componentService != null) { |
| Service service = componentService.getService(); |
| if (componentService.getName() != null && service instanceof CompositeService) { |
| |
| // Continue to follow the service promotion chain |
| return getPromotedComponent((CompositeService)service); |
| |
| } else { |
| |
| // Found a non-composite service |
| return compositeService.getPromotedComponent(); |
| } |
| } else { |
| |
| // No promoted service |
| return null; |
| } |
| } |
| |
| public synchronized ServiceBindingProvider getBindingProvider() { |
| resolve(); |
| if (bindingProvider == null) { |
| BindingProviderFactory factory = |
| (BindingProviderFactory)providerFactories.getProviderFactory(getBinding().getClass()); |
| if (factory == null) { |
| throw new ServiceRuntimeException("No provider factory is registered for binding " + getBinding() |
| .getType()); |
| } |
| this.bindingProvider = factory.createServiceBindingProvider(this); |
| } |
| return bindingProvider; |
| } |
| |
| public synchronized List<PolicyProvider> getPolicyProviders() { |
| resolve(); |
| if (policyProviders == null) { |
| policyProviders = new ArrayList<PolicyProvider>(); |
| for (PolicyProviderFactory factory : providerFactories.getPolicyProviderFactories()) { |
| PolicyProvider provider = factory.createServicePolicyProvider(this); |
| if (provider != null) { |
| policyProviders.add(provider); |
| } |
| } |
| } |
| return policyProviders; |
| } |
| |
| public void setBindingProvider(ServiceBindingProvider provider) { |
| this.bindingProvider = provider; |
| } |
| |
| public Contract getContract() { |
| return getService(); |
| } |
| |
| public CompositeContext getCompositeContext() { |
| return compositeContext; |
| } |
| |
| @Override |
| protected void reset() { |
| super.reset(); |
| this.xml = null; |
| } |
| |
| @Override |
| protected synchronized void resolve() { |
| if (xml != null && component == null) { |
| if (compositeContext == null) { |
| compositeContext = CompositeContext.getCurrentCompositeContext(); |
| if (compositeContext != null) { |
| bind(compositeContext); |
| } |
| } // end if |
| if (serializer != null) { |
| RuntimeEndpointImpl ep = (RuntimeEndpointImpl)serializer.readEndpoint(xml); |
| copyFrom(ep); |
| } else { |
| // In this case, we assume that we're running on a detached (non Tuscany) thread and |
| // as a result we need to connect back to the Tuscany environment... |
| ExtensionPointRegistry registry = ExtensionPointRegistryLocator.getExtensionPointRegistry(); |
| if( registry != null ) { |
| this.registry = registry; |
| UtilityExtensionPoint utilities = registry.getExtensionPoint(UtilityExtensionPoint.class); |
| this.interfaceContractMapper = utilities.getUtility(InterfaceContractMapper.class); |
| this.serializer = utilities.getUtility(EndpointSerializer.class); |
| RuntimeEndpointImpl ep = (RuntimeEndpointImpl)serializer.readEndpoint(xml); |
| // Find the actual Endpoint in the DomainRegistry |
| ep = findActualEP( ep, registry ); |
| if( ep != null ){ |
| copyFrom( ep ); |
| } // end if |
| } // end if |
| } // end if |
| setNormalizedWSDLContract(); |
| } // end if |
| super.resolve(); |
| } // end method resolve |
| |
| /** |
| * Find the actual Endpoint in the DomainRegistry which corresponds to the configuration described |
| * in a deserialized Endpoint |
| * @param ep The deserialized endpoint |
| * @param registry - the main extension point Registry |
| * @return the corresponding Endpoint from the DomainRegistry, or null if no match can be found |
| */ |
| private RuntimeEndpointImpl findActualEP(RuntimeEndpointImpl ep, |
| ExtensionPointRegistry registry) { |
| DomainRegistry domainRegistry = getEndpointRegistry( registry ); |
| |
| if( domainRegistry == null ) return null; |
| |
| for( Endpoint endpoint : domainRegistry.findEndpoint(ep.getURI()) ) { |
| // TODO: For the present, simply return the first matching endpoint |
| return (RuntimeEndpointImpl) endpoint; |
| } // end for |
| |
| return null; |
| } // end method findActualEP |
| |
| /** |
| * Get the DomainRegistry |
| * @param registry - the ExtensionPoint registry |
| * @return the DomainRegistry - will be null if the DomainRegistry cannot be found |
| */ |
| private DomainRegistry getEndpointRegistry( ExtensionPointRegistry registry) { |
| DomainRegistryFactory domainRegistryFactory = ExtensibleDomainRegistryFactory.getInstance(registry); |
| |
| if( domainRegistryFactory == null ) return null; |
| |
| // TODO: For the moment, just use the first (and only!) DomainRegistry... |
| DomainRegistry domainRegistry = (DomainRegistry) domainRegistryFactory.getEndpointRegistries().toArray()[0]; |
| |
| return domainRegistry; |
| } // end method |
| |
| public InterfaceContract getBindingInterfaceContract() { |
| resolve(); |
| if (bindingInterfaceContract != null) { |
| return bindingInterfaceContract; |
| } |
| bindingInterfaceContract = getBindingProvider().getBindingInterfaceContract(); |
| if (bindingInterfaceContract == null) { |
| bindingInterfaceContract = getComponentServiceInterfaceContract(); |
| } |
| if (bindingInterfaceContract == null) { |
| bindingInterfaceContract = getComponentTypeServiceInterfaceContract(); |
| } |
| return bindingInterfaceContract; |
| } |
| |
| public InterfaceContract getComponentTypeServiceInterfaceContract() { |
| resolve(); |
| if (serviceInterfaceContract != null) { |
| return serviceInterfaceContract; |
| } |
| if (service == null) { |
| return getComponentServiceInterfaceContract(); |
| } |
| serviceInterfaceContract = getLeafContract(service).getInterfaceContract(); |
| if (serviceInterfaceContract == null) { |
| serviceInterfaceContract = getComponentServiceInterfaceContract(); |
| } |
| return serviceInterfaceContract; |
| } |
| |
| public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { |
| this.uri = in.readUTF(); |
| this.xml = in.readUTF(); |
| this.wsdl = in.readUTF(); |
| } |
| |
| public void writeExternal(ObjectOutput out) throws IOException { |
| out.writeUTF(getURI()); |
| if (serializer == null && xml != null) { |
| out.writeUTF(xml); |
| } else { |
| if (serializer != null) { |
| out.writeUTF(serializer.write(this)); |
| } else { |
| throw new IllegalStateException("No serializer is configured"); |
| } |
| } |
| |
| if (wsdl == null) { |
| wsdl = getWsdl(); |
| } |
| out.writeUTF(wsdl); |
| } |
| |
| public String getAsXML() { |
| if (xml == null) { |
| this.xml = serializer.write(this); |
| } |
| return xml; |
| } |
| |
| private String getWsdl() { |
| InterfaceContract ic = getComponentServiceInterfaceContract(); |
| if (ic == null || ic.getInterface() == null || !!!ic.getInterface().isRemotable()) { |
| return ""; |
| } |
| WSDLInterfaceContract wsdlIC = (WSDLInterfaceContract)getGeneratedWSDLContract(getComponentServiceInterfaceContract()); |
| if (wsdlIC == null) { |
| return ""; |
| } |
| WSDLInterface wsdl = (WSDLInterface)wsdlIC.getInterface(); |
| WSDLDefinition d = wsdl.getWsdlDefinition(); |
| ByteArrayOutputStream outStream = new ByteArrayOutputStream(); |
| try { |
| WSDLWriter writer = javax.wsdl.factory.WSDLFactory.newInstance().newWSDLWriter(); |
| writer.writeWSDL(d.getDefinition(), outStream); |
| } catch (Exception e){ |
| throw new RuntimeException(e); |
| } |
| return outStream.toString(); |
| } |
| |
| private void setNormalizedWSDLContract() { |
| if (wsdl == null || wsdl.length() < 1) { |
| return; |
| } |
| InterfaceContract ic = getComponentServiceInterfaceContract(); |
| if (ic != null) { |
| // ic.setNormalizedWSDLContract(WSDLHelper.createWSDLInterfaceContract(registry, wsdl)); |
| } |
| } |
| |
| public InterfaceContract getGeneratedWSDLContract(InterfaceContract interfaceContract) { |
| |
| if ( interfaceContract.getNormalizedWSDLContract() == null){ |
| if (getComponentServiceInterfaceContract() instanceof JavaInterfaceContract){ |
| if (contractBuilder == null){ |
| throw new ServiceRuntimeException("Contract builder not found while calculating WSDL contract for " + this.toString()); |
| } |
| contractBuilder.build(interfaceContract, null); |
| } |
| } |
| |
| return interfaceContract.getNormalizedWSDLContract(); |
| } |
| |
| @Override |
| public RuntimeEndpoint getDelegateEndpoint() { |
| return delegateEndpoint; |
| } |
| |
| @Override |
| public void setDelegateEndpoint(RuntimeEndpoint delegateEndpoint) { |
| this.delegateEndpoint = delegateEndpoint; |
| } |
| } |
