<?xml version="1.0" encoding="UTF-8"?>
<connector configId="user/database-pool-HibernateDS/1/car" xmlns="http://geronimo.apache.org/xml/ns/j2ee/connector-1.02">
  <dep:dependencyenvironment xmlns:dep="http://geronimo.apache.org/xml/ns/deployment-1.01">
    <dep:uri>mysql/mysql-connector-java/3.1.10-bin/jar</dep:uri>
  </dep:dependency>
  <resourceadapter>
    moduleId>
	  <dep:groupId>user</dep:groupId>
	  <dep:artifactId>database-pool-HibernateDB</dep:artifactId>
	  <dep:version>2.0</dep:version>
	  <dep:type>car</dep:type>
	</dep:moduleId>
	<dep:dependencies>
	  <dep:dependency
	    <dep:groupId>mysql</dep:groupId>
		<dep:artifactId>mysql-connector-java</dep:artifactId>
		<dep:version>3.1.10-bin</dep:version>
		<dep:type>jar</dep:type>
	  </dep:dependency>
	</dep:dependencies>
  </dep:environment>
  <resourceadapter>
    <outbound-resourceadapter>
      <connection-definition>
        <connectionfactory-interface>javax.sql.DataSource</connectionfactory-interface>
        <connectiondefinition-instance>
          <name>HibernateDS</name>
          <config-property-setting name="Password">password</config-property-setting>
          <config-property-setting name="CommitBeforeAutocommit">false</config-property-setting>
          <config-property-setting name="Driver">com.mysql.jdbc.Driver</config-property-setting>
          <config-property-setting name="ExceptionSorterClass">
	                                 org.tranql.connector>org.tranql.connector.AllExceptionsAreFatalSorter</config-property-setting>
          <config-property-setting name="UserName">root</config-property-setting>
          <config-property-setting name="ConnectionURL">jdbc:mysql://localhost:3306/adi</config-property-setting>
          <connectionmanager>
            <local-transaction/>
            <single-pool>
              <max-size>10</max-size>
              <min-size>0</min-size>
              <blocking-timeout-milliseconds>5000</blocking-timeout-milliseconds>
              <idle-timeout-minutes>30</idle-timeout-minutes>
              <match-one/>
            </single-pool>
          </connectionmanager>
        </connectiondefinition-instance>
      </connection-definition>
    </outbound-resourceadapter>
  </resourceadapter>
</connector>

E:\geronimo-1.0\bin>deploy --user system --password manager deploy \brokerage\plan\mysql-geronimo-plan.xml
..\repository\tranql\rars\tranql-connector-1.1.rar
    Deployed user/database-pool-HibernateDS/1/car

package com.dev.trade.util;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

/**
 * Configures and provides access to Hibernate sessions, tied to the
 * current thread of execution.  Follows the Thread Local Session
 * pattern, see {@link http://hibernate.org/42.html}.
 */
public class HibernateUtil {

    /** location of the Hibernate Configuration File */
    private static String CONFIG_FILE_LOCATION = "hibernate.cfg.xml";

    /** Holds a single instance of Session */
    private static final ThreadLocal threadLocal = new ThreadLocal();

    /** The single instance of hibernate configuration */
    private static final Configuration cfg = new Configuration();

    /** The single instance of hibernate SessionFactory */
    private static org.hibernate.SessionFactory sessionFactory;

    /**
     * Returns the ThreadLocal Session instance.  Lazy initialize
     * the <code>SessionFactory</code> if needed.
     *
     *  @return Session
     *  @throws HibernateException
     */
    public static Session getCurrentSession() throws HibernateException {
        Session session = (Session) threadLocal.get();

        if (session == null || ! session.isConnected()) {
            if (sessionFactory == null) {
                try {
                    cfg.configure(CONFIG_FILE_LOCATION);
                    sessionFactory = cfg.buildSessionFactory();
                }
                catch (Exception e) {
                    System.err.println("%%%% Error Creating SessionFactory %%%%");
                    e.printStackTrace();
                }
            }
            session = sessionFactory.openSession();
            threadLocal.set(session);
        }

        return session;
    }

    /**
     *  Close the single hibernate session instance.
     *
     *  @throws HibernateException
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();


        if (session != null) {
            session.close();
        }
    }



}

package org.hibernate.transaction;

import java.util.Iterator;
import java.util.Properties;
import javaxjava.managementutil.ObjectNameSet;

import javax.transaction.TransactionManager;
import org.hibernate.HibernateException;
import org.hibernate.transaction.TransactionManagerLookup;

public class GeronimoTransactionManagerLookup
    implements TransactionManagerLookup
{
   public static final String TransactionMgrGBeanName="geronimo.server:J2EEApplication=null,
      J2EEModule=geronimo/j2ee-server/1.0/car,J2EEServer=geronimo,j2eeType=TransactionManager,import org.apache.geronimo.gbean.AbstractName;
import org.apache.geronimo.gbean.AbstractNameQuery;
import org.apache.geronimo.kernel.Kernel;
import org.apache.geronimo.kernel.KernelRegistry;
import org.apache.geronimo.kernel.proxy.ProxyManager;

public class GeronimoTransactionManagerLookup implements
        TransactionManagerLookup  name=TransactionManager";
{

    public static final String UserTransactionName = "java:comp/UserTransaction";

    public TransactionManager getTransactionManager(Properties props) throws HibernateException {
   try {    /*
         Class kernelClass* try { Kernel kernel = ClassKernelRegistry.forName("org.apache.geronimo.kernel.Kernel");getSingleKernel(); ProxyManager
         Class* kernelRegistryClassproxyManager = Classkernel.forName("org.apache.geronimo.kernel.KernelRegistry");getProxyManager(); AbstractNameQuery query =
         Class* proxyManagerClass = Class.forName("org.apache.geronimo.kernel.proxy.ProxyManager");new AbstractNameQuery(TransactionManager.class.getName()); Set names =
         ObjectName TransactionManagerName = new ObjectName(TransactionMgrGBeanName);
  * kernel.listGBeans(query); AbstractName name = null; for (Iterator it =
       Object kernel =* kernelRegistryClassnames.getMethod("getSingleKernel", null).invoke(null, null);
iterator(); it.hasNext();) name = (AbstractName) it.next();
         * Object proxyManagertransMg = kernelClass.getMethod("getProxyManager",null).invoke(kernel,null);(Object) proxyManager.createProxy(name,
         Class[] clzArray = {ObjectName.class,Class.class};* TransactionManager.class); return (TransactionManager)transMg; }catch
         Object[] objArray =* (Exception e) {TransactionManagerName, TransactionManager.class};
   e.printStackTrace(); System.out.println(); throw new
      return (TransactionManager)proxyManagerClass.getMethod("createProxy",clzArray).
  * HibernateException("Geronimo Transaction Manager        invoke(proxyManagerLookup Failed", objArraye); }

       }catch (Exception e) { */
       try {
   throw new HibernateException("Geronimo Transaction ManagerKernel Lookupkernel Failed", e= KernelRegistry.getSingleKernel();
       }
}

AbstractNameQuery query = public String getUserTransactionName() {new AbstractNameQuery(TransactionManager.class.getName ());
       returnSet<AbstractName> UserTransactionName;
names   }
}
= kernel.listGBeans(query);
       if (names.size() != 1) {
           throw new IllegalStateException("Expected one transaction manager, not " + names.size());
       }
       AbstractName name = names.iterator().next();
       TransactionManager transMg = (TransactionManager)
       kernel.getGBean(name);
       return (TransactionManager)transMg;
       } catch (Exception e) {
           e.printStackTrace();
           System.out.println();
           throw new HibernateException("Geronimo Transaction Manager Lookup Failed", e);
       }
   }

    public String getUserTransactionName() {
        return UserTransactionName;
    }
}