Upstream/AuthMeReloaded
1
0
Fork 0
mirror of https://github.com/AuthMe/AuthMeReloaded.git synced 2024-11-23 10:45:23 +01:00
Code Issues Projects Releases Wiki Activity

Change the MySQL Connection Pool to HikariCP, so fast !

Browse Source
This commit is contained in:
Xephi59 2015-07-31 03:31:17 +02:00
parent 28e56cc33e
commit d49b309301
5 changed files with 65 additions and 567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
pom.xml
View File

@ -90,6 +90,8 @@
<include>com.sun.mail:*</include>
<include>com.comphenix.attribute:*</include>
<include>org.mcstats.*:*</include>
<include>com.zaxxer:*</include>
<include>org.slf4j:*</include>
</includes>
</artifactSet>
<relocations>
@ -175,11 +177,27 @@
<!-- MySql Library -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.36</version>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.12</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>2.4.0</version>
<scope>compile</scope>
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- SQLite Library -->
<dependency>

12
src/main/java/fr/xephi/authme/AuthMe.java
View File

@ -251,7 +251,7 @@ public class AuthMe extends JavaPlugin {
}
if (Settings.getSessionTimeout == 0 && Settings.isSessionsEnabled) {
ConsoleLogger.showError("WARNING!!! You set session timeout to 0, this may cause security issues!");
ConsoleLogger.showError("WARNING!!! You set session timeout to 0, this may cause security issues!");
}
if (Settings.reloadSupport) {
@ -545,13 +545,17 @@ public class AuthMe extends JavaPlugin {
return;
ConsoleLogger.info("AutoPurging the Database: " + cleared.size() + " accounts removed!");
if (Settings.purgeEssentialsFile && this.ess != null)
dataManager.purgeEssentials(cleared); // name to UUID convertion needed with latest versions
dataManager.purgeEssentials(cleared); // name to UUID convertion
// needed with latest versions
if (Settings.purgePlayerDat)
dataManager.purgeDat(cleared); // name to UUID convertion needed with latest versions of MC
dataManager.purgeDat(cleared); // name to UUID convertion needed
// with latest versions of MC
if (Settings.purgeLimitedCreative)
dataManager.purgeLimitedCreative(cleared);
if (Settings.purgeAntiXray)
dataManager.purgeAntiXray(cleared); // IDK if it uses UUID or names... (Actually it purges only names!)
dataManager.purgeAntiXray(cleared); // IDK if it uses UUID or
// names... (Actually it purges
// only names!)
if (Settings.purgePermissions)
dataManager.purgePermissions(cleared, permission);
}

427
src/main/java/fr/xephi/authme/datasource/MiniConnectionPoolManager.java
View File

@ -1,427 +0,0 @@
// Copyright 2007-2013 Christian d'Heureuse, Inventec Informatik AG, Zurich,
// Switzerland
// www.source-code.biz, www.inventec.ch/chdh
//
// This module is multi-licensed and may be used under the terms
// of any of the following licenses:
//
// EPL, Eclipse Public License, http://www.eclipse.org/legal
// LGPL, GNU Lesser General Public License,
// http://www.gnu.org/licenses/lgpl.html
// MPL, Mozilla Public License 1.1, http://www.mozilla.org/MPL
//
// Please contact the author if you need another license.
// This module is provided "as is", without warranties of any kind.
package fr.xephi.authme.datasource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.LinkedList;
import javax.sql.ConnectionEvent;
import javax.sql.ConnectionEventListener;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
/**
* A lightweight standalone JDBC connection pool manager.
*
* <p>
* The public methods of this class are thread-safe.
*
* <p>
* Home page: <a
* href="http://www.source-code.biz/miniconnectionpoolmanager">www.
* source-code.biz/miniconnectionpoolmanager</a><br>
* Author: Christian d'Heureuse, Inventec Informatik AG, Zurich, Switzerland<br>
* Multi-licensed: EPL / LGPL / MPL.
*/
public class MiniConnectionPoolManager {
private ConnectionPoolDataSource dataSource;
private int maxConnections;
private long timeoutMs;
private PrintWriter logWriter;
private Semaphore semaphore;
private PoolConnectionEventListener poolConnectionEventListener;
// The following variables must only be accessed within synchronized blocks.
// @GuardedBy("this") could by used in the future.
private LinkedList<PooledConnection> recycledConnections; // list of
// inactive
// PooledConnections
private int activeConnections; // number of active (open) connections of
// this pool
private boolean isDisposed; // true if this connection pool has been
// disposed
private boolean doPurgeConnection; // flag to purge the connection currently
// beeing closed instead of recycling it
private PooledConnection connectionInTransition; // a PooledConnection which
// is currently within a
// PooledConnection.getConnection()
// call, or null
/**
* Thrown in {@link #getConnection()} or {@link #getValidConnection()} when
* no free connection becomes available within <code>timeout</code> seconds.
*/
public static class TimeoutException extends RuntimeException {
private static final long serialVersionUID = 1;
public TimeoutException() {
super("Timeout while waiting for a free database connection.");
}
public TimeoutException(String msg) {
super(msg);
}
}
/**
* Constructs a MiniConnectionPoolManager object with a timeout of 60
* seconds.
*
* @param dataSource
* the data source for the connections.
* @param maxConnections
* the maximum number of connections.
*/
public MiniConnectionPoolManager(ConnectionPoolDataSource dataSource,
int maxConnections) {
this(dataSource, maxConnections, 60);
}
/**
* Constructs a MiniConnectionPoolManager object.
*
* @param dataSource
* the data source for the connections.
* @param maxConnections
* the maximum number of connections.
* @param timeout
* the maximum time in seconds to wait for a free connection.
*/
public MiniConnectionPoolManager(ConnectionPoolDataSource dataSource,
int maxConnections, int timeout) {
this.dataSource = dataSource;
this.maxConnections = maxConnections;
this.timeoutMs = timeout * 1000L;
try {
logWriter = dataSource.getLogWriter();
} catch (SQLException e) {
}
if (maxConnections < 1) {
throw new IllegalArgumentException("Invalid maxConnections value.");
}
semaphore = new Semaphore(maxConnections, true);
recycledConnections = new LinkedList<PooledConnection>();
poolConnectionEventListener = new PoolConnectionEventListener();
}
/**
* Closes all unused pooled connections.
*/
public synchronized void dispose() throws SQLException {
if (isDisposed) {
return;
}
isDisposed = true;
SQLException e = null;
while (!recycledConnections.isEmpty()) {
PooledConnection pconn = recycledConnections.remove();
try {
pconn.close();
} catch (SQLException e2) {
if (e == null) {
e = e2;
}
}
}
if (e != null) {
throw e;
}
}
/**
* Retrieves a connection from the connection pool.
*
* <p>
* If <code>maxConnections</code> connections are already in use, the method
* waits until a connection becomes available or <code>timeout</code>
* seconds elapsed. When the application is finished using the connection,
* it must close it in order to return it to the pool.
*
* @return a new <code>Connection</code> object.
* @throws TimeoutException
* when no connection becomes available within
* <code>timeout</code> seconds.
*/
public Connection getConnection() throws SQLException {
return getConnection2(timeoutMs);
}
private Connection getConnection2(long timeoutMs) throws SQLException {
// This routine is unsynchronized, because semaphore.tryAcquire() may
// block.
synchronized (this) {
if (isDisposed) {
throw new IllegalStateException("Connection pool has been disposed.");
}
}
try {
if (!semaphore.tryAcquire(timeoutMs, TimeUnit.MILLISECONDS)) {
throw new TimeoutException();
}
} catch (InterruptedException e) {
throw new RuntimeException("Interrupted while waiting for a database connection.", e);
}
boolean ok = false;
try {
Connection conn = getConnection3();
ok = true;
return conn;
} finally {
if (!ok) {
semaphore.release();
}
}
}
private synchronized Connection getConnection3() throws SQLException {
if (isDisposed) {
throw new IllegalStateException("Connection pool has been disposed.");
}
PooledConnection pconn;
if (!recycledConnections.isEmpty()) {
pconn = recycledConnections.remove();
} else {
pconn = dataSource.getPooledConnection();
pconn.addConnectionEventListener(poolConnectionEventListener);
}
Connection conn;
try {
// The JDBC driver may call
// ConnectionEventListener.connectionErrorOccurred()
// from within PooledConnection.getConnection(). To detect this
// within
// disposeConnection(), we temporarily set connectionInTransition.
connectionInTransition = pconn;
activeConnections++;
conn = pconn.getConnection();
} finally {
connectionInTransition = null;
}
assertInnerState();
return conn;
}
/**
* Retrieves a connection from the connection pool and ensures that it is
* valid by calling {@link Connection#isValid(int)}.
*
* <p>
* If a connection is not valid, the method tries to get another connection
* until one is valid (or a timeout occurs).
*
* <p>
* Pooled connections may become invalid when e.g. the database server is
* restarted.
*
* <p>
* This method is slower than {@link #getConnection()} because the JDBC
* driver has to send an extra command to the database server to test the
* connection.
*
* <p>
* This method requires Java 1.6 or newer.
*
* @throws TimeoutException
* when no valid connection becomes available within
* <code>timeout</code> seconds.
*/
public Connection getValidConnection() {
long time = System.currentTimeMillis();
long timeoutTime = time + timeoutMs;
int triesWithoutDelay = getInactiveConnections() + 1;
while (true) {
Connection conn = getValidConnection2(time, timeoutTime);
if (conn != null) {
return conn;
}
triesWithoutDelay--;
if (triesWithoutDelay <= 0) {
triesWithoutDelay = 0;
try {
Thread.sleep(250);
} catch (InterruptedException e) {
throw new RuntimeException("Interrupted while waiting for a valid database connection.", e);
}
}
time = System.currentTimeMillis();
if (time >= timeoutTime) {
throw new TimeoutException("Timeout while waiting for a valid database connection.");
}
}
}
private Connection getValidConnection2(long time, long timeoutTime) {
long rtime = Math.max(1, timeoutTime - time);
Connection conn;
try {
conn = getConnection2(rtime);
} catch (SQLException e) {
return null;
}
rtime = timeoutTime - System.currentTimeMillis();
int rtimeSecs = Math.max(1, (int) ((rtime + 999) / 1000));
try {
if (conn.isValid(rtimeSecs)) {
return conn;
}
} catch (SQLException e) {
}
// This Exception should never occur. If it nevertheless occurs, it's
// because of an error in the
// JDBC driver which we ignore and assume that the connection is not
// valid.
// When isValid() returns false, the JDBC driver should have already
// called connectionErrorOccurred()
// and the PooledConnection has been removed from the pool, i.e. the
// PooledConnection will
// not be added to recycledConnections when Connection.close() is
// called.
// But to be sure that this works even with a faulty JDBC driver, we
// call purgeConnection().
purgeConnection(conn);
return null;
}
// Purges the PooledConnection associated with the passed Connection from
// the connection pool.
private synchronized void purgeConnection(Connection conn) {
try {
doPurgeConnection = true;
// (A potential problem of this program logic is that setting the
// doPurgeConnection flag
// has an effect only if the JDBC driver calls connectionClosed()
// synchronously within
// Connection.close().)
conn.close();
} catch (SQLException e) {
}
// ignore exception from close()
finally {
doPurgeConnection = false;
}
}
private synchronized void recycleConnection(PooledConnection pconn) {
if (isDisposed || doPurgeConnection) {
disposeConnection(pconn);
return;
}
if (activeConnections <= 0) {
throw new AssertionError("AuthMeDatabaseError");
}
activeConnections--;
semaphore.release();
recycledConnections.add(pconn);
assertInnerState();
}
private synchronized void disposeConnection(PooledConnection pconn) {
pconn.removeConnectionEventListener(poolConnectionEventListener);
if (!recycledConnections.remove(pconn) && pconn != connectionInTransition) {
// If the PooledConnection is not in the recycledConnections list
// and is not currently within a PooledConnection.getConnection()
// call,
// we assume that the connection was active.
if (activeConnections <= 0) {
throw new AssertionError("AuthMeDatabaseError");
}
activeConnections--;
semaphore.release();
}
closeConnectionAndIgnoreException(pconn);
assertInnerState();
}
private void closeConnectionAndIgnoreException(PooledConnection pconn) {
try {
pconn.close();
} catch (SQLException e) {
log("Error while closing database connection: " + e.toString());
}
}
private void log(String msg) {
String s = "MiniConnectionPoolManager: " + msg;
try {
if (logWriter == null) {
System.err.println(s);
} else {
logWriter.println(s);
}
} catch (Exception e) {
}
}
private synchronized void assertInnerState() {
if (activeConnections < 0) {
throw new AssertionError("AuthMeDatabaseError");
}
if (activeConnections + recycledConnections.size() > maxConnections) {
throw new AssertionError("AuthMeDatabaseError");
}
if (activeConnections + semaphore.availablePermits() > maxConnections) {
throw new AssertionError("AuthMeDatabaseError");
}
}
private class PoolConnectionEventListener implements
ConnectionEventListener {
public void connectionClosed(ConnectionEvent event) {
PooledConnection pconn = (PooledConnection) event.getSource();
recycleConnection(pconn);
}
public void connectionErrorOccurred(ConnectionEvent event) {
PooledConnection pconn = (PooledConnection) event.getSource();
disposeConnection(pconn);
}
}
/**
* Returns the number of active (open) connections of this pool.
*
* <p>
* This is the number of <code>Connection</code> objects that have been
* issued by {@link #getConnection()}, for which
* <code>Connection.close()</code> has not yet been called.
*
* @return the number of active connections.
**/
public synchronized int getActiveConnections() {
return activeConnections;
}
/**
* Returns the number of inactive (unused) connections in this pool.
*
* <p>
* This is the number of internally kept recycled connections, for which
* <code>Connection.close()</code> has been called and which have not yet
* been reused.
*
* @return the number of inactive connections.
**/
public synchronized int getInactiveConnections() {
return recycledConnections.size();
}
} // end class MiniConnectionPoolManager

133
src/main/java/fr/xephi/authme/datasource/MySQL.java
View File

@ -8,13 +8,14 @@ import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeoutException;
import com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.datasource.MiniConnectionPoolManager.TimeoutException;
import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.settings.Settings;
@ -40,7 +41,7 @@ public class MySQL implements DataSource {
private String columnID;
private String columnLogged;
private List<String> columnOthers;
private MiniConnectionPoolManager conPool;
private HikariDataSource ds;
private String columnRealName;
public MySQL() {
@ -100,15 +101,14 @@ public class MySQL implements DataSource {
private synchronized void connect() throws ClassNotFoundException,
SQLException, TimeoutException, NumberFormatException {
Class.forName("com.mysql.jdbc.Driver");
ConsoleLogger.info("MySQL driver loaded");
MysqlConnectionPoolDataSource dataSource = new MysqlConnectionPoolDataSource();
dataSource.setDatabaseName(database);
dataSource.setServerName(host);
dataSource.setPort(Integer.parseInt(port));
dataSource.setUser(username);
dataSource.setPassword(password);
conPool = new MiniConnectionPoolManager(dataSource, 10);
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://" + this.host + ":" + this.port + "/" + this.database);
config.setUsername(this.username);
config.setPassword(this.password);
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
ds = new HikariDataSource(config);
ConsoleLogger.info("Connection pool ready");
}
@ -185,9 +185,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(rs);
close(pst);
@ -238,9 +235,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return null;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return null;
} finally {
close(rs);
close(pst);
@ -451,9 +445,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(pst);
close(con);
@ -499,9 +490,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(pst);
close(con);
@ -523,9 +511,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(pst);
close(con);
@ -545,9 +530,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return 0;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return 0;
} finally {
close(pst);
close(con);
@ -576,9 +558,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally {
close(rs);
close(pst);
@ -615,9 +594,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(pst);
close(con);
@ -641,9 +617,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(pst);
close(con);
@ -669,9 +642,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return 0;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return 0;
} finally {
close(rs);
close(pst);
@ -692,9 +662,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(pst);
close(con);
@ -718,9 +685,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(pst);
close(con);
@ -730,11 +694,8 @@ public class MySQL implements DataSource {
@Override
public synchronized void close() {
try {
conPool.dispose();
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
}
if (ds != null)
ds.close();
}
@Override
@ -800,9 +761,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally {
close(rs);
close(pst);
@ -828,9 +786,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally {
close(rs);
close(pst);
@ -856,9 +811,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally {
close(rs);
close(pst);
@ -888,7 +840,7 @@ public class MySQL implements DataSource {
private synchronized Connection makeSureConnectionIsReady() {
Connection con = null;
try {
con = conPool.getValidConnection();
con = ds.getConnection();
} catch (Exception te) {
try {
con = null;
@ -920,22 +872,31 @@ public class MySQL implements DataSource {
AuthMe.getInstance().getServer().getPluginManager().disablePlugin(AuthMe.getInstance());
}
}
if (con == null)
con = conPool.getValidConnection();
while (con == null)
try {
con = ds.getConnection();
} catch (SQLException e) {
try {
reconnect(false);
con = ds.getConnection();
} catch (Exception ex) {
}
}
return con;
}
private synchronized void reconnect(boolean reload)
throws ClassNotFoundException, SQLException, TimeoutException {
conPool.dispose();
Class.forName("com.mysql.jdbc.Driver");
MysqlConnectionPoolDataSource dataSource = new MysqlConnectionPoolDataSource();
dataSource.setDatabaseName(database);
dataSource.setServerName(host);
dataSource.setPort(Integer.parseInt(port));
dataSource.setUser(username);
dataSource.setPassword(password);
conPool = new MiniConnectionPoolManager(dataSource, 10);
if (ds != null)
ds.close();
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://" + this.host + ":" + this.port + "/" + this.database);
config.setUsername(this.username);
config.setPassword(this.password);
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
ds = new HikariDataSource(config);
if (!reload)
ConsoleLogger.info("ConnectionPool was unavailable... Reconnected!");
}
@ -960,9 +921,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(rs);
close(pst);
@ -984,9 +942,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
close(con);
@ -1008,9 +963,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
close(con);
@ -1031,9 +983,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
close(con);
@ -1057,9 +1006,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return result;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return result;
} finally {
close(pst);
close(con);
@ -1080,9 +1026,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
close(con);
@ -1133,9 +1076,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally {
close(pst);
close(con);
@ -1187,9 +1127,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally {
close(pst);
close(rs);

34
src/main/java/fr/xephi/authme/datasource/SQLite.java
View File

@ -12,7 +12,6 @@ import java.util.List;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.datasource.MiniConnectionPoolManager.TimeoutException;
import fr.xephi.authme.settings.Settings;
public class SQLite implements DataSource {
@ -436,9 +435,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (NullPointerException npe) {
return new ArrayList<String>();
} finally {
@ -463,9 +459,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (NullPointerException npe) {
return new ArrayList<String>();
} finally {
@ -490,9 +483,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (NullPointerException npe) {
return new ArrayList<String>();
} finally {
@ -535,9 +525,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally {
close(rs);
close(pst);
@ -556,9 +543,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
}
@ -577,9 +561,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
}
@ -597,9 +578,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
}
@ -620,9 +598,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return result;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return result;
} finally {
close(pst);
}
@ -640,9 +615,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally {
close(pst);
}
@ -674,9 +646,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally {
close(pst);
}
@ -708,9 +677,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally {
close(pst);
}