/*

 * 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

 * particular file as subject to the "Classpath" exception as provided

 *

 * 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.

 *

 */

package com.sun.corba.se.impl.oa.poa;

import java.util.Collection ;

import java.util.Set ;

import java.util.HashSet ;

import java.util.Map ;

import java.util.HashMap ;

import java.util.Iterator ;

import org.omg.CORBA.Policy ;

import org.omg.CORBA.SystemException ;

import org.omg.PortableServer.POA ;

import org.omg.PortableServer.Servant ;

import org.omg.PortableServer.POAManager ;

import org.omg.PortableServer.AdapterActivator ;

import org.omg.PortableServer.ServantManager ;

import org.omg.PortableServer.ForwardRequest ;

import org.omg.PortableServer.ThreadPolicy;

import org.omg.PortableServer.LifespanPolicy;

import org.omg.PortableServer.IdUniquenessPolicy;

import org.omg.PortableServer.IdAssignmentPolicy;

import org.omg.PortableServer.ImplicitActivationPolicy;

import org.omg.PortableServer.ServantRetentionPolicy;

import org.omg.PortableServer.RequestProcessingPolicy;

import org.omg.PortableServer.ThreadPolicyValue ;

import org.omg.PortableServer.LifespanPolicyValue ;

import org.omg.PortableServer.IdUniquenessPolicyValue ;

import org.omg.PortableServer.IdAssignmentPolicyValue ;

import org.omg.PortableServer.ImplicitActivationPolicyValue ;

import org.omg.PortableServer.ServantRetentionPolicyValue ;

import org.omg.PortableServer.RequestProcessingPolicyValue ;

import org.omg.PortableServer.POAPackage.AdapterAlreadyExists ;

import org.omg.PortableServer.POAPackage.AdapterNonExistent ;

import org.omg.PortableServer.POAPackage.InvalidPolicy ;

import org.omg.PortableServer.POAPackage.WrongPolicy ;

import org.omg.PortableServer.POAPackage.WrongAdapter ;

import org.omg.PortableServer.POAPackage.NoServant ;

import org.omg.PortableServer.POAPackage.ServantAlreadyActive ;

import org.omg.PortableServer.POAPackage.ObjectAlreadyActive ;

import org.omg.PortableServer.POAPackage.ServantNotActive ;

import org.omg.PortableServer.POAPackage.ObjectNotActive ;

import org.omg.PortableInterceptor.ObjectReferenceFactory ;

import org.omg.PortableInterceptor.ObjectReferenceTemplate ;

import org.omg.PortableInterceptor.NON_EXISTENT ;

import org.omg.IOP.TAG_INTERNET_IOP ;

import com.sun.corba.se.spi.copyobject.CopierManager ;

import com.sun.corba.se.spi.copyobject.ObjectCopier ;

import com.sun.corba.se.spi.copyobject.ObjectCopierFactory ;

import com.sun.corba.se.spi.oa.OADestroyed ;

import com.sun.corba.se.spi.oa.OAInvocationInfo ;

import com.sun.corba.se.spi.oa.ObjectAdapter ;

import com.sun.corba.se.spi.oa.ObjectAdapterBase ;

import com.sun.corba.se.spi.oa.ObjectAdapterFactory ;

import com.sun.corba.se.spi.ior.ObjectKeyTemplate ;

import com.sun.corba.se.spi.ior.ObjectId ;

import com.sun.corba.se.spi.ior.ObjectAdapterId ;

import com.sun.corba.se.spi.ior.IOR ;

import com.sun.corba.se.spi.ior.IORFactories ;

import com.sun.corba.se.spi.ior.IORTemplate ;

import com.sun.corba.se.spi.ior.IORTemplateList ;

import com.sun.corba.se.spi.ior.TaggedProfile ;

import com.sun.corba.se.spi.ior.iiop.IIOPProfile ;

import com.sun.corba.se.spi.ior.iiop.IIOPAddress ;

import com.sun.corba.se.spi.ior.iiop.IIOPFactories ;

import com.sun.corba.se.spi.orb.ORB ;

import com.sun.corba.se.spi.protocol.ForwardException ;

import com.sun.corba.se.spi.transport.SocketOrChannelAcceptor;

import com.sun.corba.se.impl.ior.POAObjectKeyTemplate ;

import com.sun.corba.se.impl.ior.ObjectAdapterIdArray ;

import com.sun.corba.se.impl.orbutil.ORBUtility;

import com.sun.corba.se.impl.orbutil.ORBConstants;

import com.sun.corba.se.impl.orbutil.concurrent.Sync ;

import com.sun.corba.se.impl.orbutil.concurrent.SyncUtil ;

