anchor.diff:      {reply, unhandled, State}.
   
   
  +complete_connection_phase({ok, Sock}, Bucket) ->
  +    case ensure_bucket(Sock, Bucket) of
  +        ok ->
  +            {ok, Sock};
  +        EnsureBucketError ->
  +            {ensure_bucket_failed, EnsureBucketError}
  +    end;
  +complete_connection_phase(Err, _Bucket) ->
  +    Err.
  +
  +handle_cast({connect_done, WorkersCount, RV}, #state{bucket = Bucket,
  +                                                     status = OldStatus} = State) ->
  +    gen_event:notify(buckets_events, {started, Bucket}),
  +
  +    case complete_connection_phase(RV, Bucket) of
  +        {ok, Sock} ->
  +            connecting = OldStatus,
  +
  +            ?log_info("Main ns_memcached connection established: ~p", [RV]),
  +
  +            {ok, Timer} = timer:send_interval(?CHECK_WARMUP_INTERVAL, check_started),
  +            Self = self(),
  +            Self ! check_started,
  +            erlang:process_flag(trap_exit, true),
  +
  +            InitialState = State#state{
  +                             timer = Timer,
  +                             start_time = os:timestamp(),
  +                             sock = Sock,
  +                             status = init
  +                            },
  +            [proc_lib:spawn_link(erlang, apply, [fun worker_init/2, [Self, InitialState]])
  +             || _ <- lists:seq(1, WorkersCount)],
  +            {noreply, InitialState};
  +        Error ->
  +            ?log_info("Failed to establish ns_memcached connection: ~p", [RV]),
  +            {stop, Error}
  +    end;
  +
   handle_cast(start_completed, #state{start_time=Start,
                                       bucket=Bucket} = State) ->
       ?user_log(1, "Bucket ~p loaded on node ~p in ~p seconds.",
  
positive.code:           fast_calls_queue = impossible :: queue(),
            heavy_calls_queue = impossible :: queue(),
            very_heavy_calls_queue = impossible :: queue(),
            status :: init | connected | warmed,
            start_time::tuple(),
            bucket::nonempty_string(),
            sock::port(),
            timer::any(),
            work_requests = []
           }).
  
negative.code:     Reply = [{connected, Connected},
               {warmed, Warmed}],
      {reply, Reply, State};
  handle_call(connected_and_list_vbuckets, _From, #state{status = Status} = State)
    when Status =:= init orelse Status =:= connecting ->
      {reply, warming_up, State};
  handle_call(connected_and_list_vbuckets, From, State) ->
      handle_call(list_vbuckets, From, State);
  