| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| package org.hsqldb.test; |
| |
| import java.io.File; |
| import java.io.FilenameFilter; |
| import java.io.IOException; |
| import java.sql.Connection; |
| import java.sql.DriverManager; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.text.SimpleDateFormat; |
| |
| import org.hsqldb.lib.tar.DbBackup; |
| import org.hsqldb.lib.tar.TarMalformatException; |
| |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| |
| public class TestDbBackup extends junit.framework.TestCase { |
| |
| public TestDbBackup() throws IOException, SQLException {} |
| |
| static protected File baseDir = |
| new File(System.getProperty("java.io.tmpdir"), |
| "TestDbBackup-" + System.getProperty("user.name")); |
| |
| static { |
| try { |
| Class.forName("org.hsqldb.jdbc.JDBCDriver"); |
| } catch (ClassNotFoundException cnfe) { |
| throw new RuntimeException( |
| "<clinit> failed. JDBC Driver class not in CLASSPATH"); |
| } |
| } |
| |
| /** |
| * Individual test methods may or may not need a Connection. |
| * If they do, they run setupConn() then use 'conn', and it will be |
| * automatically closed by the tearDown() method. |
| * |
| * @see #tearDown() |
| */ |
| protected void setupConn(String id) throws SQLException { |
| conn = getConnection(id); |
| alreadyShut = false; |
| } |
| |
| protected void shutdownAndCloseConn() throws SQLException { |
| |
| if (conn == null) { |
| return; |
| } |
| if (!alreadyShut) { |
| conn.createStatement().executeUpdate("SHUTDOWN"); |
| alreadyShut = true; |
| } |
| if (verbose) { |
| System.err.println("Shut down 'db1'"); |
| } |
| conn.close(); |
| |
| conn = null; |
| } |
| |
| /** |
| * Use setupConn() to set up this Connection for just this individual test. |
| * |
| * @see #setupConn(String) |
| */ |
| protected Connection conn = null; |
| protected boolean alreadyShut = false; |
| |
| /** |
| * Remove the specified directory and all of it's descendants. |
| * |
| * @throws IOException if unable to completely remove the specified dir |
| */ |
| protected void rmR(File dir) throws IOException { |
| |
| if (!dir.exists()) { |
| throw new IOException("Specified dir does not exist: " |
| + dir.getAbsolutePath()); |
| } |
| |
| File[] children = dir.listFiles(); |
| |
| for (int i = 0; i < children.length; i++) { |
| if (children[i].isDirectory()) { |
| rmR(children[i]); |
| } else if (!children[i].delete()) { |
| throw new IOException("Failed to remove '" |
| + children[i].getAbsolutePath() + "'"); |
| } |
| } |
| |
| if (!dir.delete()) { |
| throw new IOException("Failed to remove '" + dir.getAbsolutePath() |
| + "'"); |
| } |
| } |
| |
| /** |
| * Accommodate JUnit's test-runner conventions. |
| */ |
| public TestDbBackup(String s) throws IOException, SQLException { |
| super(s); |
| } |
| |
| /** |
| * JUnit convention for cleanup. |
| * |
| * Called after each test*() method. |
| */ |
| protected void tearDown() throws IOException, SQLException { |
| |
| if (baseDir.exists()) { |
| rmR(baseDir); |
| if (verbose) { |
| System.err.println("Tore down"); |
| } |
| } |
| } |
| |
| static boolean verbose = Boolean.getBoolean("VERBOSE"); |
| |
| /** |
| * Specifically, this method creates and populates "db1", then closes it. |
| * |
| * Invoked before each test*() invocation by JUnit. |
| */ |
| protected void setUp() throws IOException, SQLException { |
| if (verbose) { |
| System.err.println("Set-upping"); |
| } |
| |
| if (baseDir.exists()) { |
| throw new IOException( |
| "Please wipe out work directory '" |
| + baseDir + ", which is probably left over from an " |
| + "aborted test run"); |
| } |
| |
| try { |
| setupConn("db1"); |
| |
| Statement st = conn.createStatement(); |
| |
| st.executeUpdate("CREATE TABLE t(i int);"); |
| st.executeUpdate("INSERT INTO t values(34);"); |
| conn.commit(); |
| } catch (SQLException se) {} |
| finally { |
| shutdownAndCloseConn(); |
| } |
| } |
| |
| /** |
| * Make sure to close after using the returned connection |
| * (like in a finally block). |
| */ |
| protected Connection getConnection(String id) throws SQLException { |
| |
| Connection c = DriverManager.getConnection("jdbc:hsqldb:file:" |
| + baseDir.getAbsolutePath() + '/' + id + "/dbfile", "SA", ""); |
| |
| if (verbose) { |
| System.err.println("Opening JDBC URL '" |
| + "jdbc:hsqldb:file:" + baseDir.getAbsolutePath() |
| + '/' + id + "/dbfile"); |
| } |
| |
| c.setAutoCommit(false); |
| |
| return c; |
| } |
| |
| /** |
| * This method allows to easily run this unit test independent of the other |
| * unit tests, and without dealing with Ant or unrelated test suites. |
| */ |
| static public void main(String[] sa) { |
| if (sa.length > 0 && !sa[sa.length - 1].equals("-g")) { |
| TestDbBackup.baseDir = new File(sa[0]); |
| |
| if (baseDir.exists()) { |
| throw new IllegalArgumentException( |
| "If you specify a work directory, it must not exist " |
| + "yet. (This makes it much easier for us to clean up " |
| + "after ourselves)."); |
| } |
| |
| System.err.println("Using user-specified base dir: " |
| + baseDir.getAbsolutePath()); |
| } |
| junit.textui.TestRunner runner = new junit.textui.TestRunner(); |
| junit.framework.TestResult result = |
| runner.run(runner.getTest(TestDbBackup.class.getName())); |
| |
| System.exit(result.wasSuccessful() ? 0 : 1); |
| } |
| |
| public void testSanity() throws SQLException { |
| |
| try { |
| setupConn("db1"); |
| |
| ResultSet rs = |
| conn.createStatement().executeQuery("SELECT * FROM t;"); |
| |
| rs.next(); |
| assertEquals("Wrong table 't' contents", 34, rs.getInt("i")); |
| } finally { |
| shutdownAndCloseConn(); |
| } |
| } |
| |
| public void testBasicBackup() |
| throws SQLException, IOException, TarMalformatException { |
| mainBackupAndRestore("basic.tar"); |
| } |
| |
| public void testGzip() |
| throws SQLException, IOException, TarMalformatException { |
| mainBackupAndRestore("compressed.tar.gz"); |
| } |
| |
| /** |
| * Test all forms of online backups with explicit filenames. |
| */ |
| public void testOnlineBackup() |
| throws SQLException, IOException, TarMalformatException { |
| onlineBackupAndRestore("online.tar", true, false, "db11"); |
| onlineBackupAndRestore("online.tar.gz", false, true, "db12"); |
| onlineBackupAndRestore("online.tgz", false, true, "db13"); |
| } |
| |
| public void onlineBackupAndRestore(String baseTarName, |
| boolean populate, boolean compress, String restoreDest) |
| throws SQLException, IOException, TarMalformatException { |
| |
| try { |
| setupConn("db1"); |
| conn.createStatement().executeUpdate("DELETE FROM t"); |
| // For this case, we wipe the data that we so carefully set up, |
| // so that we can call this method repeatedly without worrying |
| // about left-over data from a previous run. |
| conn.commit(); |
| conn.createStatement().executeUpdate("INSERT INTO t VALUES(1)"); |
| conn.createStatement().executeUpdate("INSERT INTO t VALUES(2)"); |
| conn.createStatement().executeUpdate("INSERT INTO t VALUES(3)"); |
| conn.commit(); |
| conn.createStatement().executeUpdate("INSERT INTO t VALUES(4)"); |
| conn.createStatement().executeUpdate("INSERT INTO t VALUES(5)"); |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + '/' + baseTarName |
| + "' BLOCKING" |
| + (compress ? "" : " NOT COMPRESSED")); |
| conn.createStatement().executeUpdate( |
| "INSERT INTO t VALUES(6)"); |
| conn.commit(); |
| conn.createStatement().executeUpdate("SHUTDOWN"); |
| alreadyShut = true; |
| if (verbose) { |
| System.err.println("Shut down 'db1'"); |
| } |
| } finally { |
| shutdownAndCloseConn(); |
| } |
| |
| File destDir = new File(baseDir, restoreDest); |
| |
| if (!destDir.mkdir()) { |
| throw new IOException("Failed to make new dir. to restore to: " |
| + destDir.getAbsolutePath()); |
| } |
| |
| DbBackup.main(new String[] { |
| "--extract", baseDir.getAbsolutePath() + '/' + baseTarName, |
| destDir.getAbsolutePath() |
| }); |
| |
| try { |
| setupConn(restoreDest); |
| conn.createStatement().executeUpdate("ROLLBACK"); |
| |
| ResultSet rs = |
| conn.createStatement().executeQuery("SELECT count(*) c FROM t;"); |
| |
| rs.next(); |
| // 3 committed, 5 uncommited before saving: |
| assertEquals("Wrong table 't' contents", 5, rs.getInt("c")); |
| } finally { |
| shutdownAndCloseConn(); |
| } |
| } |
| |
| public void mainBackupAndRestore(String baseTarName) |
| throws SQLException, IOException, TarMalformatException { |
| |
| DbBackup.main(new String[] { |
| "--save", baseDir.getAbsolutePath() + '/' + baseTarName, |
| baseDir.getAbsolutePath() + "/db1/dbfile" |
| }); |
| |
| File destDir = new File(baseDir, "mainrestored"); |
| |
| if (!destDir.mkdir()) { |
| throw new IOException("Failed to make new dir. to restore to: " |
| + destDir.getAbsolutePath()); |
| } |
| |
| DbBackup.main(new String[] { |
| "--extract", baseDir.getAbsolutePath() + '/' + baseTarName, |
| destDir.getAbsolutePath() |
| }); |
| |
| try { |
| setupConn("mainrestored"); |
| |
| ResultSet rs = conn.createStatement().executeQuery("SELECT * FROM t;"); |
| |
| rs.next(); |
| assertEquals("Wrong table 't' contents", 34, rs.getInt("i")); |
| } finally { |
| shutdownAndCloseConn(); |
| } |
| } |
| |
| public void testMainAlreadyOpen() |
| throws SQLException, IOException, TarMalformatException { |
| |
| try { |
| setupConn("db1"); |
| |
| try { |
| DbBackup.main(new String[] { |
| "--save", baseDir.getAbsolutePath() + "/mainOpen.tar", |
| baseDir.getAbsolutePath() + "/db1/dbfile" |
| }); |
| } catch (IllegalStateException ioe) { |
| return; |
| } |
| } finally { |
| shutdownAndCloseConn(); |
| } |
| |
| fail("Backup from main() did not throw even though DB is open"); |
| } |
| |
| /** |
| * Test that bad explicit filenames are rejected for onilne backups. |
| */ |
| public void testTarFileNames() |
| throws SQLException, IOException, TarMalformatException { |
| |
| boolean caught; |
| try { |
| setupConn("db1"); |
| conn.createStatement().executeUpdate("INSERT INTO t VALUES(2)"); |
| conn.commit(); |
| |
| // #1: COMPRESSED -> no-extension |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad' BLOCKING COMPRESSED"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested compression " |
| + "to file '/x/bad'"); |
| } |
| // #2: NOT COMPRESSED -> no-extension |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad' BLOCKING NOT COMPRESSED"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested " |
| + "no-compression to file '/x/bad'"); |
| } |
| // #3: COMPRESSED -> *.txt |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad.txt' BLOCKING COMPRESSED"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested compression " |
| + "to file '/x/bad.txt'"); |
| } |
| // #4: NOT COMPRESSED -> *.txt |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad.txt' BLOCKING NOT COMPRESSED"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested " |
| + "no-compression to file '/x/bad.txt'"); |
| } |
| // #5: DEFAULT -> *.tar |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad.tar' BLOCKING"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested default " |
| + "to file '/x/bad.tar'"); |
| } |
| // #6: COMPRESSION -> *.tar |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad.tar' BLOCKING COMPRESSED"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested compression " |
| + "to file '/x/bad.tar'"); |
| } |
| // #7: NOT COMPRESSED -> *.tar.gz |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad.tar.gz' BLOCKING NOT COMPRESSED"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested " |
| + "non-compression to file '/x/bad.tar.gz'"); |
| } |
| // #8: NOT COMPRESSED -> *.tgz |
| caught = false; |
| try { |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/x/bad.tgz' BLOCKING NOT COMPRESSED"); |
| } catch (SQLException se) { |
| caught = true; |
| } |
| if (!caught) { |
| fail("BACKUP did not throw even though requested " |
| + "non-compression to file '/x/bad.tgz'"); |
| } |
| |
| // Finally run a test to ensure that the attempts above didn't |
| // fail for some unexpected reason. |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/positivetest.tar' BLOCKING NOT COMPRESSED"); |
| } finally { |
| shutdownAndCloseConn(); |
| } |
| |
| } |
| |
| /** |
| * Test that correct DB names are generated when user supplies just a |
| * directory. |
| * |
| * N.b. This test may not work right if tests are run at midnight. |
| * This limitation will be removed once we can update the FilenameFilters |
| * with Java 4's java.util.regex. |
| */ |
| public void testAutoNaming() |
| throws SQLException, IOException, TarMalformatException { |
| |
| boolean caught; |
| int fileCount; |
| try { |
| setupConn("db1"); |
| conn.createStatement().executeUpdate("INSERT INTO t VALUES(2)"); |
| conn.commit(); |
| |
| fileCount = baseDir.listFiles(autoTarFilenameFilter).length; |
| if (fileCount != 0) |
| throw new IllegalStateException(Integer.toString(fileCount) |
| + " auto-tar files exist in baseDir '" |
| + baseDir.getAbsolutePath() |
| + "' before starting testAutoNaming"); |
| fileCount = baseDir.listFiles(autoTarGzFilenameFilter).length; |
| if (fileCount != 0) |
| throw new IllegalStateException(Integer.toString(fileCount) |
| + " auto-tar.gz files exist in baseDir '" |
| + baseDir.getAbsolutePath() |
| + "' before starting testAutoNaming"); |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/' BLOCKING NOT COMPRESSED"); |
| fileCount = baseDir.listFiles(autoTarFilenameFilter).length; |
| if (fileCount != 1) |
| fail(Integer.toString(fileCount) |
| + " auto-tar files exist in baseDir '" |
| + baseDir.getAbsolutePath() |
| + "' after writing a non-compressed backup"); |
| fileCount = baseDir.listFiles(autoTarGzFilenameFilter).length; |
| if (fileCount != 0) |
| fail(Integer.toString(fileCount) |
| + " auto-tar.gz files exist in baseDir '" |
| + baseDir.getAbsolutePath() |
| + "' after writing a non-compressed backup"); |
| conn.createStatement().executeUpdate("BACKUP DATABASE TO '" |
| + baseDir.getAbsolutePath() |
| + "/' BLOCKING COMPRESSED"); |
| fileCount = baseDir.listFiles(autoTarFilenameFilter).length; |
| if (fileCount != 1) |
| fail(Integer.toString(fileCount) |
| + " auto-tar files exist in baseDir '" |
| + baseDir.getAbsolutePath() |
| + "' after writing both backups"); |
| fileCount = baseDir.listFiles(autoTarGzFilenameFilter).length; |
| if (fileCount != 1) |
| fail(Integer.toString(fileCount) |
| + " auto-tar.gz files exist in baseDir '" |
| + baseDir.getAbsolutePath() |
| + "' after writing a compressed backup"); |
| } finally { |
| shutdownAndCloseConn(); |
| } |
| |
| } |
| static public Test suite() throws IOException, SQLException { |
| |
| TestSuite newSuite = new TestSuite(); |
| |
| newSuite.addTest(new TestDbBackup("testSanity")); |
| newSuite.addTest(new TestDbBackup("testBasicBackup")); |
| newSuite.addTest(new TestDbBackup("testMainAlreadyOpen")); |
| newSuite.addTest(new TestDbBackup("testGzip")); |
| newSuite.addTest(new TestDbBackup("testOnlineBackup")); |
| newSuite.addTest(new TestDbBackup("testTarFileNames")); |
| newSuite.addTest(new TestDbBackup("testAutoNaming")); |
| |
| return newSuite; |
| } |
| |
| private String autoMiddlingString = "-" |
| + new SimpleDateFormat("yyyyMMdd").format(new java.util.Date()) |
| + 'T'; |
| |
| FilenameFilter autoTarFilenameFilter = new FilenameFilter() { |
| private String suffixFormat = "-yyyyMMddTHHmmss.tar"; |
| public boolean accept(File dir, String name) { |
| if (name.length() < suffixFormat.length() + 1) { |
| // Require variable name length >= 1 char |
| return false; |
| } |
| int suffixPos = name.length() - suffixFormat.length(); |
| // Would like to use Java 1.4's java.util.regex here. |
| return name.endsWith(".tar") |
| && name.substring(suffixPos, |
| suffixPos + autoMiddlingString.length()) |
| .equals(autoMiddlingString); |
| } |
| }; |
| |
| FilenameFilter autoTarGzFilenameFilter = new FilenameFilter() { |
| private String suffixFormat = "-yyyyMMddTHHmmss.tar.gz"; |
| public boolean accept(File dir, String name) { |
| if (name.length() < suffixFormat.length() + 1) { |
| // Require variable name length >= 1 char |
| return false; |
| } |
| int suffixPos = name.length() - suffixFormat.length(); |
| // Would like to use Java 1.4's java.util.regex here. |
| return name.endsWith(".tar.gz") |
| && name.substring(suffixPos, |
| suffixPos + autoMiddlingString.length()) |
| .equals(autoMiddlingString); |
| } |
| }; |
| } |
