anchor.diff:  connect(State) ->
       case State#state.sock of
           undefined ->
  -            Config = ns_config:get(),
  -            Port = ns_config:search_node_prop(Config, memcached, port),
  -            error_logger:info_msg("ns_memcached connecting to memcached on port ~p~n", [Port]),
  -            {ok, Sock} = gen_tcp:connect("127.0.0.1", Port, [binary, {packet, 0}, {active, false}], 5000),
  -            Sock;
  +            try
  +                Config = ns_config:get(),
  +                Port = ns_config:search_node_prop(Config, memcached, port),
  +                gen_tcp:connect("127.0.0.1", Port, [binary, {packet, 0},
  +                                                    {active, false}], 5000)
  +            catch
  +                E ->
  +                    %% Retry after 500ms
  +                    timer:send_after(500, connect),
  +                    E
  +            end;
           Sock ->
  -            Sock
  +            {ok, Sock}
       end.
   
   connected() ->
  
positive.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}).
  
  
negative.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",
  