Fixed a race condition!

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

diff --git a/rsm.h b/rsm.h
index 87734e1..8fdf2d5 100644 (file)
--- a/rsm.h
+++ b/rsm.h
@@ -3,74 +3,72 @@
 #ifndef rsm_h
 #define rsm_h
 
 #ifndef rsm_h
 #define rsm_h
 

-#include <string>
-#include <vector>
+#include "types.h"

 #include "rsm_protocol.h"
 #include "rsm_protocol.h"

-#include "rsm_state_transfer.h"

 #include "rpc/rpc.h"
 #include <arpa/inet.h>
 #include "config.h"
 
 #include "rpc/rpc.h"
 #include <arpa/inet.h>
 #include "config.h"
 

+class rsm_state_transfer {
+    public:
+        virtual string marshal_state() = 0;
+        virtual void unmarshal_state(const string &) = 0;
+        virtual ~rsm_state_transfer() {}
+};
+

 class rsm : public config_view_change {
     private:
         void reg1(int proc, handler *);
     protected:
 class rsm : public config_view_change {
     private:
         void reg1(int proc, handler *);
     protected:

-        std::map<int, handler *> procs;
-        config *cfg;
-        class rsm_state_transfer *stf;
+        map<int, handler *> procs;
+        unique_ptr<config> cfg;
+        rsm_state_transfer *stf = nullptr;

         rpcs *rsmrpc;
         // On slave: expected viewstamp of next invoke request
         // On primary: viewstamp for the next request from rsm_client
         rpcs *rsmrpc;
         // On slave: expected viewstamp of next invoke request
         // On primary: viewstamp for the next request from rsm_client

-        viewstamp myvs;
-        viewstamp last_myvs;   // Viewstamp of the last executed request
-        std::string primary;
+        viewstamp last_myvs{0, 0};   // Viewstamp of the last executed request
+        viewstamp myvs{0, 1};
+        string primary;

         bool insync;
         bool inviewchange;
         unsigned vid_commit;  // Latest view id that is known to rsm layer
         unsigned vid_insync;  // The view id that this node is synchronizing for
         bool insync;
         bool inviewchange;
         unsigned vid_commit;  // Latest view id that is known to rsm layer
         unsigned vid_insync;  // The view id that this node is synchronizing for

-        std::vector<std::string> backups;   // A list of unsynchronized backups
+        vector<string> backups;   // A list of unsynchronized backups

 
         // For testing purposes
 
         // For testing purposes

-        rpcs *testsvr;
+        unique_ptr<rpcs> testsvr;

         bool partitioned;
         bool dopartition;
         bool break1;
         bool break2;
 
         bool partitioned;
         bool dopartition;
         bool break1;
         bool break2;
 

-
-        rsm_client_protocol::status client_members(std::vector<std::string> &r, int i);
-        rsm_protocol::status invoke(int &, int proc, viewstamp vs, std::string mreq);
-        rsm_protocol::status transferreq(rsm_protocol::transferres &r, std::string src,
+        rsm_client_protocol::status client_members(vector<string> &r, int i);
+        rsm_protocol::status invoke(int &, int proc, viewstamp vs, const string & mreq);
+        rsm_protocol::status transferreq(rsm_protocol::transferres &r, const string & src,

                 viewstamp last, unsigned vid);
                 viewstamp last, unsigned vid);

-        rsm_protocol::status transferdonereq(int &, std::string m, unsigned vid);
-        rsm_protocol::status joinreq(rsm_protocol::joinres &r, std::string src,
-                viewstamp last);
-        rsm_test_protocol::status test_net_repairreq(int &r, int heal);
-        rsm_test_protocol::status breakpointreq(int &r, int b);
+        rsm_protocol::status transferdonereq(int &, const string & m, unsigned vid);
+        rsm_protocol::status joinreq(string & log, const string & src, viewstamp last);
+        rsm_test_protocol::status test_net_repairreq(rsm_test_protocol::status &r, int heal);
+        rsm_test_protocol::status breakpointreq(rsm_test_protocol::status &r, int b);

 
 

-        std::mutex rsm_mutex;
-        std::mutex invoke_mutex;
-        std::condition_variable recovery_cond;
-        std::condition_variable sync_cond;
+        mutex rsm_mutex, invoke_mutex;
+        cond recovery_cond, sync_cond;

 
 

-        void execute(int procno, std::string req, std::string &r);
-        rsm_client_protocol::status client_invoke(std::string &r, int procno,
-                std::string req);
-        bool statetransfer(std::string m);
-        bool statetransferdone(std::string m);
-        bool join(std::string m);
+        void execute(int procno, const string & req, string & r);
+        rsm_client_protocol::status client_invoke(string & r, int procno, const string & req);
+        bool statetransfer(const string & m, lock & rsm_mutex_lock);
+        bool statetransferdone(const string & m, lock & rsm_mutex_lock);
+        bool join(const string & m, lock & rsm_mutex_lock);

         void set_primary(unsigned vid);
         void set_primary(unsigned vid);

-        std::string find_highest(viewstamp &vs, std::string &m, unsigned &vid);
-        bool sync_with_backups();
-        bool sync_with_primary();
-        void net_repair_wo(bool heal);
+        bool sync_with_backups(lock & rsm_mutex_lock);
+        bool sync_with_primary(lock & rsm_mutex_lock);
+        void net_repair(bool heal, lock & rsm_mutex_lock);

         void breakpoint1();
         void breakpoint2();
         void breakpoint1();
         void breakpoint2();

-        void partition1();
-        void commit_change_wo(unsigned vid);
+        void partition1(lock & rsm_mutex_lock);
+        void commit_change(unsigned vid, lock & rsm_mutex_lock);

     public:
     public:

-        rsm (std::string _first, std::string _me);
-        ~rsm() {}
+        rsm (const string & _first, const string & _me);

 
         bool amiprimary();
         void set_state_transfer(rsm_state_transfer *_stf) { stf = _stf; }
 
         bool amiprimary();
         void set_state_transfer(rsm_state_transfer *_stf) { stf = _stf; }

@@ -78,6 +76,8 @@ class rsm : public config_view_change {
         void commit_change(unsigned vid);
 
         template<class F, class C=void> void reg(int proc, F f, C *c=nullptr);
         void commit_change(unsigned vid);
 
         template<class F, class C=void> void reg(int proc, F f, C *c=nullptr);

+
+        void start();

 };
 
 template<class F, class C> void rsm::reg(int proc, F f, C *c) {
 };
 
 template<class F, class C> void rsm::reg(int proc, F f, C *c) {