void Monitor::start_election()                                                   
{
  /*这条日志我们一般看不到*/
  dout(10) << "start_election" << dendl;
  wait_for_paxos_write();
  _reset();
  state = STATE_ELECTING;

  logger->inc(l_mon_num_elections);
  logger->inc(l_mon_election_call);

  cancel_probe_timeout();

  clog->info() << "mon." << name << " calling new monitor election\n";
  elector.call_election();
}

  void call_election() {                                                     
    start();
  }

void Elector::start()
{
  if (!participating) {
    dout(0) << "not starting new election -- not participating" << dendl;
    return;
  }
  dout(5) << "start -- can i be leader?" << dendl;

  acked_me.clear();
  classic_mons.clear();
  init();
  
  /*从稳定态进入选举态，需要将版本号从偶数往上抬，抬成奇数*/
  if (epoch % 2 == 0) 
    bump_epoch(epoch+1);  // odd == election cycle
  start_stamp = ceph_clock_now(g_ceph_context);
  electing_me = true;
  acked_me[mon->rank] = CEPH_FEATURES_ALL;
  leader_acked = -1;

  /*向每一个成员广播消息，提议开始重新选举*/
  for (unsigned i=0; i<mon->monmap->size(); ++i) {
    if ((int)i == mon->rank) continue;
    Message *m = new MMonElection(MMonElection::OP_PROPOSE, epoch, mon->monmap);
    mon->messenger->send_message(m, mon->monmap->get_inst(i));
  }              
  reset_timer();
}

  if (mon->rank < from) {
    // i would win over them.
    if (leader_acked >= 0) { // we already acked someone
      /*自己曾经认过怂，消息来源的mon还不如自己，直接不理，
       *来源的mon太弱，是不可能被自己承认的*/
      assert(leader_acked < from);  // and they still win, of course
      dout(5) << "no, we already acked " << leader_acked << dendl;
    } else {
      /*注意，electing_me记录了自己是否发出过选我为leader的请求
       *如果先后收到两个弱小者发来的选举请求，处理第一个的时候，本节点已经发出了选自己当leader的请求，
       *当第二个弱者消息到来的时候，没必要再发送选自己当leader的请求*/
      if (!electing_me) {
        mon->start_election();
      }
    }
  } else {
    // they would win over me
    if (leader_acked < 0 ||      // haven't acked anyone yet, or
        leader_acked > from ||   // they would win over who you did ack, or
        leader_acked == from) {  // this is the guy we're already deferring to
      defer(from);
    } else {
      // ignore them!
      dout(5) << "no, we already acked " << leader_acked << dendl;
    }
  }

    if (leader_acked < 0 ||      /*从未承认过别人，从未认过怂*/ 
        leader_acked > from ||   /*虽然承认过别人，认过怂，无奈这次来的更强大，所以还是得认怂，承认它*/
        leader_acked == from) {  
      defer(from);  /*defer函数的作用是认可对方可以当leader*/
    }else {
      /*曾经认可过更强者，不可能向不够强的mon发送认可，不理*/
      dout(5) << "no, we already acked " << leader_acked << dendl;
    }

void Elector::defer(int who)
{
  dout(5) << "defer to " << who << dendl;

  if (electing_me) {
    /*注意，认怂就要清零，哪怕曾竖起过大旗，要求别人选自己*/
    acked_me.clear();
    classic_mons.clear();
    electing_me = false;
  }

  // ack them
  leader_acked = who;
  ack_stamp = ceph_clock_now(g_ceph_context);
  /*发送OP_ACK承认对方可以当leader*/
  MMonElection *m = new MMonElection(MMonElection::OP_ACK, epoch, mon->monmap);
  m->sharing_bl = mon->get_supported_commands_bl();
  mon->messenger->send_message(m, mon->monmap->get_inst(who));
  
  // set a timer
  reset_timer(1.0);  // give the leader some extra time to declare victory
}

void Elector::handle_ack(MMonElection *m)
{                                                                                                                                                      
  dout(5) << "handle_ack from " << m->get_source() << dendl;
  int from = m->get_source().num();

  assert(m->epoch % 2 == 1); // election
  if (m->epoch > epoch) {
    dout(5) << "woah, that's a newer epoch, i must have rebooted.  bumping and re-starting!" << dendl;
    bump_epoch(m->epoch);
    start();
    m->put();
    return;
  }
  assert(m->epoch == epoch);
  uint64_t required_features = mon->get_required_features();
  if ((required_features ^ m->get_connection()->get_features()) &
      required_features) {
    dout(5) << " ignoring ack from mon" << from
            << " without required features" << dendl;
    return;
  }
  
  if (electing_me) {
    // thanks
    /*搜集到一枚承认，记录在acked_me*/
    acked_me[from] = m->get_connection()->get_features();
    if (!m->sharing_bl.length())
      classic_mons.insert(from);
    dout(5) << " so far i have " << acked_me << dendl;
    
    /*如果所有成员都承认了自己的leader地位，那么宣布获胜，调用victory*/
    if (acked_me.size() == mon->monmap->size()) {
      // if yes, shortcut to election finish
      victory();
    }
  } else {
    // ignore, i'm deferring already.
    assert(leader_acked >= 0);
  }
  
  m->put();
}  

void Elector::victory()
{

  /*选举过程完成，需要抬election_epoch，变成偶数*/
  assert(epoch % 2 == 1);  // election
  bump_epoch(epoch+1);     // is over!  
  // tell everyone!
  for (set<int>::iterator p = quorum.begin();
       p != quorum.end();
       ++p) {
    if (*p == mon->rank) continue;
    MMonElection *m = new MMonElection(MMonElection::OP_VICTORY, epoch, mon->monmap);
    m->quorum = quorum;
    m->quorum_features = features;
    m->sharing_bl = *cmds_bl;
    mon->messenger->send_message(m, mon->monmap->get_inst(*p));
  }    
  // tell monitor                                                  
  mon->win_election(epoch, quorum, features, cmds, cmdsize, &copy_classic_mons);
}

void Elector::handle_victory(MMonElection *m)
{
  ...
   bump_epoch(m->epoch) ;
   // they win
   mon->lose_election(epoch, m->quorum, from, m->quorum_features);
   ...
}