rsm.h

// replicated state machine interface.

#ifndef rsm_h
#define rsm_h

#include <string>
#include <vector>
#include "rsm_protocol.h"
#include "rsm_state_transfer.h"
#include "rpc.h"
#include <arpa/inet.h>
#include "config.h"
#include <map>
#include <set>
//#include "connection_handler.cc"


class rsm : public config_view_change {
private:
    void reg1(int proc, handler *);
    std::map<long long, std::string> state_map;
    pthread_mutex_t state_transfer_mutex;

protected:
    std::map<int, handler *> procs;
    config *cfg;
    std::set<std::string> transfer_set;
    class rsm_state_transfer *stf;

    rpcs *rsmrpc;
    viewstamp myvs;
    viewstamp last_myvs;
    std::string primary;
    bool insync;
    bool inviewchange;
    unsigned nbackup;

    // For testing purposes
    rpcs *testsvr;
    bool partitioned;
    bool dopartition;
    bool break1;
    bool break2;


    rsm_client_protocol::status client_members(int i,
            std::vector<std::string> &r);

    rsm_protocol::status invoke(int proc, viewstamp vs, std::string mreq,
            int &dummy);

    rsm_protocol::status transferreq(std::string src, viewstamp last,
            rsm_protocol::transferres &r);

    rsm_protocol::status transferdonereq(std::string m, int &r);

    rsm_protocol::status joinreq(std::string src, viewstamp last,
            rsm_protocol::joinres &r);

    rsm_test_protocol::status test_net_repairreq(int heal, int &r);

    rsm_test_protocol::status breakpointreq(int b, int &r);

    pthread_mutex_t rsm_mutex;
    pthread_mutex_t invoke_mutex;
    pthread_cond_t recovery_cond;
    pthread_cond_t sync_cond;
    pthread_cond_t join_cond;

    std::string execute(int procno, std::string req);

    rsm_client_protocol::status client_invoke(int procno, std::string req,
            std::string &r);

    bool statetransfer(std::string m);

    bool statetransferdone(std::string m);

    bool join(std::string m);

    void set_primary();

    std::string find_highest(viewstamp &vs, std::string &m, unsigned &vid);

    bool sync_with_backups();

    bool sync_with_primary();

    bool amiprimary_wo();

    void net_repair_wo(bool heal);

    void breakpoint1();

    void breakpoint2();

    void partition1();

public:
    rsm(std::string _first, std::string _me);

    ~rsm() {
    };

    bool amiprimary();

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

    void recovery();

    void commit_change();

    template<class S, class A1, class R>
    void reg(int proc, S *, int (S::*meth)(const A1 a1, R &));

    template<class S, class A1, class A2, class R>
    void reg(int proc, S *, int (S::*meth)(const A1 a1, const A2 a2, R &));

    template<class S, class A1, class A2, class A3, class R>
    void reg(int proc, S *, int (S::*meth)(const A1 a1, const A2 a2,
            const A3 a3, R &));

    template<class S, class A1, class A2, class A3, class A4, class R>
    void reg(int proc, S *, int (S::*meth)(const A1 a1, const A2 a2,
            const A3 a3, const A4 a4, R &));

    template<class S, class A1, class A2, class A3, class A4, class A5, class R>
    void reg(int proc, S *, int (S::*meth)(const A1 a1, const A2 a2,
            const A3 a3, const A4 a4,
            const A5 a5, R &));
};

template<class S, class A1, class R>
void
rsm::reg(int proc, S *sob, int (S::*meth)(const A1 a1, R &r)) {
    class h1 : public handler {
    private:
        S *sob;

        int (S::*meth)(const A1 a1, R &r);

    public:
        h1(S *xsob, int (S::*xmeth)(const A1 a1, R &r))
                : sob(xsob), meth(xmeth) {
        }

        int fn(unmarshall &args, marshall &ret) {
            A1 a1;
            R r;
            args >> a1;
            assert(args.okdone());
            int b = (sob->*meth)(a1, r);
            ret << r;
            return b;
        }
    };
    reg1(proc, new h1(sob, meth));
}

template<class S, class A1, class A2, class R>
void
rsm::reg(int proc, S *sob, int (S::*meth)(const A1 a1, const A2 a2, R &r)) {
    class h1 : public handler {
    private:
        S *sob;

        int (S::*meth)(const A1 a1, const A2 a2, R &r);

    public:
        h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, R &r))
                : sob(xsob), meth(xmeth) {
        }

        int fn(unmarshall &args, marshall &ret) {
            A1 a1;
            A2 a2;
            R r;
            args >> a1;
            args >> a2;
            assert(args.okdone());
            int b = (sob->*meth)(a1, a2, r);
            ret << r;
            return b;
        }
    };
    reg1(proc, new h1(sob, meth));
}

template<class S, class A1, class A2, class A3, class R>
void
rsm::reg(int proc, S *sob, int (S::*meth)(const A1 a1, const A2 a2,
        const A3 a3, R &r)) {
    class h1 : public handler {
    private:
        S *sob;

        int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, R &r);

    public:
        h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3, R &r))
                : sob(xsob), meth(xmeth) {
        }

        int fn(unmarshall &args, marshall &ret) {
            A1 a1;
            A2 a2;
            A3 a3;
            R r;
            args >> a1;
            args >> a2;
            args >> a3;
            assert(args.okdone());
            int b = (sob->*meth)(a1, a2, a3, r);
            ret << r;
            return b;
        }
    };
    reg1(proc, new h1(sob, meth));
}

template<class S, class A1, class A2, class A3, class A4, class R>
void
rsm::reg(int proc, S *sob, int (S::*meth)(const A1 a1, const A2 a2,
        const A3 a3, const A4 a4, R &r)) {
    class h1 : public handler {
    private:
        S *sob;

        int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, const A4 a4, R &r);

    public:
        h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3,
                const A4 a4, R &r))
                : sob(xsob), meth(xmeth) {
        }

        int fn(unmarshall &args, marshall &ret) {
            A1 a1;
            A2 a2;
            A3 a3;
            A4 a4;
            R r;
            args >> a1;
            args >> a2;
            args >> a3;
            args >> a4;
            assert(args.okdone());
            int b = (sob->*meth)(a1, a2, a3, a4, r);
            ret << r;
            return b;
        }
    };
    reg1(proc, new h1(sob, meth));
}


template<class S, class A1, class A2, class A3, class A4, class A5, class R>
void
rsm::reg(int proc, S *sob, int (S::*meth)(const A1 a1, const A2 a2,
        const A3 a3, const A4 a4,
        const A5 a5, R &r)) {
    class h1 : public handler {
    private:
        S *sob;

        int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, const A4 a4,
                const A5 a5, R &r);

    public:
        h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3,
                const A4 a4, const A5 a5, R &r))
                : sob(xsob), meth(xmeth) {
        }

        int fn(unmarshall &args, marshall &ret) {
            A1 a1;
            A2 a2;
            A3 a3;
            A4 a4;
            A5 a5;
            R r;
            args >> a1;
            args >> a2;
            args >> a3;
            args >> a4;
            assert(args.okdone());
            int b = (sob->*meth)(a1, a2, a3, a4, a5, r);
            ret << r;
            return b;
        }
    };
    reg1(proc, new h1(sob, meth));
}

#endif /* rsm_h */