Example usage for org.apache.commons.pool KeyedObjectPool returnObject

Introduction

In this page you can find the example usage for org.apache.commons.pool KeyedObjectPool returnObject.

Prototype

void returnObject(Object key, Object obj) throws Exception;

Source Link

Document

Return an instance to the pool.

Usage

From source file:edu.illinois.enforcemop.examples.apache.pool.TestKeyedObjectPool.java

public void testKPOFReturnObjectUsages() throws Exception {
    final FailingKeyedPoolableObjectFactory factory = new FailingKeyedPoolableObjectFactory();
    final KeyedObjectPool pool;
    try {/* ww  w  .  j a  v  a 2  s  .  c om*/
        pool = makeEmptyPool(factory);
    } catch (UnsupportedOperationException uoe) {
        return; // test not supported
    }
    final List expectedMethods = new ArrayList();
    Object obj;

    /// Test correct behavior code paths
    obj = pool.borrowObject(KEY);
    clear(factory, expectedMethods);

    // returned object should be passivated
    pool.returnObject(KEY, obj);
    if (pool instanceof StackKeyedObjectPool) {
        expectedMethods.add(new MethodCall("validateObject", KEY, obj).returned(Boolean.TRUE));
    }
    expectedMethods.add(new MethodCall("passivateObject", KEY, obj));
    assertEquals(expectedMethods, factory.getMethodCalls());

    //// Test exception handling of returnObject
    reset(pool, factory, expectedMethods);

    // passivateObject should swallow exceptions and not add the object to the pool
    pool.addObject(KEY);
    pool.addObject(KEY);
    pool.addObject(KEY);
    assertEquals(3, pool.getNumIdle(KEY));
    obj = pool.borrowObject(KEY);
    obj = pool.borrowObject(KEY);
    assertEquals(1, pool.getNumIdle(KEY));
    assertEquals(2, pool.getNumActive(KEY));
    clear(factory, expectedMethods);
    factory.setPassivateObjectFail(true);
    pool.returnObject(KEY, obj);
    if (pool instanceof StackKeyedObjectPool) {
        expectedMethods.add(new MethodCall("validateObject", KEY, obj).returned(Boolean.TRUE));
    }
    expectedMethods.add(new MethodCall("passivateObject", KEY, obj));
    TestObjectPool.removeDestroyObjectCall(factory.getMethodCalls()); // The exact timing of destroyObject is flexible here.
    assertEquals(expectedMethods, factory.getMethodCalls());
    assertEquals(1, pool.getNumIdle(KEY)); // Not added
    assertEquals(1, pool.getNumActive(KEY)); // But not active

    reset(pool, factory, expectedMethods);
    obj = pool.borrowObject(KEY);
    clear(factory, expectedMethods);
    factory.setPassivateObjectFail(true);
    factory.setDestroyObjectFail(true);
    try {
        pool.returnObject(KEY, obj);
        if (!(pool instanceof GenericKeyedObjectPool)) { // ugh, 1.3-compat
            fail("Expecting destroyObject exception to be propagated");
        }
    } catch (PrivateException ex) {
        // Expected
    }
}

---

From source file:au.org.intersect.dms.wn.impl.TransportConnectionTemplate.java

/**
 * Runs action with transport connection from pool and does proper pool handling.
 * //from   ww w .j  a  va  2  s.c o m
 * @param <T>
 * @param key
 * @param action
 * @return
 */
