Application: gvSIG desktop » gvSIG projections

/*

 * Geotools 2 - OpenSource mapping toolkit

 * (C) 2005, Geotools Project Managment Committee (PMC)

 *

 *    This library is free software; you can redistribute it and/or

 *    modify it under the terms of the GNU Lesser General Public

 *    License as published by the Free Software Foundation; either

 *    version 2.1 of the License, or (at your option) any later version.

 *

 *    This library is distributed in the hope that it will be useful,

 *    but WITHOUT ANY WARRANTY; without even the implied warranty of

 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *    Lesser General Public License for more details.

 *

 *    You should have received a copy of the GNU Lesser General Public

 *    License along with this library; if not, write to the Free Software

 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package es.idr.teledeteccion.connection.epsg;

// J2SE dependencies

import java.awt.AWTEvent;

import java.awt.EventQueue;

import java.awt.SecondaryLoop;

import java.awt.Toolkit;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.lang.management.ManagementFactory;

import java.nio.channels.FileChannel;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.SQLFeatureNotSupportedException;

import java.sql.Statement;

import java.util.Date;

import java.util.logging.Level;

import javax.swing.SwingUtilities;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableBoolean;

import org.geotools.referencing.factory.AbstractAuthorityFactory;

import org.geotools.referencing.factory.FactoryGroup;

import org.geotools.referencing.factory.epsg.DataSource;

import org.geotools.referencing.factory.epsg.FactoryUsingSQL;

import org.gvsig.crs.CrsFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

// HSQL dependencies

import org.hsqldb.jdbc.jdbcDataSource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Connection to the EPSG database in HSQL database engine format using JDBC.

 * The EPSG database can be downloaded from <A

 * HREF="http://www.epsg.org">http://www.epsg.org</A>. The SQL scripts (modified

 * for the HSQL syntax as <A HREF="doc-files/HSQL.html">explained here</A>) are

 * bundled into this plugin. The database version is given in the

 * {@linkplain org.opengis.metadata.citation.Citation#getEdition edition attribute}

 * of the

 * {@linkplain org.opengis.referencing.AuthorityFactory#getAuthority authority}.

 * The HSQL database is read only.

 * <P>

 * <H3>Implementation note</H3>

 * The SQL scripts are executed the first time a connection is required. The

 * database is then created as cached tables ({@code HSQL.properties} and

 * {@code HSQL.data} files) in a temporary directory. Future connections to the

 * EPSG database while reuse the cached tables, if available. Otherwise, the

 * scripts will be executed again in order to recreate them.

 *

 * @version $Id: HSQLDataSource.java 14624 2005-06-29 02:19:08Z desruisseaux $

 * @author Martin Desruisseaux

 * @author Didier Richard

 *

 * @since 2.2

 */

public class HSQLDataSource extends jdbcDataSource implements DataSource {

    // 20090518 cmartinez: Use a different tmp dir for each geotools instance

    private static File tmpDir = null;

    private static final Logger logger = LoggerFactory.getLogger(HSQLDataSource.class);

    /**

     * Creates a new instance of this data source

     */

    public HSQLDataSource() {

        File directory = getGtTmpDir();

        if ( directory.isDirectory() || directory.mkdir() ) {

            directory = new File(directory, "Cached databases");

            if ( directory.isDirectory() || directory.mkdir() ) {

                /*

                 * Constructs the full path to the HSQL database. Note: we do not use

                 * File.toURI() because HSQL doesn't seem to expect an encoded URL

                 * (e.g. "%20" instead of spaces).

                 */

                final StringBuffer url = new StringBuffer("jdbc:hsqldb:file:");

                final String path = directory.getAbsolutePath().replace(File.separatorChar, '/');

                if ( path.length() == 0 || path.charAt(0) != '/' ) {

                    url.append('/');

                }

                url.append(path);

                if ( url.charAt(url.length() - 1) != '/' ) {

                    url.append('/');

                }

                url.append("EPSG");

                setDatabase(url.toString());

            }

            /*

             * If the temporary directory do not exists or can't be created,

             * lets the 'database' attribute unset. If the user do not set it

             * explicitly (for example through JNDI), an exception will be thrown

             * when 'getConnection()' will be invoked.

             */

        }

        setUser("SA"); // System administrator. No password.

    }

