anchor.diff:  call(Node, Call) ->
       gen_server:call({?MODULE, Node}, Call).
   
  -do_in_bucket(State, Bucket, Fun) ->
  -    case connect(State) of
  -        {ok, Sock} ->
  -            State1 = State#state{sock=Sock},
  -            %% TODO: real multi-tenancy
  -            case Bucket of
  -                "default" ->
  -                    {reply, catch Fun(Sock), State1};
  -                _ ->
  -                    {reply, {memcached_error, {mc_status_key_enoent, []}},
  -                     State1}
  -            end;
  -        E ->
  -            {reply, {could_not_connect, E}, State}
  -    end.
  +do_in_bucket(_Sock, Bucket, Fun) ->
  +    %% TODO: real multi-tenancy
  +    case Bucket of
  +        "default" ->
  +            Fun();
  +        _ ->
  +            {memcached_error, {mc_status_key_enoent, []}}
  +    end.
  +    %% case mc_client_binary:select_bucket(Sock, Bucket) of
  +    %%     ok ->
  +    %%         Fun();
  +    %%     R ->
  +    %%         R
  +    %% end.
   
   map_vbucket_state("active") -> active;
   map_vbucket_state("replica") -> replica;
  
positive.code:     Reply = unimplemented,
      {reply, Reply, State};
  handle_call({delete_vbucket, Bucket, VBucket}, _From, State) ->
      do_in_bucket(State, Bucket,
                   fun(Sock) ->
                           mc_client_binary:delete_vbucket(
                             Sock, VBucket)
                   end);
  handle_call(list_buckets, _From, State) ->
      Reply = {ok, ["default"]},
      {reply, Reply, State};
  handle_call({set_vbucket_state, Bucket, VBucket, VBState}, _From, State) ->
      do_in_bucket(State, Bucket,
                   fun(Sock) ->
                           mc_client_binary:set_vbucket_state(
                             Sock, VBucket,
                             atom_to_list(VBState))
                   end);
  handle_call({stats, Bucket, Key}, _From, State) ->
      do_in_bucket(State, Bucket,
                   fun (Sock) ->
                           mc_client_binary:stats(Sock, Key)
                   end).
  
  handle_cast(undefined, undefined) ->
      undefined.
  
  handle_info(connect, State) ->
      case connect(State) of
          {ok, Sock} ->
              {noreply, State#state{sock=Sock}};
          _ ->
              timer:send_after(500, connect),
              {noreply, State}
      end.
  
  terminate(Reason, State) ->
      error_logger:error_msg("~p:terminate(~p, ~p)~n",
  
negative.code: -export([start_link/0]).
  -export([init/1, handle_call/3, handle_cast/2,
           handle_info/2, terminate/2, code_change/3]).
  
  -record(state, {sock}).
  
  