| Methods Summary |
|---|
| private boolean | closeAll(java.util.Map cmToConnectionsMap)
if (debug == false)
return false;
boolean unclosed = false;
Collection connections = cmToConnectionsMap.values();
if (connections.size() != 0)
{
for (Iterator i = connections.iterator(); i.hasNext();)
{
Collection conns = (Collection) i.next();
for (Iterator j = conns.iterator(); j.hasNext();)
{
Object c = ((ConnectionRecord) j.next()).connection;
CloseConnectionSynchronization cas = getCloseConnectionSynchronization(true);
if (cas == null)
{
unclosed = true;
closeConnection(c);
}
else
cas.add(c);
}
}
}
return unclosed;
|
| private void | closeConnection(java.lang.Object c)
try
{
Throwable e;
synchronized (connectionStackTraces)
{
e = (Throwable) connectionStackTraces.remove(c);
}
Method m = c.getClass().getMethod("close", new Class[]{});
try
{
if (e != null)
log.info("Closing a connection for you. Please close them yourself: " + c, e);
else
log.info("Closing a connection for you. Please close them yourself: " + c);
m.invoke(c, new Object[]{});
}
catch (Throwable t)
{
log.info("Throwable trying to close a connection for you, please close it yourself", t);
}
}
catch (NoSuchMethodException nsme)
{
log.info("Could not find a close method on alleged connection objects. Please close your own connections.");
}
|
| private void | disconnect(org.jboss.resource.connectionmanager.CachedConnectionManager$KeyConnectionAssociation key, java.util.Set unsharableResources)
Map cmToConnectionsMap = key.getCMToConnectionsMap();
if (!cmToConnectionsMap.isEmpty())
{
synchronized (objectToConnectionManagerMap)
{
objectToConnectionManagerMap.put(key, cmToConnectionsMap);
}
for (Iterator i = cmToConnectionsMap.keySet().iterator(); i.hasNext();)
{
ConnectionCacheListener cm = (ConnectionCacheListener) i.next();
Collection conns = (Collection) cmToConnectionsMap.get(cm);
cm.disconnect(conns, unsharableResources);
}
}
|
| private org.jboss.resource.connectionmanager.CachedConnectionManager$CloseConnectionSynchronization | getCloseConnectionSynchronization(boolean createIfNotFound)
try
{
Transaction tx = tm.getTransaction();
if (TxUtils.isActive(tx))
{
TransactionSynchronizer.lock(tx);
try
{
CloseConnectionSynchronization cas = (CloseConnectionSynchronization) TransactionSynchronizer.getCCMSynchronization(tx);
if (cas == null && createIfNotFound)
{
cas = new CloseConnectionSynchronization();
TransactionSynchronizer.registerCCMSynchronization(tx, cas);
}
return cas;
}
finally
{
TransactionSynchronizer.unlock(tx);
}
}
}
catch (Throwable t)
{
log.debug("Unable to synchronize with transaction", t);
}
return null;
|
| public int | getInUseConnections()
synchronized (connectionStackTraces)
{
return connectionStackTraces.size();
}
|
| public org.jboss.resource.connectionmanager.CachedConnectionManager | getInstance()
return this;
|
| public javax.management.ObjectName | getTransactionManagerServiceName()
return transactionManagerServiceName;
|
| public boolean | isDebug()
return debug;
|
| public boolean | isError()
return error;
|
| public boolean | isSpecCompliant()
return specCompliant;
|
| public java.util.Map | listInUseConnections()
synchronized (connectionStackTraces)
{
HashMap result = new HashMap();
for (Iterator i = connectionStackTraces.entrySet().iterator(); i.hasNext();)
{
Map.Entry entry = (Map.Entry) i.next();
Throwable stackTrace = (Throwable) entry.getValue();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(baos);
stackTrace.printStackTrace(ps);
result.put(entry.getKey().toString(), baos.toString());
}
return result;
}
|
| org.jboss.resource.connectionmanager.CachedConnectionManager$KeyConnectionAssociation | peekMetaAwareObject()
LinkedList stack = (LinkedList) currentObjects.get();
if (stack == null)
return null;
if (!stack.isEmpty())
return (KeyConnectionAssociation) stack.getLast();
else
return null;
|
| public void | popMetaAwareObject(java.util.Set unsharableResources)Describe popMetaAwareObject method here.
PUBLIC for TESTING PURPOSES ONLY!
LinkedList stack = (LinkedList) currentObjects.get();
KeyConnectionAssociation oldKey = (KeyConnectionAssociation) stack.removeLast();
if (trace)
log.trace("popped object: " + Strings.defaultToString(oldKey));
if (specCompliant)
{
if (!stack.contains(oldKey))
{
disconnect(oldKey, unsharableResources);
} // end of if ()
}
else if (debug)
{
if (closeAll(oldKey.getCMToConnectionsMap()) && error)
throw new ResourceException("Some connections were not closed, see the log for the allocation stacktraces");
}
//At one time I attempted to recycle connections held over method calls.
//This caused problems if the other method call started a new transaction.
//To assure optimal use of connections, close them before calling out.
|
| public void | pushMetaAwareObject(java.lang.Object rawKey, java.util.Set unsharableResources)Describe pushMetaAwareObject method here.
PUBLIC for TESTING PURPOSES ONLY!
LinkedList stack = (LinkedList) currentObjects.get();
if (stack == null)
{
if (trace)
log.trace("new stack for key: " + Strings.defaultToString(rawKey));
stack = new LinkedList();
currentObjects.set(stack);
} // end of if ()
else
{
if (trace)
log.trace("old stack for key: " + Strings.defaultToString(rawKey));
//At one time I attempted to recycle connections held over method calls.
//This caused problems if the other method call started a new transaction.
//To assure optimal use of connections, close them before calling out.
} // end of else
//check for reentrancy, reconnect if not reentrant.
//wrap key to be based on == rather than equals
KeyConnectionAssociation key = new KeyConnectionAssociation(rawKey);
if (specCompliant && !stack.contains(key))
{
reconnect(key, unsharableResources);
}
stack.addLast(key);
|
| private void | reconnect(org.jboss.resource.connectionmanager.CachedConnectionManager$KeyConnectionAssociation key, java.util.Set unsharableResources)The reconnect method gets the cmToConnectionsMap
from objectToConnectionManagerMap, copies it to the key, and
reconnects all the connections in it.
Map cmToConnectionsMap = null;
synchronized (objectToConnectionManagerMap)
{
cmToConnectionsMap = (Map) objectToConnectionManagerMap.get(key);
if (cmToConnectionsMap == null)
return;
}
key.setCMToConnectionsMap(cmToConnectionsMap);
for (Iterator i = cmToConnectionsMap.keySet().iterator(); i.hasNext();)
{
ConnectionCacheListener cm = (ConnectionCacheListener) i.next();
Collection conns = (Collection) cmToConnectionsMap.get(cm);
cm.reconnect(conns, unsharableResources);
}
|
| void | registerConnection(ConnectionCacheListener cm, ConnectionListener cl, java.lang.Object connection, javax.resource.spi.ConnectionRequestInfo cri)
if (debug)
{
synchronized (connectionStackTraces)
{
connectionStackTraces.put(connection, new Throwable("STACKTRACE"));
}
}
KeyConnectionAssociation key = peekMetaAwareObject();
if (trace)
log.trace("registering connection from " + cm + ", connection : " + connection + ", key: " + key);
if (key == null)
return; //not participating properly in this management scheme.
ConnectionRecord cr = new ConnectionRecord(cl, connection, cri);
Map cmToConnectionsMap = key.getCMToConnectionsMap();
Collection conns = (Collection) cmToConnectionsMap.get(cm);
if (conns == null)
{
conns = new ArrayList();
cmToConnectionsMap.put(cm, conns);
}
conns.add(cr);
|
| public void | setDebug(boolean value)
this.debug = value;
|
| public void | setError(boolean value)
this.error = value;
|
| public void | setSpecCompliant(boolean specCompliant)
if (specCompliant)
log.warn("THE SpecCompliant ATTRIBUTE IS MISNAMED SEE http://jira.jboss.com/jira/browse/JBAS-1662");
this.specCompliant = specCompliant;
|
| public void | setTransactionManagerServiceName(javax.management.ObjectName transactionManagerServiceName)
this.transactionManagerServiceName = transactionManagerServiceName;
|
| protected void | startService()
tm = (TransactionManager) getServer().getAttribute(transactionManagerServiceName,
"TransactionManager");
TransactionSynchronizer.setTransactionManager(tm);
ServerVMClientUserTransaction.getSingleton().registerTxStartedListener(this);
EnterpriseContext.setUserTransactionStartedListener(this);
|
| protected void | stopService()
ServerVMClientUserTransaction.getSingleton().unregisterTxStartedListener(this);
EnterpriseContext.setUserTransactionStartedListener(null);
|
| void | unregisterConnection(ConnectionCacheListener cm, java.lang.Object c)
if (debug)
{
CloseConnectionSynchronization cas = getCloseConnectionSynchronization(false);
if (cas != null)
cas.remove(c);
synchronized (connectionStackTraces)
{
connectionStackTraces.remove(c);
}
}
KeyConnectionAssociation key = peekMetaAwareObject();
if (trace)
log.trace("unregistering connection from " + cm + ", object: " + c + ", key: " + key);
if (key == null)
return; //not participating properly in this management scheme.
Map cmToConnectionsMap = key.getCMToConnectionsMap();
Collection conns = (Collection) cmToConnectionsMap.get(cm);
if (conns == null)
return; // Can happen if connections are "passed" between contexts
for (Iterator i = conns.iterator(); i.hasNext();)
{
if (((ConnectionRecord) i.next()).connection == c)
{
i.remove();
return;
}
}
throw new IllegalStateException("Trying to return an unknown connection2! " + c);
|
| void | unregisterConnectionCacheListener(ConnectionCacheListener cm)Describe unregisterConnectionCacheListener method here.
This is a shutdown method called by a connection manager. It will remove all reference
to that connection manager from the cache, so cached connections from that manager
will never be recoverable.
Possibly this method should not exist.
if (trace)
log.trace("unregisterConnectionCacheListener: " + cm);
synchronized (objectToConnectionManagerMap)
{
for (Iterator i = objectToConnectionManagerMap.values().iterator(); i.hasNext();)
{
Map cmToConnectionsMap = (Map) i.next();
if (cmToConnectionsMap != null)
cmToConnectionsMap.remove(cm);
}
}
|
| public void | userTransactionStarted()
KeyConnectionAssociation key = peekMetaAwareObject();
if (trace)
log.trace("user tx started, key: " + key);
if (key == null)
return; //not participating properly in this management scheme.
Map cmToConnectionsMap = key.getCMToConnectionsMap();
for (Iterator i = cmToConnectionsMap.keySet().iterator(); i.hasNext();)
{
ConnectionCacheListener cm = (ConnectionCacheListener) i.next();
Collection conns = (Collection) cmToConnectionsMap.get(cm);
cm.transactionStarted(conns);
}
|
