public CountBasedPolicy(long count) { this.count = count; this.limiter = new CountBasedLimiter(count); }
@Override public Limiter buildLimiter(Config config) { if (!config.hasPath(COUNT_KEY)) { throw new IllegalArgumentException("Missing key " + COUNT_KEY); } return new CountBasedLimiter(config.getLong(COUNT_KEY)); } }
@Test public void testSimpleCalls() throws Exception { FileSystem fs = Mockito.mock(FileSystem.class); Mockito.when(fs.getFileStatus(Mockito.any(Path.class))).thenReturn(new FileStatus(0, false, 0, 0, 0, new Path("/"))); Limiter limiter = new CountBasedLimiter(2); ThrottledFileSystem throttledFileSystem = new ThrottledFileSystem(fs, limiter, "testService"); Assert.assertNotNull(throttledFileSystem.getFileStatus(new Path("/myFile"))); Assert.assertNotNull(throttledFileSystem.getFileStatus(new Path("/myFile"))); try { throttledFileSystem.getFileStatus(new Path("/myFile")); Assert.fail(); } catch (NotEnoughPermitsException expected) { // Expected } }
@Test public void test() throws Exception { CountBasedLimiter countLimiter1 = new CountBasedLimiter(3); CountBasedLimiter countLimiter2 = new CountBasedLimiter(1); MultiLimiter multiLimiter = new MultiLimiter(countLimiter1, countLimiter2); // Can only take 1 permit (limiter2 has only 1 permit available) Assert.assertNotNull(multiLimiter.acquirePermits(1)); Assert.assertNull(multiLimiter.acquirePermits(1)); // limiter1 has 1 leftover permit (one consumed in the failed second permit above) Assert.assertNotNull(countLimiter1.acquirePermits(1)); Assert.assertNull(countLimiter1.acquirePermits(1)); // limiter2 has not leftover permits Assert.assertNull(countLimiter2.acquirePermits(1)); }
@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 test() throws Exception { ByteArrayInputStream inputStream = new ByteArrayInputStream("abcde".getBytes(Charsets.UTF_8)); MeteredInputStream meteredInputStream = MeteredInputStream.builder().in(inputStream).updateFrequency(1).build(); Limiter limiter = new CountBasedLimiter(4); InputStream throttled = new ThrottledInputStream(meteredInputStream, limiter, meteredInputStream); try { String output = IOUtils.toString(throttled, Charsets.UTF_8); Assert.fail(); } catch (RuntimeException re) { // Expected } meteredInputStream.reset(); limiter = new CountBasedLimiter(5); throttled = new ThrottledInputStream(meteredInputStream, limiter, meteredInputStream); Assert.assertEquals(IOUtils.toString(throttled, Charsets.UTF_8), "abcde"); }
public void testConstructor() throws Exception { CountBasedLimiter countLimiter1 = new CountBasedLimiter(3); CountBasedLimiter countLimiter2 = new CountBasedLimiter(3); CountBasedLimiter countLimiter3 = new CountBasedLimiter(3); NoopLimiter noopLimiter = new NoopLimiter(); MultiLimiter multiLimiter1 = new MultiLimiter(countLimiter1, countLimiter2); Assert.assertEquals(multiLimiter1.getUnderlyingLimiters(), Lists.newArrayList(countLimiter1, countLimiter2)); // Noop limiters get filtered MultiLimiter multiLimiter2 = new MultiLimiter(countLimiter1, noopLimiter); Assert.assertEquals(multiLimiter2.getUnderlyingLimiters(), Lists.newArrayList(countLimiter1)); // multilimiters get expanded MultiLimiter multiLimiter3 = new MultiLimiter(multiLimiter1, countLimiter3); Assert.assertEquals(multiLimiter3.getUnderlyingLimiters(), Lists.newArrayList(countLimiter1, countLimiter2, countLimiter3)); // deduplication MultiLimiter multiLimiter4 = new MultiLimiter(countLimiter1, countLimiter1); Assert.assertEquals(multiLimiter4.getUnderlyingLimiters(), Lists.newArrayList(countLimiter1)); // deduplication on expanded multilimiters MultiLimiter multiLimiter5 = new MultiLimiter(multiLimiter1, countLimiter1); Assert.assertEquals(multiLimiter5.getUnderlyingLimiters(), Lists.newArrayList(countLimiter1, countLimiter2)); }
Preconditions.checkArgument(state.contains(EXTRACT_LIMIT_COUNT_LIMIT_KEY)); long countLimit = Long.parseLong(state.getProp(EXTRACT_LIMIT_COUNT_LIMIT_KEY)); return new CountBasedLimiter(countLimit); case POOL_BASED: Preconditions.checkArgument(state.contains(EXTRACT_LIMIT_POOL_SIZE_KEY));
@Test public void testListing() throws Exception { FileSystem fs = Mockito.mock(FileSystem.class); Mockito.when(fs.listStatus(Mockito.any(Path.class))).thenAnswer(new Answer<FileStatus[]>() { @Override public FileStatus[] answer(InvocationOnMock invocation) throws Throwable { Path path = (Path) invocation.getArguments()[0]; int files = Integer.parseInt(path.getName()); FileStatus status = new FileStatus(0, false, 0, 0, 0, new Path("/")); FileStatus[] out = new FileStatus[files]; for (int i = 0; i < files; i++) { out[i] = status; } return out; } }); Limiter limiter = new CountBasedLimiter(5); ThrottledFileSystem throttledFileSystem = new ThrottledFileSystem(fs, limiter, "testService"); Assert.assertEquals(throttledFileSystem.getServiceName(), "testService"); Assert.assertNotNull(throttledFileSystem.listStatus(new Path("/files/99"))); // use 1 permit Assert.assertNotNull(throttledFileSystem.listStatus(new Path("/files/250"))); // use 3 permits try { throttledFileSystem.listStatus(new Path("/files/150")); // requires 2 permits Assert.fail(); } catch (NotEnoughPermitsException expected) { // Expected } Assert.assertNotNull(throttledFileSystem.listStatus(new Path("/files/99"))); // requires 1 permit }
public CountBasedPolicy(long count) { this.count = count; this.limiter = new CountBasedLimiter(count); }
@Override public Limiter buildLimiter(Config config) { if (!config.hasPath(COUNT_KEY)) { throw new IllegalArgumentException("Missing key " + COUNT_KEY); } return new CountBasedLimiter(config.getLong(COUNT_KEY)); } }
Preconditions.checkArgument(state.contains(EXTRACT_LIMIT_COUNT_LIMIT_KEY)); long countLimit = Long.parseLong(state.getProp(EXTRACT_LIMIT_COUNT_LIMIT_KEY)); return new CountBasedLimiter(countLimit); case POOL_BASED: Preconditions.checkArgument(state.contains(EXTRACT_LIMIT_POOL_SIZE_KEY));