/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 * 
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License. You can obtain
 * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
 * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
 * Sun designates this particular file as subject to the "Classpath" exception
 * as provided by Sun in the GPL Version 2 section of the License file that
 * accompanied this code.  If applicable, add the following below the License
 * Header, with the fields enclosed by brackets [] replaced by your own
 * identifying information: "Portions Copyrighted [year]
 * [name of copyright owner]"
 * 
 * Contributor(s):
 * 
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

/*
 * Copyright 2004-2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

//----------------------------------------------------------------------------
//
// Module:      TimeoutManager.java
//
// Description: Transaction time-out manager.
//
// Product:     com.sun.jts.CosTransactions
//
// Author:      Simon Holdsworth
//
// Date:        March, 1997
//
// Copyright (c):   1995-1997 IBM Corp.
//
//   The source code for this program is not published or otherwise divested
//   of its trade secrets, irrespective of what has been deposited with the
//   U.S. Copyright Office.
//
//   This software contains confidential and proprietary information of
//   IBM Corp.
//----------------------------------------------------------------------------

package com.sun.jts.CosTransactions;

import java.util.*;

import org.omg.CosTransactions.*;
import com.sun.jts.jtsxa.XID;

import com.sun.jts.trace.*;

import java.util.logging.Logger;
import java.util.logging.Level;
import com.sun.logging.LogDomains;
import com.sun.jts.utils.LogFormatter;

/**
 * This class records state for timing out transactions, and runs a thread
 * which performs occasional checks to time out transactions.
 *
 * @version 0.01
 *
 * @author Simon Holdsworth, IBM Corporation
 *
 * @see
*/

//----------------------------------------------------------------------------
// CHANGE HISTORY
//
// Version By     Change Description
//   0.01  SAJH   Initial implementation.
//----------------------------------------------------------------------------

class TimeoutManager {
    /**
     * Constants which define the types of timeout possible.
     */
    static final int CANCEL_TIMEOUT   = 0;
    static final int NO_TIMEOUT       = 0;
    static final int ACTIVE_TIMEOUT   = 1;
    static final int IN_DOUBT_TIMEOUT = 2;

    /**
     * this attribute indicates whether initialisation has been started.
     */
    private static boolean initialised = false;

    private static Hashtable     pendingTimeouts = new Hashtable();
    private static Hashtable     indoubtTimeouts = new Hashtable();
    private static TimeoutThread timeoutThread = null;
    private static boolean       timeoutActive = false;
    private static boolean       quiescing = false;
    private static boolean       isSetTimeout = false;

	/*
		Logger to log transaction messages
	*/  
    static Logger _logger = LogDomains.getLogger(LogDomains.TRANSACTION_LOGGER);
    /**
     * Initialises the static state of the TimeoutManager class.
     *
     * @param
     *
     * @return
     *
     * @see
     */
    synchronized static void initialise() {

        // If already initialised, return immediately.

        if (initialised) {
            return;
        }

        initialised = true;

        // Start the timeout thread.

        if (!timeoutActive && timeoutThread == null) {
           //  timeoutThread = new TimeoutThread();
           //  timeoutThread.start();
            timeoutActive = true;
        }
    }


    static synchronized void initSetTimeout() {
	if (isSetTimeout)
	   return;
        isSetTimeout = true;
        timeoutThread = new TimeoutThread();
        timeoutThread.start();
    }

