gcc/libjava/classpath/gnu/CORBA/OrbFocused.java

/* OrbFocused.java --
   Copyright (C) 2005 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package gnu.CORBA;

import gnu.CORBA.Poa.ORB_1_4;

import org.omg.CORBA.BAD_INV_ORDER;
import org.omg.CORBA.BAD_OPERATION;
import org.omg.CORBA.BAD_PARAM;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.NO_RESOURCES;
import org.omg.CORBA.portable.InvokeHandler;

import java.applet.Applet;
import java.net.ServerSocket;
import java.util.Iterator;
import java.util.Properties;
import java.util.Random;
import java.util.StringTokenizer;

/**
 * This class implements the ORB that uses a single port or the restricted port
 * range for all its objects. It is required to for use together with various
 * firewalls that does not allow opening multiple randomly selected ports, as
 * the defauld CORBA implementation used to do. The firewal must be configured
 * to allow CORBA to work on one fixed port or (for better performance) on a
 * small fixed range of ports. This does not restrict the maximal number of the
 * connected objects as the objects can share the same port.
 * 
 * The used port or the used port range can be specified via property
 * gnu.CORBA.ListenerPort. The value of this property is a single port or range
 * of ports, boundary values (inclusive) being separeted by dash (for instance,
 * "1245-1250").
 * 
 * It is possible to instantiate multiple instances of the focused ORBs and
 * combine them with the ordinary ORBs. If you instantiate several instances of
 * the focused ORBs on the same host, they used port sets should not overlap.
 * 
 * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
 */