public <T> T execute(ConnectionParams key, TransportConnectionCallback<T> action) {
    if (key == null) {
        throw new ConnectionClosedError("The connection to this server has timed out. "
                + "Please close the current tab and re-establish the connection");
    }
    // TODO CHECKSTYLE-OFF: IllegalCatch
    KeyedObjectPool pool = protoMapping.get(key.getProtocol());
    Object conn = null;
    try {
        conn = pool.borrowObject(key);
        return action.performWith((TransportConnection) conn);
    } catch (TransportException e) {
        throw e;
    } catch (Exception e) {
        LOGGER.error("Failed to perform operation. Exception:", e);
        if (conn != null) {
            try {
                pool.invalidateObject(key, conn);
            } catch (Exception e1) {
                LOGGER.error("Failed to remove closed connection from the pool. Exception:", e1);
            }
        }
        conn = null;
        throw new ConnectionClosedError("This server has stopped responding. Please close the current tab and"
                + " re-establish the connection. "
                + "If the problem persists please contact your system administrator.");
    } finally {
        if (conn != null) {
            try {
                pool.returnObject(key, conn);
            } catch (Exception e) {
                LOGGER.error("Failed to return connection to the pool. Exception:", e);
            }
        }
    }
    // CHECKSTYLE-ON: IllegalCatch
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestKeyedObjectPool.java

public void testKPOFBorrowObjectUsages() throws Exception {
    final FailingKeyedPoolableObjectFactory factory = new FailingKeyedPoolableObjectFactory();
    final KeyedObjectPool pool;
    try {/*from  ww  w  .  j a  v  a  2 s .co  m*/
        pool = makeEmptyPool(factory);
    } catch (UnsupportedOperationException uoe) {
        return; // test not supported
    }
    final List expectedMethods = new ArrayList();
    Object obj;

    if (pool instanceof GenericKeyedObjectPool) {
        ((GenericKeyedObjectPool) pool).setTestOnBorrow(true);
    }

    /// Test correct behavior code paths

    // existing idle object should be activated and validated
    pool.addObject(KEY);
    clear(factory, expectedMethods);
    obj = pool.borrowObject(KEY);
    expectedMethods.add(new MethodCall("activateObject", KEY, ZERO));
    expectedMethods.add(new MethodCall("validateObject", KEY, ZERO).returned(Boolean.TRUE));
    assertEquals(expectedMethods, factory.getMethodCalls());
    pool.returnObject(KEY, obj);

    //// Test exception handling of borrowObject
    reset(pool, factory, expectedMethods);

    // makeObject Exceptions should be propagated to client code from borrowObject
    factory.setMakeObjectFail(true);
    try {
        obj = pool.borrowObject(KEY);
        fail("Expected borrowObject to propagate makeObject exception.");
    } catch (PrivateException pe) {
        // expected
    }
    expectedMethods.add(new MethodCall("makeObject", KEY));
    assertEquals(expectedMethods, factory.getMethodCalls());

    // when activateObject fails in borrowObject, a new object should be borrowed/created
    reset(pool, factory, expectedMethods);
    pool.addObject(KEY);
    clear(factory, expectedMethods);

    factory.setActivateObjectFail(true);
    expectedMethods.add(new MethodCall("activateObject", KEY, obj));
    try {
        obj = pool.borrowObject(KEY);
        fail("Expecting NoSuchElementException");
    } catch (NoSuchElementException e) {
        //Activate should fail
    }
    // After idle object fails validation, new on is created and activation
    // fails again for the new one.
    expectedMethods.add(new MethodCall("makeObject", KEY).returned(ONE));
    expectedMethods.add(new MethodCall("activateObject", KEY, ONE));
    TestObjectPool.removeDestroyObjectCall(factory.getMethodCalls()); // The exact timing of destroyObject is flexible here.
    assertEquals(expectedMethods, factory.getMethodCalls());

    // when validateObject fails in borrowObject, a new object should be borrowed/created
    reset(pool, factory, expectedMethods);
    pool.addObject(KEY);
    clear(factory, expectedMethods);

    factory.setValidateObjectFail(true);
    // testOnBorrow is on, so this will throw when the newly created instance
    // fails validation
    try {
        obj = pool.borrowObject(KEY);
        fail("Expecting NoSuchElementException");
    } catch (NoSuchElementException ex) {
        // expected
    }
    // Activate, then validate for idle instance
    expectedMethods.add(new MethodCall("activateObject", KEY, ZERO));
    expectedMethods.add(new MethodCall("validateObject", KEY, ZERO));
    // Make new instance, activate succeeds, validate fails
    expectedMethods.add(new MethodCall("makeObject", KEY).returned(ONE));
    expectedMethods.add(new MethodCall("activateObject", KEY, ONE));
    expectedMethods.add(new MethodCall("validateObject", KEY, ONE));
    TestObjectPool.removeDestroyObjectCall(factory.getMethodCalls());
    assertEquals(expectedMethods, factory.getMethodCalls());
}

---

From source file:edu.illinois.enforcemop.examples.apache.pool.TestKeyedObjectPool.java

public void testClosedPoolBehavior() throws Exception {
    final KeyedObjectPool pool;
    try {/*from  www.  j a  va 2s  . c  o  m*/
        pool = makeEmptyPool(new BaseKeyedPoolableObjectFactory() {
            public Object makeObject(final Object key) throws Exception {
                return new Object();
            }
        });
    } catch (UnsupportedOperationException uoe) {
        return; // test not supported
    }

    Object o1 = pool.borrowObject(KEY);
    Object o2 = pool.borrowObject(KEY);

    pool.close();

    try {
        pool.addObject(KEY);
        fail("A closed pool must throw an IllegalStateException when addObject is called.");
    } catch (IllegalStateException ise) {
        // expected
    }

    try {
        pool.borrowObject(KEY);
        fail("A closed pool must throw an IllegalStateException when borrowObject is called.");
    } catch (IllegalStateException ise) {
        // expected
    }

    // The following should not throw exceptions just because the pool is closed.
    assertEquals("A closed pool shouldn't have any idle objects.", 0, pool.getNumIdle(KEY));
    assertEquals("A closed pool shouldn't have any idle objects.", 0, pool.getNumIdle());
    pool.getNumActive();
    pool.getNumActive(KEY);
    pool.returnObject(KEY, o1);
    assertEquals("returnObject should not add items back into the idle object pool for a closed pool.", 0,
            pool.getNumIdle(KEY));
    assertEquals("returnObject should not add items back into the idle object pool for a closed pool.", 0,
            pool.getNumIdle());
    pool.invalidateObject(KEY, o2);
    pool.clear(KEY);
    pool.clear();
    pool.close();
}

---

From source file:org.talend.dataquality.common.inference.ConcurrentAnalyzer.java

private ConcurrentAnalyzer(int maxSize, AnalyzerSupplier<Analyzer<T>> supplier) {
    GenericKeyedObjectPool.Config config = new GenericKeyedObjectPool.Config();
    config.maxTotal = maxSize;//from ww  w . j a  v a  2s.  c  o m
    config.maxActive = maxSize;
    config.maxIdle = maxSize / 2;
    config.minIdle = maxSize / 2;
    config.maxWait = -1;
    // #1: Initialize a ThreadLocal backed with a generic object pool -> allows getting previously borrowed instance
    // and return to pool on remove() call.
    // #2: Pool is expected to be thread safe.
    final KeyedObjectPool<Thread, Analyzer<T>> pool = new GenericKeyedObjectPool<>(new Factory<>(supplier),
            config);
    this.threadLocal = new ThreadLocal<Analyzer<T>>() {

        @Override
        protected Analyzer<T> initialValue() {
            try {
                return pool.borrowObject(Thread.currentThread());
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        public void remove() {
            try {
                // Order matters here as remove() causes get() to return null.
                pool.returnObject(Thread.currentThread(), get());
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                // Thread local keeps a lot of references, make sure everything gets cleaned up on error.
                super.remove();
            }
        }
    };
}

---