/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { pool.clear(); }
@Override public void clear() throws Exception, UnsupportedOperationException { pool.clear(); }
/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { final WriteLock writeLock = readWriteLock.writeLock(); writeLock.lock(); try { pool.clear(); } finally { writeLock.unlock(); } }
private static void reset(final ObjectPool<Object> pool, final MethodCallPoolableObjectFactory factory, final List<MethodCall> expectedMethods) throws Exception { pool.clear(); clear(factory, expectedMethods); factory.reset(); }
private static List<String> invokeEveryMethod(final ObjectPool<Object> op) throws Exception { op.addObject(); op.borrowObject(); op.clear(); op.close(); op.getNumActive(); op.getNumIdle(); op.invalidateObject(new Object()); op.returnObject(new Object()); op.toString(); final List<String> expectedMethods = Arrays.asList(new String[] { "addObject", "borrowObject", "clear", "close", "getNumActive", "getNumIdle", "invalidateObject", "returnObject", "toString" }); return expectedMethods; }
@Test public void testPOFClearUsages() throws Exception { final MethodCallPoolableObjectFactory factory = new MethodCallPoolableObjectFactory(); final ObjectPool<Object> pool; try { pool = makeEmptyPool(factory); } catch (final UnsupportedOperationException uoe) { return; // test not supported } final List<MethodCall> expectedMethods = new ArrayList<>(); /// Test correct behavior code paths PoolUtils.prefill(pool, 5); pool.clear(); //// Test exception handling clear should swallow destory object failures reset(pool, factory, expectedMethods); factory.setDestroyObjectFail(true); PoolUtils.prefill(pool, 5); pool.clear(); pool.close(); }
/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { pool.clear(); }
@Override public void clear() throws Exception { delegate.clear(); }
@Override public void clear() throws Exception, UnsupportedOperationException { pool.clear(); }
@Test public void testUnsupportedOperations() throws Exception { if (!getClass().equals(TestBaseObjectPool.class)) { return; // skip redundant tests } try (final ObjectPool<Object> pool = new TestObjectPool()) { assertTrue("Negative expected.", pool.getNumIdle() < 0); assertTrue("Negative expected.", pool.getNumActive() < 0); try { pool.clear(); fail("Expected UnsupportedOperationException"); } catch (final UnsupportedOperationException e) { // expected } try { pool.addObject(); fail("Expected UnsupportedOperationException"); } catch (final UnsupportedOperationException e) { // expected } } }
expectedMethods.add("getNumIdle"); expectedMethods.add("invalidateObject"); pool.clear();
/** * {@inheritDoc} */ @Override public void clear() throws Exception, UnsupportedOperationException { final WriteLock writeLock = readWriteLock.writeLock(); writeLock.lock(); try { pool.clear(); } finally { writeLock.unlock(); } }
@Test public void testPassThroughMethods01() throws Exception { assertEquals(0, pool.getNumActive()); assertEquals(0, pool.getNumIdle()); pool.addObject(); assertEquals(0, pool.getNumActive()); assertEquals(1, pool.getNumIdle()); pool.clear(); assertEquals(0, pool.getNumActive()); assertEquals(0, pool.getNumIdle()); }
@Override synchronized public void clearPoolConnections() { ObjectPool<PoolableConnection> pool = getPool(); try { if (LOG.isDebugEnabled()) { LOG.debug("Clearing all active/idle (" + pool.getNumActive() + "/" + pool.getNumIdle() + ") connections from the pool"); } pool.clear(); } catch (Exception ex) { LOG.error("Unable to clear connections from the pool: " + ex.getMessage()); } } }
/** * Clears pool(s) maintained by this data source. * * @see org.apache.commons.pool2.ObjectPool#clear() * @since 2.3.0 */ public void clear() { for (final PooledConnectionManager manager : managers.values()) { try { getCPDSConnectionFactoryPool(manager).clear(); } catch (final Exception closePoolException) { // ignore and try to close others. } } InstanceKeyDataSourceFactory.removeInstance(getInstanceKey()); }
@Override protected void doUndeploy(final ServiceUnitDataHandler suDH) throws PEtALSCDKException { final Provides provides = suDH.getDescriptor().getServices().getProvides().get(0); final ObjectPool<WrappedFTPClient> pool = ((FTPComponent) getComponent()).getMapOfPool().get(provides); final PEtALSCDKException ex = new PEtALSCDKException("Error during undeploy"); try { this.logger.fine("Closing pool's resource"); pool.clear(); pool.close(); } catch (Exception e) { ex.addSuppressed(e); } ex.throwIfNeeded(); }
@Override protected void doUndeploy(final ServiceUnitDataHandler suDH) throws PEtALSCDKException { final Provides provides = suDH.getDescriptor().getServices().getProvides().get(0); final ObjectPool<WrappedSftpClient> pool = ((SFTPComponent) getComponent()).getMapOfPool().remove(provides); final PEtALSCDKException ex = new PEtALSCDKException("Error during undeploy"); try { if (pool != null) { this.logger.fine("Closing pool's resource"); pool.clear(); pool.close(); } } catch (Exception e) { ex.addSuppressed(e); } ex.throwIfNeeded(); }
@Test public void testBaseClear() throws Exception { try { _pool = makeEmptyPool(3); } catch(final UnsupportedOperationException e) { return; // skip this test if unsupported } assertEquals(0,_pool.getNumActive()); assertEquals(0,_pool.getNumIdle()); final String obj0 = _pool.borrowObject(); final String obj1 = _pool.borrowObject(); assertEquals(2,_pool.getNumActive()); assertEquals(0,_pool.getNumIdle()); _pool.returnObject(obj1); _pool.returnObject(obj0); assertEquals(0,_pool.getNumActive()); assertEquals(2,_pool.getNumIdle()); _pool.clear(); assertEquals(0,_pool.getNumActive()); assertEquals(0,_pool.getNumIdle()); final Object obj2 = _pool.borrowObject(); assertEquals(getNthObject(2),obj2); _pool.close(); }
assertEquals("A closed pool should still keep count of active objects.", 0, pool.getNumActive()); pool.clear(); pool.close();