anchor.diff:  ensure_ring(State) -> State.
   
   %% @private
  -terminate(_,_,_) -> ok.
  -
  -%% @private
  -code_change(_OldVsn, StateName, State, _Extra) -> {ok, StateName, State}.
  -
  -%% @private
  -handle_event(_, _, StateData) -> {stop,badmsg,StateData}.
  -
  -%% @private
  -handle_sync_event(_, _, _, StateData) -> {stop,badmsg,StateData}.
  -
  -%% @private
  -handle_info({set_ring, Ring}, StateName, State) -> 
  -    {next_state, StateName, State#state{ring=Ring}, ?FLUSH_INTERVAL};
  -handle_info(_, _, StateData) -> {stop,badmsg,StateData}.
  +terminate(_,#state{tref=TRef}) -> timer:cancel(TRef), ok.
  +
  +%% @private
  +code_change(_OldVsn, State, _Extra) -> {ok, State}.
  +
  +%% @private
  +handle_info({set_ring, Ring}, State) -> {noreply, State#state{ring=Ring}};
  +handle_info(timeout, State=#state{ops=Ops}) ->
  +    NewState = ensure_ring(State),
  +    do_write_all(Ops, NewState#state.ring),
  +    {noreply, NewState#state{ops=dict:new()}};
  +handle_info(_,State) -> {stop,badmsg,State}.
  
positive.code: %% @private 
  all_frags(Bucket) when is_atom(Bucket) ->
      [atom_to_list(Bucket) ++ "-" ++ X || X <- [integer_to_list(I) || 
                                                    I <- lists:seq(0, ?NFRAGS-1)]].
  
  %% @private
  ensure_ring(State=#state{ring=undefined}) ->
      riak_ring_manager:subscribe(self()),
  
negative.code: %% @spec put_key(riak_object:bucket(), riak_object:key()) -> ok
  %% @doc Add Key to the keylist for Bucket.
  put_key(Bucket,Key) -> 
      gen_server2:cast(?MODULE,{add,Bucket,Key}).
  
  %% @spec del_key(riak_object:bucket(), riak_object:key()) -> ok
  %% @doc Remove Key from the keylist for Bucket.
  del_key(Bucket,Key) -> 
      gen_server2:cast(?MODULE,{del,Bucket,Key}).
  
  %% @private
  start_link() -> 
      gen_server2:start_link({local, ?MODULE}, ?MODULE, [], 
                             [{fullsweep_after, 0}]).
  
  %% @private
  init(_) -> 
      {ok, TRef} = timer:send_interval(1000, timeout),
      {ok, #state{ops=dict:new(),ring=undefined, tref=TRef}}.
  
  handle_call(_,_,State) -> {reply,no_call_support,State}.
  
  handle_cast({OpType,Bucket,Key},State=#state{ops=Ops}) ->
      BucketFrag = lists:flatten(
                     io_lib:format("~s-~b", 
                                   [Bucket, 
                                    erlang:phash2(Key) rem ?NFRAGS])),
      NewState = ensure_ring(State),
      OpList = case dict:find(BucketFrag, Ops) of
          error ->   [{OpType,Key}];
          {ok, L} -> [{OpType,Key}|L]
      end,
      case length(OpList) > ?QSIZE of
          true ->
              do_write_all(dict:store(BucketFrag, OpList, Ops), 
                           NewState#state.ring),
              {noreply, NewState#state{ops=dict:new()}};
          false ->
              {noreply,NewState#state{ops=dict:store(BucketFrag,OpList,Ops)}}
      end.
  
  %% @private
  