rsm_client.h

#ifndef rsm_client_h
#define rsm_client_h

#include "rpc.h"
#include "rsm_protocol.h"
#include <string>
#include <vector>

//
// rsm client interface.
//
// The client stubs package up an rpc, and then call the invoke procedure
// on the replicated state machine passing the RPC as an argument.  This way
// the replicated state machine isn't service specific; any server can use it.
//

class rsm_client {
 protected:
  std::string primary;
  std::vector<std::string> known_mems;
  pthread_mutex_t rsm_client_mutex;

  void primary_failure();
  bool init_members();

 public:
  rsm_client(std::string dst);
  rsm_protocol::status invoke(int proc, std::string req, std::string &rep);

  template<class R, class A1>
  int call(unsigned int proc, const A1 &a1, R &r);

  template<class R, class A1, class A2>
  int call(unsigned int proc, const A1 &a1, const A2 &a2, R &r);

  template<class R, class A1, class A2, class A3>
  int call(unsigned int proc, const A1 &a1, const A2 &a2, const A3 &a3, R &r);

  template<class R, class A1, class A2, class A3, class A4>
  int call(unsigned int proc, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, R &r);

  template<class R, class A1, class A2, class A3, class A4, class A5>
  int call(unsigned int proc, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, R &r);

 private:
  template<class R>
  int call_m(unsigned int proc, marshall &req, R &r);
};

template<class R> int
rsm_client::call_m(unsigned int proc, marshall &req, R &r)
{
  std::string rep;
  std::string res;

  int intret = invoke(proc, req.str(), rep);
  VERIFY(intret == rsm_client_protocol::OK);

  unmarshall u(rep);

  u >> intret;
  if (intret < 0) return intret;

  u >> res;
  if (!u.okdone()) {
    fprintf(stderr, "rsm_client::call_m: failed to unmarshall the reply.\n"
                    "You probably forgot to set the reply string in "
                    "rsm::client_invoke, or you may call RPC 0x%x with wrong return "
                    "type.\n", proc);
    VERIFY(0);
    return rpc_const::unmarshal_reply_failure;
  }

  unmarshall u1(res);
  u1 >> r;
  if(!u1.okdone()) {
    fprintf(stderr, "rsm_client::call_m: failed to unmarshall the reply.\n"
                    "You are probably calling RPC 0x%x with wrong return "
                    "type.\n", proc);
    VERIFY(0);
    return rpc_const::unmarshal_reply_failure;
  }
  return intret;
}

template<class R, class A1> int
rsm_client::call(unsigned int proc, const A1 &a1, R &r)
{
  marshall m;
  m << a1;
  return call_m(proc, m, r);
}

template<class R, class A1, class A2> int
rsm_client::call(unsigned int proc, const A1 &a1, const A2 &a2, R &r)
{
  marshall m;
  m << a1;
  m << a2;
  return call_m(proc, m, r);
}

template<class R, class A1, class A2, class A3> int
rsm_client::call(unsigned int proc, const A1 &a1, const A2 &a2, const A3 &a3, R &r)
{
  marshall m;
  std::string rep;
  std::string res;
  m << a1;
  m << a2;
  m << a3;
  return call_m(proc, m, r);
}

template<class R, class A1, class A2, class A3, class A4> int
rsm_client::call(unsigned int proc, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, R &r)
{
  marshall m;
  std::string rep;
  std::string res;
  m << a1;
  m << a2;
  m << a3;
  m << a4;
  return call_m(proc, m, r);
}

template<class R, class A1, class A2, class A3, class A4, class A5> int
rsm_client::call(unsigned int proc, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, R &r)
{
  marshall m;
  std::string rep;
  std::string res;
  m << a1;
  m << a2;
  m << a3;
  m << a4;
  m << a5;
  return call_m(proc, m, r);
}

#endif