public DistributedStateManager(
     DatabaseCluster<Z, D> cluster, CommandDispatcherFactory dispatcherFactory) throws Exception {
   this.cluster = cluster;
   this.stateManager = cluster.getStateManager();
   StateCommandContext<Z, D> context = this;
   this.dispatcher =
       dispatcherFactory.createCommandDispatcher(cluster.getId() + ".state", context, this, this);
 }
예제 #2
0
  /**
   * {@inheritDoc}
   *
   * @see net.sf.hajdbc.state.StateManagerFactory#createStateManager(net.sf.hajdbc.DatabaseCluster)
   */
  @Override
  public <Z, D extends Database<Z>> StateManager createStateManager(DatabaseCluster<Z, D> cluster) {
    if (this.urlPattern == null) {
      throw new IllegalArgumentException(
          "No embedded database driver was detected on the classpath.");
    }

    String url = MessageFormat.format(this.urlPattern, cluster.getId(), Strings.HA_JDBC_HOME);
    DriverDatabase database = new DriverDatabase();
    database.setLocation(url);
    database.setUser(this.user);
    database.setPassword(this.password);

    this.logger.log(
        Level.INFO, "State for database cluster {0} will be persisted to {1}", cluster, url);

    return new SQLStateManager<Z, D>(cluster, database, new GenericObjectPoolFactory(this));
  }
  /**
   * @see net.sf.hajdbc.invocation.InvocationStrategy#invoke(net.sf.hajdbc.sql.SQLProxy,
   *     net.sf.hajdbc.invocation.Invoker)
   */
  @Override
  public <Z, D extends Database<Z>, T, R, E extends Exception> SortedMap<D, R> invoke(
      SQLProxy<Z, D, T, E> proxy, Invoker<Z, D, T, R, E> invoker) throws E {
    Map.Entry<SortedMap<D, R>, SortedMap<D, E>> results = this.collectResults(proxy, invoker);

    SortedMap<D, R> resultMap = results.getKey();
    SortedMap<D, E> exceptionMap = results.getValue();

    if (!exceptionMap.isEmpty()) {
      ExceptionFactory<E> exceptionFactory = proxy.getExceptionFactory();
      DatabaseCluster<Z, D> cluster = proxy.getDatabaseCluster();
      Dialect dialect = cluster.getDialect();

      List<D> failedDatabases = new ArrayList<D>(exceptionMap.size());

      // Determine which exceptions are due to failures
      for (Map.Entry<D, E> entry : exceptionMap.entrySet()) {
        if (exceptionFactory.indicatesFailure(entry.getValue(), dialect)) {
          failedDatabases.add(entry.getKey());
        }
      }

      StateManager stateManager = cluster.getStateManager();

      // Deactivate failed databases, unless all failed
      if (!resultMap.isEmpty() || (failedDatabases.size() < exceptionMap.size())) {
        for (D failedDatabase : failedDatabases) {
          E exception = exceptionMap.remove(failedDatabase);

          if (cluster.deactivate(failedDatabase, stateManager)) {
            logger.error(
                "" + exception + "" + Messages.DATABASE_DEACTIVATED.getMessage(),
                failedDatabase,
                cluster);
          }
        }
      }

      if (!exceptionMap.isEmpty()) {
        // If primary database threw exception
        if (resultMap.isEmpty() || !exceptionMap.headMap(resultMap.firstKey()).isEmpty()) {
          D primaryDatabase = exceptionMap.firstKey();
          E primaryException = exceptionMap.get(primaryDatabase);

          // Deactivate databases with non-matching exceptions
          for (Map.Entry<D, E> entry : exceptionMap.tailMap(primaryDatabase).entrySet()) {
            E exception = entry.getValue();

            if (!exceptionFactory.equals(exception, primaryException)) {
              D database = entry.getKey();

              if (cluster.deactivate(database, stateManager)) {
                logger.error("" + exception + " " + Messages.DATABASE_INCONSISTENT.getMessage());
              }
            }
          }

          // Deactivate databases with results
          for (Map.Entry<D, R> entry : resultMap.entrySet()) {
            D database = entry.getKey();

            if (cluster.deactivate(database, stateManager)) {
              logger.error(Messages.DATABASE_INCONSISTENT.getMessage());
            }
          }

          throw primaryException;
        }
      }
      // Else primary was successful
      // Deactivate databases with exceptions
      for (Map.Entry<D, E> entry : exceptionMap.entrySet()) {
        D database = entry.getKey();
        E exception = entry.getValue();

        if (cluster.deactivate(database, stateManager)) {
          logger.error(Messages.DATABASE_DEACTIVATED.getMessage(), database, cluster);
        }
      }
    }

    return resultMap;
  }