Actually, you know, build.

[invirt/third/libt4.git] / rsm_client.cc

diff --git a/rsm_client.cc b/rsm_client.cc
index ee25564..2e6d33d 100644 (file)
--- a/rsm_client.cc
+++ b/rsm_client.cc
@@ -3,20 +3,20 @@
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <handle.h>
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <handle.h>

+#include <unistd.h>

 #include "lang/verify.h"
 #include "lang/verify.h"

-
+#include "lock.h"

 
 rsm_client::rsm_client(std::string dst) {
     printf("create rsm_client\n");
     std::vector<std::string> mems;
 
 
 rsm_client::rsm_client(std::string dst) {
     printf("create rsm_client\n");
     std::vector<std::string> mems;
 

-    pthread_mutex_init(&rsm_client_mutex, NULL);

     sockaddr_in dstsock;
     make_sockaddr(dst.c_str(), &dstsock);
     primary = dst;
 
     {
     sockaddr_in dstsock;
     make_sockaddr(dst.c_str(), &dstsock);
     primary = dst;
 
     {

-        ScopedLock ml(&rsm_client_mutex);
+        lock ml(rsm_client_mutex);

         VERIFY (init_members());
     }
     printf("rsm_client: done\n");
         VERIFY (init_members());
     }
     printf("rsm_client: done\n");

@@ -28,18 +28,18 @@ void rsm_client::primary_failure() {
     known_mems.pop_back();
 }
 
     known_mems.pop_back();
 }
 

-rsm_protocol::status rsm_client::invoke(int proc, std::string req, std::string &rep) {
-    int ret;
-    ScopedLock ml(&rsm_client_mutex);
+rsm_protocol::status rsm_client::invoke(int proc, std::string &rep, const std::string &req) {
+    int ret = 0;
+    lock ml(rsm_client_mutex);

     while (1) {
         printf("rsm_client::invoke proc %x primary %s\n", proc, primary.c_str());
         handle h(primary);
 
     while (1) {
         printf("rsm_client::invoke proc %x primary %s\n", proc, primary.c_str());
         handle h(primary);
 

-        VERIFY(pthread_mutex_unlock(&rsm_client_mutex)==0);
+        ml.unlock();

         rpcc *cl = h.safebind();
         if (cl)
         rpcc *cl = h.safebind();
         if (cl)

-            ret = cl->call(rsm_client_protocol::invoke, proc, req, rep, rpcc::to(5000));
-        VERIFY(pthread_mutex_lock(&rsm_client_mutex)==0);
+            ret = cl->call_timeout(rsm_client_protocol::invoke, rpcc::to(5000), rep, proc, req);
+        ml.lock();

 
         if (!cl)
             goto prim_fail;
 
         if (!cl)
             goto prim_fail;

@@ -70,14 +70,17 @@ prim_fail:
 bool rsm_client::init_members() {
     printf("rsm_client::init_members get members!\n");
     handle h(primary);
 bool rsm_client::init_members() {
     printf("rsm_client::init_members get members!\n");
     handle h(primary);

-    VERIFY(pthread_mutex_unlock(&rsm_client_mutex)==0);

     int ret;
     int ret;

-    rpcc *cl = h.safebind();
-    if (cl) {
-        ret = cl->call(rsm_client_protocol::members, 0, known_mems,
-                rpcc::to(1000));
+    rpcc *cl;
+    {
+        adopt_lock ml(rsm_client_mutex);
+        ml.unlock();
+        cl = h.safebind();
+        if (cl) {
+            ret = cl->call_timeout(rsm_client_protocol::members, rpcc::to(1000), known_mems, 0);
+        }
+        ml.lock();

     }
     }

-    VERIFY(pthread_mutex_lock(&rsm_client_mutex)==0);

     if (cl == 0 || ret != rsm_protocol::OK)
         return false;
     if (known_mems.size() < 1) {
     if (cl == 0 || ret != rsm_protocol::OK)
         return false;
     if (known_mems.size() < 1) {