/** {@inheritDoc} */ public ActivationSpec createInstance() throws NotFoundException, InstantiationException, IllegalAccessException, ResourceException { Class<?> clz = activationSpecClass.get(); if (clz == null) throw new NotFoundException(bundle.activationSpecClassNotAvailable()); ResourceAdapter ra = rar.get(); if (ra == null) throw new NotFoundException(bundle.resourceAdapterNotAvailable()); ActivationSpec instance = ActivationSpec.class.cast(clz.newInstance()); instance.setResourceAdapter(ra); if (valueProperties != null && valueProperties.size() > 0) { Injection injector = new Injection(); Iterator<Map.Entry<String, String>> it = valueProperties.entrySet().iterator(); while (it.hasNext()) { String propertyName = null; String propertyValue = null; try { Map.Entry<String, String> entry = it.next(); propertyName = entry.getKey(); propertyValue = entry.getValue(); injector.inject(instance, propertyName, propertyValue); } catch (Throwable t) { log.debugf(t, "Ignoring: %s (%s)", propertyName, propertyValue); } } } return instance; }
/** * Gets connection listener instance associated with transaction. This method is package protected * beacause it is intended only for test case use. Please don't use it in your production code. * * @param trackByTransaction transaction instance * @param mcp the managed connection pool associated with the desired connection listener * @return connection listener instance * @throws ResourceException Thrown if an error occurs */ ConnectionListener getTransactionOldConnection( Transaction trackByTransaction, ManagedConnectionPool mcp) throws ResourceException { TransactionSynchronizationRegistry tsr = getTransactionSynchronizationRegistry(); Lock lock = getLock(); try { lock.lockInterruptibly(); } catch (InterruptedException ie) { Thread.interrupted(); throw new ResourceException(bundle.unableObtainLock(), ie); } try { // Already got one ConnectionListener cl = (ConnectionListener) tsr.getResource(mcp); if (cl != null) { if (trace) log.tracef("Previous connection tracked by transaction=%s tx=%s", cl, trackByTransaction); return cl; } return null; } finally { lock.unlock(); } }
/** * Gets new connection listener if necessary instance with transaction. This method is package * protected beacause it is intended only for test case use. Please don't use it in your * production code. * * @param trackByTransaction transaction instance * @param mcp pool instance * @param subject subject instance * @param cri connection request info * @return connection listener instance * @throws ResourceException ResourceException */ ConnectionListener getTransactionNewConnection( Transaction trackByTransaction, ManagedConnectionPool mcp, Subject subject, ConnectionRequestInfo cri) throws ResourceException { // Need a new one for this transaction // This must be done outside the tx local lock, otherwise // the tx timeout won't work and get connection can do a lot of other work // with many opportunities for deadlocks. // Instead we do a double check after we got the transaction to see // whether another thread beat us to the punch. ConnectionListener cl = mcp.getConnection(subject, cri); if (trace) log.tracef( "Got connection from pool tracked by transaction=%s tx=%s", cl, trackByTransaction); TransactionSynchronizationRegistry tsr = getTransactionSynchronizationRegistry(); Lock lock = getLock(); try { lock.lockInterruptibly(); } catch (InterruptedException ie) { Thread.interrupted(); throw new ResourceException(bundle.unableObtainLock(), ie); } try { // Check we weren't racing with another transaction ConnectionListener other = (ConnectionListener) tsr.getResource(mcp); if (other != null) { mcp.returnConnection(cl, false); if (trace) log.tracef( "Another thread already got a connection tracked by transaction=%s tx=%s", other, trackByTransaction); cl = other; } // This is the connection for this transaction cl.setTrackByTx(true); tsr.putResource(mcp, cl); if (trace) log.tracef( "Using connection from pool tracked by transaction=%s tx=%s", cl, trackByTransaction); return cl; } finally { lock.unlock(); } }
/** * Determine the correct pool for this request, creates a new one when necessary. * * @param key the key to the pool * @param subject the subject of the pool * @param cri the connection request info * @return the subpool context * @throws ResourceException for any error */ protected ManagedConnectionPool getManagedConnectionPool( Object key, Subject subject, ConnectionRequestInfo cri) throws ResourceException { try { ManagedConnectionPool mcp = mcpPools.get(key); if (mcp == null) { ManagedConnectionPoolFactory mcpf = new ManagedConnectionPoolFactory(); ManagedConnectionPool newMcp = mcpf.create(mcf, clf, subject, cri, poolConfiguration, this); mcp = mcpPools.putIfAbsent(key, newMcp); if (mcp == null) { mcp = newMcp; initLock(); } } return mcp; } catch (Throwable t) { throw new ResourceException(bundle.unableGetManagedConnectionPool(), t); } }