machine/console.hpp

   1 #ifndef RBX_CONSOLE_HPP
   2 #define RBX_CONSOLE_HPP
   3
   4 #include "machine_thread.hpp"
   5 #include "spinlock.hpp"
   6
   7 #include <list>
   8 #include <mutex>
   9 #include <string>
  10
  11 namespace rubinius {
  12   class Console;
  13   class Channel;
  14   class ThreadState;
  15   class FSEvent;
  16   class Object;
  17   class String;
  18
  19   namespace console {
  20     class Listener;
  21     class Request;
  22     class Response;
  23
  24     class Listener : public MachineThread {
  25       Console* console_;
  26
  27       FSEvent* fsevent_;
  28
  29       int fd_;
  30
  31     public:
  32
  33       Listener(STATE, Console* console);
  34       virtual ~Listener();
  35
  36       bool connection_initiated();
  37
  38       void start_thread(STATE);
  39       void initialize(STATE);
  40       void run(STATE);
  41       void wakeup(STATE);
  42
  43       void trace_objects(STATE, std::function<void (STATE, Object**)> f);
  44     };
  45
  46     typedef std::list<char*> RequestList;
  47
  48     class Response : public MachineThread {
  49       Console* console_;
  50
  51       Channel* inbox_;
  52       Channel* outbox_;
  53
  54       int fd_;
  55
  56       RequestList* request_list_;
  57
  58       locks::spinlock_mutex list_lock_;
  59
  60       std::mutex response_lock_;
  61       std::condition_variable response_cond_;
  62
  63     public:
  64
  65       Response(STATE, Console* console);
  66       virtual ~Response();
  67
  68       void initialize(STATE);
  69       void start_thread(STATE);
  70       void run(STATE);
  71       void wakeup(STATE);
  72       void stop_thread(STATE);
  73       void after_fork_child(STATE);
  74
  75       void close_response();
  76       void clear_requests();
  77
  78       void send_request(STATE, const char* request);
  79       void write_response(STATE, const char* response, intptr_t size);
  80
  81       void trace_objects(STATE, std::function<void (STATE, Object**)> f);
  82     };
  83
  84     class Request : public MachineThread {
  85       Console* console_;
  86       Response* response_;
  87
  88       bool enabled_;
  89
  90       int fd_;
  91
  92       FSEvent* fsevent_;
  93
  94     public:
  95
  96       Request(STATE, Console* console, Response* response);
  97
  98       bool enabled_p() {
  99         return enabled_;
 100       }
 101
 102       void initialize(STATE);
 103       void start_thread(STATE);
 104       void run(STATE);
 105       void wakeup(STATE);
 106       void stop_thread(STATE);
 107       void after_fork_child(STATE);
 108
 109       void close_request();
 110
 111       char* read_request(STATE);
 112
 113       void trace_objects(STATE, std::function<void (STATE, Object**)> f);
 114     };
 115   }
 116
 117   using namespace console;
 118
 119   class Console {
 120     std::string console_path_;
 121     std::string request_path_;
 122     std::string response_path_;
 123
 124     Listener* listener_;
 125     Response* response_;
 126     Request* request_;
 127
 128     Object* ruby_console_;
 129
 130   public:
 131     Console(STATE);
 132     virtual ~Console();
 133
 134     Object* ruby_console() {
 135       return ruby_console_;
 136     }
 137
 138     std::string& console_path() {
 139       return console_path_;
 140     }
 141
 142     std::string& request_path() {
 143       return request_path_;
 144     }
 145
 146     std::string& response_path() {
 147       return response_path_;
 148     }
 149
 150     bool connected_p();
 151
 152     void reset();
 153
 154     void start(STATE);
 155     void stop(STATE);
 156     void after_fork_child(STATE);
 157
 158     void accept(STATE);
 159     Class* server_class(STATE);
 160
 161     void trace_objects(STATE, std::function<void (STATE, Object**)> f);
 162   };
 163 }
 164
 165 #endif