import com.sun.corba.se.impl.orbutil.concurrent.ReentrantMutex ;

import com.sun.corba.se.impl.orbutil.concurrent.CondVar ;

/**

 * POAImpl is the implementation of the Portable Object Adapter. It

 * contains an implementation of the POA interfaces specified in

 * COBRA 2.3.1 chapter 11 (formal/99-10-07).  This implementation

 * is moving to comply with CORBA 3.0 due to the many clarifications

 * that have been made to the POA semantics since CORBA 2.3.1.

 * Specific comments have been added where 3.0 applies, but note that

 * we do not have the new 3.0 APIs yet.

 */

public class POAImpl extends ObjectAdapterBase implements POA

{

    private boolean debug ;

    /* POA creation takes place in 2 stages: first, the POAImpl constructor is

       called, then the initialize method is called.  This separation is

       needed because an AdapterActivator does not know the POAManager or

       the policies when

       the unknown_adapter method is invoked.  However, the POA must be created

       before the unknown_adapter method is invoked, so that the parent knows

       when concurrent attempts are made to create the same POA.

       Calling the POAImpl constructor results in a new POA in state STATE_START.

       Calling initialize( POAManager, Policies ) results in state STATE_RUN.

       Calling destroy results in STATE_DESTROY, which marks the beginning of

       POA destruction.

    */

    // Notes on concurrency.

    // The POA requires careful design for concurrency management to correctly

    // implement the specification and avoid deadlocks.  The order of acquiring

    // locks must respect the following locking hierarchy:

    //

    // 1. Lock POAs before POAManagers

    // 2. Lock a POA before locking its child POA

    //

    // Also note that there are 3 separate conditions on which threads may wait

    // in the POA, as defined by invokeCV, beingDestroyedCV, and

    // adapterActivatorCV.  This means that (for this reason as well as others)

    // we cannot simply use the standard Java synchronized primitive.

    // This implementation uses a modified version of Doug Lea's

    // util.concurrent (version 1.3.0) that supports reentrant

    // mutexes to handle the locking.  This will all be replaced by the new JSR

    // 166 concurrency primitives in J2SE 1.5 and later once the ORB moves to

    // J2SE 1.5.

    // POA state constants

    //

    // Note that ordering is important here: we must have the state defined in

    // this order so that ordered comparison is possible.

    // DO NOT CHANGE THE VALUES OF THE STATE CONSTANTS!!!  In particular, the

    // initialization related states must be lower than STATE_RUN.

    //

    // POA is created in STATE_START

    //

    // Valid state transitions:

    //

    // START to INIT                        after find_POA constructor call

    // START to RUN                         after initialize completes

    // INIT to INIT_DONE                    after initialize completes

    // INIT to DESTROYED                    after failed unknown_adapter

    // INIT_DONE to RUN                     after successful unknown_adapter

    // STATE_RUN to STATE_DESTROYING        after start of destruction

    // STATE_DESTROYING to STATE_DESTROYED  after destruction completes.

    private static final int STATE_START        = 0 ; // constructor complete

    private static final int STATE_INIT         = 1 ; // waiting for adapter activator

    private static final int STATE_INIT_DONE    = 2 ; // adapter activator called create_POA

    private static final int STATE_RUN          = 3 ; // initialized and running

    private static final int STATE_DESTROYING   = 4 ; // being destroyed

    private static final int STATE_DESTROYED    = 5 ; // destruction complete

    private String stateToString()

    {

        switch (state) {

            case STATE_START :

                return "START" ;

            case STATE_INIT :

                return "INIT" ;

            case STATE_INIT_DONE :

                return "INIT_DONE" ;

            case STATE_RUN :

                return "RUN" ;

            case STATE_DESTROYING :

                return "DESTROYING" ;

            case STATE_DESTROYED :

                return "DESTROYED" ;

            default :

                return "UNKNOWN(" + state + ")" ;

        }

    }

    // Current state of the POA

    private int state ;

    // The POA request handler that performs all policy specific operations

    // Note that POAImpl handles all synchronization, so mediator is (mostly)

    // unsynchronized.

    private POAPolicyMediator mediator;

    // Representation of object adapter ID

    private int numLevels;          // counts depth of tree.  Root = 1.

    private ObjectAdapterId poaId ; // the actual object adapter ID for this POA

    private String name;            // the name of this POA

    private POAManagerImpl manager; // This POA's POAManager

    private int uniquePOAId ;       // ID for this POA that is unique relative

                                    // to the POAFactory, which has the same

                                    // lifetime as the ORB.

    private POAImpl parent;         // The POA that created this POA.

    private Map children;           // Map from name to POA of POAs created by

                                    // this POA.

