anchor.diff:               {ok, reference()} | {error, reference(),  any()}).
   repair(#read_parameter{quorum = ReadQuorum,
                          req_id = ReqId}, Redundancies, Metadata, Callback) ->
  +    Ref    = make_ref(),
       From   = self(),
       AddrId = Metadata#?METADATA.addr_id,
       Key    = Metadata#?METADATA.key,
  
positive.code: %%--------------------------------------------------------------------
  %% @doc Compare local-metadata with remote-metadata
  %% @private
  -spec(compare(pid(), pid(), atom(), #state{}) ->
               ok).
  compare(Pid, RPCKey, Node, #state{metadata = #?METADATA{addr_id = AddrId,
                                                          key     = Key,
                                                          clock   = Clock}}) ->
      Ret = case rpc:nb_yield(RPCKey, ?DEF_REQ_TIMEOUT) of
                {value, {ok, #?METADATA{clock = RemoteClock}}} when Clock == RemoteClock ->
                    ok;
  
negative.code:                           can_read_repair = true}) ->
                spawn(fun() ->
                              RPCKey = rpc:async_call(
                                         Node, leo_storage_handler_object,
                                         head, [AddrId, Key]),
                              compare(Ref, From, RPCKey, Node, Params)
                      end);
           (#redundant_node{}) ->
                void
        end, Redundancies),
      loop(ReadQuorum, Ref, From, NumOfNodes, {ReqId, Key, []}, Callback).
  
  
  %% @doc Waiting for messages (compare a metadata)
  %%
  -spec(loop(reference(), integer(), pid(), list(), tuple(), function()) ->
               ok).
  loop(0,_Ref,_From,_NumOfNodes, {_,_,_E}, Callback) ->
      Callback(ok);
  loop(R,_Ref,_From, NumOfNodes, {_,_, E}, Callback) when (NumOfNodes - R) < length(E) ->
      Callback({error, E});
  loop(R, Ref, From, NumOfNodes, {ReqId, Key, E} = Args, Callback) ->
      receive
          {Ref, ok} ->
              loop(R-1, Ref, From, NumOfNodes, Args, Callback);
          {Ref, {error, {Node, Cause}}} ->
              loop(R,   Ref, From, NumOfNodes, {ReqId, Key, [{Node, Cause}|E]}, Callback)
      after
          ?DEF_REQ_TIMEOUT ->
              case (R >= 0) of
  