    private File getGtTmpDir() {

        if ( tmpDir == null ) {

            tmpDir = new File(CrsFactory.getDataBaseFolder(), "temp-" + getProcessId());

            Runtime.getRuntime().addShutdownHook(new cleanOnShutdown(this));

        }

        return tmpDir;

    }

    private static String getProcessId() {

        String fallback = "time" + System.currentTimeMillis();

        // something like '<pid>@<hostname>', at least in SUN / Oracle JVMs

        final String jvmName = ManagementFactory.getRuntimeMXBean().getName();

        final int index = jvmName.indexOf('@');

        if ( index < 1 ) {

            // part before '@' empty (index = 0) / '@' not found (index = -1)

            return fallback;

        }

        try {

            return "pid" + Long.toString(Long.parseLong(jvmName.substring(0, index)));

        } catch (NumberFormatException e) {

            // ignore

        }

        return fallback;

    }

    public static class cleanOnShutdown extends Thread {

        private HSQLDataSource ds;

        public cleanOnShutdown(HSQLDataSource ds) {

            this.ds = ds;

        }

        public void run() {

            this.shutdown();

            this.delete();

        }

        private void delete() {

            File folder = HSQLDataSource.tmpDir;

            if ( folder == null ) {

                return;

            }

            try {

                logger.info("Deleting CRS temporary database folder (" + folder.getAbsolutePath() + ").");

                FileUtils.deleteDirectory(folder);

            } catch (IOException e) {

                logger.error("Can't delete CRS temporary database folder (" + folder + ".", e);

            }

        }

        private void shutdown() {

            try {

                logger.info("Shutdown the data-base.");

                Connection connection = this.ds.getConnection(false);

                final Statement statement = connection.createStatement();

                statement.execute("SHUTDOWN");

                statement.close();

                connection.close();

            } catch (Exception ex) {

                logger.error("Can't shutdown the database.", ex);

            }

        }

    }

    /**

     * Returns the priority for this data source. This priority is set to a

     * lower value than the {@linkplain AccessDataSource}'s one in order to give

     * the priority to the Access-backed database, if presents. Priorities are

     * set that way because:

     * <ul>

     * <li>The MS-Access format is the primary EPSG database format.</li>

     * <li>If a user downloads the MS-Access database himself, he probably wants

     * to use it.</li>

     * </ul>

     */

    public int getPriority() {

        return NORMAL_PRIORITY - 30;

    }

    /**

     * Returns {@code true} if the database contains data. This method returns

     * {@code false} if an empty EPSG database has been automatically created by

     * HSQL and not yet populated.

     */

    private static boolean dataExists(final Connection connection) throws SQLException {

        final ResultSet tables = connection.getMetaData().getTables(

                null, null, "EPSG_%", new String[]{"TABLE"});

        final boolean exists = tables.next();

        tables.close();

        return exists;

    }

    /**

     * Opens a connection to the database. If the cached tables are not

     * available, they will be created now from the SQL scripts bundled in this

     * plugin.

     */

    public Connection getConnection() throws SQLException {

        return getConnection(true);

    }

    public synchronized Connection getConnection(boolean initialize) throws SQLException {

        final String database = getDatabase();

        if ( StringUtils.isEmpty(database) ) {

            /*

             * The 'database' attribute is unset if the constructor has been unable

             * to locate the temporary directory, or to create the subdirectory.

             */

            throw new SQLException("Can't write to the temporary directory.");

        }

        Connection connection = super.getConnection();

        if ( initialize ) {

            initializeDatabase();

        }

        return connection;

    }

