| /* |
| * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.xml.internal.ws.client; |
| |
| import com.sun.istack.internal.NotNull; |
| import com.sun.istack.internal.Nullable; |
| import com.sun.xml.internal.stream.buffer.XMLStreamBuffer; |
| import com.sun.xml.internal.ws.addressing.WSEPRExtension; |
| import com.sun.xml.internal.ws.api.BindingID; |
| import com.sun.xml.internal.ws.api.Component; |
| import com.sun.xml.internal.ws.api.ComponentFeature; |
| import com.sun.xml.internal.ws.api.ComponentFeature.Target; |
| import com.sun.xml.internal.ws.api.ComponentRegistry; |
| import com.sun.xml.internal.ws.api.ComponentsFeature; |
| import com.sun.xml.internal.ws.api.EndpointAddress; |
| import com.sun.xml.internal.ws.api.WSBinding; |
| import com.sun.xml.internal.ws.api.WSService; |
| import com.sun.xml.internal.ws.api.addressing.AddressingVersion; |
| import com.sun.xml.internal.ws.api.addressing.WSEndpointReference; |
| import com.sun.xml.internal.ws.api.client.WSPortInfo; |
| import com.sun.xml.internal.ws.api.message.AddressingUtils; |
| import com.sun.xml.internal.ws.api.message.Header; |
| import com.sun.xml.internal.ws.api.message.HeaderList; |
| import com.sun.xml.internal.ws.api.message.MessageHeaders; |
| import com.sun.xml.internal.ws.api.message.Packet; |
| import com.sun.xml.internal.ws.api.model.SEIModel; |
| import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort; |
| import com.sun.xml.internal.ws.api.pipe.ClientTubeAssemblerContext; |
| import com.sun.xml.internal.ws.api.pipe.Engine; |
| import com.sun.xml.internal.ws.api.pipe.Fiber; |
| import com.sun.xml.internal.ws.api.pipe.FiberContextSwitchInterceptorFactory; |
| import com.sun.xml.internal.ws.api.pipe.SyncStartForAsyncFeature; |
| import com.sun.xml.internal.ws.api.pipe.Tube; |
| import com.sun.xml.internal.ws.api.pipe.TubelineAssembler; |
| import com.sun.xml.internal.ws.api.pipe.TubelineAssemblerFactory; |
| import com.sun.xml.internal.ws.api.server.Container; |
| import com.sun.xml.internal.ws.api.server.ContainerResolver; |
| import com.sun.xml.internal.ws.binding.BindingImpl; |
| import com.sun.xml.internal.ws.developer.JAXWSProperties; |
| import com.sun.xml.internal.ws.developer.WSBindingProvider; |
| import com.sun.xml.internal.ws.model.wsdl.WSDLDirectProperties; |
| import com.sun.xml.internal.ws.model.wsdl.WSDLPortProperties; |
| import com.sun.xml.internal.ws.model.wsdl.WSDLProperties; |
| import com.sun.xml.internal.ws.resources.ClientMessages; |
| import com.sun.xml.internal.ws.util.Pool; |
| import com.sun.xml.internal.ws.util.Pool.TubePool; |
| import com.sun.xml.internal.ws.util.RuntimeVersion; |
| import com.sun.xml.internal.ws.wsdl.OperationDispatcher; |
| import com.sun.org.glassfish.gmbal.ManagedObjectManager; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.ws.BindingProvider; |
| import javax.xml.ws.EndpointReference; |
| import javax.xml.ws.RespectBindingFeature; |
| import javax.xml.ws.Response; |
| import javax.xml.ws.WebServiceException; |
| import javax.xml.ws.http.HTTPBinding; |
| import javax.xml.ws.wsaddressing.W3CEndpointReference; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.CopyOnWriteArraySet; |
| import java.util.concurrent.Executor; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| import javax.management.ObjectName; |
| |
| /** |
| * Base class for stubs, which accept method invocations from |
| * client applications and pass the message to a {@link Tube} |
| * for processing. |
| * |
| * <p> |
| * This class implements the management of pipe instances, |
| * and most of the {@link BindingProvider} methods. |
| * |
| * @author Kohsuke Kawaguchi |
| */ |
| public abstract class Stub implements WSBindingProvider, ResponseContextReceiver, ComponentRegistry { |
| /** |
| * Internal flag indicating async dispatch should be used even when the |
| * SyncStartForAsyncInvokeFeature is present on the binding associated |
| * with a stub. There is no type associated with this property on the |
| * request context. Its presence is what triggers the 'prevent' behavior. |
| */ |
| public static final String PREVENT_SYNC_START_FOR_ASYNC_INVOKE = "com.sun.xml.internal.ws.client.StubRequestSyncStartForAsyncInvoke"; |
| |
| /** |
| * Reuse pipelines as it's expensive to create. |
| * <p> |
| * Set to null when {@link #close() closed}. |
| */ |
| private Pool<Tube> tubes; |
| |
| private final Engine engine; |
| |
| /** |
| * The {@link WSServiceDelegate} object that owns us. |
| */ |
| protected final WSServiceDelegate owner; |
| |
| /** |
| * Non-null if this stub is configured to talk to an EPR. |
| * <p> |
| * When this field is non-null, its reference parameters are sent as out-bound headers. |
| * This field can be null even when addressing is enabled, but if the addressing is |
| * not enabled, this field must be null. |
| * <p> |
| * Unlike endpoint address, we are not letting users to change the EPR, |
| * as it contains references to services and so on that we don't want to change. |
| */ |
| protected |
| @Nullable |
| WSEndpointReference endpointReference; |
| |
| protected final BindingImpl binding; |
| |
| protected final WSPortInfo portInfo; |
| |
| /** |
| * represents AddressingVersion on binding if enabled, otherwise null; |
| */ |
| protected AddressingVersion addrVersion; |
| |
| public RequestContext requestContext = new RequestContext(); |
| |
| private final RequestContext cleanRequestContext; |
| |
| /** |
| * {@link ResponseContext} from the last synchronous operation. |
| */ |
| private ResponseContext responseContext; |
| @Nullable |
| protected final WSDLPort wsdlPort; |
| |
| protected QName portname; |
| |
| /** |
| * {@link Header}s to be added to outbound {@link Packet}. |
| * The contents is determined by the user. |
| */ |
| @Nullable |
| private volatile Header[] userOutboundHeaders; |
| |
| private final |
| @NotNull |
| WSDLProperties wsdlProperties; |
| protected OperationDispatcher operationDispatcher = null; |
| private final |
| @NotNull |
| ManagedObjectManager managedObjectManager; |
| private boolean managedObjectManagerClosed = false; |
| |
| private final Set<Component> components = new CopyOnWriteArraySet<Component>(); |
| |
| /** |
| * @param master The created stub will send messages to this pipe. |
| * @param binding As a {@link BindingProvider}, this object will |
| * return this binding from {@link BindingProvider#getBinding()}. |
| * @param defaultEndPointAddress The destination of the message. The actual destination |
| * could be overridden by {@link RequestContext}. |
| * @param epr To create a stub that sends out reference parameters |
| * of a specific EPR, give that instance. Otherwise null. |
| * Its address field will not be used, and that should be given |
| * separately as the <tt>defaultEndPointAddress</tt>. |
| */ |
| @Deprecated |
| protected Stub(WSServiceDelegate owner, Tube master, BindingImpl binding, WSDLPort wsdlPort, EndpointAddress defaultEndPointAddress, @Nullable WSEndpointReference epr) { |
| this(owner, master, null, null, binding, wsdlPort, defaultEndPointAddress, epr); |
| } |
| |
| /** |
| * @param portname The name of this port |
| * @param master The created stub will send messages to this pipe. |
| * @param binding As a {@link BindingProvider}, this object will |
| * return this binding from {@link BindingProvider#getBinding()}. |
| * @param defaultEndPointAddress The destination of the message. The actual destination |
| * could be overridden by {@link RequestContext}. |
| * @param epr To create a stub that sends out reference parameters |
| * of a specific EPR, give that instance. Otherwise null. |
| * Its address field will not be used, and that should be given |
| * separately as the <tt>defaultEndPointAddress</tt>. |
| */ |
| @Deprecated |
| protected Stub(QName portname, WSServiceDelegate owner, Tube master, BindingImpl binding, WSDLPort wsdlPort, EndpointAddress defaultEndPointAddress, @Nullable WSEndpointReference epr) { |
| this(owner, master, null, portname, binding, wsdlPort, defaultEndPointAddress, epr); |
| } |
| |
| /** |
| * @param portInfo PortInfo for this stub |
| * @param binding As a {@link BindingProvider}, this object will |
| * return this binding from {@link BindingProvider#getBinding()}. |
| * @param master The created stub will send messages to this pipe. |
| * @param defaultEndPointAddress The destination of the message. The actual destination |
| * could be overridden by {@link RequestContext}. |
| * @param epr To create a stub that sends out reference parameters |
| * of a specific EPR, give that instance. Otherwise null. |
| * Its address field will not be used, and that should be given |
| * separately as the <tt>defaultEndPointAddress</tt>. |
| */ |
| protected Stub(WSPortInfo portInfo, BindingImpl binding, Tube master,EndpointAddress defaultEndPointAddress, @Nullable WSEndpointReference epr) { |
| this((WSServiceDelegate) portInfo.getOwner(), master, portInfo, null, binding,portInfo.getPort(), defaultEndPointAddress, epr); |
| } |
| |
| /** |
| * @param portInfo PortInfo for this stub |
| * @param binding As a {@link BindingProvider}, this object will |
| * return this binding from {@link BindingProvider#getBinding()}. |
| * @param defaultEndPointAddress The destination of the message. The actual destination |
| * could be overridden by {@link RequestContext}. |
| * @param epr To create a stub that sends out reference parameters |
| * of a specific EPR, give that instance. Otherwise null. |
| * Its address field will not be used, and that should be given |
| * separately as the <tt>defaultEndPointAddress</tt>. |
| */ |
| protected Stub(WSPortInfo portInfo, BindingImpl binding, EndpointAddress defaultEndPointAddress, @Nullable WSEndpointReference epr) { |
| this(portInfo,binding,null, defaultEndPointAddress,epr); |
| |
| } |
| |
| private Stub(WSServiceDelegate owner, @Nullable Tube master, @Nullable WSPortInfo portInfo, QName portname, BindingImpl binding, @Nullable WSDLPort wsdlPort, EndpointAddress defaultEndPointAddress, @Nullable WSEndpointReference epr) { |
| Container old = ContainerResolver.getDefault().enterContainer(owner.getContainer()); |
| try { |
| this.owner = owner; |
| this.portInfo = portInfo; |
| this.wsdlPort = wsdlPort != null ? wsdlPort : (portInfo != null ? portInfo.getPort() : null); |
| this.portname = portname; |
| if (portname == null) { |
| if (portInfo != null) { |
| this.portname = portInfo.getPortName(); |
| } else if (wsdlPort != null) { |
| this.portname = wsdlPort.getName(); |
| } |
| } |
| this.binding = binding; |
| |
| ComponentFeature cf = binding.getFeature(ComponentFeature.class); |
| if (cf != null && Target.STUB.equals(cf.getTarget())) { |
| components.add(cf.getComponent()); |
| } |
| ComponentsFeature csf = binding.getFeature(ComponentsFeature.class); |
| if (csf != null) { |
| for (ComponentFeature cfi : csf.getComponentFeatures()) { |
| if (Target.STUB.equals(cfi.getTarget())) |
| components.add(cfi.getComponent()); |
| } |
| } |
| |
| // if there is an EPR, EPR's address should be used for invocation instead of default address |
| if (epr != null) { |
| this.requestContext.setEndPointAddressString(epr.getAddress()); |
| } else { |
| this.requestContext.setEndpointAddress(defaultEndPointAddress); |
| } |
| this.engine = new Engine(getStringId(), owner.getContainer(), owner.getExecutor()); |
| this.endpointReference = epr; |
| wsdlProperties = (wsdlPort == null) ? new WSDLDirectProperties(owner.getServiceName(), portname) : new WSDLPortProperties(wsdlPort); |
| |
| this.cleanRequestContext = this.requestContext.copy(); |
| |
| // ManagedObjectManager MUST be created before the pipeline |
| // is constructed. |
| |
| managedObjectManager = new MonitorRootClient(this).createManagedObjectManager(this); |
| |
| if (master != null) { |
| this.tubes = new TubePool(master); |
| } else { |
| this.tubes = new TubePool(createPipeline(portInfo, binding)); |
| } |
| |
| addrVersion = binding.getAddressingVersion(); |
| |
| // This needs to happen after createPipeline. |
| // TBD: Check if it needs to happen outside the Stub constructor. |
| managedObjectManager.resumeJMXRegistration(); |
| } finally { |
| ContainerResolver.getDefault().exitContainer(old); |
| } |
| } |
| |
| /** |
| * Creates a new pipeline for the given port name. |
| */ |
| private Tube createPipeline(WSPortInfo portInfo, WSBinding binding) { |
| //Check all required WSDL extensions are understood |
| checkAllWSDLExtensionsUnderstood(portInfo, binding); |
| SEIModel seiModel = null; |
| Class sei = null; |
| if (portInfo instanceof SEIPortInfo) { |
| SEIPortInfo sp = (SEIPortInfo) portInfo; |
| seiModel = sp.model; |
| sei = sp.sei; |
| } |
| BindingID bindingId = portInfo.getBindingId(); |
| |
| TubelineAssembler assembler = TubelineAssemblerFactory.create( |
| Thread.currentThread().getContextClassLoader(), bindingId, owner.getContainer()); |
| if (assembler == null) { |
| throw new WebServiceException("Unable to process bindingID=" + bindingId); // TODO: i18n |
| } |
| return assembler.createClient( |
| new ClientTubeAssemblerContext( |
| portInfo.getEndpointAddress(), |
| portInfo.getPort(), |
| this, binding, owner.getContainer(), ((BindingImpl) binding).createCodec(), seiModel, sei)); |
| } |
| |
| public WSDLPort getWSDLPort() { |
| return wsdlPort; |
| } |
| |
| public WSService getService() { |
| return owner; |
| } |
| |
| public Pool<Tube> getTubes() { |
| return tubes; |
| } |
| |
| /** |
| * Checks only if RespectBindingFeature is enabled |
| * checks if all required wsdl extensions in the |
| * corresponding wsdl:Port are understood when RespectBindingFeature is enabled. |
| * @throws WebServiceException |
| * when any wsdl extension that has wsdl:required=true is not understood |
| */ |
| private static void checkAllWSDLExtensionsUnderstood(WSPortInfo port, WSBinding binding) { |
| if (port.getPort() != null && binding.isFeatureEnabled(RespectBindingFeature.class)) { |
| port.getPort().areRequiredExtensionsUnderstood(); |
| } |
| } |
| |
| @Override |
| public WSPortInfo getPortInfo() { |
| return portInfo; |
| } |
| |
| /** |
| * Nullable when there is no associated WSDL Model |
| * @return |
| */ |
| public |
| @Nullable |
| OperationDispatcher getOperationDispatcher() { |
| if (operationDispatcher == null && wsdlPort != null) { |
| operationDispatcher = new OperationDispatcher(wsdlPort, binding, null); |
| } |
| return operationDispatcher; |
| } |
| |
| /** |
| * Gets the port name that this stub is configured to talk to. |
| * <p> |
| * When {@link #wsdlPort} is non-null, the port name is always |
| * the same as {@link WSDLPort#getName()}, but this method |
| * returns a port name even if no WSDL is available for this stub. |
| */ |
| protected abstract |
| @NotNull |
| QName getPortName(); |
| |
| /** |
| * Gets the service name that this stub is configured to talk to. |
| * <p> |
| * When {@link #wsdlPort} is non-null, the service name is always |
| * the same as the one that's inferred from {@link WSDLPort#getOwner()}, |
| * but this method returns a port name even if no WSDL is available for |
| * this stub. |
| */ |
| protected final |
| @NotNull |
| QName getServiceName() { |
| return owner.getServiceName(); |
| } |
| |
| /** |
| * Gets the {@link Executor} to be used for asynchronous method invocations. |
| * <p> |
| * Note that the value this method returns may different from invocations |
| * to invocations. The caller must not cache. |
| * |
| * @return always non-null. |
| */ |
| public final Executor getExecutor() { |
| return owner.getExecutor(); |
| } |
| |
| /** |
| * Passes a message to a pipe for processing. |
| * <p> |
| * Unlike {@link Tube} instances, |
| * this method is thread-safe and can be invoked from |
| * multiple threads concurrently. |
| * |
| * @param packet The message to be sent to the server |
| * @param requestContext The {@link RequestContext} when this invocation is originally scheduled. |
| * This must be the same object as {@link #requestContext} for synchronous |
| * invocations, but for asynchronous invocations, it needs to be a snapshot |
| * captured at the point of invocation, to correctly satisfy the spec requirement. |
| * @param receiver Receives the {@link ResponseContext}. Since the spec requires |
| * that the asynchronous invocations must not update response context, |
| * depending on the mode of invocation they have to go to different places. |
| * So we take a setter that abstracts that away. |
| */ |
| protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) { |
| packet.isSynchronousMEP = true; |
| packet.component = this; |
| configureRequestPacket(packet, requestContext); |
| Pool<Tube> pool = tubes; |
| if (pool == null) { |
| throw new WebServiceException("close method has already been invoked"); // TODO: i18n |
| } |
| |
| Fiber fiber = engine.createFiber(); |
| configureFiber(fiber); |
| |
| // then send it away! |
| Tube tube = pool.take(); |
| |
| try { |
| return fiber.runSync(tube, packet); |
| } finally { |
| // this allows us to capture the packet even when the call failed with an exception. |
| // when the call fails with an exception it's no longer a 'reply' but it may provide some information |
| // about what went wrong. |
| |
| // note that Packet can still be updated after |
| // ResponseContext is created. |
| Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket(); |
| receiver.setResponseContext(new ResponseContext(reply)); |
| |
| pool.recycle(tube); |
| } |
| } |
| |
| private void configureRequestPacket(Packet packet, RequestContext requestContext) { |
| // fill in Packet |
| packet.proxy = this; |
| packet.handlerConfig = binding.getHandlerConfig(); |
| |
| // to make it multi-thread safe we need to first get a stable snapshot |
| Header[] hl = userOutboundHeaders; |
| if (hl != null) { |
| MessageHeaders mh = packet.getMessage().getHeaders(); |
| for (Header h : hl) { |
| mh.add(h); |
| } |
| } |
| |
| requestContext.fill(packet, (binding.getAddressingVersion() != null)); |
| packet.addSatellite(wsdlProperties); |
| |
| if (addrVersion != null) { |
| // populate request WS-Addressing headers |
| MessageHeaders headerList = packet.getMessage().getHeaders(); |
| AddressingUtils.fillRequestAddressingHeaders(headerList, wsdlPort, binding, packet); |
| |
| |
| // Spec is not clear on if ReferenceParameters are to be added when addressing is not enabled, |
| // but the EPR has ReferenceParameters. |
| // Current approach: Add ReferenceParameters only if addressing enabled. |
| if (endpointReference != null) { |
| endpointReference.addReferenceParametersToList(packet.getMessage().getHeaders()); |
| } |
| } |
| } |
| |
| /** |
| * Passes a message through a {@link Tube}line for processing. The processing happens |
| * asynchronously and when the response is available, Fiber.CompletionCallback is |
| * called. The processing could happen on multiple threads. |
| * |
| * <p> |
| * Unlike {@link Tube} instances, |
| * this method is thread-safe and can be invoked from |
| * multiple threads concurrently. |
| * |
| * @param receiver The {@link Response} implementation |
| * @param request The message to be sent to the server |
| * @param requestContext The {@link RequestContext} when this invocation is originally scheduled. |
| * This must be the same object as {@link #requestContext} for synchronous |
| * invocations, but for asynchronous invocations, it needs to be a snapshot |
| * captured at the point of invocation, to correctly satisfy the spec requirement. |
| * @param completionCallback Once the processing is done, the callback is invoked. |
| */ |
| protected final void processAsync(AsyncResponseImpl<?> receiver, Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) { |
| // fill in Packet |
| request.component = this; |
| configureRequestPacket(request, requestContext); |
| |
| final Pool<Tube> pool = tubes; |
| if (pool == null) { |
| throw new WebServiceException("close method has already been invoked"); // TODO: i18n |
| } |
| |
| final Fiber fiber = engine.createFiber(); |
| configureFiber(fiber); |
| |
| receiver.setCancelable(fiber); |
| |
| // check race condition on cancel |
| if (receiver.isCancelled()) { |
| return; |
| } |
| |
| FiberContextSwitchInterceptorFactory fcsif = owner.getSPI(FiberContextSwitchInterceptorFactory.class); |
| if (fcsif != null) { |
| fiber.addInterceptor(fcsif.create()); |
| } |
| |
| // then send it away! |
| final Tube tube = pool.take(); |
| |
| Fiber.CompletionCallback fiberCallback = new Fiber.CompletionCallback() { |
| @Override |
| public void onCompletion(@NotNull Packet response) { |
| pool.recycle(tube); |
| completionCallback.onCompletion(response); |
| } |
| |
| @Override |
| public void onCompletion(@NotNull Throwable error) { |
| // let's not reuse tubes as they might be in a wrong state, so not |
| // calling pool.recycle() |
| completionCallback.onCompletion(error); |
| } |
| }; |
| |
| // Check for SyncStartForAsyncInvokeFeature |
| |
| fiber.start(tube, request, fiberCallback, |
| getBinding().isFeatureEnabled(SyncStartForAsyncFeature.class) && |
| !requestContext.containsKey(PREVENT_SYNC_START_FOR_ASYNC_INVOKE)); |
| } |
| |
| protected void configureFiber(Fiber fiber) { |
| // no-op in the base class, but can be used by derived classes to configure the Fiber prior |
| // to invocation |
| } |
| |
| private static final Logger monitoringLogger = Logger.getLogger(com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".monitoring"); |
| |
| @Override |
| public void close() { |
| TubePool tp = (TubePool) tubes; |
| if (tp != null) { |
| // multi-thread safety of 'close' needs to be considered more carefully. |
| // some calls might be pending while this method is invoked. Should we |
| // block until they are complete, or should we abort them (but how?) |
| Tube p = tp.takeMaster(); |
| p.preDestroy(); |
| tubes = null; |
| } |
| if (!managedObjectManagerClosed) { |
| try { |
| final ObjectName name = managedObjectManager.getObjectName(managedObjectManager.getRoot()); |
| // The name is null when the MOM is a NOOP. |
| if (name != null) { |
| monitoringLogger.log(Level.INFO, "Closing Metro monitoring root: {0}", name); |
| } |
| managedObjectManager.close(); |
| } catch (java.io.IOException e) { |
| monitoringLogger.log(Level.WARNING, "Ignoring error when closing Managed Object Manager", e); |
| } |
| managedObjectManagerClosed = true; |
| } |
| } |
| |
| @Override |
| public final WSBinding getBinding() { |
| return binding; |
| } |
| |
| @Override |
| public final Map<String, Object> getRequestContext() { |
| return requestContext.asMap(); |
| } |
| |
| public void resetRequestContext() { |
| requestContext = cleanRequestContext.copy(); |
| } |
| |
| @Override |
| public final ResponseContext getResponseContext() { |
| return responseContext; |
| } |
| |
| @Override |
| public void setResponseContext(ResponseContext rc) { |
| this.responseContext = rc; |
| } |
| |
| private String getStringId() { |
| return RuntimeVersion.VERSION + ": Stub for " + getRequestContext().get(BindingProvider.ENDPOINT_ADDRESS_PROPERTY); |
| } |
| |
| @Override |
| public String toString() { |
| return getStringId(); |
| } |
| |
| @Override |
| public final WSEndpointReference getWSEndpointReference() { |
| if (binding.getBindingID().equals(HTTPBinding.HTTP_BINDING)) { |
| throw new java.lang.UnsupportedOperationException( |
| ClientMessages.UNSUPPORTED_OPERATION("BindingProvider.getEndpointReference(Class<T> class)", "XML/HTTP Binding", "SOAP11 or SOAP12 Binding") |
| ); |
| } |
| |
| if (endpointReference != null) { |
| return endpointReference; |
| } |
| |
| String eprAddress = requestContext.getEndpointAddress().toString(); |
| QName portTypeName = null; |
| String wsdlAddress = null; |
| List<WSEndpointReference.EPRExtension> wsdlEPRExtensions = new ArrayList<WSEndpointReference.EPRExtension>(); |
| if (wsdlPort != null) { |
| portTypeName = wsdlPort.getBinding().getPortTypeName(); |
| wsdlAddress = eprAddress + "?wsdl"; |
| |
| //gather EPRExtensions specified in WSDL. |
| try { |
| WSEndpointReference wsdlEpr = wsdlPort.getEPR(); |
| if (wsdlEpr != null) { |
| for (WSEndpointReference.EPRExtension extnEl : wsdlEpr.getEPRExtensions()) { |
| wsdlEPRExtensions.add(new WSEPRExtension( |
| XMLStreamBuffer.createNewBufferFromXMLStreamReader(extnEl.readAsXMLStreamReader()), extnEl.getQName())); |
| } |
| } |
| |
| } catch (XMLStreamException ex) { |
| throw new WebServiceException(ex); |
| } |
| } |
| AddressingVersion av = AddressingVersion.W3C; |
| this.endpointReference = new WSEndpointReference( |
| av, eprAddress, getServiceName(), getPortName(), portTypeName, null, wsdlAddress, null, wsdlEPRExtensions, null); |
| |
| return this.endpointReference; |
| } |
| |
| |
| @Override |
| public final W3CEndpointReference getEndpointReference() { |
| if (binding.getBindingID().equals(HTTPBinding.HTTP_BINDING)) { |
| throw new java.lang.UnsupportedOperationException( |
| ClientMessages.UNSUPPORTED_OPERATION("BindingProvider.getEndpointReference()", "XML/HTTP Binding", "SOAP11 or SOAP12 Binding")); |
| } |
| return getEndpointReference(W3CEndpointReference.class); |
| } |
| |
| @Override |
| public final <T extends EndpointReference> T getEndpointReference(Class<T> clazz) { |
| return getWSEndpointReference().toSpec(clazz); |
| } |
| |
| public |
| @NotNull |
| @Override |
| ManagedObjectManager getManagedObjectManager() { |
| return managedObjectManager; |
| } |
| |
| // |
| // |
| // WSBindingProvider methods |
| // |
| // |
| @Override |
| public final void setOutboundHeaders(List<Header> headers) { |
| if (headers == null) { |
| this.userOutboundHeaders = null; |
| } else { |
| for (Header h : headers) { |
| if (h == null) { |
| throw new IllegalArgumentException(); |
| } |
| } |
| userOutboundHeaders = headers.toArray(new Header[headers.size()]); |
| } |
| } |
| |
| @Override |
| public final void setOutboundHeaders(Header... headers) { |
| if (headers == null) { |
| this.userOutboundHeaders = null; |
| } else { |
| for (Header h : headers) { |
| if (h == null) { |
| throw new IllegalArgumentException(); |
| } |
| } |
| Header[] hl = new Header[headers.length]; |
| System.arraycopy(headers, 0, hl, 0, headers.length); |
| userOutboundHeaders = hl; |
| } |
| } |
| |
| @Override |
| public final List<Header> getInboundHeaders() { |
| return Collections.unmodifiableList(((MessageHeaders) |
| responseContext.get(JAXWSProperties.INBOUND_HEADER_LIST_PROPERTY)).asList()); |
| } |
| |
| @Override |
| public final void setAddress(String address) { |
| requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, address); |
| } |
| |
| @Override |
| public <S> S getSPI(Class<S> spiType) { |
| for (Component c : components) { |
| S s = c.getSPI(spiType); |
| if (s != null) { |
| return s; |
| } |
| } |
| return owner.getSPI(spiType); |
| } |
| |
| @Override |
| public Set<Component> getComponents() { |
| return components; |
| } |
| } |
