anchor.diff:  %% misc. messages
   handle_info (ping_ring_nodes,State=#state{ring=Ring}) ->
       erlang:send_after(?INTERVAL,self(),ping_ring_nodes),
  +
  +    %% use the same ring we already have, just ping nodes again
       handle_cast({update_ring,Ring},State);
   
  -handle_info ({actually_update_ring,Ring},State) ->
  -    {noreply,update_ring(State,Ring)};
  +handle_info (clear_update_tick,State) ->
  +    {noreply,State#state{update_tick=false}};
   
   handle_info (_,State) ->
       {noreply,State}.
  
positive.code:     {reply,{ok,V,P},State}.
  
  %% calls that don't block and don't reply
  handle_cast ({update_ring,Ring},State=#state{update=TimerRef}) ->
      %% Whenever we receive a ring update, what we actually do is start
      %% a timer that will actually process the new ring after a certain
      %% period of time has elapsed. We do this because ring updates come
      %% in spurts and we don't want to process all of those changes, we
      %% only want the last change.
  
      %% cancel the current delay timer, and wait a bit longer
      erlang:cancel_timer(TimerRef),
  
      %% setup the new timer to actually update with the new ring
      NewRef=erlang:send_after(?RING_UPDATE_DELAY,
                               self(),
                               {actually_update_ring,Ring}),
      {noreply,State#state{update=NewRef}};
  
  handle_cast ({update_services,Services},State) ->
      {noreply,update_services(State,Services)}.
  
negative.code:          get_ring/0,
           get_nodes/0,
           get_services/0,
           get_partitions/0,
           force_update/0
          ]).
  
  %% gen_server callbacks
  