/*
* Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.corba.se.impl.interceptors;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.INTERNAL;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.portable.Delegate;
import org.omg.PortableInterceptor.LOCATION_FORWARD;
import org.omg.PortableInterceptor.SUCCESSFUL;
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
import org.omg.PortableInterceptor.TRANSPORT_RETRY;
import org.omg.PortableInterceptor.USER_EXCEPTION;
import org.omg.PortableInterceptor.ClientRequestInfo;
import org.omg.PortableInterceptor.ClientRequestInterceptor;
import org.omg.PortableInterceptor.ForwardRequest;
import org.omg.PortableInterceptor.IORInterceptor;
import org.omg.PortableInterceptor.IORInterceptor_3_0;
import org.omg.PortableInterceptor.ServerRequestInfo;
import org.omg.PortableInterceptor.ServerRequestInterceptor;
import org.omg.PortableInterceptor.ObjectReferenceTemplate;
import com.sun.corba.se.spi.ior.IOR;
import com.sun.corba.se.spi.oa.ObjectAdapter;
import com.sun.corba.se.spi.orb.ORB;
import com.sun.corba.se.impl.orbutil.ORBUtility;
/**
* Handles invocation of interceptors. Has specific knowledge of how to
* invoke IOR, ClientRequest, and ServerRequest interceptors.
* Makes use of the InterceptorList to retrieve the list of interceptors to
* be invoked. Most methods in this class are package scope so that they
* may only be called from the PIHandlerImpl.
*/
public class InterceptorInvoker {
// The ORB
private ORB orb;
// The list of interceptors to be invoked
private InterceptorList interceptorList;
// True if interceptors are to be invoked, or false if not
// Note: This is a global enable/disable flag, whereas the enable flag
// in the RequestInfoStack in PIHandlerImpl is only for a particular Thread.
private boolean enabled = false;
// PICurrent variable.
private PICurrent current;
// NOTE: Be careful about adding additional attributes to this class.
// Multiple threads may be calling methods on this invoker at the same
// time.
/**
* Creates a new Interceptor Invoker. Constructor is package scope so
* only the ORB can create it. The invoker is initially disabled, and
* must be explicitly enabled using setEnabled().
*/
InterceptorInvoker( ORB orb, InterceptorList interceptorList,
PICurrent piCurrent )
{
this.orb = orb;
this.interceptorList = interceptorList;
this.enabled = false;
this.current = piCurrent;
}
/**
* Enables or disables the interceptor invoker
*/
void setEnabled( boolean enabled ) {
this.enabled = enabled;
}
/*
**********************************************************************
* IOR Interceptor invocation
**********************************************************************/
/**
* Called when a new POA is created.
*
* @param oa The Object Adapter associated with the IOR interceptor.
*/
void objectAdapterCreated( ObjectAdapter oa ) {
// If invocation is not yet enabled, don't do anything.
if( enabled ) {
// Create IORInfo object to pass to IORInterceptors:
IORInfoImpl info = new IORInfoImpl( oa );
// Call each IORInterceptor:
IORInterceptor[] iorInterceptors =
(IORInterceptor[])interceptorList.getInterceptors(
InterceptorList.INTERCEPTOR_TYPE_IOR );
int size = iorInterceptors.length;
// Implementation note:
// This loop counts backwards for greater efficiency.
// Benchmarks have shown that counting down is more efficient
// than counting up in Java for loops, as a compare to zero is
// faster than a subtract and compare to zero. In this case,
// it doesn't really matter much, but it's simply a force of habit.
for( int i = (size - 1); i >= 0; i-- ) {
IORInterceptor interceptor = iorInterceptors[i];
try {
interceptor.establish_components( info );
}
catch( Exception e ) {
// as per PI spec (orbos/99-12-02 sec 7.2.1), if
// establish_components throws an exception, ignore it.
}
}
// Change the state so that only template operations are valid
info.makeStateEstablished() ;
for( int i = (size - 1); i >= 0; i-- ) {
IORInterceptor interceptor = iorInterceptors[i];
if (interceptor instanceof IORInterceptor_3_0) {
IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0)interceptor ;
// Note that exceptions here are NOT ignored, as per the
// ORT spec (orbos/01-01-04)
interceptor30.components_established( info );
}
}
// Change the state so that no operations are valid,
// in case a reference to info escapes this scope.
// This also completes the actions associated with the
// template interceptors on this POA.
info.makeStateDone() ;
}
}
void adapterManagerStateChanged( int managerId, short newState )
{
if (enabled) {
IORInterceptor[] interceptors =
(IORInterceptor[])interceptorList.getInterceptors(
InterceptorList.INTERCEPTOR_TYPE_IOR );
int size = interceptors.length;
for( int i = (size - 1); i >= 0; i-- ) {
try {
IORInterceptor interceptor = interceptors[i];
if (interceptor instanceof IORInterceptor_3_0) {
IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0)interceptor ;
interceptor30.adapter_manager_state_changed( managerId,
newState );
}
} catch (Exception exc) {
// No-op: ignore exception in this case
}
}
}
}
void adapterStateChanged( ObjectReferenceTemplate[] templates,
short newState )
{
if (enabled) {
IORInterceptor[] interceptors =
(IORInterceptor[])interceptorList.getInterceptors(
InterceptorList.INTERCEPTOR_TYPE_IOR );
int size = interceptors.length;
for( int i = (size - 1); i >= 0; i-- ) {
try {
IORInterceptor interceptor = interceptors[i];
if (interceptor instanceof IORInterceptor_3_0) {
IORInterceptor_3_0 interceptor30 = (IORInterceptor_3_0)interceptor ;
interceptor30.adapter_state_changed( templates, newState );
}
} catch (Exception exc) {
// No-op: ignore exception in this case
}
}
}
}
/*
**********************************************************************
* Client Interceptor invocation
**********************************************************************/
/**
* Invokes either send_request, or send_poll, depending on the value
* of info.getStartingPointCall()
*/
void invokeClientInterceptorStartingPoint( ClientRequestInfoImpl info ) {
// If invocation is not yet enabled, don't do anything.
if( enabled ) {
try {
// Make a a fresh slot table available to TSC in case
// interceptors need to make out calls.
// Client's TSC is now RSC via RequestInfo.
current.pushSlotTable( );
info.setPICurrentPushed( true );
info.setCurrentExecutionPoint( info.EXECUTION_POINT_STARTING );
// Get all ClientRequestInterceptors:
ClientRequestInterceptor[] clientInterceptors =
(ClientRequestInterceptor[])interceptorList.
getInterceptors( InterceptorList.INTERCEPTOR_TYPE_CLIENT );
int size = clientInterceptors.length;
// We will assume that all interceptors returned successfully,
// and adjust the flowStackIndex to the appropriate value if
// we later discover otherwise.
int flowStackIndex = size;
boolean continueProcessing = true;
// Determine whether we are calling send_request or send_poll:
// (This is currently commented out because our ORB does not
// yet support the Messaging specification, so send_poll will
// never occur. Once we have implemented messaging, this may
// be uncommented.)
// int startingPointCall = info.getStartingPointCall();
for( int i = 0; continueProcessing && (i < size); i++ ) {
try {
clientInterceptors[i].send_request( info );
// Again, it is not necessary for a switch here, since
// there is only one starting point call type (see
// above comment).
//switch( startingPointCall ) {
//case ClientRequestInfoImpl.CALL_SEND_REQUEST:
//clientInterceptors[i].send_request( info );
//break;
//case ClientRequestInfoImpl.CALL_SEND_POLL:
//clientInterceptors[i].send_poll( info );
//break;
//}
}
catch( ForwardRequest e ) {
// as per PI spec (orbos/99-12-02 sec 5.2.1.), if
// interception point throws a ForwardRequest,
// no other Interceptors' send_request operations are
// called.
flowStackIndex = i;
info.setForwardRequest( e );
info.setEndingPointCall(
ClientRequestInfoImpl.CALL_RECEIVE_OTHER );
info.setReplyStatus( LOCATION_FORWARD.value );
updateClientRequestDispatcherForward( info );
// For some reason, using break here causes the VM on
// NT to lose track of the value of flowStackIndex
// after exiting the for loop. I changed this to
// check a boolean value instead and it seems to work
// fine.
continueProcessing = false;
}
catch( SystemException e ) {
// as per PI spec (orbos/99-12-02 sec 5.2.1.), if
// interception point throws a SystemException,
// no other Interceptors' send_request operations are
// called.
flowStackIndex = i;
info.setEndingPointCall(
ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION );
info.setReplyStatus( SYSTEM_EXCEPTION.value );
info.setException( e );
// For some reason, using break here causes the VM on
// NT to lose track of the value of flowStackIndex
// after exiting the for loop. I changed this to
// check a boolean value instead and it seems to
// work fine.
continueProcessing = false;
}
}
// Remember where we left off in the flow stack:
info.setFlowStackIndex( flowStackIndex );
}
finally {
// Make the SlotTable fresh for the next interception point.
current.resetSlotTable( );
}
} // end enabled check
}
/**
* Invokes either receive_reply, receive_exception, or receive_other,
* depending on the value of info.getEndingPointCall()
*/
void invokeClientInterceptorEndingPoint( ClientRequestInfoImpl info ) {
// If invocation is not yet enabled, don't do anything.
if( enabled ) {
try {
// NOTE: It is assumed someplace else prepared a
// fresh TSC slot table.
info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );
// Get all ClientRequestInterceptors:
ClientRequestInterceptor[] clientInterceptors =
(ClientRequestInterceptor[])interceptorList.
getInterceptors( InterceptorList.INTERCEPTOR_TYPE_CLIENT );
int flowStackIndex = info.getFlowStackIndex();
// Determine whether we are calling receive_reply,
// receive_exception, or receive_other:
int endingPointCall = info.getEndingPointCall();
// If we would be calling RECEIVE_REPLY, but this is a
// one-way call, override this and call receive_other:
if( ( endingPointCall ==
ClientRequestInfoImpl.CALL_RECEIVE_REPLY ) &&
info.getIsOneWay() )
{
endingPointCall = ClientRequestInfoImpl.CALL_RECEIVE_OTHER;
info.setEndingPointCall( endingPointCall );
}
// Only step through the interceptors whose starting points
// have successfully returned.
// Unlike the previous loop, this one counts backwards for a
// reason - we must execute these in the reverse order of the
// starting points.
for( int i = (flowStackIndex - 1); i >= 0; i-- ) {
try {
switch( endingPointCall ) {
case ClientRequestInfoImpl.CALL_RECEIVE_REPLY:
clientInterceptors[i].receive_reply( info );
break;
case ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION:
clientInterceptors[i].receive_exception( info );
break;
case ClientRequestInfoImpl.CALL_RECEIVE_OTHER:
clientInterceptors[i].receive_other( info );
break;
}
}
catch( ForwardRequest e ) {
// as per PI spec (orbos/99-12-02 sec 5.2.1.), if
// interception point throws a ForwardException,
// ending point call changes to receive_other.
endingPointCall =
ClientRequestInfoImpl.CALL_RECEIVE_OTHER;
info.setEndingPointCall( endingPointCall );
info.setReplyStatus( LOCATION_FORWARD.value );
info.setForwardRequest( e );
updateClientRequestDispatcherForward( info );
}
catch( SystemException e ) {
// as per PI spec (orbos/99-12-02 sec 5.2.1.), if
// interception point throws a SystemException,
// ending point call changes to receive_exception.
endingPointCall =
ClientRequestInfoImpl.CALL_RECEIVE_EXCEPTION;
info.setEndingPointCall( endingPointCall );
info.setReplyStatus( SYSTEM_EXCEPTION.value );
info.setException( e );
}
}
}
finally {
// See doc for setPICurrentPushed as to why this is necessary.
// Check info for null in case errors happen before initiate.
if (info != null && info.isPICurrentPushed()) {
current.popSlotTable( );
// After the pop, original client's TSC slot table
// remains avaiable via PICurrent.
}
}
} // end enabled check
}
/*
**********************************************************************
* Server Interceptor invocation
**********************************************************************/
/**
* Invokes receive_request_service_context interception points.
*/
void invokeServerInterceptorStartingPoint( ServerRequestInfoImpl info ) {
// If invocation is not yet enabled, don't do anything.
if( enabled ) {
try {
// Make a fresh slot table for RSC.
current.pushSlotTable();
info.setSlotTable(current.getSlotTable());
// Make a fresh slot table for TSC in case
// interceptors need to make out calls.
current.pushSlotTable( );
info.setCurrentExecutionPoint( info.EXECUTION_POINT_STARTING );
// Get all ServerRequestInterceptors:
ServerRequestInterceptor[] serverInterceptors =
(ServerRequestInterceptor[])interceptorList.
getInterceptors( InterceptorList.INTERCEPTOR_TYPE_SERVER );
int size = serverInterceptors.length;
// We will assume that all interceptors returned successfully,
// and adjust the flowStackIndex to the appropriate value if
// we later discover otherwise.
int flowStackIndex = size;
boolean continueProcessing = true;
// Currently, there is only one server-side starting point
// interceptor called receive_request_service_contexts.
for( int i = 0; continueProcessing && (i < size); i++ ) {
try {
serverInterceptors[i].
receive_request_service_contexts( info );
}
catch( ForwardRequest e ) {
// as per PI spec (orbos/99-12-02 sec 5.3.1.), if
// interception point throws a ForwardRequest,
// no other Interceptors' starting points are
// called and send_other is called.
flowStackIndex = i;
info.setForwardRequest( e );
info.setIntermediatePointCall(
ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE );
info.setEndingPointCall(
ServerRequestInfoImpl.CALL_SEND_OTHER );
info.setReplyStatus( LOCATION_FORWARD.value );
// For some reason, using break here causes the VM on
// NT to lose track of the value of flowStackIndex
// after exiting the for loop. I changed this to
// check a boolean value instead and it seems to work
// fine.
continueProcessing = false;
}
catch( SystemException e ) {
// as per PI spec (orbos/99-12-02 sec 5.3.1.), if
// interception point throws a SystemException,
// no other Interceptors' starting points are
// called.
flowStackIndex = i;
info.setException( e );
info.setIntermediatePointCall(
ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE );
info.setEndingPointCall(
ServerRequestInfoImpl.CALL_SEND_EXCEPTION );
info.setReplyStatus( SYSTEM_EXCEPTION.value );
// For some reason, using break here causes the VM on
// NT to lose track of the value of flowStackIndex
// after exiting the for loop. I changed this to
// check a boolean value instead and it seems to
// work fine.
continueProcessing = false;
}
}
// Remember where we left off in the flow stack:
info.setFlowStackIndex( flowStackIndex );
}
finally {
// The remaining points, ServantManager and Servant
// all run in the same logical thread.
current.popSlotTable( );
// Now TSC and RSC are equivalent.
}
} // end enabled check
}
/**
* Invokes receive_request interception points
*/
void invokeServerInterceptorIntermediatePoint(
ServerRequestInfoImpl info )
{
int intermediatePointCall = info.getIntermediatePointCall();
// If invocation is not yet enabled, don't do anything.
if( enabled && ( intermediatePointCall !=
ServerRequestInfoImpl.CALL_INTERMEDIATE_NONE ) )
{
// NOTE: do not touch the slotStack. The RSC and TSC are
// equivalent at this point.
info.setCurrentExecutionPoint( info.EXECUTION_POINT_INTERMEDIATE );
// Get all ServerRequestInterceptors:
ServerRequestInterceptor[] serverInterceptors =
(ServerRequestInterceptor[])
interceptorList.getInterceptors(
InterceptorList.INTERCEPTOR_TYPE_SERVER );
int size = serverInterceptors.length;
// Currently, there is only one server-side intermediate point
// interceptor called receive_request.
for( int i = 0; i < size; i++ ) {
try {
serverInterceptors[i].receive_request( info );
}
catch( ForwardRequest e ) {
// as per PI spec (orbos/99-12-02 sec 5.3.1.), if
// interception point throws a ForwardRequest,
// no other Interceptors' intermediate points are
// called and send_other is called.
info.setForwardRequest( e );
info.setEndingPointCall(
ServerRequestInfoImpl.CALL_SEND_OTHER );
info.setReplyStatus( LOCATION_FORWARD.value );
break;
}
catch( SystemException e ) {
// as per PI spec (orbos/99-12-02 sec 5.3.1.), if
// interception point throws a SystemException,
// no other Interceptors' starting points are
// called.
info.setException( e );
info.setEndingPointCall(
ServerRequestInfoImpl.CALL_SEND_EXCEPTION );
info.setReplyStatus( SYSTEM_EXCEPTION.value );
break;
}
}
} // end enabled check
}
/**
* Invokes either send_reply, send_exception, or send_other,
* depending on the value of info.getEndingPointCall()
*/
void invokeServerInterceptorEndingPoint( ServerRequestInfoImpl info ) {
// If invocation is not yet enabled, don't do anything.
if( enabled ) {
try {
// NOTE: do not touch the slotStack. The RSC and TSC are
// equivalent at this point.
// REVISIT: This is moved out to PIHandlerImpl until dispatch
// path is rearchitected. It must be there so that
// it always gets executed so if an interceptor raises
// an exception any service contexts added in earlier points
// this point get put in the exception reply (via the SC Q).
//info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );
// Get all ServerRequestInterceptors:
ServerRequestInterceptor[] serverInterceptors =
(ServerRequestInterceptor[])interceptorList.
getInterceptors( InterceptorList.INTERCEPTOR_TYPE_SERVER );
int flowStackIndex = info.getFlowStackIndex();
// Determine whether we are calling
// send_exception, or send_other:
int endingPointCall = info.getEndingPointCall();
// Only step through the interceptors whose starting points
// have successfully returned.
for( int i = (flowStackIndex - 1); i >= 0; i-- ) {
try {
switch( endingPointCall ) {
case ServerRequestInfoImpl.CALL_SEND_REPLY:
serverInterceptors[i].send_reply( info );
break;
case ServerRequestInfoImpl.CALL_SEND_EXCEPTION:
serverInterceptors[i].send_exception( info );
break;
case ServerRequestInfoImpl.CALL_SEND_OTHER:
serverInterceptors[i].send_other( info );
break;
}
}
catch( ForwardRequest e ) {
// as per PI spec (orbos/99-12-02 sec 5.3.1.), if
// interception point throws a ForwardException,
// ending point call changes to receive_other.
endingPointCall =
ServerRequestInfoImpl.CALL_SEND_OTHER;
info.setEndingPointCall( endingPointCall );
info.setForwardRequest( e );
info.setReplyStatus( LOCATION_FORWARD.value );
info.setForwardRequestRaisedInEnding();
}
catch( SystemException e ) {
// as per PI spec (orbos/99-12-02 sec 5.3.1.), if
// interception point throws a SystemException,
// ending point call changes to send_exception.
endingPointCall =
ServerRequestInfoImpl.CALL_SEND_EXCEPTION;
info.setEndingPointCall( endingPointCall );
info.setException( e );
info.setReplyStatus( SYSTEM_EXCEPTION.value );
}
}
// Remember that all interceptors' starting and ending points
// have already been executed so we need not do anything.
info.setAlreadyExecuted( true );
}
finally {
// Get rid of the Server side RSC.
current.popSlotTable();
}
} // end enabled check
}
/*
**********************************************************************
* Private utility methods
**********************************************************************/
/**
* Update the client delegate in the event of a ForwardRequest, given the
* information in the passed-in info object.
*/
private void updateClientRequestDispatcherForward(
ClientRequestInfoImpl info )
{
ForwardRequest forwardRequest = info.getForwardRequestException();
// ForwardRequest may be null if the forwarded IOR is set internal
// to the ClientRequestDispatcher rather than explicitly through Portable
// Interceptors. In this case, we need not update the client
// delegate ForwardRequest object.
if( forwardRequest != null ) {
org.omg.CORBA.Object object = forwardRequest.forward;
// Convert the forward object into an IOR:
IOR ior = ORBUtility.getIOR( object ) ;
info.setLocatedIOR( ior );
}
}
}