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

@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 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 shouldGeLimitSingleWindowReactive() {

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

        Flux<Boolean> geLimitLimitFlux = Flux
                .just("ip:127.0.1.2")
                .repeat(3)
                .flatMap(key -> {
                    timeBandit.addUnixTimeMilliSeconds(100);
                    return rateLimiter.geLimitWhenIncrementedReactive(key);
                });

        geLimitLimitFlux.toStream().forEach(result -> assertThat(result).isFalse());

        assertThat(rateLimiter.geLimitWhenIncrementedReactive("ip:127.0.1.2").block()).isTrue();
}
 

@Test
void shouldLimitSingleWindowReactive() {

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

    Flux<Boolean> overLimitFlux = Flux
            .just("ip:127.0.1.5")
            .repeat(4)
            .flatMap(key -> {
                timeBandit.addUnixTimeMilliSeconds(100);
                return rateLimiter.overLimitWhenIncrementedReactive(key);
            });

    overLimitFlux.toStream().forEach(result -> assertThat(result).isFalse());

    assertThat(rateLimiter.overLimitWhenIncrementedReactive("ip:127.0.1.5").block()).isTrue();
}
 

@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 @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
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 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 shouldReloadMissingScript() {
    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(60), 1));
    ReactiveRequestRateLimiter rateLimiter = getRateLimiter(rules, new SystemTimeSupplier());

    rateLimiter.overLimitWhenIncrementedReactive(UUID.randomUUID().toString()).block(Duration.ofSeconds(5));

    getRedisScriptingReactiveCommands().scriptFlush().block();

    rateLimiter.overLimitWhenIncrementedReactive(UUID.randomUUID().toString()).block(Duration.ofSeconds(5));
}
 

public RedisSlidingWindowRequestRateLimiter(RedisScriptingReactiveCommands<String, String> redisScriptingReactiveCommands, RedisKeyReactiveCommands<String, String> redisKeyCommands, Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    requireNonNull(rules, "rules can not be null");
    requireNonNull(timeSupplier, "time supplier can not be null");
    requireNonNull(redisScriptingReactiveCommands, "redisScriptingReactiveCommands can not be null");
    requireNonNull(redisKeyCommands, "redisKeyCommands can not be null");
    this.redisScriptingReactiveCommands = redisScriptingReactiveCommands;
    this.redisKeyCommands = redisKeyCommands;
    scriptLoader = new RedisScriptLoader(redisScriptingReactiveCommands, "sliding-window-ratelimit.lua");
    requestLimitRulesSupplier = new SerializedRequestLimitRulesSupplier(rules);
    this.timeSupplier = timeSupplier;
}
 

@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 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);
}
 

SerializedRequestLimitRulesSupplier(Set<RequestLimitRule> rules) {
    this.serializedRuleMap = RequestLimitRulesSupplier.buildRuleMap(rules)
            .entrySet()
            .stream()
            .collect(Collectors.toMap(Map.Entry::getKey, kv -> serialiser.encode(kv.getValue()) ));
    this.serializedDefaultRuleSet = serialiser.encode(RequestLimitRulesSupplier.buildDefaultRuleSet(rules));
}
 

@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 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
@DisplayName("should encode limit rule in JSON array")
void shouldEncode() {

    ImmutableList<RequestLimitRule> rules = ImmutableList.of(RequestLimitRule.of(Duration.ofSeconds(10), 10L),
            RequestLimitRule.of(Duration.ofMinutes(1), 20L));

    assertThat(serialiser.encode(rules)).isEqualTo("[[10,10,10],[60,20,60]]");
}
 

public HazelcastSlidingWindowRequestRateLimiter(HazelcastInstance hz, Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    requireNonNull(hz, "hazelcast can not be null");
    requireNonNull(rules, "rules can not be null");
    if (rules.isEmpty()) {
        throw new IllegalArgumentException("at least one rule must be provided");
    }
    requireNonNull(rules, "time supplier can not be null");
    this.hz = hz;
    this.rulesSupplier = new DefaultRequestLimitRulesSupplier(rules);
    this.timeSupplier = timeSupplier;
}
 

@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);
}
 

@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
@DisplayName("should encode limit rule with precision in JSON array")
void shouldEncodeWithPrecisions() {

    ImmutableList<RequestLimitRule> rules = ImmutableList.of(RequestLimitRule.of(Duration.ofSeconds(10), 10L).withPrecision(Duration.ofSeconds(4)),
            RequestLimitRule.of(Duration.ofMinutes(1), 20L).withPrecision(Duration.ofSeconds(8)));

    assertThat(serialiser.encode(rules)).isEqualTo("[[10,10,4],[60,20,8]]");
}
 

InMemorySlidingWindowRequestRateLimiter(ExpiringMap<String, ConcurrentMap<String, Long>> expiringKeyMap, Set<RequestLimitRule> rules, TimeSupplier timeSupplier) {
    requireNonNull(rules, "rules can not be null");
    requireNonNull(rules, "time supplier can not be null");
    if (rules.isEmpty()) {
        throw new IllegalArgumentException("at least one rule must be provided");
    }
    this.expiringKeyMap = expiringKeyMap;
    this.timeSupplier = timeSupplier;
    this.rulesSupplier = new DefaultRequestLimitRulesSupplier(rules);
}
 

@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();
}
 

@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 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 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();
}
 

/**
 * @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 shouldLimitDualWindowReactive() {

    ImmutableSet<RequestLimitRule> rules = ImmutableSet.of(RequestLimitRule.of(Duration.ofSeconds(1), 5), RequestLimitRule.of(Duration.ofSeconds(10), 10));
    ReactiveRequestRateLimiter rateLimiter = getRateLimiter(rules, timeBandit);

    Flux
            .just("ip:127.0.1.6")
            .repeat(4)
            .flatMap(key -> {
                timeBandit.addUnixTimeMilliSeconds(100);
                return rateLimiter.overLimitWhenIncrementedReactive(key);
            })
            .toStream()
            .forEach(result -> assertThat(result).isFalse());

    timeBandit.addUnixTimeMilliSeconds(1000L);

    Flux
            .just("ip:127.0.1.6")
            .repeat(4)
            .flatMap(key -> {
                timeBandit.addUnixTimeMilliSeconds(100);
                return rateLimiter.overLimitWhenIncrementedReactive(key);
            })
            .toStream()
            .forEach(result -> assertThat(result).isFalse());

    assertThat(rateLimiter.overLimitWhenIncrementedReactive("ip:127.0.1.6").block()).isTrue();
}
 

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

    String key = "ip:127.1.0.1";

    assertThat(rateLimiter.overLimitWhenIncrementedReactive(key).block()).isFalse();
    assertThat(rateLimiter.overLimitWhenIncrementedReactive(key).block()).isTrue();

    assertThat(rateLimiter.resetLimitReactive(key).block()).isTrue();
    assertThat(rateLimiter.resetLimitReactive(key).block()).isFalse();

    assertThat(rateLimiter.overLimitWhenIncrementedReactive(key).block()).isFalse();
}
 

public RedisSlidingWindowRequestRateLimiter(RedisScriptingReactiveCommands<String, String> redisScriptingReactiveCommands, RedisKeyReactiveCommands<String, String> redisKeyCommands, Set<RequestLimitRule> rules) {
    this(redisScriptingReactiveCommands, redisKeyCommands, rules, new SystemTimeSupplier());
}