anchor.diff:      Info = {struct, [{etag, list_to_binary(ETag)} | PList]},
       reply_json(Req, Info).
   
  -is_healthy(InfoNode) ->
  -    not proplists:get_bool(down, InfoNode).
  -
   build_pool_info(Id, UserPassword, InfoLevel, LocalAddr) ->
       F = build_nodes_info_fun(menelaus_auth:check_auth(UserPassword), InfoLevel, LocalAddr),
       Nodes = [F(N, undefined) || N <- ns_node_disco:nodes_wanted()],
  
positive.code:                        end,
              KV = build_node_info(Config, WantENode, InfoNode, LocalAddr),
  
              Status = case is_healthy(InfoNode) of
                           true ->
                               case Bucket of
                                   undefined ->
                                       is_warming_up(WantENode, BucketNames);
                                   _ ->
                                       case lists:member(
                                              Bucket,
                                              proplists:get_value(
                                                active_buckets, InfoNode)) of
                                           true ->
                                               is_warming_up(WantENode, BucketNames);
                                           false ->
                                               <<"unhealthy">>
                                                   end
                               end;
                           false ->
                               <<"unhealthy">>
                      end,
              KV1 = [{clusterMembership,
                      atom_to_binary(
                        ns_cluster_membership:get_cluster_membership(
  
negative.code:     F = build_nodes_info_fun(true, normal, "127.0.0.1"),
      [F(N, undefined) || N <- ns_node_disco:nodes_wanted()].
  
  %% builds health/warmup status of given node (w.r.t. given Bucket if
  %% not undefined)
  build_node_status(Node, Bucket, InfoNode, BucketsAll) ->
      case proplists:get_bool(down, InfoNode) of
          false ->
              ReadyBuckets = proplists:get_value(ready_buckets, InfoNode),
              NodeBucketNames = ns_bucket:node_bucket_names(Node, BucketsAll),
              case Bucket of
                  undefined ->
                      case ordsets:is_subset(lists:sort(NodeBucketNames),
                                             lists:sort(ReadyBuckets)) of
                          true ->
                              <<"healthy">>;
                          false ->
                              <<"warmup">>
                      end;
                  _ ->
                      case lists:member(Bucket, ReadyBuckets) of
                          true ->
                              <<"healthy">>;
                          false ->
                              case lists:member(Bucket, NodeBucketNames) of
                                  true ->
                                      <<"warmup">>;
                                  false ->
                                      <<"unhealthy">>
                              end
                      end
              end;
          true ->
              <<"unhealthy">>
      end.
  
  build_nodes_info_fun(IncludeOtp, InfoLevel, LocalAddr) ->
      OtpCookie = list_to_binary(atom_to_list(ns_node_disco:cookie_get())),
      NodeStatuses = ns_doctor:get_nodes(),
      Config = ns_config:get(),
      BucketsAll = ns_bucket:get_buckets(Config),
      fun(WantENode, Bucket) ->
              InfoNode = case dict:find(WantENode, NodeStatuses) of
                             {ok, Info} -> Info;
  