/*

  * 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");

         }

     }

 }