Allow sql connection parallelity

Signed-off-by: Lixfel <agga-games@gmx.de>

src/de/steamwar/bungeecore/BungeeCore.java

@@ -272,12 +272,6 @@ public class BungeeCore extends Plugin {
         Persistent.setChatPrefix(CHAT_PREFIX);
         Persistent.setLobbyServer(LOBBY_SERVER);
 
-        Statement.connect(
-                config.getString("db.url"),
-                config.getString("db.username"),
-                config.getString("db.password")
-        );
-
         if (config.contains("discord")) {
             SteamwarDiscordBotConfig.loadConfig(config.getSection("discord"));
         }

src/de/steamwar/bungeecore/ErrorLogger.java

@@ -20,7 +20,6 @@
 package de.steamwar.bungeecore;
 
 import de.steamwar.bungeecore.sql.SWException;
-import de.steamwar.bungeecore.sql.Statement;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
@@ -63,7 +62,7 @@ public class ErrorLogger extends Handler {
                 SWException.log("Bungee", "DDOS", ddosRate + "");
             }
             return;
-        } else if (!Statement.connectionStable()) {
+        } else if (stacktrace.contains("ErrorLogger")) {
             return;
         }
 

src/de/steamwar/bungeecore/sql/Statement.java

@@ -21,128 +21,167 @@ package de.steamwar.bungeecore.sql;
 
 import de.steamwar.bungeecore.BungeeCore;
 import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.config.Configuration;
+import net.md_5.bungee.config.ConfigurationProvider;
+import net.md_5.bungee.config.YamlConfiguration;
 
+import java.io.File;
+import java.io.IOException;
 import java.sql.*;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.List;
 import java.util.logging.Level;
