RPC procedures are now identified via a struct containing a string name.

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

diff --git a/rpc/rpc.h b/rpc/rpc.h
index 58e9381..9464e57 100644 (file)
--- a/rpc/rpc.h
+++ b/rpc/rpc.h
@@ -2,14 +2,13 @@
 #define rpc_h
 
 #include "types.h"
 #define rpc_h
 
 #include "types.h"

-#include <sys/socket.h>
-#include <netinet/in.h>

 
 #include "rpc_protocol.h"
 
 #include "rpc_protocol.h"

-#include "thr_pool.h"
+#include "thread_pool.h"

 #include "marshall.h"
 #include "marshall_wrap.h"
 #include "connection.h"
 #include "marshall.h"
 #include "marshall_wrap.h"
 #include "connection.h"

+#include "threaded_log.h"

 
 using std::chrono::milliseconds;
 
 
 using std::chrono::milliseconds;
 

@@ -43,8 +42,6 @@ struct is_valid_registration<
 class rpcc : private connection_delegate {
     private:
         using proc_id_t = rpc_protocol::proc_id_t;
 class rpcc : private connection_delegate {
     private:
         using proc_id_t = rpc_protocol::proc_id_t;

-        template <class S>
-        using proc_t = rpc_protocol::proc_t<S>;

         using nonce_t = rpc_protocol::nonce_t;
         using xid_t = rpc_protocol::xid_t;
 
         using nonce_t = rpc_protocol::nonce_t;
         using xid_t = rpc_protocol::xid_t;
 

@@ -75,6 +72,7 @@ class rpcc : private connection_delegate {
 
         std::mutex m_; // protect insert/delete to calls[]
         std::mutex chan_m_;
 
         std::mutex m_; // protect insert/delete to calls[]
         std::mutex chan_m_;

+        std::mutex bind_m_; // protect bind operations

 
         bool destroy_wait_ = false;
         cond destroy_wait_c_;
 
         bool destroy_wait_ = false;
         cond destroy_wait_c_;

@@ -94,22 +92,7 @@ class rpcc : private connection_delegate {
         request dup_req_;
         int xid_rep_done_ = -1;
 
         request dup_req_;
         int xid_rep_done_ = -1;
 

-        int call1(proc_id_t proc, milliseconds to, string & rep, marshall & req);
-
-        template<class R>
-        inline int call_m(proc_id_t proc, milliseconds to, R & r, marshall && req) {
-            string rep;
-            int intret = call1(proc, to, rep, req);
-            if (intret < 0) return intret;
-            unmarshall u(rep, true, r);
-            if (u.okdone() != true) {
-                LOG << "rpcc::call_m: failed to unmarshall the reply.  You are probably "
-                    << "calling RPC 0x" << std::hex << proc << " with the wrong return type.";
-                VERIFY(0);
-                return rpc_protocol::unmarshall_reply_failure;
-            }
-            return intret;
-        }
+        int call_marshalled(const rpc_protocol::proc_t & proc, milliseconds to, string & rep, const marshall & req);

 
         bool got_pdu(const shared_ptr<connection> & c, const string & b);
 
 
         bool got_pdu(const shared_ptr<connection> & c, const string & b);
 

@@ -118,23 +101,34 @@ class rpcc : private connection_delegate {
         rpcc(const string & d);
         ~rpcc();
 
         rpcc(const string & d);
         ~rpcc();
 

-        nonce_t id() { return clt_nonce_; }
-

         int bind(milliseconds to = rpc::to_max);
 
         int bind(milliseconds to = rpc::to_max);
 

+        // Manages a cache of RPC connections.  Usage:
+        //     if (auto cl = rpcc::bind_cached(dst))
+        //         ret = cl->call(...);
+        // where the string dst has the form "host:port".  Because bind_cached()
+        // may block, callers should probably not hold mutexes.
+        static shared_ptr<rpcc> bind_cached(const string & destination);
+        static void unbind_cached(const string & destination);
+

         void set_reachable(bool r) { reachable_ = r; }
 
         void set_reachable(bool r) { reachable_ = r; }
 

-        void cancel();
+        void cancel(lock & m_lock);

 
         template<class P, class R, typename ...Args>
 
         template<class P, class R, typename ...Args>

-        inline int call(proc_t<P> proc, R & r, const Args & ... args) {
+        inline int call(const rpc_protocol::proc_checked_t<P> & proc, R & r, const Args & ... args) {

             return call_timeout(proc, rpc::to_max, r, args...);
         }
 
         template<class P, class R, typename ...Args>
             return call_timeout(proc, rpc::to_max, r, args...);
         }
 
         template<class P, class R, typename ...Args>

-        inline int call_timeout(proc_t<P> proc, milliseconds to, R & r, const Args & ... args) {
+        inline int call_timeout(const rpc_protocol::proc_checked_t<P> & proc, milliseconds to, R & r, const Args & ... args) {

             static_assert(is_valid_call<P, R, Args...>::value, "RPC called with incorrect argument types");
             static_assert(is_valid_call<P, R, Args...>::value, "RPC called with incorrect argument types");

-            return call_m(proc.id, to, r, std::forward<marshall>(marshall(args...)));
+            string rep;
+            int intret = call_marshalled(proc, to, rep, marshall(args...));
+            if (intret >= 0) {
+                VERIFY(unmarshall(rep, true, r).okdone()); // guaranteed by static type checking
+            }
+            return intret;

         }
 };
 
         }
 };
 

@@ -142,8 +136,6 @@ class rpcc : private connection_delegate {
 class rpcs : private connection_delegate {
     private:
         using proc_id_t = rpc_protocol::proc_id_t;
 class rpcs : private connection_delegate {
     private:
         using proc_id_t = rpc_protocol::proc_id_t;

-        template <class S>
-        using proc_t = rpc_protocol::proc_t<S>;

         using nonce_t = rpc_protocol::nonce_t;
         using xid_t = rpc_protocol::xid_t;
 
         using nonce_t = rpc_protocol::nonce_t;
         using xid_t = rpc_protocol::xid_t;
 

@@ -193,7 +185,7 @@ class rpcs : private connection_delegate {
 
         void dispatch(shared_ptr<connection> c, const string & buf);
 
 
         void dispatch(shared_ptr<connection> c, const string & buf);
 

-        unique_ptr<thread_pool> dispatchpool_{new thread_pool(6, false)};
+        unique_ptr<thread_pool> dispatchpool_{new thread_pool(6)};

         unique_ptr<connection_listener> listener_;
 
         // RPC handler for clients binding
         unique_ptr<connection_listener> listener_;
 
         // RPC handler for clients binding

@@ -208,7 +200,8 @@ class rpcs : private connection_delegate {
 
         void set_reachable(bool r) { reachable_ = r; }
 
 
         void set_reachable(bool r) { reachable_ = r; }
 

-        template<class P, class F, class C=void> inline void reg(proc_t<P> proc, F f, C *c=nullptr) {
+        template<class P, class F, class C=void>
+        inline void reg(const rpc_protocol::proc_checked_t<P> & proc, F f, C *c=nullptr) {

             static_assert(is_valid_registration<P, F>::value, "RPC handler registered with incorrect argument types");
             struct ReturnOnFailure {
                 static inline int unmarshall_args_failure() {
             static_assert(is_valid_registration<P, F>::value, "RPC handler registered with incorrect argument types");
             struct ReturnOnFailure {
                 static inline int unmarshall_args_failure() {