es.moki.ratelimitj.core.limiter.request.RequestRateLimiter Java Examples

@Test
void shouldEventuallyCleanUpExpiredKeys() throws Exception {
    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(2), 5));
    RequestRateLimiter requestRateLimiter = getRateLimiter(rules, timeBandit);

    String key = "ip:127.0.0.5";

    IntStream.rangeClosed(1, 5).forEach(value -> {
        timeBandit.addUnixTimeMilliSeconds(100L);
        assertThat(requestRateLimiter.overLimitWhenIncremented(key)).isFalse();
    });

    IMap<Object, Object> map = hz.getMap(key);
    while (map.size() != 0) {
        Thread.sleep(10);
    }
    assertThat(map.size()).isZero();
}
 

@Test
void shouldLimitSingleWindowSyncWithMultipleKeys() {

    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(10), 5));
    RequestRateLimiter requestRateLimiter = getRateLimiter(rules, timeBandit);

    IntStream.rangeClosed(1, 5).forEach(value -> {
        timeBandit.addUnixTimeMilliSeconds(1000L);
        IntStream.rangeClosed(1, 10).forEach(
                keySuffix -> assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.0.0." + keySuffix)).isFalse());
    });

    IntStream.rangeClosed(1, 10).forEach(
            keySuffix -> assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.0.0." + keySuffix)).isTrue());

    timeBandit.addUnixTimeMilliSeconds(5000L);
    IntStream.rangeClosed(1, 10).forEach(
            keySuffix -> assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.0.0." + keySuffix)).isFalse());
}
 

@Test
void shouldLimitSingleWindowSyncWithKeySpecificRules() {

    RequestLimitRule rule1 = RequestLimitRule.of(Duration.ofSeconds(10), 5).matchingKeys("ip:127.9.0.0");
    RequestLimitRule rule2 = RequestLimitRule.of(Duration.ofSeconds(10), 10);

    RequestRateLimiter requestRateLimiter = getRateLimiter(ImmutableSet.of(rule1, rule2), timeBandit);

    IntStream.rangeClosed(1, 5).forEach(value -> {
        timeBandit.addUnixTimeMilliSeconds(1000L);
        assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.9.0.0")).isFalse();
    });
    assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.9.0.0")).isTrue();

    IntStream.rangeClosed(1, 10).forEach(value -> assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.9.1.0")).isFalse());
    assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.9.1.0")).isTrue();
}
 

@Test
void shouldRateLimitOverTime() {
    RequestLimitRule rule1 = RequestLimitRule.of(Duration.ofSeconds(5), 250).withPrecision(Duration.ofSeconds(1)).matchingKeys("ip:127.3.9.3");
    RequestRateLimiter requestRateLimiter = getRateLimiter(ImmutableSet.of(rule1), timeBandit);
    AtomicLong timeOfLastOperation = new AtomicLong();

    IntStream.rangeClosed(1, 50).forEach(loop -> {

        IntStream.rangeClosed(1, 250).forEach(value -> {
            timeBandit.addUnixTimeMilliSeconds(14L);
            boolean overLimit = requestRateLimiter.overLimitWhenIncremented("ip:127.3.9.3");
            if (overLimit) {
                long timeSinceLastOperation = timeBandit.get() - timeOfLastOperation.get();
                assertThat(timeSinceLastOperation).isLessThan(3);
            } else {
                timeOfLastOperation.set(timeBandit.get());
            }
        });

    });
}
 

@Test @Disabled
void shouldPreventThunderingHerdWithPrecision() {

    RequestLimitRule rule1 = RequestLimitRule.of(Duration.ofSeconds(5), 250).withPrecision(Duration.ofSeconds(1)).matchingKeys("ip:127.9.9.9");
    RequestRateLimiter requestRateLimiter = getRateLimiter(ImmutableSet.of(rule1), timeBandit);
    Map<Long, Integer> underPerSecond = new LinkedHashMap<>();
    Map<Long, Integer> overPerSecond = new HashMap<>();

    IntStream.rangeClosed(1, 50).forEach(loop -> {

        IntStream.rangeClosed(1, 250).forEach(value -> {
            timeBandit.addUnixTimeMilliSeconds(14L);
            boolean overLimit = requestRateLimiter.overLimitWhenIncremented("ip:127.9.9.9");
            if (!overLimit) {
                underPerSecond.merge(timeBandit.get(), 1, Integer::sum);
            } else {
                overPerSecond.merge(timeBandit.get(), 1, Integer::sum);
            }
        });

    });

    Set<Long> allSeconds = Sets.newTreeSet(Sets.union(underPerSecond.keySet(), overPerSecond.keySet()));

    allSeconds.forEach((k)->System.out.println("Time seconds : " + k + " under count : " + underPerSecond.get(k) + " over count : " + overPerSecond.get(k)));
}
 

@Test
@Disabled
void shouldEventuallyCleanUpExpiredKeys() throws Exception {
    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(1), 5));
    RequestRateLimiter requestRateLimiter = getRateLimiter(rules, timeBandit);

    String key = "ip:127.0.0.5";

    IntStream.rangeClosed(1, 5).forEach(value -> {
        timeBandit.addUnixTimeMilliSeconds(100L);
        assertThat(requestRateLimiter.overLimitWhenIncremented(key)).isFalse();
    });

    while (expiryingKeyMap.size() != 0) {
        Thread.sleep(50);
    }

    assertThat(expiryingKeyMap.size()).isZero();
}
 

@Test
void shouldNotReturnTheSameInstanceForSameRules() {

    RequestLimitRule rule1 = RequestLimitRule.of(Duration.ofMinutes(1), 22);
    RequestRateLimiter rateLimiter1 = factory.getInstance(ImmutableSet.of(rule1));

    RequestLimitRule rule2 = RequestLimitRule.of(Duration.ofMinutes(1), 33);
    RequestRateLimiter rateLimiter2 = factory.getInstance(ImmutableSet.of(rule2));

    assertThat(rateLimiter1).isNotSameAs(rateLimiter2);
}
 

@Bean
public RedisSlidingWindowByMobileRateLimiter redisSlidingWindowByMobileRateLimiter(
        RequestRateLimiterFactory redisRateLimiterFactory, SlidingWindowProperties slidingWindowProperties) {
    Set<RequestLimitRule> rules = Collections.singleton(
            RequestLimitRule.of(slidingWindowProperties.getDuration(), slidingWindowProperties.getLimit()));
    RequestRateLimiter requestRateLimiter = redisRateLimiterFactory.getInstance(rules);
    return new RedisSlidingWindowByMobileRateLimiter(requestRateLimiter);
}
 

@Test
void shouldReturnTheSameInstanceForSameSetOfRules() {

    RequestLimitRule rule1a = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestLimitRule rule1b = RequestLimitRule.of(Duration.ofHours(1), 100);
    RequestRateLimiter rateLimiter1 = factory.getInstance(ImmutableSet.of(rule1a, rule1b));

    RequestLimitRule rule2a = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestLimitRule rule2b = RequestLimitRule.of(Duration.ofHours(1), 100);
    RequestRateLimiter rateLimiter2 = factory.getInstance(ImmutableSet.of(rule2a, rule2b));

    assertThat(rateLimiter1).isSameAs(rateLimiter2);
}
 

@Test
void shouldReturnTheSameInstanceForSameRules() {

    RequestLimitRule rule1 = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestRateLimiter rateLimiter1 = factory.getInstance(ImmutableSet.of(rule1));

    RequestLimitRule rule2 = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestRateLimiter rateLimiter2 = factory.getInstance(ImmutableSet.of(rule2));

    assertThat(rateLimiter1).isSameAs(rateLimiter2);
}
 

@Test
void shouldNotReturnTheSameInstanceForSameRules() {

    RequestLimitRule rule1 = RequestLimitRule.of(Duration.ofMinutes(1), 22);
    RequestRateLimiter rateLimiter1 = factory.getInstance(ImmutableSet.of(rule1));

    RequestLimitRule rule2 = RequestLimitRule.of(Duration.ofMinutes(1), 33);
    RequestRateLimiter rateLimiter2 = factory.getInstance(ImmutableSet.of(rule2));

    assertThat(rateLimiter1).isNotSameAs(rateLimiter2);
}
 

@Test
void shouldReturnTheSameInstanceForSameSetOfRules() {

    RequestLimitRule rule1a = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestLimitRule rule1b = RequestLimitRule.of(Duration.ofHours(1), 100);
    RequestRateLimiter rateLimiter1 = factory.getInstance(ImmutableSet.of(rule1a, rule1b));

    RequestLimitRule rule2a = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestLimitRule rule2b = RequestLimitRule.of(Duration.ofHours(1), 100);
    RequestRateLimiter rateLimiter2 = factory.getInstance(ImmutableSet.of(rule2a, rule2b));

    assertThat(rateLimiter1).isSameAs(rateLimiter2);
}
 

@Test
void shouldReturnTheSameInstanceForSameRules() {

    RequestLimitRule rule1 = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestRateLimiter rateLimiter1 = factory.getInstance(ImmutableSet.of(rule1));

    RequestLimitRule rule2 = RequestLimitRule.of(Duration.ofMinutes(1), 10);
    RequestRateLimiter rateLimiter2 = factory.getInstance(ImmutableSet.of(rule2));

    assertThat(rateLimiter1).isSameAs(rateLimiter2);
}
 

/**
 * @param seconds
 * @param limit
 * @return
 */
public static RequestRateLimiter createRateLimiter(long[] seconds, int[] limit) {
    Assert.isTrue(seconds.length == limit.length, "Rule pair not matchs");

    Set<RequestLimitRule> rules = new HashSet<>();
    for (int i = 0; i < seconds.length; i++) {
        rules.add(RequestLimitRule.of(Duration.ofSeconds(seconds[i]), limit[i]));
    }
    return new InMemorySlidingWindowRequestRateLimiter(rules);
}
 

@Test
void shouldResetLimit() {
    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(60), 1));
    RequestRateLimiter requestRateLimiter = getRateLimiter(rules, timeBandit);

    String key = "ip:127.1.0.1";
    assertThat(requestRateLimiter.overLimitWhenIncremented(key)).isFalse();
    assertThat(requestRateLimiter.overLimitWhenIncremented(key)).isTrue();

    assertThat(requestRateLimiter.resetLimit(key)).isTrue();
    assertThat(requestRateLimiter.resetLimit(key)).isFalse();

    assertThat(requestRateLimiter.overLimitWhenIncremented(key)).isFalse();
}
 

