Add some SQL-Storage settings and tweak some connection-pool settings

Author: TBlueF

BlueMapCommon/src/main/java/de/bluecolored/bluemap/common/config/storage/SQLConfig.java

@@ -32,6 +32,8 @@
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Optional;
 
 @SuppressWarnings({"FieldMayBeFinal", "FieldCanBeLocal"})
@@ -42,10 +44,14 @@ public class SQLConfig extends StorageConfig implements SQLStorageSettings {
     @DebugDump private String driverClass = null;
     private String connectionUrl = "jdbc:mysql://localhost/bluemap?permitMysqlScheme";
 
+    private Map<String, String> connectionProperties = new HashMap<>();
+
     @DebugDump private Compression compression = Compression.GZIP;
 
     @DebugDump private transient URL driverJarURL = null;
 
+    @DebugDump private int maxConnections = -1;
+
     @Override
     public Optional<URL> getDriverJar() throws MalformedURLException {
         if (driverJar == null) return Optional.empty();
@@ -67,6 +73,16 @@ public String getConnectionUrl() {
         return connectionUrl;
     }
 
+    @Override
+    public Map<String, String> getConnectionProperties() {
+        return connectionProperties;
+    }
+
+    @Override
+    public int getMaxConnections() {
+        return maxConnections;
+    }
+
     @Override
     public Compression getCompression() {
         return compression;

BlueMapCommon/src/main/resources/de/bluecolored/bluemap/config/storages/sql.conf

@@ -11,10 +11,23 @@ storage-type: SQL
 # The JDBC-Connection URL that is used to connect to the database.
 # The format for this url is usually something like: jdbc:[driver]://[host]:[port]/[database]?user=[user]&password=[password]
 # The exact format of the url is determined by the JDBC-Driver you are using.
+# (You might need to URL-encode the user and password if it has special characters)
 connection-url: "jdbc:mysql://localhost/bluemap?permitMysqlScheme"
 #connection-url: "jdbc:mariadb://localhost/bluemap?user=root"
 #connection-url: "jdbc:mysql://localhost:3306/bluemap?user=root&password=password"
 
+# You can set any additional (JDBC-Driver-specific) properties here
+# (if you have user/password in your connection-url, you don't need them here, and vice versa)
+connection-properties: {
+    #user: "root",
+    #password: ""
+}
+
+# The maximum number of connections to the database that are allowed to be open at the same time.
+# A negative number means unlimited.
+# Default is: -1
+max-connections: -1
+
 # This can be used to load a custom jdbc-driver from a .jar file.
 # E.g. if your runtime-environment is not already providing the sql-driver you need,
 # you could download the MariaDB JDBC-Connector from https://mariadb.com/downloads/connectors/connectors-data-access/java8-connector/

BlueMapCore/src/main/java/de/bluecolored/bluemap/core/storage/sql/SQLStorage.java

@@ -45,10 +45,8 @@
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.sql.*;
-import java.util.NoSuchElementException;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Properties;
+import java.time.Duration;
+import java.util.*;
 import java.util.concurrent.CompletionException;
 
 public class SQLStorage extends Storage {
@@ -81,13 +79,13 @@ public SQLStorage(SQLStorageSettings config) throws MalformedURLException, SQLDr
                                 "Instead you'll need to add your driver-jar to the classpath when starting your server," +
                                 "e.g. using the '-classpath' command-line argument", ex);*/
                     }
-                    this.dataSource = createDataSource(config.getConnectionUrl(), driver);
+                    this.dataSource = createDataSource(config.getConnectionUrl(), config.getConnectionProperties(), config.getMaxConnections(), driver);
                 } else {
                     Class.forName(config.getDriverClass().get());
-                    this.dataSource = createDataSource(config.getConnectionUrl());
+                    this.dataSource = createDataSource(config.getConnectionUrl(), config.getConnectionProperties(), config.getMaxConnections());
                 }
             } else {
-                this.dataSource = createDataSource(config.getConnectionUrl());
+                this.dataSource = createDataSource(config.getConnectionUrl(), config.getConnectionProperties(), config.getMaxConnections());
             }
         } catch (ClassNotFoundException ex) {
             throw new SQLDriverException("The driver-class does not exist.", ex);
@@ -98,16 +96,6 @@ public SQLStorage(SQLStorageSettings config) throws MalformedURLException, SQLDr
         this.hiresCompression = config.getCompression();
     }
 
