anchor.diff:      ReadParameter_1 = ReadParameter#read_parameter{quorum = Quorum - 1},
       leo_storage_read_repairer:repair(ReadParameter_1, Redundancies, Metadata, Fun);
   
  -read_and_repair_2({error, not_found = Cause}, #read_parameter{key = _K}, []) ->
  +read_and_repair_2({error, not_found = Cause}, #read_parameter{key = _K}, _Redundancies) ->
       {error, Cause};
   read_and_repair_2({error, timeout = Cause}, #read_parameter{key = _K}, _Redundancies) ->
       ?output_warn("read_and_repair_2/3", _K, Cause),
       {error, Cause};
  -read_and_repair_2({error, Cause}, #read_parameter{key = _K}, []) ->
  +read_and_repair_2({error, Cause}, #read_parameter{key = _K}, _Redundancies) ->
       ?output_warn("read_and_repair_2/3", _K, Cause),
       {error, Cause};
  -
  -read_and_repair_2({error, Reason},
  -                  #read_parameter{key = _K,
  -                                  quorum = ReadQuorum} = ReadParameter, Redundancies) ->
  -    NumOfNodes = erlang:length([N || #redundant_node{node = N,
  -                                                     can_read_repair = true}
  -                                         <- Redundancies]),
  -    case (NumOfNodes >= ReadQuorum) of
  -        true ->
  -            read_and_repair(ReadParameter, Redundancies);
  -        false when Reason == not_found ->
  -            {error, not_found};
  -        false ->
  -            ?output_warn("read_and_repair_2/3", _K, Reason),
  -            {error, ?ERROR_COULD_NOT_GET_DATA}
  -    end;
   read_and_repair_2(_,_,_) ->
       {error, invalid_request}.
   
  
positive.code:     end;
  
  read_and_repair_1(ReadParameter,
                    [#redundant_node{node = Node}|_],_Redundancies) ->
      RPCKey = rpc:async_call(Node, ?MODULE, get, [ReadParameter, []]),
      Reply  = case rpc:nb_yield(RPCKey, ?DEF_REQ_TIMEOUT) of
                   {value, {ok, Meta, Bin}} ->
                       {ok, Meta, #?OBJECT{data = Bin}};
                   {value, {ok, match} = Ret} ->
  
negative.code:                   [#redundant_node{node = Node}|_], Redundancies) when Node == erlang:node() ->
      %% Retrieve an head of object,
      %%     then compare it with requested 'Etag'
      HeadRet =
          case leo_object_storage_api:head({AddrId, Key}) of
              {ok, MetaBin} ->
                  Metadata = binary_to_term(MetaBin),
                  case Metadata#?METADATA.checksum of
                      ETag ->
                          {ok, match};
                      _ ->
                          []
                  end;
              _ ->
                  []
          end,
  
      %% If the result is 'match', then response it,
      %% not the case, retrieve an object by key
      case HeadRet of
          {ok, match} = Reply ->
              Reply;
          _ ->
  