001: /**
002: * EasyBeans
003: * Copyright (C) 2006 Bull S.A.S.
004: * Contact: easybeans@ow2.org
005: *
006: * This library is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation; either
009: * version 2.1 of the License, or any later version.
010: *
011: * This library is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: *
016: * You should have received a copy of the GNU Lesser General Public
017: * License along with this library; if not, write to the Free Software
018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
019: * USA
020: *
021: * --------------------------------------------------------------------------
022: * $Id: SLSBBeanManagedTransaction.java 1970 2007-10-16 11:49:25Z benoitf $
023: * --------------------------------------------------------------------------
024: */package org.ow2.easybeans.tests.common.ejbs.stateless.beanmanaged.transaction;
025:
026: import java.sql.SQLException;
027:
028: import javax.ejb.EJBContext;
029: import javax.ejb.Remote;
030: import javax.ejb.Stateless;
031: import javax.ejb.TransactionManagement;
032: import javax.ejb.TransactionManagementType;
033: import javax.naming.NamingException;
034: import javax.transaction.HeuristicMixedException;
035: import javax.transaction.HeuristicRollbackException;
036: import javax.transaction.NotSupportedException;
037: import javax.transaction.RollbackException;
038: import javax.transaction.SystemException;
039: import javax.transaction.UserTransaction;
040:
041: import org.ow2.easybeans.tests.common.db.TableManager;
042: import org.ow2.easybeans.tests.common.exception.TransactionException;
043: import org.ow2.easybeans.tests.common.helper.EJBContextHelper;
044: import org.ow2.easybeans.tests.common.helper.TransactionHelper;
045:
046: /**
047: * Inserts the table test in the database using the UserTransaction. This class
048: * has many methods with differents combinations of begin/commit.
049: * @author Gisele Pinheiro Souza
050: * @author Eduardo Studzinski Estima de Castro
051: */
052: @Stateless(name="SLSBBeanManagedTransaction")
053: @Remote(ItfBeanManagedTransaction.class)
054: @TransactionManagement(value=TransactionManagementType.BEAN)
055: public class SLSBBeanManagedTransaction implements
056: ItfBeanManagedTransaction {
057:
058: /**
059: * Deletes the table and makes an UserTransaction.begin() before create the
060: * table and an UserTransaction.commit() after create.
061: * @param callOnlyTransaction says if the table must be created or only the
062: * UserTransaction.begin() and UserTransaction.commit() must be
063: * called.
064: * @param dbName database where the table must be inserted.
065: * @throws SQLException if a database error occurs.
066: * @throws NamingException if a lookup error occurs.
067: * @throws SystemException if an unexpected error occurs.
068: * @throws NotSupportedException if the resquest cannot be made.
069: * @throws HeuristicRollbackException if a heuristic decision was made and
070: * some relevant update was rolled back.
071: * @throws RollbackException if the transaction was rolled back instead of
072: * committed.
073: * @throws HeuristicMixedException if a heuristic decision was made and some
074: * relevant update was commited and others rolled back.
075: * @throws TransactionException if a rollback was made.
076: */
077: public void deleteTableWithBeginCommit(
078: final boolean callOnlyTransaction, final String dbName)
079: throws SQLException, NamingException, SystemException,
080: NotSupportedException, HeuristicRollbackException,
081: RollbackException, HeuristicMixedException,
082: TransactionException {
083: UserTransaction utx = TransactionHelper.getUserTransaction();
084: utx.begin();
085: try {
086: if (!callOnlyTransaction) {
087: TableManager tableManager = new TableManager(dbName);
088: tableManager.deleteTable(TABLE);
089: }
090: utx.commit();
091: } catch (Exception e) {
092: utx.rollback();
093: throw new TransactionException("Error during commit.", e);
094: }
095:
096: }
097:
098: /**
099: * Deletes the table and makes an UserTransaction.commit() after create.
100: * @param callOnlyTransaction says if the table must be created or only the
101: * UserTransaction.begin() and UserTransaction.commit() must be
102: * called.
103: * @param dbName database where the table must be inserted.
104: * @throws SQLException if a database error occurs.
105: * @throws NamingException if a lookup error occurs.
106: * @throws SystemException if an unexpected error occurs.
107: * @throws NotSupportedException if the resquest cannot be made.
108: * @throws HeuristicRollbackException if a heuristic decision was made and
109: * some relevant update was rolled back.
110: * @throws RollbackException if the transaction was rolled back instead of
111: * committed.
112: * @throws HeuristicMixedException if a heuristic decision was made and some
113: * relevant update was commited and others rolled back.
114: */
115: public void deleteTableWithoutBegin(
116: final boolean callOnlyTransaction, final String dbName)
117: throws SQLException, NamingException, SystemException,
118: NotSupportedException, HeuristicRollbackException,
119: RollbackException, HeuristicMixedException {
120: UserTransaction utx = TransactionHelper.getUserTransaction();
121: if (!callOnlyTransaction) {
122: TableManager tableManager = new TableManager(dbName);
123: tableManager.deleteTable(TABLE);
124: }
125: utx.commit();
126:
127: }
128:
129: /**
130: * Calls userTransaction.begin(), inserts the table and calls userTransaction.commit().
131: * @param callOnlyTransaction says if the table must be created or only the
132: * UserTransaction.begin() and UserTransaction.commit() must be
133: * called.
134: * @param dbName database where the table must be inserted.
135: * @throws SQLException if a database error occurs.
136: * @throws NamingException if a lookup error occurs.
137: * @throws SystemException if an unexpected error occurs.
138: * @throws NotSupportedException if the resquest cannot be made.
139: * @throws HeuristicRollbackException if a heuristic decision was made and
140: * some relevant update was rolled back.
141: * @throws RollbackException if the transaction was rolled back instead of
142: * committed.
143: * @throws HeuristicMixedException if a heuristic decision was made and some
144: * relevant update was commited and others rolled back.
145: * @throws TransactionException if a rollback was made.
146: */
147: public void insertTableWithBeginCommit(
148: final boolean callOnlyTransaction, final String dbName)
149: throws SQLException, NamingException, SystemException,
150: NotSupportedException, HeuristicRollbackException,
151: RollbackException, HeuristicMixedException,
152: TransactionException {
153: UserTransaction utx = TransactionHelper.getUserTransaction();
154: utx.begin();
155: try {
156: if (!callOnlyTransaction) {
157: TableManager tableManager = new TableManager(dbName);
158: tableManager.insertTable(TABLE);
159: }
160: utx.commit();
161: } catch (Exception e) {
162: utx.rollback();
163: throw new TransactionException("Error during commit.", e);
164: }
165:
166: }
167:
168: /**
169: * Inserts the table and makes an UserTransaction.begin() before create the
170: * table.
171: * @param callOnlyTransaction says if the table must be created or only the
172: * UserTransaction.begin() and UserTransaction.commit() must be
173: * called.
174: * @param dbName database where the table must be inserted.
175: * @throws SQLException if a database error occurs.
176: * @throws NamingException if a lookup error occurs.
177: * @throws SystemException if an unexpected error occurs.
178: * @throws NotSupportedException if the resquest cannot be made.
179: */
180: public void insertTableWithoutCommit(
181: final boolean callOnlyTransaction, final String dbName)
182: throws SQLException, NamingException, SystemException,
183: NotSupportedException {
184: UserTransaction utx = TransactionHelper.getUserTransaction();
185: utx.begin();
186: if (!callOnlyTransaction) {
187: TableManager tableManager = new TableManager(dbName);
188: tableManager.insertTable(TABLE);
189: }
190: }
191:
192: /**
193: * Makes a setRollbackOnly that must to throw en exception.
194: * @throws NamingException if a lookup error occurs.
195: * @throws IllegalStateException if the bean try to call the setRollBackOnly
196: */
197: public void setRollbackOnly() throws NamingException,
198: IllegalStateException {
199: EJBContext ejbContext = EJBContextHelper.getEJBContext();
200: ejbContext.setRollbackOnly();
201: }
202:
203: /**
204: * Makes a getRollbackOnly that must to throw en exception.
205: * @throws NamingException if a lookup error occurs.
206: * @throws IllegalStateException if the bean try to call the getRollBackOnly
207: */
208: public void getRollbackOnly() throws NamingException,
209: IllegalStateException {
210: EJBContext ejbContext = EJBContextHelper.getEJBContext();
211: ejbContext.getRollbackOnly();
212: }
213:
214: }
|