/*

 * Created on Aug 21, 2003

 */

package isac.bridge;

/**

 * @author rgradisc

 * 

 * Stores times of requests to sml-kernel. This is used for informing

 * Clients2KernelServer to kill sml-kernel if no response is coming back for a

 * certain amount of time, which means that the bridge_ has probably crashed or

 * is caught in an endless loop, and neeeds to be restarted.

 */

import java.util.Vector;

import org.apache.log4j.Logger;

public class TimeCheckerThread extends Thread {

    //Time to wait for response from the kernel to a request

    private long wait_millis_;

    //Stores the times when the waitTime for current request will run out

    private Vector time_out_times_;

    //Reference to the bridgeMain object

    private BridgeMain bridge_;

    static Logger logger_ = Logger.getLogger(TimeCheckerThread.class.getName());

    /**

     * Constructor: instantiate a new TimeCheckerThread

     * 

     * @param bridge_

     *            BridgeMain object that belongs to this TimeCheckerThread

     * @param wait_millis_

     *            Time to wait for response from kernel before restarting

     */

    public TimeCheckerThread(BridgeMain bridge, long waitMillis) {

        logger_.warn("TimeCheckerThread: bridge_=" + bridge + ", wait_millis_"

                + waitMillis);

        this.bridge_ = bridge;

        this.time_out_times_ = bridge.getTimeOutTimes();

        this.wait_millis_ = waitMillis;

    }

    /**

     * Start this Thread

     */

    public void run() {

        try {

            while (true) {

                if (!time_out_times_.isEmpty()) {

                    long first = ((Long) time_out_times_.firstElement())

                            .longValue();

                    long timeOut = first + wait_millis_;

                    long now = System.currentTimeMillis();

                    if (now > timeOut) {

                        // timeOut: no response from sml-kernel within TIME_OUT:

                        // restart sml-kernel

                        bridge_.restartSML();

                    } else {

                        // sleep until first time in vector would run out (plus

                        // a little buffer)

                        long sleepTime = timeOut - now + 20;

                        bridge_

                                .log(

                                        1,

                                        "TimeCheckerThread: "

                                                + time_out_times_.size()

                                                + " request(s) waiting for response, sleeping for "

                                                + sleepTime + " millis");

                        sleep(sleepTime);

                    }

                } else {

                    // TimesVector is empty: No pending requests

                    bridge_.log(1,

                            "TimeCheckerThread: no requests, sleeping for "

                                    + wait_millis_ + " millis");

                    sleep(wait_millis_);

                }

            }

        } catch (InterruptedException e) {

            bridge_.log(1, "TimeCheckerThread interrupted");

        }

    }

}