public CallReturnEvent borrowCallReturnEvent(final int processId, final int invokeId) { if (isEnable) { try { final CallReturnEvent event = (CallReturnEvent) pool.borrowObject(Event.Type.CALL_RETURN); initCallReturnEvent(event, processId, invokeId); return event; } catch (Exception cause) { logger.warn("EventPool borrow CallReturnEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new CallReturnEvent(processId, invokeId); }
public ThrowsEvent borrowThrowsEvent(final int processId, final int invokeId, final Throwable throwable) { if (isEnable) { try { final ThrowsEvent event = (ThrowsEvent) pool.borrowObject(Event.Type.THROWS); initThrowsEvent(event, processId, invokeId, throwable); return event; } catch (Exception cause) { logger.warn("EventPool borrow ThrowsEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new ThrowsEvent(processId, invokeId, throwable); }
public CallThrowsEvent borrowCallThrowsEvent(final int processId, final int invokeId, final String throwException) { if (isEnable) { try { final CallThrowsEvent event = (CallThrowsEvent) pool.borrowObject(Event.Type.CALL_THROWS); initCallThrowsEvent(event, processId, invokeId, throwException); return event; } catch (Exception cause) { logger.warn("EventPool borrow CallThrowsEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new CallThrowsEvent(processId, invokeId, throwException); }
public LineEvent borrowLineEvent(final int processId, final int invokeId, final int lineNumber) { if (isEnable) { try { final LineEvent event = (LineEvent) pool.borrowObject(Event.Type.LINE); initLineEvent(event, processId, invokeId, lineNumber); return event; } catch (Exception cause) { logger.warn("EventPool borrow LineEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new LineEvent(processId, invokeId, lineNumber); }
public ImmediatelyReturnEvent borrowImmediatelyReturnEvent(final int processId, final int invokeId, final Object object) { if (isEnable) { try { final ImmediatelyReturnEvent event = (ImmediatelyReturnEvent) pool.borrowObject(Event.Type.IMMEDIATELY_RETURN); initReturnEvent(event, processId, invokeId, object); return event; } catch (Exception cause) { logger.warn("EventPool borrow ImmediatelyReturnEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new ImmediatelyReturnEvent(processId, invokeId, object); }
public ReturnEvent borrowReturnEvent(final int processId, final int invokeId, final Object object) { if (isEnable) { try { final ReturnEvent event = (ReturnEvent) pool.borrowObject(Event.Type.RETURN); initReturnEvent(event, processId, invokeId, object); return event; } catch (Exception cause) { logger.warn("EventPool borrow ReturnEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new ReturnEvent(processId, invokeId, object); }
public ImmediatelyThrowsEvent borrowImmediatelyThrowsEvent(final int processId, final int invokeId, final Throwable throwable) { if (isEnable) { try { final ImmediatelyThrowsEvent event = (ImmediatelyThrowsEvent) pool.borrowObject(Event.Type.IMMEDIATELY_THROWS); initThrowsEvent(event, processId, invokeId, throwable); return event; } catch (Exception cause) { logger.warn("EventPool borrow ImmediatelyThrowsEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new ImmediatelyThrowsEvent(processId, invokeId, throwable); }
public CallBeforeEvent borrowCallBeforeEvent(final int processId, final int invokeId, final int lineNumber, final String owner, final String name, final String desc) { if (isEnable) { try { final CallBeforeEvent event = (CallBeforeEvent) pool.borrowObject(Event.Type.CALL_BEFORE); initCallBeforeEvent(event, processId, invokeId, lineNumber, owner, name, desc); return event; } catch (Exception cause) { logger.warn("EventPool borrow CallBeforeEvent[processId={};invokeId={};] failed.", processId, invokeId, cause); } } return new CallBeforeEvent(processId, invokeId, lineNumber, owner, name, desc); }
public BeforeEvent borrowBeforeEvent(final int processId, final int invokeId, final ClassLoader javaClassLoader, final String javaClassName, final String javaMethodName, final String javaMethodDesc, final Object target, final Object[] argumentArray) { if (isEnable) { try { final BeforeEvent event = (BeforeEvent) pool.borrowObject(Event.Type.BEFORE); initBeforeEvent( event, processId, invokeId, javaClassLoader, javaClassName, javaMethodName, javaMethodDesc, target, argumentArray ); return event; } catch (Exception cause) { logger.warn("EventPool borrow BeforeEvent[processId={};invokeId={};class={};method={};] failed.", processId, invokeId, javaClassName, javaMethodName, cause); } } return new BeforeEvent( processId, invokeId, javaClassLoader, javaClassName, javaMethodName, javaMethodDesc, target, argumentArray ); }
/** * {@inheritDoc} */ @Override public V borrowObject(final K key) throws Exception, NoSuchElementException, IllegalStateException { return keyedPool.borrowObject(key); }
/** * {@inheritDoc} */ @Override public V borrowObject(final K key) throws Exception, NoSuchElementException, IllegalStateException { final WriteLock writeLock = readWriteLock.writeLock(); writeLock.lock(); try { return keyedPool.borrowObject(key); } finally { writeLock.unlock(); } }
@SuppressWarnings("unchecked") @Override public V borrowObject(final K key) throws Exception, NoSuchElementException, IllegalStateException { UsageTracking<V> usageTracking = null; if (pool instanceof UsageTracking) { usageTracking = (UsageTracking<V>) pool; } final V pooledObject = pool.borrowObject(key); final V proxy = proxySource.createProxy(pooledObject, usageTracking); return proxy; }
@Override public void run() { try { final T obj = _pool.borrowObject(_key); _pool.returnObject(_key, obj); } catch (final Exception e) { // Ignore } } }
@Override public void run() { try { preborrow = System.currentTimeMillis(); final String obj = _pool.borrowObject(_key); objectId = obj; postborrow = System.currentTimeMillis(); Thread.sleep(_pause); _pool.returnObject(_key, obj); postreturn = System.currentTimeMillis(); } catch (final Exception e) { _thrown = e; } finally{ ended = System.currentTimeMillis(); } } }
@Test public void testBaseBorrow() throws Exception { try { _pool = makeEmptyPool(3); } catch(final UnsupportedOperationException uoe) { return; // skip this test if unsupported } final Object keya = makeKey(0); final Object keyb = makeKey(1); assertEquals("1",getNthObject(keya,0),_pool.borrowObject(keya)); assertEquals("2",getNthObject(keyb,0),_pool.borrowObject(keyb)); assertEquals("3",getNthObject(keyb,1),_pool.borrowObject(keyb)); assertEquals("4",getNthObject(keya,1),_pool.borrowObject(keya)); assertEquals("5",getNthObject(keyb,2),_pool.borrowObject(keyb)); assertEquals("6",getNthObject(keya,2),_pool.borrowObject(keya)); _pool.close(); }
private static List<String> invokeEveryMethod(final KeyedObjectPool<Object,Object> kop) throws Exception { kop.addObject(null); kop.borrowObject(null); kop.clear(); kop.clear(null); kop.close(); kop.getNumActive(); kop.getNumActive(null); kop.getNumIdle(); kop.getNumIdle(null); kop.invalidateObject(null, new Object()); kop.returnObject(null, new Object()); kop.toString(); final List<String> expectedMethods = Arrays.asList(new String[] { "addObject", "borrowObject", "clear", "clear", "close", "getNumActive", "getNumActive", "getNumIdle", "getNumIdle", "invalidateObject", "returnObject", "toString" }); return expectedMethods; }
@Test public void testBorrowObject() throws Exception { final TestObject obj = pool.borrowObject(KEY1); assertNotNull(obj); // Make sure proxied methods are working obj.setData(DATA1); assertEquals(DATA1, obj.getData()); pool.returnObject(KEY1, obj); }
@Test(expected=IllegalStateException.class) public void testAccessAfterReturn() throws Exception { final TestObject obj = pool.borrowObject(KEY1); assertNotNull(obj); // Make sure proxied methods are working obj.setData(DATA1); assertEquals(DATA1, obj.getData()); pool.returnObject(KEY1, obj); assertNotNull(obj); obj.getData(); }
@Test(expected=IllegalStateException.class) public void testAccessAfterInvalidate() throws Exception { final TestObject obj = pool.borrowObject(KEY1); assertNotNull(obj); // Make sure proxied methods are working obj.setData(DATA1); assertEquals(DATA1, obj.getData()); pool.invalidateObject(KEY1, obj); assertNotNull(obj); obj.getData(); }
@Test public void testBaseInvalidateObject() throws Exception { try { _pool = makeEmptyPool(3); } catch(final UnsupportedOperationException uoe) { return; // skip this test if unsupported } final Object keya = makeKey(0); assertEquals(0,_pool.getNumActive(keya)); assertEquals(0,_pool.getNumIdle(keya)); final Object obj0 = _pool.borrowObject(keya); final Object obj1 = _pool.borrowObject(keya); assertEquals(2,_pool.getNumActive(keya)); assertEquals(0,_pool.getNumIdle(keya)); _pool.invalidateObject(keya,obj0); assertEquals(1,_pool.getNumActive(keya)); assertEquals(0,_pool.getNumIdle(keya)); _pool.invalidateObject(keya,obj1); assertEquals(0,_pool.getNumActive(keya)); assertEquals(0,_pool.getNumIdle(keya)); _pool.close(); }