Examples with AsyncResponseFuture com.linkedin.pinot.transport.common.AsyncResponseFuture used on opensource projects

Example 1 with AsyncResponseFuture

use of com.linkedin.pinot.transport.common.AsyncResponseFuture in project pinot by linkedin.

the class KeyedPoolImpl method checkoutObject.

@Override
public KeyedFuture<K, T> checkoutObject(K key) {
    AsyncPool<T> pool = _keyedPool.get(key);
    if (null == pool) {
        synchronized (_mutex) {
            pool = _keyedPool.get(key);
            if (null == pool) {
                String poolName = "Pool for (" + key + ")";
                AsyncPoolResourceManagerAdapter<K, T> rmAdapter = new AsyncPoolResourceManagerAdapter<K, T>(key, _resourceManager, _executorService, _metricRegistry);
                pool = new AsyncPoolImpl<T>(poolName, rmAdapter, _maxResourcesPerKey, _idleTimeoutMs, _timeoutExecutor, _executorService, _maxPendingCheckoutRequests, Strategy.LRU, _minResourcesPerKey, _metricRegistry);
                _keyedPool.put(key, pool);
                _poolStats.add(pool);
                _pooledResourceManagerMap.put(key, rmAdapter);
                pool.start();
            }
        }
    }
    AsyncResponseFuture<K, T> future = new AsyncResponseFuture<K, T>(key, "Checkout future for key " + key);
    Cancellable cancellable = pool.get(future);
    future.setCancellable(cancellable);
    return future;
}

Example 2 with AsyncResponseFuture

use of com.linkedin.pinot.transport.common.AsyncResponseFuture in project pinot by linkedin.

the class KeyedPoolImplTest method testShutdownWhileCheckingOut.

@Test
public void testShutdownWhileCheckingOut() throws Exception {
    ScheduledExecutorService timedExecutor = new ScheduledThreadPoolExecutor(1);
    ExecutorService service = new ThreadPoolExecutor(1, 1, 1, TimeUnit.DAYS, new LinkedBlockingDeque<Runnable>());
    int numKeys = 1;
    int numResourcesPerKey = 1;
    Map<String, List<String>> resources = buildCreateMap(numKeys, numResourcesPerKey);
    BlockingTestResourceManager rm = new BlockingTestResourceManager(resources, null, null, null);
    KeyedPool<String, String> kPool = new KeyedPoolImpl<String, String>(0, 1, 1000L, 1000 * 60 * 60, rm, timedExecutor, service, null);
    kPool.start();
    AsyncResponseFuture<String, String> f = (AsyncResponseFuture<String, String>) kPool.checkoutObject(getKey(0));
    boolean isTimedout = false;
    try {
        f.get(2, TimeUnit.SECONDS);
    } catch (TimeoutException e) {
        isTimedout = true;
    }
    Assert.assertTrue(isTimedout);
    kPool.shutdown().get();
    // Future should have been done with error
    Assert.assertNull(f.get());
    Assert.assertNotNull(f.getError());
    boolean cancelled = f.cancel(false);
    Assert.assertFalse(cancelled);
    Assert.assertFalse(f.isCancelled());
    Assert.assertTrue(f.isDone());
    rm.getCreateBlockLatch().countDown();
    Thread.sleep(5000);
}

Example 3 with AsyncResponseFuture

use of com.linkedin.pinot.transport.common.AsyncResponseFuture in project pinot by linkedin.

the class KeyedPoolImplTest method testInvalidCheckinDestroy.

@Test
public void testInvalidCheckinDestroy() throws Exception {
    ScheduledExecutorService timedExecutor = new ScheduledThreadPoolExecutor(1);
    ExecutorService service = new ThreadPoolExecutor(1, 1, 1, TimeUnit.DAYS, new LinkedBlockingDeque<Runnable>());
    int numKeys = 1;
    int numResourcesPerKey = 1;
    Map<String, List<String>> resources = buildCreateMap(numKeys, numResourcesPerKey);
    TestResourceManager rm = new TestResourceManager(resources, null, null, null);
    KeyedPool<String, String> kPool = new KeyedPoolImpl<String, String>(0, 1, 1000L, 1000 * 60 * 60, rm, timedExecutor, service, null);
    kPool.start();
    AsyncResponseFuture<String, String> f = (AsyncResponseFuture<String, String>) kPool.checkoutObject(getKey(0));
    String s1 = f.getOne();
    // checkin with invalid key
    boolean isException = false;
    try {
        kPool.checkinObject(getKey(1), s1);
    } catch (IllegalStateException e) {
        isException = true;
    }
    Assert.assertTrue(isException);
    // destroy with invalid key
    isException = false;
    try {
        kPool.destroyObject(getKey(1), s1);
    } catch (IllegalStateException e) {
        isException = true;
    }
    Assert.assertTrue(isException);
}

Example 4 with AsyncResponseFuture

use of com.linkedin.pinot.transport.common.AsyncResponseFuture in project pinot by linkedin.

the class KeyedPoolImplTest method testCancelAfterCheckingOut.