    /**
     * Sets the timeout for the transaction to the specified type and time in
     * seconds.
     * <p>
     * If the type is none, the timeout for the transaction is
     * cancelled, otherwise the current timeout for the transaction is modified
     * to be of the new type and duration.
     *
     * @param localTID     The local identifier for the transaction.
     * @param timeoutType  The type of timeout to establish.
     * @param seconds      The length of the timeout.
     *
     * @return  Indicates success of the operation.
     *
     * @see
     */
     static boolean setTimeout(Long localTID, int timeoutType,
                                           int seconds) {

        boolean result = true;

        // Modify the timeout to the required type and value.

        if (timeoutActive) {

            TimeoutInfo timeoutInfo = null;

            switch (timeoutType) {

            // If the new type is active or in_doubt, then create a
            // new TimeoutInfo if necessary, and set up the type and interval.

            case TimeoutManager.ACTIVE_TIMEOUT :
		 if (!isSetTimeout) {
		     initSetTimeout();
                 }
                 timeoutInfo = new TimeoutInfo();
                 timeoutInfo.expireTime  =
                    new Date().getTime() + seconds * 1000;
                 timeoutInfo.localTID    = localTID;
                 timeoutInfo.timeoutType = timeoutType;
                 pendingTimeouts.put(localTID,timeoutInfo);
                 break;
            case TimeoutManager.IN_DOUBT_TIMEOUT :
		 if (!isSetTimeout) {
		     initSetTimeout();
		     // isSetTimeout = true;
                 }
                timeoutInfo = new TimeoutInfo();
                timeoutInfo.expireTime  =
                    new Date().getTime() + seconds * 1000;
                timeoutInfo.localTID    = localTID;
                timeoutInfo.timeoutType = timeoutType;
                indoubtTimeouts.put(localTID,timeoutInfo);
                break;

            // For any other type, remove the timeout if there is one.

            default:
		if (!isSetTimeout)
		  break;
                   result = (pendingTimeouts.remove(localTID) != null);
		   if (!result)
                      result = (indoubtTimeouts.remove(localTID) != null);

                    // If the transaction service is quiescing and
                    // there are no more pending timeouts,
                    // deactivate timeout and stop the timeout thread.

                    if (quiescing && pendingTimeouts.isEmpty() && indoubtTimeouts.isEmpty()) {
                        timeoutThread.stop();
                        timeoutActive = false;
                        // pendingTimeouts = null;
                    }
                break;
            }
        } else {
            // If timeouts are not active, just return false.
            result = false;
        }

        return result;
    }

