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

*/

* @author Gerald Brose, FU Berlin

*/

    extends ORBSingleton

    implements org.jacorb.poa.POAListener, Configurable

    private static final String nullIORString =

        "IOR:00000000000000010000000000000000";

    private final static String[] services = new String[] {"RootPOA", "POACurrent", "DynAnyFactory", "PICurrent", "CodecFactory", "RTORB",};

    // configuration properties

    private boolean cacheReferences;

    private String implName;

    private int giopMinorVersion;

    private boolean giopAdd_1_0_Profiles;

    private String hashTableClassName;

    private boolean useIMR = false;

    private boolean useTaoIMR = false;

    private boolean useSelectorManager;

    private ProtocolAddressBase imrProxyAddress = null;

    private ProtocolAddressBase iorProxyAddress;

    /**

     *  "initial" references

     */

    private final Map<String, org.omg.CORBA.Object> initial_references = new HashMap<String, org.omg.CORBA.Object>();

    private POA rootpoa;

    private org.jacorb.poa.Current poaCurrent;

    private BasicAdapter basicAdapter;

    /** interceptor handling */

    private InterceptorManager interceptor_manager = null;

    private boolean hasClientInterceptors = false;

    private boolean hasServerInterceptors = false;

    private final org.omg.PortableInterceptor.Current piCurrent = new PICurrent();

    /** reference caching */

    private Map<String, ObjectImpl> knownReferences = null;

    /** connection mgmt. */

    private ClientConnectionManager clientConnectionManager;

    /** The transport manager*/

    private TransportManager transport_manager = null;

    private GIOPConnectionManager giop_connection_manager = null;

    /**

     * The timer queue is a single thread along with a time-sorted list of

     * event handlers. When the timer fires, either a notification is sent

     * to an object to wake other threads, or a _simple_ action is performed.

     * Since the timer queue instance requires a thread, it is only created

     * when first asked for. the queue is internally synchronized.

     *

     * The timer queue is a wrapper around the selector manager

     */

    private TimerQueue timer_queue = null;

    /**

       The selectorManager is a wrappper around the NIO Selector

     */

    private SelectorManager selectorManager = null;

    /**

     * Maps repository ids (strings) to objects that implement

     * org.omg.CORBA.portable.ValueFactory.  This map is used by

     * register/unregister_value_factory() and lookup_value_factory().

     */

    private final Map<String, ValueFactory> valueFactories = new HashMap<String, ValueFactory>();

    /**

     * Maps repository ids (strings) of boxed value types to

     * BoxedValueHelper instances for those types.

     */

    private final Map<String, BoxedValueHelper> boxedValueHelpers = new HashMap<String, BoxedValueHelper>();

    private final ObjectKeyMap objectKeyMap = new ObjectKeyMap(this);

    /** command like args */

    private String[] arguments;

    /* for run() and shutdown()  */

    private final Object runSync = new Object();

    private boolean run = true;

    private boolean shutdown_in_progress = false;

    private boolean destroyed = false;

    private final Object shutdown_synch = new Object();

    /**

     *  for registering POAs with the ImR

     */

    private ImRAccess imr = null;

    private int persistentPOACount;

    private String orb_id = Version.orbId;

    /**

     * outstanding dii requests awaiting completion

     */

    private final Set<org.omg.CORBA.Request> requests = Collections.synchronizedSet( new HashSet<org.omg.CORBA.Request>() );

    /**

     * most recently completed dii request found during poll

     */

    private Request request = null;

    private RTORB rtORB;

    /* PolicyManagement */

    private org.jacorb.orb.policies.PolicyManager policyManager;

    /* policy factories, from portable interceptor spec */

    private final Map<Integer, PolicyFactory> policy_factories = Collections.synchronizedMap(new HashMap<Integer, PolicyFactory>());

    private boolean bidir_giop = false;

    /**

     * <code>serverIdStr</code> is a unique ID that will be used to identify this

     * server.

     */

    private final String serverIdStr = String.valueOf((long)(Math.random()*9999999999L));

    /**

     * <code>serverId</code> is the bytes form of serverIdStr.

     */

    private final byte[] serverId = serverIdStr.getBytes();

    private RPPoolManagerFactory poolManagerFactory;

    private boolean failOnORBInitializerError;

    private boolean inORBInitializer;

    /**

     * 4.5.3.3

     *

     * The ORB default initial reference argument, -ORBDefaultInitRef, assists in

     * resolution of initial references not explicitly specified with -ORBInitRef.

     * -ORBDefaultInitRef requires a URL that, after appending a slash ‘/’ character and a

     * stringified object key, forms a new URL to identify an initial object reference.

     */

    private String defaultInitRef;

    /**

     * Indicates that the root POA manager was not yet activated.

     */

    private boolean firstConnection = true;

    /**

     * Associates connected objects to their servants. The servant associated

     * with a connected object is retrieved from this map when disconnect is

     * called on the object.

     */

    private Map connectedObjects = new HashMap();

    public ORB()

    {

        super(false);

    }

    /**

     * configure the ORB

     */

    @Override

    public void configure(Configuration config) throws ConfigurationException

    {

        super.configure(config);

        cacheReferences =

            configuration.getAttributeAsBoolean("jacorb.reference_caching", false);

        implName =

            configuration.getAttribute("jacorb.implname", "" );

        giopMinorVersion =

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

        giopAdd_1_0_Profiles =

            configuration.getAttributeAsBoolean("jacorb.giop.add_1_0_profiles", false);

        hashTableClassName =

            configuration.getAttribute( "jacorb.hashtable_class", HashMap.class.getName());

        useIMR =

            configuration.getAttributeAsBoolean("jacorb.use_imr", false);

        useTaoIMR =

            configuration.getAttributeAsBoolean("jacorb.use_tao_imr", false);

        if (useTaoIMR && useIMR)

        {

            throw new ConfigurationException ("Ambiguous ImR property settings: jacorb.use_tao_imr and jacorb.use_imr are both true");

        }

        String host =

            configuration.getAttribute("jacorb.imr.ior_proxy_host", null);

        int port =

            configuration.getAttributeAsInteger("jacorb.imr.ior_proxy_port", -1);

        String address =

            configuration.getAttribute("jacorb.imr.ior_proxy_address", null);

        imrProxyAddress = createAddress(host, port, address);

        if (useTaoIMR && imrProxyAddress  != null)

        {

            // ignore IMR proxy setting when TAO ImR is used

            imrProxyAddress = null;

        }

        host =

            configuration.getAttribute("jacorb.ior_proxy_host", null);

        port =

            configuration.getAttributeAsInteger("jacorb.ior_proxy_port", -1);

        address =

            configuration.getAttribute("jacorb.ior_proxy_address", null);

        iorProxyAddress = createAddress(host, port, address);

        if (useTaoIMR && iorProxyAddress  != null)

        {

            // ignore IOR proxy setting when TAO ImR is used

            iorProxyAddress = null;

        }

        failOnORBInitializerError = configuration.getAttributeAsBoolean("jacorb.orb_initializer.fail_on_error", false);

        boolean useTimerQueue = configuration.getAttributeAsBoolean("jacorb.use_timer_queue", false);

        // There are features that if enabled require the use of the timer queue

        // and thus need to ensure the timer queue is available.

        if (!useTimerQueue)

        {

            useTimerQueue =

                configuration.getAttributeAsInteger("jacorb.connection.request.write_timeout", 0) > 0 ||

                configuration.getAttributeAsInteger("jacorb.connection.reply.write_timeout", 0) > 0;

        }

        useSelectorManager = useTimerQueue ||

            configuration.getAttributeAsBoolean("jacorb.connection.nonblocking", false);

        boolean cacheTypeCodes = configuration.getAttributeAsBoolean("jacorb.cacheTypecodes", false);

        if (cacheTypeCodes)

        {

            typeCodeCache = (TypeCodeCache) configuration.getAttributeAsObject("jacorb.cacheTypecodes.class", "org.jacorb.orb.typecode.TypeCodeCacheImpl");

            if ( logger.isDebugEnabled() )

            {

                logger.debug("enabled TypeCodeCache: "  + typeCodeCache.getClass().getName());

            }

        }

        else

        {

            typeCodeCache = NullTypeCodeCache.getInstance();

        }

        boolean compactTypeCodes = configuration.getAttributeAsBoolean("jacorb.compactTypecodes", false);

        if (compactTypeCodes)

        {

            typeCodeCompactor = (TypeCodeCompactor) configuration.getAttributeAsObject("jacorb.compactTypecodes.class", "org.jacorb.orb.typecode.TypeCodeCompactorImpl");

            if ( logger.isDebugEnabled() )

            {

                logger.debug("enabled TypeCodeCompactor: " + typeCodeCompactor.getClass().getName());

            }

        }

        else

        {

            typeCodeCompactor = NullTypeCodeCompactor.getInstance();

        }

        printVersion(configuration);

        configureObjectKeyMap(configuration);

        if (poolManagerFactory != null)

        {

            // currently the ORB is only re-configured during

            // test runs. in this case an existing the poolManagerFactory

            // should be shut down properly to give its threads the

            // change to exit.

            // doesn't work this way as configure is invoked during

            // a request. causes the test to hang (alphonse)

            //poolManagerFactory.destroy();

        }

        poolManagerFactory = new RPPoolManagerFactory(this);

    }

    /**

     * create an address based on addressString OR (host AND port)

     * it neither addressString NOR (host AND port) are specified this method

     * will return null.

     */

    private ProtocolAddressBase createAddress(String host, int port, String addressString)

    {

        final ProtocolAddressBase address;

        try

        {

            if (addressString == null)

            {

                if (host != null || port != -1)

                {

                    address = new IIOPAddress ();

                    address.configure(configuration);

                    if (host != null)

                    {

                        ((IIOPAddress)address).setHostname(host);

                    }

                    if (port != -1)

                    {

                        ((IIOPAddress)address).setPort(port);

                    }

                }

                else

                {

                    address = null;

                }

            }

            else

            {

                address = createAddress(addressString);

            }

        }

        catch (Exception ex)

        {

            logger.error ("error initializing ProxyAddress", ex);

            throw new INITIALIZE(ex.toString());

        }

        return address;

    }

    private void printVersion(org.jacorb.config.Configuration configuration)

    {

        final boolean printVersion =

            configuration.getAttributeAsBoolean("jacorb.orb.print_version", false);

        if (!printVersion)

        {

            return;

        }

        Logger versionLogger = configuration.getLogger("org.jacorb.orb.print_version");

        versionLogger.info

        (

            System.getProperty("line.separator") +

            "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" +

            System.getProperty("line.separator") +

            Version.versionInfo +

            System.getProperty("line.separator") +

            "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"

        );

    }

    /**

     * Overrides id() in org.omg.CORBA_2_5.ORB

     */

    @Override

    public String id()

    {

        return orb_id;

    }

    public boolean useBiDirGIOP()

    {

        return bidir_giop;

    }

    public void turnOnBiDirGIOP()

    {

        if ( ! bidir_giop )

        {

            bidir_giop = true;

            clientConnectionManager.setRequestListener( basicAdapter.getRequestListener() );

        }

    }

    private ProtocolAddressBase createAddress (String address)

    {

        List<Factories> factorylist = getTransportManager().getFactoriesList();

        ProtocolAddressBase result = null;

        for (Iterator<Factories> i = factorylist.iterator();

                i.hasNext() && result == null;)

        {

            FactoriesBase f = (FactoriesBase)i.next();

            result = f.create_protocol_address(address);

        }

        return result;

    }

    /**

     * This method is used for references that have

     * arrived over the network and is called from CDRInputStream. It

     * does not cache entries as we are delaying creating a ParsedIOR.

     *

     * @param ior an <code>org.omg.IOP.IOR</code>, the IOR.

     * @return an <code>org.omg.CORBA.Object</code> the Object to use.

     */

    public org.omg.CORBA.Object _getObject(org.omg.IOP.IOR ior)

    {

        final org.jacorb.orb.Delegate delegate = new Delegate(this, ior, true);

        return delegate.getReference( null );

    }