org.flywaydb.core.api.MigrationInfo Java Examples

@Override protected void run(Bootstrap<KeywhizConfig> bootstrap, Namespace namespace,
    KeywhizConfig config) throws Exception {
  DataSource dataSource = config.getDataSourceFactory()
      .build(new MetricRegistry(), "migration-preview-datasource");

  Flyway flyway = Flyway.configure().dataSource(dataSource).locations(config.getMigrationsDir()).table(config.getFlywaySchemaTable()).load();
  MigrationInfoService info = flyway.info();

  MigrationInfo current = info.current();
  if (current == null) {
    logger.info("No migrations have been run yet.");
  } else {
    logger.info("Currently applied migration:");
    logger.info("* {} - {}", current.getVersion(), current.getDescription());
  }

  if (info.pending().length > 0) {
    logger.info("Pending migrations:");
    for (MigrationInfo migration : info.pending()) {
      logger.info("* {} - {}", migration.getVersion(), migration.getDescription());
    }
  } else {
    logger.info("No pending migrations");
  }
}
 

@Test
@DisplayName("Create history table correctly")
public void testFlywayInitialBaselineInfo() {
    MigrationInfo baselineInfo = flyway.info().applied()[0];

    assertEquals("0.0.1", baselineInfo.getVersion().getVersion());
    assertEquals("Initial description for test", baselineInfo.getDescription());
}
 

/**
 * <p>listInfo.</p>
 *
 * @return a {@link java.util.Map} object.
 */
