Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2007, Red Hat Middleware LLC, and individual contributors
   * as indicated by the @author tags.
   * See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   * This copyrighted material is made available to anyone wishing to use,
   * modify, copy, or redistribute it subject to the terms and conditions
   * of the GNU Lesser General Public License, v. 2.1.
  * This program is distributed in the hope that it will be useful, but WITHOUT A
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
  * You should have received a copy of the GNU Lesser General Public License,
  * v.2.1 along with this distribution; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  * MA  02110-1301, USA.
  *
  * (C) 2007,
  * @author Red Hat Middleware LLC.
  */
 package org.jboss.jbossts.xts.recovery.coordinator.ba;
 
 
 
 
This class is a plug-in module for the recovery manager. It is responsible for recovering failed XTS BA (ACCoordinator) transactions. (instances of com.arjuna.mwlabs.wscf.model..arjunacore.ACCoordinator) $Id$
 
 public class BACoordinatorRecoveryModule implements XTSRecoveryModule
 {
     public BACoordinatorRecoveryModule()
     {
         if (..isDebugEnabled()) {
             ..debug("BACoordinatorRecoveryModule created - default");
         }
 
         if ( == null)
         {
              = StoreManager.getRecoveryStore();
         }
 
     }

    
called by the service startup code before the recovery module is added to the recovery managers module list
 
     public void install()
     {
         // the manager is needed by both the participant or the coordinator recovery modules so whichever
         // one gets there first creates it. No synchronization is needed as modules are only ever
         // installed in a single thread
         XTSBARecoveryManager baRecoveryManager = XTSBARecoveryManager.getRecoveryManager();
         if (baRecoveryManager == null) {
             baRecoveryManager = new XTSBARecoveryManagerImple();
             XTSBARecoveryManager.setRecoveryManager(baRecoveryManager);
         }
         
         Implementations.install();
     }

    
module list in order to allow the implementations list to be purged of this module's implementations
 
     public void uninstall()
     {
         Implementations.uninstall();
     }

    
This is called periodically by the RecoveryManager
 
     public void periodicWorkFirstPass()
     {
         // Transaction type
             boolean ACCoordinators = false ;
        // uids per transaction type
        InputObjectState acc_uids = new InputObjectState() ;
        try
        {
            if (..isDebugEnabled()) {
                ..debug("BACoordinatorRecoveryModule: first pass");
            }
            ACCoordinators = .allObjUidsacc_uids );
        }
        catch ( ObjectStoreException ex )
        {
        }
        if ( ACCoordinators )
        {
             = processTransactionsacc_uids ) ;
        }
    }
    public void periodicWorkSecondPass()
    {
        if (..isDebugEnabled()) {
            ..debug("BACoordinatorRecoveryModule: Second pass");
        }
        if ( != null) {
            processTransactionsStatus() ;
        }
        // ok notify the coordinator processor that recovery processing has completed
    }
    protected BACoordinatorRecoveryModule(String type)
    {
        if (..isDebugEnabled()) {
            ..debug("BACoordinatorRecoveryModule created " + type);
        }
        if ( == null)
        {
             = StoreManager.getRecoveryStore();
        }
         = type;
    }
    private void doRecoverTransactionUid recoverUid )
    {
        boolean commitThisTransaction = true ;
        // Retrieve the transaction status from its original process.
        // n.b. for a non-active XTS TX this status wil l always be committed even
        // if it aborted or had a heuristic outcome. in that case we need to use
        // the logged action status which can only be retrieved after activation
        int theStatus = .getTransactionStatusrecoverUid ) ;
        boolean inFlight = isTransactionInMidFlighttheStatus ) ;
        String Status = ActionStatus.stringFormtheStatus ) ;
        if (..isDebugEnabled()) {
            ..debug("transaction type is " +  + " uid is " +
                    recoverUid.toString() + "\n ActionStatus is " + Status +
                    " in flight is " + inFlight);
        }
        if ( ! inFlight )
        {
            try {
                ..debug("jjh doing revovery here for " + recoverUid);
                // TODO jjh
                RecoveryBACoordinator rcvACCoordinator =
                        new RecoveryBACoordinator(recoverUid);
//                RecoverAtomicAction rcvAtomicAction =
//                        new RecoverAtomicAction( recoverUid, theStatus ) ;
//                rcvAtomicAction.replayPhase2() ;
                rcvACCoordinator.replayPhase2();
            }
            catch ( Exception ex )
            {
                ..warn_coordinator_ba_BACoordinatorRecoveryModule_2(recoverUidex);
            }
        }
    }
    private boolean isTransactionInMidFlightint status )
    {
        boolean inFlight = false ;
        switch ( status )
        {
            // these states can only come from a process that is still alive
            case .    :
            case . :
            case .  :
            case . :
            case .   :
            case .   :
                inFlight = true ;
                break ;
                // the transaction is apparently still there, but has completed its
                // phase2. should be safe to redo it.
            case .  :
            case .   :
            case .    :
            case .   :
            case .    :
            case . :
                inFlight = false ;
                break ;
                // this shouldn't happen
            case . :
            default:
                inFlight = false ;
        }
        return inFlight ;
    }
    private Vector processTransactionsInputObjectState uids )
    {
        Vector uidVector = new Vector() ;
        if (..isDebugEnabled()) {
            ..debug("processing " + 
                    + " transactions");
        }
        Uid NULL_UID = Uid.nullUid();
        Uid theUid = null;
        while (true)
        {
            try
            {
                theUid = UidHelper.unpackFromuids ) ;
            }
            catch ( Exception ex )
            {
                break;
            }
            if (theUid.equalsNULL_UID))
            {
                break;
            }
            if (..isDebugEnabled()) {
                ..debug("found transaction " + theUid);
            }
            uidVector.addElementtheUid ) ;
        }
        
        return uidVector ;
    }
    private void processTransactionsStatus()
    {
        // Process the Vector of transaction Uids
        Enumeration transactionUidEnum = .elements() ;
        while ( transactionUidEnum.hasMoreElements() )
        {
            Uid currentUid = (UidtransactionUidEnum.nextElement();
            try
            {
                if ( .currentStatecurrentUid ) != . )
                {
                    doRecoverTransactioncurrentUid ) ;
                }
            }
            catch ( ObjectStoreException ex )
            {
                ..warn_coordinator_ba_BACoordinatorRecoveryModule_3(currentUidex);
            }
        }
        XTSBARecoveryManager.getRecoveryManager().setCoordinatorRecoveryStarted();
    }
    // 'type' within the Object Store for ACCoordinator.
    private String _transactionType = new BACoordinator().type() ;
    // Array of transactions found in the object store of the
    // ACCoordinator type.
    private Vector _transactionUidVector = null ;
    // Reference to the Object Store.
    private static RecoveryStore _recoveryStore = null ;
    // This object manages the interface to all TransactionStatusManagers
    // processes(JVMs) on this system/node.
New to GrepCode? Check out our FAQ X