jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/protocol/CorbaClientRequestDispatcherImpl.java@052dda3b5ce3 (annotated)

src/share/classes/com/sun/corba/se/impl/protocol/CorbaClientRequestDispatcherImpl.java@052dda3b5ce3 (annotated)

src/share/classes/com/sun/corba/se/impl/protocol/CorbaClientRequestDispatcherImpl.java

Sun, 18 Dec 2011 22:12:41 +0400

author: dmeetry
date: Sun, 18 Dec 2011 22:12:41 +0400
changeset 323: 052dda3b5ce3
parent 231: ff0f02a67881
child 561: b083590cb088
permissions: -rw-r--r--

7046238: new InitialContext(); hangs
Summary: Synchronization on a single monitor for contactInfo parameters with identical hashCode()
Reviewed-by: robm, skoppar

 /*
  * Copyright (c) 2001, 2011, 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.
  */
 /*
  * Licensed Materials - Property of IBM
  * RMI-IIOP v1.0
  * Copyright IBM Corp. 1998 1999  All Rights Reserved
  *
  */
 package com.sun.corba.se.impl.protocol;
 import java.io.IOException;
 import java.util.Iterator;
 import java.rmi.RemoteException;
 import javax.rmi.CORBA.Util;
 import javax.rmi.CORBA.Tie;
 import org.omg.CORBA.COMM_FAILURE;
 import org.omg.CORBA.INTERNAL;
 import org.omg.CORBA.SystemException;
 import org.omg.CORBA.Request;
 import org.omg.CORBA.NamedValue;
 import org.omg.CORBA.NVList;
 import org.omg.CORBA.Context;
 import org.omg.CORBA.ContextList;
 import org.omg.CORBA.ExceptionList;
 import org.omg.CORBA.TypeCode;
 import org.omg.CORBA.portable.RemarshalException;
 import org.omg.CORBA_2_3.portable.InputStream;
 import org.omg.CORBA_2_3.portable.OutputStream;
 import org.omg.CORBA.portable.Delegate;
 import org.omg.CORBA.portable.ServantObject;
 import org.omg.CORBA.portable.ApplicationException;
 import org.omg.CORBA.portable.UnknownException;
 import org.omg.IOP.ExceptionDetailMessage;
 import org.omg.IOP.TAG_CODE_SETS;
 import com.sun.org.omg.SendingContext.CodeBase;
 import com.sun.corba.se.pept.broker.Broker;
 import com.sun.corba.se.pept.encoding.InputObject;
 import com.sun.corba.se.pept.encoding.OutputObject;
 import com.sun.corba.se.pept.protocol.ClientRequestDispatcher;
 import com.sun.corba.se.pept.protocol.MessageMediator;
 import com.sun.corba.se.pept.transport.Connection;
 import com.sun.corba.se.pept.transport.OutboundConnectionCache;
 import com.sun.corba.se.pept.transport.ContactInfo;
 import com.sun.corba.se.spi.ior.IOR;
 import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
 import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate;
 import com.sun.corba.se.spi.ior.iiop.CodeSetsComponent;
 import com.sun.corba.se.spi.oa.OAInvocationInfo;
 import com.sun.corba.se.spi.oa.ObjectAdapterFactory;
 import com.sun.corba.se.spi.orb.ORB;
 import com.sun.corba.se.spi.orb.ORBVersion;
 import com.sun.corba.se.spi.orb.ORBVersionFactory;
 import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
 import com.sun.corba.se.spi.protocol.RequestDispatcherRegistry;
 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.spi.transport.CorbaConnection;
 import com.sun.corba.se.spi.logging.CORBALogDomains;
 import com.sun.corba.se.spi.servicecontext.MaxStreamFormatVersionServiceContext;
 import com.sun.corba.se.spi.servicecontext.ServiceContext;
 import com.sun.corba.se.spi.servicecontext.ServiceContexts;
 import com.sun.corba.se.spi.servicecontext.UEInfoServiceContext;
 import com.sun.corba.se.spi.servicecontext.CodeSetServiceContext;
 import com.sun.corba.se.spi.servicecontext.SendingContextServiceContext;
 import com.sun.corba.se.spi.servicecontext.ORBVersionServiceContext;
 import com.sun.corba.se.spi.servicecontext.MaxStreamFormatVersionServiceContext;
 import com.sun.corba.se.spi.servicecontext.UnknownServiceContext;
 import com.sun.corba.se.impl.encoding.CDRInputObject;
 import com.sun.corba.se.impl.encoding.CodeSetComponentInfo;
 import com.sun.corba.se.impl.encoding.CodeSetConversion;
 import com.sun.corba.se.impl.encoding.EncapsInputStream;
 import com.sun.corba.se.impl.encoding.MarshalOutputStream;
 import com.sun.corba.se.impl.encoding.MarshalInputStream;
 import com.sun.corba.se.impl.logging.ORBUtilSystemException;
 import com.sun.corba.se.impl.orbutil.ORBUtility;
 import com.sun.corba.se.impl.orbutil.ORBConstants;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.KeyAddr;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ProfileAddr;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReferenceAddr;
 import com.sun.corba.se.impl.transport.CorbaContactInfoListIteratorImpl;
 import com.sun.corba.se.impl.util.JDKBridge;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentHashMap;
 /**
  * ClientDelegate is the RMI client-side subcontract or representation
  * It implements RMI delegate as well as our internal ClientRequestDispatcher
  * interface.
  */
 public class CorbaClientRequestDispatcherImpl
     implements
         ClientRequestDispatcher
 {
     private ConcurrentMap<ContactInfo, Object> locks =
             new ConcurrentHashMap<ContactInfo, Object>();
     public OutputObject beginRequest(Object self, String opName,
                                      boolean isOneWay, ContactInfo contactInfo)
     {
       ORB orb = null;
       try {
         CorbaContactInfo corbaContactInfo = (CorbaContactInfo) contactInfo;
         orb =  (ORB)contactInfo.getBroker();
         if (orb.subcontractDebugFlag) {
             dprint(".beginRequest->: op/" + opName);
         }
         //
         // Portable Interceptor initialization.
         //
         orb.getPIHandler().initiateClientPIRequest( false );
         //
         // Connection.
         //
         CorbaConnection connection = null;
         // This locking is done so that multiple connections are not created
         // for the same endpoint
         // 7046238 - Synchronization on a single monitor for contactInfo parameters
         // with identical hashCode(), so we lock on same monitor for equal parameters
         // (which can refer to equal (in terms of equals()) but not the same objects)
         Object lock = locks.get(contactInfo);
         if (lock == null) {
             Object newLock = new Object();
             lock = locks.putIfAbsent(contactInfo, newLock);
             if (lock == null) {
                 lock = newLock;
             }
         }
         synchronized (lock) {
             if (contactInfo.isConnectionBased()) {
                 if (contactInfo.shouldCacheConnection()) {
                     connection = (CorbaConnection)
                         orb.getTransportManager()
                         .getOutboundConnectionCache(contactInfo).get(contactInfo);
                 }
                 if (connection != null) {
                     if (orb.subcontractDebugFlag) {
                         dprint(".beginRequest: op/" + opName
                                + ": Using cached connection: " + connection);
                     }
                 } else {
                     try {
                         connection = (CorbaConnection)
                             contactInfo.createConnection();
                         if (orb.subcontractDebugFlag) {
                             dprint(".beginRequest: op/" + opName
                                    + ": Using created connection: " + connection);
                         }
                     } catch (RuntimeException e) {
                         if (orb.subcontractDebugFlag) {
                             dprint(".beginRequest: op/" + opName
                                    + ": failed to create connection: " + e);
                         }
                         // REVISIT: this part similar to marshalingComplete below.
                         boolean retry = getContactInfoListIterator(orb)
                                            .reportException(contactInfo, e);
                         // REVISIT:
                         // this part similar to Remarshal in this method below
                         if (retry) {
                             if(getContactInfoListIterator(orb).hasNext()) {
                                 contactInfo = (ContactInfo)
                                    getContactInfoListIterator(orb).next();
                                 unregisterWaiter(orb);
                                 return beginRequest(self, opName,
                                                     isOneWay, contactInfo);
                             } else {
                                 throw e;
                             }
                         } else {
                             throw e;
                         }
                     }
                     if (connection.shouldRegisterReadEvent()) {
                         // REVISIT: cast
                         orb.getTransportManager().getSelector(0)
                             .registerForEvent(connection.getEventHandler());
                         connection.setState("ESTABLISHED");
                     }
                     // Do not do connection reclaim here since the connections
                     // are marked in use by registerWaiter() call and since this
                     // call happens later do it after that.
                     if (contactInfo.shouldCacheConnection()) {
                         OutboundConnectionCache connectionCache =
                          orb.getTransportManager()
                             .getOutboundConnectionCache(contactInfo);
                         connectionCache.stampTime(connection);
                         connectionCache.put(contactInfo, connection);
     //              connectionCache.reclaim();
                     }
                 }
             }
         }
         CorbaMessageMediator messageMediator = (CorbaMessageMediator)
             contactInfo.createMessageMediator(
                 orb, contactInfo, connection, opName, isOneWay);
         if (orb.subcontractDebugFlag) {
             dprint(".beginRequest: " + opAndId(messageMediator)
                    + ": created message mediator: " +  messageMediator);
         }
         // NOTE: Thread data so we can get the mediator in release reply
         // in order to remove the waiter in CorbaConnection.
         // We cannot depend on obtaining information in releaseReply
         // via its InputStream argument since, on certain errors
         // (e.g., client marshaling errors), the stream may be null.
         // Likewise for releaseReply "self".
         // NOTE: This must be done before initializing the message since
         // that may start sending fragments which may end up in "early"
         // replies or client marshaling exceptions.
         orb.getInvocationInfo().setMessageMediator(messageMediator);
         if (connection != null && connection.getCodeSetContext() == null) {
             performCodeSetNegotiation(messageMediator);
         }
         addServiceContexts(messageMediator);
         OutputObject outputObject =
             contactInfo.createOutputObject(messageMediator);
         if (orb.subcontractDebugFlag) {
             dprint(".beginRequest: " + opAndId(messageMediator)
                    + ": created output object: " + outputObject);
         }
         // NOTE: Not necessary for oneways, but useful for debugging.
         // This must be done BEFORE message initialization since fragments
         // may be sent at that time.
         registerWaiter(messageMediator);
         // Do connection reclaim now
         synchronized (lock) {
             if (contactInfo.isConnectionBased()) {
                 if (contactInfo.shouldCacheConnection()) {
                     OutboundConnectionCache connectionCache =
                              orb.getTransportManager()
                                 .getOutboundConnectionCache(contactInfo);
                     connectionCache.reclaim();
                 }
             }
         }
         orb.getPIHandler().setClientPIInfo(messageMediator);
         try {
             // This MUST come before message is initialized so
             // service contexts may be added by PI because
             // initial fragments may be sent during message initialization.
             orb.getPIHandler().invokeClientPIStartingPoint();
         } catch( RemarshalException e ) {
             if (orb.subcontractDebugFlag) {
                 dprint(".beginRequest: " + opAndId(messageMediator)
                        + ": Remarshal");
             }
             // NOTE: We get here because an interceptor raised ForwardRequest
             // and updated the IOR/Iterator.  Since we have a fresh iterator
             // hasNext should succeed.
             // REVISIT: We should feed ALL interceptor exceptions to
             // iterator.reportException so it can determine if it wants
             // to retry.  Right now, SystemExceptions will flow to the
             // client code.
             // REVISIT:
             // This assumes that interceptors update
             // ContactInfoList outside of subcontract.
             // Want to move that update to here.
             if (getContactInfoListIterator(orb).hasNext()) {
                 contactInfo = (ContactInfo)getContactInfoListIterator(orb).next();
                 if (orb.subcontractDebugFlag) {
                     dprint( "RemarshalException: hasNext true\ncontact info " + contactInfo );
                 }
                 // Fix for 6763340: Complete the first attempt before starting another.
                 orb.getPIHandler().makeCompletedClientRequest(
                     ReplyMessage.LOCATION_FORWARD, null ) ;
                 unregisterWaiter(orb);
                 orb.getPIHandler().cleanupClientPIRequest() ;
                 return beginRequest(self, opName, isOneWay, contactInfo);
             } else {
                 if (orb.subcontractDebugFlag) {
                     dprint( "RemarshalException: hasNext false" );
                 }
                 ORBUtilSystemException wrapper =
                     ORBUtilSystemException.get(orb,
                                                CORBALogDomains.RPC_PROTOCOL);
                 throw wrapper.remarshalWithNowhereToGo();
             }
         }
         messageMediator.initializeMessage();
         if (orb.subcontractDebugFlag) {
             dprint(".beginRequest: " + opAndId(messageMediator)
                    + ": initialized message");
         }
         return outputObject;
       } finally {
         if (orb.subcontractDebugFlag) {
             dprint(".beginRequest<-: op/" + opName);
         }
       }
     }
     public InputObject marshalingComplete(java.lang.Object self,
                                           OutputObject outputObject)
         throws
             ApplicationException,
             org.omg.CORBA.portable.RemarshalException
     {
         ORB orb = null;
         CorbaMessageMediator messageMediator = null;
         try {
             messageMediator = (CorbaMessageMediator)
                 outputObject.getMessageMediator();
             orb = (ORB) messageMediator.getBroker();
             if (orb.subcontractDebugFlag) {
                 dprint(".marshalingComplete->: " + opAndId(messageMediator));
             }
             InputObject inputObject =
                 marshalingComplete1(orb, messageMediator);
             return processResponse(orb, messageMediator, inputObject);
         } finally {
             if (orb.subcontractDebugFlag) {
                 dprint(".marshalingComplete<-: " + opAndId(messageMediator));
             }
         }
     }
     public InputObject marshalingComplete1(
             ORB orb, CorbaMessageMediator messageMediator)
         throws
             ApplicationException,
             org.omg.CORBA.portable.RemarshalException
     {
         try {
             messageMediator.finishSendingRequest();
             if (orb.subcontractDebugFlag) {
                 dprint(".marshalingComplete: " + opAndId(messageMediator)
                        + ": finished sending request");
             }
             return messageMediator.waitForResponse();
         } catch (RuntimeException e) {
             if (orb.subcontractDebugFlag) {
                 dprint(".marshalingComplete: " + opAndId(messageMediator)
                        + ": exception: " + e.toString());
             }
             boolean retry  =
                 getContactInfoListIterator(orb)
                     .reportException(messageMediator.getContactInfo(), e);
             //Bug 6382377: must not lose exception in PI
             // Must run interceptor end point before retrying.
             Exception newException =
                     orb.getPIHandler().invokeClientPIEndingPoint(
                     ReplyMessage.SYSTEM_EXCEPTION, e);
             if (retry) {
                 if (newException == e) {
                     continueOrThrowSystemOrRemarshal(messageMediator,
                                                      new RemarshalException());
                 } else {
                     continueOrThrowSystemOrRemarshal(messageMediator,
                                                      newException);
                 }
             } else {
                 if (newException instanceof RuntimeException){
                     throw (RuntimeException)newException;
                 }
                 else if (newException instanceof RemarshalException)
                 {
                     throw (RemarshalException)newException;
                 }
                 // NOTE: Interceptor ending point will run in releaseReply.
                 throw e;
             }
             return null; // for compiler
         }
     }
     protected InputObject processResponse(ORB orb,
                                           CorbaMessageMediator messageMediator,
                                           InputObject inputObject)
         throws
             ApplicationException,
             org.omg.CORBA.portable.RemarshalException
     {
         ORBUtilSystemException wrapper =
             ORBUtilSystemException.get( orb,
                 CORBALogDomains.RPC_PROTOCOL ) ;
         if (orb.subcontractDebugFlag) {
             dprint(".processResponse: " + opAndId(messageMediator)
                    + ": response received");
         }
         // We know for sure now that we've sent a message.
         // So OK to not send initial again.
         if (messageMediator.getConnection() != null) {
             ((CorbaConnection)messageMediator.getConnection())
                 .setPostInitialContexts();
         }
         // NOTE: not necessary to set MessageMediator for PI.
         // It already has it.
         // Process the response.
         Exception exception = null;
         if (messageMediator.isOneWay()) {
             getContactInfoListIterator(orb)
                 .reportSuccess(messageMediator.getContactInfo());
             // Invoke Portable Interceptors with receive_other
             exception = orb.getPIHandler().invokeClientPIEndingPoint(
                 ReplyMessage.NO_EXCEPTION, exception );
             continueOrThrowSystemOrRemarshal(messageMediator, exception);
             return null;
         }
         consumeServiceContexts(orb, messageMediator);
         // Now that we have the service contexts processed and the
         // correct ORBVersion set, we must finish initializing the stream.
         // REVISIT - need interface for this operation.
         ((CDRInputObject)inputObject).performORBVersionSpecificInit();
         if (messageMediator.isSystemExceptionReply()) {
             SystemException se = messageMediator.getSystemExceptionReply();
             if (orb.subcontractDebugFlag) {
                 dprint(".processResponse: " + opAndId(messageMediator)
                        + ": received system exception: " + se);
             }
             boolean doRemarshal =
                 getContactInfoListIterator(orb)
                     .reportException(messageMediator.getContactInfo(), se);
             if (doRemarshal) {
                 // Invoke Portable Interceptors with receive_exception:
                 exception = orb.getPIHandler().invokeClientPIEndingPoint(
                     ReplyMessage.SYSTEM_EXCEPTION, se );
                 // If PI did not change the exception, throw a
                 // Remarshal.
                 if( se == exception ) {
                     // exception = null is to maintain symmetry with
                     // GenericPOAClientSC.
                     exception = null;
                     continueOrThrowSystemOrRemarshal(messageMediator,
                                                      new RemarshalException());
                     throw wrapper.statementNotReachable1() ;
                 } else {
                     //  Otherwise, throw the exception PI wants thrown.
                     continueOrThrowSystemOrRemarshal(messageMediator,
                                                      exception);
                     throw wrapper.statementNotReachable2() ;
                 }
             }
             // No retry, so see if was unknown.
             ServiceContexts contexts =
                 messageMediator.getReplyServiceContexts();
             if (contexts != null) {
                 UEInfoServiceContext usc =
                     (UEInfoServiceContext)
                     contexts.get(UEInfoServiceContext.SERVICE_CONTEXT_ID);
                 if (usc != null) {
                     Throwable unknown = usc.getUE() ;
                     UnknownException ue = new UnknownException(unknown);
                     // Invoke Portable Interceptors with receive_exception:
                     exception = orb.getPIHandler().invokeClientPIEndingPoint(
                         ReplyMessage.SYSTEM_EXCEPTION, ue );
                     continueOrThrowSystemOrRemarshal(messageMediator, exception);
                     throw wrapper.statementNotReachable3() ;
                 }
             }
             // It was not a comm failure nor unknown.
             // This is the general case.
             // Invoke Portable Interceptors with receive_exception:
             exception = orb.getPIHandler().invokeClientPIEndingPoint(
                 ReplyMessage.SYSTEM_EXCEPTION, se );
             continueOrThrowSystemOrRemarshal(messageMediator, exception);
             // Note: We should never need to execute this line, but
             // we should assert in case exception is null somehow.
             throw wrapper.statementNotReachable4() ;
         } else if (messageMediator.isUserExceptionReply()) {
             if (orb.subcontractDebugFlag) {
                 dprint(".processResponse: " + opAndId(messageMediator)
                        + ": received user exception");
             }
             getContactInfoListIterator(orb)
                 .reportSuccess(messageMediator.getContactInfo());
             String exceptionRepoId = peekUserExceptionId(inputObject);
             Exception newException = null;
             if (messageMediator.isDIIRequest()) {
                 exception = messageMediator.unmarshalDIIUserException(
                                 exceptionRepoId, (InputStream)inputObject);
                 newException = orb.getPIHandler().invokeClientPIEndingPoint(
                                    ReplyMessage.USER_EXCEPTION, exception );
                 messageMediator.setDIIException(newException);
             } else {
                 ApplicationException appException =
                     new ApplicationException(
                         exceptionRepoId,
                         (org.omg.CORBA.portable.InputStream)inputObject);
                 exception = appException;
                 newException = orb.getPIHandler().invokeClientPIEndingPoint(
                                    ReplyMessage.USER_EXCEPTION, appException );
             }
             if (newException != exception) {
                 continueOrThrowSystemOrRemarshal(messageMediator,newException);
             }
             if (newException instanceof ApplicationException) {
                 throw (ApplicationException)newException;
             }
             // For DII:
             // This return will be ignored - already unmarshaled above.
             return inputObject;
         } else if (messageMediator.isLocationForwardReply()) {
             if (orb.subcontractDebugFlag) {
                 dprint(".processResponse: " + opAndId(messageMediator)
                        + ": received location forward");
             }
             // NOTE: Expects iterator to update target IOR
             getContactInfoListIterator(orb).reportRedirect(
                 (CorbaContactInfo)messageMediator.getContactInfo(),
                 messageMediator.getForwardedIOR());
             // Invoke Portable Interceptors with receive_other:
             Exception newException = orb.getPIHandler().invokeClientPIEndingPoint(
                 ReplyMessage.LOCATION_FORWARD, null );
             if( !(newException instanceof RemarshalException) ) {
                 exception = newException;
             }
             // If PI did not change exception, throw Remarshal, else
             // throw the exception PI wants thrown.
             // KMC: GenericPOAClientSC did not check exception != null
             if( exception != null ) {
                 continueOrThrowSystemOrRemarshal(messageMediator, exception);
             }
             continueOrThrowSystemOrRemarshal(messageMediator,
                                              new RemarshalException());
             throw wrapper.statementNotReachable5() ;
         } else if (messageMediator.isDifferentAddrDispositionRequestedReply()){
             if (orb.subcontractDebugFlag) {
                 dprint(".processResponse: " + opAndId(messageMediator)
                        + ": received different addressing dispostion request");
             }
             // Set the desired target addressing disposition.
             getContactInfoListIterator(orb).reportAddrDispositionRetry(
                 (CorbaContactInfo)messageMediator.getContactInfo(),
                 messageMediator.getAddrDispositionReply());
             // Invoke Portable Interceptors with receive_other:
             Exception newException = orb.getPIHandler().invokeClientPIEndingPoint(
                 ReplyMessage.NEEDS_ADDRESSING_MODE, null);
             // For consistency with corresponding code in GenericPOAClientSC:
             if( !(newException instanceof RemarshalException) ) {
                 exception = newException;
             }
             // If PI did not change exception, throw Remarshal, else
             // throw the exception PI wants thrown.
             // KMC: GenericPOAClientSC did not include exception != null check
             if( exception != null ) {
                 continueOrThrowSystemOrRemarshal(messageMediator, exception);
             }
             continueOrThrowSystemOrRemarshal(messageMediator,
                                              new RemarshalException());
             throw wrapper.statementNotReachable6() ;
         } else /* normal response */ {
             if (orb.subcontractDebugFlag) {
                 dprint(".processResponse: " + opAndId(messageMediator)
                        + ": received normal response");
             }
             getContactInfoListIterator(orb)
                 .reportSuccess(messageMediator.getContactInfo());
             messageMediator.handleDIIReply((InputStream)inputObject);
             // Invoke Portable Interceptors with receive_reply:
             exception = orb.getPIHandler().invokeClientPIEndingPoint(
                 ReplyMessage.NO_EXCEPTION, null );
             // Remember: not thrown if exception is null.
             continueOrThrowSystemOrRemarshal(messageMediator, exception);
             return inputObject;
         }
     }
     // Filters the given exception into a SystemException or a
     // RemarshalException and throws it.  Assumes the given exception is
     // of one of these two types.  This is a utility method for
     // the above invoke code which must do this numerous times.
     // If the exception is null, no exception is thrown.
     //
     // Note that this code is duplicated in GenericPOAClientSC.java
     protected void continueOrThrowSystemOrRemarshal(
         CorbaMessageMediator messageMediator, Exception exception)
         throws
             SystemException, RemarshalException
     {
         ORB orb = (ORB) messageMediator.getBroker();
         if( exception == null ) {
             // do nothing.
         } else if( exception instanceof RemarshalException ) {
             // REVISIT - unify with PI handling
             orb.getInvocationInfo().setIsRetryInvocation(true);
             // NOTE - We must unregister the waiter NOW for this request
             // since the retry will result in a new request id.  Therefore
             // the old request id would be lost and we would have a memory
             // leak in the responseWaitingRoom.
             unregisterWaiter(orb);
             if (orb.subcontractDebugFlag) {
                 dprint(".continueOrThrowSystemOrRemarshal: "
                        + opAndId(messageMediator)
                        + ": throwing Remarshal");
             }
             throw (RemarshalException)exception;
         } else {
             if (orb.subcontractDebugFlag) {
                 dprint(".continueOrThrowSystemOrRemarshal: "
                        + opAndId(messageMediator)
                        + ": throwing sex:"
                        + exception);
             }
             throw (SystemException)exception;
         }
     }
     protected CorbaContactInfoListIterator  getContactInfoListIterator(ORB orb)
     {
         return (CorbaContactInfoListIterator)
             ((CorbaInvocationInfo)orb.getInvocationInfo())
                 .getContactInfoListIterator();
     }
     protected void registerWaiter(CorbaMessageMediator messageMediator)
     {
         if (messageMediator.getConnection() != null) {
             messageMediator.getConnection().registerWaiter(messageMediator);
         }
     }
     protected void unregisterWaiter(ORB orb)
     {
         MessageMediator messageMediator =
             orb.getInvocationInfo().getMessageMediator();
         if (messageMediator!=null && messageMediator.getConnection() != null) {
             // REVISIT:
             // The messageMediator may be null if COMM_FAILURE before
             // it is created.
             messageMediator.getConnection().unregisterWaiter(messageMediator);
         }
     }
     protected void addServiceContexts(CorbaMessageMediator messageMediator)
     {
         ORB orb = (ORB)messageMediator.getBroker();
         CorbaConnection c = (CorbaConnection) messageMediator.getConnection();
         GIOPVersion giopVersion = messageMediator.getGIOPVersion();
         ServiceContexts contexts = messageMediator.getRequestServiceContexts();
         addCodeSetServiceContext(c, contexts, giopVersion);
         // Add the RMI-IIOP max stream format version
         // service context to every request.  Once we have GIOP 1.3,
         // we could skip it since we now support version 2, but
         // probably safer to always send it.
         contexts.put(MaxStreamFormatVersionServiceContext.singleton);
         // ORBVersion servicecontext needs to be sent
         ORBVersionServiceContext ovsc = new ORBVersionServiceContext(
                         ORBVersionFactory.getORBVersion() ) ;
         contexts.put( ovsc ) ;
         // NOTE : We only want to send the runtime context the first time
         if ((c != null) && !c.isPostInitialContexts()) {
             // Do not do c.setPostInitialContexts() here.
             // If a client interceptor send_request does a ForwardRequest
             // which ends up using the same connection then the service
             // context would not be sent.
             SendingContextServiceContext scsc =
                 new SendingContextServiceContext( orb.getFVDCodeBaseIOR() ) ; //d11638
             contexts.put( scsc ) ;
         }
     }
     protected void consumeServiceContexts(ORB orb,
                                         CorbaMessageMediator messageMediator)
     {
         ServiceContexts ctxts = messageMediator.getReplyServiceContexts();
         ServiceContext sc ;
         ORBUtilSystemException wrapper = ORBUtilSystemException.get( orb,
                 CORBALogDomains.RPC_PROTOCOL ) ;
         if (ctxts == null) {
             return; // no service context available, return gracefully.
         }
         sc = ctxts.get( SendingContextServiceContext.SERVICE_CONTEXT_ID ) ;
         if (sc != null) {
             SendingContextServiceContext scsc =
                 (SendingContextServiceContext)sc ;
             IOR ior = scsc.getIOR() ;
             try {
                 // set the codebase returned by the server
                 if (messageMediator.getConnection() != null) {
                     ((CorbaConnection)messageMediator.getConnection()).setCodeBaseIOR(ior);
                 }
             } catch (ThreadDeath td) {
                 throw td ;
             } catch (Throwable t) {
                 throw wrapper.badStringifiedIor( t ) ;
             }
         }
         // see if the version subcontract is present, if yes, then set
         // the ORBversion
         sc = ctxts.get( ORBVersionServiceContext.SERVICE_CONTEXT_ID ) ;
         if (sc != null) {
             ORBVersionServiceContext ovsc =
                (ORBVersionServiceContext) sc;
             ORBVersion version = ovsc.getVersion();
             orb.setORBVersion( version ) ;
         }
         getExceptionDetailMessage(messageMediator, wrapper);
     }
     protected void getExceptionDetailMessage(
         CorbaMessageMediator  messageMediator,
         ORBUtilSystemException wrapper)
     {
         ServiceContext sc = messageMediator.getReplyServiceContexts()
             .get(ExceptionDetailMessage.value);
         if (sc == null)
             return ;
         if (! (sc instanceof UnknownServiceContext)) {
             throw wrapper.badExceptionDetailMessageServiceContextType();
         }
         byte[] data = ((UnknownServiceContext)sc).getData();
         EncapsInputStream in =
             new EncapsInputStream((ORB)messageMediator.getBroker(),
                                   data, data.length);
         in.consumeEndian();
         String msg =
               "----------BEGIN server-side stack trace----------\n"
             + in.read_wstring() + "\n"
             + "----------END server-side stack trace----------";
         messageMediator.setReplyExceptionDetailMessage(msg);
     }
     public void endRequest(Broker broker, Object self, InputObject inputObject)
     {
         ORB orb = (ORB)broker ;
         try {
             if (orb.subcontractDebugFlag) {
                 dprint(".endRequest->");
             }
             // Note: the inputObject may be null if an error occurs
             //       in request or before _invoke returns.
             // Note: self may be null also (e.g., compiler generates null in stub).
             MessageMediator messageMediator =
                 orb.getInvocationInfo().getMessageMediator();
             if (messageMediator != null)
             {
                 if (messageMediator.getConnection() != null)
                 {
                     ((CorbaMessageMediator)messageMediator)
                               .sendCancelRequestIfFinalFragmentNotSent();
                 }
                 // Release any outstanding NIO ByteBuffers to the ByteBufferPool
                 InputObject inputObj = messageMediator.getInputObject();
                 if (inputObj != null) {
                     inputObj.close();
                 }
                 OutputObject outputObj = messageMediator.getOutputObject();
                 if (outputObj != null) {
                     outputObj.close();
                 }
             }
             // XREVISIT NOTE - Assumes unregistering the waiter for
             // location forwards has already happened somewhere else.
             // The code below is only going to unregister the final successful
             // request.
             // NOTE: In the case of a recursive stack of endRequests in a
             // finally block (because of Remarshal) only the first call to
             // unregisterWaiter will remove the waiter.  The rest will be
             // noops.
             unregisterWaiter(orb);
             // Invoke Portable Interceptors cleanup.  This is done to handle
             // exceptions during stream marshaling.  More generally, exceptions
             // that occur in the ORB after send_request (which includes
             // after returning from _request) before _invoke:
             orb.getPIHandler().cleanupClientPIRequest();
             // REVISIT: Early replies?
         } catch (IOException ex) {
             // See CDRInput/OutputObject.close() for more info.
             // This won't result in a Corba error if an IOException happens.
             if (orb.subcontractDebugFlag)
             {
                 dprint(".endRequest: ignoring IOException - " + ex.toString());
             }
         } finally {
             if (orb.subcontractDebugFlag) {
                 dprint(".endRequest<-");
             }
         }
     }
     protected void performCodeSetNegotiation(CorbaMessageMediator messageMediator)
     {
         CorbaConnection conn =
             (CorbaConnection) messageMediator.getConnection();
         IOR ior =
             ((CorbaContactInfo)messageMediator.getContactInfo())
             .getEffectiveTargetIOR();
         GIOPVersion giopVersion = messageMediator.getGIOPVersion();
         // XXX This seems to be a broken double checked locking idiom: FIX IT!
         // conn.getCodeSetContext() is null when no other requests have
         // been made on this connection to trigger code set negotation.
         if (conn != null &&
             conn.getCodeSetContext() == null &&
             !giopVersion.equals(GIOPVersion.V1_0)) {
             synchronized(conn) {
                 // Double checking.  Don't let any other
                 // threads use this connection until the
                 // code sets are straight.
                 if (conn.getCodeSetContext() != null)
                     return;
                 // This only looks at the first code set component.  If
                 // there can be multiple locations with multiple code sets,
                 // this requires more work.
                 IIOPProfileTemplate temp =
                     (IIOPProfileTemplate)ior.getProfile().
                     getTaggedProfileTemplate();
                 Iterator iter = temp.iteratorById(TAG_CODE_SETS.value);
                 if (!iter.hasNext()) {
                     // Didn't have a code set component.  The default will
                     // be to use ISO8859-1 for char data and throw an
                     // exception if wchar data is used.
                     return;
                 }
                 // Get the native and conversion code sets the
                 // server specified in its IOR
                 CodeSetComponentInfo serverCodeSets
                     = ((CodeSetsComponent)iter.next()).getCodeSetComponentInfo();
                 // Perform the negotiation between this ORB's code sets and
                 // the ones from the IOR
                 CodeSetComponentInfo.CodeSetContext result
                     = CodeSetConversion.impl().negotiate(
                           conn.getBroker().getORBData().getCodeSetComponentInfo(),
                           serverCodeSets);
                 conn.setCodeSetContext(result);
             }
         }
     }
     protected void addCodeSetServiceContext(CorbaConnection conn,
                                           ServiceContexts ctxs,
                                           GIOPVersion giopVersion) {
         // REVISIT.  OMG issue 3318 concerning sending the code set
         // service context more than once was deemed too much for the
         // RTF.  Here's our strategy for the moment:
         //
         // Send it on every request (necessary in cases of fragmentation
         // with multithreaded clients or when the first thing on a
         // connection is a LocateRequest).  Provide an ORB property
         // to disable multiple sends.
         //
         // Note that the connection is null in the local case and no
         // service context is included.  We use the ORB provided
         // encapsulation streams.
         //
         // Also, there will be no negotiation or service context
         // in GIOP 1.0.  ISO8859-1 is used for char/string, and
         // wchar/wstring are illegal.
         //
         if (giopVersion.equals(GIOPVersion.V1_0) || conn == null)
             return;
         CodeSetComponentInfo.CodeSetContext codeSetCtx = null;
         if (conn.getBroker().getORBData().alwaysSendCodeSetServiceContext() ||
             !conn.isPostInitialContexts()) {
             // Get the negotiated code sets (if any) out of the connection
             codeSetCtx = conn.getCodeSetContext();
         }
         // Either we shouldn't send the code set service context, or
         // for some reason, the connection doesn't have its code sets.
         // Perhaps the server didn't include them in the IOR.  Uses
         // ISO8859-1 for char and makes wchar/wstring illegal.
         if (codeSetCtx == null)
             return;
         CodeSetServiceContext cssc = new CodeSetServiceContext(codeSetCtx);
         ctxs.put(cssc);
     }
     protected String peekUserExceptionId(InputObject inputObject)
     {
         CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
         // REVISIT - need interface for mark/reset
         cdrInputObject.mark(Integer.MAX_VALUE);
         String result = cdrInputObject.read_string();
         cdrInputObject.reset();
         return result;
     }
     protected void dprint(String msg)
     {
         ORBUtility.dprint("CorbaClientRequestDispatcherImpl", msg);
     }
     protected String opAndId(CorbaMessageMediator mediator)
     {
         return ORBUtility.operationNameAndRequestId(mediator);
     }
 }
 // End of file.

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/protocol/CorbaClientRequestDispatcherImpl.java@052dda3b5ce3 (annotated)

src/share/classes/com/sun/corba/se/impl/protocol/CorbaClientRequestDispatcherImpl.java