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

説明を見る。

package org.objectweb.cjdbc.controller.core;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Locale;
import java.util.ResourceBundle;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.objectweb.cjdbc.common.exceptions.ControllerException;
import org.objectweb.cjdbc.common.exceptions.ExceptionTypes;
import org.objectweb.cjdbc.common.exceptions.VirtualDatabaseException;
import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.jmx.JmxConstants;
import org.objectweb.cjdbc.common.jmx.JmxException;
import org.objectweb.cjdbc.common.jmx.mbeans.ControllerMBean;
import org.objectweb.cjdbc.common.jmx.notifications.CjdbcNotificationList;
import org.objectweb.cjdbc.common.log.LogManager;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.util.Constants;
import org.objectweb.cjdbc.common.util.ZipMe;
import org.objectweb.cjdbc.common.xml.ControllerXmlTags;
import org.objectweb.cjdbc.common.xml.XmlComponent;
import org.objectweb.cjdbc.controller.core.security.ControllerSecurityManager;
import org.objectweb.cjdbc.controller.core.shutdown.ControllerShutdownThread;
import org.objectweb.cjdbc.controller.jmx.AbstractStandardMBean;
import org.objectweb.cjdbc.controller.jmx.MBeanServerManager;
import org.objectweb.cjdbc.controller.jmx.RmiConnector;
import org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase;
import org.objectweb.cjdbc.controller.xml.DatabasesParser;

