/*

    * JBoss, Home of Professional Open Source

    * Copyright 2006, 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) 2005-2006,

   * @author JBoss Inc.

   */

  /*

   * Copyright (C) 1998, 1999, 2000, 2001,

   *

   * Arjuna Solutions Limited,

   * Newcastle upon Tyne,

   * Tyne and Wear,

   * UK.

   *

   * $Id: LockManager.java 2342 2006-03-30 13:06:17Z  $

   */

  package com.arjuna.ats.txoj;

  import java.io.IOException;

  import java.io.PrintWriter;

  import java.util.Enumeration;

  import com.arjuna.ats.arjuna.ObjectModel;

  import com.arjuna.ats.arjuna.ObjectStatus;

  import com.arjuna.ats.arjuna.ObjectType;

  import com.arjuna.ats.arjuna.StateManager;

  import com.arjuna.ats.arjuna.common.Mutex;

  import com.arjuna.ats.arjuna.common.ObjectStoreEnvironmentBean;

  import com.arjuna.ats.arjuna.common.Uid;

  import com.arjuna.ats.arjuna.coordinator.AbstractRecord;

  import com.arjuna.ats.arjuna.coordinator.ActionHierarchy;

  import com.arjuna.ats.arjuna.coordinator.ActionStatus;

  import com.arjuna.ats.arjuna.coordinator.AddOutcome;

  import com.arjuna.ats.arjuna.coordinator.BasicAction;

  import com.arjuna.ats.arjuna.logging.tsLogger;

  import com.arjuna.ats.arjuna.state.InputObjectState;

  import com.arjuna.ats.arjuna.state.OutputObjectState;

  import com.arjuna.ats.internal.arjuna.common.UidHelper;

  import com.arjuna.ats.internal.txoj.LockConflictManager;

  import com.arjuna.ats.internal.txoj.LockList;

  import com.arjuna.ats.internal.txoj.LockListIterator;

  import com.arjuna.ats.internal.txoj.abstractrecords.CadaverLockRecord;

  import com.arjuna.ats.internal.txoj.abstractrecords.LockRecord;

  import com.arjuna.ats.internal.txoj.lockstore.BasicLockStore;

  import com.arjuna.ats.internal.txoj.lockstore.BasicPersistentLockStore;

  import com.arjuna.ats.txoj.common.txojPropertyManager;

  import com.arjuna.ats.txoj.exceptions.LockStoreException;

  import com.arjuna.ats.txoj.lockstore.LockStore;

  import com.arjuna.ats.txoj.logging.txojLogger;

  public class LockManager extends StateManager

  {

    

      public static final int defaultRetry = 100;

    

      public static final int defaultSleepTime = 250;

    

     public static final int waitTotalTimeout = -100;

    

     public void finalize () throws Throwable

     {

         if (tsLogger.logger.isTraceEnabled()) {

             tsLogger.logger.trace("LockManager.finalize() for object-id " + get_uid()

                     + " type " + type());

         }

         /*

          * terminate should have been called. Check and warn/do something about it if this

          * is not the case!

          */

         if (status() == ObjectStatus.ACTIVE_NEW)

         {

             BasicAction action = BasicAction.Current();

             if ((action != null) && (action.status() == ActionStatus.RUNNING)) {

                 tsLogger.i18NLogger.warn_StateManager_1();

                 cleanup(false);

             }

         }

         boolean doSignal = false;

         cleanUp();

         if (mutex != null)

         {

             if (mutex.lock() == Mutex.LOCKED)

                 doSignal = true;

         }

         locksHeld = null;

         lockStore = null;

         conflictManager = null;

         if (doSignal) // mutex must be set

             mutex.unlock();

         mutex = null;

         super.finalize();

     }

    

     public boolean propagate (Uid from, Uid to)

     {

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::propagate(" + from + ", " + to + ")");

         }

         boolean result = false;

         int retryCount = 10;

         do

         {

             try

             {

                 Object syncObject = ((BasicAction.Current() == null) ? getMutex() : BasicAction.Current());

                 synchronized (syncObject)

                 {

                     synchronized (locksHeldLockObject)

                     {

                         if (loadState())

                         {

                             LockList oldlist = locksHeld;

                             Lock current = null;

                             locksHeld = new LockList(); /* create a new one */

                             if (locksHeld != null)

                             {

                                 /*

                                  * scan through old list of held locks and propagate

                                  * to parent.

                                  */

                                 while ((current = oldlist.pop()) != null)

                                 {

                                     if (current.getCurrentOwner().equals(from))

                                     {

                                         current.propagate();

                                     }

                                     if (!locksHeld.insert(current))

                                     {

                                         current = null;

                                     }

                                 }

                                 oldlist = null; /* get rid of old lock list */

                                 result = true;

                             }

                             else

                             {

                                 /*

                                  * Cannot create new locklist - abort and try again.

                                  */

                                 freeState();

                                 throw new NullPointerException();

                             }

                         }

                         if (result)

                         {

                             result = unloadState();

                         }

                     }

                 }

             }

             catch (NullPointerException e)

             {

                 result = false;

             }

             if (!result)

             {

                 try

                 {

                     Thread.sleep(LockManager.DOZE_TIME);

                 }

                 catch (InterruptedException e)

                 {

                 }

             }

         }

         while ((!result) && (--retryCount > 0));

         if (!result)

         {

             txojLogger.i18NLogger.warn_LockManager_1();

             synchronized (locksHeldLockObject)

             {

                 freeState();

             }

         }

         return result;

     }

    

     public final boolean releaseAll (Uid actionUid)

     {

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::releaseAll(" + actionUid + ")");

         }

         return doRelease(actionUid, true);

     }

    

     public final boolean releaselock (Uid lockUid)

     {

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::releaseLock(" + lockUid + ")");

         }

         return doRelease(lockUid, false);

     }

     /*

      * This is the main user visible operation. Attempts to set the given lock

      * on the current object. If lock cannot be set, then the lock attempt is

      * retried retry times before giving up and returning an error. This gives a

      * simple handle on deadlock. Use the default timeout and retry values.

      * @return <code>LockResult</code> indicating outcome.

      */

     public final int setlock (Lock toSet)

     {

         return setlock(toSet, LockManager.defaultRetry,

                 LockManager.defaultSleepTime);

     }

     /*

      * This is the main user visible operation. Attempts to set the given lock

      * on the current object. If lock cannot be set, then the lock attempt is

      * retried retry times before giving up and returning an error. This gives a

      * simple handle on deadlock. Use the default timeout value.

      * @return <code>LockResult</code> indicating outcome.

      */

     public final int setlock (Lock toSet, int retry)

     {

         return setlock(toSet, retry, LockManager.defaultSleepTime);

     }

     /*

      * This is the main user visible operation. Attempts to set the given lock

      * on the current object. If lock cannot be set, then the lock attempt is

      * retried retry times before giving up and returning an error. This gives a

      * simple handle on deadlock.

      * @return <code>LockResult</code> indicating outcome.

      */

     public int setlock (Lock toSet, int retry, int sleepTime)

     {

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::setlock(" + toSet + ", " + retry + ", "

                     + sleepTime + ")");

         }

         int conflict = ConflictType.CONFLICT;

         int returnStatus = LockResult.REFUSED;

         LockRecord newLockR = null;

         boolean modifyRequired = false;

         BasicAction currAct = null;

         if (toSet == null)

         {

             txojLogger.i18NLogger.warn_LockManager_2();

             return LockResult.REFUSED;

         }

         currAct = BasicAction.Current();

         if (currAct != null)

         {

             ActionHierarchy ah = currAct.getHierarchy();

             if (ah != null)

                 toSet.changeHierarchy(ah);

             else

             {

                 txojLogger.i18NLogger.warn_LockManager_3();

                 toSet = null;

                 return LockResult.REFUSED;

             }

         }

         if (super.loadObjectState())

             super.setupStore();

         while ((conflict == ConflictType.CONFLICT)

                 && ((retry >= 0) || ((retry == LockManager.waitTotalTimeout) && (sleepTime > 0))))

         {

             Object syncObject = ((currAct == null) ? getMutex() : currAct);

             synchronized (syncObject)

             {

                 synchronized (locksHeldLockObject)

                 {

                     conflict = ConflictType.CONFLICT;

                     if (loadState())

                     {

                         conflict = lockConflict(toSet);

                     }

                     else

                     {

                         txojLogger.i18NLogger.warn_LockManager_4();

                     }

                     if (conflict != ConflictType.CONFLICT)

                     {

                         /*

                          * When here the conflict was resolved or the retry limit

                          * expired.

                          */

                         /* no conflict so set lock */

                         modifyRequired = toSet.modifiesObject();

                         /* trigger object load from store */

                         if (super.activate())

                         {

                             returnStatus = LockResult.GRANTED;

                             if (conflict == ConflictType.COMPATIBLE)

                             {

                                 int lrStatus = AddOutcome.AR_ADDED;

                                 if (currAct != null)

                                 {

                                     /* add new lock record to action list */

                                     newLockR = new LockRecord(this, (modifyRequired ? false : true), currAct);

                                     if ((lrStatus = currAct.add(newLockR)) != AddOutcome.AR_ADDED)

                                     {

                                         newLockR = null;

                                         if (lrStatus == AddOutcome.AR_REJECTED)

                                             returnStatus = LockResult.REFUSED;

                                     }

                                 }

                                 if (returnStatus == LockResult.GRANTED)

                                 {

                                     locksHeld.insert(toSet); /*

                                                               * add to local lock

                                                               * list

                                                               */

                                 }

                             }

                         }

                         else

                         {

                             /* activate failed - refuse request */

                             txojLogger.i18NLogger.warn_LockManager_5();

                             returnStatus = LockResult.REFUSED;

                         }

                     }

                     /*

                      * Unload internal state into lock store only if lock list was

                      * modified if this fails claim the setlock failed. If we are

                      * using the lock daemon we can arbitrarily throw the lock away

                      * as the daemon has it.

                      */

                     if ((returnStatus == LockResult.GRANTED)

                             && (conflict == ConflictType.COMPATIBLE))

                     {

                         if (!unloadState())

                         {

                             txojLogger.i18NLogger.warn_LockManager_6();

                             returnStatus = LockResult.REFUSED;

                         }

                     }

                     else

                         freeState();

                     /*

                      * Postpone call on modified to here so that semaphore will have

                      * been released. This means when modified invokes save_state

                      * that routine may set another lock without blocking.

                      */

                     if (returnStatus == LockResult.GRANTED)

                     {

                         if (modifyRequired)

                         {

                             if (super.modified())

                                 hasBeenLocked = true;

                             else

                             {

                                 conflict = ConflictType.CONFLICT;

                                 returnStatus = LockResult.REFUSED;

                             }

                         }

                     }

                     /*

                      * Make sure we free state while we still have the lock.

                      */

                     if (conflict == ConflictType.CONFLICT)

                         freeState();

                 }

             }

             if (conflict == ConflictType.CONFLICT)

             {

                 if (retry != 0)

                 {

                     if (sleepTime > 0)

                     {

                         sleepTime -= conflictManager.wait(retry, sleepTime);

                     }

                     else

                         retry = 0;

                 }

                 if (retry != LockManager.waitTotalTimeout)

                     retry--;

             }

         }

         return returnStatus;

     }

    

     public void print (PrintWriter strm)

     {

         LockListIterator next = new LockListIterator(locksHeld);

         Lock current;

         strm.println("LocalLockManager for object " + get_uid());

         if (!stateLoaded)

             strm.println("No loaded state");

         else if (locksHeld != null)

         {

             strm.println("\tCurrently holding : " + locksHeld.entryCount()

                     + " locks");

             while ((current = next.iterate()) != null)

                 current.print(strm);

         }

         else

             strm.println("Currently holding : 0 locks");

     }

    

     public void printState (PrintWriter strm)

     {

         synchronized (locksHeldLockObject)

         {

             boolean iDeleteState = false;

             if (!stateLoaded)

             {

                 loadState();

                 iDeleteState = true;

             }

             print(strm);

             if (iDeleteState)

                 freeState();

         }

     }

    

     public String type ()

     {

         return "StateManager/LockManager";

     }

     /*

      * Pass on some args to StateManager and initialise internal state. The lock

      * store and semaphore are set up lazily since they depend upon the result

      * of the type() operation which if run in the constructor always give the

      * same answer!

      */

     protected LockManager(Uid storeUid)

     {

         this(storeUid, ObjectType.ANDPERSISTENT, ObjectModel.SINGLE);

     }

     protected LockManager(Uid storeUid, int ot)

     {

         this(storeUid, ot, ObjectModel.SINGLE);

     }

     // make default SINGLE

     protected LockManager (Uid storeUid, int ot, int om)

     {

         super(storeUid, ot, om);

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::LockManager(" + storeUid + ")");

         }

         systemKey = null;

         locksHeld = new LockList();

         lockStore = null;

         mutex = null;

         stateLoaded = false;

         hasBeenLocked = false;

         objectLocked = false;

         conflictManager = new LockConflictManager();

     }

     /*

      * Pass on some args to StateManager and initialise internal state. The lock

      * store and semaphore are set up lazily since they depend upon the result

      * of the type() operation which if run in the constructor always give the

      * same answer!

      */

     protected LockManager()

     {

         this(ObjectType.RECOVERABLE);

     }

     protected LockManager(int ot)

     {

         this(ot, ObjectModel.SINGLE);

     }

     protected LockManager (int ot, int om)

     {

         super(ot, om);

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::LockManager(" + ot + ")");

         }

         systemKey = null;

         locksHeld = new LockList();

         lockStore = null;

         mutex = null;

         stateLoaded = false;

         hasBeenLocked = false;

         objectLocked = false;

         conflictManager = new LockConflictManager();

     }
    
    

     protected void terminate ()

     {

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::terminate() for object-id " + get_uid());

         }

         cleanUp();

         super.terminate();

     }

     protected final void cleanUp ()

     {

         if (txojLogger.logger.isTraceEnabled()) {

             txojLogger.logger.trace("LockManager::cleanUp() for object-id " + get_uid());

         }

         if (hasBeenLocked)

         {

             if ((super.objectModel == ObjectModel.MULTIPLE)

                     && (systemKey == null))

             {

                 initialise();

             }

             /*

              * Unlike in the original version of Arjuna, we don't check to see

              * if the invoking thread is within a transaction. We look at

              * whether this object has been used within a transaction, and then

              * act accordingly.

              */

             BasicAction current = BasicAction.Current();

             synchronized (super.usingActions)

             {

                 if (super.usingActions != null)

                 {

                     Enumeration e = super.usingActions.elements();

                     while (e.hasMoreElements())

                     {

                         BasicAction action = (BasicAction) e.nextElement();

                         if (action != null)  // shouldn't be null!!

                         {

                             /*

                              * Pop actions off using list. Don't check if action

                              * is running below so that cadavers can be created

                              * in commit protocol too.

                              */

                             /*

                              * We need to create a cadaver lock record to

                              * maintain the locks because this object is being

                              * deleted.

                              */

                             AbstractRecord A = new CadaverLockRecord(lockStore,

                                     this, action);

                             if (action.add(A) != AddOutcome.AR_ADDED)

                             {

                                 A = null;

                             }

                         }

                     }

                 }

             }