src/org/objectweb/cjdbc/driver/Driver.java

説明を見る。

package org.objectweb.cjdbc.driver;

import java.io.IOException;
import java.net.Socket;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Properties;
import java.util.Random;
import java.util.StringTokenizer;

import javax.net.SocketFactory;

import org.objectweb.cjdbc.common.net.SSLConfiguration;
import org.objectweb.cjdbc.common.net.SocketFactoryFactory;
import org.objectweb.cjdbc.common.sql.filters.AbstractBlobFilter;
import org.objectweb.cjdbc.common.stream.CJDBCInputStream;
import org.objectweb.cjdbc.common.stream.CJDBCOutputStream;
import org.objectweb.cjdbc.common.util.Constants;
import org.objectweb.cjdbc.controller.core.ControllerConstants;
import org.objectweb.cjdbc.driver.protocol.Commands;

public class Driver implements java.sql.Driver
{
  public static final int       MAJOR_VERSION                            = Constants
                                                                             .getMajorVersion();

  public static final int       MINOR_VERSION                            = Constants
                                                                             .getMinorVersion();

  private static final String   HOST_PROPERTY                            = "HOST";
  private static final String   PORT_PROPERTY                            = "PORT";
  private static final String   CONTROLLER_PROPERTY                      = "CONTROLLER";
  protected static final String DATABASE_PROPERTY                        = "DATABASE";
  protected static final String USER_PROPERTY                            = "user";
  protected static final String PASSWORD_PROPERTY                        = "password";
  protected static final String PARAMETER_PROPERTY                       = "parameter";
  protected static final String BOOLEAN_TRUE_PROPERTY                    = "booleanTrue";
  protected static final String BOOLEAN_FALSE_PROPERTY                   = "booleanFalse";
  protected static final String ESCAPE_BACKSLASH_PROPERTY                = "escapeBackslash";
  protected static final String ESCAPE_SINGLE_QUOTE_PROPERTY             = "escapeSingleQuote";
  protected static final String ESCAPE_CHARACTER_PROPERTY                = "escapeCharacter";
  protected static final String DRIVER_PROCESSED_PROPERTY                = "driverProcessed";

  private static final String   HOST_PROPERTY_DESCRIPTION                = "Hostname of C-JDBC controller";
  private static final String   PORT_PROPERTY_DESCRIPTION                = "Port number of C-JDBC controller";
  private static final String   DATABASE_PROPERTY_DESCRIPTION            = "Database name";
  private static final String   USER_PROPERTY_DESCRIPTION                = "Username to authenticate as";
  private static final String   PASSWORD_PROPERTY_DESCRIPTION            = "Password to use for authentication";
  private static final String   BOOLEAN_TRUE_PROPERTY_DESCRIPTION        = "Use this value for the 'true' value when using PreparedStatement.setBoolean method";
  private static final String   BOOLEAN_FALSE_PROPERTY_DESCRIPTION       = "Use this value for the 'false' value when using PreparedStatement.setBoolean method";
  private static final String   ESCAPE_BACKSLASH_PROPERTY_DESCRIPTION    = "Set this to true to escape backslashes when performing escape processing of PreparedStatements";
  private static final String   ESCAPE_SINGLE_QUOTE_PROPERTY_DESCRIPTION = "Set this to true to escape single quotes (') when performing escape processing of PreparedStatements";
  private static final String   ESCAPE_CHARACTER_PROPERTY_DESCRIPTION    = "Use this character to prepend and append to the values when performing escape processing of PreparedStatements";
  private static final String   DRIVER_PROCESSED_PROPERTY_DESCRIPTION    = "Set this to false to let queries be passed and prepared for each individual backend";

  private static final String   CJDBC_URL_HEADER                         = "jdbc:cjdbc://";

  private static final int      CJDBC_URL_HEADER_LENGTH                  = CJDBC_URL_HEADER
                                                                             .length();

  private HashMap               controllerCache                          = new HashMap();

  private HashMap               dbNameCache                              = new HashMap();

  protected ArrayList           pendingConnectionClosing                 = new ArrayList();
  protected boolean             connectionClosingThreadisAlive           = false;

