From 795479658226959ed900a31d1a9b6122e19056ac Mon Sep 17 00:00:00 2001 From: Rsl1122 Date: Sat, 8 Sep 2018 17:36:52 +0300 Subject: [PATCH] Attempt to reduce memory usage with selective caching in DataContainer Reduced use of CachingSupplier in every DataContainer to reduce the amount of String variables ending up in heap for a longer period of time. Impacts #685 --- .../store/containers/AnalysisContainer.java | 62 +++++++++---------- .../data/store/containers/DataContainer.java | 7 +++ .../store/containers/NetworkContainer.java | 22 +++---- .../databases/sql/operation/SQLFetchOps.java | 54 ++++++++-------- 4 files changed, 76 insertions(+), 69 deletions(-) diff --git a/Plan/src/main/java/com/djrapitops/plan/data/store/containers/AnalysisContainer.java b/Plan/src/main/java/com/djrapitops/plan/data/store/containers/AnalysisContainer.java index d11aeb46c..d871e35c0 100644 --- a/Plan/src/main/java/com/djrapitops/plan/data/store/containers/AnalysisContainer.java +++ b/Plan/src/main/java/com/djrapitops/plan/data/store/containers/AnalysisContainer.java @@ -62,9 +62,9 @@ public class AnalysisContainer extends DataContainer { } private void addAnalysisSuppliers() { - putSupplier(AnalysisKeys.SESSIONS_MUTATOR, () -> SessionsMutator.forContainer(serverContainer)); - putSupplier(AnalysisKeys.TPS_MUTATOR, () -> TPSMutator.forContainer(serverContainer)); - putSupplier(AnalysisKeys.PLAYERS_MUTATOR, () -> PlayersMutator.forContainer(serverContainer)); + putCachingSupplier(AnalysisKeys.SESSIONS_MUTATOR, () -> SessionsMutator.forContainer(serverContainer)); + putCachingSupplier(AnalysisKeys.TPS_MUTATOR, () -> TPSMutator.forContainer(serverContainer)); + putCachingSupplier(AnalysisKeys.PLAYERS_MUTATOR, () -> PlayersMutator.forContainer(serverContainer)); addConstants(); addPlayerSuppliers(); @@ -101,7 +101,7 @@ public class AnalysisContainer extends DataContainer { } private void addServerProperties() { - putSupplier(AnalysisKeys.SERVER_NAME, () -> + putCachingSupplier(AnalysisKeys.SERVER_NAME, () -> getUnsafe(serverNames).getOrDefault(serverContainer.getUnsafe(ServerKeys.SERVER_UUID), "Plan") ); @@ -126,7 +126,7 @@ public class AnalysisContainer extends DataContainer { } private void addPlayerSuppliers() { - putSupplier(AnalysisKeys.PLAYER_NAMES, () -> serverContainer.getValue(ServerKeys.PLAYERS).orElse(new ArrayList<>()) + putCachingSupplier(AnalysisKeys.PLAYER_NAMES, () -> serverContainer.getValue(ServerKeys.PLAYERS).orElse(new ArrayList<>()) .stream().collect(Collectors.toMap( p -> p.getUnsafe(PlayerKeys.UUID), p -> p.getValue(PlayerKeys.NAME).orElse("?")) ) @@ -169,22 +169,22 @@ public class AnalysisContainer extends DataContainer { Key uniqueDay = new Key<>(PlayersMutator.class, "UNIQUE_DAY"); Key uniqueWeek = new Key<>(PlayersMutator.class, "UNIQUE_WEEK"); Key uniqueMonth = new Key<>(PlayersMutator.class, "UNIQUE_MONTH"); - putSupplier(newDay, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) + putCachingSupplier(newDay, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) .filterRegisteredBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_DAY_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(newWeek, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) + putCachingSupplier(newWeek, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) .filterRegisteredBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_WEEK_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(newMonth, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) + putCachingSupplier(newMonth, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) .filterRegisteredBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_MONTH_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(uniqueDay, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) + putCachingSupplier(uniqueDay, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) .filterPlayedBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_DAY_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(uniqueWeek, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) + putCachingSupplier(uniqueWeek, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) .filterPlayedBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_WEEK_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(uniqueMonth, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) + putCachingSupplier(uniqueMonth, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR) .filterPlayedBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_MONTH_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); @@ -212,7 +212,7 @@ public class AnalysisContainer extends DataContainer { Key retentionDay = new Key<>(Integer.class, "RETENTION_DAY"); // compareAndFindThoseLikelyToBeRetained can throw exception. - putSupplier(retentionDay, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR).compareAndFindThoseLikelyToBeRetained( + putCachingSupplier(retentionDay, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR).compareAndFindThoseLikelyToBeRetained( getUnsafe(newDay).all(), getUnsafe(AnalysisKeys.ANALYSIS_TIME_MONTH_AGO), getUnsafe(AnalysisKeys.PLAYERS_ONLINE_RESOLVER) ).count() @@ -224,13 +224,13 @@ public class AnalysisContainer extends DataContainer { return 0; } }); - putSupplier(AnalysisKeys.PLAYERS_RETAINED_WEEK, () -> + putCachingSupplier(AnalysisKeys.PLAYERS_RETAINED_WEEK, () -> getUnsafe(newWeek).filterRetained( getUnsafe(AnalysisKeys.ANALYSIS_TIME_WEEK_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME) ).count() ); - putSupplier(AnalysisKeys.PLAYERS_RETAINED_MONTH, () -> + putCachingSupplier(AnalysisKeys.PLAYERS_RETAINED_MONTH, () -> getUnsafe(newMonth).filterRetained( getUnsafe(AnalysisKeys.ANALYSIS_TIME_MONTH_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME) @@ -260,8 +260,8 @@ public class AnalysisContainer extends DataContainer { private void addSessionSuppliers() { Key sessionAccordion = new Key<>(SessionAccordion.class, "SESSION_ACCORDION"); - putSupplier(serverNames, () -> Database.getActive().fetch().getServerNames()); - putSupplier(sessionAccordion, () -> SessionAccordion.forServer( + putCachingSupplier(serverNames, () -> Database.getActive().fetch().getServerNames()); + putCachingSupplier(sessionAccordion, () -> SessionAccordion.forServer( getUnsafe(AnalysisKeys.SESSIONS_MUTATOR).all(), getSupplier(serverNames), () -> getUnsafe(AnalysisKeys.PLAYER_NAMES) @@ -301,13 +301,13 @@ public class AnalysisContainer extends DataContainer { Key sessionsDay = new Key<>(SessionsMutator.class, "SESSIONS_DAY"); Key sessionsWeek = new Key<>(SessionsMutator.class, "SESSIONS_WEEK"); Key sessionsMonth = new Key<>(SessionsMutator.class, "SESSIONS_MONTH"); - putSupplier(sessionsDay, () -> getUnsafe(AnalysisKeys.SESSIONS_MUTATOR) + putCachingSupplier(sessionsDay, () -> getUnsafe(AnalysisKeys.SESSIONS_MUTATOR) .filterSessionsBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_DAY_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(sessionsWeek, () -> getUnsafe(AnalysisKeys.SESSIONS_MUTATOR) + putCachingSupplier(sessionsWeek, () -> getUnsafe(AnalysisKeys.SESSIONS_MUTATOR) .filterSessionsBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_WEEK_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(sessionsMonth, () -> getUnsafe(AnalysisKeys.SESSIONS_MUTATOR) + putCachingSupplier(sessionsMonth, () -> getUnsafe(AnalysisKeys.SESSIONS_MUTATOR) .filterSessionsBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_MONTH_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); @@ -320,7 +320,7 @@ public class AnalysisContainer extends DataContainer { private void addGraphSuppliers() { Key worldPie = new Key<>(WorldPie.class, "WORLD_PIE"); - putSupplier(worldPie, () -> new WorldPie(serverContainer.getValue(ServerKeys.WORLD_TIMES).orElse(new WorldTimes(new HashMap<>())))); + putCachingSupplier(worldPie, () -> new WorldPie(serverContainer.getValue(ServerKeys.WORLD_TIMES).orElse(new WorldTimes(new HashMap<>())))); putSupplier(AnalysisKeys.WORLD_PIE_SERIES, () -> getUnsafe(worldPie).toHighChartsSeries()); putSupplier(AnalysisKeys.GM_PIE_SERIES, () -> getUnsafe(worldPie).toHighChartsDrilldown()); putSupplier(AnalysisKeys.PLAYERS_ONLINE_SERIES, () -> @@ -335,12 +335,12 @@ public class AnalysisContainer extends DataContainer { new WorldMap(getUnsafe(AnalysisKeys.PLAYERS_MUTATOR).getGeolocations()).toHighChartsSeries() ); Key geolocationBarChart = new Key<>(GeolocationBarGraph.class, "GEOLOCATION_BAR_CHART"); - putSupplier(geolocationBarChart, () -> new GeolocationBarGraph(getUnsafe(AnalysisKeys.PLAYERS_MUTATOR))); + putCachingSupplier(geolocationBarChart, () -> new GeolocationBarGraph(getUnsafe(AnalysisKeys.PLAYERS_MUTATOR))); putSupplier(AnalysisKeys.COUNTRY_CATEGORIES, () -> getUnsafe(geolocationBarChart).toHighChartsCategories()); putSupplier(AnalysisKeys.COUNTRY_SERIES, () -> getUnsafe(geolocationBarChart).toHighChartsSeries()); Key pingGraph = new Key<>(PingGraph.class, "PING_GRAPH"); - putSupplier(pingGraph, () -> new PingGraph( + putCachingSupplier(pingGraph, () -> new PingGraph( PingMutator.forContainer(serverContainer).mutateToByMinutePings().all() )); putSupplier(AnalysisKeys.AVG_PING_SERIES, () -> getUnsafe(pingGraph).toAvgSeries()); @@ -353,9 +353,9 @@ public class AnalysisContainer extends DataContainer { getUnsafe(AnalysisKeys.NEW_PLAYERS_PER_DAY) ).toCalendarSeries()); - putSupplier(AnalysisKeys.ACTIVITY_DATA, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR).toActivityDataMap(getUnsafe(AnalysisKeys.ANALYSIS_TIME))); + putCachingSupplier(AnalysisKeys.ACTIVITY_DATA, () -> getUnsafe(AnalysisKeys.PLAYERS_MUTATOR).toActivityDataMap(getUnsafe(AnalysisKeys.ANALYSIS_TIME))); Key activityStackGraph = new Key<>(ActivityStackGraph.class, "ACTIVITY_STACK_GRAPH"); - putSupplier(activityStackGraph, () -> new ActivityStackGraph(getUnsafe(AnalysisKeys.ACTIVITY_DATA))); + putCachingSupplier(activityStackGraph, () -> new ActivityStackGraph(getUnsafe(AnalysisKeys.ACTIVITY_DATA))); putSupplier(AnalysisKeys.ACTIVITY_STACK_CATEGORIES, () -> getUnsafe(activityStackGraph).toHighChartsLabels()); putSupplier(AnalysisKeys.ACTIVITY_STACK_SERIES, () -> getUnsafe(activityStackGraph).toHighChartsSeries()); putSupplier(AnalysisKeys.ACTIVITY_PIE_SERIES, () -> @@ -376,17 +376,17 @@ public class AnalysisContainer extends DataContainer { Key tpsWeek = new Key<>(TPSMutator.class, "TPS_WEEK"); Key tpsDay = new Key<>(TPSMutator.class, "TPS_DAY"); - putSupplier(tpsMonth, () -> getUnsafe(AnalysisKeys.TPS_MUTATOR) + putCachingSupplier(tpsMonth, () -> getUnsafe(AnalysisKeys.TPS_MUTATOR) .filterDataBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_MONTH_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(tpsWeek, () -> getUnsafe(AnalysisKeys.TPS_MUTATOR) + putCachingSupplier(tpsWeek, () -> getUnsafe(AnalysisKeys.TPS_MUTATOR) .filterDataBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_WEEK_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(tpsDay, () -> getUnsafe(AnalysisKeys.TPS_MUTATOR) + putCachingSupplier(tpsDay, () -> getUnsafe(AnalysisKeys.TPS_MUTATOR) .filterDataBetween(getUnsafe(AnalysisKeys.ANALYSIS_TIME_DAY_AGO), getUnsafe(AnalysisKeys.ANALYSIS_TIME)) ); - putSupplier(AnalysisKeys.PLAYERS_ONLINE_RESOLVER, () -> new PlayersOnlineResolver(getUnsafe(AnalysisKeys.TPS_MUTATOR))); + putCachingSupplier(AnalysisKeys.PLAYERS_ONLINE_RESOLVER, () -> new PlayersOnlineResolver(getUnsafe(AnalysisKeys.TPS_MUTATOR))); putSupplier(AnalysisKeys.TPS_SPIKE_MONTH, () -> getUnsafe(tpsMonth).lowTpsSpikeCount()); putSupplier(AnalysisKeys.AVG_TPS_MONTH, () -> getUnsafe(tpsMonth).averageTPS()); @@ -416,7 +416,7 @@ public class AnalysisContainer extends DataContainer { private void addServerHealth() { Key healthInformation = new Key<>(HealthInformation.class, "HEALTH_INFORMATION"); - putSupplier(healthInformation, () -> new HealthInformation(this)); + putCachingSupplier(healthInformation, () -> new HealthInformation(this)); putSupplier(AnalysisKeys.HEALTH_INDEX, () -> getUnsafe(healthInformation).getServerHealth()); putSupplier(AnalysisKeys.HEALTH_NOTES, () -> getUnsafe(healthInformation).toHtml()); } @@ -424,13 +424,13 @@ public class AnalysisContainer extends DataContainer { private void addPluginSuppliers() { // TODO Refactor into a system that supports running the analysis on Bungee Key navAndTabs = new Key<>(new Type() {}, "NAV_AND_TABS"); - putSupplier(navAndTabs, () -> + putCachingSupplier(navAndTabs, () -> AnalysisPluginsTabContentCreator.createContent( getUnsafe(AnalysisKeys.PLAYERS_MUTATOR), this ) ); - putSupplier(AnalysisKeys.BAN_DATA, () -> new ServerBanDataReader().readBanDataForContainer(this)); + putCachingSupplier(AnalysisKeys.BAN_DATA, () -> new ServerBanDataReader().readBanDataForContainer(this)); putSupplier(AnalysisKeys.PLUGINS_TAB_NAV, () -> getUnsafe(navAndTabs)[0]); putSupplier(AnalysisKeys.PLUGINS_TAB, () -> getUnsafe(navAndTabs)[1]); } diff --git a/Plan/src/main/java/com/djrapitops/plan/data/store/containers/DataContainer.java b/Plan/src/main/java/com/djrapitops/plan/data/store/containers/DataContainer.java index 96d7ca388..b47d3ee03 100644 --- a/Plan/src/main/java/com/djrapitops/plan/data/store/containers/DataContainer.java +++ b/Plan/src/main/java/com/djrapitops/plan/data/store/containers/DataContainer.java @@ -44,6 +44,13 @@ public class DataContainer { } public void putSupplier(Key key, Supplier supplier) { + if (supplier == null) { + return; + } + map.put(key, supplier); + } + + public void putCachingSupplier(Key key, Supplier supplier) { if (supplier == null) { return; } diff --git a/Plan/src/main/java/com/djrapitops/plan/data/store/containers/NetworkContainer.java b/Plan/src/main/java/com/djrapitops/plan/data/store/containers/NetworkContainer.java index dab7aae04..5bc3e758d 100644 --- a/Plan/src/main/java/com/djrapitops/plan/data/store/containers/NetworkContainer.java +++ b/Plan/src/main/java/com/djrapitops/plan/data/store/containers/NetworkContainer.java @@ -46,7 +46,7 @@ public class NetworkContainer extends DataContainer { this.bungeeContainer = bungeeContainer; serverContainers = new HashMap<>(); - putSupplier(NetworkKeys.PLAYERS_MUTATOR, () -> PlayersMutator.forContainer(bungeeContainer)); + putCachingSupplier(NetworkKeys.PLAYERS_MUTATOR, () -> PlayersMutator.forContainer(bungeeContainer)); addConstants(); addPlayerInformation(); @@ -55,9 +55,9 @@ public class NetworkContainer extends DataContainer { private void addNetworkHealth() { Key healthInformation = new Key<>(NetworkHealthInformation.class, "HEALTH_INFORMATION"); - putSupplier(healthInformation, () -> new NetworkHealthInformation(this)); - putSupplier(NetworkKeys.HEALTH_INDEX, () -> getUnsafe(healthInformation).getServerHealth()); - putSupplier(NetworkKeys.HEALTH_NOTES, () -> getUnsafe(healthInformation).toHtml()); + putCachingSupplier(healthInformation, () -> new NetworkHealthInformation(this)); + putCachingSupplier(NetworkKeys.HEALTH_INDEX, () -> getUnsafe(healthInformation).getServerHealth()); + putCachingSupplier(NetworkKeys.HEALTH_NOTES, () -> getUnsafe(healthInformation).toHtml()); } public void putAnalysisContainer(AnalysisContainer analysisContainer) { @@ -90,7 +90,7 @@ public class NetworkContainer extends DataContainer { putRawData(NetworkKeys.VERSION, PlanPlugin.getInstance().getVersion()); putSupplier(NetworkKeys.TIME_ZONE, MiscUtils::getTimeZoneOffsetHours); - putSupplier(NetworkKeys.NETWORK_NAME, () -> + putCachingSupplier(NetworkKeys.NETWORK_NAME, () -> Check.isBungeeAvailable() ? Settings.BUNGEE_NETWORK_NAME.toString() : bungeeContainer.getValue(ServerKeys.NAME).orElse("Plan") @@ -146,22 +146,22 @@ public class NetworkContainer extends DataContainer { Key uniqueDay = new Key<>(PlayersMutator.class, "UNIQUE_DAY"); Key uniqueWeek = new Key<>(PlayersMutator.class, "UNIQUE_WEEK"); Key uniqueMonth = new Key<>(PlayersMutator.class, "UNIQUE_MONTH"); - putSupplier(newDay, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) + putCachingSupplier(newDay, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) .filterRegisteredBetween(getUnsafe(NetworkKeys.REFRESH_TIME_DAY_AGO), getUnsafe(NetworkKeys.REFRESH_TIME)) ); - putSupplier(newWeek, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) + putCachingSupplier(newWeek, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) .filterRegisteredBetween(getUnsafe(NetworkKeys.REFRESH_TIME_WEEK_AGO), getUnsafe(NetworkKeys.REFRESH_TIME)) ); - putSupplier(newMonth, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) + putCachingSupplier(newMonth, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) .filterRegisteredBetween(getUnsafe(NetworkKeys.REFRESH_TIME_MONTH_AGO), getUnsafe(NetworkKeys.REFRESH_TIME)) ); - putSupplier(uniqueDay, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) + putCachingSupplier(uniqueDay, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) .filterPlayedBetween(getUnsafe(NetworkKeys.REFRESH_TIME_DAY_AGO), getUnsafe(NetworkKeys.REFRESH_TIME)) ); - putSupplier(uniqueWeek, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) + putCachingSupplier(uniqueWeek, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) .filterPlayedBetween(getUnsafe(NetworkKeys.REFRESH_TIME_WEEK_AGO), getUnsafe(NetworkKeys.REFRESH_TIME)) ); - putSupplier(uniqueMonth, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) + putCachingSupplier(uniqueMonth, () -> getUnsafe(NetworkKeys.PLAYERS_MUTATOR) .filterPlayedBetween(getUnsafe(NetworkKeys.REFRESH_TIME_MONTH_AGO), getUnsafe(NetworkKeys.REFRESH_TIME)) ); diff --git a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLFetchOps.java b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLFetchOps.java index 51a3ebeaa..7868a8873 100644 --- a/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLFetchOps.java +++ b/Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLFetchOps.java @@ -27,7 +27,7 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { @Override public NetworkContainer getNetworkContainer() { NetworkContainer networkContainer = new NetworkContainer(getBungeeServerContainer()); - networkContainer.putSupplier(NetworkKeys.BUKKIT_SERVERS, () -> getBukkitServers().values()); + networkContainer.putCachingSupplier(NetworkKeys.BUKKIT_SERVERS, () -> getBukkitServers().values()); return networkContainer; } @@ -38,8 +38,8 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { } ServerContainer container = getServerContainer(bungeeInfo.get().getUuid()); - container.putSupplier(ServerKeys.PLAYERS, this::getAllPlayerContainers); - container.putSupplier(ServerKeys.TPS, tpsTable::getNetworkOnlineData); + container.putCachingSupplier(ServerKeys.PLAYERS, this::getAllPlayerContainers); + container.putCachingSupplier(ServerKeys.TPS, tpsTable::getNetworkOnlineData); container.putSupplier(ServerKeys.WORLD_TIMES, null); // Additional Session information not supported container.putSupplier(ServerKeys.PLAYER_KILLS, null); container.putSupplier(ServerKeys.PLAYER_KILL_COUNT, null); @@ -58,12 +58,12 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { container.putRawData(ServerKeys.SERVER_UUID, serverUUID); container.putRawData(ServerKeys.NAME, serverInfo.get().getName()); - container.putSupplier(ServerKeys.PLAYERS, () -> getPlayerContainers(serverUUID)); + container.putCachingSupplier(ServerKeys.PLAYERS, () -> getPlayerContainers(serverUUID)); container.putSupplier(ServerKeys.PLAYER_COUNT, () -> container.getUnsafe(ServerKeys.PLAYERS).size()); - container.putSupplier(ServerKeys.TPS, () -> tpsTable.getTPSData(serverUUID)); - container.putSupplier(ServerKeys.PING, () -> PlayersMutator.forContainer(container).pings()); - container.putSupplier(ServerKeys.ALL_TIME_PEAK_PLAYERS, () -> { + container.putCachingSupplier(ServerKeys.TPS, () -> tpsTable.getTPSData(serverUUID)); + container.putCachingSupplier(ServerKeys.PING, () -> PlayersMutator.forContainer(container).pings()); + container.putCachingSupplier(ServerKeys.ALL_TIME_PEAK_PLAYERS, () -> { Optional allTimePeak = tpsTable.getAllTimePeak(serverUUID); if (allTimePeak.isPresent()) { TPS peak = allTimePeak.get(); @@ -71,7 +71,7 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { } return null; }); - container.putSupplier(ServerKeys.RECENT_PEAK_PLAYERS, () -> { + container.putCachingSupplier(ServerKeys.RECENT_PEAK_PLAYERS, () -> { long twoDaysAgo = System.currentTimeMillis() - TimeUnit.DAYS.toMillis(2); Optional lastPeak = tpsTable.getPeakPlayerCount(serverUUID, twoDaysAgo); if (lastPeak.isPresent()) { @@ -81,22 +81,22 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { return null; }); - container.putSupplier(ServerKeys.COMMAND_USAGE, () -> commandUseTable.getCommandUse(serverUUID)); - container.putSupplier(ServerKeys.WORLD_TIMES, () -> worldTimesTable.getWorldTimesOfServer(serverUUID)); + container.putCachingSupplier(ServerKeys.COMMAND_USAGE, () -> commandUseTable.getCommandUse(serverUUID)); + container.putCachingSupplier(ServerKeys.WORLD_TIMES, () -> worldTimesTable.getWorldTimesOfServer(serverUUID)); // Calculating getters - container.putSupplier(ServerKeys.OPERATORS, () -> PlayersMutator.forContainer(container).operators()); - container.putSupplier(ServerKeys.SESSIONS, () -> { + container.putCachingSupplier(ServerKeys.OPERATORS, () -> PlayersMutator.forContainer(container).operators()); + container.putCachingSupplier(ServerKeys.SESSIONS, () -> { List sessions = PlayersMutator.forContainer(container).getSessions(); if (serverUUID.equals(ServerInfo.getServerUUID())) { sessions.addAll(SessionCache.getActiveSessions().values()); } return sessions; }); - container.putSupplier(ServerKeys.PLAYER_KILLS, () -> SessionsMutator.forContainer(container).toPlayerKillList()); - container.putSupplier(ServerKeys.PLAYER_KILL_COUNT, () -> container.getUnsafe(ServerKeys.PLAYER_KILLS).size()); - container.putSupplier(ServerKeys.MOB_KILL_COUNT, () -> SessionsMutator.forContainer(container).toMobKillCount()); - container.putSupplier(ServerKeys.DEATH_COUNT, () -> SessionsMutator.forContainer(container).toDeathCount()); + container.putCachingSupplier(ServerKeys.PLAYER_KILLS, () -> SessionsMutator.forContainer(container).toPlayerKillList()); + container.putCachingSupplier(ServerKeys.PLAYER_KILL_COUNT, () -> container.getUnsafe(ServerKeys.PLAYER_KILLS).size()); + container.putCachingSupplier(ServerKeys.MOB_KILL_COUNT, () -> SessionsMutator.forContainer(container).toMobKillCount()); + container.putCachingSupplier(ServerKeys.DEATH_COUNT, () -> SessionsMutator.forContainer(container).toDeathCount()); return container; } @@ -129,13 +129,13 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { container.putRawData(PlayerKeys.KICK_COUNT, timesKicked.get(uuid)); container.putRawData(PlayerKeys.GEO_INFO, geoInfo.get(uuid)); container.putRawData(PlayerKeys.PING, allPings.get(uuid)); - container.putSupplier(PlayerKeys.NICKNAMES, () -> nicknamesTable.getNicknameInformation(uuid)); + container.putCachingSupplier(PlayerKeys.NICKNAMES, () -> nicknamesTable.getNicknameInformation(uuid)); container.putRawData(PlayerKeys.PER_SERVER, perServerInfo.get(uuid)); container.putRawData(PlayerKeys.BANNED, userInfo.isBanned()); container.putRawData(PlayerKeys.OPERATOR, userInfo.isOperator()); - container.putSupplier(PlayerKeys.SESSIONS, () -> { + container.putCachingSupplier(PlayerKeys.SESSIONS, () -> { List playerSessions = sessions.getOrDefault(uuid, new ArrayList<>()); container.getValue(PlayerKeys.ACTIVE_SESSION).ifPresent(playerSessions::add); return playerSessions; @@ -143,7 +143,7 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { ); // Calculating getters - container.putSupplier(PlayerKeys.WORLD_TIMES, () -> { + container.putCachingSupplier(PlayerKeys.WORLD_TIMES, () -> { WorldTimes worldTimes = new PerServerMutator(container.getUnsafe(PlayerKeys.PER_SERVER)).flatMapWorldTimes(); container.getValue(PlayerKeys.ACTIVE_SESSION) .ifPresent(session -> worldTimes.add( @@ -187,10 +187,10 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { container.putRawData(PlayerKeys.KICK_COUNT, timesKicked.get(uuid)); container.putRawData(PlayerKeys.GEO_INFO, geoInfo.get(uuid)); container.putRawData(PlayerKeys.PING, allPings.get(uuid)); - container.putSupplier(PlayerKeys.NICKNAMES, () -> nicknamesTable.getNicknameInformation(uuid)); + container.putCachingSupplier(PlayerKeys.NICKNAMES, () -> nicknamesTable.getNicknameInformation(uuid)); container.putRawData(PlayerKeys.PER_SERVER, perServerInfo.get(uuid)); - container.putSupplier(PlayerKeys.SESSIONS, () -> { + container.putCachingSupplier(PlayerKeys.SESSIONS, () -> { List playerSessions = PerServerMutator.forContainer(container).flatMapSessions(); container.getValue(PlayerKeys.ACTIVE_SESSION).ifPresent(playerSessions::add); return playerSessions; @@ -285,21 +285,21 @@ public class SQLFetchOps extends SQLOps implements FetchOperations { container.putRawData(PlayerKeys.UUID, uuid); container.putAll(usersTable.getUserInformation(uuid)); - container.putSupplier(PlayerKeys.GEO_INFO, () -> geoInfoTable.getGeoInfo(uuid)); - container.putSupplier(PlayerKeys.PING, () -> pingTable.getPing(uuid)); - container.putSupplier(PlayerKeys.NICKNAMES, () -> nicknamesTable.getNicknameInformation(uuid)); - container.putSupplier(PlayerKeys.PER_SERVER, () -> getPerServerData(uuid)); + container.putCachingSupplier(PlayerKeys.GEO_INFO, () -> geoInfoTable.getGeoInfo(uuid)); + container.putCachingSupplier(PlayerKeys.PING, () -> pingTable.getPing(uuid)); + container.putCachingSupplier(PlayerKeys.NICKNAMES, () -> nicknamesTable.getNicknameInformation(uuid)); + container.putCachingSupplier(PlayerKeys.PER_SERVER, () -> getPerServerData(uuid)); container.putSupplier(PlayerKeys.BANNED, () -> new PerServerMutator(container.getUnsafe(PlayerKeys.PER_SERVER)).isBanned()); container.putSupplier(PlayerKeys.OPERATOR, () -> new PerServerMutator(container.getUnsafe(PlayerKeys.PER_SERVER)).isOperator()); - container.putSupplier(PlayerKeys.SESSIONS, () -> { + container.putCachingSupplier(PlayerKeys.SESSIONS, () -> { List sessions = new PerServerMutator(container.getUnsafe(PlayerKeys.PER_SERVER)).flatMapSessions(); container.getValue(PlayerKeys.ACTIVE_SESSION).ifPresent(sessions::add); return sessions; } ); - container.putSupplier(PlayerKeys.WORLD_TIMES, () -> + container.putCachingSupplier(PlayerKeys.WORLD_TIMES, () -> { WorldTimes worldTimes = new PerServerMutator(container.getUnsafe(PlayerKeys.PER_SERVER)).flatMapWorldTimes(); container.getValue(PlayerKeys.ACTIVE_SESSION).ifPresent(session -> worldTimes.add(