anchor.diff:      end.
   
   build_pool(Name, NSConfig, PoolConfig) ->
  -    case ns_port_server:get_port_server_param(NSConfig, memcached, "-p") of
  -        false ->
  -            ns_log:log(?MODULE, 0003, "missing memcached port"),
  -            error;
  -        {value, MemcachedPortStr} ->
  -            MP = list_to_integer(MemcachedPortStr),
  -            Nodes = ns_node_disco:nodes_actual_proper(),
  -            create_pool(Name, PoolConfig, MP, Nodes)
  +    case get_memcached_port(NSConfig) of
  +        error -> error;
  +        Port  -> Nodes = ns_node_disco:nodes_actual_proper(),
  +                 create_pool(Name, PoolConfig, Port, Nodes)
       end.
   
   create_pool(Name, PoolConfig, MemcachedPort, Nodes) ->
  
positive.code:               end,
                Nodes).
  
  % ------------------------------------------------
  
  search_bucket(_BucketId, []) -> false;
  
negative.code: handle_call({reconfig, Name, WantPoolConfig}, _From,
              #mc_pool{config = CurrPoolConfig} = State) ->
      case WantPoolConfig =:= CurrPoolConfig of
          true  -> {reply, ok, State};
          false ->
              case build_pool(Name, ns_config:get(), WantPoolConfig) of
                  {ok, Pool} ->
                      ns_log:log(?MODULE, 0005, "reconfig: ~p",
                                 [Name]),
                      {reply, ok, Pool};
                  error ->
                      ns_log:log(?MODULE, 0002, "reconfig error: ~p",
                                 [Name]),
                      NoopPool = create(Name, [], [], []),
                      {reply, error, NoopPool}
              end
      end;
  
  handle_call({reconfig_nodes, Name, WantNodes}, From,
              #mc_pool{nodes = CurrNodes,
                       config = PoolConfig} = State) ->
      case WantNodes =:= CurrNodes of
          true  -> {reply, ok, State};
          false -> handle_call({reconfig, Name, PoolConfig}, From,
                               State#mc_pool{config = undefined})
      end;
  
  handle_call(_, _From, State) ->
  