/* * @(#)ServerRequestInfoImpl.java 1.41 04/06/21 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package com.sun.corba.se.impl.interceptors; import org.omg.CORBA.Any; import org.omg.CORBA.BAD_INV_ORDER; import org.omg.CORBA.CompletionStatus; import org.omg.CORBA.INTERNAL; import org.omg.CORBA.LocalObject; 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.Policy; import org.omg.CORBA.TypeCode; import org.omg.PortableServer.Servant; import org.omg.IOP.TaggedProfile; import org.omg.IOP.ServiceContext; import org.omg.Dynamic.Parameter; import org.omg.PortableInterceptor.InvalidSlot; import org.omg.PortableInterceptor.ServerRequestInfo; 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.spi.oa.ObjectAdapter; import com.sun.corba.se.spi.presentation.rmi.StubAdapter; import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage; import com.sun.corba.se.spi.servicecontext.ServiceContexts; import com.sun.corba.se.spi.orb.ORB; import com.sun.corba.se.spi.ior.ObjectKeyTemplate; import com.sun.corba.se.spi.ior.ObjectAdapterId ; import com.sun.corba.se.spi.protocol.CorbaMessageMediator; import java.util.*; /** * Implementation of the ServerRequestInfo interface as specified in * orbos/99-12-02 section 5.4.3. */ public final class ServerRequestInfoImpl extends RequestInfoImpl implements ServerRequestInfo { // The available constants for startingPointCall static final int CALL_RECEIVE_REQUEST_SERVICE_CONTEXT = 0; // The available constants for intermediatePointCall. The default (0) // is receive_request, but can be set to none on demand. static final int CALL_RECEIVE_REQUEST = 0; static final int CALL_INTERMEDIATE_NONE = 1; // The available constants for endingPointCall static final int CALL_SEND_REPLY = 0; static final int CALL_SEND_EXCEPTION = 1; static final int CALL_SEND_OTHER = 2; ////////////////////////////////////////////////////////////////////// // // NOTE: IF AN ATTRIBUTE IS ADDED, PLEASE UPDATE RESET(); // ////////////////////////////////////////////////////////////////////// // Set to true if the server ending point raised ForwardRequest at some // point in the ending point. private boolean forwardRequestRaisedInEnding; // Sources of server request information: private CorbaMessageMediator request; private java.lang.Object servant; private byte[] objectId; private ObjectKeyTemplate oktemp ; // Information cached from calls to oktemp private byte[] adapterId; private String[] adapterName; private ArrayList addReplyServiceContextQueue; private ReplyMessage replyMessage; private String targetMostDerivedInterface; private NVList dsiArguments; private Any dsiResult; private Any dsiException; private boolean isDynamic; private ObjectAdapter objectAdapter; private int serverRequestId; // Cached information: private Parameter[] cachedArguments; private Any cachedSendingException; // key = Integer, value = IOP.ServiceContext. private HashMap cachedRequestServiceContexts; // key = Integer, value = IOP.ServiceContext. private HashMap cachedReplyServiceContexts; ////////////////////////////////////////////////////////////////////// // // 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 as declared above. forwardRequestRaisedInEnding = false; request = null; servant = null; objectId = null; oktemp = null; adapterId = null; adapterName = null; addReplyServiceContextQueue = null; replyMessage = null; targetMostDerivedInterface = null; dsiArguments = null; dsiResult = null; dsiException = null; isDynamic = false; objectAdapter = null; serverRequestId = myORB.getPIHandler().allocateServerRequestId(); // reset cached attributes: cachedArguments = null; cachedSendingException = null; cachedRequestServiceContexts = null; cachedReplyServiceContexts = null; startingPointCall = CALL_RECEIVE_REQUEST_SERVICE_CONTEXT; intermediatePointCall = CALL_RECEIVE_REQUEST; endingPointCall = CALL_SEND_REPLY; } /* ********************************************************************** * Access protection **********************************************************************/ // Method IDs for all methods in ServerRequestInfo. This allows for a // convenient O(1) lookup for checkAccess(). protected static final int MID_SENDING_EXCEPTION = MID_RI_LAST + 1; protected static final int MID_OBJECT_ID = MID_RI_LAST + 2; protected static final int MID_ADAPTER_ID = MID_RI_LAST + 3; protected static final int MID_TARGET_MOST_DERIVED_INTERFACE = MID_RI_LAST + 4; protected static final int MID_GET_SERVER_POLICY = MID_RI_LAST + 5; protected static final int MID_SET_SLOT = MID_RI_LAST + 6; protected static final int MID_TARGET_IS_A = MID_RI_LAST + 7; protected static final int MID_ADD_REPLY_SERVICE_CONTEXT = MID_RI_LAST + 8; protected static final int MID_SERVER_ID = MID_RI_LAST + 9; protected static final int MID_ORB_ID = MID_RI_LAST + 10; protected static final int MID_ADAPTER_NAME = MID_RI_LAST + 11; // ServerRequestInfo validity table (see ptc/00-08-06 table 21-2). // Note: These must be in the same order as specified in contants. protected static final boolean validCall[][] = { // LEGEND: // r_rsc = receive_request_service_contexts // r_req = receive_request // s_rep = send_reply // s_exc = send_exception // s_oth = send_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. // // { r_rsc, r_req, s_rep, s_exc, s_oth } // RequestInfo methods: /*request_id*/ { true , true , true , true , true }, /*operation*/ { true , true , true , true , true }, /*arguments*/ { false, true , true , false, false }, /*exceptions*/ { false, true , true , true , true }, /*contexts*/ { false, true , true , true , true }, /*operation_context*/ { false, true , true , false, false }, /*result*/ { false, false, true , false, false }, /*response_expected*/ { true , true , true , true , true }, /*sync_scope*/ { true , true , 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 , true , true , true , true }, /*get_reply_service_context*/ { false, false, true , true , true }, // // ServerRequestInfo methods:: /*sending_exception*/ { false, false, false, true , false }, /*object_id*/ { false, true , true , true , true }, /*adapter_id*/ { false, true , true , true , true }, /*target_most_derived_inte...*/ { false, true , false, false, false }, /*get_server_policy*/ { true , true , true , true , true }, /*set_slot*/ { true , true , true , true , true }, /*target_is_a*/ { false, true , false, false, false }, /*add_reply_service_context*/ { true , true , true , true , true }, /*orb_id*/ { false, true , true , true , true }, /*server_id*/ { false, true , true , true , true }, /*adapter_name*/ { false, true , true , true , true } }; /* ********************************************************************** * Public interfaces **********************************************************************/ /** * Creates a new ServerRequestInfo implementation. * The constructor is package scope since no other package need create * an instance of this class. */ ServerRequestInfoImpl( ORB myORB ) { super( myORB ); startingPointCall = CALL_RECEIVE_REQUEST_SERVICE_CONTEXT; intermediatePointCall = CALL_RECEIVE_REQUEST; endingPointCall = CALL_SEND_REPLY; serverRequestId = myORB.getPIHandler().allocateServerRequestId(); } /** * Any containing the exception to be returned to the client. */ public Any sending_exception () { checkAccess( MID_SENDING_EXCEPTION ); if( cachedSendingException == null ) { Any result = null ; if( dsiException != null ) { result = dsiException; } else if( exception != null ) { result = exceptionToAny( exception ); } else { // sending_exception should not be callable if both dsiException // and exception are null. throw wrapper.exceptionUnavailable() ; } cachedSendingException = result; } return cachedSendingException; } /** * The opaque object_id describing the target of the operation invocation. */ public byte[] object_id () { checkAccess( MID_OBJECT_ID ); if( objectId == null ) { // For some reason, we never set object id. This could be // because a servant locator caused a location forward or // raised an exception. As per ptc/00-08-06, section 21.3.14, // we throw NO_RESOURCES throw stdWrapper.piOperationNotSupported6() ; } // Good citizen: In the interest of efficiency, we will assume // interceptors will not change the resulting byte[] array. // Otherwise, we would need to make a clone of this array. return objectId; } private void checkForNullTemplate() { if (oktemp == null) { // For some reason, we never set the ObjectKeyTemplate // because a servant locator caused a location forward or // raised an exception. As per ptc/00-08-06, section 21.3.14, // we throw NO_RESOURCES throw stdWrapper.piOperationNotSupported7() ; } } public String server_id() { checkAccess( MID_SERVER_ID ) ; checkForNullTemplate() ; // Good citizen: In the interest of efficiency, we will assume // interceptors will not change the resulting byte[] array. // Otherwise, we would need to make a clone of this array. return Integer.toString( oktemp.getServerId() ) ; } public String orb_id() { checkAccess( MID_ORB_ID ) ; return myORB.getORBData().getORBId() ; } synchronized public String[] adapter_name() { checkAccess( MID_ADAPTER_NAME ) ; if (adapterName == null) { checkForNullTemplate() ; ObjectAdapterId oaid = oktemp.getObjectAdapterId() ; adapterName = oaid.getAdapterName() ; } return adapterName ; } /** * The opaque identifier for the object adapter. */ synchronized public byte[] adapter_id () { checkAccess( MID_ADAPTER_ID ); if( adapterId == null ) { checkForNullTemplate() ; adapterId = oktemp.getAdapterId() ; } return adapterId; } /** * The RepositoryID for the most derived interface of the servant. */ public String target_most_derived_interface () { checkAccess( MID_TARGET_MOST_DERIVED_INTERFACE ); return targetMostDerivedInterface; } /** * Returns the policy in effect for this operation for the given policy * type. */ public Policy get_server_policy (int type) { // access is currently valid for all states: //checkAccess( MID_GET_SERVER_POLICY ); Policy result = null; if( objectAdapter != null ) { result = objectAdapter.getEffectivePolicy( type ); } // _REVISIT_ RTF Issue: get_server_policy spec not in sync with // get_effective_policy spec. return result; } /** * Allows an Interceptor to set a slot in the Current that is in the scope * of the request. If data already exists in that slot, it will be * overwritten. If the ID does not define an allocated slot, InvalidSlot * is raised. */ public void set_slot (int id, Any data) throws InvalidSlot { // access is currently valid for all states: //checkAccess( MID_SET_SLOT ); slotTable.set_slot( id, data ); } /** * Returns true if the servant is the given RepositoryId, false if it is * not. */ public boolean target_is_a (String id) { checkAccess( MID_TARGET_IS_A ); boolean result = false ; if( servant instanceof Servant ) { result = ((Servant)servant)._is_a( id ); } else if (StubAdapter.isStub( servant )) { result = ((org.omg.CORBA.Object)servant)._is_a( id ); } else { throw wrapper.servantInvalid() ; } return result; } /** * Allows Interceptors to add service contexts to the request. */ public void add_reply_service_context ( ServiceContext service_context, boolean replace ) { // access is currently valid for all states: //checkAccess( MID_ADD_REPLY_SERVICE_CONTEXT ); if( currentExecutionPoint == EXECUTION_POINT_ENDING ) { ServiceContexts scs = replyMessage.getServiceContexts(); // May be null. If this is null, create a new one in its place. if( scs == null ) { scs = new ServiceContexts( myORB ); replyMessage.setServiceContexts( scs ); } if( cachedReplyServiceContexts == null ) { cachedReplyServiceContexts = new HashMap(); } // This is during and ending point, so we now have enough // information to add the reply service context. addServiceContext( cachedReplyServiceContexts, scs, service_context, replace ); } // We enqueue all adds for the following reasons: // // If we are not in the ending point then we do not yet have a // pointer to the ServiceContexts object so we cannot access the // service contexts until we get to the ending point. // So we enqueue this add reply service context request. // It is added when we do have a handle on the service contexts object. // // If we are in the ending point and we just add directly to the // SC container but then an interceptor raises a SystemException // then that add will be lost since a new container is created // for the SystemException response. // // Therefore we always enqueue and never dequeue (per request) so // that all adds will be completed. AddReplyServiceContextCommand addReply = new AddReplyServiceContextCommand(); addReply.service_context = service_context; addReply.replace = replace; if( addReplyServiceContextQueue == null ) { addReplyServiceContextQueue = new ArrayList(); } // REVISIT: this does not add to the cache. enqueue( addReply ); } // 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 ServerRequestInfo for javadocs. */ public int request_id (){ // access is currently valid for all states: //checkAccess( MID_REQUEST_ID ); /* * NOTE: The request id in server interceptors is NOT the * same as the GIOP request id. The ORB may be servicing several * connections, each with possibly overlapping sets of request ids. * Therefore we create a request id specific to interceptors. */ return serverRequestId; } /** * See ServerRequestInfo for javadocs. */ public String operation (){ // access is currently valid for all states: //checkAccess( MID_OPERATION ); return request.getOperationName(); } /** * See ServerRequestInfo for javadocs. */ public Parameter[] arguments (){ checkAccess( MID_ARGUMENTS ); if( cachedArguments == null ) { if( !isDynamic ) { throw stdWrapper.piOperationNotSupported1() ; } if( dsiArguments == null ) { throw stdWrapper.piOperationNotSupported8() ; } // If it is a DSI request then get the arguments from the DSI req // and convert that into parameters. cachedArguments = nvListToParameterArray( dsiArguments ); } // 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 ServerRequestInfo for javadocs. */ public TypeCode[] exceptions (){ checkAccess( MID_EXCEPTIONS ); // _REVISIT_ PI RTF Issue: No exception list on server side. throw stdWrapper.piOperationNotSupported2() ; } /** * See ServerRequestInfo for javadocs. */ public String[] contexts (){ checkAccess( MID_CONTEXTS ); // We do not support this because our ORB does not send contexts. throw stdWrapper.piOperationNotSupported3() ; } /** * See ServerRequestInfo for javadocs. */ public String[] operation_context (){ checkAccess( MID_OPERATION_CONTEXT ); // We do not support this because our ORB does not send // operation_context. throw stdWrapper.piOperationNotSupported4() ; } /** * See ServerRequestInfo for javadocs. */ public Any result (){ checkAccess( MID_RESULT ); if( !isDynamic ) { throw stdWrapper.piOperationNotSupported5() ; } if( dsiResult == null ) { throw wrapper.piDsiResultIsNull() ; } // 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 dsiResult; } /** * See ServerRequestInfo for javadocs. */ public boolean response_expected (){ // access is currently valid for all states: //checkAccess( MID_RESPONSE_EXPECTED ); return !request.isOneWay(); } /** * See ServerRequestInfo for javadocs. */ 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-2 // footnote 2. if( replyStatus != LOCATION_FORWARD.value ) { throw stdWrapper.invalidPiCall1() ; } return getForwardRequestException().forward; } /** * See ServerRequestInfo for javadocs. */ 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, request.getRequestServiceContexts(), id ); } /** * See ServerRequestInfo for javadocs. */ public org.omg.IOP.ServiceContext get_reply_service_context( int id ) { checkAccess( MID_GET_REPLY_SERVICE_CONTEXT ); if( cachedReplyServiceContexts == null ) { cachedReplyServiceContexts = new HashMap(); } return getServiceContext( cachedReplyServiceContexts, replyMessage.getServiceContexts(), id ); } /* ********************************************************************** * Private-scope classes and methods **********************************************************************/ // A command encapsulating a request to add a reply service context. // These commands are enqueued until we have a handle on the actual // reply service context, at which point they are executed. private class AddReplyServiceContextCommand { ServiceContext service_context; boolean replace; } // Adds the given add reply service context command to the queue of // such commands. If a command is detected to have the same id as // the service context in this command, and replace is false, // BAD_INV_ORDER is thrown. If replace is true, the original command // in the queue is replaced by this command. private void enqueue( AddReplyServiceContextCommand addReply ) { int size = addReplyServiceContextQueue.size(); boolean found = false; for( int i = 0; i < size; i++ ) { AddReplyServiceContextCommand cmd = (AddReplyServiceContextCommand) addReplyServiceContextQueue.get( i ); if( cmd.service_context.context_id == addReply.service_context.context_id ) { found = true; if( addReply.replace ) { addReplyServiceContextQueue.set( i, addReply ); } else { throw stdWrapper.serviceContextAddFailed( new Integer( cmd.service_context.context_id ) ) ; } break; } } if( !found ) { addReplyServiceContextQueue.add( addReply ); } } /* ********************************************************************** * Package and protected-scope methods **********************************************************************/ /** * Overridden from RequestInfoImpl. This version calls the super * and then, if we are changing to ending points, executes all * enqueued AddReplyServiceContextCommands. */ protected void setCurrentExecutionPoint( int executionPoint ) { super.setCurrentExecutionPoint( executionPoint ); // If we are transitioning to ending point, we will now have a pointer // to the reply service contexts, so we can execute all queued // add reply service context requests. if( (executionPoint == EXECUTION_POINT_ENDING) && (addReplyServiceContextQueue != null) ) { int size = addReplyServiceContextQueue.size(); for( int i = 0; i < size; i++ ) { AddReplyServiceContextCommand addReply = (AddReplyServiceContextCommand) addReplyServiceContextQueue.get( i ); try { add_reply_service_context( addReply.service_context, addReply.replace ); } catch( BAD_INV_ORDER e ) { // _REVISIT_ The only way this can happen is if during // rrsc or rr, the interceptor tried to add with // replace=false to a service context that is present in // the reply message. At that time there was no way for // us to check for this, so the best we can do is ignore // the original request. } } // We specifically do not empty the SC queue so that if // the interceptor raises an exception the queued service contexts // will be put in the exception response. } } /** * Stores the various sources of information used for this info object. */ protected void setInfo( CorbaMessageMediator request, ObjectAdapter oa, byte[] objectId, ObjectKeyTemplate oktemp ) { this.request = request; this.objectId = objectId; this.oktemp = oktemp; this.objectAdapter = oa ; this.connection = (com.sun.corba.se.spi.legacy.connection.Connection) request.getConnection(); } /** * Stores the various sources of information used for this info object. */ protected void setDSIArguments( NVList arguments ) { this.dsiArguments = arguments; } /** * Stores the various sources of information used for this info object. */ protected void setDSIException( Any exception ) { this.dsiException = exception; // Clear cached exception value: cachedSendingException = null; } /** * Stores the various sources of information used for this info object. */ protected void setDSIResult( Any result ) { this.dsiResult = result; } /** * Sets the exception to be returned by received_exception and * received_exception_id. */ protected void setException( Exception exception ) { super.setException( exception ); // Make sure DSIException is null because this is the more recent one. this.dsiException = null; // Clear cached exception value: cachedSendingException = null; } /** * Stores the various sources of information used for this info object. */ protected void setInfo( java.lang.Object servant, String targetMostDerivedInterface ) { this.servant = servant; this.targetMostDerivedInterface = targetMostDerivedInterface; this.isDynamic = (servant instanceof org.omg.PortableServer.DynamicImplementation) || (servant instanceof org.omg.CORBA.DynamicImplementation); } /** * Set reply message */ void setReplyMessage( ReplyMessage replyMessage ) { this.replyMessage = replyMessage; } /** * 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_SEND_REPLY; break; case SYSTEM_EXCEPTION.value: case USER_EXCEPTION.value: endingPointCall = CALL_SEND_EXCEPTION; break; case LOCATION_FORWARD.value: case TRANSPORT_RETRY.value: endingPointCall = CALL_SEND_OTHER; break; } } /** * Release the servant object so the user has control over its lifetime. * Called after receive_request is finished executing. */ void releaseServant() { this.servant = null; } /** * Sets the forwardRequestRaisedInEnding flag to true, indicating that * a server ending point has raised location forward at some point. */ void setForwardRequestRaisedInEnding() { this.forwardRequestRaisedInEnding = true; } /** * Returns true if ForwardRequest was raised by a server ending point * or false otherwise. */ boolean isForwardRequestRaisedInEnding() { return this.forwardRequestRaisedInEnding; } /** * Returns true if this is a dynamic invocation, or false if not */ boolean isDynamic() { return this.isDynamic; } /** * See description for RequestInfoImpl.checkAccess */ protected void checkAccess( int methodID ) { // Make sure currentPoint matches the appropriate index in the // validCall table: int validCallIndex = 0; switch( currentExecutionPoint ) { case EXECUTION_POINT_STARTING: validCallIndex = 0; break; case EXECUTION_POINT_INTERMEDIATE: validCallIndex = 1; break; case EXECUTION_POINT_ENDING: switch( endingPointCall ) { case CALL_SEND_REPLY: validCallIndex = 2; break; case CALL_SEND_EXCEPTION: validCallIndex = 3; break; case CALL_SEND_OTHER: validCallIndex = 4; break; } break; } // Check the validCall table: if( !validCall[methodID][validCallIndex] ) { throw stdWrapper.invalidPiCall2() ; } } }