    /**
     * Takes appropriate action for a timeout.
     * <p>
     * The type fo timeout is given, and the transaction represented by the
     * Coordinator and its local identifier.
     * <p>
     * This method does not reference the TimeoutManager's state directly
     * and so does not need to be synchronized.
     *
     * @param localTID     The local identifier for the transaction.
     * @param timeoutType  The type of timeout.
     *
     * @return
     *
     * @see
     */
    static void timeoutCoordinator(Long localTID, int  timeoutType) {

        // Look up the Coordinator for the transaction.
        // If there is none, then the transaction has already gone.
        // Otherwise do something with the transaction.


        CoordinatorImpl coord = RecoveryManager.getLocalCoordinator(localTID);
        if (coord == null) {
            if(_logger.isLoggable(Level.FINER))
            {
                _logger.logp(Level.FINER,"TimeoutManager","timeoutCoordinator()",
		    "RecoveryManager.getLocalCoordinator() returned null,"+
		    "which means txn is done. Setting timeout type to CANCEL_TIMEOUT");
            }
            TimeoutManager.setTimeout(localTID,
                                      TimeoutManager.CANCEL_TIMEOUT,
                                      0);
        } else {
            synchronized (coord) {
                boolean[] isRoot = new boolean[1];

                switch (timeoutType) {

                // If active, then attempt to roll the transaction back.

                case TimeoutManager.ACTIVE_TIMEOUT :
                    if(_logger.isLoggable(Level.FINER))
            	    {
                        _logger.logp(Level.FINER,"TimeoutManager","timeoutCoordinator()",
                                     "TimeoutManager.timeoutCoordinator():case ACTIVE_TIMEOUT"+
                                     "RecoveryManager.getLocalCoordinator() returned non-null,"+
                                     "which means txn is still around. Marking for Rollback the"+
                                     "transaction...: GTID is : " + 
                                     ((TopCoordinator)coord).superInfo.globalTID.toString());
                    }
                    try {
                        // coord.rollback(true);
                        coord.rollback_only();
                    } catch (Throwable exc) {}
                    break;

                    // If in doubt, it must be a TopCoordinator.
                    // In that case replay_completion needs to be driven.
                    // This is done by telling the TopCoordinator to act as
                    // if in recovery.  The result is then used to
                    // determine what to do with the Coordinator.

                case TimeoutManager.IN_DOUBT_TIMEOUT :
                    if(_logger.isLoggable(Level.FINER))
                    {
                        _logger.logp(Level.FINER,"TimeoutManager","timeoutCoordinator()",
                                     "TimeoutManager.timeoutCoordinator():case IN_DOUBT_TIMEOUT"+
                                     "RecoveryManager.getLocalCoordinator() returned non-null,"+
                                     "which means txn is still around. Invoking recover(boolean)"+
                                     "on TopCoordinator...: GTID is: "+ 
                                     ((TopCoordinator)coord).superInfo.globalTID.toString());
                    }
                    Status state = ((TopCoordinator) coord).recover(isRoot);

                    if (state == Status.StatusUnknown) {
                    
                        // If the outcome is not currently known, we do
                        // nothing with the transaction, as we expect to
                        // eventually get an outcome from the parent.

                        // GDH put out warning in case this state
                        // continues for a long time.
                        _logger.log(Level.WARNING, "jts.transaction_resync_from_orginator_failed");

                    } else if (state == Status.StatusCommitted) {

                        // For committed or rolled back, proceed with
                        // completion of the transaction, regardless of whether
                        // it is the root or a subordinate. This will
                        // result in the removal of the in-doubt timeout.

                        try {
                            ((TopCoordinator)coord).commit();
                            if (isRoot[0]) {
                                ((TopCoordinator) coord).
                                    afterCompletion(state);
                            }
                        } catch (Throwable exc) {}
                    } else {
                        // By default, roll the transaction back.
                        try {
                            ((TopCoordinator) coord).rollback(true);
                            if (isRoot[0]) {
                                ((TopCoordinator) coord).
                                    afterCompletion(Status.StatusRolledBack);
                            }
                        } catch (Throwable exc) {}
                    }

                    break;

                default:
                    // Otherwise do nothing.
                    break;
                }
            }
        }
    }

    /**
     * Periodically checks the existing timeouts.
     * <p>
     * This is done to discover if any transactions have overrun their allotted
     * time.  Those which have are returned as an Enumeration.
     * <p>
     * Note that this method should not do anything that will cause a
     * synchronized method in the RecoveryManager to be called, as this could
     * cause a deadlock when RecoveryManager methods on other threads call
     * setTimeout.
     *
     * @param
     *
     * @return  The information for transactions which have timed out.
     *
     * @see
     */
     static Enumeration checkTimeouts() {
        if (!isSetTimeout)
           return null;

        Enumeration result = null;

        // When woken up, go through all current timeouts and identify those
        // which have expired.

        if (timeoutActive && ((pendingTimeouts.size() != 0) || (indoubtTimeouts.size() != 0))) {
            Vector timedOut = null;

            Enumeration timeouts = null;
          
            synchronized (pendingTimeouts) {
                timeouts = pendingTimeouts.elements();

                while (timeouts.hasMoreElements()) {

                    TimeoutInfo timeoutInfo = (TimeoutInfo)timeouts.nextElement();

                    // For each timeout in the list, check whether it has expired.
                    // If so, look up the Coordinator and roll it back.

                    if (new Date().getTime() > timeoutInfo.expireTime) {

                       // Add the TimeoutInfo to the queue of
                       //those that have timed out.

                       if (timedOut == null) {
                           timedOut = new Vector();
                       }

                       timedOut.addElement(timeoutInfo);
                    }
               }
            }

	    synchronized (indoubtTimeouts) {

                timeouts = indoubtTimeouts.elements();

                while (timeouts.hasMoreElements()) {

                    TimeoutInfo timeoutInfo = (TimeoutInfo)timeouts.nextElement();

                    // For each timeout in the list, check whether it has expired.
                    // If so, look up the Coordinator and roll it back.

                    if (new Date().getTime() > timeoutInfo.expireTime) {

                       // Add the TimeoutInfo to the queue of
                       //those that have timed out.

                       if (timedOut == null) {
                           timedOut = new Vector();
                       }

                       timedOut.addElement(timeoutInfo);
                    }
                }

            }
            // Enumerate the transactions which have timed out.

            if (timedOut != null) {
                result = timedOut.elements();
            }
           }

        // The remainder of the timeout processing is not carried out here
        // because we would get deadlocked with addCoordinator or
        // removeCoordinator that also update the timeout list.  Hence the
        // returned enumeration, which may be processed with
        // no concurrency control.

        return result;
    }

