jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java

Tue, 28 Dec 2010 15:52:36 -0800

author: ohair
date: Tue, 28 Dec 2010 15:52:36 -0800
changeset 240: f90b3e014e83
parent 215: cff5a173ec1e
child 380: 47adb42076f1
permissions: -rw-r--r--

6962318: Update copyright year
Reviewed-by: xdono

 /*
  * Copyright (c) 2002, 2010, 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 java.util.*;
 import java.io.IOException;
 import org.omg.CORBA.Any;
 import org.omg.CORBA.BAD_PARAM;
 import org.omg.CORBA.BAD_POLICY;
 import org.omg.CORBA.BAD_INV_ORDER;
 import org.omg.CORBA.COMM_FAILURE;
 import org.omg.CORBA.CompletionStatus;
 import org.omg.CORBA.INTERNAL;
 import org.omg.CORBA.NVList;
 import org.omg.CORBA.OBJECT_NOT_EXIST;
 import org.omg.CORBA.ORBPackage.InvalidName;
 import org.omg.CORBA.SystemException;
 import org.omg.CORBA.UserException;
 import org.omg.CORBA.UNKNOWN;
 import org.omg.CORBA.portable.ApplicationException;
 import org.omg.CORBA.portable.RemarshalException;
 import org.omg.IOP.CodecFactory;
 import org.omg.PortableInterceptor.ForwardRequest;
 import org.omg.PortableInterceptor.Current;
 import org.omg.PortableInterceptor.Interceptor;
 import org.omg.PortableInterceptor.LOCATION_FORWARD;
 import org.omg.PortableInterceptor.ORBInitializer;
 import org.omg.PortableInterceptor.ORBInitInfo;
 import org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName;
 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.PolicyFactory;
 import org.omg.PortableInterceptor.ObjectReferenceTemplate ;
 import com.sun.corba.se.pept.encoding.OutputObject;
 import com.sun.corba.se.spi.ior.IOR;
 import com.sun.corba.se.spi.ior.ObjectKeyTemplate;
 import com.sun.corba.se.spi.oa.ObjectAdapter;
 import com.sun.corba.se.spi.orb.ORB;
 import com.sun.corba.se.spi.orbutil.closure.ClosureFactory;
 import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
 import com.sun.corba.se.spi.protocol.ForwardException;
 import com.sun.corba.se.spi.protocol.PIHandler;
 import com.sun.corba.se.spi.protocol.RetryType;
 import com.sun.corba.se.spi.logging.CORBALogDomains;
 import com.sun.corba.se.impl.logging.InterceptorsSystemException;
 import com.sun.corba.se.impl.logging.ORBUtilSystemException;
 import com.sun.corba.se.impl.logging.OMGSystemException;
 import com.sun.corba.se.impl.corba.RequestImpl;
 import com.sun.corba.se.impl.orbutil.ORBClassLoader;
 import com.sun.corba.se.impl.orbutil.ORBConstants;
 import com.sun.corba.se.impl.orbutil.ORBUtility;
 import com.sun.corba.se.impl.orbutil.StackImpl;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage;
 /**
  * Provides portable interceptor functionality.
  */
 public class PIHandlerImpl implements PIHandler
 {
     // REVISIT - delete these after framework merging.
     boolean printPushPopEnabled = false;
     int pushLevel = 0;
     private void printPush()
     {
         if (! printPushPopEnabled) return;
         printSpaces(pushLevel);
         pushLevel++;
         System.out.println("PUSH");
     }
     private void printPop()
     {
         if (! printPushPopEnabled) return;
         pushLevel--;
         printSpaces(pushLevel);
         System.out.println("POP");
     }
     private void printSpaces(int n)
     {
         for (int i = 0; i < n; i++) {
             System.out.print(" ");
         }
     }
     private ORB orb ;
     InterceptorsSystemException wrapper ;
     ORBUtilSystemException orbutilWrapper ;
     OMGSystemException omgWrapper ;
     // A unique id used in ServerRequestInfo.
     // This does not correspond to the GIOP request id.
     private int serverRequestIdCounter = 0;
     // Stores the codec factory for producing codecs
     CodecFactory codecFactory = null;
     // The arguments passed to the application's main method.  May be null.
     // This is used for ORBInitializers and set from set_parameters.
     String[] arguments = null;
     // The list of portable interceptors, organized by type:
     private InterceptorList interceptorList;
     // Cached information for optimization - do we have any interceptors
     // registered of the given types?  Set during ORB initialization.
     private boolean hasIORInterceptors;
     private boolean hasClientInterceptors;  // temp always true
     private boolean hasServerInterceptors;
     // The class responsible for invoking interceptors
     private InterceptorInvoker interceptorInvoker;
     // There will be one PICurrent instantiated for every ORB.
     private PICurrent current;
     // This table contains a list of PolicyFactories registered using
     // ORBInitInfo.registerPolicyFactory() method.
     // Key for the table is PolicyType which is an Integer
     // Value is PolicyFactory.
     private HashMap policyFactoryTable;
     // Table to convert from a ReplyMessage.? to a PI replyStatus short.
     // Note that this table relies on the order and constants of
     // ReplyMessage not to change.
     private final static short REPLY_MESSAGE_TO_PI_REPLY_STATUS[] = {
         SUCCESSFUL.value,       // = ReplyMessage.NO_EXCEPTION
         USER_EXCEPTION.value,   // = ReplyMessage.USER_EXCEPTION
         SYSTEM_EXCEPTION.value, // = ReplyMessage.SYSTEM_EXCEPTION
         LOCATION_FORWARD.value, // = ReplyMessage.LOCATION_FORWARD
         LOCATION_FORWARD.value, // = ReplyMessage.LOCATION_FORWARD_PERM
         TRANSPORT_RETRY.value   // = ReplyMessage.NEEDS_ADDRESSING_MODE
     };
     // ThreadLocal containing a stack to store client request info objects
     // and a disable count.
     private ThreadLocal threadLocalClientRequestInfoStack =
         new ThreadLocal() {
             protected Object initialValue() {
                 return new RequestInfoStack();
             }
         };
     // ThreadLocal containing the current server request info object.
     private ThreadLocal threadLocalServerRequestInfoStack =
         new ThreadLocal() {
             protected Object initialValue() {
                 return new RequestInfoStack();
             }
         };
     // Class to contain all ThreadLocal data for ClientRequestInfo
     // maintenance.
     //
     // We use an ArrayList instead since it is not thread-safe.
     // RequestInfoStack is used quite frequently.
     private final class RequestInfoStack extends Stack {
         // Number of times a request has been made to disable interceptors.
         // When this reaches 0, interception hooks are disabled.  Any higher
         // value indicates they are enabled.
         // NOTE: The is only currently used on the client side.
         public int disableCount = 0;
     }
     public PIHandlerImpl( ORB orb, String[] args ) {
         this.orb = orb ;
         wrapper = InterceptorsSystemException.get( orb,
             CORBALogDomains.RPC_PROTOCOL ) ;
         orbutilWrapper = ORBUtilSystemException.get( orb,
             CORBALogDomains.RPC_PROTOCOL ) ;
         omgWrapper = OMGSystemException.get( orb,
             CORBALogDomains.RPC_PROTOCOL ) ;
         arguments = args ;
         // Create codec factory:
         codecFactory = new CodecFactoryImpl( orb );
         // Create new interceptor list:
         interceptorList = new InterceptorList( wrapper );
         // Create a new PICurrent.
         current = new PICurrent( orb );
         // Create new interceptor invoker, initially disabled:
         interceptorInvoker = new InterceptorInvoker( orb, interceptorList,
                                                      current );
         // Register the PI current and Codec factory objects
         orb.getLocalResolver().register( ORBConstants.PI_CURRENT_NAME,
             ClosureFactory.makeConstant( current ) ) ;
         orb.getLocalResolver().register( ORBConstants.CODEC_FACTORY_NAME,
             ClosureFactory.makeConstant( codecFactory ) ) ;
     }
     public void initialize() {
         // If we have any orb initializers, make use of them:
         if( orb.getORBData().getORBInitializers() != null ) {
             // Create the ORBInitInfo object to pass to ORB intializers:
             ORBInitInfoImpl orbInitInfo = createORBInitInfo();
             // Make sure get_slot and set_slot are not called from within
             // ORB initializers:
             current.setORBInitializing( true );
             // Call pre_init on all ORB initializers:
             preInitORBInitializers( orbInitInfo );
             // Call post_init on all ORB initializers:
             postInitORBInitializers( orbInitInfo );
             // Proprietary: sort interceptors:
             interceptorList.sortInterceptors();
             // Re-enable get_slot and set_slot to be called from within
             // ORB initializers:
             current.setORBInitializing( false );
             // Ensure nobody makes any more calls on this object.
             orbInitInfo.setStage( ORBInitInfoImpl.STAGE_CLOSED );
             // Set cached flags indicating whether we have interceptors
             // registered of a given type.
             hasIORInterceptors = interceptorList.hasInterceptorsOfType(
                 InterceptorList.INTERCEPTOR_TYPE_IOR );
             // XXX This must always be true, so that using the new generic
             // RPC framework can pass info between the PI stack and the
             // framework invocation stack.  Temporary until Harold fixes
             // this.  Note that this must never be true until after the
             // ORBInitializer instances complete executing.
             //hasClientInterceptors = interceptorList.hasInterceptorsOfType(
                 //InterceptorList.INTERCEPTOR_TYPE_CLIENT );
             hasClientInterceptors = true;
             hasServerInterceptors = interceptorList.hasInterceptorsOfType(
                 InterceptorList.INTERCEPTOR_TYPE_SERVER );
             // Enable interceptor invoker (not necessary if no interceptors
             // are registered).  This should be the last stage of ORB
             // initialization.
             interceptorInvoker.setEnabled( true );
         }
     }
     /**
      *  ptc/00-08-06 p 205: "When an application calls ORB::destroy, the ORB
      *  1) waits for all requests in progress to complete
      *  2) calls the Interceptor::destroy operation for each interceptor
      *  3) completes destruction of the ORB"
      *
      * This must be called at the end of ORB.destroy.  Note that this is not
      * part of the PIHandler interface, since ORBImpl implements the ORB interface.
      */
     public void destroyInterceptors() {
         interceptorList.destroyAll();
     }
     public void objectAdapterCreated( ObjectAdapter oa )
     {
         if (!hasIORInterceptors)
             return ;
         interceptorInvoker.objectAdapterCreated( oa ) ;
     }
     public void adapterManagerStateChanged( int managerId,
         short newState )
     {
         if (!hasIORInterceptors)
             return ;
         interceptorInvoker.adapterManagerStateChanged( managerId, newState ) ;
     }
     public void adapterStateChanged( ObjectReferenceTemplate[]
         templates, short newState )
     {
         if (!hasIORInterceptors)
             return ;
         interceptorInvoker.adapterStateChanged( templates, newState ) ;
     }
     /*
      *****************
      * Client PI hooks
      *****************/
     public void disableInterceptorsThisThread() {
         if( !hasClientInterceptors ) return;
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalClientRequestInfoStack.get();
         infoStack.disableCount++;
     }
     public void enableInterceptorsThisThread() {
         if( !hasClientInterceptors ) return;
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalClientRequestInfoStack.get();
         infoStack.disableCount--;
     }
     public void invokeClientPIStartingPoint()
         throws RemarshalException
     {
         if( !hasClientInterceptors ) return;
         if( !isClientPIEnabledForThisThread() ) return;
         // Invoke the starting interception points and record exception
         // and reply status info in the info object:
         ClientRequestInfoImpl info = peekClientRequestInfoImplStack();
         interceptorInvoker.invokeClientInterceptorStartingPoint( info );
         // Check reply status.  If we will not have another chance later
         // to invoke the client ending points, do it now.
         short replyStatus = info.getReplyStatus();
         if( (replyStatus == SYSTEM_EXCEPTION.value) ||
             (replyStatus == LOCATION_FORWARD.value) )
         {
             // Note: Transport retry cannot happen here since this happens
             // before the request hits the wire.
             Exception exception = invokeClientPIEndingPoint(
                 convertPIReplyStatusToReplyMessage( replyStatus ),
                 info.getException() );
             if( exception == null ) {
                 // Do not throw anything.  Otherwise, it must be a
                 // SystemException, UserException or RemarshalException.
             } if( exception instanceof SystemException ) {
                 throw (SystemException)exception;
             } else if( exception instanceof RemarshalException ) {
                 throw (RemarshalException)exception;
             } else if( (exception instanceof UserException) ||
                      (exception instanceof ApplicationException) ) {
                 // It should not be possible for an interceptor to throw
                 // a UserException.  By asserting instead of throwing the
                 // UserException, we need not declare anything but
                 // RemarshalException in the throws clause.
                 throw wrapper.exceptionInvalid() ;
             }
         }
         else if( replyStatus != ClientRequestInfoImpl.UNINITIALIZED ) {
             throw wrapper.replyStatusNotInit() ;
         }
     }
     // Needed when an error forces a retry AFTER initiateClientPIRequest
     // but BEFORE invokeClientPIStartingPoint.
     public Exception makeCompletedClientRequest( int replyStatus,
         Exception exception ) {
         // 6763340
         return handleClientPIEndingPoint( replyStatus, exception, false ) ;
     }
     public Exception invokeClientPIEndingPoint( int replyStatus,
         Exception exception ) {
         // 6763340
         return handleClientPIEndingPoint( replyStatus, exception, true ) ;
     }
     public Exception handleClientPIEndingPoint(
         int replyStatus, Exception exception, boolean invokeEndingPoint ) {
         if( !hasClientInterceptors ) return exception;
         if( !isClientPIEnabledForThisThread() ) return exception;
         // Translate ReplyMessage.replyStatus into PI replyStatus:
         // Note: this is also an assertion to make sure a valid replyStatus
         // is passed in (IndexOutOfBoundsException will be thrown otherwise)
         short piReplyStatus = REPLY_MESSAGE_TO_PI_REPLY_STATUS[replyStatus];
         // Invoke the ending interception points and record exception
         // and reply status info in the info object:
         ClientRequestInfoImpl info = peekClientRequestInfoImplStack();
         info.setReplyStatus( piReplyStatus );
         info.setException( exception );
         if (invokeEndingPoint) {
             // 6763340
             interceptorInvoker.invokeClientInterceptorEndingPoint( info );
             piReplyStatus = info.getReplyStatus();
         }
         // Check reply status:
         if( (piReplyStatus == LOCATION_FORWARD.value) ||
             (piReplyStatus == TRANSPORT_RETRY.value) ) {
             // If this is a forward or a retry, reset and reuse
             // info object:
             info.reset();
             // fix for 6763340:
             if (invokeEndingPoint) {
                 info.setRetryRequest( RetryType.AFTER_RESPONSE ) ;
             } else {
                 info.setRetryRequest( RetryType.BEFORE_RESPONSE ) ;
             }
             // ... and return a RemarshalException so the orb internals know
             exception = new RemarshalException();
         } else if( (piReplyStatus == SYSTEM_EXCEPTION.value) ||
                  (piReplyStatus == USER_EXCEPTION.value) ) {
             exception = info.getException();
         }
         return exception;
     }
     public void initiateClientPIRequest( boolean diiRequest ) {
         if( !hasClientInterceptors ) return;
         if( !isClientPIEnabledForThisThread() ) return;
         // Get the most recent info object from the thread local
         // ClientRequestInfoImpl stack:
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalClientRequestInfoStack.get();
         ClientRequestInfoImpl info = null;
         if (!infoStack.empty() ) {
             info = (ClientRequestInfoImpl)infoStack.peek();
         }
         if (!diiRequest && (info != null) && info.isDIIInitiate() ) {
             // In RequestImpl.doInvocation we already called
             // initiateClientPIRequest( true ), so ignore this initiate.
             info.setDIIInitiate( false );
         } else {
             // If there is no info object or if we are not retrying a request,
             // push a new ClientRequestInfoImpl on the stack:
             // 6763340: don't push unless this is not a retry
             if( (info == null) || !info.getRetryRequest().isRetry() ) {
                 info = new ClientRequestInfoImpl( orb );
                 infoStack.push( info );
                 printPush();
                 // Note: the entry count is automatically initialized to 0.
             }
             // Reset the retry request flag so that recursive calls will
             // push a new info object, and bump up entry count so we know
             // when to pop this info object:
             info.setRetryRequest( RetryType.NONE );
             info.incrementEntryCount();
             // KMC 6763340: I don't know why this wasn't set earlier,
             // but we do not want a retry to pick up the previous
             // reply status, so clear it here.  Most likely a new
             // info was pushed before, so that this was not a problem.
             info.setReplyStatus( RequestInfoImpl.UNINITIALIZED ) ;
             // If this is a DII request, make sure we ignore the next initiate.
             if( diiRequest ) {
                 info.setDIIInitiate( true );
             }
         }
     }
     public void cleanupClientPIRequest() {
         if( !hasClientInterceptors ) return;
         if( !isClientPIEnabledForThisThread() ) return;
         ClientRequestInfoImpl info = peekClientRequestInfoImplStack();
         RetryType rt = info.getRetryRequest() ;
         // fix for 6763340
         if (!rt.equals( RetryType.BEFORE_RESPONSE )) {
             // If the replyStatus has not yet been set, this is an indication
             // that the ORB threw an exception before we had a chance to
             // invoke the client interceptor ending points.
             //
             // _REVISIT_ We cannot handle any exceptions or ForwardRequests
             // flagged by the ending points here because there is no way
             // to gracefully handle this in any of the calling code.
             // This is a rare corner case, so we will ignore this for now.
             short replyStatus = info.getReplyStatus();
             if (replyStatus == info.UNINITIALIZED ) {
                 invokeClientPIEndingPoint( ReplyMessage.SYSTEM_EXCEPTION,
                     wrapper.unknownRequestInvoke(
                         CompletionStatus.COMPLETED_MAYBE ) ) ;
             }
         }
         // Decrement entry count, and if it is zero, pop it from the stack.
         info.decrementEntryCount();
         // fix for 6763340, and probably other cases (non-recursive retry)
         if (info.getEntryCount() == 0 && !info.getRetryRequest().isRetry()) {
             // RequestInfoStack<ClientRequestInfoImpl> infoStack =
             //     threadLocalClientRequestInfoStack.get();
             RequestInfoStack infoStack =
                 (RequestInfoStack)threadLocalClientRequestInfoStack.get();
             infoStack.pop();
             printPop();
         }
     }
     public void setClientPIInfo(CorbaMessageMediator messageMediator)
     {
         if( !hasClientInterceptors ) return;
         if( !isClientPIEnabledForThisThread() ) return;
         peekClientRequestInfoImplStack().setInfo(messageMediator);
     }
     public void setClientPIInfo( RequestImpl requestImpl ) {
         if( !hasClientInterceptors ) return;
         if( !isClientPIEnabledForThisThread() ) return;
         peekClientRequestInfoImplStack().setDIIRequest( requestImpl );
     }
     /*
      *****************
      * Server PI hooks
      *****************/
     public void invokeServerPIStartingPoint()
     {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         interceptorInvoker.invokeServerInterceptorStartingPoint( info );
         // Handle SystemException or ForwardRequest:
         serverPIHandleExceptions( info );
     }
     public void invokeServerPIIntermediatePoint()
     {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         interceptorInvoker.invokeServerInterceptorIntermediatePoint( info );
         // Clear servant from info object so that the user has control over
         // its lifetime:
         info.releaseServant();
         // Handle SystemException or ForwardRequest:
         serverPIHandleExceptions( info );
     }
     public void invokeServerPIEndingPoint( ReplyMessage replyMessage )
     {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         // REVISIT: This needs to be done "early" for the following workaround.
         info.setReplyMessage( replyMessage );
         // REVISIT: This was done inside of invokeServerInterceptorEndingPoint
         // but needs to be here for now.  See comment in that method for why.
         info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );
         // It is possible we might have entered this method more than
         // once (e.g. if an ending point threw a SystemException, then
         // a new ServerResponseImpl is created).
         if( !info.getAlreadyExecuted() ) {
             int replyStatus = replyMessage.getReplyStatus();
             // Translate ReplyMessage.replyStatus into PI replyStatus:
             // Note: this is also an assertion to make sure a valid
             // replyStatus is passed in (IndexOutOfBoundsException will be
             // thrown otherwise)
             short piReplyStatus =
                 REPLY_MESSAGE_TO_PI_REPLY_STATUS[replyStatus];
             // Make forwarded IOR available to interceptors, if applicable:
             if( ( piReplyStatus == LOCATION_FORWARD.value ) ||
                 ( piReplyStatus == TRANSPORT_RETRY.value ) )
             {
                 info.setForwardRequest( replyMessage.getIOR() );
             }
             // REVISIT: Do early above for now.
             // Make reply message available to interceptors:
             //info.setReplyMessage( replyMessage );
             // Remember exception so we can tell if an interceptor changed it.
             Exception prevException = info.getException();
             // _REVISIT_ We do not have access to the User Exception at
             // this point, so treat it as an UNKNOWN for now.
             // Note that if this is a DSI call, we do have the user exception.
             if( !info.isDynamic() &&
                 (piReplyStatus == USER_EXCEPTION.value) )
             {
                 info.setException( omgWrapper.unknownUserException(
                     CompletionStatus.COMPLETED_MAYBE ) ) ;
             }
             // Invoke the ending interception points:
             info.setReplyStatus( piReplyStatus );
             interceptorInvoker.invokeServerInterceptorEndingPoint( info );
             short newPIReplyStatus = info.getReplyStatus();
             Exception newException = info.getException();
             // Check reply status.  If an interceptor threw a SystemException
             // and it is different than the one that we came in with,
             // rethrow it so the proper response can be constructed:
             if( ( newPIReplyStatus == SYSTEM_EXCEPTION.value ) &&
                 ( newException != prevException ) )
             {
                 throw (SystemException)newException;
             }
             // If we are to forward the location:
             if( newPIReplyStatus == LOCATION_FORWARD.value ) {
                 if( piReplyStatus != LOCATION_FORWARD.value ) {
                     // Treat a ForwardRequest as a ForwardException.
                     IOR ior = info.getForwardRequestIOR();
                     throw new ForwardException( orb, ior ) ;
                 }
                 else if( info.isForwardRequestRaisedInEnding() ) {
                     // Treat a ForwardRequest by changing the IOR.
                     replyMessage.setIOR( info.getForwardRequestIOR() );
                 }
             }
         }
     }
     public void setServerPIInfo( Exception exception ) {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         info.setException( exception );
     }
     public void setServerPIInfo( NVList arguments )
     {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         info.setDSIArguments( arguments );
     }
     public void setServerPIExceptionInfo( Any exception )
     {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         info.setDSIException( exception );
     }
     public void setServerPIInfo( Any result )
     {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         info.setDSIResult( result );
     }
     public void initializeServerPIInfo( CorbaMessageMediator request,
         ObjectAdapter oa, byte[] objectId, ObjectKeyTemplate oktemp )
     {
         if( !hasServerInterceptors ) return;
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalServerRequestInfoStack.get();
         ServerRequestInfoImpl info = new ServerRequestInfoImpl( orb );
         infoStack.push( info );
         printPush();
         // Notify request object that once response is constructed, make
         // sure we execute ending points.
         request.setExecutePIInResponseConstructor( true );
         info.setInfo( request, oa, objectId, oktemp );
     }
     public void setServerPIInfo( java.lang.Object servant,
                                           String targetMostDerivedInterface )
     {
         if( !hasServerInterceptors ) return;
         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();
         info.setInfo( servant, targetMostDerivedInterface );
     }
     public void cleanupServerPIRequest() {
         if( !hasServerInterceptors ) return;
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalServerRequestInfoStack.get();
         infoStack.pop();
         printPop();
     }
     /*
      **********************************************************************
      *  The following methods are private utility methods.
      ************************************************************************/
     /**
      * Handles exceptions for the starting and intermediate points for
      * server request interceptors.  This is common code that has been
      * factored out into this utility method.
      * <p>
      * This method will NOT work for ending points.
      */
     private void serverPIHandleExceptions( ServerRequestInfoImpl info )
     {
         int endingPointCall = info.getEndingPointCall();
         if(endingPointCall == ServerRequestInfoImpl.CALL_SEND_EXCEPTION) {
             // If a system exception was thrown, throw it to caller:
             throw (SystemException)info.getException();
         }
         else if( (endingPointCall == ServerRequestInfoImpl.CALL_SEND_OTHER) &&
                  (info.getForwardRequestException() != null) )
         {
             // If an interceptor throws a forward request, convert it
             // into a ForwardException for easier handling:
             IOR ior = info.getForwardRequestIOR();
             throw new ForwardException( orb, ior );
         }
     }
     /**
      * Utility method to convert a PI reply status short to a ReplyMessage
      * constant.  This is a reverse lookup on the table defined in
      * REPLY_MESSAGE_TO_PI_REPLY_STATUS.  The reverse lookup need not be
      * performed as quickly since it is only executed in exception
      * conditions.
      */
     private int convertPIReplyStatusToReplyMessage( short replyStatus ) {
         int result = 0;
         for( int i = 0; i < REPLY_MESSAGE_TO_PI_REPLY_STATUS.length; i++ ) {
             if( REPLY_MESSAGE_TO_PI_REPLY_STATUS[i] == replyStatus ) {
                 result = i;
                 break;
             }
         }
         return result;
     }
     /**
      * Convenience method to get the ClientRequestInfoImpl object off the
      * top of the ThreadLocal stack.  Throws an INTERNAL exception if
      * the Info stack is empty.
      */
     private ClientRequestInfoImpl peekClientRequestInfoImplStack() {
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalClientRequestInfoStack.get();
         ClientRequestInfoImpl info = null;
         if( !infoStack.empty() ) {
             info = (ClientRequestInfoImpl)infoStack.peek();
         } else {
             throw wrapper.clientInfoStackNull() ;
         }
         return info;
     }
     /**
      * Convenience method to get the ServerRequestInfoImpl object off the
      * top of the ThreadLocal stack.  Returns null if there are none.
      */
     private ServerRequestInfoImpl peekServerRequestInfoImplStack() {
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalServerRequestInfoStack.get();
         ServerRequestInfoImpl info = null;
         if( !infoStack.empty() ) {
             info = (ServerRequestInfoImpl)infoStack.peek();
         } else {
             throw wrapper.serverInfoStackNull() ;
         }
         return info;
     }
     /**
      * Convenience method to determine whether Client PI is enabled
      * for requests on this thread.
      */
     private boolean isClientPIEnabledForThisThread() {
         RequestInfoStack infoStack =
             (RequestInfoStack)threadLocalClientRequestInfoStack.get();
         return (infoStack.disableCount == 0);
     }
     /**
      * Call pre_init on all ORB initializers
      */
     private void preInitORBInitializers( ORBInitInfoImpl info ) {
         // Inform ORBInitInfo we are in pre_init stage
         info.setStage( ORBInitInfoImpl.STAGE_PRE_INIT );
         // Step through each initializer instantiation and call its
         // pre_init.  Ignore any exceptions.
         for( int i = 0; i < orb.getORBData().getORBInitializers().length;
             i++ ) {
             ORBInitializer init = orb.getORBData().getORBInitializers()[i];
             if( init != null ) {
                 try {
                     init.pre_init( info );
                 }
                 catch( Exception e ) {
                     // As per orbos/99-12-02, section 9.3.1.2, "If there are
                     // any exceptions, the ORB shall ignore them and proceed."
                 }
             }
         }
     }
     /**
      * Call post_init on all ORB initializers
      */
     private void postInitORBInitializers( ORBInitInfoImpl info ) {
         // Inform ORBInitInfo we are in post_init stage
         info.setStage( ORBInitInfoImpl.STAGE_POST_INIT );
         // Step through each initializer instantiation and call its post_init.
         // Ignore any exceptions.
         for( int i = 0; i < orb.getORBData().getORBInitializers().length;
             i++ ) {
             ORBInitializer init = orb.getORBData().getORBInitializers()[i];
             if( init != null ) {
                 try {
                     init.post_init( info );
                 }
                 catch( Exception e ) {
                     // As per orbos/99-12-02, section 9.3.1.2, "If there are
                     // any exceptions, the ORB shall ignore them and proceed."
                 }
             }
         }
     }
     /**
      * Creates the ORBInitInfo object to be passed to ORB intializers'
      * pre_init and post_init methods
      */
     private ORBInitInfoImpl createORBInitInfo() {
         ORBInitInfoImpl result = null;
         // arguments comes from set_parameters.  May be null.
         // _REVISIT_ The spec does not specify which ID this is to be.
         // We currently get this from the corba.ORB, which reads it from
         // the ORB_ID_PROPERTY property.
         String orbId = orb.getORBData().getORBId() ;
         result = new ORBInitInfoImpl( orb, arguments, orbId, codecFactory );
         return result;
     }
     /**
      * Called by ORBInitInfo when an interceptor needs to be registered.
      * The type is one of:
      * <ul>
      *   <li>INTERCEPTOR_TYPE_CLIENT - ClientRequestInterceptor
      *   <li>INTERCEPTOR_TYPE_SERVER - ServerRequestInterceptor
      *   <li>INTERCEPTOR_TYPE_IOR - IORInterceptor
      * </ul>
      *
      * @exception DuplicateName Thrown if an interceptor of the given
      *     name already exists for the given type.
      */
     public void register_interceptor( Interceptor interceptor, int type )
         throws DuplicateName
     {
         // We will assume interceptor is not null, since it is called
         // internally.
         if( (type >= InterceptorList.NUM_INTERCEPTOR_TYPES) || (type < 0) ) {
             throw wrapper.typeOutOfRange( new Integer( type ) ) ;
         }
         String interceptorName = interceptor.name();
         if( interceptorName == null ) {
             throw wrapper.nameNull() ;
         }
         // Register with interceptor list:
         interceptorList.register_interceptor( interceptor, type );
     }
     public Current getPICurrent( ) {
         return current;
     }
     /**
      * Called when an invalid null parameter was passed.  Throws a
      * BAD_PARAM with a minor code of 1
      */
     private void nullParam()
         throws BAD_PARAM
     {
         throw orbutilWrapper.nullParam() ;
     }
     /** This is the implementation of standard API defined in org.omg.CORBA.ORB
      *  class. This method finds the Policy Factory for the given Policy Type
      *  and instantiates the Policy object from the Factory. It will throw
      *  PolicyError exception, If the PolicyFactory for the given type is
      *  not registered.
      *  _REVISIT_, Once Policy Framework work is completed, Reorganize
      *  this method to com.sun.corba.se.spi.orb.ORB.
      */
     public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any val)
         throws org.omg.CORBA.PolicyError
     {
         if( val == null ) {
             nullParam( );
         }
         if( policyFactoryTable == null ) {
             throw new org.omg.CORBA.PolicyError(
                 "There is no PolicyFactory Registered for type " + type,
                 BAD_POLICY.value );
         }
         PolicyFactory factory = (PolicyFactory)policyFactoryTable.get(
             new Integer(type) );
         if( factory == null ) {
             throw new org.omg.CORBA.PolicyError(
                 " Could Not Find PolicyFactory for the Type " + type,
                 BAD_POLICY.value);
         }
         org.omg.CORBA.Policy policy = factory.create_policy( type, val );
         return policy;
     }
     /** This method registers the Policy Factory in the policyFactoryTable,
      *  which is a HashMap. This method is made package private, because
      *  it is used internally by the  Interceptors.
      */
     public void registerPolicyFactory( int type, PolicyFactory factory ) {
         if( policyFactoryTable == null ) {
             policyFactoryTable = new HashMap();
         }
         Integer key = new Integer( type );
         java.lang.Object val = policyFactoryTable.get( key );
         if( val == null ) {
             policyFactoryTable.put( key, factory );
         }
         else {
             throw omgWrapper.policyFactoryRegFailed( new Integer( type ) ) ;
         }
     }
     public synchronized int allocateServerRequestId ()
     {
         return serverRequestIdCounter++;
     }
 }

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/corba/se/impl/interceptors/PIHandlerImpl.java