|
1 package org.objectweb.celtix.bindings;
2
3 import java.io.IOException  ;
4 import java.io.InputStream ;
5 import java.lang.ref.WeakReference ;
6 import java.util.List ;
7 import java.util.concurrent.Executor ;
8 import java.util.concurrent.Future ;
9 import java.util.logging.Level ;
10 import java.util.logging.Logger ;
11
12 import javax.wsdl.Port;
13 import javax.wsdl.WSDLException;
14 import javax.wsdl.extensions.ExtensibilityElement;
15 import javax.xml.ws.handler.MessageContext;
16
17 import org.objectweb.celtix.Bus;
18 import org.objectweb.celtix.BusException;
19 import org.objectweb.celtix.buslifecycle.BusLifeCycleListener;
20 import org.objectweb.celtix.common.i18n.Message;
21 import org.objectweb.celtix.common.injection.ResourceInjector;
22 import org.objectweb.celtix.common.logging.LogUtils;
23 import org.objectweb.celtix.configuration.Configuration;
24 import org.objectweb.celtix.context.InputStreamMessageContext;
25 import org.objectweb.celtix.context.ObjectMessageContext;
26 import org.objectweb.celtix.context.OutputStreamMessageContext;
27 import org.objectweb.celtix.handlers.HandlerInvoker;
28 import org.objectweb.celtix.resource.DefaultResourceManager;
29 import org.objectweb.celtix.resource.ResourceManager;
30 import org.objectweb.celtix.resource.ResourceResolver;
31 import org.objectweb.celtix.transports.ClientTransport;
32 import org.objectweb.celtix.transports.TransportFactory;
33 import org.objectweb.celtix.ws.addressing.EndpointReferenceType;
34 import org.objectweb.celtix.wsdl.EndpointReferenceUtils;
35
36 import static org.objectweb.celtix.bindings.JAXWSConstants.BUS_PROPERTY;
37 import static org.objectweb.celtix.bindings.JAXWSConstants.CLIENT_BINDING_PROPERTY;
38 import static org.objectweb.celtix.bindings.JAXWSConstants.CLIENT_TRANSPORT_PROPERTY;
39
40 public abstract class AbstractClientBinding extends AbstractBindingBase implements ClientBinding {
41 private static final Logger LOG = LogUtils.getL7dLogger(AbstractClientBinding.class);
42
43 protected Port port;
44 private ResponseCorrelator responseCorrelator;
45
46 public AbstractClientBinding(Bus b, EndpointReferenceType ref) throws WSDLException, IOException {
47 super(b, ref);
48 bus.getLifeCycleManager().registerLifeCycleListener(new ShutdownListener(this));
49 transport = null;
50 }
51
52 private class ShutdownListener extends WeakReference <AbstractClientBinding> implements
53 BusLifeCycleListener {
54
55 ShutdownListener(AbstractClientBinding c) {
56 super(c);
57 }
58
59 public void initComplete() {
60 }
62
63 public void preShutdown() {
64 if (get() != null) {
65 get().shutdown();
66 clear();
67 }
68 }
69
70 public void postShutdown() {
71 clearResponseCorrelator();
72 }
73 }
74
75 public void clearResponseCorrelator() {
76 responseCorrelator = null;
77 }
78
79
81 public abstract AbstractBindingImpl getBindingImpl();
82
83
85
87 public void configureSystemHandlers(Configuration endpointConfiguration) {
88 super.configureSystemHandlers(endpointConfiguration);
89
90 ResourceManager rm = new DefaultResourceManager();
91 rm.addResourceResolver(new ResourceResolver() {
92 @SuppressWarnings ("unchecked")
93 public <T> T resolve(String resourceName, Class <T> resourceType) {
94 if (BUS_PROPERTY.equals(resourceName)) {
95 return (T)AbstractClientBinding.this.getBus();
96 } else if (CLIENT_BINDING_PROPERTY.equals(resourceName)) {
97 return (T)AbstractClientBinding.this;
98 } else if (CLIENT_TRANSPORT_PROPERTY.equals(resourceName)) {
99 try {
100 return (T)AbstractClientBinding.this.getTransport();
101 } catch (IOException ex) {
102 Message msg = new Message("SYSTEM_HANDLER_RESOURCE_INJECTION_FAILURE_MSG",
103 LOG, resourceName);
104 LOG.log(Level.WARNING, msg.toString(), ex);
105 }
106 }
107 return null;
108 }
109
110 public InputStream getAsStream(String name) {
111 return null;
112 }
113 });
114 ResourceInjector injector = new ResourceInjector(rm);
115 getBindingImpl().injectSystemHandlers(injector);
116
117 }
118
119
121
123 public ObjectMessageContext invoke(ObjectMessageContext objectCtx, DataBindingCallback callback)
124 throws IOException {
125
126 BindingContextUtils.storeDataBindingCallback(objectCtx, callback);
128
129 Request request = new Request(this, getTransport(), objectCtx);
130
131 try {
132 OutputStreamMessageContext ostreamCtx = request.process(null);
133
134 if (null != ostreamCtx) {
135
136 InputStreamMessageContext responseContext = clientTransport().invoke(ostreamCtx);
137 Response fullResponse = null;
138 if (BindingContextUtils.retrieveDecoupledResponse(responseContext)) {
139 Response partialResponse = new Response(request);
141 partialResponse.processProtocol(responseContext);
142 partialResponse.processLogical(callback);
143
144 if (BindingContextUtils.isOnewayMethod(objectCtx)) {
145 objectCtx = partialResponse.getObjectMessageContext();
147 } else {
148 fullResponse = getResponseCorrelator().getResponse(request);
151 fullResponse.setObjectMessageContext(objectCtx);
152 fullResponse.setHandlerInvoker(request.getHandlerInvoker());
153 fullResponse.processLogical(callback);
154 objectCtx = fullResponse.getObjectMessageContext();
155 }
156 } else {
157 fullResponse = new Response(request);
159 fullResponse.processProtocol(responseContext);
160 fullResponse.processLogical(callback);
161 objectCtx = fullResponse.getObjectMessageContext();
162 }
163
164 }
165
166 } finally {
167 request.complete();
168 }
169
170 return objectCtx;
171 }
172
173 public void invokeOneWay(ObjectMessageContext objectCtx, DataBindingCallback callback)
174 throws IOException {
175 BindingContextUtils.storeDataBindingCallback(objectCtx, callback);
177
178 Request request = new Request(this, getTransport(), objectCtx);
179 request.setOneway(true);
180
181 try {
182 OutputStreamMessageContext ostreamCtx = request.process(null);
183
184 if (null != ostreamCtx) {
185
190 if (BindingContextUtils.isOnewayTransport(ostreamCtx)) {
191 clientTransport().invokeOneway(ostreamCtx);
192 } else {
193 LOG.fine("Sending message as a twoway request as required by system handlers.");
194 InputStreamMessageContext istreamCtx = clientTransport().invoke(ostreamCtx);
195 Response response = new Response(request);
196 response.processProtocol(istreamCtx);
197 response.processLogical(null);
198 }
199 }
200
201 } finally {
202 request.complete();
203 }
204 }
205
206 public Future <ObjectMessageContext> invokeAsync(ObjectMessageContext objectCtx,
207 DataBindingCallback callback, Executor executor)
208 throws IOException {
209
210 BindingContextUtils.storeDataBindingCallback(objectCtx, callback);
212
213 Request request = new Request(this, getTransport(), objectCtx);
214 AsyncFuture asyncFuture = null;
215
216 try {
217 OutputStreamMessageContext ostreamCtx = request.process(null);
218
219 if (null != ostreamCtx) {
220
221 Future <InputStreamMessageContext> ins = clientTransport().invokeAsync(ostreamCtx, executor);
222 asyncFuture = new AsyncFuture(ins, this, callback, request.getHandlerInvoker(), objectCtx);
223 }
224
225 } finally {
226 request.complete();
227 }
228
229 return asyncFuture;
230 }
231
232 public synchronized ResponseCallback createResponseCallback() {
233 responseCorrelator = new ResponseCorrelator(this);
234 return responseCorrelator;
235 }
236
237
239
241 protected synchronized void shutdown() {
242 if (transport != null) {
243 transport.shutdown();
244 transport = null;
245 }
246 }
247
248 public synchronized ClientTransport getTransport() throws IOException {
249 if (transport == null) {
250 try {
251 transport = createTransport(reference);
252 } catch (WSDLException e) {
253 throw (IOException )(new IOException (e.getMessage()).initCause(e));
254 }
255 }
256 assert transport != null : "transport is null";
257 return clientTransport();
258 }
259
260 protected ClientTransport createTransport(EndpointReferenceType ref) throws WSDLException, IOException {
261 ClientTransport ret = null;
262 try {
263 LOG.info("creating client transport for " + ref);
264
265 port = EndpointReferenceUtils.getPort(bus.getWSDLManager(), ref);
266 List <?> exts = port.getExtensibilityElements();
267 if (exts.size() > 0) {
268 ExtensibilityElement el = (ExtensibilityElement)exts.get(0);
269
270 TransportFactory factory = bus.getTransportFactoryManager()
271 .getTransportFactory(el.getElementType().getNamespaceURI());
272 ret = factory.createClientTransport(ref, this);
273 }
274 } catch (BusException ex) {
275 LOG.severe("TRANSPORT_FACTORY_RETREIVAL_FAILURE_MSG");
276 }
277 assert ret != null;
278 return ret;
279 }
280
281 protected ClientTransport clientTransport() {
282 return (ClientTransport)transport;
283 }
284
285 public synchronized ResponseCorrelator getResponseCorrelator() {
286 if (responseCorrelator == null) {
287 responseCorrelator =
288 (ResponseCorrelator)clientTransport().getResponseCallback();
289 }
290 return responseCorrelator;
291 }
292
293 protected void finalPrepareOutputStreamContext(MessageContext bindingContext,
294 OutputStreamMessageContext ostreamContext)
295 throws IOException {
296 transport.finalPrepareOutputStreamContext(ostreamContext);
297 }
298
299 public ObjectMessageContext getObjectMessageContextAsync(InputStreamMessageContext ins,
300 HandlerInvoker handlerInvoker,
301 DataBindingCallback callback,
302 ObjectMessageContext objectCtx) {
303 Response response = new Response(this, handlerInvoker);
304 try {
305 response.setObjectMessageContext(objectCtx);
306 response.processProtocol(ins);
307 response.processLogical(callback);
308 } finally {
309 handlerInvoker.mepComplete(objectCtx);
310 }
311
312 return response.getObjectMessageContext();
313 }
314 }
315 |
Popular Tags |
Java API By Example, From Geeks To Geeks.