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

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

src/share/classes/com/sun/corba/se/impl/interceptors/ClientRequestInfoImpl.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 371: e324dfb90c9e
permissions: -rw-r--r--

6962318: Update copyright year
Reviewed-by: xdono

 /*
  * Copyright (c) 2000, 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.HashMap ;
 import org.omg.CORBA.Any;
 import org.omg.CORBA.BAD_INV_ORDER;
 import org.omg.CORBA.BAD_PARAM;
 import org.omg.CORBA.CompletionStatus;
 import org.omg.CORBA.Context;
 import org.omg.CORBA.ContextList;
 import org.omg.CORBA.CTX_RESTRICT_SCOPE;
 import org.omg.CORBA.ExceptionList;
 import org.omg.CORBA.LocalObject;
 import org.omg.CORBA.NamedValue;
 import org.omg.CORBA.NO_IMPLEMENT;
 import org.omg.CORBA.NO_RESOURCES;
 import org.omg.CORBA.NVList;
 import org.omg.CORBA.Object;
 import org.omg.CORBA.ParameterMode;
 import org.omg.CORBA.Policy;
 import org.omg.CORBA.SystemException;
 import org.omg.CORBA.TypeCode;
 import org.omg.CORBA.INTERNAL;
 import org.omg.CORBA.UserException;
 import org.omg.CORBA.portable.ApplicationException;
 import org.omg.CORBA.portable.InputStream;
 import com.sun.corba.se.spi.servicecontext.ServiceContexts;
 import com.sun.corba.se.spi.servicecontext.UnknownServiceContext;
 import org.omg.IOP.ServiceContext;
 import org.omg.IOP.ServiceContextHelper;
 import org.omg.IOP.TaggedProfile;
 import org.omg.IOP.TaggedProfileHelper;
 import org.omg.IOP.TaggedComponent;
 import org.omg.IOP.TaggedComponentHelper;
 import org.omg.IOP.TAG_INTERNET_IOP;
 import org.omg.Dynamic.Parameter;
 import org.omg.PortableInterceptor.ClientRequestInfo;
 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 com.sun.corba.se.pept.protocol.MessageMediator;
 import com.sun.corba.se.spi.ior.IOR;
 import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate;
 import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
 import com.sun.corba.se.spi.orb.ORB;
 import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
 import com.sun.corba.se.spi.protocol.RetryType;
 import com.sun.corba.se.spi.transport.CorbaContactInfo;
 import com.sun.corba.se.spi.transport.CorbaContactInfoList;
 import com.sun.corba.se.spi.transport.CorbaContactInfoListIterator;
 import com.sun.corba.se.impl.encoding.CDROutputStream;
 import com.sun.corba.se.impl.encoding.CDRInputStream_1_0;
 import com.sun.corba.se.impl.orbutil.ORBUtility;
 import com.sun.corba.se.impl.protocol.CorbaInvocationInfo;
 import com.sun.corba.se.impl.util.RepositoryId;
 /**
  * Implementation of the ClientRequestInfo interface as specified in
  * orbos/99-12-02 section 5.4.2.
  */
 public final class ClientRequestInfoImpl
     extends RequestInfoImpl
     implements ClientRequestInfo
 {
     // The available constants for startingPointCall
     static final int CALL_SEND_REQUEST = 0;
     static final int CALL_SEND_POLL = 1;
     // The available constants for endingPointCall
     static final int CALL_RECEIVE_REPLY = 0;
     static final int CALL_RECEIVE_EXCEPTION = 1;
     static final int CALL_RECEIVE_OTHER = 2;
     //////////////////////////////////////////////////////////////////////
     //
     // NOTE: IF AN ATTRIBUTE IS ADDED, PLEASE UPDATE RESET();
     //
     //////////////////////////////////////////////////////////////////////
     // The current retry request status.  True if this request is being
     // retried and this info object is to be reused, or false otherwise.
     private RetryType retryRequest;
     // The number of times this info object has been (re)used.  This is
     // incremented every time a request is retried, and decremented every
     // time a request is complete.  When this reaches zero, the info object
     // is popped from the ClientRequestInfoImpl ThreadLocal stack in the ORB.
     private int entryCount = 0;
     // The RequestImpl is set when the call is DII based.
     // The DII query calls like ParameterList, ExceptionList,
     // ContextList will be delegated to RequestImpl.
     private org.omg.CORBA.Request request;
     // Sources of client request information
     private boolean diiInitiate;
     private CorbaMessageMediator messageMediator;
     // Cached information:
     private org.omg.CORBA.Object cachedTargetObject;
     private org.omg.CORBA.Object cachedEffectiveTargetObject;
     private Parameter[] cachedArguments;
     private TypeCode[] cachedExceptions;
     private String[] cachedContexts;
     private String[] cachedOperationContext;
     private String cachedReceivedExceptionId;
     private Any cachedResult;
     private Any cachedReceivedException;
     private TaggedProfile cachedEffectiveProfile;
     // key = Integer, value = IOP.ServiceContext.
     private HashMap cachedRequestServiceContexts;
     // key = Integer, value = IOP.ServiceContext.
     private HashMap cachedReplyServiceContexts;
     // key = Integer, value = TaggedComponent
     private HashMap cachedEffectiveComponents;
     protected boolean piCurrentPushed;
     //////////////////////////////////////////////////////////////////////
     //
     // NOTE: IF AN ATTRIBUTE IS ADDED, PLEASE UPDATE RESET();
     //
     //////////////////////////////////////////////////////////////////////
     /**
      * Reset the info object so that it can be reused for a retry,
      * for example.
      */
     void reset() {
         super.reset();
         // Please keep these in the same order that they're declared above.
         // 6763340
         retryRequest = RetryType.NONE;
         // Do not reset entryCount because we need to know when to pop this
         // from the stack.
         request = null;
         diiInitiate = false;
         messageMediator = null;
         // Clear cached attributes:
         cachedTargetObject = null;
         cachedEffectiveTargetObject = null;
         cachedArguments = null;
         cachedExceptions = null;
         cachedContexts = null;
         cachedOperationContext = null;
         cachedReceivedExceptionId = null;
         cachedResult = null;
         cachedReceivedException = null;
         cachedEffectiveProfile = null;
         cachedRequestServiceContexts = null;
         cachedReplyServiceContexts = null;
         cachedEffectiveComponents = null;
         piCurrentPushed = false;
         startingPointCall = CALL_SEND_REQUEST;
         endingPointCall = CALL_RECEIVE_REPLY;
     }
     /*
      **********************************************************************
      * Access protection
      **********************************************************************/
     // Method IDs for all methods in ClientRequestInfo.  This allows for a
     // convenient O(1) lookup for checkAccess().
     protected static final int MID_TARGET                  = MID_RI_LAST + 1;
     protected static final int MID_EFFECTIVE_TARGET        = MID_RI_LAST + 2;
     protected static final int MID_EFFECTIVE_PROFILE       = MID_RI_LAST + 3;
     protected static final int MID_RECEIVED_EXCEPTION      = MID_RI_LAST + 4;
     protected static final int MID_RECEIVED_EXCEPTION_ID   = MID_RI_LAST + 5;
     protected static final int MID_GET_EFFECTIVE_COMPONENT = MID_RI_LAST + 6;
     protected static final int MID_GET_EFFECTIVE_COMPONENTS
                                                            = MID_RI_LAST + 7;
     protected static final int MID_GET_REQUEST_POLICY      = MID_RI_LAST + 8;
     protected static final int MID_ADD_REQUEST_SERVICE_CONTEXT
                                                            = MID_RI_LAST + 9;
     // ClientRequestInfo validity table (see ptc/00-08-06 table 21-1).
     // Note: These must be in the same order as specified in contants.
     protected static final boolean validCall[][] = {
         // LEGEND:
         // s_req = send_request     r_rep = receive_reply
         // s_pol = send_poll        r_exc = receive_exception
         //                          r_oth = receive_other
         //
         // A true value indicates call is valid at specified point.
         // A false value indicates the call is invalid.
         //
         //
         // NOTE: If the order or number of columns change, update
         // checkAccess() accordingly.
         //
         //                              { s_req, s_pol, r_rep, r_exc, r_oth }
         // RequestInfo methods:
         /*request_id*/                  { true , true , true , true , true  },
         /*operation*/                   { true , true , true , true , true  },
         /*arguments*/                   { true , false, true , false, false },
         /*exceptions*/                  { true , false, true , true , true  },
         /*contexts*/                    { true , false, true , true , true  },
         /*operation_context*/           { true , false, true , true , true  },
         /*result*/                      { false, false, true , false, false },
         /*response_expected*/           { true , true , true , true , true  },
         /*sync_scope*/                  { true , false, true , true , true  },
         /*reply_status*/                { false, false, true , true , true  },
         /*forward_reference*/           { false, false, false, false, true  },
         /*get_slot*/                    { true , true , true , true , true  },
         /*get_request_service_context*/ { true , false, true , true , true  },
         /*get_reply_service_context*/   { false, false, true , true , true  },
         //
         // ClientRequestInfo methods::
         /*target*/                      { true , true , true , true , true  },
         /*effective_target*/            { true , true , true , true , true  },
         /*effective_profile*/           { true , true , true , true , true  },
         /*received_exception*/          { false, false, false, true , false },
         /*received_exception_id*/       { false, false, false, true , false },
         /*get_effective_component*/     { true , false, true , true , true  },
         /*get_effective_components*/    { true , false, true , true , true  },
         /*get_request_policy*/          { true , false, true , true , true  },
         /*add_request_service_context*/ { true , false, false, false, false }
     };
     /*
      **********************************************************************
      * Public ClientRequestInfo interfaces
      **********************************************************************/
     /**
      * Creates a new ClientRequestInfo implementation.
      * The constructor is package scope since no other package need create
      * an instance of this class.
      */
     protected ClientRequestInfoImpl( ORB myORB ) {
         super( myORB );
         startingPointCall = CALL_SEND_REQUEST;
         endingPointCall = CALL_RECEIVE_REPLY;
     }
     /**
      * The object which the client called to perform the operation.
      */
     public org.omg.CORBA.Object target (){
         // access is currently valid for all states:
         //checkAccess( MID_TARGET );
         if (cachedTargetObject == null) {
             CorbaContactInfo corbaContactInfo = (CorbaContactInfo)
                 messageMediator.getContactInfo();
             cachedTargetObject =
                 iorToObject(corbaContactInfo.getTargetIOR());
         }
         return cachedTargetObject;
     }
     /**
      * The actual object on which the operation will be invoked.  If the
      * reply_status is LOCATION_FORWARD, then on subsequent requests,
      * effective_target will contain the forwarded IOR while target will
      * remain unchanged.
      */
     public org.omg.CORBA.Object effective_target() {
         // access is currently valid for all states:
         //checkAccess( MID_EFFECTIVE_TARGET );
         // Note: This is not necessarily the same as locatedIOR.
         // Reason: See the way we handle COMM_FAILURES in
         // ClientRequestDispatcher.createRequest, v1.32
         if (cachedEffectiveTargetObject == null) {
             CorbaContactInfo corbaContactInfo = (CorbaContactInfo)
                 messageMediator.getContactInfo();
             // REVISIT - get through chain like getLocatedIOR helper below.
             cachedEffectiveTargetObject =
                 iorToObject(corbaContactInfo.getEffectiveTargetIOR());
         }
         return cachedEffectiveTargetObject;
     }
     /**
      * The profile that will be used to send the request.  If a location
      * forward has occurred for this operation's object and that object's
      * profile change accordingly, then this profile will be that located
      * profile.
      */
     public TaggedProfile effective_profile (){
         // access is currently valid for all states:
         //checkAccess( MID_EFFECTIVE_PROFILE );
         if( cachedEffectiveProfile == null ) {
             CorbaContactInfo corbaContactInfo = (CorbaContactInfo)
                 messageMediator.getContactInfo();
             cachedEffectiveProfile =
                 corbaContactInfo.getEffectiveProfile().getIOPProfile();
         }
         // Good citizen: In the interest of efficiency, we assume interceptors
         // will not modify the returned TaggedProfile in any way so we need
         // not make a deep copy of it.
         return cachedEffectiveProfile;
     }
     /**
      * Contains the exception to be returned to the client.
      */
     public Any received_exception (){
         checkAccess( MID_RECEIVED_EXCEPTION );
         if( cachedReceivedException == null ) {
             cachedReceivedException = exceptionToAny( exception );
         }
         // Good citizen: In the interest of efficiency, we assume interceptors
         // will not modify the returned Any in any way so we need
         // not make a deep copy of it.
         return cachedReceivedException;
     }
     /**
      * The CORBA::RepositoryId of the exception to be returned to the client.
      */
     public String received_exception_id (){
         checkAccess( MID_RECEIVED_EXCEPTION_ID );
         if( cachedReceivedExceptionId == null ) {
             String result = null;
             if( exception == null ) {
                 // Note: exception should never be null here since we will
                 // throw a BAD_INV_ORDER if this is not called from
                 // receive_exception.
                 throw wrapper.exceptionWasNull() ;
             } else if( exception instanceof SystemException ) {
                 String name = exception.getClass().getName();
                 result = ORBUtility.repositoryIdOf(name);
             } else if( exception instanceof ApplicationException ) {
                 result = ((ApplicationException)exception).getId();
             }
             // _REVISIT_ We need to be able to handle a UserException in the
             // DII case.  How do we extract the ID from a UserException?
             cachedReceivedExceptionId = result;
         }
         return cachedReceivedExceptionId;
     }
     /**
      * Returns the IOP::TaggedComponent with the given ID from the profile
      * selected for this request.  IF there is more than one component for a
      * given component ID, it is undefined which component this operation
      * returns (get_effective_component should be called instead).
      */
     public TaggedComponent get_effective_component (int id){
         checkAccess( MID_GET_EFFECTIVE_COMPONENT );
         return get_effective_components( id )[0];
     }
     /**
      * Returns all the tagged components with the given ID from the profile
      * selected for this request.
      */
     public TaggedComponent[] get_effective_components (int id){
         checkAccess( MID_GET_EFFECTIVE_COMPONENTS );
         Integer integerId = new Integer( id );
         TaggedComponent[] result = null;
         boolean justCreatedCache = false;
         if( cachedEffectiveComponents == null ) {
             cachedEffectiveComponents = new HashMap();
             justCreatedCache = true;
         }
         else {
             // Look in cache:
             result = (TaggedComponent[])cachedEffectiveComponents.get(
                 integerId );
         }
         // null could mean we cached null or not in cache.
         if( (result == null) &&
             (justCreatedCache ||
             !cachedEffectiveComponents.containsKey( integerId ) ) )
         {
             // Not in cache.  Get it from the profile:
             CorbaContactInfo corbaContactInfo = (CorbaContactInfo)
                 messageMediator.getContactInfo();
             IIOPProfileTemplate ptemp =
                 (IIOPProfileTemplate)corbaContactInfo.getEffectiveProfile().
                 getTaggedProfileTemplate();
             result = ptemp.getIOPComponents(myORB, id);
             cachedEffectiveComponents.put( integerId, result );
         }
         // As per ptc/00-08-06, section 21.3.13.6., If not found, raise
         // BAD_PARAM with minor code INVALID_COMPONENT_ID.
         if( (result == null) || (result.length == 0) ) {
             throw stdWrapper.invalidComponentId( integerId ) ;
         }
         // Good citizen: In the interest of efficiency, we will assume
         // interceptors will not modify the returned TaggedCompoent[], or
         // the TaggedComponents inside of it.  Otherwise, we would need to
         // clone the array and make a deep copy of its contents.
         return result;
     }
     /**
      * Returns the given policy in effect for this operation.
      */
     public Policy get_request_policy (int type){
         checkAccess( MID_GET_REQUEST_POLICY );
         // _REVISIT_ Our ORB is not policy-based at this time.
         throw wrapper.piOrbNotPolicyBased() ;
     }
     /**
      * Allows interceptors to add service contexts to the request.
      * <p>
      * There is no declaration of the order of the service contexts.  They
      * may or may not appear in the order they are added.
      */
     public void add_request_service_context (ServiceContext service_context,
                                              boolean replace)
     {
         checkAccess( MID_ADD_REQUEST_SERVICE_CONTEXT );
         if( cachedRequestServiceContexts == null ) {
             cachedRequestServiceContexts = new HashMap();
         }
         addServiceContext( cachedRequestServiceContexts,
                            messageMediator.getRequestServiceContexts(),
                            service_context, replace );
     }
     // NOTE: When adding a method, be sure to:
     // 1. Add a MID_* constant for that method
     // 2. Call checkAccess at the start of the method
     // 3. Define entries in the validCall[][] table for interception points.
     /*
      **********************************************************************
      * Public RequestInfo interfaces
      *
      * These are implemented here because they have differing
      * implementations depending on whether this is a client or a server
      * request info object.
      **********************************************************************/
     /**
      * See RequestInfoImpl for javadoc.
      */
     public int request_id (){
         // access is currently valid for all states:
         //checkAccess( MID_REQUEST_ID );
         /*
          * NOTE: The requestId in client interceptors is the same as the
          * GIOP request id.  This works because both interceptors and
          * request ids are scoped by the ORB on the client side.
          */
         return messageMediator.getRequestId();
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public String operation (){
         // access is currently valid for all states:
         //checkAccess( MID_OPERATION );
         return messageMediator.getOperationName();
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public Parameter[] arguments (){
         checkAccess( MID_ARGUMENTS );
         if( cachedArguments == null ) {
             if( request == null ) {
                 throw stdWrapper.piOperationNotSupported1() ;
             }
             // If it is DII request then get the arguments from the DII req
             // and convert that into parameters.
             cachedArguments = nvListToParameterArray( request.arguments() );
         }
         // Good citizen: In the interest of efficiency, we assume
         // interceptors will be "good citizens" in that they will not
         // modify the contents of the Parameter[] array.  We also assume
         // they will not change the values of the containing Anys.
         return cachedArguments;
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public TypeCode[] exceptions (){
         checkAccess( MID_EXCEPTIONS );
         if( cachedExceptions == null ) {
             if( request == null ) {
                throw stdWrapper.piOperationNotSupported2() ;
             }
             // Get the list of exceptions from DII request data, If there are
             // no exceptions raised then this method will return null.
             ExceptionList excList = request.exceptions( );
             int count = excList.count();
             TypeCode[] excTCList = new TypeCode[count];
             try {
                 for( int i = 0; i < count; i++ ) {
                     excTCList[i] = excList.item( i );
                 }
             } catch( Exception e ) {
                 throw wrapper.exceptionInExceptions( e ) ;
             }
             cachedExceptions = excTCList;
         }
         // Good citizen: In the interest of efficiency, we assume
         // interceptors will be "good citizens" in that they will not
         // modify the contents of the TypeCode[] array.  We also assume
         // they will not change the values of the containing TypeCodes.
         return cachedExceptions;
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public String[] contexts (){
         checkAccess( MID_CONTEXTS );
         if( cachedContexts == null ) {
             if( request == null ) {
                 throw stdWrapper.piOperationNotSupported3() ;
             }
             // Get the list of contexts from DII request data, If there are
             // no contexts then this method will return null.
             ContextList ctxList = request.contexts( );
             int count = ctxList.count();
             String[] ctxListToReturn = new String[count];
             try {
                 for( int i = 0; i < count; i++ ) {
                     ctxListToReturn[i] = ctxList.item( i );
                 }
             } catch( Exception e ) {
                 throw wrapper.exceptionInContexts( e ) ;
             }
             cachedContexts = ctxListToReturn;
         }
         // Good citizen: In the interest of efficiency, we assume
         // interceptors will be "good citizens" in that they will not
         // modify the contents of the String[] array.
         return cachedContexts;
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public String[] operation_context (){
         checkAccess( MID_OPERATION_CONTEXT );
         if( cachedOperationContext == null ) {
             if( request == null ) {
                 throw stdWrapper.piOperationNotSupported4() ;
             }
             // Get the list of contexts from DII request data, If there are
             // no contexts then this method will return null.
             Context ctx = request.ctx( );
             // _REVISIT_ The API for get_values is not compliant with the spec,
             // Revisit this code once it's fixed.
             // _REVISIT_ Our ORB doesn't support Operation Context, This code
             // will not be excerscised until it's supported.
             // The first parameter in get_values is the start_scope which
             // if blank makes it as a global scope.
             // The second parameter is op_flags which is set to RESTRICT_SCOPE
             // As there is only one defined in the spec.
             // The Third param is the pattern which is '*' requiring it to
             // get all the contexts.
             NVList nvList = ctx.get_values( "", CTX_RESTRICT_SCOPE.value,"*" );
             String[] context = new String[(nvList.count() * 2) ];
             if( ( nvList != null ) &&( nvList.count() != 0 ) ) {
                 // The String[] array will contain Name and Value for each
                 // context and hence double the size in the array.
                 int index = 0;
                 for( int i = 0; i < nvList.count(); i++ ) {
                     NamedValue nv;
                     try {
                         nv = nvList.item( i );
                     }
                     catch (Exception e ) {
                         return (String[]) null;
                     }
                     context[index] = nv.name();
                     index++;
                     context[index] = nv.value().extract_string();
                     index++;
                 }
             }
             cachedOperationContext = context;
         }
         // Good citizen: In the interest of efficiency, we assume
         // interceptors will be "good citizens" in that they will not
         // modify the contents of the String[] array.
         return cachedOperationContext;
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public Any result (){
         checkAccess( MID_RESULT );
         if( cachedResult == null ) {
             if( request == null ) {
                 throw stdWrapper.piOperationNotSupported5() ;
             }
             // Get the result from the DII request data.
             NamedValue nvResult = request.result( );
             if( nvResult == null ) {
                 throw wrapper.piDiiResultIsNull() ;
             }
             cachedResult = nvResult.value();
         }
         // Good citizen: In the interest of efficiency, we assume that
         // interceptors will not modify the contents of the result Any.
         // Otherwise, we would need to create a deep copy of the Any.
         return cachedResult;
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public boolean response_expected (){
         // access is currently valid for all states:
         //checkAccess( MID_RESPONSE_EXPECTED );
         return ! messageMediator.isOneWay();
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public Object forward_reference (){
         checkAccess( MID_FORWARD_REFERENCE );
         // Check to make sure we are in LOCATION_FORWARD
         // state as per ptc/00-08-06, table 21-1
         // footnote 2.
         if( replyStatus != LOCATION_FORWARD.value ) {
             throw stdWrapper.invalidPiCall1() ;
         }
         // Do not cache this value since if an interceptor raises
         // forward request then the next interceptor in the
         // list should see the new value.
         IOR ior = getLocatedIOR();
         return iorToObject(ior);
     }
     private IOR getLocatedIOR()
     {
         IOR ior;
         CorbaContactInfoList contactInfoList = (CorbaContactInfoList)
             messageMediator.getContactInfo().getContactInfoList();
         ior = contactInfoList.getEffectiveTargetIOR();
         return ior;
     }
     protected void setLocatedIOR(IOR ior)
     {
         ORB orb = (ORB) messageMediator.getBroker();
         CorbaContactInfoListIterator iterator = (CorbaContactInfoListIterator)
             ((CorbaInvocationInfo)orb.getInvocationInfo())
             .getContactInfoListIterator();
         // REVISIT - this most likely causes reportRedirect to happen twice.
         // Once here and once inside the request dispatcher.
         iterator.reportRedirect(
             (CorbaContactInfo)messageMediator.getContactInfo(),
             ior);
     }
     /**
      * See RequestInfoImpl for javadoc.
      */
     public org.omg.IOP.ServiceContext get_request_service_context( int id ) {
         checkAccess( MID_GET_REQUEST_SERVICE_CONTEXT );
         if( cachedRequestServiceContexts == null ) {
             cachedRequestServiceContexts = new HashMap();
         }
         return  getServiceContext(cachedRequestServiceContexts,
                                   messageMediator.getRequestServiceContexts(),
                                   id);
     }
     /**
      * does not contain an etry for that ID, BAD_PARAM with a minor code of
      * TBD_BP is raised.
      */
     public org.omg.IOP.ServiceContext get_reply_service_context( int id ) {
         checkAccess( MID_GET_REPLY_SERVICE_CONTEXT );
         if( cachedReplyServiceContexts == null ) {
             cachedReplyServiceContexts = new HashMap();
         }
         // In the event this is called from a oneway, we will have no
         // response object.
         //
         // In the event this is called after a IIOPConnection.purgeCalls,
         // we will have a response object, but that object will
         // not contain a header (which would hold the service context
         // container).  See bug 4624102.
         //
         // REVISIT: this is the only thing used
         // from response at this time.  However, a more general solution
         // would avoid accessing other parts of response's header.
         //
         // Instead of throwing a NullPointer, we will
         // "gracefully" handle these with a BAD_PARAM with minor code 25.
         try {
             ServiceContexts serviceContexts =
                 messageMediator.getReplyServiceContexts();
             if (serviceContexts == null) {
                 throw new NullPointerException();
             }
             return getServiceContext(cachedReplyServiceContexts,
                                      serviceContexts, id);
         } catch (NullPointerException e) {
             // REVISIT how this is programmed - not what it does.
             // See purge calls test.  The waiter is woken up by the
             // call to purge calls - but there is no reply containing
             // service contexts.
             throw stdWrapper.invalidServiceContextId( e ) ;
         }
     }
     //
     // REVISIT
     // Override RequestInfoImpl connection to work in framework.
     //
     public com.sun.corba.se.spi.legacy.connection.Connection connection()
     {
         return (com.sun.corba.se.spi.legacy.connection.Connection)
             messageMediator.getConnection();
     }
     /*
      **********************************************************************
      * Package-scope interfaces
      **********************************************************************/
     protected void setInfo(MessageMediator messageMediator)
     {
         this.messageMediator = (CorbaMessageMediator)messageMediator;
         // REVISIT - so mediator can handle DII in subcontract.
         this.messageMediator.setDIIInfo(request);
     }
     /**
      * Set or reset the retry request flag.
      */
     void setRetryRequest( RetryType retryRequest ) {
         this.retryRequest = retryRequest;
     }
     /**
      * Retrieve the current retry request status.
      */
     RetryType getRetryRequest() {
         // 6763340
         return this.retryRequest;
     }
     /**
      * Increases the entry count by 1.
      */
     void incrementEntryCount() {
         this.entryCount++;
     }
     /**
      * Decreases the entry count by 1.
      */
     void decrementEntryCount() {
         this.entryCount--;
     }
     /**
      * Retrieve the current entry count
      */
     int getEntryCount() {
         return this.entryCount;
     }
     /**
      * Overridden from RequestInfoImpl.  Calls the super class, then
      * sets the ending point call depending on the reply status.
      */
     protected void setReplyStatus( short replyStatus ) {
         super.setReplyStatus( replyStatus );
         switch( replyStatus ) {
         case SUCCESSFUL.value:
             endingPointCall = CALL_RECEIVE_REPLY;
             break;
         case SYSTEM_EXCEPTION.value:
         case USER_EXCEPTION.value:
             endingPointCall = CALL_RECEIVE_EXCEPTION;
             break;
         case LOCATION_FORWARD.value:
         case TRANSPORT_RETRY.value:
             endingPointCall = CALL_RECEIVE_OTHER;
             break;
         }
     }
     /**
      * Sets DII request object in the RequestInfoObject.
      */
     protected void setDIIRequest(org.omg.CORBA.Request req) {
          request = req;
     }
     /**
      * Keeps track of whether initiate was called for a DII request.  The ORB
      * needs to know this so it knows whether to ignore a second call to
      * initiateClientPIRequest or not.
      */
     protected void setDIIInitiate( boolean diiInitiate ) {
         this.diiInitiate = diiInitiate;
     }
     /**
      * See comment for setDIIInitiate
      */
     protected boolean isDIIInitiate() {
         return this.diiInitiate;
     }
     /**
      * The PICurrent stack should only be popped if it was pushed.
      * This is generally the case.  But exceptions which occur
      * after the stub's entry to _request but before the push
      * end up in _releaseReply which will try to pop unless told not to.
      */
     protected void setPICurrentPushed( boolean piCurrentPushed ) {
         this.piCurrentPushed = piCurrentPushed;
     }
     protected boolean isPICurrentPushed() {
         return this.piCurrentPushed;
     }
     /**
      * Overridden from RequestInfoImpl.
      */
     protected void setException( Exception exception ) {
         super.setException( exception );
         // Clear cached values:
         cachedReceivedException = null;
         cachedReceivedExceptionId = null;
     }
     protected boolean getIsOneWay() {
         return ! response_expected();
     }
     /**
      * See description for RequestInfoImpl.checkAccess
      */
     protected void checkAccess( int methodID )
         throws BAD_INV_ORDER
     {
         // Make sure currentPoint matches the appropriate index in the
         // validCall table:
         int validCallIndex = 0;
         switch( currentExecutionPoint ) {
         case EXECUTION_POINT_STARTING:
             switch( startingPointCall ) {
             case CALL_SEND_REQUEST:
                 validCallIndex = 0;
                 break;
             case CALL_SEND_POLL:
                 validCallIndex = 1;
                 break;
             }
             break;
         case EXECUTION_POINT_ENDING:
             switch( endingPointCall ) {
             case CALL_RECEIVE_REPLY:
                 validCallIndex = 2;
                 break;
             case CALL_RECEIVE_EXCEPTION:
                 validCallIndex = 3;
                 break;
             case CALL_RECEIVE_OTHER:
                 validCallIndex = 4;
                 break;
             }
             break;
         }
         // Check the validCall table:
         if( !validCall[methodID][validCallIndex] ) {
             throw stdWrapper.invalidPiCall2() ;
         }
     }
 }
 // End of file.

Mercurial > jdk8-mips64-public > corba / annotate

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

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