Upstream/Plan
1
0
Fork 0
mirror of https://github.com/plan-player-analytics/Plan.git synced 2024-07-08 04:24:55 +02:00
Code Issues Projects Releases Wiki Activity

[#769, #928] Session save on server shutdown (#927)

Browse Source 
* ShutdownHook: No sessions to save check

ShutdownHook now checks if it needs to save any sessions and does not
start the database if no sessions are unsaved.

* SessionCache.getActiveSessions() now immutable

* [#769] Bukkit and Sponge server shutdown save

Implemented following save procedure for Bukkit:
- On plugin disable check if server is shutting down and save sessions
- Shutdown hook triggered on JVM shutdown calls the same session save
- Save clears sessions from cache, so the sessions are not saved twice

Implemented following save procedure for Sponge:
- Listen for GameStoppingServerEvent
- On plugin disable ask listener if shutting down and save sessions
- Shutdown hook triggered on JVM shutdown calls the same session save
- Save clears sessions from cache, so the sessions are not saved twice

Test:
- Tests ShutdownSave on reload
- Tests ShutdownSave on shutdown
- Tests ShutdownSave on JVM shutdown
This commit is contained in:
Risto Lahtela 2019-02-24 12:28:58 +02:00 committed by GitHub
parent 96564c90be
commit 16e6ef1dc7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 561 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
Plan/bukkit/src/main/java/com/djrapitops/plan/BukkitServerShutdownSave.java Normal file
View File

@ -0,0 +1,65 @@
/*
* This file is part of Player Analytics (Plan).
*
* Plan is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License v3 as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Plan is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Plan. If not, see <https://www.gnu.org/licenses/>.
*/
package com.djrapitops.plan;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.utilities.java.Reflection;
import com.djrapitops.plugin.logging.console.PluginLogger;
import com.djrapitops.plugin.logging.error.ErrorHandler;
import javax.inject.Inject;
import javax.inject.Singleton;
/**
* ServerShutdownSave implementation for Bukkit based servers.
*
* @author Rsl1122
*/
@Singleton
public class BukkitServerShutdownSave extends ServerShutdownSave {
private final PluginLogger logger;
@Inject
public BukkitServerShutdownSave(
DBSystem dbSystem,
PluginLogger logger,
ErrorHandler errorHandler
) {
super(dbSystem, errorHandler);
this.logger = logger;
}
@Override
protected boolean checkServerShuttingDownStatus() {
try {
return performCheck();
} catch (Exception | NoClassDefFoundError | NoSuchFieldError e) {
logger.debug("Server shutdown check failed, using JVM ShutdownHook instead. Error: " + e.toString());
return false; // ShutdownHook handles save in case this fails upon plugin disable.
}
}
private boolean performCheck() {
// Special thanks to Fuzzlemann for figuring out the methods required for this check.
// https://github.com/Rsl1122/Plan-PlayerAnalytics/issues/769#issuecomment-433898242
Class<?> minecraftServerClass = Reflection.getMinecraftClass("MinecraftServer");
Object minecraftServer = Reflection.getField(minecraftServerClass, "SERVER", minecraftServerClass).get(null);
return Reflection.getField(minecraftServerClass, "isStopped", boolean.class).get(minecraftServer);
}
}

6
Plan/bukkit/src/main/java/com/djrapitops/plan/Plan.java
View File

@ -40,6 +40,7 @@ public class Plan extends BukkitPlugin implements PlanPlugin {
private PlanSystem system;
private Locale locale;
private ServerShutdownSave serverShutdownSave;
@Override
public void onEnable() {
@ -47,6 +48,7 @@ public class Plan extends BukkitPlugin implements PlanPlugin {
try {
timings.start("Enable");
system = component.system();
serverShutdownSave = component.serverShutdownSave();
locale = system.getLocaleSystem().getLocale();
system.enable();
@ -88,6 +90,10 @@ public class Plan extends BukkitPlugin implements PlanPlugin {
*/
@Override
public void onDisable() {
if (serverShutdownSave != null) {
logger.info(locale != null ? locale.getString(PluginLang.DISABLED_UNSAVED_SESSIONS) : PluginLang.DISABLED_UNSAVED_SESSIONS.getDefault());
serverShutdownSave.performSave();
}
if (system != null) {
system.disable();
}

2
Plan/bukkit/src/main/java/com/djrapitops/plan/PlanBukkitComponent.java
View File

@ -53,6 +53,8 @@ public interface PlanBukkitComponent {
PlanSystem system();
ServerShutdownSave serverShutdownSave();
@Component.Builder
interface Builder {

7
Plan/bukkit/src/main/java/com/djrapitops/plan/modules/bukkit/BukkitSuperClassBindingModule.java
View File

@ -16,6 +16,8 @@
*/
package com.djrapitops.plan.modules.bukkit;
import com.djrapitops.plan.BukkitServerShutdownSave;
import com.djrapitops.plan.ServerShutdownSave;
import com.djrapitops.plan.system.database.BukkitDBSystem;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.system.importing.BukkitImportSystem;
@ -55,6 +57,9 @@ public interface BukkitSuperClassBindingModule {
ListenerSystem bindBukkitListenerSystem(BukkitListenerSystem bukkitListenerSystem);
@Binds
ImportSystem bindImportSsytem(BukkitImportSystem bukkitImportSystem);
ImportSystem bindImportSystem(BukkitImportSystem bukkitImportSystem);
@Binds
ServerShutdownSave bindBukkitServerShutdownSave(BukkitServerShutdownSave bukkitServerShutdownSave);
}

2
Plan/bukkit/src/main/java/com/djrapitops/plan/system/tasks/BukkitTaskSystem.java
View File

@ -33,6 +33,7 @@ import com.djrapitops.plugin.task.RunnableFactory;
import org.bukkit.Bukkit;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@ -41,6 +42,7 @@ import java.util.concurrent.TimeUnit;
*
* @author Rsl1122
*/
@Singleton
public class BukkitTaskSystem extends ServerTaskSystem {
private final Plan plugin;

2
Plan/bungeecord/src/main/java/com/djrapitops/plan/system/tasks/BungeeTaskSystem.java
View File

@ -28,6 +28,7 @@ import com.djrapitops.plugin.api.TimeAmount;
import com.djrapitops.plugin.task.RunnableFactory;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.concurrent.TimeUnit;
/**
@ -35,6 +36,7 @@ import java.util.concurrent.TimeUnit;
*
* @author Rsl1122
*/
@Singleton
public class BungeeTaskSystem extends TaskSystem {
private final PlanBungee plugin;

121
Plan/common/src/main/java/com/djrapitops/plan/ServerShutdownSave.java Normal file
View File

@ -0,0 +1,121 @@
/*
* This file is part of Player Analytics (Plan).
*
* Plan is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License v3 as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Plan is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Plan. If not, see <https://www.gnu.org/licenses/>.
*/
package com.djrapitops.plan;
import com.djrapitops.plan.api.exceptions.database.DBInitException;
import com.djrapitops.plan.api.exceptions.database.DBOpException;
import com.djrapitops.plan.data.container.Session;
import com.djrapitops.plan.data.store.keys.SessionKeys;
import com.djrapitops.plan.db.Database;
import com.djrapitops.plan.db.access.transactions.events.ServerShutdownTransaction;
import com.djrapitops.plan.system.cache.SessionCache;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plugin.logging.L;
import com.djrapitops.plugin.logging.error.ErrorHandler;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
/**
* Class in charge of performing save operations when the server shuts down.
*
* @author Rsl1122
*/
public abstract class ServerShutdownSave {
private final DBSystem dbSystem;
private final ErrorHandler errorHandler;
private boolean shuttingDown = false;
public ServerShutdownSave(
DBSystem dbSystem,
ErrorHandler errorHandler
) {
this.dbSystem = dbSystem;
this.errorHandler = errorHandler;
}
protected abstract boolean checkServerShuttingDownStatus();
public void serverIsKnownToBeShuttingDown() {
shuttingDown = true;
}
public void performSave() {
if (!checkServerShuttingDownStatus() && !shuttingDown) {
return;
}
Map<UUID, Session> activeSessions = SessionCache.getActiveSessions();
if (activeSessions.isEmpty()) {
return;
}
attemptSave(activeSessions);
SessionCache.clear();
}
private void attemptSave(Map<UUID, Session> activeSessions) {
try {
prepareSessionsForStorage(activeSessions, System.currentTimeMillis());
saveActiveSessions(activeSessions);
} catch (DBInitException e) {
errorHandler.log(L.ERROR, this.getClass(), e);
} catch (IllegalStateException ignored) {
/* Database is not initialized */
} finally {
closeDatabase(dbSystem.getDatabase());
}
}
private void saveActiveSessions(Map<UUID, Session> activeSessions) {
Database database = dbSystem.getDatabase();
if (database.getState() == Database.State.CLOSED) {
// Ensure that database is not closed when performing the transaction.
database.init();
}
saveSessions(activeSessions, database);
}
private void prepareSessionsForStorage(Map<UUID, Session> activeSessions, long now) {
for (Session session : activeSessions.values()) {
Optional<Long> end = session.getValue(SessionKeys.END);
if (!end.isPresent()) {
session.endSession(now);
}
}
}
private void saveSessions(Map<UUID, Session> activeSessions, Database database) {
try {
database.executeTransaction(new ServerShutdownTransaction(activeSessions.values()))
.get(); // Ensure that the transaction is executed before shutdown.
} catch (ExecutionException | DBOpException e) {
errorHandler.log(L.ERROR, this.getClass(), e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
private void closeDatabase(Database database) {
database.close();
}
}

69
Plan/common/src/main/java/com/djrapitops/plan/ShutdownHook.java
View File

@ -16,21 +16,8 @@
*/
package com.djrapitops.plan;
import com.djrapitops.plan.api.exceptions.database.DBInitException;
import com.djrapitops.plan.api.exceptions.database.DBOpException;
import com.djrapitops.plan.data.container.Session;
import com.djrapitops.plan.data.store.keys.SessionKeys;
import com.djrapitops.plan.db.Database;
import com.djrapitops.plan.db.access.transactions.events.ServerShutdownTransaction;
import com.djrapitops.plan.system.cache.SessionCache;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plugin.logging.L;
import com.djrapitops.plugin.logging.error.ErrorHandler;
import javax.inject.Inject;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import javax.inject.Singleton;
/**
* Thread that is run when JVM shuts down.
@ -39,16 +26,16 @@ import java.util.UUID;
*
* @author Rsl1122
*/
@Singleton
public class ShutdownHook extends Thread {
private static ShutdownHook activated;
private final DBSystem dbSystem;
private final ErrorHandler errorHandler;
private final ServerShutdownSave serverShutdownSave;
@Inject
public ShutdownHook(DBSystem dbSystem, ErrorHandler errorHandler) {
this.dbSystem = dbSystem;
this.errorHandler = errorHandler;
public ShutdownHook(ServerShutdownSave serverShutdownSave) {
this.serverShutdownSave = serverShutdownSave;
}
private static boolean isActivated() {
@ -74,47 +61,7 @@ public class ShutdownHook extends Thread {
@Override
public void run() {
try {
Map<UUID, Session> activeSessions = SessionCache.getActiveSessions();
prepareSessionsForStorage(activeSessions, System.currentTimeMillis());
saveActiveSessions(activeSessions);
} catch (DBInitException e) {
errorHandler.log(L.ERROR, this.getClass(), e);
} catch (IllegalStateException ignored) {
/* Database is not initialized */
} finally {
closeDatabase(dbSystem.getDatabase());
}
}
private void saveActiveSessions(Map<UUID, Session> activeSessions) {
Database database = dbSystem.getDatabase();
if (database.getState() == Database.State.CLOSED) {
// Ensure that database is not closed when performing the transaction.
database.init();
}
saveSessions(activeSessions, database);
}
private void prepareSessionsForStorage(Map<UUID, Session> activeSessions, long now) {
for (Session session : activeSessions.values()) {
Optional<Long> end = session.getValue(SessionKeys.END);
if (!end.isPresent()) {
session.endSession(now);
}
}
}
private void saveSessions(Map<UUID, Session> activeSessions, Database database) {
try {
database.executeTransaction(new ServerShutdownTransaction(activeSessions.values()));
} catch (DBOpException e) {
errorHandler.log(L.ERROR, this.getClass(), e);
}
}
private void closeDatabase(Database database) {
database.close();
serverShutdownSave.serverIsKnownToBeShuttingDown();
serverShutdownSave.performSave();
}
}

5
Plan/common/src/main/java/com/djrapitops/plan/db/SQLiteDB.java
View File

@ -69,6 +69,8 @@ public class SQLiteDB extends SQLDB {
@Override
public void setupDataSource() {
try {
if (connection != null) connection.close();
connection = getNewConnection(databaseFile);
} catch (SQLException e) {
throw new DBInitException(e.getMessage(), e);
@ -139,11 +141,12 @@ public class SQLiteDB extends SQLDB {
@Override
public void close() {
logger.debug("SQLite Connection close prompted by: " + ThrowableUtils.findCallerAfterClass(Thread.currentThread().getStackTrace(), SQLiteDB.class));
super.close();
stopConnectionPingTask();
if (connection != null) {
logger.debug("SQLite Connection close prompted by: " + ThrowableUtils.findCallerAfterClass(Thread.currentThread().getStackTrace(), SQLiteDB.class));
logger.debug("SQLite " + dbName + ": Closed Connection");
MiscUtils.close(connection);
}

11
Plan/common/src/main/java/com/djrapitops/plan/system/cache/CacheSystem.java vendored
View File

@ -30,11 +30,17 @@ import javax.inject.Singleton;
@Singleton
public class CacheSystem implements SubSystem {
private final SessionCache sessionCache;
private final NicknameCache nicknameCache;
private final GeolocationCache geolocationCache;
@Inject
public CacheSystem(NicknameCache nicknameCache, GeolocationCache geolocationCache) {
public CacheSystem(
SessionCache sessionCache,
NicknameCache nicknameCache,
GeolocationCache geolocationCache
) {
this.sessionCache = sessionCache;
this.nicknameCache = nicknameCache;
this.geolocationCache = geolocationCache;
}
@ -58,4 +64,7 @@ public class CacheSystem implements SubSystem {
return geolocationCache;
}
public SessionCache getSessionCache() {
return sessionCache;
}
}

3
Plan/common/src/main/java/com/djrapitops/plan/system/cache/SessionCache.java vendored
View File

@ -18,6 +18,7 @@ package com.djrapitops.plan.system.cache;
import com.djrapitops.plan.data.container.Session;
import com.djrapitops.plan.data.store.keys.SessionKeys;
import com.google.common.collect.ImmutableMap;
import javax.inject.Inject;
import javax.inject.Singleton;
@ -42,7 +43,7 @@ public class SessionCache {
}
public static Map<UUID, Session> getActiveSessions() {
return ACTIVE_SESSIONS;
return ImmutableMap.copyOf(ACTIVE_SESSIONS);
}
public static void clear() {

1
Plan/common/src/main/java/com/djrapitops/plan/system/locale/lang/PluginLang.java
View File

@ -49,6 +49,7 @@ public enum PluginLang implements Lang {
DISABLED_WEB_SERVER("Disable - WebServer", "Webserver has been disabled."),
DISABLED_PROCESSING("Disable - Processing", "Processing critical unprocessed tasks. (${0})"),
DISABLED_PROCESSING_COMPLETE("Disable - Processing Complete", "Processing complete."),
DISABLED_UNSAVED_SESSIONS("Disable - Unsaved Session Save", "Saving unfinished sessions.."),
VERSION_NEWEST("Version - Latest", "You're using the latest version."),
VERSION_AVAILABLE("Version - New", "New Release (${0}) is available ${1}"),

33
Plan/common/src/main/java/com/djrapitops/plan/system/processing/Processing.java
View File

@ -16,7 +16,6 @@
*/
package com.djrapitops.plan.system.processing;
import com.djrapitops.plan.api.exceptions.EnableException;
import com.djrapitops.plan.system.SubSystem;
import com.djrapitops.plan.system.locale.Locale;
import com.djrapitops.plan.system.locale.lang.PluginLang;
@ -38,8 +37,8 @@ public class Processing implements SubSystem {
private final PluginLogger logger;
private final ErrorHandler errorHandler;
private final ExecutorService nonCriticalExecutor;
private final ExecutorService criticalExecutor;
private ExecutorService nonCriticalExecutor;
private ExecutorService criticalExecutor;
@Inject
public Processing(
@ -50,8 +49,12 @@ public class Processing implements SubSystem {
this.locale = locale;
this.logger = logger;
this.errorHandler = errorHandler;
nonCriticalExecutor = Executors.newFixedThreadPool(6, new ThreadFactoryBuilder().setNameFormat("Plan Non critical-pool-%d").build());
criticalExecutor = Executors.newFixedThreadPool(2, new ThreadFactoryBuilder().setNameFormat("Plan Critical-pool-%d").build());
nonCriticalExecutor = createExecutor(6, "Plan Non critical-pool-%d");
criticalExecutor = createExecutor(2, "Plan Critical-pool-%d");
}
private ExecutorService createExecutor(int i, String s) {
return Executors.newFixedThreadPool(i, new ThreadFactoryBuilder().setNameFormat(s).build());
}
public void submit(Runnable runnable) {
@ -126,18 +129,28 @@ public class Processing implements SubSystem {
}
@Override
public void enable() throws EnableException {
public void enable() {
if (nonCriticalExecutor.isShutdown()) {
throw new EnableException("Non Critical ExecutorService was shut down on enable");
nonCriticalExecutor = createExecutor(6, "Plan Non critical-pool-%d");
}
if (criticalExecutor.isShutdown()) {
throw new EnableException("Critical ExecutorService was shut down on enable");
criticalExecutor = createExecutor(2, "Plan Critical-pool-%d");
}
}
@Override
public void disable() {
shutdownNonCriticalExecutor();
shutdownCriticalExecutor();
ensureShutdown();
logger.info(locale.get().getString(PluginLang.DISABLED_PROCESSING_COMPLETE));
}
private void shutdownNonCriticalExecutor() {
nonCriticalExecutor.shutdown();
}
private void shutdownCriticalExecutor() {
List<Runnable> criticalTasks = criticalExecutor.shutdownNow();
logger.info(locale.get().getString(PluginLang.DISABLED_PROCESSING, criticalTasks.size()));
for (Runnable runnable : criticalTasks) {
@ -148,6 +161,9 @@ public class Processing implements SubSystem {
errorHandler.log(L.WARN, this.getClass(), e);
}
}
}
private void ensureShutdown() {
try {
if (!nonCriticalExecutor.isTerminated() && !nonCriticalExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
nonCriticalExecutor.shutdownNow();
@ -161,6 +177,5 @@ public class Processing implements SubSystem {
criticalExecutor.shutdownNow();
Thread.currentThread().interrupt();
}
logger.info(locale.get().getString(PluginLang.DISABLED_PROCESSING_COMPLETE));
}
}

155
Plan/common/src/test/java/com/djrapitops/plan/ShutdownSaveTest.java Normal file
View File

@ -0,0 +1,155 @@
/*
* This file is part of Player Analytics (Plan).
*
* Plan is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License v3 as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Plan is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Plan. If not, see <https://www.gnu.org/licenses/>.
*/
package com.djrapitops.plan;
import com.djrapitops.plan.data.container.Session;
import com.djrapitops.plan.data.time.GMTimes;
import com.djrapitops.plan.db.Database;
import com.djrapitops.plan.db.access.queries.objects.SessionQueries;
import com.djrapitops.plan.db.access.transactions.StoreServerInformationTransaction;
import com.djrapitops.plan.db.access.transactions.commands.RemoveEverythingTransaction;
import com.djrapitops.plan.db.access.transactions.events.PlayerRegisterTransaction;
import com.djrapitops.plan.db.access.transactions.events.WorldNameStoreTransaction;
import com.djrapitops.plan.system.cache.SessionCache;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.system.info.server.Server;
import com.djrapitops.plugin.logging.console.TestPluginLogger;
import com.djrapitops.plugin.logging.error.ConsoleErrorLogger;
import extension.PrintExtension;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.io.TempDir;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import utilities.TestConstants;
import utilities.dagger.DaggerPlanPluginComponent;
import utilities.dagger.PlanPluginComponent;
import utilities.mocks.PlanPluginMocker;
import java.nio.file.Path;
import java.util.UUID;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* Test ensures that unsaved sessions are saved on server shutdown.
*
* @author Rsl1122
*/
@RunWith(JUnitPlatform.class)
@ExtendWith(PrintExtension.class)
public class ShutdownSaveTest {
private boolean shutdownStatus;
private ServerShutdownSave underTest;
private Database database;
private SessionCache sessionCache;
@BeforeEach
void setupShutdownSaveObject(@TempDir Path temporaryFolder) throws Exception {
PlanPluginComponent pluginComponent = DaggerPlanPluginComponent.builder().plan(
PlanPluginMocker.setUp()
.withDataFolder(temporaryFolder.resolve("ShutdownSaveTest").toFile())
.withLogging()
.getPlanMock()
).build();
database = pluginComponent.system().getDatabaseSystem().getSqLiteFactory().usingFileCalled("test");
database.init();
sessionCache = pluginComponent.system().getCacheSystem().getSessionCache();
storeNecessaryInformation();
placeSessionToCache();
DBSystem dbSystemMock = mock(DBSystem.class);
when(dbSystemMock.getDatabase()).thenReturn(database);
underTest = new ServerShutdownSave(dbSystemMock, new ConsoleErrorLogger(new TestPluginLogger())) {
@Override
protected boolean checkServerShuttingDownStatus() {
return shutdownStatus;
}
};
shutdownStatus = false;
}
@AfterEach
void tearDownPluginComponent() {
database.close();
SessionCache.clear();
}
private void storeNecessaryInformation() throws Exception {
database.executeTransaction(new RemoveEverythingTransaction());
UUID serverUUID = TestConstants.SERVER_UUID;
UUID playerUUID = TestConstants.PLAYER_ONE_UUID;
String worldName = TestConstants.WORLD_ONE_NAME;
database.executeTransaction(new StoreServerInformationTransaction(new Server(-1, serverUUID, "-", "", 0)));
database.executeTransaction(new PlayerRegisterTransaction(playerUUID, () -> 0L, TestConstants.PLAYER_ONE_NAME));
database.executeTransaction(new WorldNameStoreTransaction(serverUUID, worldName))
.get();
}
@Test
void sessionsAreNotSavedOnReload() {
shutdownStatus = false;
underTest.performSave();
database.init();
assertTrue(database.query(SessionQueries.fetchAllSessions()).isEmpty());
database.close();
}
@Test
void sessionsAreSavedOnServerShutdown() {
shutdownStatus = true;
underTest.performSave();
database.init();
assertFalse(database.query(SessionQueries.fetchAllSessions()).isEmpty());
database.close();
}
@Test
void sessionsAreSavedOnJVMShutdown() {
ShutdownHook shutdownHook = new ShutdownHook(underTest);
shutdownHook.run();
database.init();
assertFalse(database.query(SessionQueries.fetchAllSessions()).isEmpty());
database.close();
}
private void placeSessionToCache() {
UUID serverUUID = TestConstants.SERVER_UUID;
UUID playerUUID = TestConstants.PLAYER_ONE_UUID;
String worldName = TestConstants.WORLD_ONE_NAME;
Session session = new Session(playerUUID, serverUUID, 0L, worldName, GMTimes.getGMKeyArray()[0]);
sessionCache.cacheSession(playerUUID, session);
}
}

43
Plan/common/src/test/java/extension/PrintExtension.java Normal file
View File

@ -0,0 +1,43 @@
/*
* This file is part of Player Analytics (Plan).
*
* Plan is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License v3 as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Plan is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Plan. If not, see <https://www.gnu.org/licenses/>.
*/
package extension;
import org.junit.jupiter.api.extension.AfterTestExecutionCallback;
import org.junit.jupiter.api.extension.BeforeTestExecutionCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import java.lang.reflect.Method;
/**
* JUnit 5 Extension that prints what test is being run before each test.
*
* @author Rsl1122
*/
public class PrintExtension implements BeforeTestExecutionCallback, AfterTestExecutionCallback {
@Override
public void beforeTestExecution(ExtensionContext context) throws Exception {
String testName = context.getTestClass().map(Class::getSimpleName).orElse("?");
String testMethodName = context.getTestMethod().map(Method::getName).orElse("?");
System.out.println(">> " + testName + " - " + testMethodName);
}
@Override
public void afterTestExecution(ExtensionContext context) throws Exception {
System.out.println();
}
}

2
Plan/common/src/test/java/utilities/TestConstants.java
View File

@ -31,6 +31,8 @@ public class TestConstants {
public static final String PLAYER_ONE_NAME = "Test_Player_one";
public static final String WORLD_ONE_NAME = "World One";
public static final int BUKKIT_MAX_PLAYERS = 20;
public static final int BUNGEE_MAX_PLAYERS = 100;

20
Plan/common/src/test/java/utilities/TestResources.java
View File

@ -22,6 +22,7 @@ import java.io.*;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
@ -53,8 +54,10 @@ public class TestResources {
}
private static void copyResourceToFile(File toFile, InputStream testResource) {
try (InputStream in = testResource;
OutputStream out = new FileOutputStream(toFile)) {
try (
InputStream in = testResource;
OutputStream out = Files.newOutputStream(toFile.toPath())
) {
copy(in, out);
} catch (IOException e) {
throw new UncheckedIOException(e);
@ -62,8 +65,10 @@ public class TestResources {
}
private static void writeResourceToFile(File toFile, String resourcePath) {
try (InputStream in = PlanPlugin.class.getResourceAsStream(resourcePath);
OutputStream out = new FileOutputStream(toFile)) {
try (
InputStream in = PlanPlugin.class.getResourceAsStream(resourcePath);
OutputStream out = Files.newOutputStream(toFile.toPath())
) {
if (in == null) {
throw new FileNotFoundException("Resource with name '" + resourcePath + "' not found");
}
@ -83,11 +88,10 @@ public class TestResources {
}
private static void createEmptyFile(File toFile) {
String path = toFile.getAbsolutePath();
try {
toFile.getParentFile().mkdirs();
if (!toFile.exists() && !toFile.createNewFile()) {
throw new FileNotFoundException("Could not create file: " + path);
Files.createDirectories(toFile.toPath().getParent());
if (!toFile.exists()) {
Files.createFile(toFile.toPath());
}
} catch (IOException e) {
throw new UncheckedIOException(e);

32
Plan/common/src/test/java/utilities/mocks/Mocker.java
View File

@ -17,8 +17,11 @@
package utilities.mocks;
import com.djrapitops.plan.PlanPlugin;
import utilities.TestResources;
import java.io.*;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import static org.mockito.Mockito.doReturn;
@ -34,42 +37,23 @@ abstract class Mocker {
File getFile(String fileName) {
// Read the resource from jar to a temporary file
File file = new File(new File(planMock.getDataFolder(), "jar"), fileName);
try {
file.getParentFile().mkdirs();
if (!file.exists() && !file.createNewFile()) {
throw new FileNotFoundException("Could not create file: " + fileName);
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
try (InputStream in = PlanPlugin.class.getResourceAsStream(fileName);
OutputStream out = new FileOutputStream(file)) {
int read;
byte[] bytes = new byte[1024];
while ((read = in.read(bytes)) != -1) {
out.write(bytes, 0, read);
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
TestResources.copyResourceIntoFile(file, fileName);
return file;
}
private void withPluginFile(String fileName) throws FileNotFoundException {
private void withPluginFile(String fileName) throws IOException {
if (planMock.getDataFolder() == null) {
throw new IllegalStateException("withDataFolder needs to be called before setting files");
}
try {
File file = getFile("/" + fileName);
doReturn(new FileInputStream(file)).when(planMock).getResource(fileName);
doReturn(Files.newInputStream(file.toPath())).when(planMock).getResource(fileName);
} catch (NullPointerException e) {
System.out.println("File is missing! " + fileName);
}
}
void withPluginFiles() throws FileNotFoundException {
void withPluginFiles() throws IOException {
for (String fileName : new String[]{
"bungeeconfig.yml",
"config.yml",

5
Plan/sponge/src/main/java/com/djrapitops/plan/PlanSponge.java
View File

@ -63,6 +63,7 @@ public class PlanSponge extends SpongePlugin implements PlanPlugin {
private File dataFolder;
private PlanSystem system;
private Locale locale;
private ServerShutdownSave serverShutdownSave;
@Listener
public void onServerStart(GameStartedServerEvent event) {
@ -79,6 +80,7 @@ public class PlanSponge extends SpongePlugin implements PlanPlugin {
PlanSpongeComponent component = DaggerPlanSpongeComponent.builder().plan(this).build();
try {
system = component.system();
serverShutdownSave = component.serverShutdownSave();
locale = system.getLocaleSystem().getLocale();
system.enable();
@ -112,6 +114,9 @@ public class PlanSponge extends SpongePlugin implements PlanPlugin {
@Override
public void onDisable() {
if (serverShutdownSave != null) {
serverShutdownSave.performSave();
}
if (system != null) {
system.disable();
}

2
Plan/sponge/src/main/java/com/djrapitops/plan/PlanSpongeComponent.java
View File

@ -53,6 +53,8 @@ public interface PlanSpongeComponent {
PlanSystem system();
ServerShutdownSave serverShutdownSave();
@Component.Builder
interface Builder {

57
Plan/sponge/src/main/java/com/djrapitops/plan/SpongeServerShutdownSave.java Normal file
View File

@ -0,0 +1,57 @@
/*
* This file is part of Player Analytics (Plan).
*
* Plan is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License v3 as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Plan is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Plan. If not, see <https://www.gnu.org/licenses/>.
*/
package com.djrapitops.plan;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plugin.logging.error.ErrorHandler;
import org.spongepowered.api.GameState;
import org.spongepowered.api.event.Listener;
import org.spongepowered.api.event.Order;
import org.spongepowered.api.event.game.state.GameStoppingServerEvent;
import javax.inject.Inject;
import javax.inject.Singleton;
/**
* ServerShutdownSave implementation for Sponge
*
* @author Rsl1122
*/
@Singleton
public class SpongeServerShutdownSave extends ServerShutdownSave {
private boolean shuttingDown = false;
@Inject
public SpongeServerShutdownSave(DBSystem dbSystem, ErrorHandler errorHandler) {
super(dbSystem, errorHandler);
}
@Override
protected boolean checkServerShuttingDownStatus() {
return shuttingDown;
}
@Listener(order = Order.PRE)
public void onServerShutdown(GameStoppingServerEvent event) {
GameState state = event.getState();
shuttingDown = state == GameState.SERVER_STOPPING
|| state == GameState.GAME_STOPPING
|| state == GameState.SERVER_STOPPED
|| state == GameState.GAME_STOPPED;
}
}

5
Plan/sponge/src/main/java/com/djrapitops/plan/modules/sponge/SpongeSuperClassBindingModule.java
View File

@ -16,6 +16,8 @@
*/
package com.djrapitops.plan.modules.sponge;
import com.djrapitops.plan.ServerShutdownSave;
import com.djrapitops.plan.SpongeServerShutdownSave;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.system.database.SpongeDBSystem;
import com.djrapitops.plan.system.importing.EmptyImportSystem;
@ -57,4 +59,7 @@ public interface SpongeSuperClassBindingModule {
@Binds
ImportSystem bindImportSystem(EmptyImportSystem emptyImportSystem);
@Binds
ServerShutdownSave bindSpongeServerShutdownSave(SpongeServerShutdownSave spongeServerShutdownSave);
}

24
Plan/sponge/src/main/java/com/djrapitops/plan/system/listeners/SpongeListenerSystem.java
View File

@ -18,6 +18,7 @@ package com.djrapitops.plan.system.listeners;
import com.djrapitops.plan.PlanPlugin;
import com.djrapitops.plan.PlanSponge;
import com.djrapitops.plan.SpongeServerShutdownSave;
import com.djrapitops.plan.api.events.PlanSpongeEnableEvent;
import com.djrapitops.plan.system.listeners.sponge.*;
import org.spongepowered.api.Sponge;
@ -36,16 +37,19 @@ public class SpongeListenerSystem extends ListenerSystem {
private final SpongeGMChangeListener gmChangeListener;
private final SpongePlayerListener playerListener;
private final SpongeWorldChangeListener worldChangeListener;
private final SpongeServerShutdownSave spongeServerShutdownSave;
@Inject
public SpongeListenerSystem(PlanSponge plugin,
SpongeAFKListener afkListener,
SpongeChatListener chatListener,
SpongeCommandListener commandListener,
SpongeDeathListener deathListener,
SpongeGMChangeListener gmChangeListener,
SpongePlayerListener playerListener,
SpongeWorldChangeListener worldChangeListener
public SpongeListenerSystem(
PlanSponge plugin,
SpongeAFKListener afkListener,
SpongeChatListener chatListener,
SpongeCommandListener commandListener,
SpongeDeathListener deathListener,
SpongeGMChangeListener gmChangeListener,
SpongePlayerListener playerListener,
SpongeWorldChangeListener worldChangeListener,
SpongeServerShutdownSave spongeServerShutdownSave
) {
this.plugin = plugin;
@ -56,6 +60,7 @@ public class SpongeListenerSystem extends ListenerSystem {
this.gmChangeListener = gmChangeListener;
this.playerListener = playerListener;
this.worldChangeListener = worldChangeListener;
this.spongeServerShutdownSave = spongeServerShutdownSave;
}
@Override
@ -67,7 +72,8 @@ public class SpongeListenerSystem extends ListenerSystem {
deathListener,
playerListener,
gmChangeListener,
worldChangeListener
worldChangeListener,
spongeServerShutdownSave
);
}

2
Plan/sponge/src/main/java/com/djrapitops/plan/system/tasks/SpongeTaskSystem.java
View File

@ -32,8 +32,10 @@ import org.spongepowered.api.Sponge;
import org.spongepowered.api.scheduler.Task;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.concurrent.TimeUnit;
@Singleton
public class SpongeTaskSystem extends ServerTaskSystem {
private final PlanSponge plugin;

2
Plan/velocity/src/main/java/com/djrapitops/plan/system/tasks/VelocityTaskSystem.java
View File

@ -28,6 +28,7 @@ import com.djrapitops.plugin.api.TimeAmount;
import com.djrapitops.plugin.task.RunnableFactory;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.concurrent.TimeUnit;
/**
@ -35,6 +36,7 @@ import java.util.concurrent.TimeUnit;
*
* @author Rsl1122
*/
@Singleton
public class VelocityTaskSystem extends TaskSystem {
private final PlanVelocity plugin;