@Test
public void testCancelAfterCheckingOut() throws Exception {
    ScheduledExecutorService timedExecutor = new ScheduledThreadPoolExecutor(1);
    ExecutorService service = new ThreadPoolExecutor(1, 1, 1, TimeUnit.DAYS, new LinkedBlockingDeque<Runnable>());
    int numKeys = 1;
    int numResourcesPerKey = 1;
    Map<String, List<String>> resources = buildCreateMap(numKeys, numResourcesPerKey);
    BlockingTestResourceManager rm = new BlockingTestResourceManager(resources, null, null, null);
    KeyedPool<String, String> kPool = new KeyedPoolImpl<String, String>(0, 1, 1000L, 1000 * 60 * 60, rm, timedExecutor, service, null);
    kPool.start();
    AsyncResponseFuture<String, String> f = (AsyncResponseFuture<String, String>) kPool.checkoutObject(getKey(0));
    boolean isTimedout = false;
    try {
        f.get(2, TimeUnit.SECONDS);
    } catch (TimeoutException e) {
        isTimedout = true;
    }
    Assert.assertTrue(isTimedout);
    boolean cancelled = f.cancel(false);
    Assert.assertTrue(cancelled);
    Assert.assertTrue(f.isCancelled());
    Assert.assertTrue(f.isDone());
    rm.getCreateBlockLatch().countDown();
    kPool.shutdown().get();
}

Example 5 with AsyncResponseFuture

use of com.linkedin.pinot.transport.common.AsyncResponseFuture in project pinot by linkedin.

the class NettySingleConnectionIntegrationTest method testValidatePool.

/*
   * WARNING: This test has potential failures due to timing.
   */
@Test
public void testValidatePool() throws Exception {
    NettyClientMetrics metric = new NettyClientMetrics(null, "abc");
    Timer timer = new HashedWheelTimer();
    MyServer server = new MyServer();
    Thread.sleep(1000);
    // used as a key to pool. Can be anything.
    final String serverName = "SomeServer";
    ServerInstance serverInstance = server.getServerInstance();
    MetricsRegistry metricsRegistry = new MetricsRegistry();
    EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
    PooledNettyClientResourceManager resourceManager = new PooledNettyClientResourceManager(eventLoopGroup, new HashedWheelTimer(), metric);
    ExecutorService executorService = Executors.newCachedThreadPool();
    ScheduledExecutorService timeoutExecutor = new ScheduledThreadPoolExecutor(5);
    AsyncPoolResourceManagerAdapter<ServerInstance, NettyClientConnection> rmAdapter = new AsyncPoolResourceManagerAdapter<ServerInstance, NettyClientConnection>(serverInstance, resourceManager, executorService, metricsRegistry);
    AsyncPool pool = new AsyncPoolImpl<NettyClientConnection>(serverName, rmAdapter, /*maxSize=*/
    5, /*idleTimeoutMs=*/
    100000, timeoutExecutor, executorService, /*maxWaiters=*/
    10, AsyncPoolImpl.Strategy.LRU, /*minSize=*/
    2, metricsRegistry);
    pool.start();
    Callback<NoneType> callback;
    callback = new Callback<NoneType>() {

        @Override
        public void onSuccess(NoneType arg0) {
        }

        @Override
        public void onError(Throwable arg0) {
            Assert.fail("Shutdown error");
        }
    };
    boolean serverShutdown = false;
    try {
        PoolStats stats;
        /* Validate with no connection in pool */
        // Give the pool enough time to create connections (in this case, 2 connections minSize)
        Thread.sleep(3000);
        //      System.out.println("Validating with no used objects in the pool");
        pool.validate(false);
        // System.out.println(stats);
        stats = pool.getStats();
        Assert.assertEquals(2, stats.getPoolSize());
        Assert.assertEquals(0, stats.getTotalBadDestroyed());
        /* checkout one connection, it should not destroy anything */
        AsyncResponseFuture<ServerInstance, NettyClientConnection> future = new AsyncResponseFuture<ServerInstance, NettyClientConnection>(serverInstance, "Future for " + serverName);
        Cancellable cancellable = pool.get(future);
        future.setCancellable(cancellable);
        NettyClientConnection conn = future.getOne();
        // System.out.println(stats);
        stats = pool.getStats();
        //      System.out.println("Validating with one used object in the pool");
        pool.validate(false);
        Assert.assertEquals(2, stats.getPoolSize());
        Assert.assertEquals(0, stats.getTotalBadDestroyed());
        Assert.assertEquals(1, stats.getCheckedOut());
        // Now stop the server, so that the checked out connection is invalidated.
        server.shutdown();
        serverShutdown = true;
        ;
        // Wait for the client channel to be closed.
        Thread.sleep(2000);
        pool.validate(false);
        // Wait for the callback into AsyncPoolImpl after the destroy thread completes destroying the connection
        Thread.sleep(5000);
        //      System.out.println("Validating with one used object in the pool, after server shutdown");
        // System.out.println(stats);
        stats = pool.getStats();
        Assert.assertEquals(2, stats.getPoolSize());
        Assert.assertEquals(1, stats.getTotalBadDestroyed());
        Assert.assertEquals(1, stats.getCheckedOut());
    } finally {
        server.shutdown();
        pool.shutdown(callback);
        executorService.shutdown();
        timeoutExecutor.shutdown();
    }
}