Added stayin alive to session. Inital director.

CMakeLists.txt

@@ -33,6 +33,6 @@ FIND_PACKAGE( Boost 1.60 COMPONENTS program_options log_setup log REQUIRED )
 INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIR} )
 
 
-ADD_EXECUTABLE( twproxy twproxy.cpp config.cpp session.cpp session.h )
+ADD_EXECUTABLE( twproxy twproxy.cpp config.cpp session.cpp director.cpp )
 TARGET_LINK_LIBRARIES( twproxy ${Boost_LIBRARIES} pthread )
 

director.cpp

@@ -0,0 +1,57 @@
+#include "director.h"
+
+Dispatch::Dispatch(Director &dir) : d{dir} {};
+
+// virtuals
+void Dispatch::server_line(const std::string &line){};
+void Dispatch::server_prompt(const std::string &prompt){};
+void Dispatch::client_input(const std::string &input){};
+
+void Dispatch::to_server(const std::string &send) { d.to_server(send); }
+void Dispatch::to_client(const std::string &send) { d.to_client(send); }
+
+Director::Director(Session &s) : session{s} {}
+
+void Director::server_line(const std::string &line) {
+  if (server_line_)
+    server_line_(line);
+}
+void Director::server_prompt(const std::string &prompt) {
+  if (server_prompt_)
+    server_prompt_(prompt);
+}
+
+void Director::client_input(const std::string &input) {
+  if (client_input_)
+    client_input_(input);
+}
+
+// These would be called by the Dispatch --
+// since it has direct access to us.
+void Director::to_server(const std::string &send) { session.to_server(send); }
+void Director::to_client(const std::string &send) { session.to_client(send); }
+
+void Director::set_server_line(stringFunc new_sl) { server_line_ = new_sl; }
+void Director::set_server_prompt(stringFunc new_sp) { server_prompt_ = new_sp; }
+void Director::set_client_input(stringFunc new_ci) { client_input_ = new_ci; }
+
+OldValues Director::get_state(void) {
+  OldValues values;
+  values.server_line = server_line_;
+  values.server_prompt = server_prompt_;
+  values.client_input = client_input_;
+  values.to_client = to_client_;
+
+  server_line_(nullptr);
+  server_prompt_(nullptr);
+  client_input_(nullptr);
+  to_client_ = false;
+  return values;
+}
+
+void Director::restore_state(OldValues v) {
+  server_line_ = v.server_line;
+  server_prompt_ = v.server_prompt;
+  client_input_ = v.client_input;
+  to_client_ = v.to_client;
+}

director.h

@@ -0,0 +1,70 @@
+#ifndef DIRECTOR_H
+#define DIRECTOR_H
+
+#include <functional>
+#include <string>
+#include "session.h"
+
+typedef std::function<void(const std::string &)> stringFunc;
+
+struct OldValues {
+  stringFunc server_line;
+  stringFunc server_prompt;
+  stringFunc client_input;
+  bool to_client;
+};
+
+class Director;
+
+// possibly setup a timer to call Dispatch.
+
+class Dispatch {
+protected:
+  OldValues original;
+  Director &d;
+
+public:
+  Dispatch(Director &);
+
+  virtual void server_line(const std::string &line);
+  virtual void server_prompt(const std::string &prompt);
+  virtual void client_input(const std::string &input);
+
+  void to_server(const std::string &send);
+  void to_client(const std::string &send);
+};
+
+class Director {
+private:
+  Session &session;
+
+public:
+  Director(Session &);
+
+  void server_line(const std::string &line);
+  void server_prompt(const std::string &prompt);
+  void client_input(const std::string &input);
+
+  // These would be called by the Dispatch --
+  // since it has direct access to us.
+  void to_server(const std::string &send);
+  void to_client(const std::string &send);
+
+  void set_server_line(stringFunc new_sl);
+  void set_server_prompt(stringFunc new_sp);
+  void set_client_input(stringFunc new_ci);
+
+  OldValues get_state(void); // save state and reset to blanks/nullptr
+  void restore_state(OldValues);
+
+private:
+  stringFunc server_line_;
+  stringFunc server_prompt_;
+  stringFunc client_input_;
+  bool to_client_; // Send server input to the client
+
+  // bool client_to_server; // WHEN would I ever have the client talking
+  // directly to the server?  [NEVER]
+};
+
+#endif

session.cpp

