git-svn-id: https://svn.microneil.com/svn/SNFMulti/trunk@2 dc71a809-1921-45c4-985c-09c81d0142d9

15 years ago · 524a0ea35b
--- a/tcp_watchdog.cpp
+++ b/tcp_watchdog.cpp
@@ -1,54 +0,0 @@
 // tcp_watchdog.cpp
 // Copyright (C) 2006 - 2009 MicroNeil Research Corporation
 // See tcp_watchdog.hpp for details.

 #include "tcp_watchdog.hpp"

 const ThreadType TCPWatchdog::Type("TCPWatchdog");                              // Thread type.

 const ThreadState TCPWatchdog::Watching("Watching");                            // State when waiting to fire.
 const ThreadState TCPWatchdog::KilledSocket("KilledSocket");                    // Killed The Socket.
 const ThreadState TCPWatchdog::LiveAndLetBe("LiveAndLetBe");                    // Shutdown without incident.

 TCPWatchdog::TCPWatchdog(Socket& SocketToWatch, int Milliseconds) :             // Construct with
  MySocket(SocketToWatch),                                                      // a socket to watch,
  MyTimeout(Milliseconds),                                                      // a time limit,
  StillAlive(true) {                                                            // and a true alive flag.
      run();                                                                    // Run the thread.
 }

 TCPWatchdog::~TCPWatchdog() {                                                   // When we go away, we
    stop();                                                                     // need to stop.
 }

 void TCPWatchdog::reset() {                                                     // We can be reset by
    MyTimeout.restart();                                                        // restarting the timeout.
 }

 void TCPWatchdog::reset(int Milliseconds) {                                     // We can also be reset by
    MyTimeout.setDuration(Milliseconds);                                        // setting a new timeout and
    MyTimeout.restart();                                                        // starting fresh.
 }

 void TCPWatchdog::stop() {                                                      // If we are stopped then
    MyTimeout.restart();                                                        // we restart the timeout for safety,
    if(StillAlive) {                                                            // IF we're alive when we get here
        CurrentThreadState(LiveAndLetBe);                                       // we are "calling off the dog".
    }
    StillAlive = false;                                                         // falsify our alive flag, and
    join();                                                                     // wait for our thread to end.
 }

 void TCPWatchdog::myTask() {                                                    // This is the job we do.
    const int OneSecond = 1000;                                                 // One second in milliseconds.
    Sleeper WaitATic(OneSecond);                                                // Set up a one second sleeper.
    while(StillAlive) {                                                         // While we are alive,
        CurrentThreadState(Watching);                                           // we are watching the clock.
        WaitATic();                                                             // Every second or so we will
        if(MyTimeout.isExpired()) {                                             // check to see if we've expired.
            CurrentThreadState(KilledSocket);                                   // If the clock expires - we kill!
            StillAlive = false;                                                 // To do that, we turn ourselves
            MySocket.close();                                                   // off and close the socket.
        }
    }
 }
--- a/tcp_watchdog.hpp
+++ b/tcp_watchdog.hpp
@@ -1,45 +0,0 @@
 // tcp_watchdog.hpp
 // Copyright (C) 2006 - 2009 MicroNeil Research Corporation
 // Watchdog timer for TCP connections.
 // Closes the connection if it times out.
 // Theoretically, when a socet closes, anything blocked on that socket
 // will receive an exception and will deal with that appropriately by
 // stopping what it is doing... Can't work on a closed socket ;-)
 // This allows blocking sockets to be used safely in that the application
 // won't "hang" on a stopped / broken socket.

 #ifndef tcp_watchdog_included
 #define tcp_watchdog_included

 #include "timing.hpp"
 #include "threading.hpp"
 #include "networking.hpp"

 class TCPWatchdog : private Thread {
  private:

    Socket& MySocket;                                                           // Socket to watch.
    Timeout MyTimeout;                                                          // Timeout value.

    void myTask();                                                              // Watchdog task.

    volatile bool StillAlive;                                                   // True if we're watching.

  public:

    TCPWatchdog(Socket& SocketToWatch, int Milliseconds);                       // Create with a socket and a time limit.
    ~TCPWatchdog();                                                             // Destroy by stopping the task.

    void reset();                                                               // Reset the watchdog - everything is ok.
    void reset(int Milliseconds);                                               // Reset the watchdog - use a new time.
    void stop();                                                                // Stop the watchdog - all done here.

    const static ThreadType Type;                                               // The thread's type.

    const static ThreadState Watching;                                          // State when waiting to fire.
    const static ThreadState KilledSocket;                                      // Killed The Socket.
    const static ThreadState LiveAndLetBe;                                      // Shutdown without incident.

 };

 #endif