1 45 package org.openejb.ri.sp; 46 47 import java.util.Enumeration ; 48 import java.util.Hashtable ; 49 import java.util.Vector ; 50 import javax.transaction.Status ; 51 import javax.transaction.Synchronization ; 52 import javax.transaction.Synchronization ; 53 import javax.transaction.Transaction ; 54 import javax.transaction.TransactionManager ; 55 import javax.transaction.RollbackException ; 56 import javax.transaction.UserTransaction ; 57 import javax.transaction.xa.XAResource ; 58 import org.openejb.spi.TransactionService; 59 60 public class PseudoTransactionService implements TransactionService { 61 TransactionManager txm = new MyTransactionManager(); 62 Hashtable map = new Hashtable (); 63 64 public void init(java.util.Properties props ) { 65 props = props; 66 } 67 68 public TransactionManager getTransactionManager( ){ 69 return txm; 70 } 71 public class MyTransactionManager implements TransactionManager { 72 public UserTransaction getUserTransaction(Object txID){ 73 return new UserTransaction ( ){ 74 public void begin() {MyTransactionManager.this.begin();} 75 public void commit() throws RollbackException {MyTransactionManager.this.commit();} 76 public int getStatus()throws javax.transaction.SystemException { 77 return MyTransactionManager.this.getStatus(); 78 } 79 public void rollback() {MyTransactionManager.this.rollback();} 80 public void setRollbackOnly() {MyTransactionManager.this.setRollbackOnly();} 81 public void setTransactionTimeout(int seconds) {MyTransactionManager.this.setTransactionTimeout(seconds);} 82 }; 83 } 84 public void begin( ){ 85 Transaction tx = new MyTransaction( ); 86 map.put(Thread.currentThread(), tx); 87 } 88 public void commit() throws RollbackException { 89 MyTransaction tx = (MyTransaction)map.remove(Thread.currentThread()); 90 if(tx!=null) 91 tx.commit(); 92 else 93 throw new IllegalStateException (); 94 } 95 public int getStatus()throws javax.transaction.SystemException { 96 Transaction tx = (Transaction )map.get(Thread.currentThread()); 97 if(tx==null)return Status.STATUS_NO_TRANSACTION; 98 return tx.getStatus(); 99 } 100 public Transaction getTransaction( ){ 101 return (Transaction )map.get(Thread.currentThread()); 102 } 103 public void resume(Transaction tx) 104 throws javax.transaction.SystemException , javax.transaction.InvalidTransactionException { 105 Transaction ctx = (Transaction )map.get(Thread.currentThread()); 106 int status = tx.getStatus(); 107 if(ctx!= null || tx == null || (status != Status.STATUS_ACTIVE && status != Status.STATUS_MARKED_ROLLBACK)) 109 throw new javax.transaction.InvalidTransactionException (); 110 map.put(Thread.currentThread(),tx); 111 } 112 public Transaction suspend( ){ 113 return (Transaction )map.remove(Thread.currentThread()); 114 } 115 public void rollback(){ 116 MyTransaction tx = (MyTransaction)map.remove(Thread.currentThread()); 117 if(tx==null) throw new IllegalStateException (); 118 tx.rollback(); 119 } 120 public void setRollbackOnly( ){ 121 MyTransaction tx = (MyTransaction)map.get(Thread.currentThread()); 122 if(tx==null) throw new IllegalStateException (); 123 tx.setRollbackOnly(); 124 } 125 public void setTransactionTimeout(int x){} 126 127 } 128 public class MyTransaction implements Transaction { 129 Vector registeredSynchronizations = new Vector (); 130 Vector xaResources = new Vector (); 131 int status = Status.STATUS_ACTIVE; 132 public void commit() throws RollbackException { 133 if ( status == Status.STATUS_MARKED_ROLLBACK ) { 134 rollback(); 135 throw new RollbackException (); 136 } 137 doBeforeCompletion(); 138 doXAResources(Status.STATUS_COMMITTED); 139 status = Status.STATUS_COMMITTED; 140 doAfterCompletion(Status.STATUS_COMMITTED); 141 registeredSynchronizations = new Vector (); 142 map.remove(Thread.currentThread()); 143 } 144 public boolean delistResource(XAResource xaRes, int flag) { 145 xaResources.remove(xaRes); return true; 146 } 147 public boolean enlistResource(XAResource xaRes){ 148 xaResources.addElement(xaRes);return true; 149 } 150 public int getStatus() {return status;} 151 152 public void registerSynchronization(Synchronization sync){ 153 registeredSynchronizations.addElement(sync); 154 } 155 public void rollback() { 156 doXAResources(Status.STATUS_ROLLEDBACK); 157 doAfterCompletion(Status.STATUS_ROLLEDBACK); 158 status = Status.STATUS_ROLLEDBACK; 159 registeredSynchronizations = new Vector (); 160 map.remove(Thread.currentThread()); 161 } 162 public void setRollbackOnly() {status = Status.STATUS_MARKED_ROLLBACK;} 163 164 private void doBeforeCompletion(){ 166 Enumeration enumeration = registeredSynchronizations.elements(); 167 while(enumeration.hasMoreElements()){ 168 try{ 169 Synchronization sync = (Synchronization )enumeration.nextElement(); 170 sync.beforeCompletion(); 171 }catch(RuntimeException re){ 172 re.printStackTrace(); 173 } 174 } 175 } 176 private void doAfterCompletion(int status){ 177 Enumeration enumeration = registeredSynchronizations.elements(); 178 while(enumeration.hasMoreElements()){ 179 try{ 180 Synchronization sync = (Synchronization )enumeration.nextElement(); 181 sync.afterCompletion(status); 182 }catch(RuntimeException re){ 183 re.printStackTrace(); 184 } 185 } 186 } 187 188 private void doXAResources(int status){ 189 Object [] resources = xaResources.toArray(); 190 for(int i = 0; i < resources.length; i++){ 191 XAResource xaRes = (XAResource )resources[i]; 192 if(status == Status.STATUS_COMMITTED){ 193 try{ 194 xaRes.commit(null,true); 195 }catch(javax.transaction.xa.XAException xae){ 196 } 198 try{ 199 xaRes.end(null,XAResource.TMSUCCESS); 200 }catch(javax.transaction.xa.XAException xae){ 201 } 203 }else{ 204 try{ 205 xaRes.rollback(null); 206 }catch(javax.transaction.xa.XAException xae){ 207 } 209 try{ 210 xaRes.end(null,XAResource.TMFAIL); 211 }catch(javax.transaction.xa.XAException xae){ 212 } 214 } 215 } 216 xaResources = new Vector (); 217 218 } 219 220 } 221 222 } 223 | Popular Tags |