anchor.diff:            fast_calls_queue = impossible :: queue(),
             heavy_calls_queue = impossible :: queue(),
             very_heavy_calls_queue = impossible :: queue(),
  -          status :: init | connected | warmed,
  +          status :: connecting | init | connected | warmed,
             start_time::tuple(),
             bucket::nonempty_string(),
  -          sock::port(),
  +          sock = still_connecting :: port() | still_connecting,
             timer::any(),
             work_requests = []
            }).
  
positive.code:     {noreply, State}.
  
  
  terminate(Reason, #state{bucket=Bucket, sock=Sock}) ->
      NsConfig = try ns_config:get()
                 catch T:E ->
  
negative.code:     {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.",
  