anchor.diff:  %% to determine capabilities through RPC to the node. If RPC fails, use
   %% default values. However, unresolved nodes will be marked as such and RPC
   %% re-attempted at the next server tick.
  -add_node(Node, Capabilities, State1) ->
  -    State2 = add_node2(Node, Capabilities, State1),
  -    filter_removed_caps(Node, Capabilities, State2).
  -
  -add_node2(Node, [], State=#state{unknown=Unknown}) ->
  +add_node(Node, [], State=#state{unknown=Unknown}) ->
       {Capabilities, Resolved} = query_capabilities(Node, State),
       Unknown2 = case Resolved of
                      true ->
  
positive.code:                            {Cap, ResolvedAcc and Resv}
                     end, true, Registered).
  
  query_capability(Node, Known, Capability, DefaultSup, LegacyVar) ->
      case dict:find(Capability, Known) of
          {ok, Supported} ->
              {true, {Capability, Supported}};
          error ->
              query_capability(Node, Capability, DefaultSup, LegacyVar)
      end.
  
  query_capability(_, Capability, DefaultSup, undefined) ->
      Default = {Capability, [DefaultSup]},
      {true, Default};
  query_capability(Node, Capability, DefaultSup, {App, Var, Map}) ->
      Default = {Capability, [DefaultSup]},
      Result = riak_core_util:safe_rpc(Node, application, get_env, [App, Var]),
      case Result of
          {badrpc, _} ->
              {false, Default};
  
negative.code:                 last_ring_id :: term(),
                  supported :: [{node(), [{capability(), [mode()]}]}],
                  unknown :: [node()],
                  negotiated :: [{capability(), mode()}],
                  rpc_fn =
                      fun(Node, App, Var) ->
                          riak_core_util:safe_rpc(Node, application, get_env, [App, Var])
                      end
                 }).
  
  -define(ETS, riak_capability_ets).
  