Java > Open Source Codes > com > sun > corba > se > impl > interceptors > InterceptorInvoker


1 /*
2  * @(#)InterceptorInvoker.java 1.32 03/12/19
3  *
4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7 package com.sun.corba.se.impl.interceptors;
8
9 import org.omg.CORBA.CompletionStatus ;
10 import org.omg.CORBA.INTERNAL ;
11 import org.omg.CORBA.SystemException ;
12 import org.omg.CORBA.portable.Delegate ;
13 import org.omg.PortableInterceptor.LOCATION_FORWARD ;
14 import org.omg.PortableInterceptor.SUCCESSFUL ;
15 import org.omg.PortableInterceptor.SYSTEM_EXCEPTION ;
16 import org.omg.PortableInterceptor.TRANSPORT_RETRY ;
17 import org.omg.PortableInterceptor.USER_EXCEPTION ;
18 import org.omg.PortableInterceptor.ClientRequestInfo ;
19 import org.omg.PortableInterceptor.ClientRequestInterceptor ;
20 import org.omg.PortableInterceptor.ForwardRequest ;
21 import org.omg.PortableInterceptor.IORInterceptor ;
22 import org.omg.PortableInterceptor.IORInterceptor_3_0 ;
23 import org.omg.PortableInterceptor.ServerRequestInfo ;
24 import org.omg.PortableInterceptor.ServerRequestInterceptor ;
25 import org.omg.PortableInterceptor.ObjectReferenceTemplate ;
26
27 import com.sun.corba.se.spi.ior.IOR;
28 import com.sun.corba.se.spi.oa.ObjectAdapter;
29 import com.sun.corba.se.spi.orb.ORB;
30 import com.sun.corba.se.impl.orbutil.ORBUtility;
31         
32 /**
33  * Handles invocation of interceptors. Has specific knowledge of how to
34  * invoke IOR, ClientRequest, and ServerRequest interceptors.
35  * Makes use of the InterceptorList to retrieve the list of interceptors to
36  * be invoked. Most methods in this class are package scope so that they
37  * may only be called from the PIHandlerImpl.
38  */
39 public class InterceptorInvoker {
40
41     // The ORB
42 private ORB orb;
43     
44     // The list of interceptors to be invoked
45 private InterceptorList interceptorList;
46
47     // True if interceptors are to be invoked, or false if not
48 // Note: This is a global enable/disable flag, whereas the enable flag
49 // in the RequestInfoStack in PIHandlerImpl is only for a particular Thread.
50 private boolean enabled = false;
51
52     // PICurrent variable.
53 private PICurrent current;
54
55     // NOTE: Be careful about adding additional attributes to this class.
56 // Multiple threads may be calling methods on this invoker at the same
57 // time.
58
59     /**
60      * Creates a new Interceptor Invoker. Constructor is package scope so
61      * only the ORB can create it. The invoker is initially disabled, and
62      * must be explicitly enabled using setEnabled().
63      */
64     InterceptorInvoker( ORB orb, InterceptorList interceptorList,
65                         PICurrent piCurrent )
66     {
67         this.orb = orb;
68     this.interceptorList = interceptorList;
69     this.enabled = false;
70         this.current = piCurrent;
71     }
72
73     /**
74      * Enables or disables the interceptor invoker
75      */
76     void setEnabled( boolean enabled ) {
77     this.enabled = enabled;
78     }
79     
80     /*
81      **********************************************************************
82      * IOR Interceptor invocation
83      **********************************************************************/
84
85     /**
86      * Called when a new POA is created.
87      *
88      * @param oa The Object Adapter associated with the IOR interceptor.
89      */
90     void objectAdapterCreated( ObjectAdapter oa ) {
91     // If invocation is not yet enabled, don't do anything.
92 if( enabled ) {
93         // Create IORInfo object to pass to IORInterceptors:
94 IORInfoImpl info = new IORInfoImpl( oa );
95
96         // Call each IORInterceptor:
97 IORInterceptor [] iorInterceptors =
98                 (IORInterceptor [])interceptorList.getInterceptors(
99                 InterceptorList.INTERCEPTOR_TYPE_IOR );
100         int size = iorInterceptors.length;
101
102         // Implementation note:
103 // This loop counts backwards for greater efficiency.
104 // Benchmarks have shown that counting down is more efficient
105 // than counting up in Java for loops, as a compare to zero is
106 // faster than a subtract and compare to zero. In this case,
107 // it doesn't really matter much, but it's simply a force of habit.
108
109         for( int i = (size - 1); i >= 0; i-- ) {
110         IORInterceptor interceptor = iorInterceptors[i];
111         try {
112             interceptor.establish_components( info );
113             }
114         catch( Exception e ) {
115             // as per PI spec (orbos/99-12-02 sec 7.2.1), if
116 // establish_components throws an exception, ignore it.
117 }
118         }
119
120         // Change the state so that only template operations are valid
121 info.makeStateEstablished() ;
122
123         for( int i = (size - 1); i >= 0; i-- ) {
124         IORInterceptor interceptor = iorInterceptors[i];
125         if (interceptor instanceof IORInterceptor_3_0 ) {
126             IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0 )interceptor ;
127             // Note that exceptions here are NOT ignored, as per the
128 // ORT spec (orbos/01-01-04)
129 interceptor30.components_established( info );
130         }
131         }
132
133         // Change the state so that no operations are valid,
134 // in case a reference to info escapes this scope.
135 // This also completes the actions associated with the
136 // template interceptors on this POA.
137 info.makeStateDone() ;
138     }
139     }
140
141     void adapterManagerStateChanged( int managerId, short newState )
142     {
143     if (enabled) {
144         IORInterceptor [] interceptors =
145                 (IORInterceptor [])interceptorList.getInterceptors(
146                 InterceptorList.INTERCEPTOR_TYPE_IOR );
147         int size = interceptors.length;
148
149         for( int i = (size - 1); i >= 0; i-- ) {
150         try {
151             IORInterceptor interceptor = interceptors[i];
152             if (interceptor instanceof IORInterceptor_3_0 ) {
153             IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0 )interceptor ;
154             interceptor30.adapter_manager_state_changed( managerId,
155                 newState );
156             }
157         } catch (Exception exc) {
158             // No-op: ignore exception in this case
159 }
160         }
161     }
162     }
163
164     void adapterStateChanged( ObjectReferenceTemplate [] templates,
165     short newState )
166     {
167     if (enabled) {
168         IORInterceptor [] interceptors =
169                 (IORInterceptor [])interceptorList.getInterceptors(
170                 InterceptorList.INTERCEPTOR_TYPE_IOR );
171         int size = interceptors.length;
172
173         for( int i = (size - 1); i >= 0; i-- ) {
174         try {
175             IORInterceptor interceptor = interceptors[i];
176             if (interceptor instanceof IORInterceptor_3_0 ) {
177             IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0 )interceptor ;
178             interceptor30.adapter_state_changed( templates, newState );
179             }
180         } catch (Exception exc) {
181             // No-op: ignore exception in this case
182 }
183         }
184     }
185     }
186
187     /*
188      **********************************************************************
189      * Client Interceptor invocation
190      **********************************************************************/
191
192     /**
193      * Invokes either send_request, or send_poll, depending on the value
194      * of info.getStartingPointCall()
195      */
196     void invokeClientInterceptorStartingPoint( ClientRequestInfoImpl info ) {
197     // If invocation is not yet enabled, don't do anything.
198 if( enabled ) {
199         try {
200         // Make a a fresh slot table available to TSC in case
201 // interceptors need to make out calls.
202 // Client's TSC is now RSC via RequestInfo.
203 current.pushSlotTable( );
204         info.setPICurrentPushed( true );
205         info.setCurrentExecutionPoint( info.EXECUTION_POINT_STARTING );
206         
207         // Get all ClientRequestInterceptors:
208 ClientRequestInterceptor [] clientInterceptors =
209             (ClientRequestInterceptor [])interceptorList.
210             getInterceptors( InterceptorList.INTERCEPTOR_TYPE_CLIENT );
211         int size = clientInterceptors.length;
212
213         // We will assume that all interceptors returned successfully,
214 // and adjust the flowStackIndex to the appropriate value if
215 // we later discover otherwise.
216 int flowStackIndex = size;
217         boolean continueProcessing = true;
218     
219         // Determine whether we are calling send_request or send_poll:
220 // (This is currently commented out because our ORB does not
221 // yet support the Messaging specification, so send_poll will
222 // never occur. Once we have implemented messaging, this may
223 // be uncommented.)
224 // int startingPointCall = info.getStartingPointCall();
225 for( int i = 0; continueProcessing && (i < size); i++ ) {
226             try {
227             clientInterceptors[i].send_request( info );
228             
229             // Again, it is not necessary for a switch here, since
230 // there is only one starting point call type (see
231 // above comment).
232
233             //switch( startingPointCall ) {
234 //case ClientRequestInfoImpl.CALL_SEND_REQUEST:
235 //clientInterceptors[i].send_request( info );
236 //break;
237 //case ClientRequestInfoImpl.CALL_SEND_POLL:
238 //clientInterceptors[i].send_poll( info );
239 //break;
240 //}
241
242             }
243             catch( ForwardRequest e ) {
244             // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
245 // interception point throws a ForwardRequest,
246 // no other Interceptors' send_request operations are
247 // called.
248 flowStackIndex = i;
249             info.setForwardRequest( e );
250             info.setEndingPointCall(
251                 ClientRequestInfoImpl.CALL_RECEIVE_OTHER );
252             info.setReplyStatus( LOCATION_FORWARD.value );
253             
254             updateClientRequestDispatcherForward( info );
255             
256             // For some reason, using break here causes the VM on
257 // NT to lose track of the value of flowStackIndex
258 // after exiting the for loop. I changed this to
259 // check a boolean value instead and it seems to work
260 // fine.
261 continueProcessing = false;
262             }
263             catch( SystemException e ) {
264             // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
265 // interception point throws a SystemException,
266 // no other Interceptors' send_request operations are
267 // called.
268 flowStackIndex = i;
269             info.setEndingPointCall(
270                 ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION );
271             info.setReplyStatus( SYSTEM_EXCEPTION.value );
272             info.setException( e );
273
274             // For some reason, using break here causes the VM on
275 // NT to lose track of the value of flowStackIndex
276 // after exiting the for loop. I changed this to
277 // check a boolean value instead and it seems to
278 // work fine.
279 continueProcessing = false;
280             }
281         }
282         
283         // Remember where we left off in the flow stack:
284 info.setFlowStackIndex( flowStackIndex );
285         }
286         finally {
287         // Make the SlotTable fresh for the next interception point.
288 current.resetSlotTable( );
289         }
290         } // end enabled check
291 }
292
293     /**
294      * Invokes either receive_reply, receive_exception, or receive_other,
295      * depending on the value of info.getEndingPointCall()
296      */
297     void invokeClientInterceptorEndingPoint( ClientRequestInfoImpl info ) {
298     // If invocation is not yet enabled, don't do anything.
299 if( enabled ) {
300         try {
301         // NOTE: It is assumed someplace else prepared a
302 // fresh TSC slot table.
303
304         info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );
305         
306         // Get all ClientRequestInterceptors:
307 ClientRequestInterceptor [] clientInterceptors =
308             (ClientRequestInterceptor [])interceptorList.
309             getInterceptors( InterceptorList.INTERCEPTOR_TYPE_CLIENT );
310         int flowStackIndex = info.getFlowStackIndex();
311         
312         // Determine whether we are calling receive_reply,
313 // receive_exception, or receive_other:
314 int endingPointCall = info.getEndingPointCall();
315
316         // If we would be calling RECEIVE_REPLY, but this is a
317 // one-way call, override this and call receive_other:
318 if( ( endingPointCall ==
319               ClientRequestInfoImpl.CALL_RECEIVE_REPLY ) &&
320             info.getIsOneWay() )
321         {
322             endingPointCall = ClientRequestInfoImpl.CALL_RECEIVE_OTHER;
323             info.setEndingPointCall( endingPointCall );
324         }
325         
326         // Only step through the interceptors whose starting points
327 // have successfully returned.
328 // Unlike the previous loop, this one counts backwards for a
329 // reason - we must execute these in the reverse order of the
330 // starting points.
331 for( int i = (flowStackIndex - 1); i >= 0; i-- ) {
332             
333             try {
334             switch( endingPointCall ) {
335             case ClientRequestInfoImpl.CALL_RECEIVE_REPLY:
336                 clientInterceptors[i].receive_reply( info );
337                 break;
338             case ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION:
339                 clientInterceptors[i].receive_exception( info );
340                 break;
341             case ClientRequestInfoImpl.CALL_RECEIVE_OTHER:
342                 clientInterceptors[i].receive_other( info );
343                 break;
344             }
345             }
346             catch( ForwardRequest e ) {
347
348             // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
349 // interception point throws a ForwardException,
350 // ending point call changes to receive_other.
351 endingPointCall =
352                 ClientRequestInfoImpl.CALL_RECEIVE_OTHER;
353             info.setEndingPointCall( endingPointCall );
354             info.setReplyStatus( LOCATION_FORWARD.value );
355             info.setForwardRequest( e );
356             updateClientRequestDispatcherForward( info );
357             }
358             catch( SystemException e ) {
359
360             // as per PI spec (orbos/99-12-02 sec 5.2.1.), if
361 // interception point throws a SystemException,
362 // ending point call changes to receive_exception.
363 endingPointCall =
364                 ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION;
365             info.setEndingPointCall( endingPointCall );
366             info.setReplyStatus( SYSTEM_EXCEPTION.value );
367             info.setException( e );
368             }
369         }
370         }
371         finally {
372         // See doc for setPICurrentPushed as to why this is necessary.
373 // Check info for null in case errors happen before initiate.
374 if (info != null && info.isPICurrentPushed()) {
375             current.popSlotTable( );
376             // After the pop, original client's TSC slot table
377 // remains avaiable via PICurrent.
378 }
379         }
380         } // end enabled check
381 }
382
383     /*
384      **********************************************************************
385      * Server Interceptor invocation
386      **********************************************************************/
387
388     /**
389      * Invokes receive_request_service_context interception points.
390      */
391     void invokeServerInterceptorStartingPoint( ServerRequestInfoImpl info ) {
392     // If invocation is not yet enabled, don't do anything.
393 if( enabled ) {
394         try {
395         // Make a fresh slot table for RSC.
396 current.pushSlotTable();
397         info.setSlotTable(current.getSlotTable());
398
399         // Make a fresh slot table for TSC in case
400 // interceptors need to make out calls.
401 current.pushSlotTable( );
402
403         info.setCurrentExecutionPoint( info.EXECUTION_POINT_STARTING );
404         
405         // Get all ServerRequestInterceptors:
406 ServerRequestInterceptor [] serverInterceptors =
407             (ServerRequestInterceptor [])interceptorList.
408             getInterceptors( InterceptorList.INTERCEPTOR_TYPE_SERVER );
409         int size = serverInterceptors.length;
410
411         // We will assume that all interceptors returned successfully,
412 // and adjust the flowStackIndex to the appropriate value if
413 // we later discover otherwise.
414 int flowStackIndex = size;
415         boolean continueProcessing = true;
416         
417         // Currently, there is only one server-side starting point
418 // interceptor called receive_request_service_contexts.
419 for( int i = 0; continueProcessing && (i < size); i++ ) {
420             
421             try {
422             serverInterceptors[i].
423                 receive_request_service_contexts( info );
424             }
425             catch( ForwardRequest e ) {
426             // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
427 // interception point throws a ForwardRequest,
428 // no other Interceptors' starting points are
429 // called and send_other is called.
430 flowStackIndex = i;
431             info.setForwardRequest( e );
432             info.setIntermediatePointCall(
433                 ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE );
434             info.setEndingPointCall(
435                 ServerRequestInfoImpl.CALL_SEND_OTHER );
436             info.setReplyStatus( LOCATION_FORWARD.value );
437
438             // For some reason, using break here causes the VM on
439 // NT to lose track of the value of flowStackIndex
440 // after exiting the for loop. I changed this to
441 // check a boolean value instead and it seems to work
442 // fine.
443 continueProcessing = false;
444             }
445             catch( SystemException e ) {
446
447             // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
448 // interception point throws a SystemException,
449 // no other Interceptors' starting points are
450 // called.
451 flowStackIndex = i;
452             info.setException( e );
453             info.setIntermediatePointCall(
454                 ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE );
455             info.setEndingPointCall(
456                 ServerRequestInfoImpl.CALL_SEND_EXCEPTION );
457             info.setReplyStatus( SYSTEM_EXCEPTION.value );
458
459             // For some reason, using break here causes the VM on
460 // NT to lose track of the value of flowStackIndex
461 // after exiting the for loop. I changed this to
462 // check a boolean value instead and it seems to
463 // work fine.
464 continueProcessing = false;
465             }
466         
467         }
468         
469         // Remember where we left off in the flow stack:
470 info.setFlowStackIndex( flowStackIndex );
471         }
472         finally {
473         // The remaining points, ServantManager and Servant
474 // all run in the same logical thread.
475 current.popSlotTable( );
476         // Now TSC and RSC are equivalent.
477 }
478         } // end enabled check
479 }
480
481     /**
482      * Invokes receive_request interception points
483      */
484     void invokeServerInterceptorIntermediatePoint(
485         ServerRequestInfoImpl info )
486     {
487         int intermediatePointCall = info.getIntermediatePointCall();
488     // If invocation is not yet enabled, don't do anything.
489 if( enabled && ( intermediatePointCall !=
490                          ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE ) )
491         {
492         // NOTE: do not touch the slotStack. The RSC and TSC are
493 // equivalent at this point.
494
495             info.setCurrentExecutionPoint( info.EXECUTION_POINT_INTERMEDIATE );
496             
497             // Get all ServerRequestInterceptors:
498 ServerRequestInterceptor [] serverInterceptors =
499                 (ServerRequestInterceptor [])
500                 interceptorList.getInterceptors(
501                 InterceptorList.INTERCEPTOR_TYPE_SERVER );
502             int size = serverInterceptors.length;
503
504             // Currently, there is only one server-side intermediate point
505 // interceptor called receive_request.
506 for( int i = 0; i < size; i++ ) {
507
508                 try {
509                     serverInterceptors[i].receive_request( info );
510                 }
511                 catch( ForwardRequest e ) {
512
513                     // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
514 // interception point throws a ForwardRequest,
515 // no other Interceptors' intermediate points are
516 // called and send_other is called.
517 info.setForwardRequest( e );
518                     info.setEndingPointCall(
519                         ServerRequestInfoImpl.CALL_SEND_OTHER );
520                     info.setReplyStatus( LOCATION_FORWARD.value );
521                     break;
522                 }
523                 catch( SystemException e ) {
524
525                     // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
526 // interception point throws a SystemException,
527 // no other Interceptors' starting points are
528 // called.
529 info.setException( e );
530                     info.setEndingPointCall(
531                         ServerRequestInfoImpl.CALL_SEND_EXCEPTION );
532                     info.setReplyStatus( SYSTEM_EXCEPTION.value );
533                     break;
534                 }
535             }
536         } // end enabled check
537 }
538
539     /**
540      * Invokes either send_reply, send_exception, or send_other,
541      * depending on the value of info.getEndingPointCall()
542      */
543     void invokeServerInterceptorEndingPoint( ServerRequestInfoImpl info ) {
544     // If invocation is not yet enabled, don't do anything.
545 if( enabled ) {
546         try {
547         // NOTE: do not touch the slotStack. The RSC and TSC are
548 // equivalent at this point.
549
550         // REVISIT: This is moved out to PIHandlerImpl until dispatch
551 // path is rearchitected. It must be there so that
552 // it always gets executed so if an interceptor raises
553 // an exception any service contexts added in earlier points
554 // this point get put in the exception reply (via the SC Q).
555 //info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );
556
557         // Get all ServerRequestInterceptors:
558 ServerRequestInterceptor [] serverInterceptors =
559             (ServerRequestInterceptor [])interceptorList.
560             getInterceptors( InterceptorList.INTERCEPTOR_TYPE_SERVER );
561         int flowStackIndex = info.getFlowStackIndex();
562         
563         // Determine whether we are calling
564 // send_exception, or send_other:
565 int endingPointCall = info.getEndingPointCall();
566         
567         // Only step through the interceptors whose starting points
568 // have successfully returned.
569 for( int i = (flowStackIndex - 1); i >= 0; i-- ) {
570             try {
571             switch( endingPointCall ) {
572             case ServerRequestInfoImpl.CALL_SEND_REPLY:
573                 serverInterceptors[i].send_reply( info );
574                 break;
575             case ServerRequestInfoImpl.CALL_SEND_EXCEPTION:
576                 serverInterceptors[i].send_exception( info );
577                 break;
578             case ServerRequestInfoImpl.CALL_SEND_OTHER:
579                 serverInterceptors[i].send_other( info );
580                 break;
581             }
582             }
583             catch( ForwardRequest e ) {
584             // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
585 // interception point throws a ForwardException,
586 // ending point call changes to receive_other.
587 endingPointCall =
588                 ServerRequestInfoImpl.CALL_SEND_OTHER;
589             info.setEndingPointCall( endingPointCall );
590             info.setForwardRequest( e );
591             info.setReplyStatus( LOCATION_FORWARD.value );
592             info.setForwardRequestRaisedInEnding();
593             }
594             catch( SystemException e ) {
595             // as per PI spec (orbos/99-12-02 sec 5.3.1.), if
596 // interception point throws a SystemException,
597 // ending point call changes to send_exception.
598 endingPointCall =
599                 ServerRequestInfoImpl.CALL_SEND_EXCEPTION;
600             info.setEndingPointCall( endingPointCall );
601             info.setException( e );
602             info.setReplyStatus( SYSTEM_EXCEPTION.value );
603             }
604         }
605         
606         // Remember that all interceptors' starting and ending points
607 // have already been executed so we need not do anything.
608 info.setAlreadyExecuted( true );
609         }
610             finally {
611         // Get rid of the Server side RSC.
612 current.popSlotTable();
613         }
614         } // end enabled check
615 }
616     
617     /*
618      **********************************************************************
619      * Private utility methods
620      **********************************************************************/
621     
622     /**
623      * Update the client delegate in the event of a ForwardRequest, given the
624      * information in the passed-in info object.
625      */
626     private void updateClientRequestDispatcherForward(
627         ClientRequestInfoImpl info )
628     {
629         ForwardRequest forwardRequest = info.getForwardRequestException();
630         
631         // ForwardRequest may be null if the forwarded IOR is set internal
632 // to the ClientRequestDispatcher rather than explicitly through Portable
633 // Interceptors. In this case, we need not update the client
634 // delegate ForwardRequest object.
635 if( forwardRequest != null ) {
636             org.omg.CORBA.Object object = forwardRequest.forward;
637
638             // Convert the forward object into an IOR:
639 IOR ior = ORBUtility.getIOR( object ) ;
640         info.setLocatedIOR( ior );
641         }
642     }
643     
644 }
645

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags