Upstream/Plan
1
0
Fork 0
mirror of https://github.com/plan-player-analytics/Plan.git synced 2024-10-06 10:27:42 +02:00
Code Issues Projects Releases Wiki Activity

Refactored ServerTable#getBukkitServers to queries:

Browse Source 
- New query for finding a single server in OptionalFetchQueries
- New query for all servers in LargeFetchQueries
- isProxy and isNotProxy methods to Server class
- Renamed ConnectionSystem bukkitServers to dataServers

This increases some boiler plate java code in some places, but reduces
it in others. This will help with saving Velocity with it's appropriate
name in the future.
This commit is contained in:
Rsl1122 2019-01-20 12:38:01 +02:00
parent 2256f4d718
commit 062ab088b3
15 changed files with 175 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Plan/bungeecord/src/main/java/com/djrapitops/plan/BStatsBungee.java
View File

@ -49,7 +49,7 @@ public class BStatsBungee {
addStringSettingPie("server_type", serverType);
addStringSettingPie("database_type", databaseType);
addStringSettingPie("network_servers", connectionSystem.getBukkitServers().size());
addStringSettingPie("network_servers", connectionSystem.getDataServers().size());
}
protected void addStringSettingPie(String id, Serializable setting) {

13
Plan/common/src/main/java/com/djrapitops/plan/command/commands/AnalyzeCommand.java
View File

@ -18,6 +18,7 @@ package com.djrapitops.plan.command.commands;
import com.djrapitops.plan.api.exceptions.connection.WebException;
import com.djrapitops.plan.api.exceptions.database.DBOpException;
import com.djrapitops.plan.db.sql.queries.single.OptionalFetchQueries;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.system.info.InfoSystem;
import com.djrapitops.plan.system.info.connection.ConnectionSystem;
@ -40,7 +41,6 @@ import com.djrapitops.plugin.logging.error.ErrorHandler;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
@ -132,16 +132,9 @@ public class AnalyzeCommand extends CommandNode {
private Optional<Server> getServer(String[] args) {
if (args.length >= 1 && connectionSystem.isServerAvailable()) {
Map<UUID, Server> bukkitServers = dbSystem.getDatabase().fetch().getBukkitServers();
String serverIdentifier = getGivenIdentifier(args);
for (Map.Entry<UUID, Server> entry : bukkitServers.entrySet()) {
Server server = entry.getValue();
if (Integer.toString(server.getId()).equals(serverIdentifier)
|| server.getName().equalsIgnoreCase(serverIdentifier)) {
return Optional.of(server);
}
}
return dbSystem.getDatabase().query(OptionalFetchQueries.matchingServerIdentifier(serverIdentifier))
.filter(server -> !server.isProxy());
}
return Optional.empty();
}

13
Plan/common/src/main/java/com/djrapitops/plan/command/commands/manage/ManageUninstalledCommand.java
View File

@ -17,6 +17,7 @@
package com.djrapitops.plan.command.commands.manage;
import com.djrapitops.plan.api.exceptions.database.DBOpException;
import com.djrapitops.plan.db.sql.queries.single.OptionalFetchQueries;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.system.info.server.Server;
import com.djrapitops.plan.system.info.server.ServerInfo;
@ -34,7 +35,6 @@ import com.djrapitops.plugin.logging.error.ErrorHandler;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
@ -102,16 +102,9 @@ public class ManageUninstalledCommand extends CommandNode {
private Optional<Server> getServer(String[] args) {
if (args.length >= 1) {
Map<UUID, Server> bukkitServers = dbSystem.getDatabase().fetch().getBukkitServers();
String serverIdentifier = getGivenIdentifier(args);
for (Map.Entry<UUID, Server> entry : bukkitServers.entrySet()) {
Server server = entry.getValue();
if (Integer.toString(server.getId()).equals(serverIdentifier)
|| server.getName().equalsIgnoreCase(serverIdentifier)) {
return Optional.of(server);
}
}
return dbSystem.getDatabase().query(OptionalFetchQueries.matchingServerIdentifier(serverIdentifier))
.filter(Server::isNotProxy);
}
return Optional.empty();
}

34
Plan/common/src/main/java/com/djrapitops/plan/db/sql/queries/batch/LargeFetchQueries.java
View File

@ -23,8 +23,11 @@ import com.djrapitops.plan.data.container.PlayerKill;
import com.djrapitops.plan.data.store.objects.Nickname;
import com.djrapitops.plan.db.access.Query;
import com.djrapitops.plan.db.access.QueryAllStatement;
import com.djrapitops.plan.db.access.QueryStatement;
import com.djrapitops.plan.db.sql.tables.*;
import com.djrapitops.plan.system.info.server.Server;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
@ -280,4 +283,35 @@ public class LargeFetchQueries {
}
};
}
/**
* Query database for all Plan server information.
*
* @return Map: Server UUID - Plan Server Information
*/
public static Query<Map<UUID, Server>> fetchPlanServerInformation() {
String sql = "SELECT * FROM " + ServerTable.TABLE_NAME + " WHERE " + ServerTable.Col.INSTALLED + "=?";
return new QueryStatement<Map<UUID, Server>>(sql, 100) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setBoolean(1, true);
}
@Override
public Map<UUID, Server> processResults(ResultSet set) throws SQLException {
Map<UUID, Server> servers = new HashMap<>();
while (set.next()) {
UUID serverUUID = UUID.fromString(set.getString(ServerTable.Col.SERVER_UUID.get()));
servers.put(serverUUID, new Server(
set.getInt(ServerTable.Col.SERVER_ID.get()),
serverUUID,
set.getString(ServerTable.Col.NAME.get()),
set.getString(ServerTable.Col.WEBSERVER_ADDRESS.get()),
set.getInt(ServerTable.Col.MAX_PLAYERS.get())));
}
return servers;
}
};
}
}

