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 */ 25 26 package com.sun.xml.internal.ws.api.server; 27 28 import com.sun.istack.internal.NotNull; 29 import com.sun.istack.internal.Nullable; 30 import com.sun.xml.internal.ws.api.BindingID; 31 import com.sun.xml.internal.ws.api.Component; 32 import com.sun.xml.internal.ws.api.ComponentRegistry; 33 import com.sun.xml.internal.ws.api.SOAPVersion; 34 import com.sun.xml.internal.ws.api.WSBinding; 35 import com.sun.xml.internal.ws.api.config.management.EndpointCreationAttributes; 36 import com.sun.xml.internal.ws.api.config.management.ManagedEndpointFactory; 37 import com.sun.xml.internal.ws.api.databinding.MetadataReader; 38 import com.sun.xml.internal.ws.api.message.Message; 39 import com.sun.xml.internal.ws.api.message.Packet; 40 import com.sun.xml.internal.ws.api.model.SEIModel; 41 import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort; 42 import com.sun.xml.internal.ws.api.pipe.Codec; 43 import com.sun.xml.internal.ws.api.pipe.Engine; 44 import com.sun.xml.internal.ws.api.pipe.FiberContextSwitchInterceptor; 45 import com.sun.xml.internal.ws.api.pipe.ServerTubeAssemblerContext; 46 import com.sun.xml.internal.ws.api.pipe.ThrowableContainerPropertySet; 47 import com.sun.xml.internal.ws.api.pipe.Tube; 48 import com.sun.xml.internal.ws.policy.PolicyMap; 49 import com.sun.xml.internal.ws.server.EndpointAwareTube; 50 import com.sun.xml.internal.ws.server.EndpointFactory; 51 import com.sun.xml.internal.ws.util.ServiceFinder; 52 import com.sun.xml.internal.ws.util.xml.XmlUtil; 53 import com.sun.xml.internal.ws.wsdl.OperationDispatcher; 54 import com.sun.org.glassfish.gmbal.ManagedObjectManager; 55 import org.xml.sax.EntityResolver; 56 import org.w3c.dom.Element; 57 58 import javax.xml.namespace.QName; 59 import javax.xml.ws.Binding; 60 import javax.xml.ws.EndpointReference; 61 import javax.xml.ws.WebServiceContext; 62 import javax.xml.ws.WebServiceException; 63 64 import java.net.URL; 65 import java.util.Collection; 66 import java.util.Collections; 67 import java.util.Iterator; 68 import java.util.List; 69 import java.util.Set; 70 import java.util.concurrent.Executor; 71 72 /** 73 * Root object that hosts the {@link Packet} processing code 74 * at the server. 75 * 76 * <p> 77 * One instance of {@link WSEndpoint} is created for each deployed service 78 * endpoint. A hosted service usually handles multiple concurrent 79 * requests. To do this efficiently, an endpoint handles incoming 80 * {@link Packet} through {@link PipeHead}s, where many copies can be created 81 * for each endpoint. 82 * 83 * <p> 84 * Each {@link PipeHead} is thread-unsafe, and request needs to be 85 * serialized. A {@link PipeHead} represents a sizable resource 86 * (in particular a whole pipeline), so the caller is expected to 87 * reuse them and avoid excessive allocations as much as possible. 88 * Making {@link PipeHead}s thread-unsafe allow the JAX-WS RI internal to 89 * tie thread-local resources to {@link PipeHead}, and reduce the total 90 * resource management overhead. 91 * 92 * <p> 93 * To abbreviate this resource management (and for a few other reasons), 94 * JAX-WS RI provides {@link Adapter} class. If you are hosting a JAX-WS 95 * service, you'll most likely want to send requests to {@link WSEndpoint} 96 * through {@link Adapter}. 97 * 98 * <p> 99 * {@link WSEndpoint} is ready to handle {@link Packet}s as soon as 100 * it's created. No separate post-initialization step is necessary. 101 * However, to comply with the JAX-WS spec requirement, the caller 102 * is expected to call the {@link #dispose()} method to allow an 103 * orderly shut-down of a hosted service. 104 * 105 * 106 * 107 * <h3>Objects Exposed From Endpoint</h3> 108 * <p> 109 * {@link WSEndpoint} exposes a series of information that represents 110 * how an endpoint is configured to host a service. See the getXXX methods 111 * for more details. 112 * 113 * 114 * 115 * <h3>Implementation Notes</h3> 116 * <p> 117 * {@link WSEndpoint} owns a {@link WSWebServiceContext} implementation. 118 * But a bulk of the work is delegated to {@link WebServiceContextDelegate}, 119 * which is passed in as a parameter to {@link PipeHead#process(Packet, WebServiceContextDelegate, TransportBackChannel)}. 120 * 121 * @author Kohsuke Kawaguchi 122 */ 123 public abstract class WSEndpoint<T> implements ComponentRegistry { 124 125 /** 126 * Gets the Endpoint's codec that is used to encode/decode {@link Message}s. This is a 127 * copy of the master codec and it shouldn't be shared across two requests running 128 * concurrently(unless it is stateless). 129 * 130 * @return codec to encode/decode 131 */ 132 public abstract @NotNull Codec createCodec(); 133 134 /** 135 * Gets the application endpoint's serviceName. It could be got from DD or annotations 136 * 137 * @return same as wsdl:service QName if WSDL exists or generated 138 */ 139 public abstract @NotNull QName getServiceName(); 140 141 /** 142 * Gets the application endpoint's portName. It could be got from DD or annotations 143 * 144 * @return same as wsdl:port QName if WSDL exists or generated 145 */ 146 public abstract @NotNull QName getPortName(); 147 148 /** 149 * Gets the application endpoint {@link Class} that eventually serves the request. 150 * 151 * <p> 152 * This is the same value given to the {@link #create} method. 153 */ 154 public abstract @NotNull Class<T> getImplementationClass(); 155 156 /** 157 * Represents the binding for which this {@link WSEndpoint} 158 * is created for. 159 * 160 * @return 161 * always same object. 162 */ 163 public abstract @NotNull WSBinding getBinding(); 164 165 /** 166 * Gets the {@link Container} object. 167 * 168 * <p> 169 * The components inside {@link WSEndpoint} uses this reference 170 * to communicate with the hosting environment. 171 * 172 * @return 173 * always same object. If no "real" {@link Container} instance 174 * is given, {@link Container#NONE} will be returned. 175 */ 176 public abstract @NotNull Container getContainer(); 177 178 /** 179 * Gets the port that this endpoint is serving. 180 * 181 * <p> 182 * A service is not required to have a WSDL, and when it doesn't, 183 * this method returns null. Otherwise it returns an object that 184 * describes the port that this {@link WSEndpoint} is serving. 185 * 186 * @return 187 * Possibly null, but always the same value. 188 */ 189 public abstract @Nullable WSDLPort getPort(); 190 191 /** 192 * Set this {@link Executor} to run asynchronous requests using this executor. 193 * This executor is set on {@link Engine} and must be set before 194 * calling {@link #schedule(Packet,CompletionCallback) } and 195 * {@link #schedule(Packet,CompletionCallback,FiberContextSwitchInterceptor)} methods. 196 * 197 * @param exec Executor to run async requests 198 */ 199 public abstract void setExecutor(@NotNull Executor exec); 200 201 /** 202 * This method takes a {@link Packet} that represents 203 * a request, run it through a {@link Tube}line, eventually 204 * pass it to the user implementation code, which produces 205 * a reply, then run that through the tubeline again, 206 * and eventually return it as a return value through {@link CompletionCallback}. 207 * 208 * <p> 209 * This takes care of pooling of {@link Tube}lines and reuses 210 * tubeline for requests. Same instance of tubeline is not used concurrently 211 * for two requests. 212 * 213 * <p> 214 * If the transport is capable of asynchronous execution, use this 215 * instead of using {@link PipeHead#process}. 216 * 217 * <p> 218 * Before calling this method, set the executor using {@link #setExecutor}. The 219 * executor may used multiple times to run this request in a asynchronous fashion. 220 * The calling thread will be returned immediately, and the callback will be 221 * called in a different a thread. 222 * 223 * <p> 224 * {@link Packet#transportBackChannel} should have the correct value, so that 225 * one-way message processing happens correctly. {@link Packet#webServiceContextDelegate} 226 * should have the correct value, so that some {@link WebServiceContext} methods correctly. 227 * 228 * @see Packet#transportBackChannel 229 * @see Packet#webServiceContextDelegate 230 * 231 * @param request web service request 232 * @param callback callback to get response packet 233 */ 234 public final void schedule(@NotNull Packet request, @NotNull CompletionCallback callback ) { 235 schedule(request,callback,null); 236 } 237 238 /** 239 * Schedule invocation of web service asynchronously. 240 * 241 * @see #schedule(Packet, CompletionCallback) 242 * 243 * @param request web service request 244 * @param callback callback to get response packet(exception if there is one) 245 * @param interceptor caller's interceptor to impose a context of execution 246 */ 247 public abstract void schedule(@NotNull Packet request, @NotNull CompletionCallback callback, @Nullable FiberContextSwitchInterceptor interceptor ); 248 249 public void process(@NotNull Packet request, @NotNull CompletionCallback callback, @Nullable FiberContextSwitchInterceptor interceptor ) { 250 schedule(request,callback,interceptor); 251 } 252 253 /** 254 * Returns {@link Engine} for this endpoint 255 * @return Engine 256 */ 257 public Engine getEngine() { 258 throw new UnsupportedOperationException(); 259 } 260 261 /** 262 * Callback to notify that jax-ws runtime has finished execution of a request 263 * submitted via schedule(). 264 */ 265 public interface CompletionCallback { 266 /** 267 * Indicates that the jax-ws runtime has finished execution of a request 268 * submitted via schedule(). 269 * 270 * <p> 271 * Since the JAX-WS RI runs asynchronously, 272 * this method maybe invoked by a different thread 273 * than any of the threads that started it or run a part of tubeline. 274 * 275 * @param response {@link Packet} 276 */ 277 void onCompletion(@NotNull Packet response); 278 } 279 280 /** 281 * Creates a new {@link PipeHead} to process 282 * incoming requests. 283 * 284 * <p> 285 * This is not a cheap operation. The caller is expected 286 * to reuse the returned {@link PipeHead}. See 287 * {@link WSEndpoint class javadoc} for details. 288 * 289 * @return 290 * A newly created {@link PipeHead} that's ready to serve. 291 */ 292 public abstract @NotNull PipeHead createPipeHead(); 293 294 /** 295 * Represents a resource local to a thread. 296 * 297 * See {@link WSEndpoint} class javadoc for more discussion about 298 * this. 299 */ 300 public interface PipeHead { 301 /** 302 * Processes a request and produces a reply. 303 * 304 * <p> 305 * This method takes a {@link Packet} that represents 306 * a request, run it through a {@link Tube}line, eventually 307 * pass it to the user implementation code, which produces 308 * a reply, then run that through the pipeline again, 309 * and eventually return it as a return value. 310 * 311 * @param request 312 * Unconsumed {@link Packet} that represents 313 * a request. 314 * @param wscd 315 * {@link WebServiceContextDelegate} to be set to {@link Packet}. 316 * (we didn't have to take this and instead just ask the caller to 317 * set to {@link Packet#webServiceContextDelegate}, but that felt 318 * too error prone.) 319 * @param tbc 320 * {@link TransportBackChannel} to be set to {@link Packet}. 321 * See the {@code wscd} parameter javadoc for why this is a parameter. 322 * Can be null. 323 * @return 324 * Unconsumed {@link Packet} that represents 325 * a reply to the request. 326 * 327 * @throws WebServiceException 328 * This method <b>does not</b> throw a {@link WebServiceException}. 329 * The {@link WSEndpoint} must always produce a fault {@link Message} 330 * for it. 331 * 332 * @throws RuntimeException 333 * A {@link RuntimeException} thrown from this method, including 334 * {@link WebServiceException}, must be treated as a bug in the 335 * code (including JAX-WS and all the pipe implementations), not 336 * an operator error by the user. 337 * 338 * <p> 339 * Therefore, it should be recorded by the caller in a way that 340 * allows developers to fix a bug. 341 */ 342 @NotNull Packet process( 343 @NotNull Packet request, @Nullable WebServiceContextDelegate wscd, @Nullable TransportBackChannel tbc); 344 } 345 346 /** 347 * Indicates that the {@link WSEndpoint} is about to be turned off, 348 * and will no longer serve any packet anymore. 349 * 350 * <p> 351 * This method needs to be invoked for the JAX-WS RI to correctly 352 * implement some of the spec semantics (TODO: pointer.) 353 * It's the responsibility of the code that hosts a {@link WSEndpoint} 354 * to invoke this method. 355 * 356 * <p> 357 * Once this method is called, the behavior is undefed for 358 * all in-progress {@link PipeHead#process} methods (by other threads) 359 * and future {@link PipeHead#process} method invocations. 360 */ 361 public abstract void dispose(); 362 363 /** 364 * Gets the description of the service. 365 * 366 * <p> 367 * A description is a set of WSDL/schema and other documents that together 368 * describes a service. 369 * A service is not required to have a description, and when it doesn't, 370 * this method returns null. 371 * 372 * @return 373 * Possibly null, always the same value under ordinary circumstances but 374 * may change if the endpoint is managed. 375 */ 376 public abstract @Nullable ServiceDefinition getServiceDefinition(); 377 378 /** 379 * Gets the list of {@link BoundEndpoint} that are associated 380 * with this endpoint. 381 * 382 * @return 383 * always return the same set. 384 */ 385 public List<BoundEndpoint> getBoundEndpoints() { 386 Module m = getContainer().getSPI(Module.class); 387 return m != null ? m.getBoundEndpoints() : null; 388 } 389 390 /** 391 * Gets the list of {@link EndpointComponent} that are associated 392 * with this endpoint. 393 * 394 * <p> 395 * Components (such as codec, tube, handler, etc) who wish to provide 396 * some service to other components in the endpoint can iterate the 397 * registry and call its {@link EndpointComponent#getSPI(Class)} to 398 * establish a private contract between components. 399 * <p> 400 * Components who wish to subscribe to such a service can add itself 401 * to this set. 402 * 403 * @return 404 * always return the same set. 405 * @deprecated 406 */ 407 public abstract @NotNull Set<EndpointComponent> getComponentRegistry(); 408 409 public @NotNull Set<Component> getComponents() { 410 return Collections.emptySet(); 411 } 412 413 public @Nullable <S> S getSPI(@NotNull Class<S> spiType) { 414 Set<Component> componentRegistry = getComponents(); 415 if (componentRegistry != null) { 416 for (Component c : componentRegistry) { 417 S s = c.getSPI(spiType); 418 if (s != null) 419 return s; 420 } 421 } 422 return getContainer().getSPI(spiType); 423 } 424 425 /** 426 * Gets the {@link com.sun.xml.internal.ws.api.model.SEIModel} that represents the relationship 427 * between WSDL and Java SEI. 428 * 429 * <p> 430 * This method returns a non-null value if and only if this 431 * endpoint is ultimately serving an application through an SEI. 432 * 433 * @return 434 * maybe null. See above for more discussion. 435 * Always the same value. 436 */ 437 public abstract @Nullable SEIModel getSEIModel(); 438 439 /** 440 * Gives the PolicMap that captures the Policy for the endpoint 441 * 442 * @return PolicyMap 443 * 444 * @deprecated 445 * Do not use this method as the PolicyMap API is not final yet and might change in next few months. 446 */ 447 public abstract PolicyMap getPolicyMap(); 448 449 /** 450 * Get the ManagedObjectManager for this endpoint. 451 */ 452 public abstract @NotNull ManagedObjectManager getManagedObjectManager(); 453 454 /** 455 * Close the ManagedObjectManager for this endpoint. 456 * This is used by the Web Service Configuration Management system so that it 457 * closes the MOM before it creates a new WSEndpoint. Then it calls dispose 458 * on the existing endpoint and then installs the new endpoint. 459 * The call to dispose also calls closeManagedObjectManager, but is a noop 460 * if that method has already been called. 461 */ 462 public abstract void closeManagedObjectManager(); 463 464 /** 465 * This is only needed to expose info for monitoring. 466 */ 467 public abstract @NotNull ServerTubeAssemblerContext getAssemblerContext(); 468 469 /** 470 * Creates an endpoint from deployment or programmatic configuration 471 * 472 * <p> 473 * This method works like the following: 474 * <ol> 475 * <li>{@link ServiceDefinition} is modeleed from the given SEI type. 476 * <li>{@link Invoker} that always serves {@code implementationObject} will be used. 477 * </ol> 478 * @param implType 479 * Endpoint class(not SEI). Enpoint class must have @WebService or @WebServiceProvider 480 * annotation. 481 * @param processHandlerAnnotation 482 * Flag to control processing of @HandlerChain on Impl class 483 * if true, processes @HandlerChain on Impl 484 * if false, DD might have set HandlerChain no need to parse. 485 * @param invoker 486 * Pass an object to invoke the actual endpoint object. If it is null, a default 487 * invoker is created using {@link InstanceResolver#createDefault}. Appservers 488 * could create its own invoker to do additional functions like transactions, 489 * invoking the endpoint through proxy etc. 490 * @param serviceName 491 * Optional service name(may be from DD) to override the one given by the 492 * implementation class. If it is null, it will be derived from annotations. 493 * @param portName 494 * Optional port name(may be from DD) to override the one given by the 495 * implementation class. If it is null, it will be derived from annotations. 496 * @param container 497 * Allows technologies that are built on top of JAX-WS(such as WSIT) needs to 498 * negotiate private contracts between them and the container 499 * @param binding 500 * JAX-WS implementation of {@link Binding}. This object can be created by 501 * {@link BindingID#createBinding()}. Usually the binding can be got from 502 * DD, {@link javax.xml.ws.BindingType}. 503 * 504 * 505 * TODO: DD has a configuration for MTOM threshold. 506 * Maybe we need something more generic so that other technologies 507 * like Tango can get information from DD. 508 * 509 * TODO: does it really make sense for this to take EntityResolver? 510 * Given that all metadata has to be given as a list anyway. 511 * 512 * @param primaryWsdl 513 * The {@link ServiceDefinition#getPrimary() primary} WSDL. 514 * If null, it'll be generated based on the SEI (if this is an SEI) 515 * or no WSDL is associated (if it's a provider.) 516 * TODO: shouldn't the implementation find this from the metadata list? 517 * @param metadata 518 * Other documents that become {@link SDDocument}s. Can be null. 519 * @param resolver 520 * Optional resolver used to de-reference resources referenced from 521 * WSDL. Must be null if the {@code url} is null. 522 * @param isTransportSynchronous 523 * If the caller knows that the returned {@link WSEndpoint} is going to be 524 * used by a synchronous-only transport, then it may pass in {@code true} 525 * to allow the callee to perform an optimization based on that knowledge 526 * (since often synchronous version is cheaper than an asynchronous version.) 527 * This value is visible from {@link ServerTubeAssemblerContext#isSynchronous()}. 528 * 529 * @return newly constructed {@link WSEndpoint}. 530 * @throws WebServiceException 531 * if the endpoint set up fails. 532 */ 533 public static <T> WSEndpoint<T> create( 534 @NotNull Class<T> implType, 535 boolean processHandlerAnnotation, 536 @Nullable Invoker invoker, 537 @Nullable QName serviceName, 538 @Nullable QName portName, 539 @Nullable Container container, 540 @Nullable WSBinding binding, 541 @Nullable SDDocumentSource primaryWsdl, 542 @Nullable Collection<? extends SDDocumentSource> metadata, 543 @Nullable EntityResolver resolver, 544 boolean isTransportSynchronous) { 545 return create(implType, processHandlerAnnotation, invoker, serviceName, portName, container, binding, primaryWsdl, metadata, resolver, isTransportSynchronous, true); 546 } 547 548 public static <T> WSEndpoint<T> create( 549 @NotNull Class<T> implType, 550 boolean processHandlerAnnotation, 551 @Nullable Invoker invoker, 552 @Nullable QName serviceName, 553 @Nullable QName portName, 554 @Nullable Container container, 555 @Nullable WSBinding binding, 556 @Nullable SDDocumentSource primaryWsdl, 557 @Nullable Collection<? extends SDDocumentSource> metadata, 558 @Nullable EntityResolver resolver, 559 boolean isTransportSynchronous, 560 boolean isStandard) 561 { 562 final WSEndpoint<T> endpoint = 563 EndpointFactory.createEndpoint( 564 implType,processHandlerAnnotation, invoker,serviceName,portName,container,binding,primaryWsdl,metadata,resolver,isTransportSynchronous,isStandard); 565 566 final Iterator<ManagedEndpointFactory> managementFactories = ServiceFinder.find(ManagedEndpointFactory.class).iterator(); 567 if (managementFactories.hasNext()) { 568 final ManagedEndpointFactory managementFactory = managementFactories.next(); 569 final EndpointCreationAttributes attributes = new EndpointCreationAttributes( 570 processHandlerAnnotation, invoker, resolver, isTransportSynchronous); 571 572 WSEndpoint<T> managedEndpoint = managementFactory.createEndpoint(endpoint, attributes); 573 574 if (endpoint.getAssemblerContext().getTerminalTube() instanceof EndpointAwareTube) { 575 ((EndpointAwareTube)endpoint.getAssemblerContext().getTerminalTube()).setEndpoint(managedEndpoint); 576 } 577 578 return managedEndpoint; 579 } 580 581 582 return endpoint; 583 } 584 585 /** 586 * Deprecated version that assumes {@code isTransportSynchronous==false} 587 */ 588 @Deprecated 589 public static <T> WSEndpoint<T> create( 590 @NotNull Class<T> implType, 591 boolean processHandlerAnnotation, 592 @Nullable Invoker invoker, 593 @Nullable QName serviceName, 594 @Nullable QName portName, 595 @Nullable Container container, 596 @Nullable WSBinding binding, 597 @Nullable SDDocumentSource primaryWsdl, 598 @Nullable Collection<? extends SDDocumentSource> metadata, 599 @Nullable EntityResolver resolver) { 600 return create(implType,processHandlerAnnotation,invoker,serviceName,portName,container,binding,primaryWsdl,metadata,resolver,false); 601 } 602 603 604 /** 605 * The same as 606 * {@link #create(Class, boolean, Invoker, QName, QName, Container, WSBinding, SDDocumentSource, Collection, EntityResolver)} 607 * except that this version takes an url of the {@code jax-ws-catalog.xml}. 608 * 609 * @param catalogUrl 610 * if not null, an {@link EntityResolver} is created from it and used. 611 * otherwise no resolution will be performed. 612 */ 613 public static <T> WSEndpoint<T> create( 614 @NotNull Class<T> implType, 615 boolean processHandlerAnnotation, 616 @Nullable Invoker invoker, 617 @Nullable QName serviceName, 618 @Nullable QName portName, 619 @Nullable Container container, 620 @Nullable WSBinding binding, 621 @Nullable SDDocumentSource primaryWsdl, 622 @Nullable Collection<? extends SDDocumentSource> metadata, 623 @Nullable URL catalogUrl) { 624 return create( 625 implType,processHandlerAnnotation,invoker,serviceName,portName,container,binding,primaryWsdl,metadata, 626 XmlUtil.createEntityResolver(catalogUrl),false); 627 } 628 629 /** 630 * Gives the wsdl:service default name computed from the endpoint implementaiton class 631 */ 632 public static @NotNull QName getDefaultServiceName(Class endpointClass){ 633 return getDefaultServiceName(endpointClass, true, null); 634 } 635 public static @NotNull QName getDefaultServiceName(Class endpointClass, MetadataReader metadataReader){ 636 return getDefaultServiceName(endpointClass, true, metadataReader); 637 } 638 639 public static @NotNull QName getDefaultServiceName(Class endpointClass, boolean isStandard){ 640 return getDefaultServiceName(endpointClass, isStandard, null); 641 } 642 public static @NotNull QName getDefaultServiceName(Class endpointClass, boolean isStandard, MetadataReader metadataReader){ 643 return EndpointFactory.getDefaultServiceName(endpointClass, isStandard, metadataReader); 644 } 645 646 /** 647 * Gives the wsdl:service/wsdl:port default name computed from the endpoint implementaiton class 648 */ 649 public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass) { 650 return getDefaultPortName(serviceName, endpointClass, null); 651 } 652 public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass, MetadataReader metadataReader) { 653 return getDefaultPortName(serviceName, endpointClass, true, metadataReader); 654 } 655 656 public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass, boolean isStandard) { 657 return getDefaultPortName(serviceName, endpointClass, isStandard, null); 658 } 659 public static @NotNull QName getDefaultPortName(@NotNull QName serviceName, Class endpointClass, boolean isStandard, MetadataReader metadataReader){ 660 return EndpointFactory.getDefaultPortName(serviceName, endpointClass, isStandard, metadataReader); 661 } 662 663 /** 664 * Return EndpointReference instance, based on passed parameters and spec version represented by clazz 665 * @param <T> 666 * @param clazz represents spec version 667 * @param address endpoint address 668 * @param wsdlAddress wsdl address 669 * @param referenceParameters any reference parameters to be added to the instance 670 * @return EndpointReference instance based on passed parameters and values obtained from current instance 671 */ 672 public abstract <T extends EndpointReference> T getEndpointReference(Class<T> clazz, String address, String wsdlAddress, Element... referenceParameters); 673 674 /** 675 * 676 * @param <T> 677 * @param clazz 678 * @param address 679 * @param wsdlAddress 680 * @param metadata 681 * @param referenceParameters 682 * @return EndpointReference instance based on passed parameters and values obtained from current instance 683 */ 684 public abstract <T extends EndpointReference> T getEndpointReference(Class<T> clazz, 685 String address, String wsdlAddress, List<Element> metadata, 686 List<Element> referenceParameters); 687 688 /** 689 * Used for managed endpoints infrastructure to compare equality of proxies vs proxied endpoints. 690 * @param endpoint 691 * @return true if the proxied endpoint instance held by this instance equals to 'endpoint', otherwise return false. 692 */ 693 public boolean equalsProxiedInstance(WSEndpoint endpoint) { 694 if (endpoint == null) return false; 695 return this.equals(endpoint); 696 } 697 698 /** 699 * Nullable when there is no associated WSDL Model 700 * @return 701 */ 702 public abstract @Nullable OperationDispatcher getOperationDispatcher(); 703 704 705 /** 706 * This is used by WsaServerTube and WSEndpointImpl to create a Packet with SOAPFault message from a Java exception. 707 */ 708 public abstract Packet createServiceResponseForException(final ThrowableContainerPropertySet tc, 709 final Packet responsePacket, 710 final SOAPVersion soapVersion, 711 final WSDLPort wsdlPort, 712 final SEIModel seiModel, 713 final WSBinding binding); 714 }