Expose configured backlog timeout in LifoBlockingLimiter

Author: Agshin Guliyev

concurrency-limits-core/src/main/java/com/netflix/concurrency/limits/limiter/LifoBlockingLimiter.java

@@ -40,7 +40,9 @@ public static class Builder<ContextT> {
 
         private final Limiter<ContextT> delegate;
         private int maxBacklogSize = 100;
-        private Function<ContextT, Long> maxBacklogTimeoutMillis = context -> 1_000L;
+        private Long fixedBacklogTimeoutMillis = 1_000L;
+        private Function<ContextT, Long> maxBacklogTimeoutMillis =
+                context -> fixedBacklogTimeoutMillis;
 
         private Builder(Limiter<ContextT> delegate) {
             this.delegate = delegate;
@@ -87,6 +89,7 @@ public Builder<ContextT> backlogTimeout(long timeout, TimeUnit units) {
          */
         public Builder<ContextT> backlogTimeoutMillis(long timeout) {
             this.maxBacklogTimeoutMillis = context -> timeout;
+            this.fixedBacklogTimeoutMillis = timeout;
             return this;
         }
 
@@ -99,6 +102,7 @@ public Builder<ContextT> backlogTimeoutMillis(long timeout) {
          */
         public Builder<ContextT> backlogTimeout(Function<ContextT, Long> mapper, TimeUnit units) {
             this.maxBacklogTimeoutMillis = context -> units.toMillis(mapper.apply(context));
+            this.fixedBacklogTimeoutMillis = null;
             return this;
         }
 
@@ -142,14 +146,35 @@ public void set(Optional<Listener> listener) {
 
     private final int backlogSize;
 
+    /**
+     * Function that computes the backlog timeout in milliseconds based on the
+     * request context. By default, this returns the fixed timeout.
+     */
     private final Function<ContextT, Long> backlogTimeoutMillis;
 
+    /**
+     * Fixed backlog timeout in milliseconds fixed for this limiter.
+     * <p>
+     * This is primarily intended for introspection and serialization. By
+     * default, the backlog timeout is 1 second.
+     */
+    private final Long fixedBacklogTimeoutMillis;
+
     private final Object lock = new Object();
 
     private LifoBlockingLimiter(Builder<ContextT> builder) {
         this.delegate = builder.delegate;
         this.backlogSize = builder.maxBacklogSize;
         this.backlogTimeoutMillis = builder.maxBacklogTimeoutMillis;
+        this.fixedBacklogTimeoutMillis = builder.fixedBacklogTimeoutMillis;
+    }
+
+    /**
+     * Returns the fixed backlog timeout in milliseconds, or  null if the
+     * timeout is derived from the request context.
+     */
+    public Long getFixedBacklogTimeoutMillis() {
+        return this.fixedBacklogTimeoutMillis;
     }
 
     private Optional<Listener> tryAcquire(ContextT context) {

concurrency-limits-core/src/test/java/com/netflix/concurrency/limits/limiter/LifoBlockingLimiterTest.java

@@ -155,11 +155,11 @@ public void verifyFifoOrder() {
 
         // Make sure all requests finished
         futures.forEach(future -> {
-                    try {
-                        future.get();
-                    } catch (Exception e) {
-                    }
-                });
+            try {
+                future.get();
+            } catch (Exception e) {
+            }
+        });
 
         // Verify that results are in reverse order
         Assert.assertEquals(Arrays.asList(4, 3, 2, 1, 0), values);
@@ -171,9 +171,9 @@ public void verifyFifoOrder() {
     public void timeoutAcquireRaceCondition() throws InterruptedException, ExecutionException {
         // a limiter with a short timeout, and large backlog (we don't want it to hit that limit)
         LifoBlockingLimiter<Void> limiter = LifoBlockingLimiter.newBuilder(simpleLimiter)
-            .backlogSize(1000)
-            .backlogTimeout(10, TimeUnit.MILLISECONDS)
-            .build();
+                .backlogSize(1000)
+                .backlogTimeout(10, TimeUnit.MILLISECONDS)
+                .build();
 
         // acquire all except one token
         acquireN(limiter, 3);
@@ -210,6 +210,28 @@ public void timeoutAcquireRaceCondition() throws InterruptedException, Execution
         }
     }
 
+    @Test
+    public void fixedTimeoutExposedWhenConfigured() {
+        LifoBlockingLimiter<Void> limiter = LifoBlockingLimiter
+                .newBuilder(simpleLimiter)
+                .backlogSize(10)
+                .backlogTimeoutMillis(250)
+                .build();
+
+        Assert.assertEquals(Long.valueOf(250L), limiter.getFixedBacklogTimeoutMillis());
+    }
+
+    @Test
+    public void fixedTimeoutIsNullForDynamicBacklogTimeout() {
+        LifoBlockingLimiter<Void> limiter = LifoBlockingLimiter
+                .newBuilder(simpleLimiter)
+                .backlogSize(10)
+                .backlogTimeout(context -> 50L, TimeUnit.MILLISECONDS)
+                .build();
+
+        Assert.assertNull(limiter.getFixedBacklogTimeoutMillis());
+    }
+
     private List<Optional<Limiter.Listener>> acquireN(Limiter<Void> limiter, int N) {
         return IntStream.range(0, N)
                 .mapToObj(i -> limiter.acquire(null))