src/org/objectweb/cjdbc/controller/core/shutdown/VirtualDatabaseShutdownThread.java

説明を見る。

package org.objectweb.cjdbc.controller.core.shutdown;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;

import org.objectweb.cjdbc.common.exceptions.ShutdownException;
import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.controller.backend.DatabaseBackend;
import org.objectweb.cjdbc.controller.virtualdatabase.DistributedVirtualDatabase;
import org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase;
import org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabaseWorkerThread;

public class VirtualDatabaseShutdownThread extends ShutdownThread
{
  VirtualDatabase database;
  int             shutdownLevel;

  public VirtualDatabaseShutdownThread(VirtualDatabase db, int ilevel)
  {
    super(ilevel, ShutdownThread.DATABASE, db.getName());
    this.database = db;
    shutdownLevel = ilevel;
  }

  public void shutdownFast() throws ShutdownException
  {
    terminateClients();
    closeVirtualDatabase();
    shutdownBackends("Fast Shutdown " + new Date());
  }

  public void shutdownImmediate() throws ShutdownException
  {
    closeVirtualDatabase();
  }

  public void shutdownSmart() throws ShutdownException
  {
    closeVirtualDatabase();
    waitForDisconnectClients();
    shutdownBackends("Smart Shutdown " + new Date());
  }

  private void terminateClients()
  {
    logger.info("Shutting down clients");
    ArrayList threads = database.getActiveThreads();
    logger.info(Translate.get("controller.shutdown.active.threads", ""
        + threads.size()));
    VirtualDatabaseWorkerThread wt;
    synchronized (threads)
    {
      for (int i = 0; i < threads.size(); i++)
      {
        logger.info(Translate.get("controller.shutdown.database.thread",
            new String[]{database.getName(), "" + i}));
        wt = ((VirtualDatabaseWorkerThread) threads.get(i));
        wt.shutdown();
      }
    }
    database.getActiveThreads().clear();
  }

  private void closeVirtualDatabase()
  {
    if (database.isDistributed())
    {
      logger.info("Shutting down group communication");
      ((DistributedVirtualDatabase) database).quitChannel();
    }
  }

  private void waitForDisconnectClients()
  {
    boolean wait = true;
    while (wait)
    {
      ArrayList threads = database.getActiveThreads();
      synchronized (threads)
      {
        int nbThreads = threads.size();
        logger.debug(Translate.get("controller.shutdown.active.threads", ""
            + nbThreads));
        if (nbThreads == 0)
        {
          wait = false;
        }
      }
      if (wait)
      {
        synchronized (this)
        {
          try
          {
            wait(1000);
          }
          catch (InterruptedException e)
          {
            // Ignore
          }
        }
      }
    }
  }

  private void shutdownBackends(String checkpoint)
  {
    if (database.getRequestManager().getRecoveryLog() != null)
    {
      try
      {
        // disable and checkpoint for recovery log
        database.storeBackendsInfo();
        database.disableAllBackendForCheckpoint(checkpoint);
        
      }
      catch (Exception ve)
      {
        logger.error(Translate
            .get("controller.shutdown.backends.exception", ve));
      }
    }
    else
    {
      // no recovery log, so just disable backends
      try
      {
        database.disableAllBackend();
      }
      catch (Exception vde)
      {
        logger.error(Translate.get("controller.shutdown.backends.exception",
            vde));
      }
    }

    ArrayList backends = database.getBackends();
    int size = backends.size();
    DatabaseBackend backend;
    for (int i = 0; i < size; i++)
    {
      backend = (DatabaseBackend) backends.get(i);
      try
      {
        backend.finalizeConnections();
      }
      catch (SQLException e)
      {
        logger
            .error(Translate.get("controller.shutdown.backends.exception", e));
      }
    }
  }

}

---