@Test
void shouldLimitWithWeightSingleWindowSync() {

    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(10), 10));
    RequestRateLimiter requestRateLimiter = getRateLimiter(rules, timeBandit);

    IntStream.rangeClosed(1, 5).forEach(value -> {
        timeBandit.addUnixTimeMilliSeconds(1000L);
        assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.0.1.2", 2)).isFalse();
    });

    assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.0.1.2", 2)).isTrue();
}
 

@Test
void shouldGeLimitSingleWindowSync() {

    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(10), 5));
    RequestRateLimiter requestRateLimiter = getRateLimiter(rules, timeBandit);

    IntStream.rangeClosed(1, 4).forEach(value -> {
        timeBandit.addUnixTimeMilliSeconds(1000L);
        assertThat(requestRateLimiter.geLimitWhenIncremented("ip:127.0.1.2")).isFalse();
    });

    assertThat(requestRateLimiter.geLimitWhenIncremented("ip:127.0.1.2")).isTrue();
}
 

@Test
void shouldLimitSingleWindowSync()  {

    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(10), 5));
    RequestRateLimiter requestRateLimiter = getRateLimiter(rules, timeBandit);

    IntStream.rangeClosed(1, 5).forEach(value -> {
        timeBandit.addUnixTimeMilliSeconds(1000L);
        assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.0.1.1")).isFalse();
    });

    assertThat(requestRateLimiter.overLimitWhenIncremented("ip:127.0.1.1")).isTrue();
}
 

