anchor.diff:  check_repairs(Repairs) ->
       Check =
           fun(R=#repair{minus_one_xfer=MOX, plus_one_xfer=POX}, Repairs2) ->
  -                MOX2 = maybe_retry(R, R#repair.minus_one, MOX),
  -                POX2 = maybe_retry(R, R#repair.plus_one, POX),
  +                Pairs = R#repair.pairs,
  +                MO = get_minus_one(Pairs),
  +                PO = get_plus_one(Pairs),
  +                MOX2 = maybe_retry(R, MO, MOX),
  +                POX2 = maybe_retry(R, PO, POX),
  +
                   if ?XFER_COMPLETE(MOX2) andalso ?XFER_COMPLETE(POX2) ->
                           Repairs2;
                      true ->
  
positive.code:     lists:keyreplace(Repair#repair.mod_partition, #repair.mod_partition,
                       Repairs, Repair).
  
  %% TODO: Need to kill the receivers for these xfers in case the cast
  %% doesn't reach the handoff mgr.
  kill_repairs(Repairs, Reason) ->
      Kill =
          fun(R) ->
                  {_,MOOwner} = R#repair.minus_one,
                  {_,POOwner} = R#repair.plus_one,
                  MOX = R#repair.minus_one_xfer,
                  POX = R#repair.plus_one_xfer,
                  MOModSrcTarget = MOX#xfer_status.mod_src_target,
  
negative.code: handle_call(get_tab, _From, State) ->
      {reply, ets:tab2list(State#state.idxtab), State};
  
  handle_call({repair, Service, {Mod,Partition}=ModPartition, FilterModFun},
              _From, State) ->
      #state{repairs=Repairs} = State,
  
      case get_repair(ModPartition, Repairs) of
          none ->
              {ok, Ring} = riak_core_ring_manager:get_my_ring(),
              Pairs = repair_pairs(Ring, Partition),
              UpNodes = riak_core_node_watcher:nodes(Service),
  
              case riak_core_ring:pending_changes(Ring) of
                      [] ->
                          case check_up(Pairs, UpNodes) of
                              true ->
                                  {MOP,_} = MinusOne = get_minus_one(Pairs),
                                  {POP,_} = PlusOne = get_plus_one(Pairs),
                                  riak_core_handoff_manager:xfer(MinusOne,
                                                                 ModPartition,
                                                                 FilterModFun),
                                  riak_core_handoff_manager:xfer(PlusOne,
                                                                 ModPartition,
                                                                 FilterModFun),
                                  MOXStatus = #xfer_status{status=pending,
                                                           mod_src_target={Mod, MOP, Partition}},
                                  POXStatus = #xfer_status{status=pending,
                                                           mod_src_target={Mod, POP, Partition}},
  
                                  Repair = #repair{mod_partition=ModPartition,
                                                   filter_mod_fun=FilterModFun,
                                                   pairs=Pairs,
                                                   minus_one_xfer=MOXStatus,
                                                   plus_one_xfer=POXStatus},
                                  Repairs2 = Repairs ++ [Repair],
                                  State2 = State#state{repairs=Repairs2},
                                  lager:debug("add repair ~p", [ModPartition]),
                                  {reply, {ok, Pairs}, State2};
                              {false, Down} ->
                                  {reply, {down, Down}, State}
                          end;
                      _ ->
                          {reply, ownership_change_in_progress, State}
                  end;
          Repair ->
              Pairs = Repair#repair.pairs,
              {reply, {ok, Pairs}, State}
      end;
  
  handle_call({repair_status, ModPartition}, _From, State) ->
  