log.cc

   1 #include "log.h"
   2 #include "paxos.h"
   3
   4 // Paxos must maintain some durable state (i.e., that survives power
   5 // failures) to run Paxos correct.  This module implements a log with
   6 // all durable state to run Paxos.  Since the values chosen correspond
   7 // to views, the log contains all views since the beginning of time.
   8
   9 log::log(proposer_acceptor *_acc, string _me) : pxs (_acc) {
  10     name = "paxos-" + _me + ".log";
  11     logread();
  12 }
  13
  14 void log::logread(void) {
  15     ifstream from(name);
  16     string type;
  17     unsigned instance;
  18
  19     LOG("logread");
  20     while (from >> type) {
  21         if (type == "done") {
  22             string v;
  23             from >> instance;
  24             from.get();
  25             getline(from, v);
  26             pxs->values[instance] = v;
  27             pxs->instance_h = instance;
  28             LOG("logread: instance: " << instance << " w. v = " <<
  29                     pxs->values[instance]);
  30             pxs->v_a.clear();
  31             pxs->n_h.n = 0;
  32             pxs->n_a.n = 0;
  33         } else if (type == "propseen") {
  34             from >> pxs->n_h.n >> pxs->n_h.m;
  35             LOG("logread: high update: " << pxs->n_h.n << "(" << pxs->n_h.m << ")");
  36         } else if (type == "accepted") {
  37             string v;
  38             from >> pxs->n_a.n >> pxs->n_a.m;
  39             from.get();
  40             getline(from, v);
  41             pxs->v_a = v;
  42             LOG("logread: prop update " << pxs->n_a.n << "(" << pxs->n_a.m << ") with v = " << pxs->v_a);
  43         } else {
  44             LOG("logread: unknown log record");
  45             VERIFY(0);
  46         }
  47     }
  48     from.close();
  49 }
  50
  51 string log::dump() {
  52     ifstream from(name);
  53     string res;
  54     string v;
  55     while (getline(from, v))
  56         res += v + "\n";
  57     from.close();
  58     return res;
  59 }
  60
  61 void log::restore(string s) {
  62     LOG("restore: " << s);
  63     ofstream f(name, std::ios::trunc);
  64     f << s;
  65     f.close();
  66 }
  67
  68 // XXX should be an atomic operation
  69 void log::loginstance(unsigned instance, string v) {
  70     ofstream f(name, std::ios::app);
  71     f << "done " << instance << " " << v << "\n";
  72     f.close();
  73 }
  74
  75 // an acceptor should call logprop(n_h) when it
  76 // receives a prepare to which it responds prepare_ok().
  77 void log::logprop(prop_t n_h) {
  78     ofstream f(name, std::ios::app);
  79     f << "propseen " << n_h.n << " " << n_h.m << "\n";
  80     f.close();
  81 }
  82
  83 // an acceptor should call logaccept(n_a, v_a) when it
  84 // receives an accept RPC to which it replies accept_ok().
  85 void log::logaccept(prop_t n, string v) {
  86     ofstream f(name, std::ios::app);
  87     f << "accepted " << n.n << " " << n.m << " " << v << "\n";
  88     f.close();
  89 }