Meishin/LoginSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #21 from Xephi/master

Browse Source 
Up
This commit is contained in:
Gabriele C. 2015-07-31 16:10:24 +02:00
commit 80f0d290bb
6 changed files with 108 additions and 594 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.sun.mail:*</include>
<include>com.comphenix.attribute:*</include> <include>com.comphenix.attribute:*</include>
<include>org.mcstats.*:*</include> <include>org.mcstats.*:*</include>
<include>com.zaxxer:*</include>
<include>org.slf4j:*</include>
</includes> </includes>
</artifactSet> </artifactSet>
<relocations> <relocations>
@ -184,11 +186,27 @@
<!-- MySql Library --> <!-- MySql Library -->
<dependency> <dependency>
<groupId>mysql</groupId> <groupId>org.slf4j</groupId>
<artifactId>mysql-connector-java</artifactId> <artifactId>slf4j-simple</artifactId>
<version>5.1.36</version> <version>1.7.12</version>
<scope>compile</scope> <scope>compile</scope>
</dependency> </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 --> <!-- SQLite Library -->
<dependency> <dependency>

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

@ -166,10 +166,11 @@ public class AuthMe extends JavaPlugin {
// Set Console Filter // Set Console Filter
if (Settings.removePassword) { if (Settings.removePassword) {
this.getLogger().setFilter(new ConsoleFilter()); ConsoleFilter filter = new ConsoleFilter();
Bukkit.getLogger().setFilter(new ConsoleFilter()); this.getLogger().setFilter(filter);
Logger.getLogger("Minecraft").setFilter(new ConsoleFilter()); Bukkit.getLogger().setFilter(filter);
authmeLogger.setFilter(new ConsoleFilter()); Logger.getLogger("Minecraft").setFilter(filter);
authmeLogger.setFilter(filter);
// Set Log4J Filter // Set Log4J Filter
try { try {
Class.forName("org.apache.logging.log4j.core.Filter"); Class.forName("org.apache.logging.log4j.core.Filter");
@ -249,9 +250,9 @@ public class AuthMe extends JavaPlugin {
if (!Settings.isForceSingleSessionEnabled) { if (!Settings.isForceSingleSessionEnabled) {
ConsoleLogger.showError("WARNING!!! By disabling ForceSingleSession, your server protection is inadequate!"); ConsoleLogger.showError("WARNING!!! By disabling ForceSingleSession, your server protection is inadequate!");
} }
if (Settings.getSessionTimeout == 0 && Settings.isSessionsEnabled) { 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) { if (Settings.reloadSupport) {
@ -545,13 +546,17 @@ public class AuthMe extends JavaPlugin {
return; return;
ConsoleLogger.info("AutoPurging the Database: " + cleared.size() + " accounts removed!"); ConsoleLogger.info("AutoPurging the Database: " + cleared.size() + " accounts removed!");
if (Settings.purgeEssentialsFile && this.ess != null) 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) 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) if (Settings.purgeLimitedCreative)
dataManager.purgeLimitedCreative(cleared); dataManager.purgeLimitedCreative(cleared);
if (Settings.purgeAntiXray) 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) if (Settings.purgePermissions)
dataManager.purgePermissions(cleared, permission); 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

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

@ -8,13 +8,15 @@ import java.sql.SQLException;
import java.sql.Statement; import java.sql.Statement;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; 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 com.zaxxer.hikari.pool.PoolInitializationException;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.ConsoleLogger; import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.auth.PlayerAuth; import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.datasource.MiniConnectionPoolManager.TimeoutException;
import fr.xephi.authme.security.HashAlgorithm; import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
@ -40,7 +42,7 @@ public class MySQL implements DataSource {
private String columnID; private String columnID;
private String columnLogged; private String columnLogged;
private List<String> columnOthers; private List<String> columnOthers;
private MiniConnectionPoolManager conPool; private HikariDataSource ds;
private String columnRealName; private String columnRealName;
public MySQL() { public MySQL() {
@ -95,20 +97,32 @@ public class MySQL implements DataSource {
if (!Settings.isStopEnabled) if (!Settings.isStopEnabled)
AuthMe.getInstance().getServer().getPluginManager().disablePlugin(AuthMe.getInstance()); AuthMe.getInstance().getServer().getPluginManager().disablePlugin(AuthMe.getInstance());
return; return;
} catch (PoolInitializationException e) {
ConsoleLogger.showError(e.getMessage());
if (Settings.isStopEnabled) {
ConsoleLogger.showError("Can't use MySQL... Please input correct MySQL informations ! SHUTDOWN...");
AuthMe.getInstance().getServer().shutdown();
}
if (!Settings.isStopEnabled)
AuthMe.getInstance().getServer().getPluginManager().disablePlugin(AuthMe.getInstance());
return;
} }
} }
private synchronized void connect() throws ClassNotFoundException, private synchronized void connect()
SQLException, TimeoutException, NumberFormatException { throws ClassNotFoundException, SQLException, TimeoutException,
Class.forName("com.mysql.jdbc.Driver"); NumberFormatException, PoolInitializationException {
ConsoleLogger.info("MySQL driver loaded"); HikariConfig config = new HikariConfig();
MysqlConnectionPoolDataSource dataSource = new MysqlConnectionPoolDataSource(); config.setJdbcUrl("jdbc:mysql://" + this.host + ":" + this.port + "/" + this.database);
dataSource.setDatabaseName(database); config.setUsername(this.username);
dataSource.setServerName(host); config.setPassword(this.password);
dataSource.setPort(Integer.parseInt(port)); config.setPoolName("AuthMeMYSQLPool");
dataSource.setUser(username); config.addDataSourceProperty("cachePrepStmts", "true");
dataSource.setPassword(password); config.addDataSourceProperty("prepStmtCacheSize", "250");
conPool = new MiniConnectionPoolManager(dataSource, 10); config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
config.addDataSourceProperty("autoReconnect", true);
config.addDataSourceProperty("initializationFailFast", true);
ds = new HikariDataSource(config);
ConsoleLogger.info("Connection pool ready"); ConsoleLogger.info("Connection pool ready");
} }
@ -185,9 +199,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -238,9 +249,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return null; return null;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return null;
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -451,9 +459,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -499,9 +504,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -523,9 +525,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -545,9 +544,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return 0; return 0;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return 0;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -576,9 +572,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>(); return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -615,9 +608,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -641,9 +631,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -669,9 +656,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return 0; return 0;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return 0;
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -692,9 +676,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -718,9 +699,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -730,11 +708,8 @@ public class MySQL implements DataSource {
@Override @Override
public synchronized void close() { public synchronized void close() {
try { if (ds != null)
conPool.dispose(); ds.close();
} catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage());
}
} }
@Override @Override
@ -800,9 +775,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>(); return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -828,9 +800,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>(); return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -856,9 +825,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>(); return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -888,7 +854,7 @@ public class MySQL implements DataSource {
private synchronized Connection makeSureConnectionIsReady() { private synchronized Connection makeSureConnectionIsReady() {
Connection con = null; Connection con = null;
try { try {
con = conPool.getValidConnection(); con = ds.getConnection();
} catch (Exception te) { } catch (Exception te) {
try { try {
con = null; con = null;
@ -920,22 +886,35 @@ public class MySQL implements DataSource {
AuthMe.getInstance().getServer().getPluginManager().disablePlugin(AuthMe.getInstance()); AuthMe.getInstance().getServer().getPluginManager().disablePlugin(AuthMe.getInstance());
} }
} }
if (con == null) while (con == null)
con = conPool.getValidConnection(); try {
con = ds.getConnection();
} catch (SQLException e) {
try {
reconnect(false);
con = ds.getConnection();
} catch (Exception ex) {
}
}
return con; return con;
} }
private synchronized void reconnect(boolean reload) private synchronized void reconnect(boolean reload)
throws ClassNotFoundException, SQLException, TimeoutException { throws ClassNotFoundException, SQLException, TimeoutException,
conPool.dispose(); PoolInitializationException {
Class.forName("com.mysql.jdbc.Driver"); if (ds != null)
MysqlConnectionPoolDataSource dataSource = new MysqlConnectionPoolDataSource(); ds.close();
dataSource.setDatabaseName(database); HikariConfig config = new HikariConfig();
dataSource.setServerName(host); config.setJdbcUrl("jdbc:mysql://" + this.host + ":" + this.port + "/" + this.database);
dataSource.setPort(Integer.parseInt(port)); config.setUsername(this.username);
dataSource.setUser(username); config.setPassword(this.password);
dataSource.setPassword(password); config.addDataSourceProperty("cachePrepStmts", "true");
conPool = new MiniConnectionPoolManager(dataSource, 10); config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
config.addDataSourceProperty("autoReconnect", true);
config.addDataSourceProperty("initializationFailFast", true);
config.setPoolName("AuthMeMYSQLPool");
ds = new HikariDataSource(config);
if (!reload) if (!reload)
ConsoleLogger.info("ConnectionPool was unavailable... Reconnected!"); ConsoleLogger.info("ConnectionPool was unavailable... Reconnected!");
} }
@ -960,9 +939,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -984,9 +960,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -1008,9 +981,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -1031,9 +1001,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -1057,9 +1024,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return result; return result;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return result;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -1080,9 +1044,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -1133,9 +1094,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return auths; return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally { } finally {
close(pst); close(pst);
close(con); close(con);
@ -1187,9 +1145,6 @@ public class MySQL implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return auths; return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally { } finally {
close(pst); close(pst);
close(rs); 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.AuthMe;
import fr.xephi.authme.ConsoleLogger; import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.auth.PlayerAuth; import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.datasource.MiniConnectionPoolManager.TimeoutException;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
public class SQLite implements DataSource { public class SQLite implements DataSource {
@ -436,9 +435,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>(); return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (NullPointerException npe) { } catch (NullPointerException npe) {
return new ArrayList<String>(); return new ArrayList<String>();
} finally { } finally {
@ -463,9 +459,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>(); return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (NullPointerException npe) { } catch (NullPointerException npe) {
return new ArrayList<String>(); return new ArrayList<String>();
} finally { } finally {
@ -490,9 +483,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>(); return new ArrayList<String>();
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return new ArrayList<String>();
} catch (NullPointerException npe) { } catch (NullPointerException npe) {
return new ArrayList<String>(); return new ArrayList<String>();
} finally { } finally {
@ -535,9 +525,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return false; return false;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return false;
} finally { } finally {
close(rs); close(rs);
close(pst); close(pst);
@ -556,9 +543,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
} }
@ -577,9 +561,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
} }
@ -597,9 +578,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
} }
@ -620,9 +598,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return result; return result;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return result;
} finally { } finally {
close(pst); close(pst);
} }
@ -640,9 +615,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return; return;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return;
} finally { } finally {
close(pst); close(pst);
} }
@ -674,9 +646,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return auths; return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally { } finally {
close(pst); close(pst);
} }
@ -708,9 +677,6 @@ public class SQLite implements DataSource {
} catch (SQLException ex) { } catch (SQLException ex) {
ConsoleLogger.showError(ex.getMessage()); ConsoleLogger.showError(ex.getMessage());
return auths; return auths;
} catch (TimeoutException ex) {
ConsoleLogger.showError(ex.getMessage());
return auths;
} finally { } finally {
close(pst); close(pst);
} }

37
src/main/java/fr/xephi/authme/process/quit/AsyncronousQuit.java
View File

@ -46,16 +46,13 @@ public class AsyncronousQuit {
return; return;
} }
Location loc = player.getLocation();
String ip = plugin.getIP(player); String ip = plugin.getIP(player);
if (PlayerCache.getInstance().isAuthenticated(name) && !player.isDead()) { if (PlayerCache.getInstance().isAuthenticated(name)) {
if (Settings.isSaveQuitLocationEnabled && database.isAuthAvailable(name)) { if (Settings.isSaveQuitLocationEnabled && database.isAuthAvailable(name)) {
final PlayerAuth auth = new PlayerAuth(name, loc.getX(), loc.getY(), loc.getZ(), loc.getWorld().getName(), player.getName()); Location loc = player.getLocation();
try { PlayerAuth auth = new PlayerAuth(name, loc.getX(), loc.getY(), loc.getZ(), loc.getWorld().getName(), player.getName());
database.updateQuitLoc(auth); database.updateQuitLoc(auth);
} catch (NullPointerException npe) {
}
} }
PlayerAuth auth = new PlayerAuth(name, ip, System.currentTimeMillis(), player.getName()); PlayerAuth auth = new PlayerAuth(name, ip, System.currentTimeMillis(), player.getName());
database.updateSession(auth); database.updateSession(auth);
@ -78,19 +75,19 @@ public class AsyncronousQuit {
LimboCache.getInstance().deleteLimboPlayer(name); LimboCache.getInstance().deleteLimboPlayer(name);
} }
if (Settings.isSessionsEnabled && !isKick) { if (Settings.isSessionsEnabled && !isKick) {
if (Settings.getSessionTimeout != 0){ if (Settings.getSessionTimeout != 0) {
BukkitTask task = plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, new Runnable() { BukkitTask task = plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, new Runnable() {
@Override @Override
public void run() { public void run() {
PlayerCache.getInstance().removePlayer(name); PlayerCache.getInstance().removePlayer(name);
if (database.isLogged(name)) if (database.isLogged(name))
database.setUnlogged(name); database.setUnlogged(name);
plugin.sessions.remove(name); plugin.sessions.remove(name);
} }
}, Settings.getSessionTimeout * 20 * 60); }, Settings.getSessionTimeout * 20 * 60);
plugin.sessions.put(name, task); plugin.sessions.put(name, task);
} }
} else { } else {
PlayerCache.getInstance().removePlayer(name); PlayerCache.getInstance().removePlayer(name);