public class OrbFocused
  extends ORB_1_4
{
  /**
   * The name of the fixed port range property. The presence of this property
   * indicates that the default focused ORB must be used.
   */
  public static final String LISTENER_PORT = "gnu.CORBA.ListenerPort";

  /**
   * The start of the range of the available ports, inclusive.
   */
  int m_ports_from = -1;

  /**
   * The end of the range of the available ports, inclusive.
   */
  int m_ports_to = -1;

  /**
   * The requests to port are served in parallel threads.
   */
  static final int PARALLEL = 0;

  /**
   * The requests to port are served in the same thread.
   */
  static final int SEQUENTIAL = 1;

  /**
   * The random number generator to get a random port in the valid range.
   */
  Random m_random = new Random();

  /**
   * Parse the "gnu.CORBA.ListenerPort" property and initialize the valid port
   * set range.
   */
  public void setPortRange(String property)
  {
    int from, to;
    try
      {
        StringTokenizer st = new StringTokenizer(property, " -");
        if (st.countTokens() == 1)
          from = to = Integer.parseInt(st.nextToken());
        else
          {
            from = Integer.parseInt(st.nextToken());
            to = Integer.parseInt(st.nextToken());
            m_random = new Random();
          }
        setPortRange(from, to);
      }
    catch (Exception ex)
      {
        throw new BAD_PARAM("Unable to parse port range '" + property + "'");
      }
  }

  /**
   * Set the port range.
   * 
   * @param from - start of the port range, inclusive.
   * @param to - end of the port range, inclusive.
   */
  public void setPortRange(int from, int to)
  {
    if (from < 0 || to < 0 || to < from)
      throw new BAD_PARAM("Invalid range");
    m_ports_from = from;
    m_ports_to = to;
  }

  /**
   * Get the port from the previously specified usage range.
   */
  int getPortFromRange(int attempt)
  {
    if (m_ports_from == m_ports_to)
      return m_ports_from;
    else if (m_ports_to - m_ports_from < RANDOM_PORT_ATTEMPTS)
      return m_ports_from + (attempt % (m_ports_to - m_ports_from + 1));
    else
      return m_random.nextInt(m_ports_to - m_ports_from + 1) + m_ports_from;
  }

  /**
   * Get the shared port server where the new object can be added. This may
   * result reusing the existing server or instantiating a new server. If the
   * new server is instantiated and the ORB is already running, the server is
   * started.
   */
  protected portServer getPortServer(int type)
  {
    portServer p;

    int n;
    if (m_ports_from < m_ports_to)
      n = RANDOM_PORT_ATTEMPTS;
    else
      n = 1;

    Ports: for (int a = 0; a < n; a++)
      {
        int port = getPortFromRange(a);
        for (int i = 0; i < portServers.size(); i++)
          {
            p = (portServer) portServers.get(i);
            if (p.s_port == port)
              {
                return (portServer) p;
              }
          }
        // The server is not yet instantiated. Instantiate.
        try
          {
            // Check if the port is ok:
            ServerSocket s = socketFactory.createServerSocket(port);
            s.close();

            portServer shared;

            switch (type)
              {
                case PARALLEL:
                  shared = new portServer(port);
                  break;

                case SEQUENTIAL:
                  shared = new sharedPortServer(port);
                  break;

                default:
                  throw new InternalError("Invalid server type " + type);
              }

            portServers.add(shared);

            if (running)
              shared.start();

            return shared;
          }
        catch (Exception ex)
          {
            // Port is taken or probably other problems.
            continue Ports;
          }
      }
    throw new NO_RESOURCES("No free port available at " + m_ports_from + "-"
      + m_ports_to, Minor.Ports, CompletionStatus.COMPLETED_NO);
  }

  /**
   * Start the ORBs main working cycle (receive invocation - invoke on the local
   * object - send response - wait for another invocation).
   * 
   * The method only returns after calling {@link #shutdown(boolean)}.
   */
  public void run()
  {
    if (m_ports_from < 0 || m_ports_to < 0)
      throw new BAD_INV_ORDER("For " + getClass().getName() + " "
        + LISTENER_PORT + " property must be set");

    running = true;

    // Start all port servers. In the current subclass, the portServers
    // collection must be already filled in.
    Iterator iter = portServers.iterator();

    while (iter.hasNext())
      {
        portServer subserver = (portServer) iter.next();

        if (!subserver.isAlive())
          {
            // Reuse the current thread for the last portServer.
            if (!iter.hasNext())
              {
                // Discard the iterator.
                iter = null;
                subserver.run();
                return;
              }
            else
              subserver.start();
          }
      }
  }

  /**
   * Get free port from the allowed range. This method instantiates the port
   * server for the returned port.
   */
  public int getFreePort()
    throws BAD_OPERATION
  {
    portServer s = getPortServer(PARALLEL);
    return s.s_port;
  }

  /**
   * Connect the given CORBA object to this ORB, explicitly specifying the
   * object key and the identity of the thread (and port), where the object must
   * be served. The identity is normally the POA.
   * 
   * The new port server will be started only if there is no one already running
   * for the same identity. Otherwise, the task of the existing port server will
   * be widened, including duty to serve the given object. All objects,
   * connected to a single identity by this method, will process they requests
   * subsequently in the same thread. The method is used when the expected
   * number of the objects is too large to have a single port and thread per
   * object. This method is used by POAs, having a single thread policy.
   * 
   * @param object the object, must implement the {@link InvokeHandler})
   * interface.
   * @param key the object key, usually used to identify the object from remote
   * side.
   * @param port the port, where the object must be connected.
   * 
   * @throws BAD_PARAM if the object does not implement the
   * {@link InvokeHandler}).
   */
  public void connect_1_thread(org.omg.CORBA.Object object, byte[] key,
    java.lang.Object identity)
  {
    sharedPortServer shared = (sharedPortServer) identities.get(identity);
    if (shared == null)
      {
        shared = (sharedPortServer) getPortServer(SEQUENTIAL);
        identities.put(identity, shared);
        if (running)
          {
            shared.start();
          }
      }

    Connected_objects.cObject ref = connected_objects.add(key, object,
      shared.s_port, identity);
    IOR ior = createIOR(ref);
    prepareObject(object, ior);
  }

  /**
   * In this type of ORB, the service is started by {@link #getPortServer}. The
   * method below is not in use and should return without action.
   */
  public void startService(IOR ior)
  {
  }

  /**
   * Set parameters (additionally search for the port range property).
   */
  protected void set_parameters(Applet applet, Properties props)
  {
    super.set_parameters(applet, props);
    String lp = applet.getParameter(LISTENER_PORT);
    if (lp != null)
      setPortRange(lp);
  }

  /**
   * Set parameters (additionally search for the port range property).
   */
  protected void set_parameters(String[] args, Properties props)
  {
    super.set_parameters(args, props);
    String lp = null;

    String lpKey = "-" + LISTENER_PORT;

    if (args != null)
      if (args.length >= 2)
        {
          for (int i = 0; i < args.length - 1; i++)
            if (args[i].equals(lpKey))
              lp = args[i + 1];
        }

    if (lp != null)
      setPortRange(lp);

  }

  /**
   * Additionally set the port range property, when applicable.
   */
  protected void useProperties(Properties props)
  {
    super.useProperties(props);
    String lp = props.getProperty(LISTENER_PORT);
    if (lp != null)
      setPortRange(lp);
  }

}