*        JacORB - a free Java ORB

*

*   Copyright (C) 1997-2014 Gerald Brose / The JacORB Team.

*

*   This library is free software; you can redistribute it and/or

*   modify it under the terms of the GNU Library General Public

*   License as published by the Free Software Foundation; either

*   version 2 of the License, or (at your option) any later version.

*

*   This library 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

*   Library General Public License for more details.

*

*   You should have received a copy of the GNU Library General Public

*   License along with this library; if not, write to the Free

*   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

* JacORB implementation of CORBA object reference

*

* @author Gerald Brose

*

*/

    extends org.omg.CORBA_2_3.portable.Delegate

    // WARNING: DO NOT USE _pior DIRECTLY, BECAUSE THAT IS NOT MT

    // SAFE. USE getParsedIOR() INSTEAD, AND KEEP A METHOD-LOCAL COPY

    // OF THE REFERENCE.

    private ParsedIOR _pior = null;

    private IOR ior = null;

    /**

     * Normally a delegate only has one connection open at a time. With the addition

     * of MIOP it is possible for the user to request a two-way operation (via e.g. IIOP)

     * and then a one-way operation via MIOP. Rather than repeatedly calling

     * ConnectionManager.getConnection the additional MIOP connection will also be cached

     * here.

     */

    private ClientConnection connections[] = new ClientConnection[2];

    private enum TransportType { IIOP, MIOP };

    /**

     * The current connection; this should be either IIOP or MIOP where

     * 0 = IIOP

     * 1 = MIOP

     */

    private TransportType currentConnection = TransportType.IIOP;

    /* save original ior for fallback */

    private ParsedIOR piorOriginal = null;

    /* save iors to detect and prevent locate forward loop */

    private ParsedIOR piorLastFailed = null;

    private boolean bound = false;

    private org.jacorb.poa.POA poa;

    private final org.jacorb.orb.ORB orb;

    private final Logger logger;

    /** set after the first attempt to determine whether

        this reference is to a local object */

    private boolean resolved_locality = false;

    private final ConcurrentHashMap<org.omg.ETF.Profile, ReplyGroup> groups;

    private final java.lang.Object bind_sync = new java.lang.Object();

    private boolean locate_on_bind_performed = false;

    private final ClientConnectionManager conn_mg;

    private final Map<Integer, Policy> policy_overrides;

    private CookieHolder cookie = null;

    private boolean clearCurrentContext = true;

    private String invokedOperation = null;

    private final SelectorManager selectorManager;

    /**

     * <code>localInterceptors</code> stores the ClientInterceptorHandler that is

     * currently in use during an interceptor invocation. It is held within a

     * thread local to prevent thread interaction issues.

     */

    private static final ThreadLocal<ClientInterceptorHandler> localInterceptors = new ThreadLocal<ClientInterceptorHandler>();

    /** the configuration object for this delegate */

    private final Configuration configuration;

    /** configuration properties */

    private boolean locateOnBind;

    /** mitigate the symptom of an infinite loop in some imr failure cases, see bug 810 */

    private int maxBuiltinRetries = 0;

   /**

    * This is the default GIOP minor version configured by JacORB. Most of the time

    * JacORB will use whatever is within the effective profile. In the case of MIOP this

    * information may not be available to it will use this to set the GIOP version.

    */

    private int defaultGiopMinor;

    /**

     * specify if this Delegate should drop its connection to the remote ORB after

     * a non-recoverable SystemException occured. non-recoverable SystemException

     * couldn't be handled by rebind.

     */

    private boolean disconnectAfterNonRecoverableSystemException;

    /**

     * Always attempt to locate is_a information locally rather than remotely.

     */

    private boolean avoidIsARemoteCall=true;

    /**

     * Preserve JacORB 2.3.x series behaviour with interceptors which restores the

     * 2.3.x behaviour of returning false from an is_local call when interceptors are

     * enabled and installed.

     *

     * This should NOT be required in general and has only been added for certain scenarios

     * with legacy applications. Do not remove without checking with Nick Cross (13/April/2012)

     */

    private boolean isLocalHistoricalInterceptors = false;

    /**

     *  Denote whether to allow orbPolicies or do optimised version

     */

    private boolean disableClientOrbPolicies;

    /** delay in millisecs before retrying */

    private Random randomDelay = null;

    public static enum INVOCATION_KEY

    {

       REQUEST_END_TIME,

       REPLY_END_TIME,

       /**

        * This is used to indicate that a current context popped from the Delegates

        * invocationContext stack was pushed there prior to an interceptor call.  We

        * need this to ensure that the context is not popped if a CORBA call is made

        * by the interceptor.  The context must be popped on return from the

        * interceptor.

        */

       INTERCEPTOR_CALL,

       SERVANT_PREINVOKE

    };

    private static enum SyncScope

    {

        NONE (org.omg.Messaging.SYNC_NONE.value),

        TRANSPORT (org.omg.Messaging.SYNC_WITH_TRANSPORT.value),

        SERVER (org.omg.Messaging.SYNC_WITH_SERVER.value),

        TARGET (org.omg.Messaging.SYNC_WITH_TARGET.value);

        public static SyncScope getSyncScope (String ss) throws ConfigurationException

        {

            try

            {

                return valueOf (ss.toUpperCase ());

            }

            catch (IllegalArgumentException e)

            {

                throw new ConfigurationException ("Invalid type for SyncScope", e);

            }

        }

        public short getType ()

        {

            return value;

        }

        private short value;

        private SyncScope(short value)

        {

            this.value = value;

        }

    };

    private SyncScope defaultSyncScope = SyncScope.TRANSPORT;

    /**

     * 03-09-04: 1.5.2.2

     *

     * boolean threadlocal to ensure that

     * after servant_preinvoke has returned null the

     * next call to is_local will return false

     * so that the stub will choose the non-optimized path

     */

    private static final ThreadLocal<Boolean> ignoreNextCallToIsLocal = new ThreadLocal<Boolean>()

    {

        @Override

        protected Boolean initialValue()

        {

            return Boolean.FALSE;

        }

    };

    /**

     * @see #getInvocationContext()

     * @see #clearInvocationContext()

     * This is a <code>ArrayDeque</code> containing HashMaps.  The HashMap will

     * contain values that apply to the current invocation.  A ArrayDeque of

     * HashMaps is needed to cater for the fact that invocations can be

     * made within invocations and the values may differ for each invocation.

     * We need to retain the values for the original invocation as well as

     * apply the correct values for any internal invocation.

     */

    private static final ThreadLocal<ArrayDeque<Map<INVOCATION_KEY, UtcT>>> invocationContext = new ThreadLocal<ArrayDeque<Map<INVOCATION_KEY, UtcT>>>()

    {

        @Override

        protected ArrayDeque<Map<INVOCATION_KEY, UtcT>> initialValue()

        {

            return new ArrayDeque<Map<INVOCATION_KEY, UtcT>> ();

        };

    };

    /**

     * access the current invocation context (its a ArrayDeque of Maps).

     * this context lives as long as the invocation is active.

     * especially it outlives RemarshalExceptions and thus

     * can be used to share information between mutiple requests

     * that are done as part of an invocation.

     */

    public static final ArrayDeque<Map<INVOCATION_KEY, UtcT>> getInvocationContext()

    {

        return invocationContext.get();

    }

    /**

     * clear the current invocation context. must be invoked

     * before control is returned to the client

     * (exceptions, orderly termination).

     * mustn't be reset in case of RemarshalExceptions.

     */

    public static void clearInvocationContext()

    {

        if ( ! ( getInvocationContext()).isEmpty())

        {

            ( getInvocationContext()).pop();

        }

    }

    /**

     * A general note on the synchronization concept

     *

     * The main problem that has to be addressed by synchronization

     * means is the case when an object reference is shared by

     * threads, and LocationForwards (e.g. thrown by the ImR) or

     * ForwardRequest (thrown by ClientInterceptors) involved. In

     * these cases, the rebinding to another target can occur while

     * there are still other requests active. Therefore, the act of

     * rebinding must be synchronized, so every thread sees a

     * consistent state.

     *

     * Synchronization is done via the bind_sync object. Please also

     * have a look at the comment for operation bind().

     */

    /* constructors: */

    private Delegate(ORB orb, Configuration config, boolean parseIORLazy)

    {

        super();

        this.orb = orb;

        configuration = config;

        conn_mg = orb.getClientConnectionManager();

        selectorManager = orb.getSelectorManager ();

        logger = config.getLogger("org.jacorb.orb.delegate");

        locateOnBind =

            config.getAttributeAsBoolean("jacorb.locate_on_bind", false);

        avoidIsARemoteCall =

            config.getAttributeAsBoolean("jacorb.avoidIsARemoteCall", true);

        isLocalHistoricalInterceptors =

            config.getAttributeAsBoolean("jacorb.isLocalHistoricalInterceptors", false);

        try

        {

            maxBuiltinRetries =

                config.getAttributeAsInteger ("jacorb.maxBuiltinRetries", 0);

            if (maxBuiltinRetries < 0)

            {

                logger.error ("Configuration error - max builtin retries < 0");

                throw new INTERNAL ("Configuration error - max builtin retries < 0");

            }

        }

        catch (ConfigurationException ex)

        {

            logger.error ("Configuration exception retrieving max builtin retries", ex);

            throw new INTERNAL ("Configuration exception retrieving max builtin retries" + ex);

        }

        disconnectAfterNonRecoverableSystemException = config.getAttributeAsBoolean

            ("jacorb.connection.client.disconnect_after_systemexception", true);

        disableClientOrbPolicies = config.getAttributeAsBoolean("jacorb.disableClientOrbPolicies", false);

        try

        {

           defaultGiopMinor = configuration.getAttributeAsInteger ("jacorb.giop_minor_version", 2);

        }

        catch (ConfigurationException ex)

        {

            logger.error ("Configuration exception retrieving giop minor version", ex);

            throw new INTERNAL ("Configuration exception retrieving giop minor version" + ex);

        }

        try

        {

            defaultSyncScope = SyncScope.getSyncScope (configuration.getAttribute("jacorb.default_sync_scope","TRANSPORT"));

        }

        catch (ConfigurationException ex)

        {

            logger.error ("Configuration exception retrieving default sync scope ", ex);

            throw new INTERNAL ("Configuration exception retrieving default sync scope " + ex);

        }

        // standard initialization

        groups = new ConcurrentHashMap<org.omg.ETF.Profile, ReplyGroup>();

        if (parseIORLazy)

        {

            // reference received across the net

            if (disableClientOrbPolicies)

            {

                policy_overrides = Collections.emptyMap ();

            }

            else

            {

                policy_overrides = new HashMap<Integer, Policy>(0);

            }

        }

        else

        {

            // reference locally created

            if (disableClientOrbPolicies)

            {

                policy_overrides = Collections.emptyMap ();

            }

            else

            {

                policy_overrides = new HashMap<Integer, Policy>();

            }

        }

    }

    private Delegate(ORB orb, boolean parseIORLazy)

    {

        this(orb, orb.getConfiguration(), parseIORLazy);

    }

    public Delegate ( org.jacorb.orb.ORB orb, ParsedIOR pior )

    {

        this(orb, false);

        _pior = pior;

    }

    public Delegate(org.jacorb.orb.ORB orb, IOR ior, boolean parseIORLazy)

    {

        this(orb, parseIORLazy);

        this.ior = ior;

        if (parseIORLazy)

        {

            // postpone parsing of IOR.

            // see getParsedIOR

        }

        else

        {

            getParsedIOR();

        }

    }

    public Delegate(org.jacorb.orb.ORB orb, org.omg.IOP.IOR ior)

    {

        this(orb, ior, false);

    }

    public int _get_TCKind()

    {

        return org.omg.CORBA.TCKind._tk_objref;

    }

    /**

     * This bind is a combination of the old _init() and bind()

     * operations. It first inits this delegate with the information

     * supplied by the (parsed) IOR. Then it requests a new

     * ClientConnection from the ConnectionsManager. This will *NOT*

     * open up a TCP connection, but the connection is needed for the

     * GIOP message ids. The actual TCP connection is automatically

     * opened up by the ClientConnection, when the first request is

     * sent. This has the advantage, that COMM_FAILURES can only occur

     * inside of _invoke, where they get handled properly (falling

     * back, etc.)

     */

    private void bind()

    {

        synchronized (bind_sync)

        {

            if ( bound )

            {

                return;

            }

            final ParsedIOR ior = getParsedIOR();

            ior.patchSSL ();

            // Check if ClientProtocolPolicy set, if so, set profile

            // selector for IOR that selects effective profile for protocol

            org.omg.RTCORBA.Protocol[] protocols = getClientProtocols();

            if (protocols != null)

            {

                ior.setProfileSelector (new SpecificProfileSelector(protocols));

            }

            org.omg.ETF.Profile profile = ior.getEffectiveProfile();

            if (profile == null)

            {

                throw new org.omg.CORBA.COMM_FAILURE ("no effective profile");

            }

            //MIOP

            if(profile instanceof MIOPProfile)

            {

                connections[TransportType.MIOP.ordinal ()] = conn_mg.getConnection(profile);

                profile = ((MIOPProfile)profile).getGroupIIOPProfile();

            }

            if (profile != null)

            {

                connections[TransportType.IIOP.ordinal ()] = conn_mg.getConnection(profile);

            }

            bound = true;

            /* The delegate could query the server for the object

             *  location using a GIOP locate request to make sure the

             *  first call will get through without redirections

             *  (provided the server's answer is definite):

             */

            if ( locateOnBind && !locate_on_bind_performed )

            {

                //only locate once, because bind is called from the

                //switch statement below again.

                locate_on_bind_performed = true;

                try

                {

                    LocateRequestOutputStream lros =

                        new LocateRequestOutputStream( orb,

                                                       ior.get_object_key(),

                                                       connections[currentConnection.ordinal ()].getId(),

                                                       ior.getEffectiveProfile().version().minor );

                    LocateReplyReceiver receiver = new LocateReplyReceiver();

                    receiver.configure (configuration);

                    connections[currentConnection.ordinal ()].sendRequest( lros,

                                            receiver,

                                            lros.getRequestId(),

                                            true ); //response expected

                    getParsedIOR ().markLastUsedProfile ();

                    LocateReplyInputStream lris = receiver.getReply();

                    switch ( lris.rep_hdr.locate_status.value() )

                    {

                    case LocateStatusType_1_2._UNKNOWN_OBJECT :

                        {

                            throw new org.omg.CORBA.UNKNOWN( "Could not bind to object, server does not know it!" );

                        }

                    case LocateStatusType_1_2._OBJECT_HERE :

                        {

                            break;

                        }

                    case LocateStatusType_1_2._OBJECT_FORWARD :

                        {

                            //fall through

                        }

                    case LocateStatusType_1_2._OBJECT_FORWARD_PERM :

                        {

                            //_OBJECT_FORWARD_PERM is actually more or

                            //less deprecated

                            rebind(lris.read_Object());

                            break;

                        }

                    case LocateStatusType_1_2._LOC_SYSTEM_EXCEPTION :

                        {

                            throw SystemExceptionHelper.read( lris );

                        }

                    case LocateStatusType_1_2._LOC_NEEDS_ADDRESSING_MODE :

                        {

                            throw new org.omg.CORBA.NO_IMPLEMENT( "Server responded to LocateRequest with a status of LOC_NEEDS_ADDRESSING_MODE, but this isn't yet implemented by JacORB" );

                        }

                    default :

                        {

                            throw new IllegalArgumentException( "Unknown reply status for LOCATE_REQUEST: " + lris.rep_hdr.locate_status.value() );

                        }

                    }

                }

                catch ( org.omg.CORBA.SystemException se )

                {

                    //rethrow

                    throw se;

                }

                catch ( Exception e )

                {

                    if (logger.isWarnEnabled())

                    {

                        logger.warn( e.getMessage() );

                    }

                }

            }

        }

    }

    public void rebind(org.omg.CORBA.Object obj)

    {

        String object_reference = orb.object_to_string(obj);

        if (object_reference != null && object_reference.indexOf( "IOR:" ) == 0)

        {

            Delegate delegate = (Delegate) ((ObjectImpl)obj)._get_delegate();

            rebind(new ParsedIOR( orb, object_reference),

                    ( delegate == null ? null : delegate.getClientProtocols()));

        }

        else

        {

            throw new INV_OBJREF ("Not an IOR: " + object_reference);

        }

    }

    private void rebind(ParsedIOR pior)

    {

        rebind (pior, null);

    }

    private void rebind(ParsedIOR pior, Protocol[] protocols)

    {

        synchronized ( bind_sync )

        {

            // Check if ClientProtocolPolicy set, if so, set profile

            // selector for IOR that selects effective profile for protocol.

            //

            // If rebind has been passed in a new set of protocols use that.

            if (protocols != null)

            {

                pior.setProfileSelector(new SpecificProfileSelector(protocols));

            }

            else

            {

                org.omg.RTCORBA.Protocol[] thisProtocols = getClientProtocols();

                if (thisProtocols != null)

                {

                    pior.setProfileSelector(new SpecificProfileSelector(thisProtocols));

                }

            }

            if (piorLastFailed != null && piorLastFailed.equals(pior))

            {

                //we've already failed to bind to the ior

                throw new org.omg.CORBA.TRANSIENT();

            }

            if (piorOriginal == null)

            {

                //keep original pior for fallback

                piorOriginal = _pior;

            }

            _pior = pior;

             if (connections[TransportType.IIOP.ordinal ()] != null)

             {

                 conn_mg.releaseConnection( connections[TransportType.IIOP.ordinal ()] );

                 connections[TransportType.IIOP.ordinal ()] = null;

             }

             if ( connections[TransportType.MIOP.ordinal ()] != null )