rsm.h

   1 // replicated state machine interface.
   2
   3 #ifndef rsm_h
   4 #define rsm_h
   5
   6 #include <string>
   7 #include <vector>
   8 #include "rsm_protocol.h"
   9 #include "rsm_state_transfer.h"
  10 #include "rpc.h"
  11 #include <arpa/inet.h>
  12 #include "config.h"
  13
  14
  15 class rsm : public config_view_change {
  16     private:
  17         void reg1(int proc, handler *);
  18     protected:
  19         std::map<int, handler *> procs;
  20         config *cfg;
  21         class rsm_state_transfer *stf;
  22         rpcs *rsmrpc;
  23         // On slave: expected viewstamp of next invoke request
  24         // On primary: viewstamp for the next request from rsm_client
  25         viewstamp myvs;
  26         viewstamp last_myvs;   // Viewstamp of the last executed request
  27         std::string primary;
  28         bool insync;
  29         bool inviewchange;
  30         unsigned vid_commit;  // Latest view id that is known to rsm layer
  31         unsigned vid_insync;  // The view id that this node is synchronizing for
  32         std::vector<std::string> backups;   // A list of unsynchronized backups
  33
  34         // For testing purposes
  35         rpcs *testsvr;
  36         bool partitioned;
  37         bool dopartition;
  38         bool break1;
  39         bool break2;
  40
  41
  42         rsm_client_protocol::status client_members(int i,
  43                 std::vector<std::string> &r);
  44         rsm_protocol::status invoke(int proc, viewstamp vs, std::string mreq,
  45                 int &dummy);
  46         rsm_protocol::status transferreq(std::string src, viewstamp last, unsigned vid,
  47                 rsm_protocol::transferres &r);
  48         rsm_protocol::status transferdonereq(std::string m, unsigned vid, int &);
  49         rsm_protocol::status joinreq(std::string src, viewstamp last,
  50                 rsm_protocol::joinres &r);
  51         rsm_test_protocol::status test_net_repairreq(int heal, int &r);
  52         rsm_test_protocol::status breakpointreq(int b, int &r);
  53
  54         mutex rsm_mutex;
  55         mutex invoke_mutex;
  56         cond recovery_cond;
  57         cond sync_cond;
  58
  59         void execute(int procno, std::string req, std::string &r);
  60         rsm_client_protocol::status client_invoke(int procno, std::string req,
  61                 std::string &r);
  62         bool statetransfer(std::string m);
  63         bool statetransferdone(std::string m);
  64         bool join(std::string m);
  65         void set_primary(unsigned vid);
  66         std::string find_highest(viewstamp &vs, std::string &m, unsigned &vid);
  67         bool sync_with_backups();
  68         bool sync_with_primary();
  69         void net_repair_wo(bool heal);
  70         void breakpoint1();
  71         void breakpoint2();
  72         void partition1();
  73         void commit_change_wo(unsigned vid);
  74     public:
  75         rsm (std::string _first, std::string _me);
  76         ~rsm() {};
  77
  78         bool amiprimary();
  79         void set_state_transfer(rsm_state_transfer *_stf) { stf = _stf; };
  80         void recovery();
  81         void commit_change(unsigned vid);
  82
  83         template<class S, class A1, class R>
  84         void reg(int proc, S*, int (S::*meth)(const A1 a1, R &));
  85         template<class S, class A1, class A2, class R>
  86         void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2, R &));
  87         template<class S, class A1, class A2, class A3, class R>
  88         void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2,
  89                     const A3 a3, R &));
  90         template<class S, class A1, class A2, class A3, class A4, class R>
  91         void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2,
  92                     const A3 a3, const A4 a4, R &));
  93         template<class S, class A1, class A2, class A3, class A4, class A5, class R>
  94         void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2,
  95                     const A3 a3, const A4 a4, const A5 a5, R &));
  96 };
  97
  98 template<class S, class A1, class R>
  99 void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, R & r)) {
 100   class h1 : public handler {
 101   private:
 102     S * sob;
 103     int (S::*meth)(const A1 a1, R & r);
 104   public:
 105   h1(S *xsob, int (S::*xmeth)(const A1 a1, R & r))
 106       : sob(xsob), meth(xmeth) { }
 107     int fn(unmarshall &args, marshall &ret) {
 108       A1 a1;
 109       R r;
 110       args >> a1;
 111       VERIFY(args.okdone());
 112       int b = (sob->*meth)(a1,r);
 113       ret << r;
 114       return b;
 115     }
 116   };
 117   reg1(proc, new h1(sob, meth));
 118 }
 119
 120 template<class S, class A1, class A2, class R>
 121 void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2, R & r)) {
 122  class h1 : public handler {
 123   private:
 124     S * sob;
 125     int (S::*meth)(const A1 a1, const A2 a2, R & r);
 126   public:
 127   h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, R & r))
 128     : sob(xsob), meth(xmeth) { }
 129     int fn(unmarshall &args, marshall &ret) {
 130       A1 a1;
 131       A2 a2;
 132       R r;
 133       args >> a1;
 134       args >> a2;
 135       VERIFY(args.okdone());
 136       int b = (sob->*meth)(a1,a2,r);
 137       ret << r;
 138       return b;
 139     }
 140   };
 141   reg1(proc, new h1(sob, meth));
 142 }
 143
 144 template<class S, class A1, class A2, class A3, class R>
 145 void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2,
 146              const A3 a3, R & r)) {
 147  class h1 : public handler {
 148   private:
 149     S * sob;
 150     int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, R & r);
 151   public:
 152   h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3, R & r))
 153     : sob(xsob), meth(xmeth) { }
 154     int fn(unmarshall &args, marshall &ret) {
 155       A1 a1;
 156       A2 a2;
 157       A3 a3;
 158       R r;
 159       args >> a1;
 160       args >> a2;
 161       args >> a3;
 162       VERIFY(args.okdone());
 163       int b = (sob->*meth)(a1,a2,a3,r);
 164       ret << r;
 165       return b;
 166     }
 167   };
 168   reg1(proc, new h1(sob, meth));
 169 }
 170
 171 template<class S, class A1, class A2, class A3, class A4, class R>
 172 void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2,
 173              const A3 a3, const A4 a4, R & r)) {
 174  class h1 : public handler {
 175   private:
 176     S * sob;
 177     int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, const A4 a4, R & r);
 178   public:
 179   h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3,
 180             const A4 a4, R & r))
 181     : sob(xsob), meth(xmeth) { }
 182     int fn(unmarshall &args, marshall &ret) {
 183       A1 a1;
 184       A2 a2;
 185       A3 a3;
 186       A4 a4;
 187       R r;
 188       args >> a1;
 189       args >> a2;
 190       args >> a3;
 191       args >> a4;
 192       VERIFY(args.okdone());
 193       int b = (sob->*meth)(a1,a2,a3,a4,r);
 194       ret << r;
 195       return b;
 196     }
 197   };
 198   reg1(proc, new h1(sob, meth));
 199 }
 200
 201
 202 template<class S, class A1, class A2, class A3, class A4, class A5, class R> void
 203   rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2,
 204              const A3 a3, const A4 a4,
 205              const A5 a5, R & r))
 206 {
 207  class h1 : public handler {
 208   private:
 209     S * sob;
 210     int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, const A4 a4,
 211        const A5 a5, R & r);
 212   public:
 213   h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3,
 214             const A4 a4, const A5 a5, R & r))
 215     : sob(xsob), meth(xmeth) { }
 216     int fn(unmarshall &args, marshall &ret) {
 217       A1 a1;
 218       A2 a2;
 219       A3 a3;
 220       A4 a4;
 221       A5 a5;
 222       R r;
 223       args >> a1;
 224       args >> a2;
 225       args >> a3;
 226       args >> a4;
 227       VERIFY(args.okdone());
 228       int b = (sob->*meth)(a1,a2,a3,a4,a5,r);
 229       ret << r;
 230       return b;
 231     }
 232   };
 233   reg1(proc, new h1(sob, meth));
 234 }
 235
 236 #endif /* rsm_h */