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 <tt>implementationObject</tt> 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 <tt>true</tt>
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 <tt>isTransportSynchronous==false</tt>
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 <tt>jax-ws-catalog.xml</tt>.
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 }