Java > Open Source Codes > org > objectweb > jotm > SubCoordinator


1 /*
2  * @(#) SubCoordinator.java
3  *
4  * JOTM: Java Open Transaction Manager
5  *
6  *
7  * This module was originally developed by
8  *
9  * - Bull S.A. as part of the JOnAS application server code released in
10  * July 1999 (www.bull.com)
11  *
12  * --------------------------------------------------------------------------
13  * The original code and portions created by Bull SA are
14  * Copyright (c) 1999 BULL SA
15  * All rights reserved.
16  *
17  * Redistribution and use in source and binary forms, with or without
18  * modification, are permitted provided that the following conditions are met:
19  *
20  * -Redistributions of source code must retain the above copyright notice, this
21  * list of conditions and the following disclaimer.
22  *
23  * -Redistributions in binary form must reproduce the above copyright notice,
24  * this list of conditions and the following disclaimer in the documentation
25  * and/or other materials provided with the distribution.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37  * POSSIBILITY OF SUCH DAMAGE.
38  *
39  * --------------------------------------------------------------------------
40  * Contributor(s):
41  * 01/11/06 Christophe Ney cney@batisseurs.com
42  * Added ResourceManagerListener mechanism to remove ThreadData
43  * dependency.
44  *
45  * 02/06/18 Marek Prochazka
46  * In addSynchronization() synchronizations are processed the
47  * same way as resources. We add synchro although transaction is
48  * marked rollback-only to be able to send beforeCompletion
49  *
50  * --------------------------------------------------------------------------
51  * $Id: SubCoordinator.java,v 1.37 2005/05/10 22:50:54 tonyortiz Exp $
52  * --------------------------------------------------------------------------
53  */
54
55 package org.objectweb.jotm;
56
57 import java.rmi.RemoteException ;
58
59 import java.util.List ;
60 import java.util.Vector ;
61 import java.nio.ByteBuffer ;
62 import javax.transaction.*;
63 import javax.transaction.xa.XAException ;
64 import javax.transaction.xa.XAResource ;
65 // import javax.transaction.xa.Xid;
66 import javax.rmi.PortableRemoteObject ;
67
68 import org.objectweb.howl.log.xa.XACommittingTx;
69
70 /**
71  * Log associated to this transaction coordinator
72  */
73 class SLog {
74
75     private Vector loggedResources = new Vector ();
76
77     private Vector loggedXids = new Vector ();
78
79     int decision;
80     static final int DECISION_TO_COMMIT = 1;
81     static final int DECISION_TO_ROLLBACK = 2;
82
83     public void addResource( XAResource res, Xid xid )
84     {
85         if (TraceTm.jta.isDebugEnabled()) {
86             TraceTm.jta.debug("res= "+ res);
87             TraceTm.jta.debug("xid= "+ xid);
88         }
89         loggedResources.addElement(res);
90         loggedXids.addElement(xid);
91     }
92
93     /**
94      * @return a List of logged Resources
95      */
96     public List getLoggedResources() {
97         if (TraceTm.jta.isDebugEnabled()) {
98             TraceTm.jta.debug("logged resources="+ loggedResources);
99         }
100         return loggedResources;
101     }
102
103     public List getLoggedXids() {
104         return loggedXids;
105     }
106
107     public void flushLog(int decide) {
108         if (TraceTm.jta.isDebugEnabled()) {
109             TraceTm.jta.debug("decide="+ decide);
110         }
111         decision = decide;
112
113         // XXX serialize log on disk
114 }
115
116     public void forgetLog() {
117         if (TraceTm.jta.isDebugEnabled()) {
118             TraceTm.jta.debug("forget log");
119         }
120         // XXX remove file on disk
121 }
122 }
123
124 /**
125  * This object is the local coordinator. It may be registered as
126  * sub-coordinator in case of distributed transaction, so it must
127  * be callable remotely and implement Resource
128  */
129 public class SubCoordinator extends PortableRemoteObject implements Resource {
130
131     // ------------------------------------------------------------------
132 // Object state
133 // ------------------------------------------------------------------
134
135     /**
136      * @serial
137      */
138     private TransactionImpl tx = null;
139
140     /**
141      * List of Synchronization objects
142      * @serial
143      */
144     private Vector synchroList = new Vector ();
145
146     /**
147      * List of XAResource objects
148      * @serial
149      */
150     private Vector resourceList = new Vector ();
151     private Vector javaxxidList = new Vector ();
152
153     /**
154      * Keep a reference on TransactionManager
155      * @serial
156      */
157     private TransactionManager tm;
158
159     /**
160      * @serial
161      */
162     private Xid xid = null;
163
164     /**
165      * @serial
166      */
167     private SLog log = null;
168
169     /**
170      * javax.transaction.Status
171      * <dl>
172      * <dt>ACTIVE</dt><dd>transaction started, commit phase not started</dd>
173      * <dt>PREPARING</dt><dd>prepare is being sent to resources</dd>
174      * <dt>PREPARED</dt><dd>prepare is done. Must commit now</dd>
175      * <dt>COMMITTING</dt><dd>commit is being sent to resources</dd>
176      * <dt>COMMITTED</dt><dd>commit was successful</dd>
177      * <dt>ROLLING_BACK</dt><dd>not used</dd>
178      * <dt>MARKED_ROLLBACK</dt><dd>setRollbackOnly has been called</dd>
179      * <dt>ROLLEDBACK</dt>
180      * <dd>transaction has been rolled back (or prepare returned "vote_rollback")</dd>
181      * <dt>UNKNOWN</dt><dd>commit raised heuristics</dd>
182      * <dt>NO_TRANSACTION</dt><dd>cannot get the status value from JTM</dd>
183      * </dl>
184      * @serial
185      */
186     private int status = Status.STATUS_ACTIVE;
187
188     /**
189      * @serial
190      */
191     private boolean beforeCompletionDone = false;
192
193     // ------------------------------------------------------------------
194 // Constructors
195 // ------------------------------------------------------------------
196
197     /**
198      * constructor used by TransactionImpl
199      */
200
201     SubCoordinator(TransactionImpl tx, Xid xid) throws RemoteException {
202
203         if (TraceTm.jta.isDebugEnabled()) {
204             TraceTm.jta.debug("tx="+ tx +", xid="+ xid);
205         }
206         
207         this.tx = tx;
208         this.xid = xid;
209         this.tm = Current.getTransactionManager();
210
211         // increment counter for management
212 Current.getCurrent().incrementBeginCounter();
213         beforeCompletionDone = false;
214     }
215
216     // ------------------------------------------------------------------
217 // Resource interface
218 // ------------------------------------------------------------------
219
220     /**
221      * phase 1 of the 2PC.
222      *
223      * @return int vote commit, rollback, or readonly.
224      */
225
226     public int prepare() throws RemoteException {
227
228         if (TraceTm.jta.isDebugEnabled()) {
229             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
230         }
231         
232         try {
233             tx.doDetach(XAResource.TMSUCCESS);
234         } catch (SystemException e) {
235
236             if (TraceTm.jta.isDebugEnabled()) {
237                 String error =
238                     "Error when detaching XAResource:"
239                     + e
240                     + "--"
241                     + e.getMessage();
242                 TraceTm.jta.debug(error);
243             }
244         }
245
246         switch (status) {
247             case Status.STATUS_MARKED_ROLLBACK :
248                 doBeforeCompletion(false);
249                 doRollback();
250                 return Resource.VOTE_ROLLBACK;
251             case Status.STATUS_COMMITTED :
252                 return Resource.VOTE_COMMIT;
253             default :
254                 doBeforeCompletion(true);
255                 break;
256         }
257
258         // Recheck Status after doBeforeCompletion
259
260         if (status == Status.STATUS_MARKED_ROLLBACK) {
261             TraceTm.jotm.info(
262                 "Rollback during beforeCompletion in SubCoordinator.prepare");
263             doRollback();
264             return Resource.VOTE_ROLLBACK;
265         }
266
267         int ret = doPrepare();
268
269         if (ret == Resource.VOTE_READONLY) {
270             // Transaction completed for this Resource
271 doAfterCompletion();
272         }
273
274         if (TraceTm.jta.isDebugEnabled()) {
275             TraceTm.jta.debug("vote = " + ret);
276         }
277
278         return ret;
279     }
280
281     /**
282      * rollback transaction
283      */
284
285     public void rollback() throws RemoteException {
286
287         if (TraceTm.jta.isDebugEnabled()) {
288             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
289         }
290        
291         try {
292             tx.doDetach(XAResource.TMSUCCESS);
293         } catch (SystemException e) {
294             if (TraceTm.jta.isDebugEnabled()) {
295                 String error =
296                     "Error when detaching XAResource:"
297                     + e
298                     + "--"
299                     + e.getMessage();
300                 TraceTm.jta.debug(error);
301             }
302         }
303
304         switch (status) {
305             case Status.STATUS_ACTIVE :
306             case Status.STATUS_MARKED_ROLLBACK :
307             case Status.STATUS_ROLLING_BACK:
308                 if (TraceTm.jotm.isDebugEnabled()) {
309                     TraceTm.jotm.debug("transaction rolling back");
310                 }
311                 break;
312             case Status.STATUS_PREPARED:
313                 if (TraceTm.jotm.isDebugEnabled()) {
314                     TraceTm.jotm.debug("should not rollback a prepared transaction");
315                 }
316                 break;
317             case Status.STATUS_ROLLEDBACK :
318                 if (TraceTm.jotm.isDebugEnabled()) {
319                     TraceTm.jotm.debug("already rolledback");
320                 }
321                 return;
322             default :
323                 TraceTm.jotm.error(
324                     "rollback: bad status: "
325                         + StatusHelper.getStatusName(status));
326                 return;
327         }
328
329         doBeforeCompletion(false);
330         doRollback();
331     }
332
333     /**
334      * phase 2 of the 2PC.
335      */
336
337     public void commit() throws RemoteException {
338
339         if (TraceTm.jta.isDebugEnabled()) {
340             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
341         }
342
343         switch (status) {
344             case Status.STATUS_PREPARED :
345                 break;
346             default :
347                 TraceTm.jotm.error(
348                     "commit: bad status: "
349                         + StatusHelper.getStatusName(status));
350                 return;
351         }
352
353         doCommit();
354     }
355
356     /**
357      * commit 1 phase. Called either from JTM (distributed transaction) or
358      * from Transaction.commit (local transaction).
359      */
360
361     public void commit_one_phase() throws RemoteException {
362
363         if (TraceTm.jta.isDebugEnabled()) {
364             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
365         }
366
367         switch (status) {
368             case Status.STATUS_ROLLEDBACK :
369                 try {
370                     tx.doDetach(XAResource.TMSUCCESS);
371                 } catch (SystemException e) {
372
373                     if (TraceTm.jta.isDebugEnabled()) {
374                         String error =
375                             "Error when detaching XAResource:"
376                             + e
377                             + "--"
378                             + e.getMessage();
379                         TraceTm.jta.debug(error);
380                     }
381                 }
382                 throw new TransactionRolledbackException();
383             case Status.STATUS_MARKED_ROLLBACK :
384                 doBeforeCompletion(false);
385                 try {
386                     tx.doDetach(XAResource.TMSUCCESS);
387                 } catch (SystemException e) {
388
389                     if (TraceTm.jta.isDebugEnabled()) {
390                         String error =
391                             "Error when detaching XAResource:"
392                             + e
393                             + "--"
394                             + e.getMessage();
395                         TraceTm.jta.debug(error);
396                     }
397                 }
398                 doRollback();
399                 throw new TransactionRolledbackException();
400             case Status.STATUS_COMMITTED :
401                 try {
402                     tx.doDetach(XAResource.TMSUCCESS);
403                 } catch (SystemException e) {
404
405                     if (TraceTm.jta.isDebugEnabled()) {
406                         String error =
407                             "Error when detaching XAResource:"
408                             + e
409                             + "--"
410                             + e.getMessage();
411                         TraceTm.jta.debug(error);
412                     }
413                 }
414                 return;
415             default :
416                 doBeforeCompletion(true);
417                 try {
418                     tx.doDetach(XAResource.TMSUCCESS);
419                 } catch (SystemException e) {
420
421                     if (TraceTm.jta.isDebugEnabled()) {
422                         String error =
423                            "Error when detaching XAResource:"
424                             + e
425                             + "--"
426                             + e.getMessage();
427                         TraceTm.jta.debug(error);
428                     }
429                 }
430                 break;
431         }
432         
433         // status many have changed in doBeforeCompletion
434
435         if (TraceTm.jta.isDebugEnabled()) {
436             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
437         }
438
439         // Recheck Status after doBeforeCompletion
440
441         if (status == Status.STATUS_MARKED_ROLLBACK) {
442             TraceTm.jotm.info(
443                 "Rollback during beforeCompletion in SubCoordinator.commit_one_phase");
444             doRollback();
445             throw new TransactionRolledbackException();
446         }
447
448         // only 1 Resource => 1 phase commit
449
450         if (resourceList.size() == 1) {
451             doOnePhaseCommit();
452             return;
453         }
454
455         // 2 phase commit
456
457         int vote = doPrepare();
458
459         switch (vote) {
460             case Resource.VOTE_COMMIT :
461                 doCommit();
462                 break;
463             case Resource.VOTE_READONLY :
464                 doAfterCompletion();
465                 break;
466             case Resource.VOTE_ROLLBACK :
467                 doRollback();
468                 throw new TransactionRolledbackException();
469         }
470     }
471
472     /**
473      * forget heuristics about this transaction.
474      */
475
476     public void forget() throws RemoteException {
477         if (TraceTm.jta.isDebugEnabled()) {
478             TraceTm.jta.debug("SubCoordinator.forget()");
479         }
480         doForget();
481     }
482
483     // ------------------------------------------------------------------
484 // Other public methods (interface exposed to Transaction object)
485 // ------------------------------------------------------------------
486
487     /**
488      * add a Synchronization to the list
489      *
490      * @param synchro The javax.transaction.Synchronization object for the
491      * transaction associated with the target object
492      *
493      * @exception RollbackException Thrown to indicate that
494      * the transaction has been marked for rollback only.
495      *
496      * @exception IllegalStateException Thrown if the transaction in the
497      * target object is in prepared state or the transaction is inactive.
498      *
499      */
500
501     public void addSynchronization(Synchronization synchro)
502         throws RollbackException, IllegalStateException {
503
504         if (TraceTm.jta.isDebugEnabled()) {
505             TraceTm.jta.debug("synchro="+ synchro);
506             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
507         }
508
509         // check status: should be ACTIVE.
510
511         boolean markedRollback = false;
512
513         switch (status) {
514             case Status.STATUS_MARKED_ROLLBACK :
515             case Status.STATUS_ROLLEDBACK :
516                 markedRollback = true;
517                 break;
518             case Status.STATUS_ACTIVE :
519                 break;
520             default :
521                 String errorMsg =
522                     "addSynchronization: bad status = "
523                         + StatusHelper.getStatusName(status);
524                 TraceTm.jotm.error(errorMsg);
525                 throw new IllegalStateException (errorMsg);
526         }
527
528         // Add synchro to the list of local synchros
529
530         synchroList.addElement(synchro);
531
532         // If transaction marked rollback only, we add synchro but we throw
533 // the correct exception because nobody can presume what will be done in the
534 // Synchronization object, so we must send it beforeCompletion and afterCompletion
535 // even in case of rollback.
536
537         if (markedRollback) {
538             if (TraceTm.jta.isDebugEnabled()) {
539             TraceTm.jta.debug("SubCoordinator.addSynchronization: transaction rollback only");
540             }
541             throw new RollbackException();
542         }
543
544     }
545
546     /**
547      * add a XAResource to the list
548      *
549      * @param xares XAResource to register
550      *
551      * @return true if this datasource was already known
552      *
553      * @exception IllegalStateException Thrown if the transaction in the
554      * target object is in prepared state or the transaction is inactive.
555      */
556
557     public synchronized boolean addResource(XAResource xares)
558         throws IllegalStateException {
559
560         if (TraceTm.jta.isDebugEnabled()) {
561             TraceTm.jta.debug("xares="+ xares);
562             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
563         }
564
565         // check status: should be ACTIVE.
566
567         boolean markedRollback = false;
568
569         switch (status) {
570             case Status.STATUS_MARKED_ROLLBACK :
571                 markedRollback = true;
572                 break;
573             case Status.STATUS_ACTIVE :
574                 break;
575             default :
576                 String errorMsg =
577                     "SubCoordinator.addResource: bad status= "
578                         + StatusHelper.getStatusName(status);
579                 TraceTm.jotm.error(errorMsg);
580                 throw new IllegalStateException (errorMsg);
581         }
582
583         // Check if this DataSource is already known
584 // -> we must register only ONE resource per DataSource.
585
586         boolean found = false;
587
588         for (int i = 0; i < resourceList.size(); i++) {
589             XAResource res = (XAResource ) resourceList.elementAt(i);
590
591             try {
592                 if (res.isSameRM(xares)) {
593                     found = true;
594                     break;
595                 }
596             } catch (XAException e) {
597                 String error =
598                 "Cannot send res.isSameRM:"
599                     + e
600                     + " (error code = "
601                     + e.errorCode
602                     + ") --"
603                     + e.getMessage();
604                 TraceTm.jotm.error(
605                     "Exception on resource.isSameRM: "+ error);
606             }
607         }
608
609         // add this XAResource to the list
610
611         if (found == false) {
612             if (TraceTm.jta.isDebugEnabled()) {
613                 TraceTm.jta.debug("new XAResource added to the list");
614             }
615             resourceList.addElement(xares);
616         }
617
618         // If transaction marked rollback only, we enlist resource but we throw
619 // the correct exception. It is important to enlist the Resource because
620 // if we don't, the database would be updated although transaction has been
621 // rolled back.
622
623         if (markedRollback) {
624             if (TraceTm.jta.isDebugEnabled()) {
625             TraceTm.jta.debug("SubCoordinator.addResource: transaction set rollback only");
626             }
627         }
628
629         return found;
630     }
631
632     public synchronized void addJavaxXid(javax.transaction.xa.Xid javaxxid) {
633
634         if (TraceTm.jta.isDebugEnabled()) {
635             TraceTm.jta.debug("addJavaxXid javaxxid="+ javaxxid);
636         }
637
638         // add this javaxxid to the List at the index location of XAResource
639
640         javaxxidList.addElement(javaxxid);
641         
642         if (TraceTm.jta.isDebugEnabled()) {
643             TraceTm.jta.debug("new JavaxXid added to the list");
644         }
645
646     }
647
648     /**
649      * return the status of this transaction
650      */
651
652     public int getStatus() {
653
654         if (TraceTm.jta.isDebugEnabled()) {
655             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
656         }
657
658         return status;
659     }
660
661     public javax.transaction.xa.Xid getJavaxXid(int xaresindex) {
662         javax.transaction.xa.Xid myjavaxxid = (javax.transaction.xa.Xid ) javaxxidList.elementAt(xaresindex);
663         return myjavaxxid;
664     }
665     
666     /**
667      * set the transaction "rollback only"
668      */
669
670     public void setRollbackOnly() {
671
672         if (TraceTm.jta.isDebugEnabled()) {
673             TraceTm.jta.debug("status="+ StatusHelper.getStatusName(status));
674         }
675
676         switch (status) {
677             case Status.STATUS_ACTIVE :
678             case Status.STATUS_UNKNOWN :
679             case Status.STATUS_PREPARING :
680                 status = Status.STATUS_MARKED_ROLLBACK;
681                 break;
682             case Status.STATUS_MARKED_ROLLBACK :
683             case Status.STATUS_ROLLING_BACK :
684                 break;
685             case Status.STATUS_PREPARED :
686             case Status.STATUS_COMMITTED :
687             case Status.STATUS_ROLLEDBACK :
688             case Status.STATUS_NO_TRANSACTION :
689             case Status.STATUS_COMMITTING :
690                 TraceTm.jotm.error("Cannot set transaction as rollback only");
691                 TraceTm.jotm.error("Bad status="+ StatusHelper.getStatusName(status));
692                 break;
693         }
694     }
695
696     // ------------------------------------------------------------------
697 // private methods
698 // ------------------------------------------------------------------
699
700     /**
701      * forget Transaction
702      */
703
704     private void doForget() throws RemoteException {
705         if (TraceTm.jta.isDebugEnabled()) {
706             TraceTm.jta.debug("SubCoordinator.doForget()");
707         }
708
709         boolean exception = false;
710
711         for (int i = 0; i < resourceList.size(); i++) {
712             // Tell this Resource to forget the transaction
713 // Remove from the list ?
714 XAResource xar = (XAResource ) resourceList.elementAt(i);
715             
716             javax.transaction.xa.Xid myjavaxxid = (javax.transaction.xa.Xid )javaxxidList.elementAt(i);
717             Xid xid = new XidImpl( this.xid, i );
718
719             if (TraceTm.jta.isDebugEnabled()) {
720                 TraceTm.jta.debug("xid= " + xid);
721                 TraceTm.jta.debug("myjavaxxid= " + myjavaxxid);
722                 TraceTm.jta.debug("forgotten with resource= " + xar);
723             }
724
725             try {
726                 xar.forget(myjavaxxid);
727                 // xar.forget(xid);
728 } catch (XAException e) {
729                 String error =
730                 "Cannot send xar.forget:"
731                     + e
732                     + " (error code = "
733                     + e.errorCode
734                     + ") --"
735                     + e.getMessage();
736                 TraceTm.jotm.error(
737                     "Got XAException from xar.forget: "+ error);
738                 exception = true;
739             }
740         }
741
742         if (exception) {
743             throw new RemoteException ("XAException on forget");
744         }
745
746         unexportObject(this);
747     }
748
749     /**
750      * 2PC phase 1 (prepare)
751      * Basically, send prepare on each XAResource and
752      * collect the results.
753      */
754
755     private synchronized int doPrepare() throws RemoteException {
756         if (TraceTm.jta.isDebugEnabled()) {
757             TraceTm.jta.debug("SubCoordinator.doPrepare()");
758         }
759
760         String jotmPrepareRecord = "PREPARE";
761
762         int ret = VOTE_READONLY;
763         int errors = 0;
764
765         // No resource
766
767         if (resourceList.size() == 0) {
768             // increment counter for management
769 Current.getCurrent().incrementCommitCounter();
770             status = Status.STATUS_COMMITTED;
771             return ret;
772         }
773
774         // Creates a log for that transaction, where we will add all the
775 // resources that replied VOTE_COMMIT to prepare.
776 // Do not flush the log on disk before decision to commit.
777
778         log = new SLog();
779
780         // Sends prepare to each resource while no error
781 // In case of prepare on sub-coord. we may have only 1 resource.
782
783         status = Status.STATUS_PREPARING;
784
785         for (int i = 0; i < resourceList.size(); i++) {
786             XAResource res = (XAResource ) resourceList.elementAt(i);
787             javax.transaction.xa.Xid myjavaxxid = (javax.transaction.xa.Xid ) javaxxidList.elementAt(i);
788
789             Xid xid = new XidImpl( this.xid, i );
790
791             if (errors > 0) {
792
793                 if (TraceTm.jta.isDebugEnabled()) {
794                     TraceTm.jta.debug("xid= " + xid);
795                     TraceTm.jta.debug("myjavaxxid= " + myjavaxxid);
796                     TraceTm.jta.debug("rolled back with resource= " + res);
797                 }
798
799                 try {
800                     res.rollback(myjavaxxid);
801                     // res.rollback(xid);
802 } catch (XAException e) {
803                     String error =
804                     "Cannot send res.rollback:"
805                         + e
806                         + " (error code = "
807                         + e.errorCode
808                         + ") --"
809                         + e.getMessage();
810                     TraceTm.jotm.error(
811                         "Got XAException from res.rollback: "+ error);
812                     // Nothing to do ?
813 }
814             } else {
815                 if (TraceTm.jta.isDebugEnabled()) {
816                     TraceTm.jta.debug("xid= " + xid);
817                     TraceTm.jta.debug("myjavaxxid= " + myjavaxxid);
818                     TraceTm.jta.debug("prepared with resource= " + res);
819                 }
820
821                 try {
822                     switch (res.prepare(myjavaxxid)) {
823                     // switch (res.prepare(xid)) {
824 case XAResource.XA_OK :
825                             log.addResource(res,xid);
826                             ret = VOTE_COMMIT;
827                             break;
828                         case XAResource.XA_RDONLY :
829                             break;
830                     }
831                 } catch (XAException e) {
832                     String error =
833                     "Cannot send res.prepare:"
834                         + e
835                         + " (error code = "
836                         + e.errorCode
837                         + ") --"
838                         + e.getMessage();
839                     TraceTm.jotm.error(
840                         "Got XAException from res.prepare: "+ error);
841                     ret = VOTE_ROLLBACK;
842                     errors++;
843                 }
844             }
845         }
846
847         // Update the status, depending on vote result
848 // If all resources returned READ_ONLY, we can forget the transaction
849
850         switch (ret) {
851             case VOTE_READONLY :
852                 // increment counter for management
853 Current.getCurrent().incrementCommitCounter();
854                 status = Status.STATUS_COMMITTED;
855                 break;
856             case VOTE_COMMIT :
857                 status = Status.STATUS_PREPARED;
858                 break;
859             case VOTE_ROLLBACK :
860                 status = Status.STATUS_ROLLING_BACK;
861                 break;
862         }
863
864