|
1 package org.objectweb.celtix.bindings;
2
3 import java.io.IOException  ;
4 import java.io.OutputStream ;
5 import java.lang.reflect.InvocationTargetException ;
6 import java.util.logging.Level ;
7 import java.util.logging.Logger ;
8
9 import javax.xml.namespace.QName ;
10 import javax.xml.ws.WebServiceException;
11 import javax.xml.ws.handler.MessageContext;
12
13 import org.objectweb.celtix.common.i18n.Message;
14 import org.objectweb.celtix.common.logging.LogUtils;
15 import org.objectweb.celtix.context.InputStreamMessageContext;
16 import org.objectweb.celtix.context.ObjectMessageContext;
17 import org.objectweb.celtix.context.OutputStreamMessageContext;
18 import org.objectweb.celtix.context.WebServiceContextImpl;
19 import org.objectweb.celtix.handlers.HandlerInvoker;
20 import org.objectweb.celtix.transports.ServerTransport;
21
22 public class ServerRequest {
23
24 public enum ServerRequestState {
25 STREAM_HANDLERS_INVOKED (1),
26 STREAM_READ (2),
27 PROTOCOL_HANDLERS_INVOKED (3),
28 UNMARSHALLED (4),
29 LOGICAL_HANDLERS_INVOKED (5),
30 DISPATCHED (6);
31
32 private final int val;
33
34 ServerRequestState(int v) {
35 this.val = v;
36 }
37
38 public int value() {
39 return val;
40 }
41 }
42
43 private static final Logger LOG = LogUtils.getL7dLogger(ServerRequest.class);
44
45 private final AbstractBindingBase binding;
46 private HandlerInvoker handlerInvoker;
47
48 private InputStreamMessageContext istreamCtx;
49 private MessageContext bindingCtx;
50 private ObjectMessageContext objectCtx;
51 private ServerRequestState state;
52 private boolean isOneway;
53 private boolean isOnewayDetermined;
54
55 public ServerRequest(AbstractBindingBase b, InputStreamMessageContext i) {
56 binding = b;
57 istreamCtx = i;
58 istreamCtx.put(ObjectMessageContext.MESSAGE_INPUT, Boolean.FALSE);
59 }
60
61
69 public ServerRequest(AbstractBindingBase b, ObjectMessageContext objectContext) {
70 binding = b;
71 objectCtx = objectContext;
72 handlerInvoker = binding.createHandlerInvoker();
73 state = ServerRequestState.DISPATCHED;
74 }
75
76 public AbstractBindingBase getBinding() {
77 return binding;
78 }
79
80 public HandlerInvoker getHandlerInvoker() {
81 return handlerInvoker;
82 }
83
84 public void setHandlerInvoker(HandlerInvoker h) {
85 handlerInvoker = h;
86 }
87
88 public MessageContext getBindingCtx() {
89 return bindingCtx;
90 }
91
92 public ObjectMessageContext getObjectCtx() {
93 return objectCtx;
94 }
95
96 public ServerRequestState getState() {
97 return state;
98 }
99
100 public void processInbound() {
101
102 if (null == handlerInvoker) {
103 handlerInvoker = binding.createHandlerInvoker();
104 }
105 handlerInvoker.setInbound();
106
107 handlerInvoker.invokeStreamHandlers(istreamCtx);
108 state = ServerRequestState.STREAM_HANDLERS_INVOKED;
109
110 if (bindingCtx == null) {
111 bindingCtx = binding.getBindingImpl().createBindingMessageContext(istreamCtx);
112 } else {
113 bindingCtx.putAll(istreamCtx);
114 }
115 bindingCtx.put(ObjectMessageContext.MESSAGE_INPUT, Boolean.FALSE);
116
117 try {
118 binding.getBindingImpl().read(istreamCtx, bindingCtx);
119 state = ServerRequestState.STREAM_READ;
120 } catch (IOException ex) {
121 LOG.log(Level.SEVERE, "REQUEST_UNREADABLE_MSG", ex);
122 throw new WebServiceException(ex);
123 }
124
125 boolean continueProcessing = handlerInvoker.invokeProtocolHandlers(isRequestor(), bindingCtx);
126 state = ServerRequestState.PROTOCOL_HANDLERS_INVOKED;
127 if (!continueProcessing) {
128 return;
129 }
130
131
134 storeOperationName();
135
136 if (null == objectCtx) {
137 objectCtx = binding.createObjectContext();
138 initObjectContext(objectCtx);
139 objectCtx.putAll(bindingCtx);
140 }
141
142 binding.getBindingImpl().unmarshal(bindingCtx, objectCtx, getDataBindingCallback());
143 state = ServerRequestState.UNMARSHALLED;
144 objectCtx.put(OutputStreamMessageContext.ONEWAY_MESSAGE_TF, isOneway());
145
146 handlerInvoker.invokeLogicalHandlers(isRequestor(), objectCtx);
147
148 state = ServerRequestState.LOGICAL_HANDLERS_INVOKED;
149 }
150
151 public void doInvocation() {
152 LOG.fine("doInvocation");
153 QName operationName = (QName )objectCtx.get(MessageContext.WSDL_OPERATION);
154 if (null == operationName) {
155 Message msg = new Message("CONTEXT_MISSING_OPERATION_NAME_EXC", LOG);
156 LOG.log(Level.SEVERE, msg.toString());
157 objectCtx.setException(new WebServiceException(msg.toString()));
158 return;
159 }
160 if (LOG.isLoggable(Level.FINE)) {
161 LOG.fine("operation name: " + operationName);
162 }
163
164
165
166 ServerDataBindingCallback method = (ServerDataBindingCallback)
167 BindingContextUtils.retrieveDataBindingCallback(objectCtx);
168 if (null == method) {
169 Message msg = new Message("IMPLEMENTOR_MISSING_METHOD_EXC", LOG, operationName);
170 LOG.log(Level.SEVERE, msg.toString());
171 objectCtx.setException(new WebServiceException(msg.toString()));
172 return;
173 }
174 if (LOG.isLoggable(Level.FINE)) {
175 LOG.fine("method: " + method);
176 }
177
178 try {
179 new WebServiceContextImpl(objectCtx);
180
181 method.invoke(objectCtx);
182 } catch (WebServiceException wex) {
183 Throwable cause = wex.getCause();
184 if (cause != null) {
185 objectCtx.setException(cause);
186 } else {
187 objectCtx.setException(wex);
188 }
189 } catch (InvocationTargetException ex) {
190 LogUtils.log(LOG, Level.FINE, "IMPLEMENTOR_INVOCATION_EXCEPTION_MSG",
191 ex, method.getOperationName());
192 Throwable cause = ex.getCause();
193 if (cause != null) {
194 objectCtx.setException(cause);
195 } else {
196 objectCtx.setException(ex);
197 }
198 }
199
200 state = ServerRequestState.DISPATCHED;
201 }
202
203 public void processOutbound(ServerTransport st, Exception inboundException) {
204 processOutbound(st, inboundException, false);
205 }
206
207 public void processOutbound(ServerTransport st,
208 Exception inboundException,
209 boolean logicalChainTraversed) {
210 if (LOG.isLoggable(Level.FINE)) {
211 LOG.info("Reverse processing inbound message, exception: " + inboundException);
212 }
213
214 handlerInvoker.setOutbound();
215
216 ObjectMessageContext replyObjectCtx = objectCtx;
217 if (null == replyObjectCtx) {
218 replyObjectCtx = binding.createObjectContext();
219 }
220 replyObjectCtx.put(ObjectMessageContext.MESSAGE_INPUT, Boolean.TRUE);
221
222 if (null != inboundException) {
223 replyObjectCtx.setException(inboundException);
224 }
225
226
231 if (!logicalChainTraversed
232 && state.value() >= ServerRequestState.LOGICAL_HANDLERS_INVOKED.value()
233 && !isOneway()) {
234
235
238 handlerInvoker.invokeLogicalHandlers(isRequestor(), replyObjectCtx);
239 }
240
241
244 MessageContext replyBindingCtx = bindingCtx;
245 if (null == replyBindingCtx) {
246 bindingCtx = binding.getBindingImpl().createBindingMessageContext(replyObjectCtx);
247 replyBindingCtx = bindingCtx;
248 } else if (null != replyObjectCtx) {
249 replyBindingCtx.putAll(replyObjectCtx);
250 }
251
252
253
255 if (handlerInvoker.faultRaised(replyObjectCtx)) {
256 LOG.fine("Marshalling fault.");
257 marshalFault(replyObjectCtx, replyBindingCtx);
258 } else if (null != replyObjectCtx.get(ObjectMessageContext.MESSAGE_PAYLOAD)
259 || state.value() >= ServerRequestState.DISPATCHED.value()
260 || null != replyObjectCtx.get(ObjectMessageContext.METHOD_RETURN)) {
261 LOG.fine("Marshalling.");
262 marshal(replyObjectCtx, replyBindingCtx);
263 }
264
265
272 if (state.value() >= ServerRequestState.PROTOCOL_HANDLERS_INVOKED.value() && !isOneway()) {
273
274
279 handlerInvoker.invokeProtocolHandlers(isRequestor(), replyBindingCtx);
280
281 if (handlerInvoker.faultRaised(replyBindingCtx)
282 && !binding.getBindingImpl().hasFault(replyBindingCtx)) {
283 LOG.fine("Marshalling fault raised by protocol handlers.");
284 replyObjectCtx.setException((Exception )replyBindingCtx.get(
285 ObjectMessageContext.METHOD_FAULT));
286 marshalFault(replyObjectCtx, replyBindingCtx);
287 }
288 }
289
290
292 binding.getBindingImpl().updateMessageContext(replyBindingCtx);
293
294 try {
295
296 OutputStreamMessageContext ostreamCtx = st.createOutputStreamContext(replyBindingCtx);
297 ostreamCtx.setOneWay(isOneway());
298
299 if (isOneway()) {
300 st.finalPrepareOutputStreamContext(ostreamCtx);
301 } else {
302
303 if (binding.getBindingImpl().hasFault(replyBindingCtx)) {
304 ostreamCtx.setFault(true);
305 }
306
307 handlerInvoker.invokeStreamHandlers(ostreamCtx);
308 st.finalPrepareOutputStreamContext(ostreamCtx);
309 binding.getBindingImpl().write(replyBindingCtx, ostreamCtx);
310 OutputStream os = ostreamCtx.getOutputStream();
311 os.flush();
312 }
313
314 LOG.fine("postDispatch from binding on thread : " + Thread.currentThread());
315 st.postDispatch(replyBindingCtx, ostreamCtx);
316 if (ostreamCtx.getOutputStream() != null) {
317 ostreamCtx.getOutputStream().close();
318 }
319 } catch (IOException ex) {
320 LOG.log(Level.SEVERE, "RESPONSE_UNWRITABLE_MSG", ex);
321 throw new WebServiceException(ex);
322 } finally {
323 complete();
324 }
325 }
326
327 public void complete() {
328 handlerInvoker.mepComplete(istreamCtx);
329 }
330
331 public boolean isRequestor() {
332 return false;
333 }
334
335 public boolean isOneway() {
336 if (!isOnewayDetermined) {
337 isOneway = BindingContextUtils.isOnewayMethod(bindingCtx);
338 }
339 return isOneway;
340 }
341
342 public void setOneway(boolean oneway) {
343 isOneway = oneway;
344 isOnewayDetermined = true;
345 }
346
347 public boolean doDispatch() {
348 return state.value() >= ServerRequestState.LOGICAL_HANDLERS_INVOKED.value()
349 && handlerInvoker.isInbound()
350 && objectCtx != null
351 && BindingContextUtils.retrieveDispatch(objectCtx);
352 }
353
354 protected void storeOperationName() {
355 AbstractServerBinding sb = (AbstractServerBinding)binding;
356 if (bindingCtx.containsKey(MessageContext.WSDL_OPERATION)) {
357 if (LOG.isLoggable(Level.FINE)) {
358 LOG.fine("Determined operation using pre-existing operation name: "
359 + bindingCtx.get(MessageContext.WSDL_OPERATION));
360 }
361 return;
362 }
363
364 QName operationName = sb.getOperationName(bindingCtx);
365
366 if (null != operationName) {
367 bindingCtx.put(MessageContext.WSDL_OPERATION, operationName);
368 } else {
369 throw new WebServiceException("No operation matching message was found");
370 }
371
372 if (LOG.isLoggable(Level.FINE)) {
373 LOG.fine("Determined operation name using server binding endpoint callback: "
374 + operationName);
375 }
376 }
377
378 public ServerDataBindingCallback getDataBindingCallback() {
379 ServerDataBindingCallback callback =
380 (ServerDataBindingCallback)BindingContextUtils.retrieveDataBindingCallback(bindingCtx);
381 if (null == callback) {
382 assert null != objectCtx;
383 ServerBindingEndpointCallback sbeCallback = BindingContextUtils
384 .retrieveServerBindingEndpointCallback(bindingCtx);
385 DataBindingCallback.Mode mode = sbeCallback.getServiceMode();
386 callback = sbeCallback
387 .getDataBindingCallback((QName )bindingCtx.get(MessageContext.WSDL_OPERATION),
388 objectCtx, mode);
389 if (LOG.isLoggable(Level.FINE)) {
390 LOG.fine("Using data binding callback constructed by server endpoint callback: " + callback);
391 }
392 BindingContextUtils.storeDataBindingCallback(bindingCtx, callback);
393 } else if (LOG.isLoggable(Level.FINE)) {
394 LOG.fine("Using data binding callback stored in context.");
395 }
396 return callback;
397 }
398
399
400 private void initObjectContext(ObjectMessageContext octx) {
401 getDataBindingCallback().initObjectContext(octx);
402 }
403
404
405 private void marshalFault(ObjectMessageContext octx, MessageContext bctx) {
406 DataBindingCallback callback =
407 BindingContextUtils.retrieveDataBindingCallback(bindingCtx);
408 if (null == callback) {
409 ServerBindingEndpointCallback sbeCallback = BindingContextUtils
410 .retrieveServerBindingEndpointCallback(bindingCtx);
411 callback = sbeCallback.getFaultDataBindingCallback(octx);
412 }
413 if (null == callback) {
414 LOG.log(Level.SEVERE, "NO_DATA_BINDING_CALLBACK");
416 }
417 try {
418 binding.getBindingImpl().marshalFault(octx, bctx, callback);
419 } catch (Exception ex) {
420 LOG.log(Level.SEVERE, "COULD_NOT_MARSHAL_FAULT_MSG", ex);
421 }
422 }
423
424 private void marshal(ObjectMessageContext octx, MessageContext bctx) {
425 DataBindingCallback callback = getDataBindingCallback();
426 if (null == callback) {
427 LOG.log(Level.SEVERE, "NO_DATA_BINDING_CALLBACK");
429 } else {
430 try {
431 binding.getBindingImpl().marshal(octx, bctx, callback);
432 } catch (Exception ex) {
433 LOG.log(Level.SEVERE, "COULD_NOT_MARSHAL_MSG", ex);
434 }
435 }
436 }
437
438 }
439 |
Popular Tags |
Java API By Example, From Geeks To Geeks.