anchor.diff:      ets:update_counter(State#state.stats, total_revs, RevsCount),
       case State#state.listeners of
       [] ->
  -        % still waiting for the first listener to sen a request
  +        % still waiting for the first listener to send a request
           {noreply, State#state{current_seq=LastSeq,done=true}};
       _ ->
           {stop, normal, ok, State#state{current_seq=LastSeq}}
  
positive.code:     
  make_attachment_stub_receiver(Url, Headers, Name, Type, Length, Retries) ->
      %% start the process that receives attachment data from ibrowse
      Pid = spawn_link(fun() -> attachment_loop(nil) end),
      
      %% make the async request
      Options = [{stream_to, Pid}, {response_format, binary}],
      ReqId = case ibrowse:send_req(Url, Headers, get, [], Options, infinity) of
          {ibrowse_req_id, X} -> X;
          {error, _Reason} -> exit(attachment_request_failed)
      end,
  
negative.code:                     receive
                          {From, continue} -> 
                              %% normal case
                              attachment_loop(ReqId, Conn);
                          {From, fail} ->
                              %% error, failure code
                              ?LOG_ERROR(
                                  "streaming attachment failed with status ~p",
                                  [Status]),
                              catch ibrowse:stop_worker_process(Conn),
                              exit(attachment_request_failed);
                          {From, stop_ok} ->
                              %% stop looping, controller will start a new loop
                              catch ibrowse:stop_worker_process(Conn),
                              stop_ok
                      end
              end,
              attachment_loop(ReqId, Conn);
          {ibrowse_async_response, ReqId, {chunk_start,_}} ->
              attachment_loop(ReqId, Conn);
          {ibrowse_async_response, ReqId, chunk_end} ->
              attachment_loop(ReqId, Conn);
          {ibrowse_async_response, ReqId, {error, Err}} ->
              ?LOG_ERROR("streaming attachment failed with ~p", [Err]),
              catch ibrowse:stop_worker_process(Conn),
              exit(attachment_request_failed);
          {ibrowse_async_response, ReqId, Data} -> 
              receive {From, gimme_data} -> From ! {self(), Data} end,
              attachment_loop(ReqId, Conn);
          {ibrowse_async_response_end, ReqId} ->
              catch ibrowse:stop_worker_process(Conn),
              exit(normal)
      end.
  
  attachment_stub_converter(DbS, Id, Rev, {Name, {stub, Type, Length}}) ->
      #http_db{uri=DbUrl, headers=Headers} = DbS,
      {Pos, [RevId|_]} = Rev,
      Url = lists:flatten([DbUrl, url_encode(Id), "/", url_encode(?b2l(Name)),
          "?rev=", ?b2l(couch_doc:rev_to_str({Pos,RevId}))]),
      ?LOG_DEBUG("Attachment URL ~p", [Url]),
      {ok, RcvFun} = make_attachment_stub_receiver(Url, Headers, Name, 
          Type, Length),
  