| /* |
| * Copyright (c) 2001, 2013, 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; |
| import sun.corba.EncapsInputStreamFactory; |
| |
| /** |
| * 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 = |
| EncapsInputStreamFactory.newEncapsInputStream((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. |