    /**
     * @return a set of in-doubt transaction ids.
     */
    static XID[] getInDoubtXids() {
        
       synchronized (indoubtTimeouts) {
        Vector inDoubtList = new Vector();
        
        Enumeration timeouts = indoubtTimeouts.elements();

        while (timeouts.hasMoreElements()) {

            TimeoutInfo timeoutInfo = (TimeoutInfo) timeouts.nextElement();

            // Look up the Coordinator for the transaction.
            // If there is none, then the transaction has already gone.
            // Otherwise do something with the transaction.
                
            CoordinatorImpl coord = 
                RecoveryManager.getLocalCoordinator(timeoutInfo.localTID);
                                
            if (coord != null) {
                XID xid = new XID();
                xid.copy(coord.getGlobalTID());
                inDoubtList.addElement(xid);
            }
        }
        
        return (XID[]) inDoubtList.toArray(new XID[] {});
       }
    }

    /**
     * Returns the amount of time left before the given transaction times out.
     *
     * @param localTID  The local identifier for the transaction.
     *
     * @return  The time left.  If there is no timeout for the transaction,
     *          this value will be negative.  If the timeout period has been
     *          exceeded, this value will be zero.
     *
     * @see
     */
    static long timeLeft(Long localTID) {

        TimeoutInfo timeoutInfo = (TimeoutInfo) pendingTimeouts.get(localTID);
        if (timeoutInfo == null)
            timeoutInfo = (TimeoutInfo) indoubtTimeouts.get(localTID);
        long result = -1;
        if (timeoutInfo != null) {
            result = timeoutInfo.expireTime - new Date().getTime();
            if (result < 0) {
                result = 0;
            }
        }

        return result;
    }

    /**
     * Informs the TimeoutManager that the transaction service
     * is being shut down. For immediate shutdown, the timeout thread is
     * stopped and all timeout information discarded.
     *
     * For quiesce, the timeout thread is stopped when there are no running
     * transactions left.
     *
     * @param immediate  Indicates whether to stop immediately.
     *
     * @return
     *
     * @see
     */
    static void shutdown(boolean immediate) {

        // For immediate, kill the timeout thread and throw
        // away all information. Also, if there are no pending
        // timeouts, there is nothing to quiesce so
        // shutdown immediately regardless.

        if (immediate ||
                pendingTimeouts == null || pendingTimeouts.isEmpty()) {
            if (timeoutThread != null) {
                timeoutThread.stop();
            }

            if (pendingTimeouts != null) {
                pendingTimeouts.clear();
            }

            pendingTimeouts = null;
            timeoutThread = null;
            timeoutActive = false;
        } else {
            quiescing = true;
        }
    }

