Java tutorial
/* (c) 2016 Open Source Geospatial Foundation - all rights reserved * This code is licensed under the GPL 2.0 license, available at the root * application directory. */ package org.geogig.geoserver.config; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static org.geogig.geoserver.config.LogStore.PROP_DRIVER_CLASS; import static org.geogig.geoserver.config.LogStore.PROP_ENABLED; import static org.geogig.geoserver.config.LogStore.PROP_MAX_CONNECTIONS; import static org.geogig.geoserver.config.LogStore.PROP_PASSWORD; import static org.geogig.geoserver.config.LogStore.PROP_RUN_SCRIPT; import static org.geogig.geoserver.config.LogStore.PROP_SCRIPT; import static org.geogig.geoserver.config.LogStore.PROP_URL; import static org.geogig.geoserver.config.LogStore.PROP_USER; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.StringReader; import java.io.Writer; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.net.URL; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.SQLFeatureNotSupportedException; import java.sql.Statement; import java.util.ArrayList; import java.util.List; import java.util.Properties; import java.util.logging.Logger; import javax.sql.DataSource; import org.geotools.util.logging.Logging; import com.google.common.base.Charsets; import com.google.common.base.Throwables; import com.google.common.io.CharStreams; import com.google.common.io.Resources; import com.google.common.reflect.Reflection; import com.zaxxer.hikari.HikariConfig; import com.zaxxer.hikari.HikariDataSource; /** * Helper class to create the default {@code <data-dir>/geogig/config/security/logstore.properties} * config file and the {@code <data-dir>/geogig/config/security/securitylogs.db} SQLite database * where to write the log entries to. * <p> * It also copies a couple sql init scripts for oher database engines to the same directory. */ class LogStoreInitializer { private static final Logger LOGGER = Logging.getLogger(LogStoreInitializer.class); static void dispose(DataSource dataSource) { if (dataSource instanceof HikariDataSource) { ((HikariDataSource) dataSource).close(); } else if (dataSource instanceof SingleConnectionDataSource) { try { ((SingleConnectionDataSource) dataSource).conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } static DataSource newDataSource(final Properties properties, final File configFile) { final String driverName = properties.getProperty(PROP_DRIVER_CLASS); checkNotNull(driverName, "driverName not provided in properties file %s", configFile); try { Class.forName(driverName); } catch (ClassNotFoundException e) { throw new IllegalArgumentException( String.format("JDBC Driver '%s' does not exist in the classpath", driverName)); } final String jdbcUrl = properties.getProperty(PROP_URL); checkArgument(jdbcUrl != null, "url not provided in properties file %s", configFile); final String username = properties.getProperty(PROP_USER); final String password = properties.getProperty(PROP_PASSWORD); final String maxConnectionsProp = properties.getProperty(PROP_MAX_CONNECTIONS); int maxConnections = 10; if (maxConnectionsProp != null) { try { maxConnections = Integer.parseInt(maxConnectionsProp); checkArgument(maxConnections > 0, "maxConnections must be an integer > 0: %s", maxConnections); } catch (NumberFormatException e) { throw new IllegalArgumentException("Can't parse maxConnections as an int: " + maxConnectionsProp, e); } } DataSource dataSource; if (jdbcUrl.startsWith("jdbc:sqlite")) { // sqlite must be used with a single connection shared among all threads Connection connection; try { connection = DriverManager.getConnection(jdbcUrl); } catch (SQLException e) { throw Throwables.propagate(e); } dataSource = new SingleConnectionDataSource(connection); } else { HikariConfig config = new HikariConfig(); config.setJdbcUrl(jdbcUrl); config.setUsername(username); config.setPassword(password); config.setMaximumPoolSize(maxConnections); dataSource = new HikariDataSource(config); } return dataSource; } static void createDefaultConfig(final File propertiesFile) throws IOException { final File configDirectory = propertiesFile.getParentFile(); final File dbFile = new File(configDirectory, "securitylogs.db"); final String driverClassName = "org.sqlite.JDBC"; final String jdbcUrl = "jdbc:sqlite:" + dbFile.getAbsolutePath(); createDefaultPropertiesFile(propertiesFile, driverClassName, jdbcUrl); } private static void createDefaultPropertiesFile(final File propertiesFile, final String driverClassName, final String jdbcUrl) { Properties props = new Properties(); props.setProperty(PROP_ENABLED, "true"); props.setProperty(PROP_DRIVER_CLASS, driverClassName); props.setProperty(PROP_URL, jdbcUrl); props.setProperty(PROP_USER, ""); props.setProperty(PROP_PASSWORD, ""); props.setProperty(PROP_MAX_CONNECTIONS, "1"); props.setProperty(PROP_SCRIPT, "sqlite.sql"); props.setProperty(PROP_RUN_SCRIPT, "true"); try { propertiesFile.createNewFile(); } catch (IOException e) { throw Throwables.propagate(e); } saveConfig(props, propertiesFile); } static void saveConfig(Properties props, File propertiesFile) { String comments = configComments(); try (Writer writer = new OutputStreamWriter(new FileOutputStream(propertiesFile), Charsets.UTF_8)) { props.store(writer, comments); } catch (IOException e) { throw Throwables.propagate(e); } } private static String configComments() { String comments = new StringBuilder("Connection information for the geogig security logs database.\n#")// .append("enabled true|false whether to enable security logging\n#").append(PROP_DRIVER_CLASS)// .append(": JDBC Driver class name\n#").append(PROP_URL)// .append(": JDBC URL for the connections\n#").append(PROP_USER)// .append(": database user name\n#")// .append(PROP_PASSWORD)// .append(": database user password\n#")// .append(PROP_MAX_CONNECTIONS)// .append(": max number of connections in the pool\n#")// .append(PROP_SCRIPT)// .append(": Database initialization DDL script file\n#")// .append(PROP_RUN_SCRIPT)// .append(": Boolean indicating whether to execute the init script. If true, and succeeded, its value will automatically be set to false afterwards\n#")// .append("If using SQLite, the ")// .append(PROP_MAX_CONNECTIONS)// .append(" option has no effect and a single connection is used among all threads.\n")// .append("If not using SQLite (for which the tables are created automatically), make sure to first run the\n#")// .append("appropriate DDL script on the database. Some sample ones accompany this file. There are\n#")// .append("more init scripts at https://github.com/qos-ch/logback/tree/master/logback-classic/src/main/resources/ch/qos/logback/classic/db/script")// .toString(); return comments; } static void copySampleInitSript(File configDirectory, String scriptName) throws IOException { File file = new File(configDirectory, scriptName); if (file.exists()) { return; } file.createNewFile(); try (OutputStream out = new FileOutputStream(file)) { Resources.copy(LogStoreInitializer.class.getResource(scriptName), out); } } static void runScript(DataSource ds, URL script) { List<String> statements = parseStatements(script); try { try (Connection connection = ds.getConnection()) { LOGGER.info("Running script " + script.getFile()); for (String sql : statements) { try (Statement st = connection.createStatement()) { LOGGER.fine(sql); st.execute(sql); } catch (SQLException e) { throw Throwables.propagate(e); } } } } catch (SQLException e) { throw Throwables.propagate(e); } } private static List<String> parseStatements(URL script) { List<String> lines; try { OutputStream to = new ByteArrayOutputStream(); Resources.copy(script, to); String scriptContents = to.toString(); lines = CharStreams.readLines(new StringReader(scriptContents)); } catch (IOException e) { throw Throwables.propagate(e); } List<String> statements = new ArrayList<String>(); StringBuilder sb = new StringBuilder(); for (String line : lines) { line = line.trim(); if (line.startsWith("#") || line.startsWith("-") || line.isEmpty()) { continue; } sb.append(line).append('\n'); if (line.endsWith(";")) { statements.add(sb.toString()); sb.setLength(0); } } return statements; } private static class SingleConnectionDataSource implements DataSource { private Connection conn; public SingleConnectionDataSource(Connection conn) { this.conn = Unclosable.proxyFor(conn); } @Override public PrintWriter getLogWriter() throws SQLException { return null; } @Override public void setLogWriter(PrintWriter out) throws SQLException { } @Override public void setLoginTimeout(int seconds) throws SQLException { } @Override public int getLoginTimeout() throws SQLException { return 0; } @Override public Logger getParentLogger() throws SQLFeatureNotSupportedException { return null; } @Override public <T> T unwrap(Class<T> iface) throws SQLException { return null; } @Override public boolean isWrapperFor(Class<?> iface) throws SQLException { return false; } @Override public Connection getConnection() throws SQLException { return conn; } @Override public Connection getConnection(String username, String password) throws SQLException { return conn; } } private static class Unclosable implements InvocationHandler { private Connection c; public Unclosable(Connection c) { this.c = c; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if ("close".equals(method.getName())) { return null; } return method.invoke(c, args); } public static Connection proxyFor(Connection c) { Connection proxy = Reflection.newProxy(Connection.class, new Unclosable(c)); return proxy; } } }