  private String                currentControllerURL                     = null;
  private ArrayList             controllerConfig                         = null;
  private ControllerInfo        currentControllerConfig                  = null;
  private String                currentDatabase                          = null;
  private Random                random;
  private int                   controllerConfigArraySize;
  private int                   connectionRequestSinceControllerFailure  = 0;
  // Retry to reconnect to a controller after RETRY_CONTROLLER_AFTER_FAILURE
  // connection requests have been treated since the failure.
  private static final int      RETRY_CONTROLLER_AFTER_FAILURE           = 10;

  // The static initializer registers ourselves with the DriverManager
  // and try to bind the C-JDBC Controller
  static
  {
    // Register with the DriverManager (see JDBC API Tutorial and Reference,
    // Second Edition p. 941)
    try
    {
      java.sql.DriverManager.registerDriver(new Driver());
    }
    catch (SQLException e)
    {
      throw new RuntimeException("Unable to register C-JDBC driver");
    }
  }

  public Driver()
  {
    // Required for Class.forName().newInstance()
    random = new Random(System.currentTimeMillis());
  }

  public java.sql.Connection connect(String url, Properties info)
      throws SQLException
  {
    if (url == null)
      throw new SQLException("Invalid null URL in connect");

    if (!url.toLowerCase().startsWith(CJDBC_URL_HEADER))
      return null;

    String user = null;
    if (info != null)
      user = info.getProperty(USER_PROPERTY);
    else
    {
      info = new Properties();
    }

    // Parse url to get parameters
    Hashtable props = this.parseUrlParams(url);
    if (props != null)
      info.putAll(props);

    if (user == null || user.equals(""))
    {
      if ((user = info.getProperty(USER_PROPERTY)) == null)
        throw new SQLException("Invalid null user name in connect");
    }

    String password = info.getProperty(PASSWORD_PROPERTY);
    if (password == null)
    {
      throw new SQLException("Invalid null password in connect");
    }
    
    // SSL enabled ?
    SSLConfiguration ssl = null;
    if ("true".equals(System.getProperty("cjdbc.ssl.enabled")))
    {
      ssl = SSLConfiguration.getDefaultConfig();
    }

    // Check if there is a connection that is about to be closed that could
    // be reused. We take the bet that if a connection has been released by
    // a client, in the general case, it will reuse the same connection.
    // As we need to keep the work in the synchronized block as minimal as
    // possible, we have to extract the string comparison (url,name,password)
    // from the sync block. This way, we cannot just read/compare/take the
    // connection without synchronizing the whole thing. A solution is to
    // systematically extract the first available connection in the sync block,
    // and do the checkings outside the block. If we fail, we re-sync to put
    // the connection back but in practice it is almost always a success and
    // we don't really care to pay this extra cost once in a while.
    try
    {
      Connection c;
      synchronized (pendingConnectionClosing)
      {
        // Take the last one to prevent shifting all elements
        c = (Connection) pendingConnectionClosing
            .remove(pendingConnectionClosing.size() - 1);
      }
      if (url.equals(c.getURL()) && user.equals(c.getUserName())
          && password.equals(c.getPassword()))
      { // Great! Take this one.
        c.isClosed = false;
        return setParametersOnConnection(info, c);
      }
      else
        // Put this connection back, it is not good for us
        synchronized (pendingConnectionClosing)
        {
          pendingConnectionClosing.add(c);
        }
    }
    catch (IndexOutOfBoundsException ignore)
    {
      // No connection available
    }

    int retry = 2;
    int picked;
    while (retry > 0)
    {
      // Check if the last url used was the same, if yes we re-use the
      // same controller and connection point.
      synchronized (this)
      {
        if (!url.equals(currentControllerURL)
            || (connectionRequestSinceControllerFailure >= RETRY_CONTROLLER_AFTER_FAILURE)
            || ((controllerConfig != null) && (controllerConfig.size() == 0)))
        { // Too bad, all caches missed
          ControllerInfo[] controllerConfigArray = (ControllerInfo[]) controllerCache
              .get(url);
          if (controllerConfigArray == null) // Not in the cache
          {
            parseURL(url);
            controllerConfigArray = (ControllerInfo[]) controllerCache.get(url);
          }
          controllerConfig = new ArrayList();
          controllerConfigArraySize = controllerConfigArray.length;
          for (int i = 0; i < controllerConfigArraySize; i++)
            controllerConfig.add(controllerConfigArray[i]);

          currentControllerURL = url;
          currentDatabase = (String) dbNameCache.get(url);
          if (currentDatabase == null)
            throw new SQLException("Database name cache failure");

          // Give all controllers a chance
          retry = controllerConfig.size();
          connectionRequestSinceControllerFailure = 0;
        }
      }

      int size = controllerConfig.size();
      if (size < controllerConfigArraySize)
        connectionRequestSinceControllerFailure++;

      // Pick one controller randomly among the controllers that have not been
      // tried yet.
      picked = random.nextInt(size);
      currentControllerConfig = (ControllerInfo) controllerConfig.get(picked);

      boolean sentVdbName = false;
      boolean sentUserInfo = false;
      try
      {
        // Connect to the controller
        Socket socket = null;
        if (ssl == null)
        {
          // no ssl - we use ordinary socket
          socket = new Socket(currentControllerConfig.getHostname(),
              currentControllerConfig.getPort());
        }
        else
        {
          SocketFactory sslFact = SocketFactoryFactory.createFactory(ssl);
          socket = sslFact.createSocket(currentControllerConfig.getHostname(),
              currentControllerConfig.getPort());
        }

        // Disable Nagle algorithm else small messages are not sent
        // (at least under Linux) even if we flush the output stream.
        socket.setTcpNoDelay(true);

        CJDBCOutputStream out = new CJDBCOutputStream(socket);
        // Send protocol version and database name
        out.writeInt(Commands.ProtocolVersion);
        out.writeUTF(currentDatabase);
        out.flush();
        sentVdbName = true;

        // Send user information
        out.writeUTF(user);
        out.writeUTF(password);
        out.flush();
        sentUserInfo = true;

        CJDBCInputStream in;
        boolean needSkeleton;
        AbstractBlobFilter filter = null;
        try
        {
          // Create input stream only here else it will block
          in = new CJDBCInputStream(socket);

          Object response = in.readObject();
          if (response instanceof Boolean)
          {
            needSkeleton = ((Boolean) response).booleanValue();
            String sfilter = in.readUTF();
            filter = AbstractBlobFilter.getBlobFilterInstance(sfilter);
          }
          else if (response instanceof SQLException)
            throw (SQLException) response;
          else
            throw new SQLException("Error during connection (received "
                + response + ")");
        }
        catch (IOException e)
        {
          currentControllerURL = null;
          throw new SQLException("Authentication failed");
        }
        return setParametersOnConnection(info, new Connection(this, socket, in,
            out, url, user, password, needSkeleton, filter));
      }
      catch (Exception re)
      {
        controllerConfig.remove(picked);
        retry--;
        if (retry == 0)
        {
          if (!sentVdbName)
            throw new SQLException("Unable to connect to controller on "
                + currentControllerConfig.getHostname() + ":"
                + currentControllerConfig.getPort() + " (" + re + ")");
          else if (!sentUserInfo)
            throw new SQLException(
                "Unable to connect to the virtual database (virtual database name is probably not correct)");
          else
            throw new SQLException(
                "Unable to connect to the virtual database (" + re + ")");
        }
        else
        { // Reset if no more controllers in the list
          if (controllerConfig.isEmpty())
            currentControllerURL = null;
        }
      }
    }
    throw new SQLException(
        "Unable to connect to the virtual database - Unexpected error.");
  }

