anchor.diff:            forward :: node(),
             handoff_node=none :: none | node(),
             pool_pid :: pid() | undefined,
  +          pool_config :: tuple() | undefined,
             manager_event_timer :: reference(),
             inactivity_timeout}).
   
  
positive.code:         {error, Reason} ->
              {stop, Reason};
          _ ->
              PoolPid = case lists:keyfind(pool, 1, Props) of
                  {pool, WorkerModule, PoolSize, WorkerArgs} ->
                      lager:debug("starting worker pool ~p with size of ~p~n",
                          [WorkerModule, PoolSize]),
                      {ok, Pid} = riak_core_vnode_worker_pool:start_link(WorkerModule,
                          PoolSize, Index, WorkerArgs, worker_props),
                      Pid;
                  _ -> undefined
              end,
              riak_core_handoff_manager:remove_exclusion(Mod, Index),
              Timeout = app_helper:get_env(riak_core, vnode_inactivity_timeout, ?DEFAULT_TIMEOUT),
              State = #state{index=Index, mod=Mod, modstate=ModState, forward=Forward,
                  inactivity_timeout=Timeout, pool_pid=PoolPid},
              lager:debug("vnode :: ~p/~p :: ~p~n", [Mod, Index, Forward]),
              {ok, active, State, InitialInactivityTimeout}
      end.
  
negative.code:     {reply, {Mode, Status}, StateName, State, State#state.inactivity_timeout}.
  
  
  handle_info({'EXIT', Pid, Reason},
              _StateName,
              State=#state{mod=Mod,
                           index=Index,
                           pool_pid=Pid,
                           pool_config=PoolConfig}) ->
      case Reason of
          Reason when Reason == normal; Reason == shutdown ->
              continue(State#state{pool_pid=undefined});
          _ ->
              lager:error("~p ~p worker pool crashed ~p\n", [Index, Mod, Reason]),
              {pool, WorkerModule, PoolSize, WorkerArgs}=PoolConfig,
              {ok, NewPoolPid} =
                  riak_core_vnode_worker_pool:start_link(WorkerModule,
                                                         PoolSize,
                                                         Index,
                                                         WorkerArgs,
                                                         worker_props),
              continue(State#state{pool_pid=NewPoolPid})
          end;
  
  handle_info(Info, _StateName,
              State=#state{mod=Mod,modstate={deleted, _},index=Index}) ->
  