public class Controller extends AbstractStandardMBean
    implements
      ControllerMBean,
      XmlComponent
{

  private int                       portNumber;
  private int                       backlogSize;

  private String                    ipAddress;

  private ControllerServerThread    connectionThread;

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

  private Hashtable                 virtualDatabases;

  private Hashtable                 configuration;

  private ControllerSecurityManager security;

  private ReportManager             report;

  private TransformerFactory        tFactory;
  private Transformer               infoTransformer;
  private boolean                   isShuttingDown;

  /* Constructor(s) */

  public Controller(String ipAddress, int port, int backlog)
      throws NotCompliantMBeanException, JmxException
  {
    super(ControllerMBean.class);
    virtualDatabases = new Hashtable();
    this.ipAddress = ipAddress;
    this.portNumber = port;
    this.backlogSize = backlog;
    ObjectName name = JmxConstants.getControllerObjectName();
    MBeanServerManager.registerMBean(this, name);
  }

  public String getAssociatedString()
  {
    return "controller";
  }

  /* Virtual databases management */

  public void addVirtualDatabases(String xml, String virtualName,
      int autoLoad, String checkPoint) throws ControllerException
  {
    if (logger.isDebugEnabled())
      logger
          .debug(Translate.get("controller.add.virtualdatabase", virtualName));
    if (virtualName != null && this.hasVirtualDatabase(virtualName))
    {
      throw new ControllerException(Translate
          .get("controller.add.virtualdatabase.already.used"));
    }
    try
    {
      DatabasesParser parser = new DatabasesParser(this, virtualName,
          autoLoad, checkPoint);
      parser.readXML(xml, true);
    }
    catch (Exception e)
    {
      String msg = Translate.get("controller.add.virtualdatabase.failed", e);
      logger.warn(msg, e);
      throw new ControllerException(msg);
    }
  }

  public void addVirtualDatabases(String xml) throws ControllerException
  {
    if (logger.isDebugEnabled())
    {
      logger.debug(Translate.get("controller.loading.virtualdatabase"));
    }
    this.addVirtualDatabases(xml, null,
        ControllerConstants.AUTO_ENABLE_BACKEND,
        ControllerConstants.DATABASE_DEFAULT_CHECKPOINT);
  }

  public void addVirtualDatabase(VirtualDatabase vdb)
      throws ControllerException
  {
    this.addVirtualDatabase(vdb, ControllerConstants.AUTO_ENABLE_BACKEND,
        ControllerConstants.DATABASE_DEFAULT_CHECKPOINT);
  }

  public synchronized void addVirtualDatabase(VirtualDatabase vdb,
      int autoLoad, String checkPoint) throws ControllerException
  {
    // Add the database or retrieve it if it already exists
    if (hasVirtualDatabase(vdb.getDatabaseName()))
    {
      String msg = Translate.get("controller.database.already.exists", vdb
          .getDatabaseName());
      logger.warn(msg);
      throw new ControllerException(msg);
    }
    else
    {
      virtualDatabases.put(vdb.getDatabaseName(), vdb);

      // Send notification
      if (MBeanServerManager.isJmxEnabled())
      {
        Hashtable databases = new Hashtable();
        try
        {
          databases.put("backends", vdb.getAllBackendNames());
        }
        catch (VirtualDatabaseException e)
        {
          // ignore
        }
        RmiConnector
            .broadcastNotification(this,
                CjdbcNotificationList.CONTROLLER_VIRTUALDATABASE_ADDED,
                CjdbcNotificationList.NOTIFICATION_LEVEL_INFO, Translate.get(
                    "notification.virtualdatabase.added", vdb.getName()),
                databases);
      }
    }
    
    // Enable backends with the proper states
    try
    {
      switch (autoLoad)
      {
        case ControllerConstants.AUTO_ENABLE_TRUE :
          vdb.enableAllBackend(checkPoint);
          break;
        case ControllerConstants.AUTO_ENABLE_FALSE :
          break;
        case ControllerConstants.AUTO_ENABLE_RESTORE :
          vdb.enableAllBackendsFromRecovery(checkPoint);
          break;
        default :
          break;
      }
    }
    catch (VirtualDatabaseException e)
    {
      throw new ControllerException(e);
    }

    logger.info(Translate.get("controller.add.virtualdatabase", vdb
        .getDatabaseName()));
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("controller.database.enabled", autoLoad));
  }

  public String viewInfo() throws Exception
  {
    return prettyXml(getXmlController());
  }

  public String viewConfiguration() throws Exception
  {
    return applyXsl(getXmlController(), "c-jdbc-controller.xsl");
  }

  public String viewDatabases() throws Exception
  {
    return applyXsl(getXmlVirtualDatabases(), "c-jdbc.xsl");
  }

  public String viewDatabasesXml() throws Exception
  {
    //return
    // "<C-JDBCTree>"+getXmlController()+getXmlVirtualDatabases()+"</C-JDBCTree>";
    return prettyXml(getXmlVirtualDatabases());
  }

  private String prettyXml(String xml)
  {
    try
    {
      return applyXsl(xml, "c-jdbc-pretty.xsl");
    }
    catch (RuntimeException e)
    {
      logger.error(e.getMessage(), e);
      return e.getMessage();
    }
    catch (Exception e)
    {
      return e.getMessage();
    }
  }

  private String applyXsl(String xml, String xsl)
  {
    try
    {
      StringWriter result = new StringWriter();
      if (tFactory == null)
        tFactory = TransformerFactory.newInstance();
      File infoXsl = internationalizeXsl(new File(this.getClass().getResource(
          "/" + xsl).getFile()));
      if (logger.isDebugEnabled())
        logger.debug(Translate.get("controller.xml.use.xsl", infoXsl));
      //if(infoTransformer==null)
      infoTransformer = tFactory.newTransformer(new StreamSource(infoXsl));
      infoTransformer.transform(new StreamSource(new StringReader(xml)),
          new StreamResult(result));
      return result.toString();
    }
    catch (Exception e)
    {
      String msg = Translate.get("controller.xml.transformation.failed", e);

      if (logger.isDebugEnabled())
        logger.debug(msg, e);
      logger.error(msg);
      return msg;
    }
  }

  private File internationalizeXsl(File xsl) throws Exception
  {
    int point = xsl.getAbsolutePath().lastIndexOf('.');
    String xslPath = xsl.getAbsolutePath();
    xslPath = xslPath.substring(0, point) + "_" + Locale.getDefault()
        + xslPath.substring(point);
    File i18nXsl = new File(xslPath);
    if (i18nXsl.exists() == false)
    {
      ResourceBundle rb = ResourceBundle.getBundle("c-jdbc-xsl");
      BufferedReader br = new BufferedReader(new FileReader(xsl));
      String xml = "";
      String oi18n = "<i18n>";
      String ci18n = "</i18n>";
      int oi18nl = oi18n.length();
      int ci18nl = oi18nl + 1;
      StringBuffer buffer = new StringBuffer();
      String i18n = "";
      while ((xml = br.readLine()) != null)
      {
        int indexOpen = 0, indexClose = 0;
        while ((indexOpen = xml.indexOf(oi18n)) != -1)
        {
          indexClose = xml.indexOf(ci18n);
          i18n = xml.substring(indexOpen + oi18nl, indexClose).trim();
          try
          {
            i18n = rb.getString(i18n);
          }
          catch (Exception ignore)
          // if the key has no match return the key itself
          {
          }
          xml = xml.substring(0, indexOpen) + i18n
              + xml.substring(indexClose + ci18nl);
        }
        buffer.append(xml + System.getProperty("line.separator"));
      }
      BufferedWriter bw = new BufferedWriter(new FileWriter(i18nXsl));
      bw.write(buffer.toString());
      bw.flush();
      bw.close();
    }
    return i18nXsl;
  }

  public String removeVirtualDatabase(String virtualname)
      throws ControllerException
  {
    if (hasVirtualDatabase(virtualname))
    {
      VirtualDatabase vdb = (VirtualDatabase) virtualDatabases.get(virtualname);
      try
      {
        vdb.disableAllBackend();
      }
      catch (VirtualDatabaseException e)
      {
        throw new ControllerException(e);
      }
      this.virtualDatabases.remove(virtualname);

      // Send notification
      if (MBeanServerManager.isJmxEnabled())
      {
        Hashtable databases = new Hashtable();
        try
        {
          databases.put("backends", vdb.getAllBackendNames());
        }
        catch (VirtualDatabaseException e)
        {
          // ignore
        }
        RmiConnector.broadcastNotification(this,
            CjdbcNotificationList.CONTROLLER_VIRTUALDATABASE_REMOVED,
            CjdbcNotificationList.NOTIFICATION_LEVEL_INFO, Translate.get(
                "notification.virtualdatabase.removed", vdb.getName()),
            databases);
      }
    }
    return Translate.get("controller.removeVirtualDatabase.success",
        virtualname);
  }

  public void addDriver(byte[] bytes) throws Exception
  {
    // Try to find drivers directory in the classpath
    File driversDirectory = null;
    URL url = Controller.class
        .getResource(ControllerConstants.C_JDBC_DRIVER_JAR_FILE);
    boolean error = false;
    if (url != null)
    {
      driversDirectory = (new File(url.getFile())).getParentFile();
      error = (driversDirectory == null) || !driversDirectory.exists();
    }

    if (error)
    {
      String msg = Translate.get("controller.driver.dir.not.found");
      logger.error(msg);
      throw new ControllerException(msg);
    }

    // Read the array of bytes to a file
    File temp = null;
    try
    {
      temp = File.createTempFile("driver", "zip", driversDirectory);
      FileOutputStream output = new FileOutputStream(temp);
      output.write(bytes);
      output.close();
    }
    catch (IOException e)
    {
      String msg = Translate.get("controller.add.jar.read.failed", e);
      logger.error(msg);
      throw new ControllerException(msg);
    }

    // Unzip the file content
    try
    {
      Enumeration entries;
      ZipFile zipFile = new ZipFile(temp);

      // Read the file
      int lenght;
      InputStream in;
      BufferedOutputStream out;
      byte[] buffer = new byte[1024];

      entries = zipFile.entries();
      while (entries.hasMoreElements())
      {
        ZipEntry entry = (ZipEntry) entries.nextElement();

        if (entry.isDirectory())
        {
          // Create the directory
          if (logger.isDebugEnabled())
            logger.debug(Translate.get("controller.add.jar.extract.dir", entry
                .getName()));

          (new File(driversDirectory, entry.getName())).mkdir();
          continue;
        }

        // Extract the file
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("controller.add.jar.extract.file", entry
              .getName()));

        in = zipFile.getInputStream(entry);
        out = new BufferedOutputStream(new FileOutputStream(driversDirectory
            + System.getProperty("file.separator") + entry.getName()));
        while ((lenght = in.read(buffer)) >= 0)
          out.write(buffer, 0, lenght);

        in.close();
        out.close();
      }

      zipFile.close();
      temp.delete();
      logger.info(Translate.get("controller.add.jar.to.directory",
          driversDirectory.toString()));
    }
    catch (IOException e)
    {
      String msg = Translate.get("controller.driver.extract.failed", e);
      logger.error(msg);
      throw new ControllerException(msg);
    }
  }

  public VirtualDatabase getVirtualDatabase(String virtualDatabaseName)
  {
    return (VirtualDatabase) virtualDatabases.get(virtualDatabaseName);
  }

  /* Controller information */

  public void refreshLogConfiguration() throws ControllerException
  {
    try
    {
      LogManager.configure(this.getClass().getResource(
          ControllerConstants.LOG4J_RESOURCE).getFile());
      if (logger.isDebugEnabled())
        logger.info(Translate.get("controller.refresh.log.success"));
    }
    catch (Exception e)
    {
      throw new ControllerException(Translate
          .get("controller.logconfigfile.not.found"));
    }
  }

  public String getVersionNumber()
  {
    return Constants.VERSION;
  }

  public String getXml()
  {
    try
    {
      return prettyXml(getXmlController());
    }
    catch (Exception e)
    {
      logger.error(Translate.get("controller.xml.transformation.failed", e));
      return e.getMessage();
    }
  }

  public String getXmlController()
  {
    StringBuffer info = new StringBuffer();
    info.append("<C-JDBC-CONTROLLER>");
    info.append("<" + ControllerXmlTags.ELT_CONTROLLER + " "
        + ControllerXmlTags.ATT_CONTROLLER_IP + "=\"" + this.getIPAddress()
        + "\" " + ControllerXmlTags.ATT_CONTROLLER_PORT + "=\""
        + this.getPortNumber() + "\" " + ">");

    info.append("<" + ControllerXmlTags.ELT_INTERNATIONALIZATION + " "
        + ControllerXmlTags.ATT_LANGUAGE + "=\""
        + Locale.getDefault().getLanguage() + "\"/>");

    if (report.isReportEnabled())
    {
      info.append("<" + ControllerXmlTags.ELT_REPORT + " "
          + ControllerXmlTags.ATT_REPORT_ENABLE_FILE_LOGGING + "=\""
          + report.isEnableFileLogging() + "\" "
          + ControllerXmlTags.ATT_REPORT_HIDE_SENSITIVE_DATA + "=\""
          + report.isHideSensitiveData() + "\" "
          + ControllerXmlTags.ATT_REPORT_GENERATE_ON_FATAL + "=\""
          + report.isGenerateOnFatal() + "\" "
          + ControllerXmlTags.ATT_REPORT_GENERATE_ON_SHUTDOWN + "=\""
          + report.isGenerateOnShutdown() + "\" "
          + ControllerXmlTags.ATT_REPORT_REPORT_LOCATION + "=\""
          + report.getReportLocation() + "\" />");
    }

    if (getJmxEnable())
    {
      info.append("<" + ControllerXmlTags.ELT_JMX + ">");
      if (configuration.containsKey(JmxConstants.ADAPTOR_TYPE_HTTP))
      {
        info.append("<" + ControllerXmlTags.ELT_HTTP_JMX_ADAPTOR + " "
            + ControllerXmlTags.ATT_JMX_ADAPTOR_PORT + "=\""
            + configuration.get(JmxConstants.ADAPTOR_TYPE_HTTP) + "\" />");
      }
      if (configuration.containsKey(JmxConstants.ADAPTOR_TYPE_RMI))
      {
        info.append("<" + ControllerXmlTags.ELT_RMI_JMX_ADAPTOR + " "
            + ControllerXmlTags.ATT_JMX_ADAPTOR_PORT + "=\""
            + configuration.get(JmxConstants.ADAPTOR_TYPE_RMI) + "\" />");
      }

      info.append("</" + ControllerXmlTags.ELT_JMX + ">");
    }

    if (this.isSecurityEnabled())
      info.append(this.getSecurity().getXml());
    info.append("</" + ControllerXmlTags.ELT_CONTROLLER + ">");
    info.append("</C-JDBC-CONTROLLER>");
    return info.toString();
  }

  public String getXmlVirtualDatabases()
  {
    try
    {
      StringBuffer info = new StringBuffer();
      info.append("<C-JDBC>");
      ArrayList virtualDatabases = this.getVirtualDatabases();
      for (int i = 0, size = virtualDatabases.size(); i < size; i++)
        info.append(((VirtualDatabase) virtualDatabases.get(i)).getXml());
      info.append("</C-JDBC>");
      return info.toString();
    }
    catch (Exception e)
    {
      logger.error(e.getMessage(), e);
      return e.getMessage();
    }
  }

  public ControllerServerThread getConnectionThread()
  {
    return connectionThread;
  }

  public void shutdown() throws ControllerException
  {
    this.shutdown(Constants.DEFAULT_SHUTDOWN_MODE);
  }

  public void shutdown(int level) throws ControllerException
  {
    this.shutdown(level, true);
  }

  public void shutdownDatabase(String databaseName, int level)
      throws ControllerException
  {
    VirtualDatabase database = this.getVirtualDatabase(databaseName);
    if (database != null)
    {
      virtualDatabases.remove(databaseName);
      if (getJmxEnable() == true)
      {
        try
        {
          MBeanServerManager.unregister(JmxConstants
              .getVirtualDbObjectName(databaseName));
        }
        catch (Exception jmxException)
        {
          logger.error(Translate.get("jmx.shutdown.virtual.database.failed"));
        }
      }

      // Send notification, if it fails after we're not in a coherent state
      // anymore
      if (MBeanServerManager.isJmxEnabled())
      {
        Hashtable databases = new Hashtable();
        try
        {
          databases.put("backends", database.getAllBackendNames());
        }
        catch (VirtualDatabaseException e)
        {
          // ignore
        }
        RmiConnector.broadcastNotification(this,
            CjdbcNotificationList.CONTROLLER_VIRTUALDATABASE_REMOVED,
            CjdbcNotificationList.NOTIFICATION_LEVEL_INFO, Translate.get(
                "notification.virtualdatabase.removed", database.getName()),
            databases);
      }

      database.shutdown(level);

      logger.info(Translate.get("controller.shutdown.remove", databaseName));
    }
  }

  public void shutdown(int level, boolean systemExit)
      throws ControllerException
  {
    if (isShuttingDown)
    {
      logger.info(Translate.get("controller.already.shutting.down", this
          .getName()));
      return;
    }
    isShuttingDown = true;

    if (isSecurityEnabled() && !security.getAllowConsoleShutdown())
      throw new ControllerException(Translate
          .get("controller.shutdown.refused"));

    ControllerShutdownThread shutdown = new ControllerShutdownThread(this,
        level);
    shutdown.setSystemExit(systemExit);
    Thread thread = new Thread(shutdown.getShutdownGroup(), shutdown,
        "Controller Shutdown Thread");
    thread.start();

    if (report != null && report.isGenerateOnShutdown())
    {
      new ReportManager(this).generate();
      logger.info(Translate.get("fatal.report.generated", report
          .getReportLocation()
          + File.separator + ControllerConstants.REPORT_FILE));
    }
  }

  public String saveConfiguration() throws VirtualDatabaseException
  {
    String msg = Translate.get("controller.save.configuration");
    try
    {
      String configurationFile = ControllerConstants
          .getSaveFile(new SimpleDateFormat("EEE, MMM d, yy")
              .format(new Date()));
      DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(
          new FileOutputStream(configurationFile)));
      StringBuffer xml = new StringBuffer();
      xml.append(prettyXml(getXmlVirtualDatabases().toString()));
      dos.write(xml.toString().getBytes());
      dos.close();
    }
    catch (Exception e)
    {
      msg = Translate.get("controller.save.configuration.failed", e);
      logger.error(msg);
    }
    return msg;
  }

  public boolean hasVirtualDatabase(String name)
  {
    return virtualDatabases.containsKey(name);
  }

  /* main() method */

  public static void main(String args[]) throws Exception
  {
    logger.info(getVersion());

    System.setProperty("javax.management.builder.initial",
        org.objectweb.cjdbc.controller.jmx.MBeanServerBuilder.class.getName());

    ControllerFactory conf = new ControllerFactory(args);
    Controller controller = conf.getController();
    if (controller != null)
      controller.launch();
    else
      throw new Exception(Translate.get("controller.configure.failed"));
  }

  public void endOfController(Exception fatal)
  {
    logger.fatal(Translate.get("fatal.error"));
    if (report.isGenerateOnFatal())
    {
      new ReportManager(this, fatal).generate();
      logger.info(Translate.get("fatal.report.generated", report
          .getReportLocation()
          + File.separator + ControllerConstants.REPORT_FILE));
    }
    Runtime.getRuntime().exit(1);
  }

  public void launch()
  {
    connectionThread = new ControllerServerThread(this);
    connectionThread.start();

    SimpleDateFormat formatter = new SimpleDateFormat(
        "yyyy.MM.dd ww 'at' hh:mm:ss a zzz");
    Date day = new Date();
    String date = formatter.format(day);
    logger.info(Translate.get("controller.date", date));
    logger.info(Translate.get("controller.ready", getName()));
  }

  // Attributes

  public String getName()
  {
    return ipAddress + ":" + portNumber;
  }

  // Operations

  public String loadXmlConfiguration(String filename, String virtualName,
      int autoLoad, String checkPoint) throws Exception
  {
    try
    {
      filename = filename.trim();
      FileReader fileReader;
      try
      {
        fileReader = new FileReader(filename);
      }
      catch (FileNotFoundException fnf)
      {
        return Translate.get("controller.file.not.found", filename);
      }

      // Read the file
      BufferedReader in = new BufferedReader(fileReader);
      StringBuffer xml = new StringBuffer();
      String line;
      do
      {
        line = in.readLine();
        if (line != null)
          xml.append(line);
      }
      while (line != null);

      // Send it to the controller
      addVirtualDatabases(xml.toString(), virtualName, autoLoad, checkPoint);
      return Translate.get("controller.file.send", filename);
    }
    catch (Exception e)
    {
      logger.error(Translate.get("controller.loadXml.failed", e), e);
      throw new ControllerException(Translate.get("controller.loadXml.failed",
          e));
    }
  }

  public String loadXML(String filename) throws Exception
  {
    return this.loadXmlConfiguration(filename, null,
        ControllerConstants.AUTO_ENABLE_BACKEND,
        ControllerConstants.DATABASE_DEFAULT_CHECKPOINT);
  }

  public String addDriver(String filename) throws Exception
  {
    // Test if addDriver is enabled.
    if (isSecurityEnabled() && security.getAllowAdditionalDriver() == false)
    {
      return Translate.get("controller.addDriver.abort", filename);
    }
    try
    {
      filename = filename.trim();
      File file;
      FileInputStream fileInput = null;
      try
      {
        file = new File(filename);
        fileInput = new FileInputStream(file);
      }
      catch (FileNotFoundException fnf)
      {
        return Translate.get("controller.file.not.found", filename);
      }

      // Read the file into an array of bytes
      try
      {
        long size = file.length();
        if (size > Integer.MAX_VALUE)
        {
          // File is too large
          fileInput.close();
          return Translate.get("controller.addDriver.too.large");

        }
        byte[] bytes = new byte[(int) size];

        int nb = fileInput.read(bytes);
        fileInput.close();
        if (nb != size)
        {
          return Translate.get("controller.file.unreadable", filename);
        }

        // Send the file contents to the controller
        addDriver(bytes);
        return Translate.get("controller.addDriver.successful", filename);
      }
      catch (IOException e)
      {
        return Translate.get("controller.addDriver.transfer.failed", filename);
      }
    }
    catch (Exception e)
    {
      return Translate.get("controller.addDriver.send.failed", e);
    }
  }

  public ArrayList getVirtualDatabases()
  {
    ArrayList result = new ArrayList();
    for (Iterator iter = virtualDatabases.values().iterator(); iter.hasNext();)
      result.add(iter.next());
    return result;
  }

  public String getIPAddress()
  {
    return ipAddress;
  }

  public void setIPAddress(String ipAddress)
  {
    this.ipAddress = ipAddress;
  }

  public int getPortNumber()
  {
    return portNumber;
  }

  public void setPortNumber(int port)
  {
    portNumber = port;
  }

  public int getBacklogSize()
  {
    return backlogSize;
  }

  public void setBacklogSize(int size)
  {
    backlogSize = size;
  }

  public boolean getJmxEnable()
  {
    return MBeanServerManager.isJmxEnabled();
  }

  public String getJmxName()
  {
    if (getJmxEnable())
    {
      RmiConnector connector = ((RmiConnector) RmiConnector.getRmiConnectors()
          .get(0));
      return connector.getHostName() + ":" + connector.getPort();
    }
    else
      return getName();
  }

  public void setJmxEnable(boolean enable)
  {
    configuration.put(ControllerFactory.JMX_ENABLE, "" + enable);
  }

  public static String getVersion()
  {
    return Translate.get("controller.info", Constants.VERSION);
  }

  public Hashtable getConfiguration()
  {
    return configuration;
  }

  public boolean isSecurityEnabled()
  {
    return security != null;
  }

  public ControllerSecurityManager getSecurity()
  {
    return security;
  }

  public void setSecurity(ControllerSecurityManager security)
  {
    this.security = security;
  }

  public ArrayList listVirtualDatabases()
  {
    return new ArrayList(virtualDatabases.keySet());
  }

  public String generateReport() throws Exception
  {
    report.startReport();
    return report.generate();
  }

  public ArrayList listBackends(String virtualDbName) throws Exception
  {
    VirtualDatabase vdb = (VirtualDatabase) virtualDatabases.get(virtualDbName);
    if (vdb == null)
      throw new Exception(ExceptionTypes.DATABASE_NOT_FOUND);
    else
    {
      return vdb.viewAllBackendNames();
    }
  }

  public ArrayList listDatabaseClients(String virtualDbName) throws Exception
  {
    VirtualDatabase vdb = (VirtualDatabase) virtualDatabases.get(virtualDbName);
    if (vdb == null)
      throw new Exception(ExceptionTypes.DATABASE_NOT_FOUND);
    else
    {
      return vdb.viewAllClientNames();
    }
  }

  public boolean isCacheEnableForDatabase(String virtualDbName)
      throws Exception
  {
    VirtualDatabase vdb = (VirtualDatabase) virtualDatabases.get(virtualDbName);
    if (vdb == null)
      throw new Exception(ExceptionTypes.DATABASE_NOT_FOUND);
    else
    {
      return (vdb.getRequestManager().getResultCache() == null) ? false : true;
    }
  }

  public void setConfiguration(Hashtable configuration)
  {
    this.configuration = configuration;
  }

  public String viewDatabaseXml(String databaseName) throws Exception
  {
    VirtualDatabase database = getVirtualDatabase(databaseName);
    if (database != null)
      return prettyXml(database.getXml());
    else
      return "";
  }

  public String generateLogReport() throws Exception
  {
    ReportManager report = new ReportManager(this, true);
    return report.generateJustLogs();
  }

  public File[] listAvailableDumpFiles()
  {
    if (getVirtualDatabases().size() <= 0)
      return new File[0];

    File f = new File(((VirtualDatabase) getVirtualDatabases().get(0))
        .getRequestManager().getBackupManager().getBackupDir());
    if (f.exists())
    {
      return f.listFiles(new FilenameFilter()
      {
        public boolean accept(File dir, String name)
        {
          if (name.endsWith(ZipMe.ZIP_EXT))
            return true;
          else
            return false;
        }
      });
    }
    else
      return new File[0];
  }

  public boolean removeDumpFile(File dumpFile)
  {
    logger.info(Translate.get("controller.remove.dump", dumpFile.getName()));
    return dumpFile.delete();
  }

  public String viewLogConfigurationFile() throws IOException
  {
    File logFile = new File(getClass().getResource(
        ControllerConstants.LOG4J_RESOURCE).getFile());
    BufferedReader reader = new BufferedReader(new FileReader(logFile));
    StringBuffer buffer = new StringBuffer();
    String line;
    while ((line = reader.readLine()) != null)
      buffer.append(line + System.getProperty("line.separator"));
    reader.close();
    return buffer.toString();
  }

  public void updateLogConfigurationFile(String newConfiguration)
      throws IOException, ControllerException
  {
    File logFile = new File(getClass().getResource(
        ControllerConstants.LOG4J_RESOURCE).getFile());
    BufferedWriter writer = new BufferedWriter(new FileWriter(logFile));
    writer.write(newConfiguration);
    writer.flush();
    writer.close();
    refreshLogConfiguration();
  }

  public boolean isDistributedVirtualDatabase(String databaseName)
  {
    VirtualDatabase db = getVirtualDatabase(databaseName);
    if (db == null || !db.isDistributed())
      return false;
    else
      return true;
  }

  public ReportManager getReport()
  {
    return report;
  }

  public void setReport(ReportManager report)
  {
    this.report = report;
  }
}

---