private static <K, V> List<String> invokeEveryMethod(final KeyedPooledObjectFactory<K, V> kpof) throws Exception { kpof.activateObject(null, null); kpof.destroyObject(null, null); kpof.makeObject(null); kpof.passivateObject(null, null); kpof.validateObject(null, null); kpof.toString(); final List<String> expectedMethods = Arrays.asList(new String[] { "activateObject", "destroyObject", "makeObject", "passivateObject", "validateObject", "toString", }); return expectedMethods; }
boolean active = false; try { factory.activateObject(evictionKey, underTest); active = true; } catch (final Exception e) { if (!factory.validateObject(evictionKey, underTest)) { destroy(evictionKey, underTest, true); destroyedByEvictorCount.incrementAndGet(); } else { try { factory.passivateObject(evictionKey, underTest); } catch (final Exception e) { destroy(evictionKey, underTest, true);
if (getTestOnReturn() && !factory.validateObject(key, p)) { try { destroy(key, p, true); factory.passivateObject(key, p); } catch (final Exception e1) { swallowException(e1);
factory.activateObject(key, p); } catch (final Exception e) { try { Throwable validationThrowable = null; try { validate = factory.validateObject(key, p); } catch (final Throwable t) { PoolUtils.checkRethrow(t);
@Test public void poolFactoryNonstandardObjectLifecycleTest() throws Exception { // Pooled object may be created and passivated right away // E.g. GenericKeyedObjectPool: returnObject() -> reuseCapacity() -> create() and addIdleObject(), which invokes passivate() PooledObject<TServiceClient> pooledObject = factory.makeObject(thriftClientKey); factory.passivateObject(thriftClientKey, pooledObject); }
/** * {@inheritDoc} */ @Override public PooledObject<V> makeObject(final K key) throws Exception { writeLock.lock(); try { return keyedFactory.makeObject(key); } finally { writeLock.unlock(); } }
/** * {@inheritDoc} */ @Override public void passivateObject(final K key, final PooledObject<V> p) throws Exception { writeLock.lock(); try { keyedFactory.passivateObject(key, p); } finally { writeLock.unlock(); } }
/** * {@inheritDoc} */ @Override public void destroyObject(final K key, final PooledObject<V> p) throws Exception { writeLock.lock(); try { keyedFactory.destroyObject(key, p); } finally { writeLock.unlock(); } }
/** * {@inheritDoc} */ @Override public void activateObject(final K key, final PooledObject<V> p) throws Exception { writeLock.lock(); try { keyedFactory.activateObject(key, p); } finally { writeLock.unlock(); } }
/** * {@inheritDoc} */ @Override public boolean validateObject(final K key, final PooledObject<V> p) { writeLock.lock(); try { return keyedFactory.validateObject(key, p); } finally { writeLock.unlock(); } }
boolean active = false; try { factory.activateObject(evictionKey, underTest); active = true; } catch (final Exception e) { if (!factory.validateObject(evictionKey, underTest)) { destroy(evictionKey, underTest, true); destroyedByEvictorCount.incrementAndGet(); } else { try { factory.passivateObject(evictionKey, underTest); } catch (final Exception e) { destroy(evictionKey, underTest, true);
if (getTestOnReturn() && !factory.validateObject(key, p)) { try { destroy(key, p, true); factory.passivateObject(key, p); } catch (final Exception e1) { swallowException(e1);
factory.activateObject(key, p); } catch (final Exception e) { try { Throwable validationThrowable = null; try { validate = factory.validateObject(key, p); } catch (final Throwable t) { PoolUtils.checkRethrow(t);
p = factory.makeObject(key); } catch (final Exception e) { numTotal.decrementAndGet();
/** * Add an object to the set of idle objects for a given key. * * @param key The key to associate with the idle object * @param p The wrapped object to add. * * @throws Exception If the associated factory fails to passivate the object */ private void addIdleObject(final K key, final PooledObject<T> p) throws Exception { if (p != null) { factory.passivateObject(key, p); final LinkedBlockingDeque<PooledObject<T>> idleObjects = poolMap.get(key).getIdleObjects(); if (getLifo()) { idleObjects.addFirst(p); } else { idleObjects.addLast(p); } } }
factory.destroyObject(key, toDestroy); } finally { objectDeque.getCreateCount().decrementAndGet();
/** * {@inheritDoc} */ @Override public void activateObject(final K key, final PooledObject<V> p) throws Exception { writeLock.lock(); try { keyedFactory.activateObject(key, p); } finally { writeLock.unlock(); } }
/** * {@inheritDoc} */ @Override public boolean validateObject(final K key, final PooledObject<V> p) { writeLock.lock(); try { return keyedFactory.validateObject(key, p); } finally { writeLock.unlock(); } }
@Test public void testDefaultMethods() throws Exception { final KeyedPooledObjectFactory<Object,Object> factory = new TestFactory(); factory.activateObject("key",null); // a no-op factory.passivateObject("key",null); // a no-op factory.destroyObject("key",null); // a no-op assertTrue(factory.validateObject("key",null)); // constant true }
/** * {@inheritDoc} */ @Override public PooledObject<V> makeObject(final K key) throws Exception { writeLock.lock(); try { return keyedFactory.makeObject(key); } finally { writeLock.unlock(); } }