Move RateLimit class from Jicofo.

Author: JonathanLennox

src/main/kotlin/org/jitsi/utils/RateLimit.kt

@@ -0,0 +1,47 @@
+package org.jitsi.utils
+
+import java.time.Clock
+import java.time.Duration
+import java.time.Instant
+import java.util.Deque
+import java.util.LinkedList
+
+/**
+ * Rate limiting which works as follows:
+ * - must be at least [minInterval] gap between the requests
+ * - no more than [maxRequests] requests within the [interval]
+ */
+class RateLimit(
+    /** Never accept a request unless at least [minInterval] has passed since the last request */
+    private val minInterval: Duration = 10.secs,
+    /** Accept at most [maxRequests] per [interval]. */
+    private val maxRequests: Int = 3,
+    /** Accept at most [maxRequests] per [interval]. */
+    private val interval: Duration = 60.secs,
+    private val clock: Clock = Clock.systemUTC()
+) {
+    /** Stores the timestamps of requests that have been received. */
+    private val requests: Deque<Instant> = LinkedList()
+
+    /** Return true if the request should be accepted and false otherwise. */
+    fun accept(): Boolean {
+        val now = clock.instant()
+        val previousRequest = requests.peekLast()
+        if (previousRequest == null) {
+            requests.add(now)
+            return true
+        }
+
+        if (Duration.between(previousRequest, now) < minInterval) {
+            return false
+        }
+
+        // Allow only [maxRequests] requests within the last [interval]
+        requests.removeIf { Duration.between(it, now) > interval }
+        if (requests.size >= maxRequests) {
+            return false
+        }
+        requests.add(now)
+        return true
+    }
+}

src/test/kotlin/org/jitsi/utils/RateLimitTest.kt

@@ -0,0 +1,60 @@
+package org.jitsi.utils
+
+import io.kotest.core.spec.style.ShouldSpec
+import io.kotest.matchers.shouldBe
+import org.jitsi.utils.time.FakeClock
+
+class RateLimitTest : ShouldSpec() {
+    init {
+        context("RateLimit test") {
+            val clock = FakeClock()
+            val rateLimit = RateLimit(clock = clock)
+
+            should("allow 1st request") {
+                rateLimit.accept() shouldBe true
+            }
+            should("not allow next request immediately") {
+                rateLimit.accept() shouldBe false
+            }
+            clock.elapse(5.secs)
+            should("not allow next request after 5 seconds") {
+                rateLimit.accept() shouldBe false
+            }
+            clock.elapse(6.secs)
+            should("allow 2nd request after 11 seconds") {
+                rateLimit.accept() shouldBe true
+            }
+            should("not allow 3rd request after 11 seconds") {
+                rateLimit.accept() shouldBe false
+            }
+            clock.elapse(10.secs)
+            should("allow 3rd request after 21 seconds") {
+                rateLimit.accept() shouldBe true
+            }
+            clock.elapse(11.secs)
+            should("not allow more than 3 request within the last minute (31 second)") {
+                rateLimit.accept() shouldBe false
+            }
+            clock.elapse(10.secs)
+            should("not allow more than 3 request within the last minute (41 second)") {
+                rateLimit.accept() shouldBe false
+            }
+            clock.elapse(10.secs)
+            should("not allow more than 3 request within the last minute (51 second)") {
+                rateLimit.accept() shouldBe false
+            }
+            clock.elapse(10.secs)
+            should("allow the 4th request after 60 seconds have passed since the 1st (61 second)") {
+                rateLimit.accept() shouldBe true
+            }
+            clock.elapse(5.secs)
+            should("not allow the 5th request in 66th second") {
+                rateLimit.accept() shouldBe false
+            }
+            clock.elapse(5.secs)
+            should("allow the 5th request in 71st second") {
+                rateLimit.accept() shouldBe true
+            }
+        }
+    }
+}