  public synchronized boolean acceptsURL(String url) throws SQLException
  {
    try
    {
      parseURL(url);
      return true;
    }
    catch (SQLException e)
    {
      return false;
    }
  }

  synchronized Hashtable parseURL(String url) throws SQLException
  {
    // Find the hostname and check for URL correctness
    if (url == null)
    {
      throw new IllegalArgumentException(
          "Illegal null URL in parseURL(String) method");
    }

    if (!url.toLowerCase().startsWith(CJDBC_URL_HEADER))
      throw new SQLException("Malformed header from URL '" + url
          + "' (expected '" + CJDBC_URL_HEADER + "')");
    else
    {
      // Initialize return
      Hashtable result = new Hashtable();

      // Get the controllers list
      int nextSlash = url.indexOf('/', CJDBC_URL_HEADER_LENGTH);
      if (nextSlash == -1)
        // Missing '/' between hostname and database name.
        throw new SQLException("Malformed URL '" + url + "' (expected '"
            + CJDBC_URL_HEADER + "<hostname>/<database>')");

      // Found end of database name
      int questionMark = url.indexOf('?', nextSlash);
      questionMark = (questionMark == -1)
          ? url.indexOf(';', nextSlash)
          : questionMark;

      String controllerURLs = url.substring(CJDBC_URL_HEADER_LENGTH, nextSlash);
      // Check the validity of each controller in the list
      StringTokenizer controllers = new StringTokenizer(controllerURLs, ",",
          true);
      int tokenNumber = controllers.countTokens();
      ArrayList list = new ArrayList();

      int i = 0;
      String s;
      boolean lastTokenWasComma = false;
      while (controllers.hasMoreTokens())
      {
        s = controllers.nextToken().trim();
        if (s.equals(","))
        {
          if (lastTokenWasComma || (i == 0) || (i == tokenNumber - 1))
            // ',' cannot be the first or the last token
            // another ',' cannot follow a ','
            throw new SQLException("Syntax error in controller list '"
                + controllerURLs + "' from URL '" + url + "'");
          else
          {
            lastTokenWasComma = true;
            continue;
          }
        }
        lastTokenWasComma = false;
        list.add(parseController(s));
        i++;
      }

      ControllerInfo[] controllerList = new ControllerInfo[i];
      for (int j = 0; j < i; j++)
      {
        controllerList[j] = (ControllerInfo) (list.get(j));
      }
      // Add controller list to the result
      result.put(CONTROLLER_PROPERTY, controllerList);

      // Check database name validity
      String databaseName = (questionMark == -1) ? url.substring(nextSlash + 1,
          url.length()) : url.substring(nextSlash + 1, questionMark);
      Character c = validDatabaseName(databaseName);
      if (c != null)
        throw new SQLException(
            "Unable to validate database name (unacceptable character '" + c
                + "' in database '" + databaseName + "' from URL '" + url
                + "')");

      // Add database name to result
      result.put(DATABASE_PROPERTY, databaseName);

      // Finally, add the controllers list and database name to the caches
      controllerCache.put(url, controllerList);
      dbNameCache.put(url, databaseName);

      // Get the parameters from the url
      Hashtable params = parseUrlParams(url);
      if (params != null)
        result.put(PARAMETER_PROPERTY, params);
      return result;
    }
  }

