hazelcast bug fix

mokies · Oct 14, 2017 · d6a34bc · d6a34bc
1 parent 00b75d3
commit d6a34bc
Show file tree

Hide file tree

Showing 9 changed files with 81 additions and 53 deletions.
diff --git a/build.gradle b/build.gradle
@@ -43,6 +43,13 @@ allprojects {
 
     junitPlatform {
         platformVersion '1.0.0'
+        filters {
+            engines {
+                include 'junit-jupiter'
+                // exclude 'junit-vintage'
+            }
+            includeClassNamePatterns '.*Test', '.*Tests'
+        }
     }
 
     dependencies {

diff --git a/ratelimitj-hazelcast/build.gradle b/ratelimitj-hazelcast/build.gradle
@@ -5,7 +5,7 @@ dependencies {
     implementation(
             project(':ratelimitj-core'),
             project(':ratelimitj-inmemory'),
-            'com.hazelcast:hazelcast:3.6.3',
+            'com.hazelcast:hazelcast:3.8.6',
             libraries.slf4j,
             libraries.findbugs
     )

diff --git a/.../src/main/java/es/moki/ratelimitj/hazelcast/HazelcastSlidingWindowRequestRateLimiter.java b/.../src/main/java/es/moki/ratelimitj/hazelcast/HazelcastSlidingWindowRequestRateLimiter.java
@@ -17,6 +17,7 @@
 import java.util.Optional;
 import java.util.Set;
 
+import static es.moki.ratelimitj.core.RateLimitUtils.coalesce;
 import static java.util.Objects.requireNonNull;
 
 @ThreadSafe
@@ -46,7 +47,7 @@ public boolean overLimitWhenIncremented(String key) {
     // TODO support muli keys
     @Override
     public boolean overLimitWhenIncremented(String key, int weight) {
-        return eqOrGeLimit(key, weight, false);
+        return eqOrGeLimit(key, weight, true);
     }
 
     @Override
@@ -56,7 +57,7 @@ public boolean geLimitWhenIncremented(String key) {
 
     @Override
     public boolean geLimitWhenIncremented(String key, int weight) {
-        return eqOrGeLimit(key, weight, true);
+        return eqOrGeLimit(key, weight, false);
     }
 
 //    @Override
@@ -71,11 +72,16 @@ public boolean geLimitWhenIncremented(String key, int weight) {
 
     @Override
     public boolean resetLimit(String key) {
-        throw new RuntimeException("Not implemented");
+        IMap<Object, Object> map = hz.getMap(key);
+        if (map == null || map.isEmpty()) {
+            return false;
+        }
+        map.clear();
+        map.destroy();
+        return true;
     }
 
     private IMap<String, Long> getMap(String key, int longestDuration) {
-
         MapConfig mapConfig = hz.getConfig().getMapConfig(key);
         mapConfig.setTimeToLiveSeconds(longestDuration);
         mapConfig.setAsyncBackupCount(1);
@@ -141,9 +147,9 @@ private boolean eqOrGeLimit(String key, int weight, boolean strictlyGreater) {
             }
 
             // check our limits
-            long count = Optional.ofNullable(cur).orElse(0L) + weight;
+            long count = coalesce(cur, 0L) + weight;
             if (count > rule.getLimit()) {
-                return true; // over limit
+                return true; // over limit, don't record request
             } else if (!strictlyGreater && count == rule.getLimit()) {
                 geLimit = true; // at limit, do record request
             }

diff --git a/...t/src/test/java/es/moki/ratelimitj/hazelcast/HazelcastRequestRateLimiterInternalTest.java b/...t/src/test/java/es/moki/ratelimitj/hazelcast/HazelcastRequestRateLimiterInternalTest.java
@@ -2,21 +2,23 @@
 
 
 import com.google.common.collect.ImmutableSet;
-import com.hazelcast.core.Hazelcast;
+import com.hazelcast.core.DistributedObject;
 import com.hazelcast.core.HazelcastInstance;
 import com.hazelcast.core.IMap;
 import es.moki.ratelimitj.core.limiter.request.RequestLimitRule;
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
-import es.moki.ratelimitj.test.time.TimeBanditSupplier;
 import es.moki.ratelimitj.core.time.TimeSupplier;
+import es.moki.ratelimitj.test.time.TimeBanditSupplier;
 import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.IntStream;
 
+import static es.moki.ratelimitj.hazelcast.HazelcastTestFactory.newStandaloneHazelcastInstance;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class HazelcastRequestRateLimiterInternalTest {
@@ -26,15 +28,20 @@ public class HazelcastRequestRateLimiterInternalTest {
     private final TimeBanditSupplier timeBandit = new TimeBanditSupplier();
 
     @BeforeAll
-    public static void before() {
-        hz = Hazelcast.newHazelcastInstance();
+    public static void beforeAll() {
+        hz = newStandaloneHazelcastInstance();
     }
 
     @AfterAll
-    public static void after() {
+    public static void afterAll() {
         hz.shutdown();
     }
 
+    @AfterEach
+    public void afterEach() {
+        hz.getDistributedObjects().forEach(DistributedObject::destroy);
+    }
+
     private RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
         return new HazelcastSlidingWindowRequestRateLimiter(hz, rules, timeSupplier);
     }

diff --git a/...t/java/es/moki/ratelimitj/hazelcast/HazelcastSlidingWindowSyncRequestRateLimiterTest.java b/...t/java/es/moki/ratelimitj/hazelcast/HazelcastSlidingWindowSyncRequestRateLimiterTest.java
@@ -1,43 +1,49 @@
 package es.moki.ratelimitj.hazelcast;
 
-import com.hazelcast.core.Hazelcast;
+import com.hazelcast.core.DistributedObject;
 import com.hazelcast.core.HazelcastInstance;
 import es.moki.ratelimitj.core.limiter.request.RequestLimitRule;
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
 import es.moki.ratelimitj.core.time.TimeSupplier;
 import es.moki.ratelimitj.test.limiter.request.AbstractSyncRequestRateLimiterTest;
 import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
+import static es.moki.ratelimitj.hazelcast.HazelcastTestFactory.newStandaloneHazelcastInstance;
+
 
 public class HazelcastSlidingWindowSyncRequestRateLimiterTest extends AbstractSyncRequestRateLimiterTest {
 
     private static HazelcastInstance hz;
 
     @BeforeAll
-    public static void before() {
-        hz = Hazelcast.newHazelcastInstance();
+    public static void beforeAll() {
+        hz = newStandaloneHazelcastInstance();
     }
 
     @AfterAll
-    public static void after() {
+    public static void afterAll() {
         hz.shutdown();
     }
 
+    @AfterEach
+    public void afterEach() {
+        hz.getDistributedObjects().forEach(DistributedObject::destroy);
+    }
+
     @Override
     protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
         return new HazelcastSlidingWindowRequestRateLimiter(hz, rules, timeSupplier);
     }
 
-    @Override
-    @Test
-    @Disabled
-    public void shouldResetLimit() {
-
-    }
+//    @Override
+//    @Test
+//    @Disabled
+//    public void shouldResetLimit() {
+//
+//    }
 
 }
diff --git a/...elimitj/hazelcast/HazelcastSlidingWindowSyncRequestRequestRateLimiterPerformanceTest.java b/...elimitj/hazelcast/HazelcastSlidingWindowSyncRequestRequestRateLimiterPerformanceTest.java
@@ -1,31 +1,39 @@
 package es.moki.ratelimitj.hazelcast;
 
-import com.hazelcast.core.Hazelcast;
+import com.hazelcast.core.DistributedObject;
 import com.hazelcast.core.HazelcastInstance;
 import es.moki.ratelimitj.core.limiter.request.RequestLimitRule;
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
 import es.moki.ratelimitj.core.time.TimeSupplier;
 import es.moki.ratelimitj.test.limiter.request.AbstractSyncRequestRateLimiterPerformanceTest;
 import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 
 import java.util.Set;
 
+import static es.moki.ratelimitj.hazelcast.HazelcastTestFactory.newStandaloneHazelcastInstance;
+
 
 public class HazelcastSlidingWindowSyncRequestRequestRateLimiterPerformanceTest extends AbstractSyncRequestRateLimiterPerformanceTest {
 
     private static HazelcastInstance hz;
 
     @BeforeAll
-    public static void before() {
-        hz = Hazelcast.newHazelcastInstance();
+    public static void beforeAll() {
+        hz = newStandaloneHazelcastInstance();
     }
 
     @AfterAll
-    public static void after() {
+    public static void afterAll() {
         hz.shutdown();
     }
 
+    @AfterEach
+    public void afterEach() {
+        hz.getDistributedObjects().forEach(DistributedObject::destroy);
+    }
+
     @Override
     protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
         return new HazelcastSlidingWindowRequestRateLimiter(hz, rules, timeSupplier);

diff --git a/ratelimitj-hazelcast/src/test/java/es/moki/ratelimitj/hazelcast/HazelcastTestFactory.java b/ratelimitj-hazelcast/src/test/java/es/moki/ratelimitj/hazelcast/HazelcastTestFactory.java
@@ -0,0 +1,19 @@
+package es.moki.ratelimitj.hazelcast;
+
+import com.hazelcast.config.Config;
+import com.hazelcast.config.NetworkConfig;
+import com.hazelcast.core.Hazelcast;
+import com.hazelcast.core.HazelcastInstance;
+
+public class HazelcastTestFactory {
+
+    public static HazelcastInstance newStandaloneHazelcastInstance() {
+        Config config = new Config();
+        config.setProperty("hazelcast.logging.type", "slf4j");
+        config.setProperty("hazelcast.shutdownhook.enabled", "false");
+        NetworkConfig network = config.getNetworkConfig();
+        network.getJoin().getTcpIpConfig().setEnabled(false);
+        network.getJoin().getMulticastConfig().setEnabled(false);
+        return Hazelcast.newHazelcastInstance(config);
+    }
+}
diff --git a/.../es/moki/ratelimitj/inmemory/request/InMemorySlidingWindowSyncRequestRateLimiterTest.java b/.../es/moki/ratelimitj/inmemory/request/InMemorySlidingWindowSyncRequestRateLimiterTest.java
@@ -4,24 +4,12 @@
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
 import es.moki.ratelimitj.core.time.TimeSupplier;
 import es.moki.ratelimitj.test.limiter.request.AbstractSyncRequestRateLimiterTest;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
 
 import java.util.Set;
 
 
 public class InMemorySlidingWindowSyncRequestRateLimiterTest extends AbstractSyncRequestRateLimiterTest {
 
-    @BeforeAll
-    public static void before() {
-
-    }
-
-    @AfterAll
-    public static void after() {
-
-    }
-
     @Override
     protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
         return new InMemorySlidingWindowRequestRateLimiter(rules, timeSupplier);

diff --git a/...j/inmemory/request/InMemorySlidingWindowSyncRequestRequestRateLimiterPerformanceTest.java b/...j/inmemory/request/InMemorySlidingWindowSyncRequestRequestRateLimiterPerformanceTest.java
@@ -4,25 +4,12 @@
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
 import es.moki.ratelimitj.core.time.TimeSupplier;
 import es.moki.ratelimitj.test.limiter.request.AbstractSyncRequestRateLimiterPerformanceTest;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
 
 import java.util.Set;
 
 
 public class InMemorySlidingWindowSyncRequestRequestRateLimiterPerformanceTest extends AbstractSyncRequestRateLimiterPerformanceTest {
 
-
-    @BeforeAll
-    public static void before() {
-
-    }
-
-    @AfterAll
-    public static void after() {
-
-    }
-
     @Override
     protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
         return new InMemorySlidingWindowRequestRateLimiter(rules, timeSupplier);