@Override public RateBasedLimiter call() throws Exception { return new RateBasedLimiter(limitPerSecond); } };
@Override protected Callback<Response<PermitAllocation>> decorateCallback(PermitRequest request, Callback<Response<PermitAllocation>> callback) { if (callback instanceof CallbackDecorator) { return callback; } return new CallbackDecorator(request, callback); }
@Override public void stop() { for (Limiter limiter : this.underlyingLimiters) { limiter.stop(); } } }
@Test public void testThrottling() throws InterruptedException { Limiter limiter = new CountBasedLimiter(10); limiter.start(); for (int i = 0; i < 10; i++) { Assert.assertTrue(limiter.acquirePermits(1) != null); } Assert.assertTrue(limiter.acquirePermits(1) == null); limiter.stop(); } }
@Test public void testNonRetriableFail() throws Exception { Queue<RequestAndCallback> queue = Queues.newArrayDeque(); BatchedPermitsRequester container = BatchedPermitsRequester.builder().resourceId("resource") .requestorIdentifier("requestor").requestSender(new TestRequestSender(queue, false)).build(); try (ParallelRequester requester = new ParallelRequester(container)) { Future<Boolean> future = requester.request(10); // container should only try request once await(new QueueSize(queue, 1), 1000); Assert.assertFalse(future.isDone()); failRequestBuilder().requestAndCallback(queue.poll()).errorStatus(HttpStatus.S_422_UNPROCESSABLE_ENTITY).fail(); Assert.assertFalse(future.get()); Assert.assertEquals(queue.size(), 0); } }
@Test public void testForwardingOfRequests() throws Exception { Queue<RequestAndCallback> queue = Queues.newArrayDeque(); BatchedPermitsRequester container = BatchedPermitsRequester.builder().resourceId("resource") .requestorIdentifier("requestor").requestSender(new TestRequestSender(queue, false)).build(); try (ParallelRequester requester = new ParallelRequester(container)) { Future<Boolean> future = requester.request(10); await(new QueueSize(queue, 1), 1000); Assert.assertEquals(queue.size(), 1); satisfyRequestBuilder().requestAndCallback(queue.poll()).satisfy(); future.get(1, TimeUnit.SECONDS); Assert.assertTrue(future.isDone()); Assert.assertTrue(future.get()); } }
private void acquirePermits(int permits, String op) throws IOException { try { Closeable closeable = getRateLimiter().acquirePermits(permits); if (closeable == null) { throw new NotEnoughPermitsException(op); } } catch (InterruptedException e) { throw new NotEnoughPermitsException(op, e); } }
@BeforeClass public void setUp() { this.limiter = new RateBasedLimiter(20, TimeUnit.SECONDS); this.limiter.start(); }
@Override public void doRun(Limiter limiter) throws InterruptedException { int ops = 0; while (ops < this.opsTarget) { limiter.acquirePermits(1); ops++; } } }
@BeforeClass public void setUp() { this.limiter = new TimeBasedLimiter(3l, TimeUnit.SECONDS); this.limiter.start(); }
@Override public void start() { for (Limiter limiter : this.underlyingLimiters) { limiter.start(); } }
public CountBasedPolicy(long count) { this.count = count; this.limiter = new CountBasedLimiter(count); }
@Override public void sendRequest(PermitRequest request, Callback<Response<PermitAllocation>> callback) { if (this.autoSatisfyRequests) { satisfyRequestBuilder().requestAndCallback(new RequestAndCallback(request, callback)).satisfy(); } else { this.requestAndCallbacks.add(new RequestAndCallback(request, callback)); } } }
/** * @param broker {@link SharedResourcesBroker} used to create {@link RestClient}s. * @param connectionPrefixes List of uri prefixes of available servers. * @throws NotConfiguredException */ public RedirectAwareRestClientRequestSender(SharedResourcesBroker<?> broker, List<String> connectionPrefixes) throws NotConfiguredException { this.broker = broker; this.connectionPrefixes = connectionPrefixes; updateRestClient(getNextConnectionPrefix(), "service start"); }
@Override public void sendRequest(PermitRequest request, Callback<Response<PermitAllocation>> callback) { log.info("Sending request to " + getCurrentServerPrefix()); super.sendRequest(request, callback); }
/** * @return the number of permits acquired from the server and not yet used. */ @VisibleForTesting public long getUnusedPermits() { return this.bachedPermitsContainer.getPermitBatchContainer().getTotalAvailablePermits(); }
@Override public Boolean call() throws Exception { return container.getPermits(permits); } });
public boolean canRetryNow() { return canRetryWithinMillis(0); }
@VisibleForTesting public void clearAllStoredPermits() { this.bachedPermitsContainer.clearAllStoredPermits(); } }
@Override public void close() throws IOException { try { this.extractor.close(); } finally { this.limiter.stop(); } } }