    private AdapterActivator activator;

    private int invocationCount ; // pending invocations on this POA.

    // Data used to control POA concurrency

    // XXX revisit for JSR 166

    // Master lock for all POA synchronization.  See lock and unlock.

    // package private for access by AOMEntry.

    Sync poaMutex ;

    // Wait on this CV for AdapterActivator upcalls to complete

    private CondVar adapterActivatorCV ;

    // Wait on this CV for all active invocations to complete

    private CondVar invokeCV ;

    // Wait on this CV for the destroy method to complete doing its work

    private CondVar beingDestroyedCV ;

    // thread local variable to store a boolean to detect deadlock in

    // POA.destroy().

    protected ThreadLocal isDestroying ;

    // This includes the most important information for debugging

    // POA problems.

    public String toString()

    {

        return "POA[" + poaId.toString() +

            ", uniquePOAId=" + uniquePOAId +

            ", state=" + stateToString() +

            ", invocationCount=" + invocationCount + "]" ;

    }

    // package private for mediator implementations.

    boolean getDebug()

    {

        return debug ;

    }

    // package private for access to servant to POA map

    static POAFactory getPOAFactory( ORB orb )

    {

        return (POAFactory)orb.getRequestDispatcherRegistry().

            getObjectAdapterFactory( ORBConstants.TRANSIENT_SCID ) ;

    }

    // package private so that POAFactory can access it.

    static POAImpl makeRootPOA( ORB orb )

    {

        POAManagerImpl poaManager = new POAManagerImpl( getPOAFactory( orb ),

            orb.getPIHandler() ) ;

        POAImpl result = new POAImpl( ORBConstants.ROOT_POA_NAME,

            null, orb, STATE_START ) ;

        result.initialize( poaManager, Policies.rootPOAPolicies ) ;

        return result ;

    }

    // package private so that POAPolicyMediatorBase can access it.

    int getPOAId()

    {

        return uniquePOAId ;

    }

    // package private so that POAPolicyMediator can access it.

    void lock()

    {

        SyncUtil.acquire( poaMutex ) ;

        if (debug) {

            ORBUtility.dprint( this, "LOCKED poa " + this ) ;

        }

    }

    // package private so that POAPolicyMediator can access it.

    void unlock()

    {

        if (debug) {

            ORBUtility.dprint( this, "UNLOCKED poa " + this ) ;

        }

        poaMutex.release() ;

    }

    // package private so that DelegateImpl can access it.

    Policies getPolicies()

    {

        return mediator.getPolicies() ;

    }

    // Note that the parent POA must be locked when this constructor is called.

    private POAImpl( String name, POAImpl parent, ORB orb, int initialState )

    {

        super( orb ) ;

        debug = orb.poaDebugFlag ;

        if (debug) {

            ORBUtility.dprint( this, "Creating POA with name=" + name +

                " parent=" + parent ) ;

        }

        this.state     = initialState ;

        this.name      = name ;

        this.parent    = parent;

        children = new HashMap();

        activator = null ;

        // This was done in initialize, but I moved it here

        // to get better searchability when tracing.

        uniquePOAId = getPOAFactory( orb ).newPOAId() ;

        if (parent == null) {

            // This is the root POA, which counts as 1 level

            numLevels = 1 ;

        } else {

            // My level is one more than that of my parent

            numLevels = parent.numLevels + 1 ;

            parent.children.put(name, this);

        }

        // Get an array of all of the POA names in order to

        // create the poaid.

        String[] names = new String[ numLevels ] ;

        POAImpl poaImpl = this ;

        int ctr = numLevels - 1 ;

        while (poaImpl != null) {

            names[ctr--] = poaImpl.name ;

            poaImpl = poaImpl.parent ;

        }

        poaId = new ObjectAdapterIdArray( names ) ;

        invocationCount = 0;

        poaMutex = new ReentrantMutex( orb.poaConcurrencyDebugFlag ) ;

        adapterActivatorCV = new CondVar( poaMutex,

            orb.poaConcurrencyDebugFlag ) ;

        invokeCV           = new CondVar( poaMutex,

            orb.poaConcurrencyDebugFlag ) ;

        beingDestroyedCV   = new CondVar( poaMutex,

            orb.poaConcurrencyDebugFlag ) ;

        isDestroying = new ThreadLocal () {

            protected java.lang.Object initialValue() {

                return Boolean.FALSE;

            }

        };

    }

    // The POA lock must be held when this method is called.

    private void initialize( POAManagerImpl manager, Policies policies )

