anchor.diff:      schedule_tree_refresh(),
   
       {noreply, State#state{out_links=OutLinks}};
  +
  +handle_info(distance, #state{pending=Pending,
  +                             membership=Membership,
  +                             connections=Connections0}=State) ->
  +    %% Establish any new connections.
  +    Connections = establish_connections(Pending,
  +                                        Membership,
  +                                        Connections0),
  +
  +    %% Record time.
  +    SourceTime = erlang:timestamp(),
  +
  +    %% Send distance requests.
  +    SourceNode = partisan_peer_service_manager:myself(),
  +
  +    lists:foreach(fun(Peer) ->
  +                do_send_message(Peer,
  +                                ?MEMBERSHIP_PROTOCOL_CHANNEL,
  +                                ?DEFAULT_PARTITION_KEY,
  +                                {ping, SourceNode, Peer, SourceTime},
  +                                Connections)
  +        end, Membership),
  +
  +    schedule_distance(),
  +
  +    {noreply, State#state{connections=Connections}};
   
   handle_info(periodic, #state{pending=Pending,
                                membership_strategy=MembershipStrategy,
  
positive.code:     MembershipStrategy = partisan_config:get(membership_strategy),
      {ok, Membership, MembershipStrategyState} = MembershipStrategy:init(Actor),
  
      {ok, #state{actor=Actor,
                  pending=[],
                  vclock=VClock,
                  interposition_funs=dict:new(),
                  connections=Connections,
                  sync_joins=[],
                  up_functions=dict:new(),
                  down_functions=dict:new(),
  
negative.code:     Connections.
  
  %% @private
  handle_message({ping, SourceNode, DestinationNode, SourceTime},
                 #state{pending=Pending,
                        connections=Connections0,
                        membership=Membership}=State) ->
      %% Establish any new connections.
      Connections = establish_connections(Pending,
                                          Membership,
                                          Connections0),
  
      %% Send ping response.
      do_send_message(SourceNode,
                      ?MEMBERSHIP_PROTOCOL_CHANNEL,
                      ?DEFAULT_PARTITION_KEY,
                      {pong, SourceNode, DestinationNode, SourceTime},
                      Connections),
  
      {reply, ok, State#state{connections=Connections}};
  handle_message({pong, SourceNode, DestinationNode, SourceTime},
                 #state{distance_metrics=DistanceMetrics0}=State) ->
      %% Compute difference.
      ArrivalTime = erlang:timestamp(),
      Difference = timer:now_diff(ArrivalTime, SourceTime),
      
      case partisan_config:get(tracing, ?TRACING) of 
          true ->
              lager:info("Updating distance metric for node ~p => ~p communication: ~p", [SourceNode, DestinationNode, Difference]);
          false ->
              ok
      end,
                          
      %% Update differences.
      DistanceMetrics = dict:store(DestinationNode, Difference, DistanceMetrics0),
  
      {reply, ok, State#state{distance_metrics=DistanceMetrics}};
  handle_message({protocol, ProtocolMessage},
                 #state{pending=Pending,
                        connections=Connections0,
  