73
Plan/common/src/main/java/com/djrapitops/plan/db/sql/queries/single/OptionalFetchQueries.java Normal file
View File

@ -0,0 +1,73 @@
/*
* 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.db.sql.queries.single;
import com.djrapitops.plan.db.access.Query;
import com.djrapitops.plan.db.access.QueryStatement;
import com.djrapitops.plan.db.sql.tables.ServerTable;
import com.djrapitops.plan.system.info.server.Server;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Optional;
import java.util.UUID;
/**
* Static method class for queries that return single item if found.
*
* @author Rsl1122
*/
public class OptionalFetchQueries {
private OptionalFetchQueries() {
/* Static method class */
}
public static Query<Optional<Server>> matchingServerIdentifier(String identifier) {
String sql = "SELECT * FROM " + ServerTable.TABLE_NAME +
" WHERE (" + ServerTable.Col.SERVER_ID + "=?" +
" OR LOWER(" + ServerTable.Col.NAME + ") LIKE LOWER(?)" +
" OR LOWER(" + ServerTable.Col.SERVER_UUID + ") LIKE LOWER(?))" +
" AND " + ServerTable.Col.INSTALLED + "=?" +
" LIMIT 1";
return new QueryStatement<Optional<Server>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, identifier);
statement.setString(2, identifier);
statement.setString(3, identifier);
statement.setBoolean(4, true);
}
@Override
public Optional<Server> processResults(ResultSet set) throws SQLException {
if (set.next()) {
return Optional.of(new Server(
set.getInt(ServerTable.Col.SERVER_ID.get()),
UUID.fromString(set.getString(ServerTable.Col.SERVER_UUID.get())),
set.getString(ServerTable.Col.NAME.get()),
set.getString(ServerTable.Col.WEBSERVER_ADDRESS.get()),
set.getInt(ServerTable.Col.MAX_PLAYERS.get())
));
}
return Optional.empty();
}
};
}
}

