/** Clears the idle connections in the pool. */ @Override public void clear() { ArrayList<ManagedPoolItem> pool = _connectionPool; if (pool == null) return; ArrayList<ManagedPoolItem> clearItems = new ArrayList<ManagedPoolItem>(); synchronized (_connectionPool) { _idlePool.clear(); clearItems.addAll(pool); pool.clear(); } for (int i = 0; i < clearItems.size(); i++) { ManagedPoolItem poolItem = clearItems.get(i); try { poolItem.destroy(); } catch (Throwable e) { log.log(Level.WARNING, e.toString(), e); } } }
/** Alarm listener. */ @Override public void handleAlarm(Alarm alarm) { if (!_lifecycle.isActive()) return; try { _alarmConnections.clear(); synchronized (_connectionPool) { _alarmConnections.addAll(_connectionPool); } for (int i = _alarmConnections.size() - 1; i >= 0; i--) { ManagedPoolItem item = _alarmConnections.get(i); if (!item.isValid()) item.destroy(); } _alarmConnections.clear(); fillIdlePool(); } finally { if (!_lifecycle.isActive()) { } else if (0 < _idleTimeout && _idleTimeout < 1000) _alarm.queue(1000); else if (1000 < _idleTimeout && _idleTimeout < 60000) _alarm.queue(_idleTimeout); else _alarm.queue(60000); } }
public void configurePhaseListeners(ArrayList<PhaseListener> list) { try { for (int i = 0; i < _phaseListenerList.size(); i++) list.add((PhaseListener) _phaseListenerList.get(i).newInstance()); } catch (RuntimeException e) { throw e; } catch (Exception e) { throw ConfigException.create(e); } }
/* * Removes a connection from the pool. */ public void markForPoolRemoval(ManagedConnection mConn) { synchronized (_connectionPool) { for (int i = _connectionPool.size() - 1; i >= 0; i--) { ManagedPoolItem poolItem = _connectionPool.get(i); if (poolItem.getManagedConnection() == mConn) { poolItem.setConnectionError(); return; } } } }
private ManagedPoolItem findPoolItem(ManagedConnection mConn) { synchronized (_connectionPool) { for (int i = _connectionPool.size() - 1; i >= 0; i--) { ManagedPoolItem testPoolItem = _connectionPool.get(i); if (testPoolItem.getManagedConnection() == mConn) { return testPoolItem; } } return null; } }
/** Finds the pool item joined to this one. return null. */ ManagedPoolItem findJoin(UserTransactionImpl uTrans, ManagedPoolItem item) { if (!uTrans.isActive()) return null; ArrayList<ManagedXAResource> poolItems = uTrans.getXaResources(); int length = poolItems.size(); for (int i = 0; i < length; i++) { ManagedXAResource resource = poolItems.get(i); if (resource instanceof ManagedPoolItem) { ManagedPoolItem poolItem = (ManagedPoolItem) resource; if (poolItem.isJoin(item)) return poolItem; } } return null; }
/** Allocates a resource matching the parameters. If none matches, return null. */ private UserPoolItem allocateShared( UserTransactionImpl transaction, ManagedConnectionFactory mcf, Subject subject, ConnectionRequestInfo info) { if (!transaction.isActive()) return null; ArrayList<ManagedXAResource> poolItems = transaction.getXaResources(); int length = poolItems.size(); for (int i = 0; i < length; i++) { ManagedXAResource xaResource = poolItems.get(i); if (xaResource instanceof ManagedPoolItem) { ManagedPoolItem poolItem = (ManagedPoolItem) xaResource; UserPoolItem item = poolItem.allocateXA(mcf, subject, info); if (item != null) return item; } } return null; }
/** Destroys the manager. */ public void destroy() { stop(); if (!_lifecycle.toDestroy()) return; ArrayList<ManagedPoolItem> pool; synchronized (_connectionPool) { pool = new ArrayList<ManagedPoolItem>(_connectionPool); _connectionPool.clear(); if (_idlePool != null) _idlePool.clear(); } for (int i = 0; i < pool.size(); i++) { ManagedPoolItem poolItem = pool.get(i); try { poolItem.destroy(); } catch (Throwable e) { log.log(Level.WARNING, e.toString(), e); } } }