+import java.util.logging.Logger;
 
 public class Statement implements AutoCloseable {
+
+    private static final Logger logger = BungeeCore.get().getLogger();
+
     private static final List<Statement> statements = new ArrayList<>();
+    private static final Deque<Connection> connections = new ArrayDeque<>();
 
-    private static Connection con;
+    private static final String URL;
-    private static String url;
+    private static final String USER;
-    private static String user;
+    private static final String PASSWORD;
-    private static String password;
 
-    public static void connect(String url, String user, String password) {
+    static {
-        Statement.url = url;
+        File file = new File(BungeeCore.get().getDataFolder(), "MySQL.yml");
-        Statement.user = user;
+        Configuration config;
-        Statement.password = password;
         try {
-            con = DriverManager.getConnection(url + "?autoReconnect=true&useServerPrepStmts=true", user, password);
+            config = ConfigurationProvider.getProvider(YamlConfiguration.class).load(file);
-        } catch (SQLException e) {
+        } catch (IOException e) {
             ProxyServer.getInstance().stop();
-            throw new SecurityException("Could not start SQL-Connection", e);
+            throw new SecurityException("", e);
-        }
         }
 
-    private static void reset() {
+        URL = "jdbc:mysql://" + config.getString("HOST") + ":" + config.getString("PORT") + "/" + config.getString("DATABASE");
-        closeAll();
+        USER = config.getString("USER");
-        connect(url, user, password);
+        PASSWORD = config.getString("PASSWORD");
-        try {
-            for (Statement statement : statements) {
-                statement.init();
-            }
-        } catch (SQLException e) {
-            throw new SecurityException("Could not reprepare SQL statements", e);
-        }
-    }
-
-    @Override
-    public void close() {
-        try {
-            st.close();
-        } catch (SQLException e) {
-            BungeeCore.get().getLogger().log(Level.INFO, "Could not close statement", e);
-        }
-        statements.remove(this);
     }
 
     public static void closeAll() {
+        synchronized (connections) {
+            for(Connection connection : connections) {
+                try {
                     synchronized (statements) {
-            for (Statement statement : statements) {
+                        statements.forEach(statement -> statement.close(connection));
-                try {
+                    }
-                    statement.st.close();
+                    connection.close();
                 } catch (SQLException e) {
-                    BungeeCore.get().getLogger().log(Level.INFO, "Could not close statement", e);
+                    logger.log(Level.INFO, "Could not close SQL connection", e);
                 }
             }
-
+            connections.clear();
-            try {
-                con.close();
-            } catch (SQLException e) {
-                BungeeCore.get().getLogger().log(Level.INFO, "Could not close SQL connection", e);
-            }
-        }
-    }
-
-    public static boolean connectionStable() {
-        try {
-            return !con.isClosed();
-        } catch (SQLException e) {
-            return false;
         }
     }
 
     private final String sql;
-    private PreparedStatement st;
+    private final Map<Connection, PreparedStatement> cachedStatements = new HashMap<>();
 
     public Statement(String sql) {
         this.sql = sql;
+        synchronized (statements) {
             statements.add(this);
-        try {
-            init();
-        } catch (SQLException e) {
-            throw new SecurityException("Could not init SQL statement", e);
         }
     }
 
-    private void init() throws SQLException {
-        st = con.prepareStatement(sql);
-    }
-
     public <T> T select(ResultSetUser<T> user, Object... objects) {
-        synchronized (statements) {
+        return withConnection(st -> {
-            return prepare(() -> {
             ResultSet rs = st.executeQuery();
             T result = user.use(rs);
             rs.close();
             return result;
         }, objects);
     }
-    }
 
     public void update(Object... objects) {
-        synchronized (statements) {
+        withConnection(PreparedStatement::executeUpdate, objects);
-            prepare(st::executeUpdate, objects);
-        }
     }
 
-    private <T> T prepare(SQLRunnable<T> runnable, Object... objects) {
+    private <T> T withConnection(SQLRunnable<T> runnable, Object... objects) {
+        Connection connection = aquireConnection();
+
+        T result;
         try {
-            setObjects(objects);
+            result = tryWithConnection(connection, runnable, objects);
-            return runnable.run();
         } catch (SQLException e) {
-            reset();
+            closeConnection(connection);
-            throw new SecurityException("Could not execute SQL statement", e);
+            connection = aquireConnection();
+            try {
+                result = tryWithConnection(connection, runnable, objects);
+            } catch (SQLException ex) {
+                closeConnection(connection);
+                throw new SecurityException("Could not execute statement", ex);
             }
         }
 
-    private void setObjects(Object... objects) throws SQLException {
+        synchronized (connections) {
+            connections.push(connection);
+        }
+
+        return result;
+    }
+
+    private <T> T tryWithConnection(Connection connection, SQLRunnable<T> runnable, Object... objects) throws SQLException {
+        PreparedStatement st = cachedStatements.get(connection);
+        if(st == null) {
+            st = connection.prepareStatement(sql);
+            cachedStatements.put(connection, st);
+        }
+
         for (int i = 0; i < objects.length; i++) {
             st.setObject(i + 1, objects[i]);
         }
+
+        return runnable.run(st);
+    }
+
+    @Override
+    public void close() {
+        cachedStatements.values().forEach(st -> closeStatement(st, false));
+        cachedStatements.clear();
+        synchronized (statements) {
+            statements.remove(this);
+        }
+    }
+
+    private void close(Connection connection) {
+        PreparedStatement st = cachedStatements.remove(connection);
+        if(st != null)
+            closeStatement(st, true);
+    }
+
+    private static Connection aquireConnection() {
+        synchronized (connections) {
+            if(!connections.isEmpty())
+                return connections.pop();
+        }
+        try {
+            return DriverManager.getConnection(URL + "?autoReconnect=true&useServerPrepStmts=true", USER, PASSWORD);
+        } catch (SQLException e) {
+            throw new SecurityException("Could not open connection", e);
+        }
+    }
+
+    private static void closeConnection(Connection connection) {
+        synchronized (statements) {
+            for (Statement statement : statements) {
+                statement.close(connection);
+            }
+        }
+        try {
+            connection.close();
+        } catch (SQLException e) {
+            logger.log(Level.INFO, "Could not close connection", e);
+        }
+    }
+
+    private static void closeStatement(PreparedStatement st, boolean silent) {
+        try {
+            st.close();
+        } catch (SQLException e) {
+            if(!silent)
+                logger.log(Level.INFO, "Could not close statement", e);
+        }
     }
 
     public interface ResultSetUser<T> {
@@ -150,6 +189,6 @@ public class Statement implements AutoCloseable {
     }
 
     private interface SQLRunnable<T> {
-        T run() throws SQLException;
+        T run(PreparedStatement st) throws SQLException;
     }
 }