feat(pkg:concurrent): added utility class LeakyBucketRateLimiterManager

Author: fenying

CHANGES.md

@@ -7,6 +7,7 @@
 - feat(pkg:concurrent): added utility class `TokenBucketRateLimiter`
 - feat(pkg:concurrent): added utility class `TokenBucketRateLimiterManager`
 - feat(pkg:concurrent): added utility class `LeakyBucketRateLimiter`
+- feat(pkg:concurrent): added utility class `LeakyBucketRateLimiterManager`
 - feat(pkg:ts-types): added helper type `IJsonSafeValue`
 - feat(pkg:ts-types): added helper type `IMaybeArray`
 - feat(pkg:concurrent): added utility class `ManualBreaker`

packages/partials/concurrent/src/Classes/LeakyBucketRateLimiter.test.ts

@@ -38,7 +38,7 @@ NodeTest.describe('Class LeakyBucketRateLimiter', async () => {
         await autoTick(ctx, limiter.challenge());
 
         const pr = limiter.challenge();
-        NodeAssert.strictEqual(limiter.isLimited(), true);
+        NodeAssert.strictEqual(limiter.isBlocking(), true);
         // the second one, should wait 100ms.
         // The next leaking time should be at 200ms later.
         await autoTick(ctx, pr);
@@ -105,7 +105,7 @@ NodeTest.describe('Class LeakyBucketRateLimiter', async () => {
         NodeAssert.strictEqual(Date.now() - start, 0);
 
         const pr = limiter.call(() => 'second');
-        NodeAssert.strictEqual(limiter.isLimited(), true);
+        NodeAssert.strictEqual(limiter.isBlocking(), true);
 
         // the second one, should wait 100ms.
         // The next leaking time should be at 200ms later.
@@ -142,7 +142,7 @@ NodeTest.describe('Class LeakyBucketRateLimiter', async () => {
         NodeAssert.strictEqual(Date.now() - start, 0);
 
         const pr = wrapped(10, 20);
-        NodeAssert.strictEqual(limiter.isLimited(), true);
+        NodeAssert.strictEqual(limiter.isBlocking(), true);
 
         // the second one, should wait 100ms.
         // The next leaking time should be at 200ms later.
@@ -204,7 +204,7 @@ NodeTest.describe('Class LeakyBucketRateLimiter', async () => {
 
         prAllowed.push(limiter.challenge());
         prAllowed.push(limiter.challenge());
-        NodeAssert.strictEqual(limiter.isLimited(), true);
+        NodeAssert.strictEqual(limiter.isBlocking(), true);
         prAllowed.push(NodeAssert.rejects(limiter.challenge()));
 
         limiter.reset();

packages/partials/concurrent/src/Classes/LeakyBucketRateLimiter.ts

@@ -70,10 +70,11 @@ export class LeakyBucketRateLimiter implements IAsyncRateLimiter {
         this._errCtor = opts.errorCtorOnLimited ?? E_RATE_LIMITED;
     }
 
-    /**
-     * Challenge the rate limiter. If it's limited, an error will be thrown.
-     * Otherwise, the function will wait until the task is able to be processed.
-     */
+    public isIdle(): boolean {
+
+        return this._nextLeakingAt <= Date.now();
+    }
+
     public async challenge(): Promise<void> {
 
         const ttl = this._leak();
@@ -106,43 +107,23 @@ export class LeakyBucketRateLimiter implements IAsyncRateLimiter {
         return elapsed;
     }
 
-    /**
-     * Call the given function if the limiter is not limited, or throw an error if
-     * the limiter is limited.
-     *
-     * @param fn    The function to be called.
-     * @returns     The return value of the given function.
-     * @throws      An error if the limiter is limited, or if the given function throws an error.
-     */
     public async call<TFn extends IFunction>(fn: TFn): Promise<Awaited<ReturnType<TFn>>> {
 
         await this.challenge();
 
         return fn() as Awaited<ReturnType<TFn>>;
     }
 
-    /**
-     * Reset the internal context.
-     */
     public reset(): void {
 
         this._nextLeakingAt = Date.now();
     }
 
-    /**
-     * Check whether the rate limiter is blocking all access now.
-     */
-    public isLimited(): boolean {
+    public isBlocking(): boolean {
 
         return this._nextLeakingAt - Date.now() > this._maxWaitMs - this._leakIntervalMs;
     }
 
-    /**
-     * Wrap the given function with rate limiting challenge.
-     *
-     * @param fn    The function to be wrapped.
-     * @returns     The new wrapped function.
-     */
     public wrap<T extends IFunction>(fn: T): IFunction<Parameters<T>, IToPromise<ReturnType<T>>> {
 
         return (async (...args: unknown[]) => {