src/org/objectweb/cjdbc/controller/core/ControllerServerThread.java

説明を見る。

package org.objectweb.cjdbc.controller.core;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

import javax.net.ServerSocketFactory;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.net.SSLException;
import org.objectweb.cjdbc.common.net.SocketFactoryFactory;
import org.objectweb.cjdbc.common.stream.CJDBCOutputStream;

public class ControllerServerThread extends Thread
{
  private ServerSocket                   serverSocket;
  private static final SecurityException BLOCKED                            = new SecurityException(
                                                                                Translate
                                                                                    .get("controller.server.thread.security.connection.refused"));
  private boolean                        isKilled                           = false;
  private boolean                        isShuttingDown                     = false;
  protected Controller                   controller;
  protected ArrayList                    controllerServerThreadPendingQueue = new ArrayList();
  protected int                          idleWorkerThreads                  = 0;

  static Trace                           logger                             = Trace
                                                                                .getLogger("org.objectweb.cjdbc.controller.core.Controller");

  public ControllerServerThread(Controller controller)
  {
    super("ControllerServerThread");
    this.controller = controller;

    try
    {

      InetAddress bindAddress = InetAddress
          .getByName(controller.getIPAddress());

      // Determine if a specific IP address has been requested.
      if (!controller.getIPAddress().equals(ControllerConstants.DEFAULT_IP))
      {

        // Yes, an IP has been specified that is not localhost...

        // Build an InetAddress by passing the requested IP address to the
        // InetAddress class constructor. This will validate the sanity of the
        // IP by either accepting the requested value or throwing a
        // BindException.
        if (controller.isSecurityEnabled()
            && controller.getSecurity().isSSLEnabled())
        {
          ServerSocketFactory sslFact = SocketFactoryFactory
              .createServerFactory(controller.getSecurity().getSslConfig());
          serverSocket = sslFact.createServerSocket(controller.getPortNumber(),
              controller.getBacklogSize(), bindAddress);
        }
        else
        {
          serverSocket = new ServerSocket(controller.getPortNumber(),
              controller.getBacklogSize(), bindAddress);
        }
      }
      else
      {

        // No, an IP was not requested or was left as the default. Create a
        // basic local socket.

        if (controller.isSecurityEnabled()
            && controller.getSecurity().isSSLEnabled())
        {
          ServerSocketFactory sslFact = SocketFactoryFactory
              .createServerFactory(controller.getSecurity().getSslConfig());
          serverSocket = sslFact.createServerSocket(controller.getPortNumber(),
              controller.getBacklogSize());
        }
        else
        {
          serverSocket = new ServerSocket(controller.getPortNumber(),
              controller.getBacklogSize());
        }
      }

    }
    catch (java.net.BindException e)
    {

      // Thrown if an illegal IP address was specified.
      logger.fatal(Translate.get("controller.server.thread.illegal.ip",
          new String[]{controller.getIPAddress(), e.getMessage()}));
      controller.endOfController(e);
    }
    catch (IOException e)
    {
      logger.fatal(Translate.get("controller.server.thread.socket.failed",
          controller.getPortNumber() + ""));
      controller.endOfController(e);
    }
    catch (SSLException e)
    {
      logger.fatal(Translate.get("controller.server.thread.socket.failed",
          controller.getPortNumber() + ""));
      controller.endOfController(e);
    }
    if (logger.isInfoEnabled())
    {
      logger.info(Translate.get("controller.server.thread.waiting.connections",
          new String[]{serverSocket.getInetAddress().getHostAddress(),
              String.valueOf(serverSocket.getLocalPort())}));
      logger.debug(Translate.get("controller.server.thread.backlog.size", ""
          + controller.getBacklogSize()));
    }
  }

  public void run()
  {
    if (controller == null)
    {
      logger.error(Translate.get("controller.server.thread.controller.null"));
      isKilled = true;
    }

    Socket clientSocket = null;
    while (!isKilled && !isShuttingDown)
    {
      try
      {
        // Accept a connection
        clientSocket = serverSocket.accept();
        if (isKilled || isShuttingDown)
          break;
        if (controller.isSecurityEnabled()
            && !controller.getSecurity().allowConnection(clientSocket))
        {
          logger.warn(Translate.get(
              "controller.server.thread.connection.refused", clientSocket
                  .getInetAddress().getHostName()));
          CJDBCOutputStream out = new CJDBCOutputStream(clientSocket);
          out.writeObject(BLOCKED);
          out.flush();
          clientSocket = null;
          continue;
        }
        else
        {
          if (logger.isDebugEnabled())
            logger.debug(Translate.get(
                "controller.server.thread.connection.accept", clientSocket
                    .getInetAddress().getHostName()));
        }
        boolean createThread = false;
        if (isKilled || isShuttingDown)
          break;
        synchronized (controllerServerThreadPendingQueue)
        {
          // Add the connection to the queue
          controllerServerThreadPendingQueue.add(clientSocket);
          // Check if we need to create a new thread or just wake up an
          // existing one
          if (idleWorkerThreads == 0)
            createThread = true;
          else
            // Here we notify all threads else if one thread doesn't wake up
            // after the first notify() we will send a second notify() and
            // one signal will be lost. So the safe way is to wake up everybody
            // and that worker threads go back to sleep if there is no job.
            controllerServerThreadPendingQueue.notifyAll();
        }
        if (createThread)
        { // Start a new worker thread if needed
          ControllerWorkerThread thread = new ControllerWorkerThread(this);
          thread.start();
          if (logger.isDebugEnabled())
            logger.debug(Translate.get("controller.server.thread.starting"));
        }
      }
      catch (IOException e)
      {
        if (!isShuttingDown)
        {
          logger.warn(Translate.get(
              "controller.server.thread.new.connection.error", e),e);
        }
      }
    }
    if (logger.isInfoEnabled())
      logger.info(Translate.get("controller.server.thread.terminating"));
  }

  public void shutdown()
  {
    isShuttingDown = true;
    // Shutting down server thread
    try
    {
      serverSocket.close();
    }
    catch (Exception e)
    {
      logger.warn(Translate.get("controller.shutdown.server.socket.exception"),
          e);
    }
    int nbSockets = controllerServerThreadPendingQueue.size();
    Socket socket = null;
    for (int i = 0; i < nbSockets; i++)
    {
      socket = (Socket) controllerServerThreadPendingQueue.get(i);
      logger.info(Translate.get("controller.shutdown.client.socket", socket
          .getInetAddress().toString()));
      //      try
      //      {
      //        // This is not a key part of shutting down. We don't want to accept any
      //        // connection and we are blocking connections that have not started
      //        // transactions
      //        CJDBCOutputStream out = new
      // CJDBCOutputStream(socket.getOutputStream());
      //        out.writeObject(new SQLException(Translate
      //            .get("controller.shutdown.server.is.shutting.down")));
      //        out.flush();
      //        socket.shutdownInput();
      //        socket.shutdownOutput();
      //        socket.close();
      //      }
      //      catch (Exception e)
      //      {
      //        // logger.warn(Translate
      //        // .get("controller.shutdown.server.socket.exception"), e);
      //      }
    }
    this.controllerServerThreadPendingQueue = null;
  }

  public int getControllerServerThreadPendingQueueSize()
  {
    synchronized (controllerServerThreadPendingQueue)
    {
      return controllerServerThreadPendingQueue.size();
    }
  }

  public int getIdleWorkerThreads()
  {
    synchronized (controllerServerThreadPendingQueue)
    {
      return idleWorkerThreads;
    }
  }

  public boolean isShuttingDown()
  {
    return isShuttingDown;
  }
}

---