@@ -65,11 +65,12 @@ std::string clean_string(const std::string &source) {
 Session::Session(boost::asio::ip::tcp::socket socket,
                  boost::asio::io_service &io_service, std::string hostname,
                  std::string port)
-    : socket_(std::move(socket)),
-      io_service_{io_service}, resolver_{io_service}, server_{io_service},
-      timer_{io_service}, host{hostname}, port{port} {
-  server_sent = 0;
+    : socket_(std::move(socket)), io_service_{io_service},
+      resolver_{io_service}, server_{io_service}, timer_{io_service},
+      keep_alive_{io_service}, host{hostname}, port{port} {
+  // server_sent = 0;
   time_ms = stoi(from_config("prompt_timeout", "50"));
+  keepalive_secs = stoi(from_config("keepalive", "45"));
 }
 
 void Session::start(void) {
@@ -179,10 +180,13 @@ void Session::process_lines(std::string &received) {
 
     // Remove \n for dispatching
     std::string part = line.substr(0, pos);
+
+    /*
     if (server_sent != 0) {
       line = line.substr(server_sent);
       server_sent = 0;
     };
+    */
 
     // display on?
     // to_client(line);
@@ -357,13 +361,13 @@ void Session::client_read(void) {
 
             if (talk_direct)
               to_server(read_buffer);
-            BUGZ_LOG(info) << "C: " << read_buffer;
+            BUGZ_LOG(info) << "CI: " << read_buffer;
 
             // do_write(output);
           }
           client_read();
         } else {
-          BUGZ_LOG(warning) << "C: read_failed";
+          BUGZ_LOG(warning) << "CI: read_failed";
           if (connected) {
             BUGZ_LOG(warning) << "Server.shutdown()";
             server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
@@ -386,7 +390,7 @@ void Session::to_client(std::string message) {
         if (!ec) {
 
         } else {
-          BUGZ_LOG(warning) << "C: write failed? closed? Server.shutdown()";
+          BUGZ_LOG(warning) << "2C: write failed? closed? Server.shutdown()";
           if (connected) {
             BUGZ_LOG(warning) << "Server.shutdown()";
             server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
@@ -407,6 +411,19 @@ void Session::to_server(std::string message) {
           socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
         }
       });
+
+  // keep alive timer
+  keep_alive_.expires_after(std::chrono::seconds(keepalive_secs));
+  keep_alive_.async_wait(boost::bind(&Session::stayin_alive, this,
+                                     boost::asio::placeholders::error));
+}
+
+void Session::stayin_alive(const boost::system::error_code error) {
+  if (error != boost::asio::error::operation_aborted) {
+    // stayin' alive, stayin' alive...
+    to_server(" ");
+    BUGZ_LOG(warning) << "Session::stayin_alive()";
+  }
 }
 
 Server::Server(boost::asio::io_service &io_service,

session.h

@@ -3,94 +3,11 @@
 
 #include <boost/asio.hpp>
 #include <boost/asio/ip/basic_resolver.hpp>
-#include <string>
 #include <map>
+#include <string>
 
 #define MAX_BUFFER 256
 
-/*
-My ideas on how to do this.
- */
-
-struct Request {
-  int x, y;
-  std::string str;
-};
-
-struct Result {
-  int x;
-  std::string str;
-};
-
-typedef std::function<void (const struct Result&)> ResultCallbackFunc;
-typedef std::function<void (const struct Request&, ResultCallbackFunc)> CommandFunc;
-
-// Yes, this needs to be in session.cpp (not the header)  Whoops!
-// std::map<std::string, CommandFunc> commands;
-
-// call_command("goto", Request{1, 0, ""}, my_callback );
-void register_command(const std::string name, CommandFunc command);
-bool call_command(const std::string name, const struct Request &param, ResultCallbackFunc callback);
-// look up name, if found, call it with params, callback.  return true (success)
-// otherwise fail (false).
-
-typedef std::function<void (const std::string &)> StringFunc;
-
-class OldState {
-  StringFunc server_line;
-  StringFunc server_prompt;
-  StringFunc client_input;
-  bool server_to_client;
-  bool client_to_server;  
-};
-
-class Dispatcher {
-
-  std::function<void (std::string)> server_line;
-  std::function<void (std::string)> server_prompt;
-  std::function<void (std::string)> client_input;
-  bool server_to_client;
-  bool client_to_server;
-
-  OldState save_state(void);
-  void restore_state(OldState);
-};
-
-
-/*
-Dispatch Manager:
-
-
-Handles:
-  [ ] Does whatever we received from the server get sent to the client?
-      [SHOW-CLIENT]
-  [ ] Where does client input go? [CLIENT]
-  [ ] Client input go directly to the server? [TALK-DIRECT]
-  [ ] Where does server input go? [SERVER-LINE] [SERVER-PROMPT]
-
-I'm thinking a dispatcher would know how to:
-  [ ] Save the current state (and current dispatcher/setup).
-  [ ] Set itself up with the director.
-  [ ] Restore the previous state (when destructing -- but only if it is the
-      current active receiver).
-  [ ] Take a command [goto SECTOR][trade FOE] (fuel organics equipment),
-      and return a result.  [1 SUCCESS][0 FAIL][-1 USER ABORTED]
-  [ ] Tell director where results should go (callback).
-  [ ] Tell director where callback messages/events should go.  (dynamic)
-
-
-Director:
-  [ ] Handles server lines, server prompt, client input.
-  [ ] Has to_client, to_server.
-  [ ] Has low-level flags for show_client, talk-direct
-  [ ] Has a std::stack of dispatchers.  Uses .top() for calls.
-  [ ] Reset -- would pop all but the last/master dispatchers.
-
-
-It seems like the director wants to be the session, or at least parts of it.
-
- */
-
 /*
 The Session:
 
@@ -123,7 +40,9 @@ private:
   void set_timer(void);
   void reset_timer(void);
   void on_timer(const boost::system::error_code error);
+  void stayin_alive(const boost::system::error_code error);
   int time_ms;
+  int keepalive_secs;
 
   // FOR NOW:  These will go into the director
   bool show_client = true;
@@ -156,7 +75,7 @@ private:
    * not matter at all, I'm thinking milliseconds here!
    */
   boost::asio::high_resolution_timer timer_;
-
+  boost::asio::high_resolution_timer keep_alive_;
   /**
    * What characters have been received from the server,
    * that weren't \n terminated?
@@ -170,7 +89,7 @@ private:
    * a hard time tracking those.
    *
    */
-  int server_sent;
+  // int server_sent;
 
   /**
    * The client read buffer.
@@ -240,11 +159,10 @@ private:
 };
 
 // The simple way to get the boost logging to log file and line number
-// information.
+// information.  [Let the BUGZ_LOG macro do it!]
 #include <iomanip>
 #include <string.h>
 
-// I don't gain anything from this being constexpr
 const char *trim_path(const char *filepath);
 
 #define BUGZ_LOG(severity)                                                     \