src/org/objectweb/cjdbc/controller/virtualdatabase/protocol/VirtualDatabaseConfiguration.java

説明を見る。

package org.objectweb.cjdbc.controller.virtualdatabase.protocol;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.jmx.JmxConstants;
import org.objectweb.cjdbc.common.shared.BackendInfo;
import org.objectweb.cjdbc.common.sql.schema.DatabaseSchema;
import org.objectweb.cjdbc.controller.jmx.RmiConnector;
import org.objectweb.cjdbc.controller.requestmanager.RAIDbLevels;
import org.objectweb.cjdbc.controller.virtualdatabase.DistributedVirtualDatabase;

public class VirtualDatabaseConfiguration extends CJDBCGroupMessage
{
  private String         controllerName;
  private String controllerJmxName;
  private String         vdbName;
  private String         groupName = null;
  private ArrayList      vLogins;
  private int            schedulerRAIDbLevel;
  private int            loadBalancerRAIDbLevel;
  private DatabaseSchema dbs;
  private ArrayList      backends;
  private HashMap        backendPolicies;

  // Jmx Information
  private String         rmiHostname;
  private String         rmiPort;

  public String getControllerName()
  {
    return controllerName;
  }

  public String getControllerJmxName()
  {
    return controllerJmxName;
  }
  public VirtualDatabaseConfiguration(DistributedVirtualDatabase dvdb)
  {
    this.controllerName = dvdb.getControllerName();
    this.controllerJmxName = dvdb.viewOwningController();
    this.vdbName = dvdb.getName();
    this.groupName = dvdb.getGroupName();
    this.vLogins = dvdb.getAuthenticationManager().getVirtualLogins();
    this.schedulerRAIDbLevel = dvdb.getRequestManager().getScheduler()
        .getRAIDbLevel();
    this.loadBalancerRAIDbLevel = dvdb.getRequestManager().getLoadBalancer()
        .getRAIDbLevel();
    this.dbs = dvdb.getRequestManager().getDatabaseSchema();
    this.backends = dvdb.getBackendsInfo(dvdb.getBackends());
    this.backendPolicies = dvdb.getBackendRecoveryPolicy();

    List connectors = RmiConnector.getRmiConnectors();
    if (connectors.size() > 0)
    {
      RmiConnector rmi = (RmiConnector) connectors.get(0);
      rmiHostname = rmi.getHostName();
      rmiPort = "" + rmi.getPort();
    }
    else
    {
      rmiHostname = controllerName.substring(0, controllerName.indexOf(":"));
      rmiPort = "" + JmxConstants.DEFAULT_JMX_RMI_PORT;
    }
  }

  public String getRmiHostname()
  {
    return rmiHostname;
  }

  public String getRmiPort()
  {
    return rmiPort;
  }

  public boolean isCompatible(DistributedVirtualDatabase localDvdb)
  {
    try
    {
      if (controllerName.equals(localDvdb.getControllerName()))
      {
        localDvdb.logger
            .warn(Translate
                .get("virtualdatabase.distributed.configuration.checking.duplicate.controller.name"));
        return false;
      }

      // Sanity checks for virtual database name and group name
      if (!vdbName.equals(localDvdb.getName()))
      {
        localDvdb.logger
            .warn(Translate
                .get("virtualdatabase.distributed.configuration.checking.mismatch.name"));
        return false;
      }
      if (!groupName.equals(localDvdb.getGroupName()))
      {
        localDvdb.logger
            .warn(Translate
                .get("virtualdatabase.distributed.configuration.checking.mismatch.groupname"));
        return false;
      }

      // Authentication managers must contains the same set of elements but
      // possibly in different orders (equals require the element to be in the
      // same order).
      if (!vLogins.containsAll(localDvdb.getAuthenticationManager()
          .getVirtualLogins())
          || !localDvdb.getAuthenticationManager().getVirtualLogins()
              .containsAll(vLogins))
      {
        localDvdb.logger
            .warn(Translate
                .get("virtualdatabase.distributed.configuration.checking.mismatch.vlogins"));
        return false;
      }

      // Scheduler and Load Balancer checking
      if (schedulerRAIDbLevel != localDvdb.getRequestManager().getScheduler()
          .getRAIDbLevel())
      {
        localDvdb.logger
            .warn(Translate
                .get("virtualdatabase.distributed.configuration.checking.mismatch.scheduler"));
        return false;
      }

      if (loadBalancerRAIDbLevel != localDvdb.getRequestManager()
          .getLoadBalancer().getRAIDbLevel())
      {
        localDvdb.logger
            .warn(Translate
                .get("virtualdatabase.distributed.configuration.checking.mismatch.loadbalancer"));
        return false;
      }

      // Checking backends
      int size = backends.size();
      for (int i = 0; i < size; i++)
      {
        BackendInfo b = (BackendInfo) backends.get(i);
        if (!localDvdb.isCompatibleBackend(b))
        {
          localDvdb.logger
              .warn(Translate
                  .get(
                      "virtualdatabase.distributed.configuration.checking.mismatch.backend.shared",
                      b.getName()));
          return false;
        }
      }

      // Database schema checking (if any)
      if (dbs == null)
      {
        localDvdb.logger
            .warn(Translate
                .get("virtualdatabase.distributed.configuration.checking.noschema"));
      }
      else
      {
        // Check database schemas compatibility
        switch (loadBalancerRAIDbLevel)
        {
          case RAIDbLevels.RAIDb0 :
            // There must be no overlap between schemas
            if (dbs.equals(localDvdb.getRequestManager().getDatabaseSchema()))
            {
              localDvdb.logger
                  .warn(Translate
                      .get("virtualdatabase.distributed.configuration.checking.mismatch.databaseschema"));
              return false;
            }
            break;
          case RAIDbLevels.SingleDB :
          case RAIDbLevels.RAIDb1 :
            // Schemas must be identical
            if (!dbs.equals(localDvdb.getRequestManager().getDatabaseSchema()))
            {
              localDvdb.logger
                  .warn(Translate
                      .get("virtualdatabase.distributed.configuration.checking.mismatch.databaseschema"));
              return false;
            }
            break;
          case RAIDbLevels.RAIDb2 :
            // Common parts of the schema must be identical
            if (!dbs.isCompatibleWith(localDvdb.getRequestManager()
                .getDatabaseSchema()))
            {
              localDvdb.logger
                  .warn(Translate
                      .get("virtualdatabase.distributed.configuration.checking.mismatch.databaseschema"));
              return false;
            }
            break;
          default :
            localDvdb.logger.error("Unsupported RAIDb level: "
                + loadBalancerRAIDbLevel);
            return false;
        }
      }

      // Ok, all tests succeeded, configuration is compatible
      return true;
    }
    catch (Exception e)
    {
      localDvdb.logger.error(Translate
          .get("virtualdatabase.distributed.configuration.checking.error"), e);
      return false;
    }
  }

  public HashMap getBackendPolicies()
  {
    return backendPolicies;
  }

}

---