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.at;
 
 
 
 
This class is a plug-in module for the recovery manager. It is responsible for recovering failed XTS AT subordinate (SubordinateCoordinator) transactions. (instances of com.arjuna.mwlabs.wscf.model.twophase.arjunacore.subordinate.SubordinateCoordinator) $Id$
 
 {
     {
         if (..isDebugEnabled()) {
             ..debug("SubordinateATCoordinatorRecoveryModule 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()
     {
         // nothing to do here as we share the implementations used by the ACCoordinatorRecoveryModule
     }

    
module list in order to allow the implementations list to be purged of this module's implementations
 
     public void uninstall()
     {
         // nothing to do here as we share the implementations used by the ACCoordinatorRecoveryModule
     }

    
This is called periodically by the RecoveryManager
 
     public void periodicWorkFirstPass()
     {
         // Transaction type
         boolean SubordinateCoordinators = false ;
 
         // uids per transaction type
         InputObjectState acc_uids = new InputObjectState() ;
 
         try
         {
             if (..isDebugEnabled()) {
                 ..debug("StatusModule: first pass ");
             }
 
            SubordinateCoordinators = .allObjUidsacc_uids );
        }
        catch ( ObjectStoreException ex )
        {
        }
        if ( SubordinateCoordinators )
        {
             = processTransactionsacc_uids ) ;
        }
    }
    public void periodicWorkSecondPass()
    {
        if (..isDebugEnabled()) {
            ..debug("SubordinateATCoordinatorRecoveryModule: Second pass ");
        }
        if ( != null) {
            processTransactionsStatus() ;
        }
        // ok notify the coordinator processor that recovery processing has completed
    }
    {
        if (..isDebugEnabled()) {
            ..debug("SubordinateATCoordinatorRecoveryModule created " + type);
        }
        if ( == null)
        {
             = StoreManager.getRecoveryStore();
        }
         = type;
    }
    private void doRecoverTransactionUid recoverUid )
    {
        boolean commitThisTransaction = true ;
        // if the subordinate transaction has already been recovered and has not committed
        // then we don't create a new one
        if (SubordinateATCoordinator.getRecoveredCoordinator(recoverUid.stringForm()) != null) {
            return;
        }
        // if there is no entry and there is still a log entry then we need to create a new coordinator
        
        // Retrieve the transaction status from its original process.
        // n.b. for a non-active XTS TX this status will 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);
                RecoverySubordinateATCoordinator rcvSubordinateCoordinator =
                        new RecoverySubordinateATCoordinator(recoverUid);
                rcvSubordinateCoordinator.replayPhase2();
            }
            catch ( Exception ex )
            {
            }
        }
    }
    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");
        }
        final Uid NULL_UID = Uid.nullUid();
        Uid theUid = null;
        while (true)
        {
            try
            {
                theUid = UidHelper.unpackFromuids ) ;
            }
            catch ( Exception ex )
            {
                break;
            }
            if (theUid.equals(NULL_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 )
            {
            }
        }
        XTSATRecoveryManager.getRecoveryManager().setSubordinateCoordinatorRecoveryStarted();
    }
    // 'type' within the Object Store for ACCoordinator.
    // 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