  private java.sql.Connection setParametersOnConnection(Properties props,
      org.objectweb.cjdbc.driver.Connection connection)
  {
    String booleanTrue = props.getProperty(BOOLEAN_TRUE_PROPERTY);
    if (booleanTrue != null)
      connection.setPreparedStatementBooleanTrue(booleanTrue);
    String booleanFalse = props.getProperty(BOOLEAN_FALSE_PROPERTY);
    if (booleanFalse != null)
      connection.setPreparedStatementBooleanFalse(booleanFalse);
    String escapeBaskslash = props.getProperty(ESCAPE_BACKSLASH_PROPERTY);
    if (escapeBaskslash != null)
      connection
          .setEscapeBackslash(new Boolean(escapeBaskslash).booleanValue());
    String escapeQuote = props.getProperty(ESCAPE_SINGLE_QUOTE_PROPERTY);
    if (escapeQuote != null)
      connection.setEscapeSingleQuote(new Boolean(escapeQuote).booleanValue());

    String escapeChar = props.getProperty(ESCAPE_CHARACTER_PROPERTY);
    if (escapeChar != null)
      connection.setEscapeChar(escapeChar);

    String driverProcessed = props.getProperty(DRIVER_PROCESSED_PROPERTY);
    if (driverProcessed != null)
      connection.setDriverProcessed(Boolean.valueOf(driverProcessed)
          .booleanValue());

    return connection;
  }

  protected String getUrlFromProperties(Hashtable props)
  {
    StringBuffer sb = new StringBuffer();
    sb.append(CJDBC_URL_HEADER);
    ControllerInfo[] controllerList = (ControllerInfo[]) props
        .get(CONTROLLER_PROPERTY);
    for (int i = 0; i < controllerList.length; i++)
    {
      if (i == 0)
        sb.append(controllerList[i].toString());
      else
        sb.append("," + controllerList[i].toString());
    }
    sb.append("/" + props.get(DATABASE_PROPERTY));
    Hashtable params = (Hashtable) props.get(PARAMETER_PROPERTY);
    if (params != null)
    {
      Enumeration paramsKeys = params.keys();
      String element = null;
      while (paramsKeys.hasMoreElements())
      {
        if (element == null)
          sb.append("?");
        else
          sb.append("&");
        element = (String) paramsKeys.nextElement();
        sb.append(element + "=" + params.get(paramsKeys));
      }
    }
    return sb.toString();
  }