    {

        if (debug) {

            ORBUtility.dprint( this, "Initializing poa " + this +

                " with POAManager=" + manager + " policies=" + policies ) ;

        }

        this.manager = manager;

        manager.addPOA(this);

        mediator = POAPolicyMediatorFactory.create( policies, this ) ;

        // Construct the object key template

        int serverid = mediator.getServerId() ;

        int scid = mediator.getScid() ;

        String orbId = getORB().getORBData().getORBId();

        ObjectKeyTemplate oktemp = new POAObjectKeyTemplate( getORB(),

            scid, serverid, orbId, poaId ) ;

        if (debug) {

            ORBUtility.dprint( this, "Initializing poa: oktemp=" + oktemp ) ;

        }

        // Note that parent == null iff this is the root POA.

        // This was used to avoid executing interceptors on the RootPOA.

        // That is no longer necessary.

        boolean objectAdapterCreated = true; // parent != null ;

        // XXX extract codebase from policies and pass into initializeTemplate

        // after the codebase policy change is finalized.

        initializeTemplate( oktemp, objectAdapterCreated,

                            policies,

                            null, // codebase

                            null, // manager id

                            oktemp.getObjectAdapterId()

                            ) ;

        if (state == STATE_START)

            state = STATE_RUN ;

        else if (state == STATE_INIT)

            state = STATE_INIT_DONE ;

        else

            throw lifecycleWrapper().illegalPoaStateTrans() ;

    }

    // The poaMutex must be held when this method is called

    private boolean waitUntilRunning()

    {

        if (debug) {

            ORBUtility.dprint( this,

                "Calling waitUntilRunning on poa " + this ) ;

        }

        while (state < STATE_RUN) {

            try {

                adapterActivatorCV.await() ;

            } catch (InterruptedException exc) {

                // NO-OP

            }

        }

        if (debug) {

            ORBUtility.dprint( this,

                "Exiting waitUntilRunning on poa " + this ) ;

        }

        // Note that a POA could be destroyed while in STATE_INIT due to a

        // failure in the AdapterActivator upcall.

        return (state == STATE_RUN) ;

    }

    // This method checks that the AdapterActivator finished the

    // initialization of a POA activated in find_POA.  This is

    // determined by checking the state of the POA.  If the state is

    // STATE_INIT, the AdapterActivator did not complete the

    // inialization.  In this case, we destroy the POA that was

    // partially created and return false.  Otherwise, we return true.

    // In any case, we must wake up all threads waiting for the adapter

    // activator, either to continue their invocations, or to return

    // errors to their client.

    //

    // The poaMutex must NOT be held when this method is called.

    private boolean destroyIfNotInitDone()

    {

        try {

            lock() ;

            if (debug) {

                ORBUtility.dprint( this,

                    "Calling destroyIfNotInitDone on poa " + this ) ;

            }

            boolean success = (state == STATE_INIT_DONE) ;

            if (success)

                state = STATE_RUN ;

            else {

                // Don't just use destroy, because the check for

                // deadlock is too general, and can prevent this from

                // functioning properly.

                DestroyThread destroyer = new DestroyThread( false, debug );

                destroyer.doIt( this, true ) ;

            }

            return success ;

        } finally {

            adapterActivatorCV.broadcast() ;

            if (debug) {

                ORBUtility.dprint( this,

                    "Exiting destroyIfNotInitDone on poa " + this ) ;

            }

            unlock() ;

        }

    }

    private byte[] internalReferenceToId(

        org.omg.CORBA.Object reference ) throws WrongAdapter

    {

        IOR ior = ORBUtility.getIOR( reference ) ;

        IORTemplateList thisTemplate = ior.getIORTemplates() ;

        ObjectReferenceFactory orf = getCurrentFactory() ;

        IORTemplateList poaTemplate =

            IORFactories.getIORTemplateList( orf ) ;

        if (!poaTemplate.isEquivalent( thisTemplate ))

            throw new WrongAdapter();

        // Extract the ObjectId from the first TaggedProfile in the IOR.

        // If ior was created in this POA, the same ID was used for

        // every profile through the profile templates in the currentFactory,

        // so we will get the same result from any profile.

        Iterator iter = ior.iterator() ;

        if (!iter.hasNext())

            throw iorWrapper().noProfilesInIor() ;

        TaggedProfile prof = (TaggedProfile)(iter.next()) ;

        ObjectId oid = prof.getObjectId() ;

        return oid.getId();

    }

    // Converted from anonymous class to local class

    // so that we can call performDestroy() directly.

    static class DestroyThread extends Thread {

        private boolean wait ;

        private boolean etherealize ;

        private boolean debug ;

        private POAImpl thePoa ;

        public DestroyThread( boolean etherealize, boolean debug )

        {

            this.etherealize = etherealize ;

            this.debug = debug ;