Added InMemoryRateLimiterFactory

ratelimitj-core/src/main/java/es/moki/ratelimitj/core/limiter/request/RequestLimitRule.java

@@ -86,4 +86,5 @@ public long getLimit() {
         return limit;
     }
 
+
 }

ratelimitj-dropwizard/build.gradle

@@ -19,6 +19,7 @@ dependencies {
 
     testImplementation(
             project(':ratelimitj-redis'),
+            project(':ratelimitj-inmemory'),
             project(':ratelimitj-test'),
             "io.dropwizard:dropwizard-testing:${dropWizardVersion}",
             'org.glassfish.jersey.test-framework.providers:jersey-test-framework-provider-grizzly2:2.25.1',

ratelimitj-dropwizard/src/test/java/es/moki/ratelimij/dropwizard/component/app/RateLimitApplication.java

@@ -7,7 +7,7 @@
 import es.moki.ratelimij.dropwizard.component.app.api.UserResource;
 import es.moki.ratelimij.dropwizard.component.app.auth.TestOAuthAuthenticator;
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiterFactory;
-import es.moki.ratelimitj.redis.RedisRequestRateLimiterFactory;
+import es.moki.ratelimitj.inmemory.InMemoryRateLimiterFactory;
 import io.dropwizard.Application;
 import io.dropwizard.Configuration;
 import io.dropwizard.auth.AuthDynamicFeature;
@@ -25,7 +25,9 @@ public class RateLimitApplication extends Application<Configuration> {
 
     public void initialize(Bootstrap<Configuration> bootstrap) {
         redisClient = RedisClient.create("redis://localhost");
-        RequestRateLimiterFactory factory = new RedisRequestRateLimiterFactory(redisClient);
+//        RequestRateLimiterFactory factory = new RedisRateLimiterFactory(redisClient);
+
+        RequestRateLimiterFactory factory = new InMemoryRateLimiterFactory();
 
         bootstrap.addBundle(new RateLimitBundle(factory));
     }

ratelimitj-inmemory/src/main/java/es/moki/ratelimitj/inmemory/InMemoryRateLimiterFactory.java

@@ -0,0 +1,43 @@
+package es.moki.ratelimitj.inmemory;
+
+
+import es.moki.ratelimitj.core.limiter.request.AsyncRequestRateLimiter;
+import es.moki.ratelimitj.core.limiter.request.ReactiveRequestRateLimiter;
+import es.moki.ratelimitj.core.limiter.request.RequestLimitRule;
+import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
+import es.moki.ratelimitj.core.limiter.request.RequestRateLimiterFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Set;
+
+public class InMemoryRateLimiterFactory implements RequestRateLimiterFactory {
+
+    private static final Logger LOG = LoggerFactory.getLogger(InMemoryRateLimiterFactory.class);
+
+    @Override
+    public RequestRateLimiter getInstance(Set<RequestLimitRule> rules) {
+        LOG.info("creating new InMemorySlidingWindowRequestRateLimiter");
+        return lookupInstance(rules);
+    }
+
+    @Override
+    public AsyncRequestRateLimiter getInstanceAsync(Set<RequestLimitRule> rules) {
+        throw new RuntimeException("In memory async not yet implemented");
+    }
+
+    @Override
+    public ReactiveRequestRateLimiter getInstanceReactive(Set<RequestLimitRule> rules) {
+        throw new RuntimeException("In memory reactive not yet implemented");
+    }
+
+    private RequestRateLimiter lookupInstance(Set<RequestLimitRule> rules) {
+        return new InMemorySlidingWindowRequestRateLimiter(rules);
+    }
+
+    @Override
+    public void close() throws IOException {
+
+    }
+}

ratelimitj-redis/src/main/java/es/moki/ratelimitj/redis/RedisRequestRateLimiterFactory.java → ratelimitj-redis/src/main/java/es/moki/ratelimitj/redis/RedisRateLimiterFactory.java

@@ -3,37 +3,46 @@
 import com.lambdaworks.redis.RedisClient;
 import com.lambdaworks.redis.api.StatefulRedisConnection;
 import es.moki.ratelimitj.core.limiter.request.AsyncRequestRateLimiter;
+import es.moki.ratelimitj.core.limiter.request.ReactiveRequestRateLimiter;
 import es.moki.ratelimitj.core.limiter.request.RequestLimitRule;
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
 import es.moki.ratelimitj.core.limiter.request.RequestRateLimiterFactory;
-import es.moki.ratelimitj.core.limiter.request.ReactiveRequestRateLimiter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.util.Set;
 
 import static java.util.Objects.requireNonNull;
 
-public class RedisRequestRateLimiterFactory implements RequestRateLimiterFactory {
+public class RedisRateLimiterFactory implements RequestRateLimiterFactory {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RedisRateLimiterFactory.class);
 
     private final RedisClient client;
     private StatefulRedisConnection<String, String> connection;
 
-    public RedisRequestRateLimiterFactory(RedisClient client) {
+    public RedisRateLimiterFactory(RedisClient client) {
         this.client = requireNonNull(client);
     }
 
     @Override
     public RequestRateLimiter getInstance(Set<RequestLimitRule> rules) {
-        return new RedisSlidingWindowRequestRateLimiter(getConnection(), rules);
+        return create(rules);
     }
 
     @Override
     public AsyncRequestRateLimiter getInstanceAsync(Set<RequestLimitRule> rules) {
-        return new RedisSlidingWindowRequestRateLimiter(getConnection(), rules);
+        return create(rules);
     }
 
     @Override
     public ReactiveRequestRateLimiter getInstanceReactive(Set<RequestLimitRule> rules) {
+        return create(rules);
+    }
+
+    private RedisSlidingWindowRequestRateLimiter create(Set<RequestLimitRule> rules) {
+        LOG.info("creating new RedisSlidingWindowRequestRateLimiter");
         return new RedisSlidingWindowRequestRateLimiter(getConnection(), rules);
     }