package liquibase.integration.spring;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Map;
import java.util.Vector;
import javax.sql.DataSource;
import liquibase.Liquibase;
import liquibase.database.Database;
import liquibase.database.DatabaseFactory;
import liquibase.database.jvm.JdbcConnection;
import liquibase.exception.DatabaseException;
import liquibase.exception.LiquibaseException;
import liquibase.logging.LogFactory;
import liquibase.logging.Logger;
import liquibase.resource.ResourceAccessor;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
/**
* A Spring-ified wrapper for Liquibase.
*
* Example Configuration:
* <p>
* <p>
* This Spring configuration example will cause liquibase to run
* automatically when the Spring context is initialized. It will load
* <code>db-changelog.xml</code> from the classpath and apply it against
* <code>myDataSource</code>.
* <p>
*
* <pre>
* <bean id="myLiquibase"
* class="liquibase.spring.SpringLiquibase"
* >
*
* <property name="dataSource" ref="myDataSource" />
*
* <property name="changeLog" value="classpath:db-changelog.xml" />
*
* <!-- The following configuration options are optional -->
*
* <property name="executeEnabled" value="true" />
*
* <!--
* If set to true, writeSqlFileEnabled will write the generated
* SQL to a file before executing it.
* -->
* <property name="writeSqlFileEnabled" value="true" />
*
* <!--
* sqlOutputDir specifies the directory into which the SQL file
* will be written, if so configured.
* -->
* <property name="sqlOutputDir" value="c:\sql" />
*
* </bean>
*
* </pre>
*
* @author Rob Schoening
*/
public class SpringLiquibase implements InitializingBean, BeanNameAware, ResourceLoaderAware {
public class SpringResourceOpener implements ResourceAccessor {
private String parentFile;
public SpringResourceOpener(String parentFile) {
this.parentFile = parentFile;
}
public InputStream getResourceAsStream(String file) throws IOException {
try {
Resource resource = getResource(file);
return resource.getInputStream();
}
catch ( FileNotFoundException ex ) {
return null;
}
}
public Enumeration<URL> getResources(String packageName) throws IOException {
Vector<URL> tmp = new Vector<URL>();
tmp.add(getResource(packageName).getURL());
return tmp.elements();
}
public Resource getResource(String file) {
return getResourceLoader().getResource(adjustClasspath(file));
}
private String adjustClasspath(String file) {
return isClasspathPrefixPresent(parentFile) && !isClasspathPrefixPresent(file)
? ResourceLoader.CLASSPATH_URL_PREFIX + file
: file;
}
public boolean isClasspathPrefixPresent(String file) {
return file.startsWith(ResourceLoader.CLASSPATH_URL_PREFIX);
}
public ClassLoader toClassLoader() {
return getResourceLoader().getClassLoader();
}
}
private String beanName;
private ResourceLoader resourceLoader;
private DataSource dataSource;
private Logger log = LogFactory.getLogger(SpringLiquibase.class.getName());
private String changeLog;
private String contexts;
private Map<String, String> parameters;
private String defaultSchema;
public SpringLiquibase() {
super();
}
public String getDatabaseProductName() throws DatabaseException {
Connection connection = null;
String name = "unknown";
try {
connection = getDataSource().getConnection();
Database database =
DatabaseFactory.getInstance().findCorrectDatabaseImplementation(new JdbcConnection(dataSource.getConnection()));
name = database.getDatabaseProductName();
} catch (SQLException e) {
throw new DatabaseException(e);
} finally {
if (connection != null) {
try {
if (!connection.getAutoCommit())
{
connection.rollback();
}
connection.close();
} catch (Exception e) {
log.warning("problem closing connection", e);
}
}
}
return name;
}
/**
* The DataSource that liquibase will use to perform the migration.
*
* @return
*/
public DataSource getDataSource() {
return dataSource;
}
/**
* The DataSource that liquibase will use to perform the migration.
*/
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
/**
* Returns a Resource that is able to resolve to a file or classpath resource.
*
* @return
*/
public String getChangeLog() {
return changeLog;
}
/**
* Sets a Spring Resource that is able to resolve to a file or classpath resource.
* An example might be <code>classpath:db-changelog.xml</code>.
*/
public void setChangeLog(String dataModel) {
this.changeLog = dataModel;
}
public String getContexts() {
return contexts;
}
public void setContexts(String contexts) {
this.contexts = contexts;
}
public String getDefaultSchema() {
return defaultSchema;
}
public void setDefaultSchema(String defaultSchema) {
this.defaultSchema = defaultSchema;
}
/**
* Executed automatically when the bean is initialized.
*/
public void afterPropertiesSet() throws LiquibaseException {
String shouldRunProperty = System.getProperty(Liquibase.SHOULD_RUN_SYSTEM_PROPERTY);
if (shouldRunProperty != null && !Boolean.valueOf(shouldRunProperty)) {
System.out.println("Liquibase did not run because '" + Liquibase.SHOULD_RUN_SYSTEM_PROPERTY + "' system property was set to false");
return;
}
Connection c = null;
Liquibase liquibase = null;
try {
c = getDataSource().getConnection();
liquibase = createLiquibase(c);
liquibase.update(getContexts());
} catch (SQLException e) {
throw new DatabaseException(e);
} finally {
if (liquibase != null) {
liquibase.forceReleaseLocks();
}
if (c != null) {
try {
c.rollback();
c.close();
} catch (SQLException e) {
//nothing to do
}
}
}
}
protected Liquibase createLiquibase(Connection c) throws LiquibaseException {
Liquibase liquibase = new Liquibase(getChangeLog(), createResourceOpener(), createDatabase(c));
if (parameters != null) {
for(Map.Entry<String, String> entry: parameters.entrySet()) {
liquibase.setChangeLogParameter(entry.getKey(), entry.getValue());
}
}
return liquibase;
}
/**
* Subclasses may override this method add change some database settings such as
* default schema before returning the database object.
* @param c
* @return a Database implementation retrieved from the {@link DatabaseFactory}.
* @throws DatabaseException
*/
protected Database createDatabase(Connection c) throws DatabaseException {
Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(new JdbcConnection(c));
if (this.defaultSchema != null) {
database.setDefaultSchemaName(this.defaultSchema);
}
return database;
}
public void setChangeLogParameters(Map<String, String> parameters) {
this.parameters = parameters;
}
/**
* Create a new resourceOpener.
*/
protected SpringResourceOpener createResourceOpener() {
return new SpringResourceOpener(getChangeLog());
}
/**
* Spring sets this automatically to the instance's configured bean name.
*/
public void setBeanName(String name) {
this.beanName = name;
}
/**
* Gets the Spring-name of this instance.
*
* @return
*/
public String getBeanName() {
return beanName;
}
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
public ResourceLoader getResourceLoader() {
return resourceLoader;
}
@Override
public String toString() {
return getClass().getName()+"("+this.getResourceLoader().toString()+")";
}
}