Upstream/Plan
1
0
Fork 0
mirror of https://github.com/plan-player-analytics/Plan.git synced 2024-08-26 22:49:51 +02:00
Code Issues Projects Releases Wiki Activity

[Debt] Turned GeolocationCache methods non-static

Browse Source 
getInstance is not necessary as GeolocationCache can be injected
everywhere where it is required (Mostly at gathering layer)
Discovered old GeolocationCacheTest that was removed.
This commit is contained in:
Rsl1122 2018-09-18 18:18:52 +03:00
parent 654d7ca03c
commit f26294d9dd
8 changed files with 110 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Plan/src/main/java/com/djrapitops/plan/system/cache/GeolocationCache.java vendored
View File

@ -9,7 +9,6 @@ import com.djrapitops.plan.system.settings.Settings;
import com.djrapitops.plan.system.settings.config.PlanConfig;
import com.djrapitops.plugin.logging.L;
import com.djrapitops.plugin.logging.console.PluginLogger;
import com.djrapitops.plugin.utilities.Verify;
import com.maxmind.geoip2.DatabaseReader;
import com.maxmind.geoip2.exception.GeoIp2Exception;
import com.maxmind.geoip2.model.CountryResponse;
@ -59,7 +58,8 @@ public class GeolocationCache implements SubSystem {
this.fileSystem = fileSystem;
this.config = config;
this.logger = logger;
cached = new HashMap<>();
this.cached = new HashMap<>();
}
@Override
@ -67,7 +67,7 @@ public class GeolocationCache implements SubSystem {
geolocationDB = fileSystem.getFileFromPluginFolder("GeoIP.dat");
if (config.isTrue(Settings.DATA_GEOLOCATIONS)) {
try {
GeolocationCache.checkDB();
checkDB();
} catch (UnknownHostException e) {
logger.error(locale.getString(PluginLang.ENABLE_NOTIFY_GEOLOCATIONS_INTERNET_REQUIRED));
} catch (IOException e) {
@ -90,33 +90,27 @@ public class GeolocationCache implements SubSystem {
* if that happens, "Not Known" will be returned.
* @see #getUnCachedCountry(String)
*/
public static String getCountry(String ipAddress) {
public String getCountry(String ipAddress) {
String country = getCachedCountry(ipAddress);
if (country != null) {
return country;
} else {
country = getUnCachedCountry(ipAddress);
getInstance().cached.put(ipAddress, country);
cached.put(ipAddress, country);
return country;
}
}
private static GeolocationCache getInstance() {
GeolocationCache geolocationCache = CacheSystem.getInstance().getGeolocationCache();
Verify.nullCheck(geolocationCache, () -> new IllegalStateException("GeolocationCache was not initialized."));
return geolocationCache;
}
/**
* Returns the cached country
*
* @param ipAddress The IP Address which is retrieved out of the cache
* @return The cached country, {@code null} if the country is not cached
*/
private static String getCachedCountry(String ipAddress) {
return getInstance().cached.get(ipAddress);
private String getCachedCountry(String ipAddress) {
return cached.get(ipAddress);
}
/**
@ -133,14 +127,14 @@ public class GeolocationCache implements SubSystem {
* @see <a href="http://maxmind.com">http://maxmind.com</a>
* @see #getCountry(String)
*/
private static String getUnCachedCountry(String ipAddress) {
private String getUnCachedCountry(String ipAddress) {
if ("127.0.0.1".equals(ipAddress)) {
return "Local Machine";
}
try {
checkDB();
try (DatabaseReader reader = new DatabaseReader.Builder(getInstance().geolocationDB).build()) {
try (DatabaseReader reader = new DatabaseReader.Builder(geolocationDB).build()) {
InetAddress inetAddress = InetAddress.getByName(ipAddress);
CountryResponse response = reader.country(inetAddress);
@ -159,13 +153,13 @@ public class GeolocationCache implements SubSystem {
*
* @throws IOException when an error at download or saving the DB happens
*/
public static void checkDB() throws IOException {
if (getInstance().geolocationDB.exists()) {
private void checkDB() throws IOException {
if (geolocationDB.exists()) {
return;
}
URL downloadSite = new URL("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.mmdb.gz");
try (ReadableByteChannel rbc = Channels.newChannel(new GZIPInputStream(downloadSite.openStream()));
FileOutputStream fos = new FileOutputStream(getInstance().geolocationDB.getAbsoluteFile())) {
FileOutputStream fos = new FileOutputStream(geolocationDB.getAbsoluteFile())) {
fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
}
}
@ -176,8 +170,8 @@ public class GeolocationCache implements SubSystem {
* @param ipAddress The IP Address which is checked
* @return true if the IP Address is cached
*/
public static boolean isCached(String ipAddress) {
return getInstance().cached.containsKey(ipAddress);
boolean isCached(String ipAddress) {
return cached.containsKey(ipAddress);
}
@Override

6
Plan/src/main/java/com/djrapitops/plan/system/importing/BukkitImportSystem.java
View File

@ -1,5 +1,6 @@
package com.djrapitops.plan.system.importing;
import com.djrapitops.plan.system.cache.GeolocationCache;
import com.djrapitops.plan.system.database.databases.Database;
import com.djrapitops.plan.system.importing.importers.OfflinePlayerImporter;
import com.djrapitops.plan.system.info.server.ServerInfo;
@ -15,20 +16,23 @@ import javax.inject.Singleton;
@Singleton
public class BukkitImportSystem extends ImportSystem {
private final GeolocationCache geolocationCache;
private final Database database;
private final ServerInfo serverInfo;
@Inject
public BukkitImportSystem(
GeolocationCache geolocationCache,
Database database,
ServerInfo serverInfo
) {
this.geolocationCache = geolocationCache;
this.database = database;
this.serverInfo = serverInfo;
}
@Override
void registerImporters() {
registerImporter(new OfflinePlayerImporter(database, serverInfo));
registerImporter(new OfflinePlayerImporter(geolocationCache, database, serverInfo));
}
}

11
Plan/src/main/java/com/djrapitops/plan/system/importing/importers/Importer.java
View File

@ -36,12 +36,19 @@ import java.util.stream.Collectors;
*/
public abstract class Importer {
private final GeolocationCache geolocationCache;
private final Database database;
private final UUID serverUUID;
private final String name;
protected Importer(Database database, ServerInfo serverInfo, String name) {
protected Importer(
GeolocationCache geolocationCache,
Database database,
ServerInfo serverInfo,
String name
) {
this.geolocationCache = geolocationCache;
this.database = database;
this.serverUUID = serverInfo.getServerUUID();
@ -188,7 +195,7 @@ public abstract class Importer {
return userImportData.getIps().parallelStream()
.map(ip -> {
String geoLoc = GeolocationCache.getCountry(ip);
String geoLoc = geolocationCache.getCountry(ip);
try {
return new GeoInfo(ip, geoLoc, date, new SHA256Hash(ip).create());
} catch (NoSuchAlgorithmException e) {

4
Plan/src/main/java/com/djrapitops/plan/system/importing/importers/OfflinePlayerImporter.java
View File

@ -4,6 +4,7 @@
*/
package com.djrapitops.plan.system.importing.importers;
import com.djrapitops.plan.system.cache.GeolocationCache;
import com.djrapitops.plan.system.database.databases.Database;
import com.djrapitops.plan.system.importing.data.ServerImportData;
import com.djrapitops.plan.system.importing.data.UserImportData;
@ -27,10 +28,11 @@ public class OfflinePlayerImporter extends Importer {
@Inject
public OfflinePlayerImporter(
GeolocationCache geolocationCache,
Database database,
ServerInfo serverInfo
) {
super(database, serverInfo, "offline");
super(geolocationCache, database, serverInfo, "offline");
}
@Override

7
Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/IPUpdateProcessor.java
View File

@ -25,21 +25,24 @@ public class IPUpdateProcessor implements CriticalRunnable {
private final long time;
private final Database database;
private final GeolocationCache geolocationCache;
IPUpdateProcessor(
UUID uuid, InetAddress ip, long time,
Database database
Database database,
GeolocationCache geolocationCache
) {
this.uuid = uuid;
this.ip = ip;
this.time = time;
this.database = database;
this.geolocationCache = geolocationCache;
}
@Override
public void run() {
try {
String country = GeolocationCache.getCountry(ip.getHostAddress());
String country = geolocationCache.getCountry(ip.getHostAddress());
GeoInfo geoInfo = new GeoInfo(ip, country, time);
database.save().geoInfo(uuid, geoInfo);
} catch (NoSuchAlgorithmException ignore) {

8
Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/PlayerProcessors.java
View File

@ -2,6 +2,7 @@ package com.djrapitops.plan.system.processing.processors.player;
import com.djrapitops.plan.data.store.objects.DateObj;
import com.djrapitops.plan.system.cache.DataCache;
import com.djrapitops.plan.system.cache.GeolocationCache;
import com.djrapitops.plan.system.database.databases.Database;
import com.djrapitops.plan.system.processing.Processing;
import dagger.Lazy;
@ -24,16 +25,19 @@ public class PlayerProcessors {
private final Lazy<Processing> processing;
private final Lazy<Database> database;
private final Lazy<DataCache> dataCache;
private final Lazy<GeolocationCache> geolocationCache;
@Inject
public PlayerProcessors(
Lazy<Processing> processing,
Lazy<Database> database,
Lazy<DataCache> dataCache
Lazy<DataCache> dataCache,
Lazy<GeolocationCache> geolocationCache
) {
this.processing = processing;
this.database = database;
this.dataCache = dataCache;
this.geolocationCache = geolocationCache;
}
public BanAndOpProcessor banAndOpProcessor(UUID uuid, Supplier<Boolean> banned, boolean op) {
@ -49,7 +53,7 @@ public class PlayerProcessors {
}
public IPUpdateProcessor ipUpdateProcessor(UUID uuid, InetAddress ip, long time) {
return new IPUpdateProcessor(uuid, ip, time, database.get());
return new IPUpdateProcessor(uuid, ip, time, database.get(), geolocationCache.get());
}
public KickProcessor kickProcessor(UUID uuid) {

80
Plan/src/test/java/com/djrapitops/plan/data/cache/GeolocationCacheTest.java vendored
View File

@ -1,80 +0,0 @@
package com.djrapitops.plan.data.cache;
import com.djrapitops.plan.system.cache.CacheSystem;
import com.djrapitops.plan.system.cache.GeolocationCache;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
import utilities.mocks.SystemMockUtil;
import java.util.HashMap;
import java.util.Map;
import static junit.framework.TestCase.*;
/**
* @author Fuzzlemann
*/
@RunWith(MockitoJUnitRunner.Silent.class)
public class GeolocationCacheTest {
private final Map<String, String> ipsToCountries = new HashMap<>();
@ClassRule
public static TemporaryFolder temporaryFolder = new TemporaryFolder();
@BeforeClass
public static void setUpClass() throws Exception {
SystemMockUtil.setUp(temporaryFolder.getRoot())
.enableConfigSystem()
.enableCacheSystem();
}
@Before
public void setUp() {
CacheSystem.getInstance().getGeolocationCache().clearCache();
ipsToCountries.put("8.8.8.8", "United States");
ipsToCountries.put("8.8.4.4", "United States");
ipsToCountries.put("4.4.2.2", "United States");
ipsToCountries.put("208.67.222.222", "United States");
ipsToCountries.put("208.67.220.220", "United States");
ipsToCountries.put("205.210.42.205", "Canada");
ipsToCountries.put("64.68.200.200", "Canada");
ipsToCountries.put("0.0.0.0", "Not Known");
ipsToCountries.put("127.0.0.1", "Local Machine");
}
@Test
public void testCountryGetting() {
for (Map.Entry<String, String> entry : ipsToCountries.entrySet()) {
String ip = entry.getKey();
String expCountry = entry.getValue();
String country = GeolocationCache.getCountry(ip);
assertEquals(country, expCountry);
}
}
@Test
public void testCaching() {
for (Map.Entry<String, String> entry : ipsToCountries.entrySet()) {
String ip = entry.getKey();
String expIp = entry.getValue();
assertFalse(GeolocationCache.isCached(ip));
String countrySecondCall = GeolocationCache.getCountry(ip);
assertTrue(GeolocationCache.isCached(ip));
String countryThirdCall = GeolocationCache.getCountry(ip);
assertEquals(countrySecondCall, countryThirdCall);
assertEquals(countryThirdCall, expIp);
}
}
}

99
Plan/src/test/java/com/djrapitops/plan/system/cache/GeolocationCacheTest.java vendored
View File

@ -1,55 +1,92 @@
package com.djrapitops.plan.system.cache;
import com.djrapitops.plan.Plan;
import com.djrapitops.plan.api.exceptions.EnableException;
import com.djrapitops.plan.system.PlanSystem;
import com.djrapitops.plugin.StaticHolder;
import com.djrapitops.plan.system.file.FileSystem;
import com.djrapitops.plan.system.locale.Locale;
import com.djrapitops.plan.system.settings.config.PlanConfig;
import com.djrapitops.plugin.logging.console.TestPluginLogger;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import utilities.mocks.BukkitMockUtil;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import utilities.mocks.SystemMockUtil;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import static junit.framework.TestCase.*;
import static org.mockito.Mockito.doReturn;
/**
* Test for GeolocationCache.
*
* @author Rsl1122
* @author Fuzzlemann
*/
@RunWith(MockitoJUnitRunner.Silent.class)
public class GeolocationCacheTest {
private final Map<String, String> ipsToCountries = new HashMap<>();
@Mock
private FileSystem fileSystem;
@Mock
private PlanConfig config;
private GeolocationCache geolocationCache;
@ClassRule
public static TemporaryFolder temporaryFolder = new TemporaryFolder();
private static Plan planMock;
@BeforeClass
public static void setUpClass() throws Exception {
BukkitMockUtil mockUtil = BukkitMockUtil.setUp()
.withDataFolder(temporaryFolder.getRoot())
.withLogging()
.withPluginDescription()
.withResourceFetchingFromJar()
.withServer();
planMock = mockUtil.getPlanMock();
StaticHolder.saveInstance(GeolocationCacheTest.class, planMock.getClass());
SystemMockUtil.setUp(temporaryFolder.getRoot())
.enableConfigSystem()
.enableCacheSystem();
}
@Before
public void setUp() throws IOException {
doReturn(temporaryFolder.newFile("GeoIP.dat")).when(fileSystem.getFileFromPluginFolder("GeoIP.dat"));
geolocationCache = new GeolocationCache(new Locale(), fileSystem, config, new TestPluginLogger());
ipsToCountries.put("8.8.8.8", "United States");
ipsToCountries.put("8.8.4.4", "United States");
ipsToCountries.put("4.4.2.2", "United States");
ipsToCountries.put("208.67.222.222", "United States");
ipsToCountries.put("208.67.220.220", "United States");
ipsToCountries.put("205.210.42.205", "Canada");
ipsToCountries.put("64.68.200.200", "Canada");
ipsToCountries.put("0.0.0.0", "Not Known");
ipsToCountries.put("127.0.0.1", "Local Machine");
}
@Test
@Ignore
public void testGeolocationCache() throws EnableException {
// Settings.WEBSERVER_PORT.setTemporaryValue(9005);
PlanSystem system = null; //TODO
try {
system.enable();
public void testCountryGetting() {
for (Map.Entry<String, String> entry : ipsToCountries.entrySet()) {
String ip = entry.getKey();
String expCountry = entry.getValue();
String expected = "Germany";
String result = GeolocationCache.getCountry("141.52.255.1");
assertEquals(expected, result);
} finally {
system.disable();
String country = geolocationCache.getCountry(ip);
assertEquals(country, expCountry);
}
}
}
@Test
public void testCaching() {
for (Map.Entry<String, String> entry : ipsToCountries.entrySet()) {
String ip = entry.getKey();
String expIp = entry.getValue();
assertFalse(geolocationCache.isCached(ip));
String countrySecondCall = geolocationCache.getCountry(ip);
assertTrue(geolocationCache.isCached(ip));
String countryThirdCall = geolocationCache.getCountry(ip);
assertEquals(countrySecondCall, countryThirdCall);
assertEquals(countryThirdCall, expIp);
}
}
}