corbaclientrequestdispatcherimpl.java

JAVA 所有包

/*
 * @(#)CorbaClientRequestDispatcherImpl.java	1.87 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

/*
 * Licensed Materials - Property of IBM
 * RMI-IIOP v1.0
 * Copyright IBM Corp. 1998 1999  All Rights Reserved
 *
 * US Government Users Restricted Rights - Use, duplication or
 * disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

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;

/**
 * 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
{
    // Used for locking
    private Object lock = new 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
	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();
				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();
		return beginRequest(self, opName, isOneWay, contactInfo);
	    } else {
		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));
	    }
	}