Got rid of most using directives. Ported tests to python.

[invirt/third/libt4.git] / rpc / connection.h

diff --git a/rpc/connection.h b/rpc/connection.h
index b1df8a1..68bd902 100644 (file)
--- a/rpc/connection.h
+++ b/rpc/connection.h
@@ -4,89 +4,77 @@
 #include "types.h"
 #include <arpa/inet.h>
 #include <netinet/in.h>
-#include "pollmgr.h"
+#include "poll_mgr.h"
 #include "file.h"
 
-constexpr size_t size_t_max = numeric_limits<size_t>::max();
-
-class thread_exit_exception : exception {};
-
 class connection;
 
-class chanmgr {
+class connection_delegate {
     public:
         virtual bool got_pdu(const shared_ptr<connection> & c, const string & b) = 0;
-        virtual ~chanmgr() {}
+        virtual ~connection_delegate();
 };
 
-class connection : public aio_callback, public enable_shared_from_this<connection> {
-    public:
-        struct charbuf {
-            string buf;
-            size_t solong = 0; // number of bytes written or read so far
-        };
+using std::chrono::steady_clock;
+using time_point = std::chrono::time_point<steady_clock>;
 
-        connection(chanmgr *m1, int f1, int lossytest=0);
+class connection : private aio_callback, public std::enable_shared_from_this<connection> {
+    public:
+        connection(connection_delegate * delegate, socket_t && f1, int lossytest=0);
         ~connection();
 
-        int channo() { return fd_; }
-        bool isdead() { lock ml(m_); return dead_; }
-        void closeconn();
+        bool isdead() { return dead_; }
 
         bool send(const string & b);
-        void write_cb(int s);
-        void read_cb(int s);
 
-        time_point<steady_clock> create_time() const { return create_time_; }
+        static shared_ptr<connection> to_dst(const sockaddr_in & dst, connection_delegate *mgr, int lossy=0);
+
+        const time_point create_time = steady_clock::now();
+        const file_t fd;
 
     private:
+        void write_cb(int s);
+        void read_cb(int s);
 
         bool readpdu();
         bool writepdu();
 
-        chanmgr *mgr_;
-        const file_t fd_;
+        connection_delegate * delegate_;
         bool dead_ = false;
 
-        charbuf wpdu_;
-        charbuf rpdu_;
+        enum charbuf_status_t { unused, inflight, error };
+
+        struct charbuf {
+            charbuf_status_t status;
+            string buf;
+            size_t cursor; // number of bytes written or read so far
+        };
 
-        time_point<steady_clock> create_time_;
+        charbuf wpdu_ = {unused, "", 0};
+        charbuf rpdu_ = {unused, "", 0};
 
-        int waiters_ = 0;
         int lossy_ = 0;
 
-        mutex m_;
+        std::mutex m_;
         cond send_complete_;
         cond send_wait_;
 };
 
-class tcpsconn {
+class connection_listener : private aio_callback {
     public:
-        tcpsconn(chanmgr *m1, in_port_t port, int lossytest=0);
-        ~tcpsconn();
+        connection_listener(connection_delegate * delegate, in_port_t port, int lossytest=0);
+        ~connection_listener();
         inline in_port_t port() { return port_; }
-        void accept_conn();
     private:
+        void write_cb(int) {}
+        void read_cb(int s);
+
         in_port_t port_;
-        mutex m_;
-        thread th_;
-        file_t pipe_[2];
+        std::mutex m_;
 
         socket_t tcp_; // listens for connections
-        chanmgr *mgr_;
+        connection_delegate * delegate_;
         int lossy_;
-        map<int, shared_ptr<connection>> conns_;
-
-        void process_accept();
+        std::map<int, shared_ptr<connection>> conns_;
 };
-
-struct bundle {
-    bundle(chanmgr *m, int s, int l):mgr(m),tcp(s),lossy(l) {}
-    chanmgr *mgr;
-    int tcp;
-    int lossy;
-};
-
-shared_ptr<connection> connect_to_dst(const sockaddr_in &dst, chanmgr *mgr, int lossy=0);
 #endif