-    public SQLStorage(String dbUrl, Compression compression) {
-        this.dataSource = createDataSource(dbUrl);
-        this.hiresCompression = compression;
-    }
-
-    public SQLStorage(DataSource dataSource, Compression compression) {
-        this.dataSource = dataSource;
-        this.hiresCompression = compression;
-    }
-
     @Override
     public OutputStream writeMapTile(String mapId, int lod, Vector2i tile) throws IOException {
         Compression compression = lod == 0 ? this.hiresCompression : Compression.NONE;
@@ -532,9 +520,8 @@ private <R> R recoveringConnection(ConnectionFunction<R> action, int tries) thro
         try {
             for (int i = 0; i < tries; i++) {
                 try (Connection connection = dataSource.getConnection()) {
-                    R result;
                     try {
-                        result = action.apply(connection);
+                        R result = action.apply(connection);
                         connection.commit();
                         return result;
                     } catch (SQLRecoverableException ex) {
@@ -621,21 +608,27 @@ private int lookupFK(String table, String idField, String valueField, String val
         }, 2);
     }
 
-    private DataSource createDataSource(String dbUrl) {
-        return createDataSource(new DriverManagerConnectionFactory(dbUrl));
+    private DataSource createDataSource(String dbUrl, Map<String, String> properties, int maxPoolSize) {
+        Properties props = new Properties();
+        props.putAll(properties);
+
+        return createDataSource(new DriverManagerConnectionFactory(dbUrl, props), maxPoolSize);
     }
 
-    private DataSource createDataSource(String dbUrl, Driver driver) {
+    private DataSource createDataSource(String dbUrl, Map<String, String> properties, int maxPoolSize, Driver driver) {
+        Properties props = new Properties();
+        props.putAll(properties);
+
         ConnectionFactory connectionFactory = new DriverConnectionFactory(
                 driver,
                 dbUrl,
-                new Properties()
+                props
         );
 
-        return createDataSource(connectionFactory);
+        return createDataSource(connectionFactory, maxPoolSize);
     }
 
-    private DataSource createDataSource(ConnectionFactory connectionFactory) {
+    private DataSource createDataSource(ConnectionFactory connectionFactory, int maxPoolSize) {
         PoolableConnectionFactory poolableConnectionFactory =
                 new PoolableConnectionFactory(() -> {
                     Logger.global.logDebug("Creating new SQL-Connection...");
@@ -649,9 +642,14 @@ private DataSource createDataSource(ConnectionFactory connectionFactory) {
         poolableConnectionFactory.setFastFailValidation(true);
 
         GenericObjectPoolConfig<PoolableConnection> objectPoolConfig = new GenericObjectPoolConfig<>();
+        objectPoolConfig.setTestWhileIdle(true);
+        objectPoolConfig.setTimeBetweenEvictionRuns(Duration.ofSeconds(10));
+        objectPoolConfig.setNumTestsPerEvictionRun(3);
+        objectPoolConfig.setBlockWhenExhausted(true);
         objectPoolConfig.setMinIdle(1);
-        objectPoolConfig.setMaxIdle(Runtime.getRuntime().availableProcessors() * 2);
-        objectPoolConfig.setMaxTotal(-1);
+        objectPoolConfig.setMaxIdle(Runtime.getRuntime().availableProcessors());
+        objectPoolConfig.setMaxTotal(maxPoolSize);
+        objectPoolConfig.setMaxWaitMillis(Duration.ofSeconds(30).toMillis());
 
         ObjectPool<PoolableConnection> connectionPool =
                 new GenericObjectPool<>(poolableConnectionFactory, objectPoolConfig);

BlueMapCore/src/main/java/de/bluecolored/bluemap/core/storage/sql/SQLStorageSettings.java

@@ -4,6 +4,7 @@
 
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.Map;
 import java.util.Optional;
 
 public interface SQLStorageSettings {
@@ -14,6 +15,10 @@ public interface SQLStorageSettings {
 
     String getConnectionUrl();
 
+    Map<String, String> getConnectionProperties();
+
+    int getMaxConnections();
+
     Compression getCompression();
 
 }