32
Plan/common/src/main/java/com/djrapitops/plan/db/sql/tables/ServerTable.java
View File

@ -237,36 +237,6 @@ public class ServerTable extends Table {
});
}
public Map<UUID, Server> getBukkitServers() {
String sql = Select.from(tableName, "*")
.where(Col.NAME + "!=?")
.and(Col.INSTALLED + "=?")
.toString();
return query(new QueryStatement<Map<UUID, Server>>(sql, 100) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, "BungeeCord");
statement.setBoolean(2, true);
}
@Override
public Map<UUID, Server> processResults(ResultSet set) throws SQLException {
Map<UUID, Server> servers = new HashMap<>();
while (set.next()) {
UUID serverUUID = UUID.fromString(set.getString(Col.SERVER_UUID.get()));
servers.put(serverUUID, new Server(
set.getInt(Col.SERVER_ID.get()),
serverUUID,
set.getString(Col.NAME.get()),
set.getString(Col.WEBSERVER_ADDRESS.get()),
set.getInt(Col.MAX_PLAYERS.get())));
}
return servers;
}
});
}
public List<UUID> getServerUUIDs() {
String sql = Select.from(tableName, Col.SERVER_UUID)
.toString();
@ -283,7 +253,7 @@ public class ServerTable extends Table {
});
}
public void insertAllServers(List<Server> allServer) {
public void insertAllServers(Collection<Server> allServer) {
if (Verify.isEmpty(allServer)) {
return;
}

9
Plan/common/src/main/java/com/djrapitops/plan/db/sql/tables/move/BatchOperationTable.java
View File

@ -19,13 +19,9 @@ package com.djrapitops.plan.db.sql.tables.move;
import com.djrapitops.plan.data.container.UserInfo;
import com.djrapitops.plan.db.SQLDB;
import com.djrapitops.plan.db.sql.queries.batch.LargeFetchQueries;
import com.djrapitops.plan.db.sql.tables.ServerTable;
import com.djrapitops.plan.db.sql.tables.Table;
import com.djrapitops.plan.db.sql.tables.UsersTable;
import com.djrapitops.plan.system.info.server.Server;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@ -136,10 +132,7 @@ public class BatchOperationTable extends Table {
if (toDB.equals(this)) {
return;
}
ServerTable serverTable = db.getServerTable();
List<Server> servers = new ArrayList<>(serverTable.getBukkitServers().values());
serverTable.getBungeeInfo().ifPresent(servers::add);
toDB.db.getServerTable().insertAllServers(servers);
toDB.db.getServerTable().insertAllServers(db.query(LargeFetchQueries.fetchPlanServerInformation()).values());
}
public void copyTPS(BatchOperationTable toDB) {

17
Plan/common/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLFetchOps.java
View File

@ -35,6 +35,7 @@ import com.djrapitops.plan.system.settings.config.Config;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
public class SQLFetchOps extends SQLOps implements FetchOperations {
@ -45,7 +46,10 @@ public class SQLFetchOps extends SQLOps implements FetchOperations {
@Override
public NetworkContainer getNetworkContainer() {
NetworkContainer networkContainer = db.getNetworkContainerFactory().forBungeeContainer(getBungeeServerContainer());
networkContainer.putCachingSupplier(NetworkKeys.BUKKIT_SERVERS, () -> getBukkitServers().values());
networkContainer.putCachingSupplier(NetworkKeys.BUKKIT_SERVERS, () ->
db.query(LargeFetchQueries.fetchPlanServerInformation()).values()
.stream().filter(Server::isNotProxy).collect(Collectors.toSet())
);
return networkContainer;
}
@ -464,7 +468,9 @@ public class SQLFetchOps extends SQLOps implements FetchOperations {
@Override
public Map<UUID, Server> getBukkitServers() {
return serverTable.getBukkitServers();
return db.query(LargeFetchQueries.fetchPlanServerInformation()).entrySet().stream()
.filter(entry -> entry.getValue().isNotProxy())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}
@Override
@ -474,12 +480,7 @@ public class SQLFetchOps extends SQLOps implements FetchOperations {
@Override
public List<Server> getServers() {
Map<UUID, Server> bukkitServers = getBukkitServers();
Optional<Server> bungeeInformation = getBungeeInformation();
List<Server> servers = new ArrayList<>(bukkitServers.values());
bungeeInformation.ifPresent(servers::add);
List<Server> servers = new ArrayList<>(db.query(LargeFetchQueries.fetchPlanServerInformation()).values());
Collections.sort(servers);
return servers;
}

10
Plan/common/src/main/java/com/djrapitops/plan/system/info/connection/ConnectionSystem.java
View File

@ -43,7 +43,7 @@ public abstract class ConnectionSystem implements SubSystem {
protected final Lazy<InfoSystem> infoSystem;
protected final ServerInfo serverInfo;
protected Map<UUID, Server> bukkitServers;
protected Map<UUID, Server> dataServers;
private boolean setupAllowed;
public ConnectionSystem(
@ -56,7 +56,7 @@ public abstract class ConnectionSystem implements SubSystem {
this.infoSystem = infoSystem;
this.serverInfo = serverInfo;
setupAllowed = false;
bukkitServers = new HashMap<>();
dataServers = new HashMap<>();
this.infoRequests = infoRequests;
}
@ -98,8 +98,8 @@ public abstract class ConnectionSystem implements SubSystem {
public abstract void sendWideInfoRequest(WideRequest infoRequest) throws NoServersException;
public List<Server> getBukkitServers() {
return new ArrayList<>(bukkitServers.values());
public List<Server> getDataServers() {
return new ArrayList<>(dataServers.values());
}
@Override
@ -110,7 +110,7 @@ public abstract class ConnectionSystem implements SubSystem {
@Override
public void disable() {
setupAllowed = false;
bukkitServers.clear();
dataServers.clear();
infoRequests.clear();
}
}

13
Plan/common/src/main/java/com/djrapitops/plan/system/info/connection/ProxyConnectionSystem.java
View File

@ -18,6 +18,7 @@ package com.djrapitops.plan.system.info.connection;
import com.djrapitops.plan.api.exceptions.connection.NoServersException;
import com.djrapitops.plan.api.exceptions.database.DBOpException;
import com.djrapitops.plan.db.sql.queries.batch.LargeFetchQueries;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.system.info.InfoSystem;
import com.djrapitops.plan.system.info.request.*;
@ -30,8 +31,10 @@ import dagger.Lazy;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
* ConnectionSystem for proxy servers.
@ -70,7 +73,9 @@ public class ProxyConnectionSystem extends ConnectionSystem {
private void refreshServerMap() {
if (latestServerMapRefresh < System.currentTimeMillis() - TimeUnit.SECONDS.toMillis(15L)) {
try {
bukkitServers = dbSystem.getDatabase().fetch().getBukkitServers();
dataServers = dbSystem.getDatabase().query(LargeFetchQueries.fetchPlanServerInformation()).entrySet().stream()
.filter(entry -> entry.getValue().isNotProxy())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
latestServerMapRefresh = System.currentTimeMillis();
} catch (DBOpException e) {
errorHandler.log(L.ERROR, this.getClass(), e);
@ -89,7 +94,7 @@ public class ProxyConnectionSystem extends ConnectionSystem {
return serverInfo.getServer();
} else if (infoRequest instanceof GenerateAnalysisPageRequest) {
UUID serverUUID = ((GenerateAnalysisPageRequest) infoRequest).getServerUUID();
server = bukkitServers.get(serverUUID);
server = dataServers.get(serverUUID);
}
if (server == null) {
throw new NoServersException("Proper server is not available to process request: " + infoRequest.getClass().getSimpleName());
@ -100,10 +105,10 @@ public class ProxyConnectionSystem extends ConnectionSystem {
@Override
public void sendWideInfoRequest(WideRequest infoRequest) throws NoServersException {
refreshServerMap();
if (bukkitServers.isEmpty()) {
if (dataServers.isEmpty()) {
throw new NoServersException("No Servers available to make wide-request: " + infoRequest.getClass().getSimpleName());
}
for (Server server : bukkitServers.values()) {
for (Server server : dataServers.values()) {
webExceptionLogger.logIfOccurs(this.getClass(), () -> sendInfoRequest(infoRequest, server));
}
// Quick hack for Bungee Plugins Tab

26
Plan/common/src/main/java/com/djrapitops/plan/system/info/connection/ServerConnectionSystem.java
View File

@ -18,8 +18,9 @@ package com.djrapitops.plan.system.info.connection;
import com.djrapitops.plan.api.exceptions.connection.ConnectionFailException;
import com.djrapitops.plan.api.exceptions.connection.NoServersException;
import com.djrapitops.plan.db.Database;
import com.djrapitops.plan.db.sql.queries.batch.LargeFetchQueries;
import com.djrapitops.plan.system.database.DBSystem;
import com.djrapitops.plan.system.database.databases.operation.FetchOperations;
import com.djrapitops.plan.system.info.InfoSystem;
import com.djrapitops.plan.system.info.request.*;
import com.djrapitops.plan.system.info.server.Server;
@ -36,6 +37,8 @@ import dagger.Lazy;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@ -87,9 +90,16 @@ public class ServerConnectionSystem extends ConnectionSystem {
private void refreshServerMap() {
processing.submitNonCritical(() -> {
if (latestServerMapRefresh < System.currentTimeMillis() - TimeUnit.SECONDS.toMillis(15L)) {
FetchOperations fetch = dbSystem.getDatabase().fetch();
mainServer = fetch.getBungeeInformation().orElse(null);
bukkitServers = fetch.getBukkitServers();
Database database = dbSystem.getDatabase();
Map<UUID, Server> servers = database.query(LargeFetchQueries.fetchPlanServerInformation());
Optional<Server> proxy = servers.values().stream()
.filter(Server::isProxy)
.findFirst();
mainServer = proxy.orElse(null);
proxy.ifPresent(proxyServer -> servers.remove(proxyServer.getUuid()));
dataServers = servers;
latestServerMapRefresh = System.currentTimeMillis();
}
});
@ -99,7 +109,7 @@ public class ServerConnectionSystem extends ConnectionSystem {
protected Server selectServerForRequest(InfoRequest infoRequest) throws NoServersException {
refreshServerMap();
if (mainServer == null && bukkitServers.isEmpty()) {
if (mainServer == null && dataServers.isEmpty()) {
throw new NoServersException("Zero servers available to process requests.");
}
@ -109,7 +119,7 @@ public class ServerConnectionSystem extends ConnectionSystem {
server = mainServer;
} else if (infoRequest instanceof GenerateAnalysisPageRequest) {
UUID serverUUID = ((GenerateAnalysisPageRequest) infoRequest).getServerUUID();
server = bukkitServers.get(serverUUID);
server = dataServers.get(serverUUID);
}
if (server == null) {
throw new NoServersException("Proper server is not available to process request: " + infoRequest.getClass().getSimpleName());
@ -119,10 +129,10 @@ public class ServerConnectionSystem extends ConnectionSystem {
@Override
public void sendWideInfoRequest(WideRequest infoRequest) throws NoServersException {
if (bukkitServers.isEmpty()) {
if (dataServers.isEmpty()) {
throw new NoServersException("No Servers available to make wide-request: " + infoRequest.getClass().getSimpleName());
}
for (Server server : bukkitServers.values()) {
for (Server server : dataServers.values()) {
webExceptionLogger.logIfOccurs(this.getClass(), () -> {
try {
sendInfoRequest(infoRequest, server);

8
Plan/common/src/main/java/com/djrapitops/plan/system/info/server/Server.java
View File

@ -98,4 +98,12 @@ public class Server implements Comparable<Server> {
public int compareTo(Server other) {
return Integer.compare(this.id, other.id);
}
public boolean isProxy() {
return "BungeeCord".equals(name);
}
public boolean isNotProxy() {
return !isProxy();
}
}

2
Plan/common/src/main/java/com/djrapitops/plan/utilities/html/pages/DebugPage.java
View File

@ -201,7 +201,7 @@ public class DebugPage implements Page {
content.append("</pre>");
content.append("<pre>### Servers:<br><br>");
List<Server> servers = connectionSystem.getBukkitServers();
List<Server> servers = connectionSystem.getDataServers();
content.append("Server Name | Address <br>")
.append("-- | --<br>");
for (Server server : servers) {

8
Plan/common/src/test/java/com/djrapitops/plan/db/CommonDBTest.java
View File

@ -572,7 +572,7 @@ public abstract class CommonDBTest {
assertTrue(db.getCommandUseTable().getCommandUse().isEmpty());
assertTrue(db.getWorldTable().getAllWorlds().isEmpty());
assertTrue(tpsTable.getTPSData().isEmpty());
assertTrue(db.getServerTable().getBukkitServers().isEmpty());
assertTrue(db.query(LargeFetchQueries.fetchPlanServerInformation()).isEmpty());
assertTrue(db.query(LargeFetchQueries.fetchAllPingData()).isEmpty());
assertTrue(db.query(LargeFetchQueries.fetchAllPlanWebUsers()).isEmpty());
}
@ -684,7 +684,7 @@ public abstract class CommonDBTest {
commitTest();
Map<UUID, List<Session>> sessions = db.getSessionsTable().getSessions(playerUUID);
List<Session> savedSessions = sessions.get(playerUUID);
List<Session> savedSessions = sessions.get(serverUUID);
assertNotNull(savedSessions);
assertFalse(savedSessions.isEmpty());
@ -736,8 +736,8 @@ public abstract class CommonDBTest {
assertFalse(backup.getCommandUseTable().getCommandUse().isEmpty());
assertFalse(backup.getWorldTable().getAllWorlds().isEmpty());
assertFalse(tpsTable.getTPSData().isEmpty());
assertFalse(backup.getServerTable().getBukkitServers().isEmpty());
assertFalse(db.query(LargeFetchQueries.fetchAllPlanWebUsers()).isEmpty());
assertFalse(backup.query(LargeFetchQueries.fetchPlanServerInformation()).isEmpty());
assertFalse(backup.query(LargeFetchQueries.fetchAllPlanWebUsers()).isEmpty());
}
@Test

8
Plan/common/src/test/java/com/djrapitops/plan/db/SQLiteTest.java
View File

@ -17,6 +17,7 @@
package com.djrapitops.plan.db;
import com.djrapitops.plan.api.exceptions.database.DBInitException;
import com.djrapitops.plan.db.sql.queries.batch.LargeFetchQueries;
import com.djrapitops.plan.db.sql.tables.ServerTable;
import com.djrapitops.plan.system.info.server.Server;
import org.junit.BeforeClass;
@ -78,9 +79,10 @@ public class SQLiteTest extends CommonDBTest {
@Test
public void testServerTableBungee() throws DBInitException {
testServerTableBungeeSave();
ServerTable serverTable = db.getServerTable();
Map<UUID, Server> bukkitServers = serverTable.getBukkitServers();
assertEquals(1, bukkitServers.size());
Map<UUID, Server> serverInformation = db.query(LargeFetchQueries.fetchPlanServerInformation());
assertEquals(1, serverInformation.values().stream().filter(Server::isNotProxy).count());
assertEquals(1, serverInformation.values().stream().filter(Server::isProxy).count());
}
}