  private Hashtable parseUrlParams(String url) throws SQLException
  {
    Hashtable props;
    props = parseUrlParams(url, '?', "&", "=");
    if (props == null)
    {
      props = parseUrlParams(url, ';', ";", "=");
    }
    return props;
  }

  private Hashtable parseUrlParams(String url, char mark, String link,
      String equal) throws SQLException
  {
    int questionMark = url.indexOf(mark, url.lastIndexOf('/'));
    if (questionMark == -1)
      return null;
    else
    {
      Hashtable props = new Hashtable();
      String parameters = url.substring(questionMark + 1);
      StringTokenizer st1 = new StringTokenizer(parameters, link);
      while (st1.hasMoreTokens())
      {
        String param = st1.nextToken();
        StringTokenizer st2 = new StringTokenizer(param, equal);
        if (st2.hasMoreTokens())
        {
          try
          {
            String paramName = st2.nextToken();
            String paramValue = (st2.hasMoreTokens()) ? st2.nextToken() : "";
            props.put(paramName, paramValue);
          }
          catch (Exception e)
          {
            throw new SQLException("Invalid parameter in URL");
          }
        }
      }
      return props;
    }
  }

  private ControllerInfo parseController(String controller) throws SQLException
  {
    ControllerInfo controllerInfo = new ControllerInfo();

    // Check controller syntax
    StringTokenizer controllerURL = new StringTokenizer(controller, ":", true);

    // Get hostname
    controllerInfo.setHostname(controllerURL.nextToken());
    Character c = validHostname(controllerInfo.getHostname());
    if (c != null)
      throw new SQLException(
          "Unable to validate hostname (unacceptable character '" + c
              + "' in hostname '" + controllerInfo.getHostname()
              + "' from the URL part '" + controller + "')");

    if (!controllerURL.hasMoreTokens())
      controllerInfo.setPort(ControllerConstants.DEFAULT_PORT);
    else
    {
      controllerURL.nextToken(); // should be ':'
      if (!controllerURL.hasMoreTokens())
        controllerInfo.setPort(ControllerConstants.DEFAULT_PORT);
      else
      { // Get the port number
        String port = controllerURL.nextToken();
        if (controllerURL.hasMoreTokens())
          throw new SQLException(
              "Invalid controller definition with more than one semicolon in URL part '"
                  + controller + "'");

        // Check the port number validity
        try
        {
          controllerInfo.setPort(Integer.parseInt(port));
        }
        catch (NumberFormatException ne)
        {
          throw new SQLException(
              "Unable to validate port number (unacceptable port number '"
                  + port + "' in this URL part '" + controller + "')");
        }
      }
    }
    return controllerInfo;
  }

