// Sanity checks
sanity = new SanityChecks();
logger.info("Checking sanity...");
try {
    sanity.doBasicChecks();
    logger.info("It all looks sane.");
}
catch( final Exception ex){
    logger.error("Something is wrong, we are not sane.  Aborting...", ex);
    stop();
}

package nz.co.great_ape.tempusFugit;

import com.almworks.sqlite4java.SQLite;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * Checks to see if all is ok for standard usage of tempusFugit.
 *
 * Checks for valid paths, existing database etc, if not assumes that
 * this is the first time tempusFugit has been run for this user and
 * tries to set up the basic files and data.
 *
 * @author Rob Brown-Bayliss
 *         Created on 2/11/14
 */
public class SanityChecks {


    public static final Logger logger = LoggerFactory.getLogger(AppConsts.LOGGER_NAME);

    public SanityChecks() {
        // todo
        // todo
        SQLite.setLibraryPath(AppConsts.HOME_DIR);   // TODO:  Why is this required?  can we not place the native libs somewhere else or in the jar?
        // todo
        // todo
    }

    /**
     * Performs basic checks to see if it is ok to run the app.  If not it will attempt to
     * set up for first time use.
     *
     * @return true if all is ok
     */
    public boolean doBasicChecks() {
        logger.info("Starting basic checks...");
        if (!HomeDirExists()) {
            return false;
        }
        if (!DatabaseExists()) {
            logger.info("Trying to create a new database.");
            DatabaseUpgrade dug = new DatabaseUpgrade();
            if (!dug.upGrade()) {
                return false;
            }
            logger.info("Created a new database.");
            // At this point a usable database should exist and it should be current
        }
        if (!DatabaseVersionCorrect()) {
//          //  If the database is old we will upgrade it to the current version.
//          DatabaseUpgrade dug = new DatabaseUpgrade();
//          if (!dug.upGrade()) {
//              return false;
//          }
            logger.info("is this it?.");
        }
        //  At this point all basic checks have passed and we are good to go...
        logger.info("Basic checks are complete.  All is good in the universe...");
        return true;
    }

    /**
     * Checks if the app home directory exists, if not it tries to create it.
     *
     * @return true if exists or was able to create the directory
     */
    private boolean HomeDirExists() {
        if (!Files.isDirectory(Paths.get(AppConsts.HOME_DIR))) {
            try {
                Files.createDirectory(Paths.get(AppConsts.HOME_DIR));
            }
            catch (IOException io) {
                logger.error("The directory " + AppConsts.HOME_DIR + " does not exist and could not be created.  This is not the best but we can survive.", io);
                return false;
            }
        }
        logger.info("The directory " + AppConsts.HOME_DIR + " exists.  This is good.");
        return true;
    }

    /**
     * Checks if the SQLite database exists, if not it tries to create it.
     * or was able to create the database
     *
     * @return true if the database exists
     */
    private boolean DatabaseExists() {
        if (Files.notExists(Paths.get(AppConsts.TF_DATABASE))) {
            logger.error("The database " + AppConsts.TF_DATABASE + " does not exist.  This is bad.");
            return false;
        }
        logger.info("The database " + AppConsts.TF_DATABASE + " exists.  This is good.");
        return true;
    }

    /**
     * Checks if the SQLite database is correct for this version.
     *
     * @return true if correct version
     */
    private boolean DatabaseVersionCorrect() {
        Integer expectedVersion = AppConsts.TF_DATABASE_VERSION;
        logger.info("Checking the database version is correct.  Looking for version "+ expectedVersion + "." );
        DatabaseUpgrade dug = new DatabaseUpgrade();
        logger.info("Checking the database version is correct.  Looking for version "+ expectedVersion + "." );
        Integer currentVersion = dug.getVersion();
        if (currentVersion < expectedVersion) {
            logger.info("Expected version " + expectedVersion + ", but database is version " + currentVersion + ".  This is bad.");
            return false;
        }
        logger.info("The database version is correct.  This is good.");
        return true;
    }

}

package nz.co.great_ape.tempusFugit;

import com.almworks.sqlite4java.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * Setup the database for current version tempusFugit.  This will upgrade an
 * existing database or create a new empty database if required.
 *
 * @author Rob Brown-Bayliss
 *         Created on 4/11/14
 */