    public synchronized void initializeDatabase() throws SQLException {

        final Connection connection = super.getConnection();

        if ( dataExists(connection) ) {

            // Database already initialized

            return;

        }

        initializeDatabase2(connection);

    }

    private void initializeDatabase2(Connection connection) throws SQLException {

        /*

         * HSQL has created automatically an empty database. We need to populate it.

         * Executes the SQL scripts bundled in the JAR. In theory, each line contains

         * a full SQL statement. For this plugin however, we have compressed "INSERT

         * INTO" statements using Compactor class in this package.

         */

        Date t1 = new Date();

        logger.info("Creating temporary cached EPSG database in '"

                + getGtTmpDir().getAbsolutePath()

                + "' from '"

                + CrsFactory.getEpsgDatabaseFile()

                + "'."

        );

        final Statement statement = connection.createStatement();

        SimpleTaskStatus status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Creating EPSG DB");

        try {

            int lineCounter = 0;

            File f = CrsFactory.getEpsgDatabaseFile();

            status.setAutoremove(true);

            status.setRangeOfValues(0, f.length());

            FileInputStream sqlInputStream = new FileInputStream(f);

            FileChannel chanel = sqlInputStream.getChannel();

            final BufferedReader in = new BufferedReader(new InputStreamReader(

                    sqlInputStream, "ISO-8859-1"));

            StringBuffer insertStatement = null;

            String line;

            while ( (line = in.readLine()) != null ) {

                status.setCurValue(chanel.position());

                line = line.trim();

                if( line.startsWith("-- " ) ) {

                    continue;

                }

                final int length = line.length();

                if ( length != 0 ) {

                    if ( line.startsWith("INSERT INTO") ) {

                        /*

                         * We are about to insert many rows into a single table.

                         * The row values appear in next lines; the current line

                         * should stop right after the VALUES keyword.

                         */

                        insertStatement = new StringBuffer(line);

                        continue;

                    }

                    if ( insertStatement != null ) {

                        /*

                         * We are about to insert a row. Prepend the "INSERT INTO"

                         * statement and check if we will have more rows to insert

                         * after this one.

                         */

                        final int values = insertStatement.length();

                        insertStatement.append(line);

                        final boolean hasMore = (line.charAt(length - 1) == ',');

                        if ( hasMore ) {

                            insertStatement.setLength(insertStatement.length() - 1);

                        }

                        line = insertStatement.toString();

                        insertStatement.setLength(values);

                        if ( !hasMore ) {

                            insertStatement = null;

                        }

                    }

                    statement.execute(line);

                    lineCounter++;

                    if( (lineCounter % 100) == 0) {

                        Thread.yield();

                    }

                }

            }

            in.close();

            Date t2 = new Date();

            logger.info("Created temporary EPSG database in "+ (t2.getTime()-t1.getTime())+ "ms.");

        } catch (IOException exception) {

            throw new SQLException("Can't read the SQL script.", exception);

        } finally {

            status.terminate();

            statement.close();

            connection.close();

        }

    }

    /**

     * Open a connection and creates an

     * {@linkplain FactoryUsingSQL EPSG factory} for it.

     *

     * @param factories The low-level factories to use for CRS creation.

     * @return The EPSG factory using HSQLDB SQL syntax.

     * @throws SQLException if connection to the database failed.

     */

    public AbstractAuthorityFactory createFactory(final FactoryGroup factories) throws SQLException {

        return new FactoryUsingHSQL(factories, getConnection());

    }

    public java.util.logging.Logger getParentLogger()

            throws SQLFeatureNotSupportedException {

        // TODO Auto-generated method stub

        return null;

    }

    public boolean isWrapperFor(Class<?> iface) throws SQLException {

        // TODO Auto-generated method stub

        return false;

    }

    public <T> T unwrap(Class<T> iface) throws SQLException {

        // TODO Auto-generated method stub

        return null;

    }

}