/**
 * Database-independent synchronization strategy that does full record transfer between two
 * databases. This strategy is best used when there are <em>many</em> differences between the active
 * database and the inactive database (i.e. very much out of sync). The following algorithm is used:
 *
 * <ol>
 *   <li>Drop the foreign keys on the inactive database (to avoid integrity constraint violations)
 *   <li>For each database table:
 *       <ol>
 *         <li>Delete all rows in the inactive database table
 *         <li>Query all rows on the active database table
 *         <li>For each row in active database table:
 *             <ol>
 *               <li>Insert new row into inactive database table
 *             </ol>
 *       </ol>
 *   <li>Re-create the foreign keys on the inactive database
 *   <li>Synchronize sequences
 * </ol>
 *
 * @author Paul Ferraro
 */
public class FullSynchronizationStrategy
    implements SynchronizationStrategy, TableSynchronizationStrategy, Serializable {
  private static final long serialVersionUID = 9190347092842178162L;

  private static Logger logger = LoggerFactory.getLogger(FullSynchronizationStrategy.class);

  private SynchronizationStrategy strategy = new PerTableSynchronizationStrategy(this);
  private int maxBatchSize = 100;
  private int fetchSize = 0;

  @Override
  public String getId() {
    return "full";
  }

  @Override
  public <Z, D extends Database<Z>> void init(DatabaseCluster<Z, D> cluster) {
    this.strategy.init(cluster);
  }

  @Override
  public <Z, D extends Database<Z>> void synchronize(SynchronizationContext<Z, D> context)
      throws SQLException {
    this.strategy.synchronize(context);
  }

  @Override
  public <Z, D extends Database<Z>> void destroy(DatabaseCluster<Z, D> cluster) {
    this.strategy.destroy(cluster);
  }

  @Override
  public <Z, D extends Database<Z>> void synchronize(
      SynchronizationContext<Z, D> context, TableProperties table) throws SQLException {
    final String tableName = table.getName().getDMLName();
    final Collection<String> columns = table.getColumns();

    final String commaDelimitedColumns = Strings.join(columns, Strings.PADDED_COMMA);

    final String selectSQL = String.format("SELECT %s FROM %s", commaDelimitedColumns, tableName);
    final String deleteSQL = context.getDialect().getTruncateTableSQL(table);
    final String insertSQL =
        String.format(
            "INSERT INTO %s (%s) VALUES (%s)",
            tableName,
            commaDelimitedColumns,
            Strings.join(
                Collections.nCopies(columns.size(), Strings.QUESTION), Strings.PADDED_COMMA));

    Connection sourceConnection = context.getConnection(context.getSourceDatabase());
    final Statement selectStatement = sourceConnection.createStatement();
    try {
      selectStatement.setFetchSize(this.fetchSize);

      Callable<ResultSet> callable =
          new Callable<ResultSet>() {
            @Override
            public ResultSet call() throws SQLException {
              logger.log(Level.DEBUG, selectSQL);
              return selectStatement.executeQuery(selectSQL);
            }
          };

      Future<ResultSet> future = context.getExecutor().submit(callable);

      Connection targetConnection = context.getConnection(context.getTargetDatabase());
      Statement deleteStatement = targetConnection.createStatement();

      try {
        logger.log(Level.DEBUG, deleteSQL);
        int deletedRows = deleteStatement.executeUpdate(deleteSQL);

        logger.log(Level.INFO, Messages.DELETE_COUNT.getMessage(), deletedRows, tableName);
      } finally {
        Resources.close(deleteStatement);
      }

      logger.log(Level.DEBUG, insertSQL);
      PreparedStatement insertStatement = targetConnection.prepareStatement(insertSQL);

      try {
        int statementCount = 0;

        ResultSet resultSet = future.get();

        while (resultSet.next()) {
          int index = 0;

          for (String column : table.getColumns()) {
            index += 1;

            int type = context.getDialect().getColumnType(table.getColumnProperties(column));

            Object object = context.getSynchronizationSupport().getObject(resultSet, index, type);

            if (resultSet.wasNull()) {
              insertStatement.setNull(index, type);
            } else {
              insertStatement.setObject(index, object, type);
            }
          }

          insertStatement.addBatch();
          statementCount += 1;

          if ((statementCount % this.maxBatchSize) == 0) {
            insertStatement.executeBatch();
            insertStatement.clearBatch();
          }

          insertStatement.clearParameters();
        }

        if ((statementCount % this.maxBatchSize) > 0) {
          insertStatement.executeBatch();
        }

        logger.log(Level.INFO, Messages.INSERT_COUNT.getMessage(), statementCount, table);
      } catch (ExecutionException e) {
        throw ExceptionType.getExceptionFactory(SQLException.class).createException(e.getCause());
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new SQLException(e);
      } finally {
        Resources.close(insertStatement);
      }
    } finally {
      Resources.close(selectStatement);
    }
  }

  @Override
  public <Z, D extends Database<Z>> void dropConstraints(SynchronizationContext<Z, D> context)
      throws SQLException {
    context.getSynchronizationSupport().dropForeignKeys();
  }

  @Override
  public <Z, D extends Database<Z>> void restoreConstraints(SynchronizationContext<Z, D> context)
      throws SQLException {
    context.getSynchronizationSupport().restoreForeignKeys();
  }

  /** @return the fetchSize. */
  public int getFetchSize() {
    return this.fetchSize;
  }

  /** @param fetchSize the fetchSize to set. */
  public void setFetchSize(int fetchSize) {
    this.fetchSize = fetchSize;
  }

  /** @return the maxBatchSize. */
  public int getMaxBatchSize() {
    return this.maxBatchSize;
  }

  /** @param maxBatchSize the maxBatchSize to set. */
  public void setMaxBatchSize(int maxBatchSize) {
    this.maxBatchSize = maxBatchSize;
  }
}
Пример #2
0
/** @author Paul Ferraro */
public class SQLStateManagerFactory extends GenericObjectPoolConfiguration
    implements StateManagerFactory {
  private static final long serialVersionUID = -544548607415128414L;

  private Logger logger = LoggerFactory.getLogger(this.getClass());

  enum EmbeddedVendor {
    H2("jdbc:h2:{1}/{0}"),
    HSQLDB("jdbc:hsqldb:{1}/{0}"),
    DERBY("jdbc:derby:{1}/{0};create=true");

    final String pattern;

    EmbeddedVendor(String pattern) {
      this.pattern = pattern;
    }
  }

  private String urlPattern = this.defaultUrlPattern();
  private String user;
  private String password;

  private String defaultUrlPattern() {
    for (EmbeddedVendor vendor : EmbeddedVendor.values()) {
      String url = MessageFormat.format(vendor.pattern, "test", Strings.HA_JDBC_HOME);

      try {
        for (Driver driver : Collections.list(DriverManager.getDrivers())) {
          if (driver.acceptsURL(url)) {
            return vendor.pattern;
          }
        }
      } catch (SQLException e) {
        // Skip vendor
      }
    }

    return null;
  }

  @Override
  public String getId() {
    return "sql";
  }

  /**
   * {@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));
  }

  public String getUrlPattern() {
    return this.urlPattern;
  }

  public void setUrlPattern(String urlPattern) {
    this.urlPattern = urlPattern;
  }

  public String getUser() {
    return this.user;
  }

  public void setUser(String user) {
    this.user = user;
  }

  public String getPassword() {
    return this.password;
  }

  public void setPassword(String password) {
    this.password = password;
  }
}
Пример #3
0
/** @author Paul Ferraro */
public class LifecycleRegistry<K, V extends Lifecycle, C, E extends Exception>
    implements Registry<K, V, C, E> {
  private final Logger logger = LoggerFactory.getLogger(this.getClass());
  private final LifecycleRegistry.Store<K, RegistryEntry> store;

  final Factory<K, V, C, E> factory;
  final ExceptionFactory<E> exceptionFactory;

  public LifecycleRegistry(
      Factory<K, V, C, E> factory,
      RegistryStoreFactory<K> storeFactory,
      ExceptionFactory<E> exceptionFactory) {
    this.store = storeFactory.createStore();
    this.factory = factory;
    this.exceptionFactory = exceptionFactory;
  }

  /**
   * {@inheritDoc}
   *
   * @see net.sf.hajdbc.util.concurrent.Registry#get(java.lang.Object, java.lang.Object)
   */
  @Override
  public V get(K key, C context) throws E {
    RegistryEntry entry = this.store.get(key);

    if (entry != null) {
      return entry.getValue();
    }

    V value = this.factory.create(key, context);

    entry = new RegistryEntry(value);

    RegistryEntry existing = this.store.setIfAbsent(key, entry);

    if (existing != null) {
      return existing.getValue();
    }

    try {
      value.start();

      entry.started();

      return value;
    } catch (Exception e) {
      this.store.clear(key);

      try {
        value.stop();
      } catch (Exception re) {
        this.logger.log(Level.INFO, re);
      }

      throw this.exceptionFactory.createException(e);
    }
  }

  /**
   * {@inheritDoc}
   *
   * @see net.sf.hajdbc.util.concurrent.Registry#remove(java.lang.Object)
   */
  @Override
  public void remove(K key) throws E {
    RegistryEntry entry = this.store.clear(key);

    if (entry != null) {
      entry.getValue().stop();
    }
  }

  private class RegistryEntry {
    private final V value;
    private final AtomicReference<CountDownLatch> latchRef =
        new AtomicReference<CountDownLatch>(new CountDownLatch(1));

    RegistryEntry(V value) {
      this.value = value;
    }

    V getValue() throws E {
      CountDownLatch latch = this.latchRef.get();

      if (latch != null) {
        try {
          if (!latch.await(
              LifecycleRegistry.this.factory.getTimeout(),
              LifecycleRegistry.this.factory.getTimeoutUnit())) {
            throw LifecycleRegistry.this.exceptionFactory.createException(new TimeoutException());
          }
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
          throw LifecycleRegistry.this.exceptionFactory.createException(e);
        }
      }

      return this.value;
    }

    void started() {
      CountDownLatch latch = this.latchRef.getAndSet(null);

      if (latch != null) {
        latch.countDown();
      }
    }
  }
}