Global destructor clean-ups and python test fixes

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

diff --git a/handle.h b/handle.h
index ecd8884..e569002 100644 (file)
--- a/handle.h
+++ b/handle.h
@@ -1,79 +1,32 @@
-// manage a cache of RPC connections.
-// assuming cid is a std::string holding the
-// host:port of the RPC server you want
-// to talk to:
-//
-// handle h(cid);
-// rpcc *cl = h.safebind();
-// if(cl){
-//   ret = cl->call(...);
-// } else {
-//   bind() failed
-// }
-//
-// if the calling program has not contacted
-// cid before, safebind() will create a new
-// connection, call bind(), and return
-// an rpcc*, or 0 if bind() failed. if the
-// program has previously contacted cid,
-// safebind() just returns the previously
-// created rpcc*. best not to hold any
-// mutexes while calling safebind().
-
 #ifndef handle_h
 #define handle_h
 
-#include <string>
-#include <vector>
-#include "rpc.h"
+#include "types.h"
+#include "rpc/rpc.h"
 
-struct hinfo {
-  rpcc *cl;
-  int refcnt;
-  bool del;
-  std::string m;
-  pthread_mutex_t cl_mutex;
-};
+// Manage a cache of RPC connections.  Typical usage:
+//     handle h(dst);
+//     rpc_protocol::status ret = rpc_protocol::bind_failure;
+//     if (rpcc *cl = h.safebind())
+//         ret = cl->call(...);
+// assuming dst is a string holding the host:port of the RPC server you want to
+// talk to.
+//
+// If the calling program has not contacted dst before, safebind() will create
+// a new connection, call bind(), and return an rpcc*, or 0 if bind() failed.
+// if the program has previously contacted dst, safebind() just returns the
+// previously created rpcc*.  Because safebind() may block, callers should
+// probably not hold mutexes.
 
 class handle {
- private:
-  struct hinfo *h;
- public:
-  handle(std::string m);
-  ~handle();
-  /* safebind will try to bind with the rpc server on the first call.
-   * Since bind may block, the caller probably should not hold a mutex
-   * when calling safebind.
-   *
-   * return: 
-   *   if the first safebind succeeded, all later calls would return
-   *   a rpcc object; otherwise, all later calls would return NULL.
-   *
-   * Example:
-   *   handle h(dst);
-   *   XXX_protocol::status ret;
-   *   if (h.safebind()) {
-   *     ret = h.safebind()->call(...);
-   *   }
-   *   if (!h.safebind() || ret != XXX_protocol::OK) {
-   *     // handle failure
-   *   }
-   */
-  rpcc *safebind();
-};
-
-class handle_mgr {
- private:
-  pthread_mutex_t handle_mutex;
-  std::map<std::string, struct hinfo *> hmap;
- public:
-  handle_mgr();
-  struct hinfo *get_handle(std::string m);
-  void done_handle(struct hinfo *h);
-  void delete_handle(std::string m);
-  void delete_handle_wo(std::string m);
+    private:
+        shared_ptr<class hinfo> h;
+        const string destination_;
+    public:
+        handle(const string & destination);
+        rpcc *safebind();
+        void invalidate();
+        static void shutdown();
 };
 
-extern class handle_mgr mgr;
-
 #endif