public LocalTxDataSource() 
{

}

 protected  void bindConnectionFactory() throws Exception 
{
      InitialContext ctx = initialContext;
      try
      {
         Name name = ctx.getNameParser("").parse(jndiName);
         String key = name.toString();
         if( true == true && name.size()  > 1 )
         {
            int size = name.size() - 1;
            Util.createSubcontext(initialContext, name.getPrefix(size));
         }
         NonSerializableFactory.rebind(initialContext, key, datasource);
         log.info("Bound datasource to JNDI name '" + jndiName + "'");
      }
      catch (NamingException ne)
      {
         throw new DeploymentException("Could not bind ConnectionFactory into jndi: " + jndiName, ne);
      }
      finally
      {
         ctx.close();
      }
}

Bind the connection factory into jndi

 public int getBlockingTimeout() 
{
      return poolParams.blockingTimeout;
}

 public String getCheckValidConnectionSQL() 
{
      return mcf.getCheckValidConnectionSQL();
}

 public String getConnectionURL() 
{
      return mcf.getConnectionURL();
}

 public Object getDatasource() 
{
      return datasource;
}

 public String getDriverClass() 
{
      return mcf.getDriverClass();
}

 public String getExceptionSorterClassName() 
{
      return mcf.getExceptionSorterClassName();
}

 public long getIdleTimeout() 
{
      return poolParams.idleTimeout;
}

 public String getJndiName() 
{
      return jndiName;
}

 public int getMaxSize() 
{
      return poolParams.maxSize;
}

 public int getMinSize() 
{
      return poolParams.minSize;
}

 public String getNewConnectionSQL() 
{
      return mcf.getNewConnectionSQL();
}

 public int getPreparedStatementCacheSize() 
{
      return mcf.getPreparedStatementCacheSize();
}

 public boolean getSharePreparedStatements() 
{
      return mcf.getSharePreparedStatements();
}

 public String getTrackStatements() 
{
      return mcf.getTrackStatements();
}

 public String getTransactionIsolation() 
{
      return mcf.getTransactionIsolation();
}

 public TransactionManager getTransactionManager() 
{
      return transactionManager;
}

 public boolean getTxQueryTimeout() 
{
      return mcf.isTransactionQueryTimeout();
}

 public String getValidConnectionCheckerClassName() 
{
      return mcf.getValidConnectionCheckerClassName();
}

 public  void setBlockingTimeout(int blockingTimeout) 
{
      poolParams.blockingTimeout = blockingTimeout;
}

 public  void setCachedConnectionManager(CachedConnectionManagerReference cachedConnectionManager) 
{
      this.cachedConnectionManager = cachedConnectionManager.getCachedConnectionManager();
}

 public  void setCheckValidConnectionSQL(String checkValidConnectionSQL) 
{
      mcf.setCheckValidConnectionSQL(checkValidConnectionSQL);
}

 public  void setConnectionURL(String connectionURL) 
{
      mcf.setConnectionURL(connectionURL);
}

 public  void setDriverClass(String driverClass) 
{
      mcf.setDriverClass(driverClass);
}

 public  void setExceptionSorterClassName(String exceptionSorterClassName) 
{
      mcf.setExceptionSorterClassName(exceptionSorterClassName);
}

 public  void setIdleTimeout(long idleTimeout) 
{
      poolParams.idleTimeout = idleTimeout;
}

 public  void setInitialContextProperties(Hashtable initialContextProperties) 
{
      this.initialContextProperties = initialContextProperties;
}

 public  void setJndiName(String jndiName) 
{
      this.jndiName = jndiName;
}

 public  void setMaxSize(int maxSize) 
{
      poolParams.maxSize = maxSize;
}

 public  void setMinSize(int minSize) 
{
      poolParams.minSize = minSize;
}

 public  void setNewConnectionSQL(String newConnectionSQL) 
{
      mcf.setNewConnectionSQL(newConnectionSQL);
}

 public  void setPassword(String password) 
{
      mcf.setPassword(password);
}

 public  void setPreparedStatementCacheSize(int size) 
{
      mcf.setPreparedStatementCacheSize(size);
}

 public  void setSharePreparedStatements(boolean sharePS) 
{
      mcf.setSharePreparedStatements(sharePS);
}

 public  void setTrackStatements(String value) 
{
      mcf.setTrackStatements(value);
}

 public  void setTransactionIsolation(String transactionIsolation) 
{
      mcf.setTransactionIsolation(transactionIsolation);
}

 public  void setTransactionManager(TransactionManager transactionManager) 
{
      this.transactionManager = transactionManager;
}

 public  void setTxQueryTimeout(boolean qt) 
{
      mcf.setTransactionQueryTimeout(qt);
}

 public  void setUserName(String userName) 
{
      mcf.setUserName(userName);
}

 public  void setValidConnectionCheckerClassName(String value) 
{
      mcf.setValidConnectionCheckerClassName(value);
}

 public  void start() throws Exception 
{
      if (initialContextProperties == null) initialContext = new InitialContext();
      else initialContext = new InitialContext(initialContextProperties);
      connectionManager = new TxConnectionManager(cachedConnectionManager, pool, transactionManager);
      connectionManager.setLocalTransactions(true);
      connectionManager.setTrackConnectionByTx(true);
      pool.setConnectionListenerFactory(connectionManager);
      datasource = connectionManager.getPoolingStrategy().getManagedConnectionFactory().createConnectionFactory(new ConnectionManagerDelegate());
      bindConnectionFactory();
}

 protected  void unbindConnectionFactory() throws Exception 
{
      InitialContext ctx = initialContext;
      try
      {                                              
         ctx.unbind(jndiName);
         NonSerializableFactory.unbind(jndiName);
         log.info("Unbound datasource for JNDI name '" + jndiName + "'");
      }
      catch (NamingException ne)
      {
         log.error("Could not unbind datasource from jndi: " + jndiName, ne);
      }
      finally
      {
         ctx.close();
      }
}