use of liquibase.Contexts in project liquibase by liquibase.
the class AbstractIntegrationTest method testTagEmptyDatabase.
@Test
public void testTagEmptyDatabase() throws Exception {
if (database == null) {
return;
}
Liquibase liquibase = createLiquibase(completeChangeLog);
clearDatabase(liquibase);
liquibase = createLiquibase(completeChangeLog);
liquibase.checkLiquibaseTables(false, null, new Contexts(), new LabelExpression());
liquibase.tag("empty");
liquibase = createLiquibase(rollbackChangeLog);
liquibase.update(new Contexts());
liquibase.rollback("empty", new Contexts());
}
use of liquibase.Contexts in project traccar by traccar.
the class DataManager method initDatabaseSchema.
private void initDatabaseSchema() throws SQLException, LiquibaseException {
if (config.hasKey("database.changelog")) {
ResourceAccessor resourceAccessor = new FileSystemResourceAccessor();
Database database = DatabaseFactory.getInstance().openDatabase(config.getString("database.url"), config.getString("database.user"), config.getString("database.password"), null, resourceAccessor);
Liquibase liquibase = new Liquibase(config.getString("database.changelog"), resourceAccessor, database);
liquibase.clearCheckSums();
liquibase.update(new Contexts());
}
}
use of liquibase.Contexts in project stdlib by petergeneric.
the class LiquibaseCore method executeAction.
/**
* Executes the Liquibase update.
*/
private static void executeAction(InitialContext jndi, GuiceApplicationValueContainer config, Map<String, String> parameters, LiquibaseAction action) throws NamingException, SQLException, LiquibaseException, IOException, ParserConfigurationException {
// N.B. liquibase may create a databasechangeloglock / databasechangelog table if one does not already exist
if (action.isWriteAction() && StringUtils.equalsIgnoreCase("true", config.getValue(HIBERNATE_IS_READONLY))) {
log.info("Changing liquibase action from " + action + " to ASSERT_UPDATED because hibernate is set to read only mode");
action = LiquibaseAction.ASSERT_UPDATED;
}
// Fail if hbm2ddl is enabled (Hibernate should not be involved in schema management)
if (StringUtils.isNotEmpty(config.getValue(HIBERNATE_SCHEMA_MANAGEMENT)) && action != LiquibaseAction.GENERATE_CHANGELOG) {
throw new RuntimeException("Liquibase is enabled but so is " + HIBERNATE_SCHEMA_MANAGEMENT + ". Only one of these schema management methods may be used at a time.");
}
final String dataSourceName = config.getDataSource();
final String changeLogFile = config.getValue(GuiceProperties.LIQUIBASE_CHANGELOG);
final String contexts = config.getValue(GuiceProperties.LIQUIBASE_CONTEXTS);
final String labels = config.getValue(GuiceProperties.LIQUIBASE_LABELS);
final String defaultSchema = config.getDefaultSchema();
final String jdbcUrl = config.getValue(AvailableSettings.URL);
final String jdbcUsername = config.getValue(AvailableSettings.USER);
final String jdbcPassword = config.getValue(AvailableSettings.PASS);
if (StringUtils.isEmpty(dataSourceName) && StringUtils.isEmpty(jdbcUrl))
throw new RuntimeException("Cannot run Liquibase: no JNDI datasource or JDBC URL set");
else if (changeLogFile == null)
throw new RuntimeException("Cannot run Liquibase: " + GuiceProperties.LIQUIBASE_CHANGELOG + " is not set");
int storedTransactionIsolation = Integer.MIN_VALUE;
Connection connection = null;
Database database = null;
try {
// Set up the resource accessor
final ResourceAccessor resourceAccessor;
{
final CompositeResourceAccessor composite;
{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
ResourceAccessor threadClFO = new ClassLoaderResourceAccessor(contextClassLoader);
ResourceAccessor clFO = new ClassLoaderResourceAccessor();
ResourceAccessor fsFO = new FileSystemResourceAccessor();
composite = new CompositeResourceAccessor(clFO, fsFO, threadClFO);
}
// If loading a resource with an absolute path fails, re-try it as a path relative to /
// This is for unit tests where /liquibase/changelog.xml needs to be accessed as liquibase/changelog.xml
final ResourceAccessor fallback = new RetryAbsoluteAsRelativeResourceAccessor(composite);
// Wrap the resource accessor in a filter that interprets ./ as the changeLogFile folder
resourceAccessor = new RelativePathFilteringResourceAccessor(fallback, changeLogFile);
}
// Set up the database
{
if (StringUtils.isNotEmpty(dataSourceName)) {
if (log.isDebugEnabled())
log.debug("Look up datasource for liquibase: " + dataSourceName);
final DataSource dataSource = (DataSource) jndi.lookup(dataSourceName);
connection = dataSource.getConnection();
} else {
if (log.isDebugEnabled())
log.debug("Create JDBC Connection directly: " + jdbcUrl);
// N.B. do we need to call Class.forName on the JDBC Driver URL?
// JDBC drivers should expose themselves using the service provider interface nowadays so this shouldn't be necessary
connection = DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword);
}
// Allow changing the transaction isolation away from the default for liquibase
// This is a hack inserted for SQL Server where the SNAPSHOT isolation is being used
// because in this mode it refuses to execute certain DDL statements because of metadata not being versioned
{
storedTransactionIsolation = connection.getTransactionIsolation();
// In this case we change to READ UNCOMMITTED for the duration of the liquibase run
if (storedTransactionIsolation == 4096) {
connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
}
}
database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(new JdbcConnection(connection));
database.setDefaultSchemaName(defaultSchema);
}
Liquibase liquibase = new Liquibase(changeLogFile, resourceAccessor, database);
for (Map.Entry<String, String> param : parameters.entrySet()) {
liquibase.setChangeLogParameter(param.getKey(), param.getValue());
}
if (log.isDebugEnabled())
log.debug("Execute liquibase action: " + action);
switch(action) {
case ASSERT_UPDATED:
// Figure out which changesets need to be run
List<ChangeSet> unrun = liquibase.listUnrunChangeSets(new Contexts(contexts), new LabelExpression(labels));
if (log.isDebugEnabled())
log.debug("Pending changesets: " + unrun);
// If any need to be run, fail
if (unrun.size() > 0)
throw new LiquibaseChangesetsPending(unrun);
else
return;
case UPDATE:
// Perform a schema update
liquibase.update(new Contexts(contexts), new LabelExpression(labels));
return;
case MARK_UPDATED:
// Mark all pending changesets as run
liquibase.changeLogSync(new Contexts(contexts), new LabelExpression(labels));
return;
case GENERATE_CHANGELOG:
CatalogAndSchema catalogueAndSchema = CatalogAndSchema.DEFAULT;
DiffToChangeLog writer = new DiffToChangeLog(new DiffOutputControl(false, false, false, new CompareControl.SchemaComparison[0]));
ByteArrayOutputStream bos = new ByteArrayOutputStream();
PrintStream pw = new PrintStream(bos);
liquibase.generateChangeLog(catalogueAndSchema, writer, pw);
System.out.println("********** GENERATED CHANGELOG START **********");
System.out.println(new String(bos.toByteArray()));
System.out.println("********** GENERATED CHANGELOG END **********");
break;
default:
throw new RuntimeException("Unknown liquibase action: " + action);
}
} finally {
// N.B. we don't return to isolations < 0 (isolation at db defaults)
if (connection != null && connection.getTransactionIsolation() != storedTransactionIsolation && storedTransactionIsolation >= 0) {
connection.setTransactionIsolation(storedTransactionIsolation);
}
if (database != null)
database.close();
else if (connection != null)
connection.close();
}
}
use of liquibase.Contexts in project liquibase by liquibase.
the class ChangeLogSyncToTagTask method executeWithLiquibaseClassloader.
@Override
public void executeWithLiquibaseClassloader() throws BuildException {
Liquibase liquibase = getLiquibase();
OutputStreamWriter writer = null;
try {
FileResource outputFile = getOutputFile();
if (outputFile != null) {
writer = new OutputStreamWriter(outputFile.getOutputStream(), getOutputEncoding());
liquibase.changeLogSync(toTag, new Contexts(getContexts()), getLabels(), writer);
} else {
liquibase.changeLogSync(toTag, new Contexts(getContexts()), getLabels());
}
} catch (UnsupportedEncodingException e) {
throw new BuildException("Unable to generate sync SQL. Encoding [" + getOutputEncoding() + "] is not supported.", e);
} catch (IOException e) {
throw new BuildException("Unable to generate sync SQL. Error creating output writer.", e);
} catch (LiquibaseException e) {
throw new BuildException("Unable to sync change log: " + e.getMessage(), e);
} finally {
FileUtils.close(writer);
}
}
use of liquibase.Contexts in project liquibase by liquibase.
the class LiquibaseChangeLogSyncMojo method performLiquibaseTask.
@Override
protected void performLiquibaseTask(Liquibase liquibase) throws LiquibaseException {
super.performLiquibaseTask(liquibase);
liquibase.changeLogSync(new Contexts(contexts), new LabelExpression(labels));
}
Aggregations