[james-project] 07/09: When we don't get any limiter, don't build a global rate limiter

[bt...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

btellier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git

commit a784fa5c0d904b29c8e2224bf88af43b877cd802
Author: Matthieu Baechler <ma...@baechler-craftsmanship.fr>
AuthorDate: Fri Feb 10 09:16:52 2023 +0100

    When we don't get any limiter, don't build a global rate limiter
---
 .../james/transport/mailets/GlobalRateLimit.scala  | 30 ++++++++++++++--------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/server/mailet/rate-limiter/src/main/scala/org/apache/james/transport/mailets/GlobalRateLimit.scala b/server/mailet/rate-limiter/src/main/scala/org/apache/james/transport/mailets/GlobalRateLimit.scala
index c446f48875..7ef7bfec51 100644
--- a/server/mailet/rate-limiter/src/main/scala/org/apache/james/transport/mailets/GlobalRateLimit.scala
+++ b/server/mailet/rate-limiter/src/main/scala/org/apache/james/transport/mailets/GlobalRateLimit.scala
@@ -37,16 +37,21 @@ case class GlobalKey(keyPrefix: Option[KeyPrefix], entityType: EntityType) exten
   }
 }
 
-class GlobalRateLimiter(rateLimiter: Option[RateLimiter], keyPrefix: Option[KeyPrefix], entityType: EntityType) {
-  def rateLimit(mail: Mail): Publisher[RateLimitingResult] = {
+trait GlobalRateLimiter {
+  def rateLimit(mail: Mail): Publisher[RateLimitingResult]
+}
+
+object GlobalRateLimiter {
+  def fromRateLimiter(rateLimiter: RateLimiter, keyPrefix: Option[KeyPrefix], entityType: EntityType): GlobalRateLimiter = {
     val rateLimitingKey = GlobalKey(keyPrefix, entityType)
 
-    rateLimiter.map(limiter =>
+    mail =>
       EntityType.extractQuantity(entityType, mail)
-        .map(increment => limiter.rateLimit(rateLimitingKey, increment))
-        .getOrElse(SMono.just[RateLimitingResult](RateExceeded)))
-      .getOrElse(SMono.just[RateLimitingResult](AcceptableRate))
+        .map(increment => rateLimiter.rateLimit(rateLimitingKey, increment))
+        .getOrElse(SMono.just[RateLimitingResult](RateExceeded))
   }
+
+  val acceptAll: GlobalRateLimiter = mail => SMono.just[RateLimitingResult](AcceptableRate)
 }
 
 /**
@@ -141,12 +146,17 @@ class GlobalRateLimit @Inject()(rateLimiterFactory: RateLimiterFactory) extends
     }
   }
 
+
   private def createRateLimiter(rateLimiterFactory: RateLimiterFactory, entityType: EntityType, keyPrefix: Option[KeyPrefix],
                                 duration: Duration, precision: Option[Duration]): GlobalRateLimiter =
-    new GlobalRateLimiter(rateLimiter = EntityType.extractRules(entityType, duration, getMailetConfig)
-      .map(rateLimiterFactory.withSpecification(_, precision)),
-      keyPrefix = keyPrefix,
-      entityType = entityType)
+    EntityType.extractRules(entityType, duration, getMailetConfig)
+      .map(rateLimiterFactory.withSpecification(_, precision))
+      .map(rateLimiter =>
+        GlobalRateLimiter.fromRateLimiter(
+          rateLimiter = rateLimiter,
+          keyPrefix = keyPrefix,
+          entityType = entityType))
+      .getOrElse(GlobalRateLimiter.acceptAll)
 
 
   override def requiredProcessingState(): util.Collection[ProcessingState] = ImmutableList.of(new ProcessingState(exceededProcessor))


---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org