/*--------GetInfo---------*/
//Started/Primary/Peering/GetInfo
GetInfo(my_context ctx)
{
  pg->generate_past_intervals();

  if (!prior_set.get())
    pg->build_prior(prior_set);

  get_infos();
  if (peer_info_requested.empty() 
  		&& !prior_set->pg_down) {
    post_event(GotInfo());
  }
}

void PG::generate_past_intervals() {
  interval_range // from start(last_epoch_clean) to
                 // end(curent osd map epoch)
}

  PG::PriorSet::PriorSet()
  {
    for (unsigned i=0; i<acting.size(); i++) {
      probe.insert();
    }

    for (unsigned i=0; i<up.size(); i++) {
      probe.insert();
    }

    for (past_intervals) {
      for (interval.acting.size()) {
        if (osdmap.is_up(o)) {
          // include past acting osds if they are up.
          probe.insert(so);
          up_now.insert(so);
        }
      }
    }
  }

void PG::RecoveryState::GetInfo::get_infos() 
{
  for (prior_set->probe) {
    context< RecoveryMachine >().send_query(
        pg_query_t::INFO);
  }
}

  GetInfo::react(const MNotifyRec& infoevt) 
  {
    if (pg->proc_replica_info()) {
      if (we got an new last_epoch_started) {
        //last_epoch_started moved forward, rebuilding prior
        pg->build_perior();
        get_infos();
      }
      //all requested info came back
      if (peer_info_requested.empty() && !prior_set->pg_down) {
        /*
        * make sure we have at least one !incomplete() osd from the
        * last rw interval.  the incomplete (backfilling) replicas
        * get a copy of the log, but they don't get all the object
        * updates, so they are insufficient to recover changes 
        * during that interval.
        */
        for (map<epoch_t,pg_interval_t>::reverse_iterator 
            p = pg->past_intervals.rbegin();
            p != pg->past_intervals.rend();
            ++p) { 
          /*
           * this mirrors the PriorSet calculation: we wait if we
           * don't have an up (AND !incomplete) node AND there are
           * nodes down that might be usable.
           */
          for (unsigned i=0; i<interval.acting.size(); i++) {
            check if there is any OSD is up & !incomplete 
          }
          if (!any_up_complete_now && any_down_now) {
            return discard_event();
          } 
        }
        post_event(GotInfo());
      }
    }
  }

  bool PG::proc_replica_info() 
  {
     assert(is_primary());
     peer_info[from] = oinfo;
     //used for pg recovery
     might_have_unfound.insert(from);
     
     if (new info) {
       update_heartbeat_peers();
     }
  }

//Started/Primary/Peering/GetLog"
PG::RecoveryState::GetLog::GetLog(my_context ctx)
{
  pg->choose_acting();
  
  // am i the best?
  if (auth_log_shard == pg->pg_whoami) {
    post_event(GotLog());
    return;
  }
  // how much?
  dout(10) << " requesting log from osd." << auth_log_shard << dendl;
  context<RecoveryMachine>().send_query(
    auth_log_shard,
    pg_query_t(
      pg_query_t::LOG,
      auth_log_shard.shard, pg->pg_whoami.shard,
      request_log_from, pg->info.history,
      pg->get_osdmap()->get_epoch()));
}

//1. find Authoritative History
//2. choose acting set
bool PG::choose_acting() 
{
  find_best_info();
  if (cant find best OSD who have authoritative log) {
  	return false;
  }
  calc_replicated_acting();
  //check if recoverable
  if (!(*recoverable_predicate)(have)) {
	want_acting.clear();
	dout(10) << "choose_acting failed, not recoverable" << dendl;
	return false;
  }
  //request pg_temp
  if (want != acting) {
    dout(10) << "choose_acting want " << want << " != acting " << acting
			   << ", requesting pg_temp change" << dendl;
    want_acting = want;
    if (want_acting == up) {
      osd->queue_want_pg_temp(info.pgid.pgid, empty);
    }
    osd->queue_want_pg_temp(info.pgid.pgid, want);
  }
}

/**
 * find_best_info
 *
 * Returns an iterator to the best info in infos sorted by:
 *  1) Prefer newer last_update
 *  2) Prefer longer tail if it brings another info into contiguity
 *  3) Prefer current primary
 */
PG::find_best_info() 
{
  must :max_last_epoch_started_found
        not incomplete
  
  prefer newer last_update
  prefer lognger tail
  prefer current primary
  
}

//calculate the desired acting set.
void PG::calc_replicated_acting()
{
  choose "size" number of candidates 
    up is the first choice then acting then all_info
  
  want = primary + up && no need backfill+ acting + all_info;
  acting_backfill = primary + up && need backfill + up && no need backfill;
  						+ acting + all_info;
  backfill = in up set need backfill;
}

PG::RecoveryState::GetLog::react(const GotLog&) 
{
  //when merge log, primary PG's missing objects is calculated
  //Auth_osd get its missing back in msg, it will be stored in peer_missing
  pg->proc_master_log(*context<RecoveryMachine>().get_cur_transaction(),
      msg->info, msg->log, msg->missing,auth_log_shard);
  return transit< GetMissing >();
}

PG::RecoveryState::GetMissing::GetMissing(my_context ctx)
{
  for (actingbackfill) {
    if (need backfill or dont need recovery) {
      continue;
    }
    // We pull the log from the peer's last_epoch_started to ensure we
    // get enough log to detect divergent updates.
    if (log_tail <= last_epoch_started) {
      // request log after last_epoch_started
      context< RecoveryMachine >().send_query();
    } else {
	    // request full log
      context< RecoveryMachine >().send_query();
    }
    peer_missing_requested.insert();
  }
  if (peer_missing_requested.empty()) {
    post_event(Activate(pg->get_osdmap()->get_epoch()));
  }
}

PG::RecoveryState::GetMissing::react(const MLogRec& logevt)
{
  peer_missing_requested.erase(logevt.from);
  //will add missing info to peer_missing
  pg->proc_replica_log();
  if (peer_missing_requested.empty()) {
    post_event(Activate(pg->get_osdmap()->get_epoch()));
  }
  return discard_event();
}