anchor.diff:      {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_ring,Ring},State=#state{update_tick=Tick}) ->
  +    %% Whenever there's a change to the ring, we try and update our
  +    %% localized view of "the world". However, ring updates can happen
  +    %% very often, and large rings change *a lot*. For this reason,
  +    %% we only want to update the ring every so often. So once we've
  +    %% updated the ring, a tick flag is set indicating that we can't
  +    %% update the ring any more until it's cleared.
  +    case Tick of
  +        false -> {noreply,update_ring(State,Ring)};
  +        true -> {noreply,State}
  +    end;
  +
  +handle_cast (update_ring,State) ->
  +    {ok,Ring}=riak_core_ring_manager:get_my_ring(),
  +    {noreply,update_ring(State,Ring)};
   
   handle_cast ({update_services,Services},State) ->
       {noreply,update_services(State,Services)}.
  
positive.code:           ring        :: riak_core_ring:riak_core_ring(),
            partitions  :: [tuple()],
            nodes       :: [tuple()],
            update      :: reference()
          }).
  
  %% hack: periodically update the ring with itself
  -define(INTERVAL, 3000).
  
  %% delay used after a ring update
  -define(RING_UPDATE_DELAY, 500).
  
  %% ===================================================================
  %% Public API
  
negative.code: %% 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 (clear_update_tick,State) ->
      {noreply,State#state{update_tick=false}};
  
  handle_info (_,State) ->
      {noreply,State}.
  