@Override
protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new InMemorySlidingWindowRequestRateLimiter(rules, timeSupplier);
}
 

@Override
protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new RedisSlidingWindowRequestRateLimiter(extension.getScriptingReactiveCommands(), extension.getKeyReactiveCommands(), rules, timeSupplier);
}
 

@Override
protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new RedisSlidingWindowRequestRateLimiter(extension.getScriptingReactiveCommands(), extension.getKeyReactiveCommands(), rules, timeSupplier);
}
 

@Override
public RequestRateLimiter getInstance(Set<RequestLimitRule> rules) {
    return lookupInstance(rules);
}
 

@Override
protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new HazelcastSlidingWindowRequestRateLimiter(hz, rules, timeSupplier);
}
 

private RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new HazelcastSlidingWindowRequestRateLimiter(hz, rules, timeSupplier);
}
 

@Override
protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new HazelcastSlidingWindowRequestRateLimiter(hz, rules, timeSupplier);
}
 

@Override
public void filter(final ContainerRequestContext requestContext) {

    try {
        AnnotatedMethod method = new AnnotatedMethod(resource.getResourceMethod());
        RateLimited rateLimited = method.getAnnotation(RateLimited.class);

        RequestRateLimiter rateLimit = factory.getInstance(toLimitRules(rateLimited));

        KeyPart[] keyParts = rateLimited.keys();


        Optional<CharSequence> keyResult = KeyPart.combineKeysParts(rateLimited.groupKeyPrefix(), Arrays.asList(keyParts), request, resource, securityContext);


        CharSequence key;
        if (keyResult.isPresent()) {
            key = keyResult.get();
        } else {
            LOG.warn("No keys were provided by the key providers '{}'",
                    Arrays.stream(keyParts)
                            .map(KeyPart::getClass)
                            .map(Object::toString)
                            .collect(Collectors.joining(", ")));
            return;
        }

        boolean overLimit = rateLimit.overLimitWhenIncremented(key.toString());
        if (overLimit) {
            if (!rateLimited.reportOnly()) {
                LOG.info("rate-limit key '{}' over limit. HTTP Status 429 returned.", key);
                requestContext.abortWith(Response.status(HTTP_STATUS_TOO_MANY_REQUESTS).build());
            } else {
                LOG.info("rate-limit key '{}' over limit. ReportOnly is true, no action taken.", key);
            }
            LOG.debug("rate-limit key '{}' under limit.", key);
        }
    } catch (Exception e) {
        LOG.error("Error occurred checking rate-limit. Assuming under limit", e);
    }
}
 

@Override
protected RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new InMemorySlidingWindowRequestRateLimiter(rules, timeSupplier);
}
 

private RequestRateLimiter getRateLimiter(Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    return new InMemorySlidingWindowRequestRateLimiter(expiryingKeyMap, rules, timeSupplier);
}
 

@Override
public RequestRateLimiter getInstance(Set<RequestLimitRule> rules) {
    requireNonNull(rules);
    return lookupInstance(rules);
}
 

/**
 * @param seconds
 * @param limit
 * @return
 */
public static RequestRateLimiter createRateLimiter(long seconds, int limit) {
    Set<RequestLimitRule> rules = Collections.singleton(RequestLimitRule.of(Duration.ofSeconds(seconds), limit));
    return new InMemorySlidingWindowRequestRateLimiter(rules);
}