jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/ws/server/WSEndpointImpl.java

-:8c0b6bccfe47
+:0989ad8c0860
 /*
-* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+* 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
 import com.sun.xml.internal.stream.buffer.XMLStreamBuffer;
 import com.sun.xml.internal.ws.addressing.EPRSDDocumentFilter;
 import com.sun.xml.internal.ws.addressing.WSEPRExtension;
 import com.sun.xml.internal.ws.api.Component;
 import com.sun.xml.internal.ws.api.ComponentFeature;
+import com.sun.xml.internal.ws.api.ComponentsFeature;
 import com.sun.xml.internal.ws.api.SOAPVersion;
 import com.sun.xml.internal.ws.api.WSBinding;
 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.message.Message;
 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.Codec;
+import com.sun.xml.internal.ws.api.pipe.*;
-import com.sun.xml.internal.ws.api.pipe.Engine;
+import com.sun.xml.internal.ws.api.server.*;
-import com.sun.xml.internal.ws.api.pipe.Fiber;
-import com.sun.xml.internal.ws.api.pipe.FiberContextSwitchInterceptor;
-import com.sun.xml.internal.ws.api.pipe.ServerPipeAssemblerContext;
-import com.sun.xml.internal.ws.api.pipe.ServerTubeAssemblerContext;
-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.TubeCloner;
-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.EndpointAwareCodec;
-import com.sun.xml.internal.ws.api.server.EndpointComponent;
-import com.sun.xml.internal.ws.api.server.EndpointReferenceExtensionContributor;
-import com.sun.xml.internal.ws.api.server.LazyMOMProvider;
-import com.sun.xml.internal.ws.api.server.TransportBackChannel;
-import com.sun.xml.internal.ws.api.server.WSEndpoint;
-import com.sun.xml.internal.ws.api.server.WebServiceContextDelegate;
 import com.sun.xml.internal.ws.binding.BindingImpl;
 import com.sun.xml.internal.ws.fault.SOAPFaultBuilder;
 import com.sun.xml.internal.ws.model.wsdl.WSDLDirectProperties;
 import com.sun.xml.internal.ws.model.wsdl.WSDLPortImpl;
 import com.sun.xml.internal.ws.model.wsdl.WSDLPortProperties;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.ws.EndpointReference;
 import javax.xml.ws.WebServiceException;
 import javax.xml.ws.handler.Handler;
 import java.lang.reflect.Method;
-import java.util.Arrays;
+import java.util.*;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-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;
 /**
 * {@link WSEndpoint} implementation.
 *
 * @author Kohsuke Kawaguchi
 * @author Jitendra Kotamraju
 */
 public /*final*/ class WSEndpointImpl<T> extends WSEndpoint<T> implements LazyMOMProvider.WSEndpointScopeChangeListener {
-private static final Logger LOGGER = Logger.getLogger(WSEndpointImpl.class.getName());
+private static final Logger logger = Logger.getLogger(com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".server.endpoint");
 private final @NotNull QName serviceName;
 private final @NotNull QName portName;
 protected final WSBinding binding;
 private final SEIModel seiModel;
 private final @NotNull Container container;
 private final WSDLPort port;
 protected final Tube masterTubeline;
 private final ServiceDefinitionImpl serviceDef;
 private final SOAPVersion soapVersion;
 private final Engine engine;
 private final @NotNull Codec masterCodec;
 private final @NotNull PolicyMap endpointPolicy;
 private final Pool<Tube> tubePool;
 private final OperationDispatcher operationDispatcher;
-private       @NotNull ManagedObjectManager managedObjectManager;
+private @NotNull ManagedObjectManager managedObjectManager;
-private       boolean managedObjectManagerClosed = false;
+private boolean managedObjectManagerClosed = false;
-private       Object managedObjectManagerLock = new Object();
+private final Object managedObjectManagerLock = new Object();
-private       LazyMOMProvider.Scope lazyMOMProviderScope = LazyMOMProvider.Scope.STANDALONE;
+private LazyMOMProvider.Scope lazyMOMProviderScope = LazyMOMProvider.Scope.STANDALONE;
 private final @NotNull ServerTubeAssemblerContext context;
 private Map<QName, WSEndpointReference.EPRExtension> endpointReferenceExtensions = new HashMap<QName, WSEndpointReference.EPRExtension>();
 /**
-* Set to true once we start shutting down this endpoint.
+* Set to true once we start shutting down this endpoint. Used to avoid
-* Used to avoid running the clean up processing twice.
+* running the clean up processing twice.
 *
 * @see #dispose()
 */
 private boolean disposed;
+private final Class<T> implementationClass;
-private final Class<T> implementationClass;
+private final @NotNull
-private final @NotNull WSDLProperties wsdlProperties;
+WSDLProperties wsdlProperties;
 private final Set<Component> componentRegistry = new CopyOnWriteArraySet<Component>();
 protected WSEndpointImpl(@NotNull QName serviceName, @NotNull QName portName, WSBinding binding,
 Container container, SEIModel seiModel, WSDLPort port,
 Class<T> implementationClass,
 @Nullable ServiceDefinitionImpl serviceDef,
 this.endpointPolicy = endpointPolicy;
 LazyMOMProvider.INSTANCE.registerEndpoint(this);
 initManagedObjectManager();
 if (serviceDef != null) {
 serviceDef.setOwner(this);
 }
 ComponentFeature cf = binding.getFeature(ComponentFeature.class);
 if (cf != null) {
-switch(cf.getTarget()) {
+switch (cf.getTarget()) {
 case ENDPOINT:
 componentRegistry.add(cf.getComponent());
 break;
 case CONTAINER:
 container.getComponents().add(cf.getComponent());
-default:
+break;
-throw new IllegalArgumentException();
+default:
-}
+throw new IllegalArgumentException();
 }
+}
+ComponentsFeature csf = binding.getFeature(ComponentsFeature.class);
+if (csf != null) {
+for (ComponentFeature cfi : csf.getComponentFeatures()) {
+switch (cfi.getTarget()) {
+case ENDPOINT:
+componentRegistry.add(cfi.getComponent());
+break;
+case CONTAINER:
+container.getComponents().add(cfi.getComponent());
+break;
+default:
+throw new IllegalArgumentException();
+}
+}
+}
 TubelineAssembler assembler = TubelineAssemblerFactory.create(
 Thread.currentThread().getContextClassLoader(), binding.getBindingId(), container);
 assert assembler != null;
 this.operationDispatcher = (port == null) ? null : new OperationDispatcher(port, binding, seiModel);
 context = createServerTubeAssemblerContext(terminalTube, isSynchronous);
 this.masterTubeline = assembler.createServer(context);
 Codec c = context.getCodec();
 if (c instanceof EndpointAwareCodec) {
 // create a copy to avoid sharing the codec between multiple endpoints
 c = c.copy();
 ((EndpointAwareCodec) c).setEndpoint(this);
 }
 this.masterCodec = c;
 tubePool = new TubePool(masterTubeline);
 terminalTube.setEndpoint(this);
-engine = new Engine(toString());
+engine = new Engine(toString(), container);
 wsdlProperties = (port == null) ? new WSDLDirectProperties(serviceName, portName, seiModel) : new WSDLPortProperties(port, seiModel);
 Map<QName, WSEndpointReference.EPRExtension> eprExtensions = new HashMap<QName, WSEndpointReference.EPRExtension>();
 try {
 if (port != null) {
 //gather EPR extrensions from WSDL Model
 }
 }
 protected ServerTubeAssemblerContext createServerTubeAssemblerContext(
 EndpointAwareTube terminalTube, boolean isSynchronous) {
-ServerTubeAssemblerContext context = new ServerPipeAssemblerContext(
+ServerTubeAssemblerContext ctx = new ServerPipeAssemblerContext(
 seiModel, port, this, terminalTube, isSynchronous);
-return context;
+return ctx;
 }
 protected WSEndpointImpl(@NotNull QName serviceName, @NotNull QName portName, WSBinding binding, Container container,
 SEIModel seiModel, WSDLPort port,
 Tube masterTubeline) {
 this.operationDispatcher = (port == null) ? null : new OperationDispatcher(port, binding, seiModel);
 this.context = new ServerPipeAssemblerContext(
 seiModel, port, this, null /* not known */, false);
 tubePool = new TubePool(masterTubeline);
-engine = new Engine(toString());
+engine = new Engine(toString(), container);
 wsdlProperties = (port == null) ? new WSDLDirectProperties(serviceName, portName, seiModel) : new WSDLPortProperties(port, seiModel);
 }
 public Collection<WSEndpointReference.EPRExtension> getEndpointReferenceExtensions() {
 return endpointReferenceExtensions.values();
 public void schedule(final Packet request, final CompletionCallback callback, FiberContextSwitchInterceptor interceptor) {
 processAsync(request, callback, interceptor, true);
 }
-private void processAsync(final Packet request, final CompletionCallback callback, FiberContextSwitchInterceptor interceptor, boolean schedule) {
+private void processAsync(final Packet request,
-request.endpoint = WSEndpointImpl.this;
+final CompletionCallback callback,
-request.addSatellite(wsdlProperties);
+FiberContextSwitchInterceptor interceptor, boolean schedule) {
+Container old = ContainerResolver.getDefault().enterContainer(container);
-Fiber fiber = engine.createFiber();
+try {
-if (interceptor != null) {
+request.endpoint = WSEndpointImpl.this;
-fiber.addInterceptor(interceptor);
+request.addSatellite(wsdlProperties);
-}
-final Tube tube = tubePool.take();
+Fiber fiber = engine.createFiber();
-Fiber.CompletionCallback cbak = new Fiber.CompletionCallback() {
+fiber.setDeliverThrowableInPacket(true);
-public void onCompletion(@NotNull Packet response) {
+if (interceptor != null) {
-tubePool.recycle(tube);
+fiber.addInterceptor(interceptor);
-if (callback != null) {
+}
-callback.onCompletion(response);
+final Tube tube = tubePool.take();
-}
+Fiber.CompletionCallback cbak = new Fiber.CompletionCallback() {
+public void onCompletion(@NotNull Packet response) {
+ThrowableContainerPropertySet tc = response.getSatellite(ThrowableContainerPropertySet.class);
+if (tc == null) {
+// Only recycle tubes in non-exception path as some Tubes may be
+// in invalid state following exception
+tubePool.recycle(tube);
+}
+if (callback != null) {
+if (tc != null) {
+response = createServiceResponseForException(tc,
+response,
+soapVersion,
+request.endpoint.getPort(),
+null,
+request.endpoint.getBinding());
 }
+callback.onCompletion(response);
-public void onCompletion(@NotNull Throwable error) {
+}
-// let's not reuse tubes as they might be in a wrong state, so not
+}
-// calling tubePool.recycle()
-// Convert all runtime exceptions to Packet so that transport doesn't
+public void onCompletion(@NotNull Throwable error) {
-// have to worry about converting to wire message
+// will never be called now that we are using
-// TODO XML/HTTP binding
+// fiber.setDeliverThrowableInPacket(true);
-Message faultMsg = SOAPFaultBuilder.createSOAPFaultMessage(
+throw new IllegalStateException();
-soapVersion, null, error);
+}
-Packet response = request.createServerResponse(faultMsg, request.endpoint.getPort(), null,
+};
-request.endpoint.getBinding());
-if (callback != null) {
+fiber.start(tube, request, cbak,
-callback.onCompletion(response);
+binding.isFeatureEnabled(SyncStartForAsyncFeature.class)
-}
+|| !schedule);
-}
+} finally {
-};
+ContainerResolver.getDefault().exitContainer(old);
+}
-fiber.start(tube, request, cbak,
+}
-binding.isFeatureEnabled(SyncStartForAsyncFeature.class) || !schedule);
-}
+@Override
+public Packet createServiceResponseForException(final ThrowableContainerPropertySet tc,
+final Packet      responsePacket,
+final SOAPVersion soapVersion,
+final WSDLPort    wsdlPort,
+final SEIModel    seiModel,
+final WSBinding   binding)
+{
+// This will happen in addressing if it is enabled.
+if (tc.isFaultCreated()) return responsePacket;
+final Message faultMessage = SOAPFaultBuilder.createSOAPFaultMessage(soapVersion, null, tc.getThrowable());
+final Packet result = responsePacket.createServerResponse(faultMessage, wsdlPort, seiModel, binding);
+// Pass info to upper layers
+tc.setFaultMessage(faultMessage);
+tc.setResponsePacket(responsePacket);
+tc.setFaultCreated(true);
+return result;
+}
 @Override
 public void process(final Packet request, final CompletionCallback callback, FiberContextSwitchInterceptor interceptor) {
 processAsync(request, callback, interceptor, false);
 }
-public @NotNull PipeHead createPipeHead() {
+public @NotNull
-return new PipeHead() {
+PipeHead createPipeHead() {
-private final Tube tube = TubeCloner.clone(masterTubeline);
+return new PipeHead() {
+private final Tube tube = TubeCloner.clone(masterTubeline);
-public @NotNull Packet process(Packet request, WebServiceContextDelegate wscd, TransportBackChannel tbc) {
-request.webServiceContextDelegate = wscd;
+public @NotNull
-request.transportBackChannel = tbc;
+Packet process(Packet request, WebServiceContextDelegate wscd,
-request.endpoint = WSEndpointImpl.this;
+TransportBackChannel tbc) {
-request.addSatellite(wsdlProperties);
+Container old = ContainerResolver.getDefault().enterContainer(container);
+try {
-Fiber fiber = engine.createFiber();
+request.webServiceContextDelegate = wscd;
-Packet response;
+request.transportBackChannel = tbc;
-try {
+request.endpoint = WSEndpointImpl.this;
-response = fiber.runSync(tube, request);
+request.addSatellite(wsdlProperties);
-} catch (RuntimeException re) {
-// Catch all runtime exceptions so that transport doesn't
+Fiber fiber = engine.createFiber();
-// have to worry about converting to wire message
+Packet response;
-// TODO XML/HTTP binding
+try {
-Message faultMsg = SOAPFaultBuilder.createSOAPFaultMessage(
+response = fiber.runSync(tube, request);
-soapVersion, null, re);
+} catch (RuntimeException re) {
-response = request.createServerResponse(faultMsg, request.endpoint.getPort(), null, request.endpoint.getBinding());
+// Catch all runtime exceptions so that transport
-}
+// doesn't
-return response;
+// have to worry about converting to wire message
-}
+// TODO XML/HTTP binding
-};
+Message faultMsg = SOAPFaultBuilder
-}
+.createSOAPFaultMessage(soapVersion, null, re);
+response = request.createServerResponse(faultMsg,
+request.endpoint.getPort(), null,
+request.endpoint.getBinding());
+}
+return response;
+} finally {
+ContainerResolver.getDefault().exitContainer(old);
+}
+}
+};
+}
 public synchronized void dispose() {
-if (disposed)
+if (disposed) {
 return;
-disposed = true;
+}
+disposed = true;
-masterTubeline.preDestroy();
+masterTubeline.preDestroy();
-for (Handler handler : binding.getHandlerChain()) {
-for (Method method : handler.getClass().getMethods()) {
+for (Handler handler : binding.getHandlerChain()) {
-if (method.getAnnotation(PreDestroy.class) == null) {
+for (Method method : handler.getClass().getMethods()) {
-continue;
+if (method.getAnnotation(PreDestroy.class) == null) {
-}
+continue;
-try {
+}
-method.invoke(handler);
+try {
-} catch (Exception e) {
+method.invoke(handler);
-logger.log(Level.WARNING, HandlerMessages.HANDLER_PREDESTROY_IGNORE(e.getMessage()), e);
+} catch (Exception e) {
-}
+logger.log(Level.WARNING, HandlerMessages.HANDLER_PREDESTROY_IGNORE(e.getMessage()), e);
-break;
+}
-}
+break;
 }
-closeManagedObjectManager();
+}
+closeManagedObjectManager();
+LazyMOMProvider.INSTANCE.unregisterEndpoint(this);
 }
 public ServiceDefinitionImpl getServiceDefinition() {
 return serviceDef;
 }
 return component.hashCode();
 }
 @Override
 public boolean equals(Object obj) {
 return component.equals(obj);
 }
 }
 private static class EndpointComponentWrapper implements Component {
 private final EndpointComponent component;
 public boolean equals(Object obj) {
 return component.equals(obj);
 }
 }
+@Override
 public @NotNull Set<Component> getComponents() {
 return componentRegistry;
 }
-private static final Logger logger = Logger.getLogger(
+public <T extends EndpointReference> T getEndpointReference(Class<T> clazz, String address, String wsdlAddress, Element... referenceParameters) {
-com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".server.endpoint");
-public <T extends EndpointReference> T getEndpointReference(Class<T>
-clazz, String address, String wsdlAddress, Element... referenceParameters) {
 List<Element> refParams = null;
 if (referenceParameters != null) {
 refParams = Arrays.asList(referenceParameters);
 }
 return getEndpointReference(clazz, address, wsdlAddress, null, refParams);
 }
 public <T extends EndpointReference> T getEndpointReference(Class<T> clazz,
 String address, String wsdlAddress, List<Element> metadata,
 List<Element> referenceParameters) {
 QName portType = null;
 if (port != null) {
 portType = port.getBinding().getPortTypeName();
 }
 AddressingVersion av = AddressingVersion.fromSpecClass(clazz);
 return new WSEndpointReference(
-av, address, serviceName, portName, portType, metadata, wsdlAddress, referenceParameters,endpointReferenceExtensions.values(), null).toSpec(clazz);
+av, address, serviceName, portName, portType, metadata, wsdlAddress, referenceParameters, endpointReferenceExtensions.values(), null).toSpec(clazz);
 }
 public @NotNull QName getPortName() {
 return portName;
 }
 * @see com.sun.xml.internal.ws.api.server.LazyMOMProvider.Scope
 * @return an instance of {@code ManagedObjectManager}
 */
 @NotNull ManagedObjectManager obtainManagedObjectManager() {
 final MonitorRootService monitorRootService = new MonitorRootService(this);
-final ManagedObjectManager managedObjectManager = monitorRootService.createManagedObjectManager(this);
+final ManagedObjectManager mOM = monitorRootService.createManagedObjectManager(this);
 // ManagedObjectManager was suspended due to root creation (see MonitorBase#initMOM)
-managedObjectManager.resumeJMXRegistration();
+mOM.resumeJMXRegistration();
-return managedObjectManager;
+return mOM;
 }
 public void scopeChanged(LazyMOMProvider.Scope scope) {
 synchronized (managedObjectManagerLock) {
 if (managedObjectManagerClosed) {
 }
 }
 }
 }
+private static final Logger monitoringLogger = Logger.getLogger(com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".monitoring");
 // This can be called independently of WSEndpoint.dispose.
 // Example: the WSCM framework calls this before dispose.
+@Override
 public void closeManagedObjectManager() {
 synchronized (managedObjectManagerLock) {
 if (managedObjectManagerClosed == true) {
 return;
 }
 && !((WSEndpointMOMProxy)managedObjectManager).isInitialized()) {
 close = false;
 }
 if (close) {
-// no further notification on scope change
+try {
-LazyMOMProvider.INSTANCE.unregisterEndpoint(this);
+final ObjectName name = managedObjectManager.getObjectName(managedObjectManager.getRoot());
-MonitorBase.closeMOM(managedObjectManager);
+// 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;
 }
 }
-public @NotNull ServerTubeAssemblerContext getAssemblerContext() {
+public @NotNull @Override ServerTubeAssemblerContext getAssemblerContext() {
 return context;
 }
 }

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/xml/internal/ws/server/WSEndpointImpl.java

src/share/jaxws_classes/com/sun/xml/internal/ws/server/WSEndpointImpl.java