private Object invokeSEIMethod(Method method, Object[] args) throws Throwable {
if (log.isDebugEnabled()) {
log.debug("Attempting to invoke SEI Method " + method.getName());
}
OperationDescription operationDesc =
endpointDesc.getEndpointInterfaceDescription().getOperation(method);
// Create and configure the request MessageContext
InvocationContext requestIC = InvocationContextFactory.createInvocationContext(null);
MessageContext request = createRequest(method, args);
request.setEndpointDescription(getEndpointDescription());
request.setOperationDescription(operationDesc);
// Enable MTOM on the Message if the property was set on the SOAPBinding.
Binding bnd = getBinding();
if (bnd != null && bnd instanceof SOAPBinding) {
if (((SOAPBinding)bnd).isMTOMEnabled()) {
Message requestMsg = request.getMessage();
requestMsg.setMTOMEnabled(true);
}
}
/*
* TODO: review: make sure the handlers are set on the InvocationContext
* This implementation of the JAXWS runtime does not use Endpoint, which
* would normally be the place to initialize and store the handler list.
* In lieu of that, we will have to intialize and store them on the
* InvocationContext. also see the InvocationContextFactory. On the client
* side, the binding is not yet set when we call into that factory, so the
* handler list doesn't get set on the InvocationContext object there. Thus
* we gotta do it here.
*/
// be sure to use whatever handlerresolver is registered on the Service
requestIC.setHandlers(bnd.getHandlerChain());
requestIC.setRequestMessageContext(request);
requestIC.setServiceClient(serviceDelegate.getServiceClient(endpointDesc.getPortQName()));
// TODO: Change this to some form of factory so that we can change the IC to
// a more simple one for marshaller/unmarshaller testing.
InvocationController controller = new AxisInvocationController();
// Migrate the properties from the client request context bag to
// the request MessageContext.
ApplicationContextMigratorUtil.performMigrationToMessageContext(
Constants.APPLICATION_CONTEXT_MIGRATOR_LIST_ID,
getRequestContext(), request);
// Check if the call is OneWay, Async or Sync
if (operationDesc.isOneWay()) {
if (log.isDebugEnabled()) {
log.debug("OneWay Call");
}
controller.invokeOneWay(requestIC);
// Check to see if we need to maintain session state
checkMaintainSessionState(request, requestIC);
}
if (method.getReturnType() == Future.class) {
if (log.isDebugEnabled()) {
log.debug("Async Callback");
}
//Get AsyncHandler from Objects and sent that to InvokeAsync
AsyncHandler asyncHandler = null;
for (Object obj : args) {
if (obj != null && AsyncHandler.class.isAssignableFrom(obj.getClass())) {
asyncHandler = (AsyncHandler)obj;
break;
}
}
// Don't allow the invocation to continue if the invocation requires a callback
// object, but none was supplied.
if (asyncHandler == null) {
throw ExceptionFactory
.makeWebServiceException(Messages.getMessage("proxyNullCallback"));
}
AsyncResponse listener = createProxyListener(args, operationDesc);
requestIC.setAsyncResponseListener(listener);
if ((serviceDelegate.getExecutor() != null) &&
(serviceDelegate.getExecutor() instanceof ExecutorService)) {
ExecutorService es = (ExecutorService)serviceDelegate.getExecutor();
if (es.isShutdown()) {
// the executor service is shutdown and won't accept new tasks
// so return an error back to the client
throw ExceptionFactory
.makeWebServiceException(Messages.getMessage("ExecutorShutdown"));
}
}
requestIC.setExecutor(serviceDelegate.getExecutor());
Future<?> future = controller.invokeAsync(requestIC, asyncHandler);
//Check to see if we need to maintain session state
checkMaintainSessionState(request, requestIC);
return future;
}
if (method.getReturnType() == Response.class) {
if (log.isDebugEnabled()) {
log.debug("Async Polling");
}
AsyncResponse listener = createProxyListener(args, operationDesc);
requestIC.setAsyncResponseListener(listener);
requestIC.setExecutor(serviceDelegate.getExecutor());
Response response = controller.invokeAsync(requestIC);
//Check to see if we need to maintain session state
checkMaintainSessionState(request, requestIC);
return response;
}
if (!operationDesc.isOneWay()) {
InvocationContext responseIC = controller.invoke(requestIC);
//Check to see if we need to maintain session state
checkMaintainSessionState(request, requestIC);