  public DriverPropertyInfo[] getPropertyInfo(String url, Properties info)
      throws SQLException
  {
    DriverPropertyInfo hostProp = new DriverPropertyInfo(HOST_PROPERTY, info
        .getProperty(HOST_PROPERTY));
    hostProp.required = true;
    hostProp.description = HOST_PROPERTY_DESCRIPTION;

    DriverPropertyInfo portProp = new DriverPropertyInfo(PORT_PROPERTY, info
        .getProperty(PORT_PROPERTY, Integer
            .toString(ControllerConstants.DEFAULT_PORT)));
    portProp.required = false;
    portProp.description = PORT_PROPERTY_DESCRIPTION;

    DriverPropertyInfo databaseProp = new DriverPropertyInfo(DATABASE_PROPERTY,
        info.getProperty(DATABASE_PROPERTY));
    databaseProp.required = true;
    databaseProp.description = DATABASE_PROPERTY_DESCRIPTION;

    DriverPropertyInfo userProp = new DriverPropertyInfo(USER_PROPERTY, info
        .getProperty(USER_PROPERTY));
    userProp.required = true;
    userProp.description = USER_PROPERTY_DESCRIPTION;

    DriverPropertyInfo passwordProp = new DriverPropertyInfo(PASSWORD_PROPERTY,
        info.getProperty(PASSWORD_PROPERTY));
    passwordProp.required = true;
    passwordProp.description = PASSWORD_PROPERTY_DESCRIPTION;

    DriverPropertyInfo escapeCharProp = new DriverPropertyInfo(
        ESCAPE_CHARACTER_PROPERTY, info.getProperty(ESCAPE_CHARACTER_PROPERTY));
    escapeCharProp.required = false;
    escapeCharProp.description = ESCAPE_CHARACTER_PROPERTY_DESCRIPTION;

    DriverPropertyInfo escapeBackProp = new DriverPropertyInfo(
        ESCAPE_BACKSLASH_PROPERTY, info.getProperty(ESCAPE_BACKSLASH_PROPERTY));
    escapeBackProp.required = false;
    escapeBackProp.description = ESCAPE_BACKSLASH_PROPERTY_DESCRIPTION;

    DriverPropertyInfo escapeSingleProp = new DriverPropertyInfo(
        ESCAPE_SINGLE_QUOTE_PROPERTY, info
            .getProperty(ESCAPE_SINGLE_QUOTE_PROPERTY));
    escapeSingleProp.required = false;
    escapeSingleProp.description = ESCAPE_SINGLE_QUOTE_PROPERTY_DESCRIPTION;

    DriverPropertyInfo booleanFalseProp = new DriverPropertyInfo(
        BOOLEAN_FALSE_PROPERTY, info.getProperty(BOOLEAN_FALSE_PROPERTY));
    booleanFalseProp.required = false;
    booleanFalseProp.description = BOOLEAN_FALSE_PROPERTY_DESCRIPTION;

    DriverPropertyInfo booleanTrueProp = new DriverPropertyInfo(
        BOOLEAN_TRUE_PROPERTY, info.getProperty(BOOLEAN_TRUE_PROPERTY));
    booleanTrueProp.required = false;
    booleanTrueProp.description = BOOLEAN_TRUE_PROPERTY_DESCRIPTION;

    DriverPropertyInfo parseQueryProp = new DriverPropertyInfo(
        DRIVER_PROCESSED_PROPERTY, info.getProperty(DRIVER_PROCESSED_PROPERTY));
    escapeSingleProp.required = false;
    escapeSingleProp.description = DRIVER_PROCESSED_PROPERTY_DESCRIPTION;

    return new DriverPropertyInfo[]{hostProp, portProp, databaseProp, userProp,
        passwordProp, escapeCharProp, escapeBackProp, escapeSingleProp,
        booleanFalseProp, booleanTrueProp, parseQueryProp};
  }

  public int getMajorVersion()
  {
    return MAJOR_VERSION;
  }

  public int getMinorVersion()
  {
    return MINOR_VERSION;
  }

  public boolean jdbcCompliant()
  {
    return false;
  }

  private static Character validHostname(String hostname)
  {
    char[] name = hostname.toCharArray();
    int size = hostname.length();
    char c;
    //boolean lastCharWasPoint = false; // used to avoid '..' in hostname
    char lastChar = ' ';

    for (int i = 0; i < size; i++)
    {
      c = name[i];

      if (c == '.' || c == '-')
      {
        if (lastChar == '.' || lastChar == '-' || (i == size - 1) || (i == 0))
        {
          // . or - cannot be the first or the last char of hostname
          // hostname cannot contain '..' or '.-' or '-.' or '--'
          return new Character(c);
        }
      }
      else
      {
        if (((c < '0') || (c > 'z') || ((c > '9') && (c < 'A')) || ((c > 'Z') && (c < 'a'))))
        {
          return new Character(c);
        }
      }
      lastChar = c;
    }
    return null;
  }

  private static Character validDatabaseName(String databaseName)
  {
    char[] name = databaseName.toCharArray();
    int size = databaseName.length();
    char c;

    for (int i = 0; i < size; i++)
    {
      c = name[i];
      if ((c < '0') || (c > 'z') || ((c > '9') && (c < 'A'))
          || ((c > 'Z') && (c < 'a')))
        return new Character(c);
    }
    return null;
  }

  public class ControllerInfo
  {
    String hostname;
    int    port;

    public ControllerInfo()
    {
    }

    public String getHostname()
    {
      return hostname;
    }

    public int getPort()
    {
      return port;
    }

    public void setHostname(String string)
    {
      hostname = string;
    }

    public void setPort(int port)
    {
      this.port = port;
    }

    public String toString()
    {
      return hostname + ":" + port;
    }
  } // ControllerInfo class

  protected ArrayList getControllerConfig()
  {
    return controllerConfig;
  }
}

---