public void returnConnection( ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { next.returnConnection(connectionInfo, connectionReturnAction); }
public void returnConnection( ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { next.returnConnection(connectionInfo, connectionReturnAction); }
public void returnConnection( ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { next.returnConnection(connectionInfo, connectionReturnAction); }
public void returnConnection(ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { next.returnConnection(connectionInfo, connectionReturnAction); }
public void returnConnection(ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { Thread currentThread = Thread.currentThread(); ClassLoader oldClassLoader = currentThread.getContextClassLoader(); try { currentThread.setContextClassLoader(classLoader); next.returnConnection(connectionInfo, connectionReturnAction); } finally { currentThread.setContextClassLoader(oldClassLoader); } }
/** * called by: GeronimoConnectionEventListener.connectionClosed, GeronimoConnectionEventListener.connectionErrorOccurred, exit * in: handle has already been dissociated from ManagedConnection. connectionInfo not null, has non-null ManagedConnectionInfo, ManagedConnectionInfo has non-null ManagedConnection * handle can be null if called from error in ManagedConnection in pool. * out: connectionTracker has been notified, ManagedConnectionInfo null. * @param connectionInfo * @param connectionReturnAction */ public void returnConnection( ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { connectionTracker.handleReleased(this, connectionInfo, connectionReturnAction); next.returnConnection(connectionInfo, connectionReturnAction); }
public void returnNamedXAResource(NamedXAResource namedXAResource) { NamedXAResourceWithConnectioninfo xares = (NamedXAResourceWithConnectioninfo) namedXAResource; recoveryStack.returnConnection(xares.getConnectionInfo(), ConnectionReturnAction.DESTROY); }
public void returnConnection( ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { ManagedConnectionInfo mci = connectionInfo.getManagedConnectionInfo(); ConnectionInterceptor poolInterceptor = mci.getPoolInterceptor(); poolInterceptor.returnConnection(connectionInfo, connectionReturnAction); }
public void run() { // protect against interceptor being set to null mid-execution AbstractSinglePoolConnectionInterceptor interceptor = parent; if (interceptor == null) return; interceptor.resizeLock.readLock().lock(); try { long threshold = System.currentTimeMillis() - interceptor.idleTimeoutMilliseconds; List<ManagedConnectionInfo> killList = new ArrayList<ManagedConnectionInfo>(interceptor.getPartitionMaxSize()); interceptor.getExpiredManagedConnectionInfos(threshold, killList); for (ManagedConnectionInfo managedConnectionInfo : killList) { ConnectionInfo killInfo = new ConnectionInfo(managedConnectionInfo); parent.next.returnConnection(killInfo, ConnectionReturnAction.DESTROY); } } catch (Throwable t) { log.error("Error occurred during execution of ExpirationMonitor TimerTask", t); } finally { interceptor.resizeLock.readLock().unlock(); } }
private void internalReturn(ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { if (connectionInfo.getManagedConnectionInfo().hasConnectionHandles()) { if (log.isTraceEnabled()) { log.trace("not returning connection from tx cache (has handles) " + infoString(connectionInfo)); } return; } //No transaction, no handles, we return it. next.returnConnection(connectionInfo, connectionReturnAction); if (log.isTraceEnabled()) { log.trace("completed return of connection through tx cache " + infoString(connectionInfo)); } }
public void returnConnection(ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { if (connectionReturnAction == ConnectionReturnAction.DESTROY || connectionInfo.isUnshareable() || !connectionInfo.getManagedConnectionInfo().hasConnectionHandles()) { if (connections.get() == connectionInfo.getManagedConnectionInfo()) { connections.remove(); } next.returnConnection(connectionInfo, connectionReturnAction); } }
/** * in: connectionInfo not null, managedConnectionInfo not null, managedConnection not null. Handle can be null if mc is being destroyed from pool. * out: managedCOnnectionInfo null, handle not in mci.handles. * @param connectionInfo * @param connectionReturnAction */ public void returnConnection(ConnectionInfo connectionInfo, ConnectionReturnAction connectionReturnAction) { if (connectionInfo.getConnectionHandle() != null) { connectionInfo.getManagedConnectionInfo().removeConnectionHandle( connectionInfo); } next.returnConnection(connectionInfo, connectionReturnAction); }
final ManagedConnectionInfo mci = connections.get(invalid); if (mci != null) { stack.returnConnection(new ConnectionInfo(mci), ConnectionReturnAction.DESTROY); continue;
final ManagedConnectionInfo mci = connections.get(invalid); if (mci != null) { stack.returnConnection(new ConnectionInfo(mci), ConnectionReturnAction.DESTROY); continue;
log.trace("destroying connection " + infoString(connectionInfo)); next.returnConnection(connectionInfo, connectionReturnAction); return;
next.returnConnection(connectionInfo, connectionReturnAction);
public void connectionClosed(ConnectionEvent connectionEvent) { if (connectionEvent.getSource() != managedConnectionInfo.getManagedConnection()) { throw new IllegalArgumentException( "ConnectionClosed event received from wrong ManagedConnection. Expected " + managedConnectionInfo.getManagedConnection() + ", actual " + connectionEvent.getSource()); } if (log.isTraceEnabled()) { log.trace("connectionClosed called with " + connectionEvent.getConnectionHandle() + " for MCI: " + managedConnectionInfo + " and MC: " + managedConnectionInfo.getManagedConnection()); } ConnectionInfo ci = new ConnectionInfo(managedConnectionInfo); ci.setConnectionHandle(connectionEvent.getConnectionHandle()); try { stack.returnConnection(ci, ConnectionReturnAction.RETURN_HANDLE); } catch (Throwable e) { if (log.isTraceEnabled()) { log.trace("connectionClosed failed with " + connectionEvent.getConnectionHandle() + " for MCI: " + managedConnectionInfo + " and MC: " + managedConnectionInfo.getManagedConnection(), e); } if (e instanceof Error) { throw (Error)e; } } }
public void connectionErrorOccurred(ConnectionEvent connectionEvent) { if (connectionEvent.getSource() != managedConnectionInfo.getManagedConnection()) { throw new IllegalArgumentException( "ConnectionError event received from wrong ManagedConnection. Expected " + managedConnectionInfo.getManagedConnection() + ", actual " + connectionEvent.getSource()); } log.warn("connectionErrorOccurred called with " + connectionEvent.getConnectionHandle(), connectionEvent.getException()); boolean errorOccurred = this.errorOccurred; this.errorOccurred = true; if (!errorOccurred) { ConnectionInfo ci = new ConnectionInfo(managedConnectionInfo); ci.setConnectionHandle(connectionEvent.getConnectionHandle()); stack.returnConnection(ci, ConnectionReturnAction.DESTROY); } }
public void getConnection(ConnectionInfo connectionInfo) throws ResourceException { next.getConnection(connectionInfo); try { ManagedConnectionInfo mci = connectionInfo.getManagedConnectionInfo(); // get the current transation and status... if there is a problem just assume there is no transaction present Transaction transaction = TxUtil.getTransactionIfActive(transactionManager); if (transaction != null) { XAResource xares = mci.getXAResource(); if (log.isTraceEnabled()) { log.trace("Enlisting connection " + connectionInfo + " with XAResource " + xares + " in transaction: " + transaction); } transaction.enlistResource(xares); } else { if (log.isTraceEnabled()) { log.trace("not enlisting connection " + connectionInfo + " with XAResource " + mci.getXAResource() + " no transaction"); } } } catch (SystemException e) { returnConnection(connectionInfo, ConnectionReturnAction.DESTROY); throw new ResourceException("Could not get transaction", e); } catch (RollbackException e) { //transaction is marked rolled back, so the xaresource could not have been enlisted next.returnConnection(connectionInfo, ConnectionReturnAction.RETURN_HANDLE); throw new ResourceException("Could not enlist resource in rolled back transaction", e); } catch (Throwable t) { returnConnection(connectionInfo, ConnectionReturnAction.DESTROY); throw new ResourceException("Unknown throwable when trying to enlist connection in tx", t); } }
public void getConnection(ConnectionInfo connectionInfo) throws ResourceException { if (connectionInfo.isUnshareable()) { next.getConnection(connectionInfo); return; } ManagedConnectionInfo managedConnectionInfo = connections.get(); if (managedConnectionInfo != null) { if (matchConnections) { ManagedConnectionInfo mciRequest = connectionInfo.getManagedConnectionInfo(); if (null != managedConnectionInfo.getManagedConnectionFactory().matchManagedConnections( Collections.singleton(managedConnectionInfo.getManagedConnection()), mciRequest.getSubject(), mciRequest.getConnectionRequestInfo() )) { connectionInfo.setManagedConnectionInfo(managedConnectionInfo); return; } else { //match failed, get a new cx after returning this one connections.set(null); next.returnConnection(connectionInfo, ConnectionReturnAction.RETURN_HANDLE); } } else { connectionInfo.setManagedConnectionInfo(managedConnectionInfo); return; } } //nothing for this thread or match failed next.getConnection(connectionInfo); connections.set(connectionInfo.getManagedConnectionInfo()); }