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

8010393: Update JAX-WS RI to 2.2.9-b12941
Reviewed-by: alanb, erikj
Contributed-by: miroslav.kos@oracle.com, martin.grebac@oracle.com

     1 /*

     2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    26 package com.sun.xml.internal.ws.server;

    28 import com.sun.istack.internal.NotNull;

    29 import com.sun.istack.internal.Nullable;

    30 import com.sun.xml.internal.stream.buffer.XMLStreamBuffer;

    31 import com.sun.xml.internal.ws.addressing.EPRSDDocumentFilter;

    32 import com.sun.xml.internal.ws.addressing.WSEPRExtension;

    33 import com.sun.xml.internal.ws.api.Component;

    34 import com.sun.xml.internal.ws.api.ComponentFeature;

    35 import com.sun.xml.internal.ws.api.ComponentsFeature;

    36 import com.sun.xml.internal.ws.api.SOAPVersion;

    37 import com.sun.xml.internal.ws.api.WSBinding;

    38 import com.sun.xml.internal.ws.api.addressing.AddressingVersion;

    39 import com.sun.xml.internal.ws.api.addressing.WSEndpointReference;

    40 import com.sun.xml.internal.ws.api.message.Message;

    41 import com.sun.xml.internal.ws.api.message.Packet;

    42 import com.sun.xml.internal.ws.api.model.SEIModel;

    43 import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort;

    44 import com.sun.xml.internal.ws.api.pipe.*;

    45 import com.sun.xml.internal.ws.api.server.*;

    46 import com.sun.xml.internal.ws.binding.BindingImpl;

    47 import com.sun.xml.internal.ws.fault.SOAPFaultBuilder;

    48 import com.sun.xml.internal.ws.model.wsdl.WSDLDirectProperties;

    49 import com.sun.xml.internal.ws.model.wsdl.WSDLPortImpl;

    50 import com.sun.xml.internal.ws.model.wsdl.WSDLPortProperties;

    51 import com.sun.xml.internal.ws.model.wsdl.WSDLProperties;

    52 import com.sun.xml.internal.ws.policy.PolicyMap;

    53 import com.sun.xml.internal.ws.resources.HandlerMessages;

    54 import com.sun.xml.internal.ws.util.Pool;

    55 import com.sun.xml.internal.ws.util.Pool.TubePool;

    56 import com.sun.xml.internal.ws.util.ServiceFinder;

    57 import com.sun.xml.internal.ws.wsdl.OperationDispatcher;

    58 import com.sun.org.glassfish.gmbal.ManagedObjectManager;

    59 import org.w3c.dom.Element;

    61 import javax.annotation.PreDestroy;

    62 import javax.xml.namespace.QName;

    63 import javax.xml.stream.XMLStreamException;

    64 import javax.xml.ws.EndpointReference;

    65 import javax.xml.ws.WebServiceException;

    66 import javax.xml.ws.handler.Handler;

    67 import java.lang.reflect.Method;

    68 import java.util.*;

    69 import java.util.concurrent.CopyOnWriteArraySet;

    70 import java.util.concurrent.Executor;

    71 import java.util.logging.Level;

    72 import java.util.logging.Logger;

    73 import javax.management.ObjectName;

    75 /**

    76  * {@link WSEndpoint} implementation.

    77  *

    78  * @author Kohsuke Kawaguchi

    79  * @author Jitendra Kotamraju

    80  */

    81 public /*final*/ class WSEndpointImpl<T> extends WSEndpoint<T> implements LazyMOMProvider.WSEndpointScopeChangeListener {

    83     private static final Logger logger = Logger.getLogger(com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".server.endpoint");

    85     private final @NotNull QName serviceName;

    86     private final @NotNull QName portName;

    87     protected final WSBinding binding;

    88     private final SEIModel seiModel;

    89     private final @NotNull Container container;

    90     private final WSDLPort port;

    92     protected final Tube masterTubeline;

    93     private final ServiceDefinitionImpl serviceDef;

    94     private final SOAPVersion soapVersion;

    95     private final Engine engine;

    96     private final @NotNull Codec masterCodec;

    97     private final @NotNull PolicyMap endpointPolicy;

    98     private final Pool<Tube> tubePool;

    99     private final OperationDispatcher operationDispatcher;

   100     private @NotNull ManagedObjectManager managedObjectManager;

   101     private boolean managedObjectManagerClosed = false;

   102     private final Object managedObjectManagerLock = new Object();

   103     private LazyMOMProvider.Scope lazyMOMProviderScope = LazyMOMProvider.Scope.STANDALONE;

   104     private final @NotNull ServerTubeAssemblerContext context;

   106     private Map<QName, WSEndpointReference.EPRExtension> endpointReferenceExtensions = new HashMap<QName, WSEndpointReference.EPRExtension>();

   107     /**

   108      * Set to true once we start shutting down this endpoint. Used to avoid

   109      * running the clean up processing twice.

   110      *

   111      * @see #dispose()

   112      */

   113     private boolean disposed;

   114     private final Class<T> implementationClass;

   115     private final @NotNull

   116     WSDLProperties wsdlProperties;

   117     private final Set<Component> componentRegistry = new CopyOnWriteArraySet<Component>();

   119     protected WSEndpointImpl(@NotNull QName serviceName, @NotNull QName portName, WSBinding binding,

   120                    Container container, SEIModel seiModel, WSDLPort port,

   121                    Class<T> implementationClass,

   122                    @Nullable ServiceDefinitionImpl serviceDef,

   123                    EndpointAwareTube terminalTube, boolean isSynchronous,

   124                    PolicyMap endpointPolicy) {

   125                 this.serviceName = serviceName;

   126                 this.portName = portName;

   127                 this.binding = binding;

   128                 this.soapVersion = binding.getSOAPVersion();

   129                 this.container = container;

   130                 this.port = port;

   131                 this.implementationClass = implementationClass;

   132                 this.serviceDef = serviceDef;

   133                 this.seiModel = seiModel;

   134         this.endpointPolicy = endpointPolicy;

   136         LazyMOMProvider.INSTANCE.registerEndpoint(this);

   137         initManagedObjectManager();

   139         if (serviceDef != null) {

   140             serviceDef.setOwner(this);

   141         }

   143         ComponentFeature cf = binding.getFeature(ComponentFeature.class);

   144         if (cf != null) {

   145             switch (cf.getTarget()) {

   146                 case ENDPOINT:

   147                     componentRegistry.add(cf.getComponent());

   148                     break;

   149                 case CONTAINER:

   150                     container.getComponents().add(cf.getComponent());

   151                     break;

   152                 default:

   153                     throw new IllegalArgumentException();

   154             }

   155         }

   156         ComponentsFeature csf = binding.getFeature(ComponentsFeature.class);

   157         if (csf != null) {

   158             for (ComponentFeature cfi : csf.getComponentFeatures()) {

   159                 switch (cfi.getTarget()) {

   160                     case ENDPOINT:

   161                         componentRegistry.add(cfi.getComponent());

   162                         break;

   163                     case CONTAINER:

   164                         container.getComponents().add(cfi.getComponent());

   165                         break;

   166                     default:

   167                         throw new IllegalArgumentException();

   168                 }

   169             }

   170         }

   172         TubelineAssembler assembler = TubelineAssemblerFactory.create(

   173                 Thread.currentThread().getContextClassLoader(), binding.getBindingId(), container);

   174         assert assembler != null;

   176         this.operationDispatcher = (port == null) ? null : new OperationDispatcher(port, binding, seiModel);

   178         context = createServerTubeAssemblerContext(terminalTube, isSynchronous);

   179         this.masterTubeline = assembler.createServer(context);

   181         Codec c = context.getCodec();

   182         if (c instanceof EndpointAwareCodec) {

   183             // create a copy to avoid sharing the codec between multiple endpoints

   184             c = c.copy();

   185             ((EndpointAwareCodec) c).setEndpoint(this);

   186         }

   187         this.masterCodec = c;

   189         tubePool = new TubePool(masterTubeline);

   190         terminalTube.setEndpoint(this);

   191         engine = new Engine(toString(), container);

   192         wsdlProperties = (port == null) ? new WSDLDirectProperties(serviceName, portName, seiModel) : new WSDLPortProperties(port, seiModel);

   194         Map<QName, WSEndpointReference.EPRExtension> eprExtensions = new HashMap<QName, WSEndpointReference.EPRExtension>();

   195         try {

   196             if (port != null) {

   197                 //gather EPR extrensions from WSDL Model

   198                 WSEndpointReference wsdlEpr = ((WSDLPortImpl) port).getEPR();

   199                 if (wsdlEpr != null) {

   200                     for (WSEndpointReference.EPRExtension extnEl : wsdlEpr.getEPRExtensions()) {

   201                         eprExtensions.put(extnEl.getQName(), extnEl);

   202                     }

   203                 }

   204             }

   206             EndpointReferenceExtensionContributor[] eprExtnContributors = ServiceFinder.find(EndpointReferenceExtensionContributor.class).toArray();

   207             for(EndpointReferenceExtensionContributor eprExtnContributor :eprExtnContributors) {

   208                 WSEndpointReference.EPRExtension wsdlEPRExtn = eprExtensions.remove(eprExtnContributor.getQName());

   209                     WSEndpointReference.EPRExtension endpointEprExtn = eprExtnContributor.getEPRExtension(this,wsdlEPRExtn);

   210                     if (endpointEprExtn != null) {

   211                         eprExtensions.put(endpointEprExtn.getQName(), endpointEprExtn);

   212                     }

   213             }

   214             for (WSEndpointReference.EPRExtension extn : eprExtensions.values()) {

   215                 endpointReferenceExtensions.put(extn.getQName(), new WSEPRExtension(

   216                         XMLStreamBuffer.createNewBufferFromXMLStreamReader(extn.readAsXMLStreamReader()),extn.getQName()));

   217             }

   218         } catch (XMLStreamException ex) {

   219             throw new WebServiceException(ex);

   220         }

   221         if(!eprExtensions.isEmpty()) {

   222             serviceDef.addFilter(new EPRSDDocumentFilter(this));

   223         }

   224   }

   226   protected ServerTubeAssemblerContext createServerTubeAssemblerContext(

   227             EndpointAwareTube terminalTube, boolean isSynchronous) {

   228     ServerTubeAssemblerContext ctx = new ServerPipeAssemblerContext(

   229         seiModel, port, this, terminalTube, isSynchronous);

   230     return ctx;

   231   }

   233         protected WSEndpointImpl(@NotNull QName serviceName, @NotNull QName portName, WSBinding binding, Container container,

   234                         SEIModel seiModel, WSDLPort port,

   235                         Tube masterTubeline) {

   236                 this.serviceName = serviceName;

   237                 this.portName = portName;

   238                 this.binding = binding;

   239                 this.soapVersion = binding.getSOAPVersion();

   240                 this.container = container;

   241                 this.endpointPolicy = null;

   242                 this.port = port;

   243                 this.seiModel = seiModel;

   244                 this.serviceDef = null;

   245                 this.implementationClass = null;

   246                 this.masterTubeline = masterTubeline;

   247                 this.masterCodec = ((BindingImpl) this.binding).createCodec();

   249         LazyMOMProvider.INSTANCE.registerEndpoint(this);

   250         initManagedObjectManager();

   252         this.operationDispatcher = (port == null) ? null : new OperationDispatcher(port, binding, seiModel);

   253             this.context = new ServerPipeAssemblerContext(

   254                 seiModel, port, this, null /* not known */, false);

   256                 tubePool = new TubePool(masterTubeline);

   257                 engine = new Engine(toString(), container);

   258                 wsdlProperties = (port == null) ? new WSDLDirectProperties(serviceName, portName, seiModel) : new WSDLPortProperties(port, seiModel);

   259   }

   261     public Collection<WSEndpointReference.EPRExtension> getEndpointReferenceExtensions() {

   262         return endpointReferenceExtensions.values();

   263     }

   265     /**

   266      * Nullable when there is no associated WSDL Model

   267      * @return

   268      */

   269     public @Nullable OperationDispatcher getOperationDispatcher() {

   270         return operationDispatcher;

   271     }

   273     public PolicyMap getPolicyMap() {

   274             return endpointPolicy;

   275     }

   277     public @NotNull Class<T> getImplementationClass() {

   278                 return implementationClass;

   279         }

   281     public @NotNull WSBinding getBinding() {

   282                 return binding;

   283         }

   285     public @NotNull Container getContainer() {

   286                 return container;

   287         }

   289         public WSDLPort getPort() {

   290                 return port;

   291         }

   293         @Override

   294     public @Nullable SEIModel getSEIModel() {

   295                 return seiModel;

   296         }

   298         public void setExecutor(Executor exec) {

   299                 engine.setExecutor(exec);

   300         }

   302         @Override

   303         public Engine getEngine() {

   304                 return engine;

   305         }

   307     public void schedule(final Packet request, final CompletionCallback callback, FiberContextSwitchInterceptor interceptor) {

   308         processAsync(request, callback, interceptor, true);

   309     }

   311     private void processAsync(final Packet request,

   312             final CompletionCallback callback,

   313             FiberContextSwitchInterceptor interceptor, boolean schedule) {

   314         Container old = ContainerResolver.getDefault().enterContainer(container);

   315         try {

   316             request.endpoint = WSEndpointImpl.this;

   317             request.addSatellite(wsdlProperties);

   319             Fiber fiber = engine.createFiber();

   320             fiber.setDeliverThrowableInPacket(true);

   321             if (interceptor != null) {

   322                 fiber.addInterceptor(interceptor);

   323             }

   324             final Tube tube = tubePool.take();

   325             Fiber.CompletionCallback cbak = new Fiber.CompletionCallback() {

   326                 public void onCompletion(@NotNull Packet response) {

   327                     ThrowableContainerPropertySet tc = response.getSatellite(ThrowableContainerPropertySet.class);

   328                     if (tc == null) {

   329                         // Only recycle tubes in non-exception path as some Tubes may be

   330                         // in invalid state following exception

   331                         tubePool.recycle(tube);

   332                     }

   334                     if (callback != null) {

   335                         if (tc != null) {

   336                             response = createServiceResponseForException(tc,

   337                                                                          response,

   338                                                                          soapVersion,

   339                                                                          request.endpoint.getPort(),

   340                                                                          null,

   341                                                                          request.endpoint.getBinding());

   342                         }

   343                         callback.onCompletion(response);

   344                     }

   345                 }

   347                 public void onCompletion(@NotNull Throwable error) {

   348                     // will never be called now that we are using

   349                     // fiber.setDeliverThrowableInPacket(true);

   350                     throw new IllegalStateException();

   351                 }

   352             };

   354             fiber.start(tube, request, cbak,

   355                     binding.isFeatureEnabled(SyncStartForAsyncFeature.class)

   356                             || !schedule);

   357         } finally {

   358             ContainerResolver.getDefault().exitContainer(old);

   359         }

   360     }

   362     @Override

   363     public Packet createServiceResponseForException(final ThrowableContainerPropertySet tc,

   364                                                     final Packet      responsePacket,

   365                                                     final SOAPVersion soapVersion,

   366                                                     final WSDLPort    wsdlPort,

   367                                                     final SEIModel    seiModel,

   368                                                     final WSBinding   binding)

   369     {

   370         // This will happen in addressing if it is enabled.

   371         if (tc.isFaultCreated()) return responsePacket;

   373         final Message faultMessage = SOAPFaultBuilder.createSOAPFaultMessage(soapVersion, null, tc.getThrowable());

   374         final Packet result = responsePacket.createServerResponse(faultMessage, wsdlPort, seiModel, binding);

   375         // Pass info to upper layers

   376         tc.setFaultMessage(faultMessage);

   377         tc.setResponsePacket(responsePacket);

   378         tc.setFaultCreated(true);

   379         return result;

   380     }

   382     @Override

   383     public void process(final Packet request, final CompletionCallback callback, FiberContextSwitchInterceptor interceptor) {

   384         processAsync(request, callback, interceptor, false);

   385     }

   387     public @NotNull

   388     PipeHead createPipeHead() {

   389         return new PipeHead() {

   390             private final Tube tube = TubeCloner.clone(masterTubeline);

   392             public @NotNull

   393             Packet process(Packet request, WebServiceContextDelegate wscd,

   394                     TransportBackChannel tbc) {

   395                 Container old = ContainerResolver.getDefault().enterContainer(container);

   396                 try {

   397                     request.webServiceContextDelegate = wscd;

   398                     request.transportBackChannel = tbc;

   399                     request.endpoint = WSEndpointImpl.this;

   400                     request.addSatellite(wsdlProperties);

   402                     Fiber fiber = engine.createFiber();

   403                     Packet response;

   404                     try {

   405                         response = fiber.runSync(tube, request);

   406                     } catch (RuntimeException re) {

   407                         // Catch all runtime exceptions so that transport

   408                         // doesn't

   409                         // have to worry about converting to wire message

   410                         // TODO XML/HTTP binding

   411                         Message faultMsg = SOAPFaultBuilder

   412                                 .createSOAPFaultMessage(soapVersion, null, re);

   413                         response = request.createServerResponse(faultMsg,

   414                                 request.endpoint.getPort(), null,

   415                                 request.endpoint.getBinding());

   416                     }

   417                     return response;

   418                 } finally {

   419                     ContainerResolver.getDefault().exitContainer(old);

   420                 }

   421             }

   422         };

   423     }

   425         public synchronized void dispose() {

   426             if (disposed) {

   427                 return;

   428             }

   429             disposed = true;

   431             masterTubeline.preDestroy();

   433             for (Handler handler : binding.getHandlerChain()) {

   434                 for (Method method : handler.getClass().getMethods()) {

   435                     if (method.getAnnotation(PreDestroy.class) == null) {

   436                         continue;

   437                     }

   438                     try {

   439                         method.invoke(handler);

   440                     } catch (Exception e) {

   441                         logger.log(Level.WARNING, HandlerMessages.HANDLER_PREDESTROY_IGNORE(e.getMessage()), e);

   442                     }

   443                     break;

   444                 }

   445             }

   446             closeManagedObjectManager();

   447             LazyMOMProvider.INSTANCE.unregisterEndpoint(this);

   448         }

   450         public ServiceDefinitionImpl getServiceDefinition() {

   451                 return serviceDef;

   452         }

   454         public Set<EndpointComponent> getComponentRegistry() {

   455                 Set<EndpointComponent> sec = new EndpointComponentSet();

   456                 for (Component c : componentRegistry) {

   457                         sec.add(c instanceof EndpointComponentWrapper ?

   458                                 ((EndpointComponentWrapper) c).component :

   459                                 new ComponentWrapper(c));

   460                 }

   461                 return sec;

   462         }

   464         private class EndpointComponentSet extends HashSet<EndpointComponent> {

   466                 @Override

   467                 public Iterator<EndpointComponent> iterator() {

   468                         final Iterator<EndpointComponent> it = super.iterator();

   469                         return new Iterator<EndpointComponent>() {

   470                                 private EndpointComponent last = null;

   472                                 public boolean hasNext() {

   473                                         return it.hasNext();

   474                                 }

   476                                 public EndpointComponent next() {

   477                                         last = it.next();

   478                                         return last;

   479                                 }

   481                                 public void remove() {

   482                                         it.remove();

   483                                         if (last != null) {

   484                                                 componentRegistry.remove(last instanceof ComponentWrapper ?

   485                                                                 ((ComponentWrapper) last).component :

   486                                                                 new EndpointComponentWrapper(last));

   487                                         }

   488                                         last = null;

   489                                 }

   490                         };

   491                 }

   493                 @Override

   494                 public boolean add(EndpointComponent e) {

   495                         boolean result = super.add(e);

   496                         if (result) {

   497                                 componentRegistry.add(new EndpointComponentWrapper(e));

   498                         }

   499                         return result;

   500                 }

   502                 @Override

   503                 public boolean remove(Object o) {

   504                         boolean result = super.remove(o);

   505                         if (result) {

   506                                 componentRegistry.remove(o instanceof ComponentWrapper ?

   507                                                 ((ComponentWrapper) o).component :

   508                                                 new EndpointComponentWrapper((EndpointComponent)o));

   509                         }

   510                         return result;

   511                 }

   513         }

   515         private static class ComponentWrapper implements EndpointComponent {

   516                 private final Component component;

   518                 public ComponentWrapper(Component component) {

   519                         this.component = component;

   520                 }

   522                 public <S> S getSPI(Class<S> spiType) {

   523                         return component.getSPI(spiType);

   524                 }

   526                 @Override

   527                 public int hashCode() {

   528                         return component.hashCode();

   529                 }

   531                 @Override

   532                 public boolean equals(Object obj) {

   533                     return component.equals(obj);

   534                 }

   535         }

   537         private static class EndpointComponentWrapper implements Component {

   538                 private final EndpointComponent component;

   540                 public EndpointComponentWrapper(EndpointComponent component) {

   541                         this.component = component;

   542                 }

   544                 public <S> S getSPI(Class<S> spiType) {

   545                         return component.getSPI(spiType);

   546                 }

   548                 @Override

   549                 public int hashCode() {

   550                         return component.hashCode();

   551                 }

   553                 @Override

   554                 public boolean equals(Object obj) {

   555                         return component.equals(obj);

   556                 }

   557         }

   559         @Override

   560         public @NotNull Set<Component> getComponents() {

   561                 return componentRegistry;

   562         }

   564     public <T extends EndpointReference> T getEndpointReference(Class<T> clazz, String address, String wsdlAddress, Element... referenceParameters) {

   565         List<Element> refParams = null;

   566         if (referenceParameters != null) {

   567             refParams = Arrays.asList(referenceParameters);

   568         }

   569         return getEndpointReference(clazz, address, wsdlAddress, null, refParams);

   570     }

   572     public <T extends EndpointReference> T getEndpointReference(Class<T> clazz,

   573             String address, String wsdlAddress, List<Element> metadata,

   574             List<Element> referenceParameters) {

   575         QName portType = null;

   576         if (port != null) {

   577             portType = port.getBinding().getPortTypeName();

   578         }

   580         AddressingVersion av = AddressingVersion.fromSpecClass(clazz);

   581         return new WSEndpointReference(

   582                 av, address, serviceName, portName, portType, metadata, wsdlAddress, referenceParameters, endpointReferenceExtensions.values(), null).toSpec(clazz);

   584     }

   586     public @NotNull QName getPortName() {

   587                 return portName;

   588         }

   591     public @NotNull Codec createCodec() {

   592                 return masterCodec.copy();

   593         }

   595     public @NotNull QName getServiceName() {

   596                 return serviceName;

   597         }

   599     private void initManagedObjectManager() {

   600         synchronized (managedObjectManagerLock) {

   601             if (managedObjectManager == null) {

   602                 switch (this.lazyMOMProviderScope) {

   603                     case GLASSFISH_NO_JMX:

   604                         managedObjectManager = new WSEndpointMOMProxy(this);

   605                         break;

   606                     default:

   607                         managedObjectManager = obtainManagedObjectManager();

   608                 }

   609             }

   610         }

   611     }

   613     public @NotNull ManagedObjectManager getManagedObjectManager() {

   614         return managedObjectManager;

   615     }

   617     /**

   618      * Obtains a real instance of {@code ManagedObjectManager} class no matter what lazyMOMProviderScope is this endpoint in (or if the

   619      * Gmbal API calls should be deferred).

   620      *

   621      * @see com.sun.xml.internal.ws.api.server.LazyMOMProvider.Scope

   622      * @return an instance of {@code ManagedObjectManager}

   623      */

   624     @NotNull ManagedObjectManager obtainManagedObjectManager() {

   625         final MonitorRootService monitorRootService = new MonitorRootService(this);

   626         final ManagedObjectManager mOM = monitorRootService.createManagedObjectManager(this);

   628         // ManagedObjectManager was suspended due to root creation (see MonitorBase#initMOM)

   629         mOM.resumeJMXRegistration();

   631         return mOM;

   632     }

   634     public void scopeChanged(LazyMOMProvider.Scope scope) {

   635         synchronized (managedObjectManagerLock) {

   636             if (managedObjectManagerClosed) {

   637                 return;

   638             }

   640             this.lazyMOMProviderScope = scope;

   642             // possible lazyMOMProviderScope change can be LazyMOMProvider.Scope.GLASSFISH_NO_JMX or LazyMOMProvider.Scope.GLASSFISH_JMX

   643             if (managedObjectManager == null) {

   644                 if (scope != LazyMOMProvider.Scope.GLASSFISH_NO_JMX) {

   645                     managedObjectManager = obtainManagedObjectManager();

   646                 } else {

   647                     managedObjectManager = new WSEndpointMOMProxy(this);

   648                 }

   649             } else {

   650                 // if ManagedObjectManager for this endpoint has already been created and is uninitialized proxy then

   651                 // fill it with a real instance

   652                 if (managedObjectManager instanceof WSEndpointMOMProxy

   653                         && !((WSEndpointMOMProxy)managedObjectManager).isInitialized()) {

   654                     ((WSEndpointMOMProxy)managedObjectManager).setManagedObjectManager(obtainManagedObjectManager());

   655                 }

   656             }

   657         }

   658     }

   660     private static final Logger monitoringLogger = Logger.getLogger(com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".monitoring");

   662     // This can be called independently of WSEndpoint.dispose.

   663     // Example: the WSCM framework calls this before dispose.

   664     @Override

   665     public void closeManagedObjectManager() {

   666         synchronized (managedObjectManagerLock) {

   667             if (managedObjectManagerClosed == true) {

   668                 return;

   669             }

   670             if (managedObjectManager != null) {

   671                 boolean close = true;

   673                 // ManagedObjectManager doesn't need to be closed because it exists only as a proxy

   674                 if (managedObjectManager instanceof WSEndpointMOMProxy

   675                         && !((WSEndpointMOMProxy)managedObjectManager).isInitialized()) {

   676                     close = false;

   677                 }

   679                 if (close) {

   680                     try {

   681                         final ObjectName name = managedObjectManager.getObjectName(managedObjectManager.getRoot());

   682                         // The name is null when the MOM is a NOOP.

   683                         if (name != null) {

   684                             monitoringLogger.log(Level.INFO, "Closing Metro monitoring root: {0}", name);

   685                         }

   686                         managedObjectManager.close();

   687                     } catch (java.io.IOException e) {

   688                         monitoringLogger.log(Level.WARNING, "Ignoring error when closing Managed Object Manager", e);

   689                     }

   690                 }

   691             }

   692             managedObjectManagerClosed = true;

   693         }

   694     }

   696     public @NotNull @Override ServerTubeAssemblerContext getAssemblerContext() {

   697         return context;

   698     }

   699 }

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

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

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