anchor.diff:  %% @spec put_key(riak_object:bucket(), riak_object:key()) -> ok
   %% @doc Add Key to the keylist for Bucket.
   put_key(Bucket,Key) -> 
  -    gen_fsm:send_event(?MODULE,{add,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_fsm:send_event(?MODULE,{del,Bucket,Key}).
  -
  -%% @private
  -start_link() -> gen_fsm:start_link({local, ?MODULE}, ?MODULE, [], []).
  +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, waiting, #state{ops=dict:new(),ring=undefined}, ?FLUSH_INTERVAL}.
  -
  -%% @private
  -waiting(timeout, State=#state{ops=Ops}) ->
  -    NewState = ensure_ring(State),
  -    do_write_all(Ops, NewState#state.ring),
  -    {next_state, waiting, NewState#state{ops=dict:new()}, ?FLUSH_INTERVAL};
  -
  -%% @private
  -waiting({OpType,Bucket,Key}, State=#state{ops=Ops}) ->
  +    {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}];
  +        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),
  -            {next_state,waiting,NewState#state{ops=dict:new()},?FLUSH_INTERVAL};
  +            {noreply, NewState#state{ops=dict:new()}};
           false ->
  -            {next_state,waiting,
  -             NewState#state{ops=dict:store(BucketFrag,OpList,Ops)},
  -             ?FLUSH_INTERVAL}
  +            {noreply,NewState#state{ops=dict:store(BucketFrag,OpList,Ops)}}
       end.
   
   %% @private
  
positive.code: 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}.
  
negative.code: 
  %% @doc Management of keylists for Riak buckets.
  -module(riak_bucketkeys).
  -behavior(gen_server2).
  
  -export([put_key/2,
           del_key/2,
           get_keys/1]).
  -export([start_link/0,
           init/1,
           handle_call/3,
           handle_cast/2,
           handle_info/2,
           code_change/3,
           terminate/2]).
  
  -define(BUCK, ' bucketkeys').
  -define(QSIZE, 1000).
  -define(NFRAGS, 1024).
  -define(FLUSH_INTERVAL, 1000).
  -record(state, {ops, ring, tref}).
  
  % State.ops is a dict, keys are bucketname atoms, vals are lists of operations,
  % where operations are tuples of {Op::[add|del], riak_object:key()}
  