Développement de composants client eXtreme Scale en vue d'utiliser des transactions

    // (C) Copyright IBM Corp. 2001, 2012.
    // All Rights Reserved. Eléments sous licence - Propriété d'IBM.
    package com.ibm.ws.xs.ra.test.ee;
     
    import javax.naming.InitialContext;
    import javax.resource.cci.Connection;
    import javax.resource.cci.ConnectionFactory;
    import javax.resource.cci.LocalTransaction;
    import javax.transaction.Status;
    import javax.transaction.UserTransaction;
     
    import junit.framework.TestCase;
     
    import com.ibm.websphere.objectgrid.ObjectMap;
    import com.ibm.websphere.objectgrid.Session;
    import com.ibm.websphere.xs.ra.XSConnection;
     
    /**
    * Cet exemple doit être exécuté dans un contexte J2EE sur votre serveur
    * d'applications. Par exemple, en utilisant le servlet d'infrastructure préfabriquée JUnitEE.
    *
    * Le code présent dans ces méthodes de texte réside généralement sur votre propre servlet,
    * sur votre EJB ou sur un autre composant Web.
    *
    * L'exemple dépend d'une fabrique de connexions WebSphere eXtreme Scale configurée
    * enregistrée sous le nom JNDI de "eis/embedded/wxscf" qui définit une
    * connexion à une grille contenant une mappe portant le nom "Map1".
    *
    * Cet exemple effectue une recherche directe du nom JNDI et ne nécessite pas une
    * injection de ressource.
    */
    public class DocSampleTests extends TestCase {
        public final static String CF_JNDI_NAME = "eis/embedded/wxscf";
        public final static String MAP_NAME = "Map1";
       
        Long                key = null;
        Long                value = null;
        InitialContext      ctx = null;
        ConnectionFactory   cf = null;
       
        public DocSampleTests() {
        }
        public DocSampleTests(String name) {
            super(name);
        }
        protected void setUp() throws Exception {
            ctx = new InitialContext();
            cf = (ConnectionFactory)ctx.lookup(CF_JNDI_NAME);
            key = System.nanoTime();
            value = System.nanoTime();
        }
        /**
         * Cette exemple s'exécute lorsqu'il n'est pas dans le contexte d'une transaction globale
         * et utilise la validation automatique (autocommit).
         */
        public void testLocalAutocommit() throws Exception {
            Connection conn = cf.getConnection();
            try {
                Session    session = ((XSConnection)conn).getSession();
                ObjectMap  map = session.getMap(MAP_NAME);
                map.insert(key, value); // Or various data access operations
            }
            finally {
                conn.close();
            }
        }
     
        /**
         * Cette exemple s'exécute lorsqu'il n'est pas dans le contexte d'une transaction globale
         * et démarque la transaction à l'aide de session.begin()/session.commit()
         */
        public void testLocalSessionTransaction() throws Exception {
            Session    session = null;
            Connection conn = cf.getConnection();
            try {
                session = ((XSConnection)conn).getSession();
                session.begin();
                ObjectMap  map = session.getMap(MAP_NAME);
                map.insert(key, value); // Or various data access operations
                session.commit();
            }
            finally {
                if (session != null && session.isTransactionActive()) {
                    try { session.rollback(); }
                    catch (Exception e) { e.printStackTrace(); }
                }
                conn.close();
            }
        }
       
        /**
         * Cet exemple utilise l'interface LocalTransaction pour démarquer les
         * transactions.
         */
        public void testLocalTranTransaction() throws Exception {
            LocalTransaction tx = null;
            Connection conn = cf.getConnection();
            try {
                tx = conn.getLocalTransaction();
                tx.begin();
                Session    session = ((XSConnection)conn).getSession();
                ObjectMap  map = session.getMap(MAP_NAME);
                map.insert(key, value); // Or various data access operations
                tx.commit(); tx = null;
            }
            finally {
                if (tx != null) {
                    try { tx.rollback(); }
                    catch (Exception e) { e.printStackTrace(); }
                }
                conn.close();
            }
        }
       
        /**
         * Cet exemple dépend d'une transaction à gestion externe.
         * Cette transaction à gestion externe peut généralement être présente dans
         * un EJB avec des attributs de transaction définis sur REQUIRED ou REQUIRES_NEW.
         * REMARQUE : S'il n'y a AUCUNE transaction globale active, cet exemple s'exécute en
         *       mode de validation automatique car il ne vérifie pas si une transaction existe.
         */
        public void testGlobalTransactionContainerManaged() throws Exception {
            Connection      conn = cf.getConnection();
            try {
                Session    session = ((XSConnection)conn).getSession();
                ObjectMap  map = session.getMap(MAP_NAME);
                map.insert(key, value); // Or various data access operations
            }
            catch (Throwable t) {
                t.printStackTrace();
                UserTransaction tx = (UserTransaction)ctx.lookup("java:comp/UserTransaction");
                if (tx.getStatus() != Status.STATUS_NO_TRANSACTION) {
                    tx.setRollbackOnly();
                }
            }
            finally {
                conn.close();
            }
        }
       
        /**
         * Cet exemple montre comment démarrer une nouvelle transaction globale à l'aide de
         * l'interface UserTransaction. Généralement, le conteneur démarre la transaction
         * globale (par exemple, dans un EJB avec un attribut de transaction défini sur
         * REQUIRES_NEW), mais cet exemple démarre aussi la transaction globale
         * à l'aide de l'API UserTransaction si elle n'est pas actuellement active.
         */
        public void testGlobalTransactionTestManaged() throws Exception {
            boolean         started = false;
            UserTransaction tx = (UserTransaction)ctx.lookup("java:comp/UserTransaction");
            if (tx.getStatus() == Status.STATUS_NO_TRANSACTION) {
                tx.begin();
                started = true;
            }
            // else { called with an externally/container managed transaction }
            Connection conn = null;
            try {
                conn = cf.getConnection(); // Get connection after the global tran starts
                Session    session = ((XSConnection)conn).getSession();
                ObjectMap  map = session.getMap(MAP_NAME);
                map.insert(key, value); // Or various data access operations
                if (started) {
                    tx.commit(); started = false; tx = null;
                }
            }
            finally {
                if (started) {
                    try { tx.rollback(); }
                    catch (Exception e) { e.printStackTrace(); }
                }
                if (conn != null) { conn.close(); }   
            }
        }
 /**
         /**
         * Cet exemple montre un transaction multipartition.
         */				
			
				public void testGlobalTransactionTestManagedMultiPartition() throws Exception {
						boolean         started = false;
						XSConnectionSpec connSpec = new XSConnectionSpec();
						connSpec.setWriteToMultiplePartitions(true);
						UserTransaction tx = (UserTransaction)ctx.lookup("java:comp/UserTransaction");
						if (tx.getStatus() == Status.STATUS_NO_TRANSACTION) {
								tx.begin();
						started = true;
					}
				// else { called with an externally/container managed transaction }
						Connection conn = null;
									try {
						conn = cf.getConnection(connSpec); // Get connection after the global tran starts
						Session    session = ((XSConnection)conn).getSession();
						ObjectMap  map = session.getMap(MAP_NAME);
						map.insert(key, value); // Or various data access operations
						if (started) {
								tx.commit(); started = false; tx = null;
								}
						}
						finally {
							if (started) {
									try { tx.rollback(); }
									catch (Exception e) { e.printStackTrace(); }
							}
							if (conn != null) { conn.close(); }
						}
					}