| /* |
| * 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.invocation.impl; |
| |
| import java.beans.Introspector; |
| import java.beans.PropertyDescriptor; |
| import java.io.StringReader; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.ParameterizedType; |
| import java.lang.reflect.Type; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.ExecutionException; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.Future; |
| import java.util.concurrent.TimeUnit; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.stream.XMLStreamReader; |
| import javax.xml.transform.stream.StreamSource; |
| import javax.xml.ws.AsyncHandler; |
| import javax.xml.ws.Response; |
| |
| import org.apache.tuscany.sca.assembly.AssemblyFactory; |
| import org.apache.tuscany.sca.assembly.Binding; |
| import org.apache.tuscany.sca.assembly.ComponentService; |
| import org.apache.tuscany.sca.assembly.Endpoint; |
| import org.apache.tuscany.sca.assembly.Implementation; |
| 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.xml.Constants; |
| 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.FactoryExtensionPoint; |
| import org.apache.tuscany.sca.core.UtilityExtensionPoint; |
| import org.apache.tuscany.sca.core.assembly.RuntimeAssemblyFactory; |
| import org.apache.tuscany.sca.core.invocation.AsyncFaultWrapper; |
| import org.apache.tuscany.sca.core.invocation.AsyncResponseException; |
| import org.apache.tuscany.sca.core.invocation.AsyncResponseHandler; |
| import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException; |
| import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceContract; |
| import org.apache.tuscany.sca.interfacedef.java.JavaInterfaceFactory; |
| import org.apache.tuscany.sca.interfacedef.util.FaultException; |
| import org.apache.tuscany.sca.interfacedef.util.WrapperInfo; |
| import org.apache.tuscany.sca.invocation.InvocationChain; |
| import org.apache.tuscany.sca.invocation.MessageFactory; |
| import org.apache.tuscany.sca.policy.Intent; |
| import org.apache.tuscany.sca.provider.PolicyProvider; |
| import org.apache.tuscany.sca.provider.ServiceBindingProvider; |
| import org.apache.tuscany.sca.runtime.Invocable; |
| import org.apache.tuscany.sca.runtime.RuntimeComponent; |
| import org.apache.tuscany.sca.runtime.RuntimeEndpoint; |
| import org.apache.tuscany.sca.runtime.RuntimeEndpointReference; |
| import org.apache.tuscany.sca.work.WorkScheduler; |
| import org.oasisopen.sca.ServiceReference; |
| import org.oasisopen.sca.ServiceRuntimeException; |
| |
| /** |
| * An InvocationHandler which deals with JAXWS-defined asynchronous client Java API method calls |
| * |
| * 2 asynchronous mappings exist for any given synchronous service operation, as shown in this example: |
| * public interface StockQuote { |
| * float getPrice(String ticker); |
| * Response<Float> getPriceAsync(String ticker); |
| * Future<?> getPriceAsync(String ticker, AsyncHandler<Float> handler); |
| * } |
| * |
| * - the second method is called the "polling method", since the returned Response<?> object permits |
| * the client to poll to see if the async call has completed |
| * - the third method is called the "async callback method", since in this case the client application can specify |
| * a callback operation that is automatically called when the async call completes |
| */ |
| public class AsyncJDKInvocationHandler extends JDKInvocationHandler { |
| |
| private static final long serialVersionUID = 1L; |
| |
| private static int invocationCount = 10; // # of threads to use |
| private static long maxWaitTime = 30; // Max wait time for completion = 30sec |
| |
| // Run the async service invocations using a ThreadPoolExecutor |
| private ExecutorService theExecutor; |
| |
| public AsyncJDKInvocationHandler(ExtensionPointRegistry registry, |
| MessageFactory messageFactory, |
| ServiceReference<?> callableReference) { |
| super(messageFactory, callableReference); |
| initExecutorService(registry); |
| } |
| |
| public AsyncJDKInvocationHandler(ExtensionPointRegistry registry, |
| MessageFactory messageFactory, |
| Class<?> businessInterface, |
| Invocable source) { |
| super(messageFactory, businessInterface, source); |
| initExecutorService(registry); |
| } |
| |
| private final void initExecutorService(ExtensionPointRegistry registry) { |
| UtilityExtensionPoint utilities = registry.getExtensionPoint(UtilityExtensionPoint.class); |
| WorkScheduler scheduler = utilities.getUtility(WorkScheduler.class); |
| theExecutor = scheduler.getExecutorService(); |
| |
| /* |
| synchronized (AsyncJDKInvocationHandler.class) { |
| theExecutor = utilities.getUtility(ExecutorService.class); |
| if (theExecutor == null) { |
| theExecutor = |
| new ThreadPoolExecutor(invocationCount, invocationCount, maxWaitTime, TimeUnit.SECONDS, |
| new ArrayBlockingQueue<Runnable>(invocationCount)); |
| utilities.addUtility(ExecutorService.class, theExecutor); |
| } |
| } |
| */ |
| } |
| |
| /** |
| * Perform the invocation of the operation |
| * - provides support for all 3 forms of client method: synchronous, polling and async callback |
| */ |
| @Override |
| public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { |
| |
| // force the bind of the reference so that we can look at the |
| // target contract to see if it's asynchronous |
| source.getInvocationChains(); |
| |
| if (isAsyncCallback(method)) { |
| return doInvokeAsyncCallback(proxy, method, args); |
| } else if (isAsyncPoll(method)) { |
| return doInvokeAsyncPoll(proxy, method, args); |
| } else { |
| // Regular synchronous method call |
| return doInvokeSync(proxy, method, args); |
| } |
| } |
| |
| /** |
| * Indicates if a supplied method has the form of an async callback method |
| * @param method - the method |
| * @return - true if the method has the form of an async callback |
| */ |
| protected boolean isAsyncCallback(Method method) { |
| if (method.getName().endsWith("Async") && (method.getReturnType() == Future.class)) { |
| if (method.getParameterTypes().length > 0) { |
| return method.getParameterTypes()[method.getParameterTypes().length - 1] == AsyncHandler.class; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Indicates is a supplied method has the form of an async polling method |
| * @param method - the method |
| * @return - true if the method has the form of an async polling method |
| */ |
| protected boolean isAsyncPoll(Method method) { |
| return method.getName().endsWith("Async") && (method.getReturnType() == Response.class); |
| } |
| |
| /** |
| * Invoke an async polling method |
| * @param proxy - the reference proxy |
| * @param asyncMethod - the async method to invoke |
| * @param args - array of input arguments to the method |
| * @return - the Response<?> object that is returned to the client application, typed by the |
| * type of the response |
| */ |
| @SuppressWarnings("unchecked") |
| protected Response doInvokeAsyncPoll(Object proxy, Method asyncMethod, Object[] args) { |
| Method method = getNonAsyncMethod(asyncMethod); |
| Class<?> returnType = method.getReturnType(); |
| // Allocate the Future<?> / Response<?> object - note: Response<?> is a subclass of Future<?> |
| AsyncInvocationFutureImpl future = AsyncInvocationFutureImpl.newInstance(returnType, getInterfaceClassloader()); |
| try { |
| invokeAsync(proxy, method, args, future, asyncMethod); |
| } catch (Exception e) { |
| future.setFault(new AsyncFaultWrapper(e)); |
| } catch (Throwable t) { |
| Exception e = |
| new ServiceRuntimeException("Received Throwable: " + t.getClass().getName() |
| + " when invoking: " |
| + asyncMethod.getName(), t); |
| future.setFault(new AsyncFaultWrapper(e)); |
| } // end try |
| return future; |
| } // end method doInvokeAsyncPoll |
| |
| /** |
| * Provide a synchronous invocation of a service operation that is either synchronous or asynchronous |
| * @return |
| */ |
| protected Object doInvokeSync(Object proxy, Method method, Object[] args) throws Throwable { |
| if (isAsyncInvocation(source)) { |
| // Target service is asynchronous |
| Class<?> returnType = method.getReturnType(); |
| AsyncInvocationFutureImpl future = |
| AsyncInvocationFutureImpl.newInstance(returnType, getInterfaceClassloader()); |
| invokeAsync(proxy, method, args, future, method); |
| // Wait for some maximum time for the result - 1000 seconds here |
| // Really, if the service is async, the client should use async client methods to invoke the service |
| // - and be prepared to wait a *really* long time |
| Object response = null; |
| try { |
| response = future.get(1000, TimeUnit.SECONDS); |
| } catch (ExecutionException ex) { |
| throw ex.getCause(); |
| } |
| return response; |
| } else { |
| // Target service is not asynchronous, so perform sync invocation |
| return super.invoke(proxy, method, args); |
| } // end if |
| } // end method doInvokeSync |
| |
| /** |
| * Invoke an async callback method - note that this form of the async client API has as its final parameter |
| * an AsyncHandler method, used for callbacks to the client code |
| * @param proxy - the reference proxy |
| * @param asyncMethod - the async method to invoke |
| * @param args - array of input arguments to the method |
| * @return - the Future<?> object that is returned to the client application, typed by the type of |
| * the response |
| */ |
| @SuppressWarnings("unchecked") |
| private Object doInvokeAsyncCallback(final Object proxy, final Method asyncMethod, final Object[] args) |
| throws Exception { |
| Future<Response> future = theExecutor.submit(new Callable<Response>() { |
| |
| @Override |
| public Response call() { |
| AsyncHandler handler = (AsyncHandler)args[args.length - 1]; |
| Response response = doInvokeAsyncPoll(proxy, asyncMethod, Arrays.copyOf(args, args.length - 1)); |
| // Invoke the callback handler, if present |
| if (handler != null) { |
| handler.handleResponse(response); |
| } // end if |
| return response; |
| } |
| }); |
| return future.get(); |
| |
| } // end method doInvokeAsyncCallback |
| |
| /** |
| * Invoke the target (synchronous) method asynchronously |
| * @param proxy - the reference proxy object |
| * @param method - the method to invoke |
| * @param args - arguments for the call |
| * @param future - Future for handling the response |
| * @return - returns the response from the invocation |
| * @throws Throwable - if an exception is thrown during the invocation |
| */ |
| @SuppressWarnings("unchecked") |
| private void invokeAsync(Object proxy, |
| Method method, |
| Object[] args, |
| AsyncInvocationFutureImpl future, |
| Method asyncMethod) throws Throwable { |
| if (source == null) { |
| throw new ServiceRuntimeException("No runtime source is available"); |
| } |
| |
| if (source instanceof RuntimeEndpointReference) { |
| RuntimeEndpointReference epr = (RuntimeEndpointReference)source; |
| if (epr.isOutOfDate()) { |
| epr.rebuild(); |
| chains.clear(); |
| } |
| } // end if |
| |
| InvocationChain chain = getInvocationChain(method, source); |
| |
| if (chain == null) { |
| throw new IllegalArgumentException("No matching operation is found: " + method); |
| } |
| |
| // Organize for an async service |
| RuntimeEndpoint theEndpoint = getAsyncCallback(source); |
| boolean isAsyncService = false; |
| if (theEndpoint != null) { |
| // ... the service is asynchronous ... |
| attachFuture(theEndpoint, future); |
| isAsyncService = true; |
| } else { |
| // ... the service is synchronous ... |
| } // end if |
| |
| // Perform the invocations on separate thread... |
| theExecutor.submit(new separateThreadInvoker(chain, args, source, future, asyncMethod, isAsyncService)); |
| |
| return; |
| } // end method invokeAsync |
| |
| /** |
| * An inner class which acts as a runnable task for invoking services asynchronously on threads that are separate from |
| * those used to execute operations of components |
| * |
| * This supports both synchronous services and asynchronous services |
| */ |
| private class separateThreadInvoker implements Runnable { |
| |
| private AsyncInvocationFutureImpl future; |
| private Method asyncMethod; |
| private InvocationChain chain; |
| private Object[] args; |
| private Invocable invocable; |
| private boolean isAsyncService; |
| |
| public separateThreadInvoker(InvocationChain chain, |
| Object[] args, |
| Invocable invocable, |
| AsyncInvocationFutureImpl future, |
| Method asyncMethod, |
| boolean isAsyncService) { |
| super(); |
| this.chain = chain; |
| this.asyncMethod = asyncMethod; |
| this.args = args; |
| this.invocable = invocable; |
| this.future = future; |
| this.isAsyncService = isAsyncService; |
| } // end constructor |
| |
| public void run() { |
| Object result; |
| |
| try { |
| if (isAsyncService) { |
| invoke(chain, args, invocable, future.getUniqueID()); |
| // The result is returned asynchronously via the future... |
| } else { |
| // ... the service is synchronous ... |
| result = invoke(chain, args, invocable); |
| Type type = null; |
| if (asyncMethod.getReturnType() == Future.class) { |
| // For callback async menthod |
| Type[] types = asyncMethod.getGenericParameterTypes(); |
| if (types.length > 0 && asyncMethod.getParameterTypes()[types.length - 1] == AsyncHandler.class) { |
| // Last paremeter, AsyncHandler<T> |
| type = types[types.length - 1]; |
| } |
| } else if (asyncMethod.getReturnType() == Response.class) { |
| // For the polling method, Response<T> |
| type = asyncMethod.getGenericReturnType(); |
| } |
| if (type instanceof ParameterizedType) { |
| // Check if the parameterized type of Response<T> is a doc-lit-wrapper class |
| Class<?> wrapperClass = (Class<?>)((ParameterizedType)type).getActualTypeArguments()[0]; |
| WrapperInfo wrapperInfo = chain.getSourceOperation().getWrapper(); |
| if (wrapperInfo != null && wrapperInfo.getOutputWrapperClass() == wrapperClass) { |
| Object wrapper = wrapperClass.newInstance(); |
| // Find the 1st matching property |
| for (PropertyDescriptor p : Introspector.getBeanInfo(wrapperClass).getPropertyDescriptors()) { |
| if (p.getWriteMethod() == null) { |
| // There is a "class" property ... |
| continue; |
| } |
| if (p.getWriteMethod().getParameterTypes()[0].isInstance(result)) { |
| p.getWriteMethod().invoke(wrapper, result); |
| result = wrapper; |
| break; |
| } |
| } |
| |
| } |
| } |
| future.setResponse(result); |
| } // end if |
| } catch (ServiceRuntimeException s) { |
| Throwable e = s.getCause(); |
| if (e != null && e instanceof FaultException) { |
| if ("AsyncResponse".equals(e.getMessage())) { |
| // Do nothing... |
| } else { |
| future.setFault(new AsyncFaultWrapper(s)); |
| } // end if |
| } // end if |
| } catch (AsyncResponseException ar) { |
| // do nothing |
| } catch (Throwable t) { |
| System.out.println("Async invoke got exception: " + t.toString()); |
| future.setFault(new AsyncFaultWrapper(t)); |
| } // end try |
| |
| } // end method run |
| |
| } // end class separateThreadInvoker |
| |
| /** |
| * Attaches a future to the callback endpoint - so that the Future is triggered when a response is |
| * received from the asynchronous service invocation associated with the Future |
| * @param endpoint - the async callback endpoint |
| * @param future - the async invocation future to attach |
| */ |
| private void attachFuture(RuntimeEndpoint endpoint, AsyncInvocationFutureImpl<?> future) { |
| Implementation impl = endpoint.getComponent().getImplementation(); |
| AsyncResponseHandlerImpl<?> asyncHandler = (AsyncResponseHandlerImpl<?>)impl; |
| asyncHandler.addFuture(future); |
| } // end method attachFuture |
| |
| /** |
| * Get the async callback endpoint - if not already created, create and start it |
| * @param source - the RuntimeEndpointReference which needs an async callback endpoint |
| * @param future |
| * @return - the RuntimeEndpoint of the async callback |
| */ |
| private RuntimeEndpoint getAsyncCallback(Invocable source) { |
| if (!(source instanceof RuntimeEndpointReference)) |
| return null; |
| RuntimeEndpointReference epr = (RuntimeEndpointReference)source; |
| if (!isAsyncInvocation(epr)) |
| return null; |
| RuntimeEndpoint endpoint; |
| synchronized (epr) { |
| endpoint = (RuntimeEndpoint)epr.getCallbackEndpoint(); |
| // If the async callback endpoint is already created, return it... |
| if (endpoint != null) |
| return endpoint; |
| // Create the endpoint for the async callback |
| endpoint = createAsyncCallbackEndpoint(epr); |
| epr.setCallbackEndpoint(endpoint); |
| } // end synchronized |
| |
| // Activate the new callback endpoint |
| startEndpoint(epr.getCompositeContext(), endpoint); |
| endpoint.getInvocationChains(); |
| |
| return endpoint; |
| } // end method setupAsyncCallback |
| |
| /** |
| * Start the callback endpoint |
| * @param compositeContext - the composite context |
| * @param ep - the endpoint to start |
| */ |
| private void startEndpoint(CompositeContext compositeContext, RuntimeEndpoint ep) { |
| for (PolicyProvider policyProvider : ep.getPolicyProviders()) { |
| policyProvider.start(); |
| } // end for |
| |
| final ServiceBindingProvider bindingProvider = ep.getBindingProvider(); |
| if (bindingProvider != null) { |
| // Allow bindings to add shutdown hooks. Requires RuntimePermission shutdownHooks in policy. |
| AccessController.doPrivileged(new PrivilegedAction<Object>() { |
| public Object run() { |
| bindingProvider.start(); |
| return null; |
| } |
| }); |
| compositeContext.getEndpointRegistry().addEndpoint(ep); |
| } |
| } // end method startEndpoint |
| |
| /** |
| * Create the async callback endpoint for a reference that is going to invoke an asyncInvocation service |
| * @param epr - the RuntimeEndpointReference for which the callback is created |
| * @return - a RuntimeEndpoint representing the callback endpoint |
| */ |
| private RuntimeEndpoint createAsyncCallbackEndpoint(RuntimeEndpointReference epr) { |
| CompositeContext compositeContext = epr.getCompositeContext(); |
| RuntimeAssemblyFactory assemblyFactory = getAssemblyFactory(compositeContext); |
| RuntimeEndpoint endpoint = (RuntimeEndpoint)assemblyFactory.createEndpoint(); |
| endpoint.bind(compositeContext); |
| |
| // Create a pseudo-component and pseudo-service |
| // - need to end with a chain with an invoker into the AsyncCallbackHandler class |
| RuntimeComponent fakeComponent = null; |
| try { |
| fakeComponent = (RuntimeComponent)epr.getComponent().clone(); |
| applyImplementation(fakeComponent); |
| } catch (CloneNotSupportedException e2) { |
| // will not happen |
| } // end try |
| endpoint.setComponent(fakeComponent); |
| |
| // Create pseudo-service |
| ComponentService service = assemblyFactory.createComponentService(); |
| 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(AsyncResponseHandler.class)); |
| } catch (InvalidInterfaceException e1) { |
| // Nothing to do here - will not happen |
| } // end try |
| service.setInterfaceContract(interfaceContract); |
| String serviceName = epr.getReference().getName() + "_asyncCallback"; |
| service.setName(serviceName); |
| endpoint.setService(service); |
| // Set pseudo-service onto the pseudo-component |
| List<ComponentService> services = fakeComponent.getServices(); |
| services.clear(); |
| services.add(service); |
| |
| // Create a binding |
| Binding binding = createMatchingBinding(epr.getBinding(), fakeComponent, service, registry); |
| endpoint.setBinding(binding); |
| |
| // Need to establish policies here (binding has some...) |
| endpoint.getRequiredIntents().addAll(epr.getRequiredIntents()); |
| endpoint.getPolicySets().addAll(epr.getPolicySets()); |
| String epURI = epr.getComponent().getName() + "#service-binding(" + serviceName + "/" + serviceName + ")"; |
| endpoint.setURI(epURI); |
| endpoint.setUnresolved(false); |
| return endpoint; |
| } |
| |
| /** |
| * 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, |
| ComponentService service, |
| 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); |
| |
| // Create a URI address for the callback based on the Component_Name/Reference_Name pattern |
| String callbackURI = "/" + component.getName() + "/" + service.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, service, 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 |
| |
| /** |
| * Applies an AsyncResponseHandlerImpl as the implementation of a RuntimeComponent |
| * - the AsyncResponseHandlerImpl acts as both the implementation class and the implementation provider... |
| * @param component - the component |
| */ |
| private void applyImplementation(RuntimeComponent component) { |
| AsyncResponseHandlerImpl<?> asyncHandler = new AsyncResponseHandlerImpl<Object>(); |
| component.setImplementation(asyncHandler); |
| component.setImplementationProvider(asyncHandler); |
| return; |
| } // end method getImplementationProvider |
| |
| private static QName ASYNC_INVOKE = new QName(Constants.SCA11_NS, "asyncInvocation"); |
| |
| /** |
| * Determines if the service invocation is asynchronous |
| * @param source - the EPR involved in the invocation |
| * @return - true if the invocation is async |
| */ |
| private boolean isAsyncInvocation(Invocable source) { |
| if (!(source instanceof RuntimeEndpointReference)) |
| return false; |
| RuntimeEndpointReference epr = (RuntimeEndpointReference)source; |
| // First check is to see if the EPR itself has the asyncInvocation intent marked |
| for (Intent intent : epr.getRequiredIntents()) { |
| if (intent.getName().equals(ASYNC_INVOKE)) |
| return true; |
| } // end for |
| |
| // Second check is to see if the target service has the asyncInvocation intent marked |
| Endpoint ep = epr.getTargetEndpoint(); |
| for (Intent intent : ep.getRequiredIntents()) { |
| if (intent.getName().equals(ASYNC_INVOKE)) |
| return true; |
| } // end for |
| return false; |
| } // end isAsyncInvocation |
| |
| /** |
| * Return the synchronous method that is the equivalent of an async method |
| * @param asyncMethod - the async method |
| * @return - the equivalent synchronous method |
| */ |
| protected Method getNonAsyncMethod(Method asyncMethod) { |
| String methodName = asyncMethod.getName().substring(0, asyncMethod.getName().length() - 5); |
| for (Method m : businessInterface.getMethods()) { |
| if (methodName.equals(m.getName())) { |
| return m; |
| } |
| } |
| throw new IllegalStateException("No synchronous method matching async method " + asyncMethod.getName()); |
| } // end method getNonAsyncMethod |
| |
| /** |
| * Gets the classloader of the business interface |
| * @return |
| */ |
| private ClassLoader getInterfaceClassloader() { |
| return businessInterface.getClassLoader(); |
| } |
| } |