    /**
     * Reports the contents of the TimeoutManager tables.
     *$Only required for debug.
     *
     * @param immediate  Indicates whether to stop immediately.
     *
     * @return
     *
     * @see
     */
    /*
    static void report() {

        // Report on pendingTimeouts.

        if (pendingTimeouts.size() > 0) {
			if(_logger.isLoggable(Level.FINER))
			{	
				_logger.logp(Level.FINER,"TimeoutManager","report()",
						"TimeoutManager.pendingTimeouts non-empty");
			}
            Enumeration keys = pendingTimeouts.keys();

            while (keys.hasMoreElements()) {
                Long localTID = (Long) keys.nextElement();
                TimeoutInfo timeInfo =
                    (TimeoutInfo) pendingTimeouts.get(localTID);
				if(_logger.isLoggable(Level.FINER))
				{
					_logger.logp(Level.FINER,"TimeoutManager","report()",
                			"localTid :"+localTID+" -> " + timeInfo);
				}
            }
        } else {
			if(_logger.isLoggable(Level.FINER))
			{
				_logger.logp(Level.FINER,"TimeoutManager","report()",
          		 		"TimeoutManager.pendingTimeouts empty");
			}
        }
    }
    */
}

/**
 * This class records information for a timeout for a transaction.
 *
 * @version 0.1
 *
 * @author Simon Holdsworth, IBM Corporation
 *
 * @see
 */

//----------------------------------------------------------------------------
// CHANGE HISTORY
//
// Version By     Change Description
//   0.1   SAJH   Initial implementation.
//----------------------------------------------------------------------------

class TimeoutInfo extends Object {
    Long localTID = null;
    long expireTime = 0;
    int  timeoutType = TimeoutManager.NO_TIMEOUT;
}

/**
 * This class represents a thread on which the TimeoutManager can perform
 * timeout checking.
 *
 * @version 0.01
 *
 * @author Simon Holdsworth, IBM Corporation
 *
 * @see
 */

//----------------------------------------------------------------------------
// CHANGE HISTORY
//
// Version By     Change Description
//   0.01  SAJH   Initial implementation.
//----------------------------------------------------------------------------

class TimeoutThread extends Thread {

    private int TIMEOUT_INTERVAL ;

    static Logger _logger = LogDomains.getLogger(LogDomains.TRANSACTION_LOGGER);
    /**
     * TimeoutThread constructor.
     * <p>
     * This sets the thread name, and sets the thread to be a daemon thread so
     * that it does not prevent the process from terminating.
     *
     * @param
     *
     * @return
     *
     * @see
     */
    TimeoutThread() {
        setName("JTS Timeout Thread"/*#Frozen*/);
        setDaemon(true);
        try{
            String timeout_interval = Configuration.getPropertyValue(Configuration.TIMEOUT_INTERVAL);
            if(timeout_interval!=null){
                TIMEOUT_INTERVAL= Integer.parseInt(timeout_interval);
		TIMEOUT_INTERVAL*=1000;
                if(TIMEOUT_INTERVAL<10000)
                    TIMEOUT_INTERVAL=10000;
            }
            else{
                TIMEOUT_INTERVAL=10000;
            }
        }catch(Exception e){
            TIMEOUT_INTERVAL=10000;
        }
    }

    /**
     * Performs timeout checking on a regular basis (every ten seconds or so).
     *
     * @param
     *
     * @return
     *
     * @see
     */
    public void run() {
        try {
            while (true) {

                // Sleep for a while between checks.

                Thread.sleep(TIMEOUT_INTERVAL);

                // Perform timeout checks, getting a list of timed-out
                // transactions.

                Enumeration timedOut = TimeoutManager.checkTimeouts();

                // Now we must go through the list, telling each
                // timed-out Coordinator to do something appropriate.

                if (timedOut != null) {
                    while (timedOut.hasMoreElements()) {
                        TimeoutInfo timeoutInfo =
                            (TimeoutInfo) timedOut.nextElement();

                        // Look up the Coordinator and tell it to roll back
                        // if it still exists. Note that we rely on the
                        // Coordinator calling removeCoordinator when it
                        // has finished, which will remove the timeout from 
                        // the list, and remove other associations as well.

                        TimeoutManager.
                            timeoutCoordinator(timeoutInfo.localTID,
                                               timeoutInfo.timeoutType);
                    }
                }
            }
        } catch (InterruptedException exc) {
			_logger.log(Level.INFO,"jts.time_out_thread_stopped");
        }
    }
}
