anchor.diff:      OtpCookie = list_to_binary(atom_to_list(ns_node_disco:cookie_get())),
       WantENodes = ns_node_disco:nodes_wanted(),
       NodeStatuses = ns_doctor:get_nodes(),
  -    BucketsAll = expect_prop_value(buckets, MyPool),
  -    NodesBucketMemoryTotal =
  -        length(WantENodes) *
  -            lists:foldl(fun({_BucketName, BucketConfig}, Acc) ->
  -                                Acc + proplists:get_value(size_per_node, BucketConfig, 0)
  -                        end,
  -                        0,
  -                        BucketsAll),
  -    {ok, Stats} = stats_aggregator:get_stats(1),
  -    NodesBucketMemoryAllocated = case dict:find("bytes", Stats) of
  -        {ok, [Bytes]} -> Bytes;
  -        error -> 0
  -    end,
       Nodes =
           lists:map(
             fun(WantENode) ->
  
positive.code:                   Versions = proplists:get_value(version, InfoNode, []),
                    Version = proplists:get_value(ns_server, Versions, "unknown"),
                    OS = proplists:get_value(system_arch, InfoNode, "unknown"),
                    {UpSecs, {MemoryTotal, MemoryAlloced, _}} =
                        case InfoLevel of
                            normal ->
                                {proplists:get_value(wall_clock, InfoNode, 0),
                                 proplists:get_value(memory_data, InfoNode,
                                                     {0, 0, undefined})};
                            stable ->
                                % These stats are zero'ed so that
                                % successive calls will provide results
                                % that are comparable and appear stable as long
                                % the cluster is stable (health is stable, no-reconfigurations).
                                {0, {0, 0, undefined}}
                        end,
                    KV1 = [{hostname, list_to_binary(Host)},
                           {status, Status},
                           {uptime, list_to_binary(integer_to_list(UpSecs))},
                           {version, list_to_binary(Version)},
                           {os, list_to_binary(OS)},
                           {memoryTotal, erlang:trunc(MemoryTotal)},
                           {memoryFree, erlang:trunc(MemoryTotal - MemoryAlloced)},
                           {mcdMemoryReserved, erlang:trunc(NodesBucketMemoryTotal)},
                           {mcdMemoryAllocated, erlang:trunc(NodesBucketMemoryAllocated)},
                           {ports,
                            {struct, [{proxy, ProxyPort},
                                      {direct, DirectPort}]}}],
  
negative.code:                                   [PoolId, Id]};
                               ["pools", PoolId, "bucketsStreaming", Id] ->
                                   {auth_bucket_with_info, fun handle_bucket_info_streaming/5,
                                    [PoolId, Id]};
                               ["pools", PoolId, "bucketsStreamingConfig", Id] ->
                                   {auth_bucket_with_info, fun handle_bucket_info_streaming_config/5,
                                    [PoolId, Id]};
                               ["pools", PoolId, "buckets", Id, "stats"] ->
                                   {auth_bucket, fun menelaus_stats:handle_bucket_stats/3,
  