public class
        DatabaseUpgrade {

    public static final Logger logger = LoggerFactory.getLogger(AppConsts.LOGGER_NAME);

    private SQLiteConnection dbConn = null;
    private SQLiteQueue      sQueue = null;
    private int currentVersion;

    public DatabaseUpgrade() {

    }

    /**
     * Attempts to upgrade the existing database to the current version, or if
     * there is no existing database then create one suitable for the current app version.
     *
     * @return true if there is a current and usable database
     */
    public boolean upGrade() {
        logger.info("    Started an upgrade on the database, if the database does not exist it will be created at the current version, ");
        logger.info("    if it exists but is an older version it will be upgraded to the current version.");
        if (openDatabase()) {
            currentVersion = getVersion();
            if (currentVersion == AppConsts.FAIL) {
                logger.info("Database version is unknown.  The file will be deleted and a new database created.  We can survive this.");
                // TODO:  Ask user if we should delete the old one or make a backup?
                closeDatabase();
                deleteDatabase();
                openDatabase();
            }
            if (currentVersion != AppConsts.TF_DATABASE_VERSION) {
                logger.info("Current Database version is " + currentVersion);
                // TODO:  Backup current database.
                if (currentVersion < 1) {
                    if (!makeVersionOne()) {
                        logger.error("Unable to upgrade the database.  This is VERY bad.");
                        return false;
                    }
                }
                currentVersion = 1;
            }
            closeDatabase();  // good practice
        }
        logger.info("The database is the current version.  This is good.");
        return true;
    }

    /**
     * Turns a blank SQLite database into a tempusFugit version 1 database by
     * adding the required tables and data.
     */
    private boolean makeVersionOne() {
        logger.info("Attempting to upgrade to version 1.");
        String CT_SQL = "CREATE TABLE IF NOT EXISTS dbVersion (id INTEGER PRIMARY KEY AUTOINCREMENT, version INTEGER NOT NULL UNIQUE, ";
        CT_SQL = CT_SQL + "upgraded INTEGER(4) NOT NULL DEFAULT (strftime('%s','now'))); ";
        String IN_SQL = "INSERT INTO dbVersion(version) values (1); ";
        try {
            execSQL("BEGIN TRANSACTION; ");
            execSQL(CT_SQL);  // create the table
            execSQL(IN_SQL);  // insert the record
            execSQL("COMMIT; ");
        }
        catch (Exception ex) {
            logger.error("Attempted upgrade of " + AppConsts.TF_DATABASE + " to version 1 has failed.  This is VERY bad.", ex);
            return false;
        }
        logger.info("The database has been upgraded to version 1.  This is good.");
        return true;
    }

    private Integer execSQL(String SQL) {
        return sQueue.execute(new SQLiteJob<Integer>() {
            protected Integer job(SQLiteConnection con) throws SQLiteException {
                SQLiteStatement st = null;
                try {
                    st = con.prepare(SQL);
                    st.step();
                    return AppConsts.SUCCESS;
                }
                catch (Exception ex) {
                    logger.error("Tried to execute SQL: " + SQL, ex);
                    return AppConsts.FAIL;
                }
                finally {
                    if (st != null) {
                        st.dispose();
                    }
                }
            }
        }).complete();
    }

    /**
     * Gets the current database version
     *
     * @return version as an int
     */
    public int getVersion() {
        return sQueue.execute(new SQLiteJob<Integer>() {
            protected Integer job(SQLiteConnection con) throws SQLiteException {
                SQLiteStatement st = null;
                try {
                    st = con.prepare("SELECT version, upgraded FROM dbVersion ORDER BY upgraded DESC LIMIT 1;");
                    st.step();
                    return st.columnInt(0);
                }
                catch (Exception ex) {
                    logger.error("The database version of " + AppConsts.TF_DATABASE + " is unknown.  This is bad.", ex);
                    return AppConsts.FAIL;
                }
                finally {
                    if (st != null) {
                        st.dispose();
                    }
                }
            }
        }).complete();
    }

    /**
     * Opens an existing SQLite database or creates a new blank database
     * if none exists.
     *
     * @return false if there is a problem.  // TODO: Is it possible to have a problem?
     */
    private boolean openDatabase() {
        try {
            dbConn = new SQLiteConnection(new File(AppConsts.TF_DATABASE));
            dbConn.open(true);
            sQueue = new SQLiteQueue(new File(AppConsts.TF_DATABASE));
            sQueue.start();
            return true;
        }
        catch (Exception ex) {
            logger.error("The database " + AppConsts.TF_DATABASE + " could not be opened or created.  This is VERY bad.", ex);
            return false;
        }
    }

    /**
     * Closes an open database.
     *
     * @return false if there is a problem.  // TODO: Is it possible to have a problem?
     */
    private boolean closeDatabase() {
        try {
            if (dbConn != null) {
                dbConn.dispose();
            }
            return true;
        }
        catch (Exception ex) {
            logger.error("The database " + AppConsts.TF_DATABASE + " could not be closed.", ex);
            return false;
        }
    }

    /**
     * Deletes an existing database.
     *
     * @return false if there is a problem.  // TODO: Is it possible to have a problem?
     */
    private boolean deleteDatabase() {
        try {
            Files.delete(Paths.get(AppConsts.TF_DATABASE));
            logger.info("The database " + AppConsts.TF_DATABASE + " has been deleted.");
            return true;
        }
        catch (Exception ex) {
            logger.error("The database " + AppConsts.TF_DATABASE + " could not be deleted.", ex);
            return false;
        }
    }
}


Plus the constants:

package nz.co.great_ape.tempusFugit;

/**
 * Constants used by tempusFugit
 *
 * @author Rob Brown-Bayliss
 *         Created on 31/10/14
 */
public class AppConsts {

    // Application
    public static final String APP_NAME       = "Tempus Fugit";
    public static final String VERSION_NUMBER = "0.0.1";

    // Debug Mode On-Off
    public static final boolean DEBUG_MODE = true;

    // Data files and paths
    public static final String FS        = System.getProperty("file.separator");
    public static final String HOME_DIR  = System.getProperty("user.home") + FS + ".tempusFugit";  // This is the tempusFugit home, not the users home.
    public static final String USER_NAME = System.getProperty("user.name");

    public static final String LOGGER_NAME = "nz.co.great_ape.tempusFugit";
    public static final String LOG_FILE    = HOME_DIR + FS + "tempusFugit.log";

    // Database
    public static final String TF_DATABASE = HOME_DIR + FS + "tfData.sql";
    public static final int TF_DATABASE_VERSION = 1;  //  This is the current version of the database

    // Error codes
    public static final int UNKNOWN = -1;
    public static final int FAIL    = 0;
    public static final int SUCCESS = 1;

}