@GET
public Map<String, MigrationInfo[]> listInfo() {
    Map<String, MigrationInfo[]> infoMap = Maps.newLinkedHashMap();
    for (String dbName : DataSourceManager.getDataSourceNames()) {
        Flyway flyway = locator.getService(Flyway.class, dbName);
        infoMap.put(dbName, flyway.info().all());
    }
    return infoMap;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void run() {

    checkNotNull(this.dataSource, "No datasource found for migrations");

    final Flyway flyway = Flyway.configure()
            .dataSource(this.dataSource)
            .locations("db/migrations")
            .baselineOnMigrate(true)
            .baselineVersion("0")
            .sqlMigrationPrefix("")
            .load();

    final MigrationInfo migrationInfo = flyway.info().current();

    if (migrationInfo == null) {
        this.logger.info("No existing database at the actual datasource");
    } else {
        this.logger.info("Current version: {}", migrationInfo.getVersion() + " : " + migrationInfo.getDescription());
    }

    try {
        flyway.migrate();
        this.logger.info("Successfully migrated to version: {}", flyway.info().current().getVersion());
    } catch (FlywayException ex) {
        this.logger.info("Flyway migrations failed!", ex);
    }
}
 

/**
 * Retrieves the full set of infos about the migrations resolved on the classpath.
 *
 * @return The resolved migrations. An empty array if none.
 */
private List<MigrationInfo> resolved(MigrationInfo[] migrationInfos) {
    if (migrationInfos.length == 0)
        throw new NotFoundException();
    List<MigrationInfo> resolvedMigrations = Lists.newArrayList();
    for (MigrationInfo migrationInfo : migrationInfos) {
        if (migrationInfo.getState().isResolved()) {
            resolvedMigrations.add(migrationInfo);
        }
    }

    return resolvedMigrations;
}
 

/**
 * Retrieves the full set of infos about the migrations that failed.
 *
 * @return The failed migrations. An empty array if none.
 */
private List<MigrationInfo> failed(MigrationInfo[] migrationInfos) {
    if (migrationInfos.length == 0)
        throw new NotFoundException();
    List<MigrationInfo> failedMigrations = Lists.newArrayList();
    for (MigrationInfo migrationInfo : migrationInfos) {
        if (migrationInfo.getState().isFailed()) {
            failedMigrations.add(migrationInfo);
        }
    }

    return failedMigrations;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void run() {

    checkNotNull(this.dataSource, "No datasource found for migrations");

    final Flyway flyway = Flyway.configure()
            .dataSource(this.dataSource)
            .locations("db/migrations")
            .baselineOnMigrate(true)
            .baselineVersion("0")
            .sqlMigrationPrefix("")
            .load();

    final MigrationInfo migrationInfo = flyway.info().current();

    if (migrationInfo == null) {
        this.logger.info("No existing database at the actual datasource");
    } else {
        this.logger.info("Current version: {}", migrationInfo.getVersion() + " : " + migrationInfo.getDescription());
    }

    try {
        flyway.migrate();
        this.logger.info("Successfully migrated to version: {}", flyway.info().current().getVersion());
    } catch (FlywayException ex) {
        this.logger.info("Flyway migrations failed!", ex);
    }
}
 

@Override
public void migrate(Flyway flyway) {
	MigrationInfo current = flyway.info().current();
	if (current != null && current.getVersion().equals(INITIAL) && current.getType() == MigrationType.SQL) {
		logger.info("Detected initial version based on SQL scripts, doing repair to switch to Java based migrations.");
		flyway.repair();
	}
	flyway.migrate();
}
 

@Test
@DisplayName("Migrates at start correctly")
public void testFlywayConfigInjection() {
    MigrationInfo migrationInfo = flyway.info().current();
    assertNotNull(migrationInfo, "No Flyway migration was executed");

    String currentVersion = migrationInfo
            .getVersion()
            .toString();
    // Expected to be 1.0.0 as migration runs at start
    assertEquals("1.0.0", currentVersion);
}
 

@Test
@DisplayName("Create history table correctly")
public void testFlywayInitialBaselineInfo() {
    MigrationInfo baselineInfo = flyway.info().applied()[0];

    assertEquals("0.0.1", baselineInfo.getVersion().getVersion());
    assertEquals("Initial description for test", baselineInfo.getDescription());
}
 

@Test
@DisplayName("Migrates at start for datasource named 'users' correctly")
public void testFlywayConfigInjection() {
    MigrationInfo migrationInfo = flywayUsers.info().current();
    assertNotNull(migrationInfo, "No Flyway migration was executed");

    String currentVersion = migrationInfo
            .getVersion()
            .toString();
    // Expected to be 1.0.0 as migration runs at start
    assertEquals("1.0.0", currentVersion);
}
 

@Test
@DisplayName("Clean at start correctly")
public void testFlywayConfigInjection() throws SQLException {

    try (Connection connection = defaultDataSource.getConnection(); Statement stat = connection.createStatement()) {
        try (ResultSet executeQuery = stat.executeQuery("select * from fake_existing_tbl")) {
            fail("fake_existing_tbl should not exist");
        } catch (JdbcSQLException e) {
            // expected fake_existing_tbl does not exist
        }
    }
    MigrationInfo current = flyway.info().current();
    assertNull(current, "Info is not null");
}
 

public MigrationInfo[] getPendingMigrationsInfo() {
    try {
        readWriteLock.readLock().lock();
        return pendingMigrationsInfo;
    } finally {
        readWriteLock.readLock().unlock();
    }
}
 

public MigrationInfo getCurrentDbVersionInfo() {
    try {
        readWriteLock.readLock().lock();
        return currentDbVersionInfo;
    } finally {
        readWriteLock.readLock().unlock();
    }
}
 

/**
 * Retrieves the full set of infos about future migrations applied to the DB.
 *
 * @return The future migrations. An empty array if none.
 */
private List<MigrationInfo> future(MigrationInfo[] migrationInfos) {
    if (migrationInfos.length == 0)
        throw new NotFoundException();
    List<MigrationInfo> futureMigrations = Lists.newArrayList();
    for (MigrationInfo migrationInfo : migrationInfos) {
        if ((migrationInfo.getState() == MigrationState.FUTURE_SUCCESS)
                || (migrationInfo.getState() == MigrationState.FUTURE_FAILED)) {
            futureMigrations.add(migrationInfo);
        }
    }

    return futureMigrations;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void run() {

    checkNotNull(this.dataSource, "No datasource found for migrations");

    final Flyway flyway = Flyway.configure()
            .dataSource(this.dataSource)
            .locations("db/migrations")
            .baselineOnMigrate(true)
            .baselineVersion("0")
            .sqlMigrationPrefix("")
            .load();

    final MigrationInfo migrationInfo = flyway.info().current();

    if (migrationInfo == null) {
        this.logger.info("No existing database at the actual datasource");
    } else {
        this.logger.info("Current version: {}", migrationInfo.getVersion() + " : " + migrationInfo.getDescription());
    }

    try {
        flyway.migrate();
        this.logger.info("Successfully migrated to version: {}", flyway.info().current().getVersion());
    } catch (FlywayException ex) {
        this.logger.info("Flyway migrations failed!", ex);
    }
}
 

private void assertAllMigrationsAre(MigrationState expectedState) {
    for (MigrationInfo migrationInfo : flyway.info().all()) {
        assertThat(migrationInfo.getState()).isEqualTo(expectedState);
    }
}
 

@Override
public void afterEachMigrate(Connection connection, MigrationInfo info) {
    log.info("> afterEachMigrate");
}
 

@Override
public void beforeEachMigrate(Connection connection, MigrationInfo info) {
    log.info("> beforeEachMigrate");
}
 

/**
 * @param name       The name of the data source
 * @param changeSets The list of changes
 */
public FlywayReport(String name, List<MigrationInfo> changeSets) {
    this.name = name;
    this.migrations = changeSets;
}
 

public MigrationInfo[] getPendingMigrationsInfo() {
	return statisticsFlywayWrapper.getPendingMigrationsInfo();
}
 

public MigrationInfo getCurrentDbVersionInfo() {
	return statisticsFlywayWrapper.getCurrentDbVersionInfo();
}
 

public String getDbVersion() {

        if (BeanUtil.getSfContext().getStatisticsService().isConnected()) {

            MigrationInfo versionInfo = BeanUtil.getSfContext().getStatisticsService().getCurrentDbVersionInfo();

            if (versionInfo != null) {

                return versionInfo.getVersion().getVersion();

            }

        }

        return "";

    }
 

/**
 * @return The list of change migrations
 */
@JsonSerialize(contentAs = MigrationInfo.class)
public List<MigrationInfo> getMigrations() {
    return migrations;
}
 

@Override
public void afterEachMigrate(Connection connection, MigrationInfo info) {

}
 

@Override
public void beforeEachMigrate(Connection connection, MigrationInfo info) {

}
 

public void init(HibernateStorageSettings settings) {
    try {
        readWriteLock.writeLock().lock();
        migrationRequired = false;

        sfUpdateRequired = false;

        flyway = new Flyway();

        flyway.getPlaceholders().put("db_name", settings.getDbName());

        String[] initSqls = new String[0];

        if (settings.getDbms().equals(DbmsType.PostgreSQL.getValue())) {
            flyway.setLocations(PSQL_SCRIPT_LOCATION);
        }

        if (settings.getDbms().equals(DbmsType.MySql.getValue())) {
            flyway.setLocations(MYSQL_SCRIPT_LOCATION);
            initSqls = MYSQL_INIT_SQL;
        }

        flyway.setDataSource(settings.buildConnectionUrl(), settings.getUsername(), settings.getPassword(), initSqls);

        flyway.setBaselineOnMigrate(false);

        // Get info about migrations

        MigrationInfoService info = flyway.info();

        currentDbVersionInfo = info.current();

        pendingMigrationsInfo = info.pending();

        MigrationInfo[] all = info.all();

        // Checks

        if (currentDbVersionInfo == null) {
            migrationRequired = true;

            throw new OlderSchemaException("DB initialization is required");

        }

        if (pendingMigrationsInfo.length != 0) {
            migrationRequired = true;

            throw new OlderSchemaException("Migration to version "
                    + pendingMigrationsInfo[pendingMigrationsInfo.length - 1].getVersion().getVersion()
                    + " is required");

        }

        if (all.length != 0) {
            MigrationInfo lastKnown = all[all.length - 1];

            if(lastKnown.getState() == MigrationState.FUTURE_SUCCESS) {

                sfUpdateRequired = true;

                throw new NewerSchemaException("DB schema has newer version " + lastKnown.getVersion().getVersion()
                        + ". Upgrade this Sailfish instance to use it.");
            }
        }
    } finally {
        readWriteLock.writeLock().unlock();
    }
}