Signal/Signal-Server
1
0
Fork 0
mirror of https://github.com/signalapp/Signal-Server synced 2026-04-22 06:38:05 +01:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Move rate limiter logic to Lua scripts"

Browse Source 
This reverts commit b585c6676d.
This commit is contained in:
Jon Chambers
2020-07-08 11:53:16 -04:00
committed by Jon Chambers
parent 062bf737c2
commit c5d0d4acd0
8 changed files with 286 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
service/src/test/java/org/whispersystems/textsecuregcm/limits/RateLimiterTest.java
View File

@@ -1,114 +0,0 @@
package org.whispersystems.textsecuregcm.limits;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration;
import org.whispersystems.textsecuregcm.controllers.RateLimitExceededException;
import org.whispersystems.textsecuregcm.providers.RedisClientFactory;
import org.whispersystems.textsecuregcm.redis.AbstractRedisClusterTest;
import org.whispersystems.textsecuregcm.redis.ReplicatedJedisPool;
import redis.clients.jedis.Jedis;
import redis.embedded.RedisServer;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.List;
import java.util.concurrent.TimeUnit;
import static org.junit.Assert.fail;
public class RateLimiterTest extends AbstractRedisClusterTest {
private static final long NOW_MILLIS = System.currentTimeMillis();
private static final String KEY = "key";
private RedisServer redisServer;
private ReplicatedJedisPool replicatedJedisPool;
@FunctionalInterface
private interface RateLimitedTask {
void run() throws RateLimitExceededException;
}
@Before
public void clearCache() throws URISyntaxException, IOException {
redisServer = new RedisServer(AbstractRedisClusterTest.getNextRedisClusterPort());
redisServer.start();
final String redisUrl = "redis://127.0.0.1:" + redisServer.ports().get(0);
replicatedJedisPool = new RedisClientFactory("test-pool", redisUrl, List.of(redisUrl), new CircuitBreakerConfiguration()).getRedisClientPool();
try (final Jedis jedis = replicatedJedisPool.getWriteResource()) {
jedis.flushAll();
}
getRedisCluster().useWriteCluster(connection -> connection.sync().flushall());
}
@After
public void stopServer() {
redisServer.stop();
}
@Test
public void validate() throws RateLimitExceededException, IOException {
final RateLimiter rateLimiter = buildRateLimiter(2, 0.5);
rateLimiter.validate(KEY, 1, NOW_MILLIS);
rateLimiter.validate(KEY, 1, NOW_MILLIS);
assertRateLimitExceeded(() -> rateLimiter.validate(KEY, 1, NOW_MILLIS));
}
@Test
public void validateWithAmount() throws RateLimitExceededException, IOException {
final RateLimiter rateLimiter = buildRateLimiter(2, 0.5);
rateLimiter.validate(KEY, 2, NOW_MILLIS);
assertRateLimitExceeded(() -> rateLimiter.validate(KEY, 1, NOW_MILLIS));
}
@Test
public void testLapseRate() throws RateLimitExceededException, IOException {
final RateLimiter rateLimiter = buildRateLimiter(2, 8.333333333333334E-6);
final String leakyBucketJson = "{\"bucketSize\":2,\"leakRatePerMillis\":8.333333333333334E-6,\"spaceRemaining\":0,\"lastUpdateTimeMillis\":" + (NOW_MILLIS - TimeUnit.MINUTES.toMillis(2)) + "}";
try (final Jedis jedis = replicatedJedisPool.getWriteResource()) {
jedis.set(rateLimiter.getBucketName(KEY), leakyBucketJson);
}
getRedisCluster().useWriteCluster(connection -> connection.sync().set(rateLimiter.getBucketName(KEY), leakyBucketJson));
rateLimiter.validate(KEY, 1, NOW_MILLIS);
assertRateLimitExceeded(() -> rateLimiter.validate(KEY, 1, NOW_MILLIS));
}
@Test
public void testLapseShort() throws IOException {
final RateLimiter rateLimiter = buildRateLimiter(2, 8.333333333333334E-6);
final String leakyBucketJson = "{\"bucketSize\":2,\"leakRatePerMillis\":8.333333333333334E-6,\"spaceRemaining\":0,\"lastUpdateTimeMillis\":" + (NOW_MILLIS - TimeUnit.MINUTES.toMillis(1)) + "}";
try (final Jedis jedis = replicatedJedisPool.getWriteResource()) {
jedis.set(rateLimiter.getBucketName(KEY), leakyBucketJson);
}
getRedisCluster().useWriteCluster(connection -> connection.sync().set(rateLimiter.getBucketName(KEY), leakyBucketJson));
assertRateLimitExceeded(() -> rateLimiter.validate(KEY, 1, NOW_MILLIS));
}
private void assertRateLimitExceeded(final RateLimitedTask task) {
try {
task.run();
fail("Expected RateLimitExceededException");
} catch (final RateLimitExceededException ignored) {
}
}
@SuppressWarnings("SameParameterValue")
private RateLimiter buildRateLimiter(final int bucketSize, final double leakRatePerMilli) throws IOException {
final double leakRatePerMinute = leakRatePerMilli * 60_000d;
return new RateLimiter(replicatedJedisPool, getRedisCluster(), KEY, bucketSize, leakRatePerMinute);
}
}