anchor.diff:  
       {noreply, State#state{is_connected=Connected,
                             was_connected=WasConnected,
  -                          graph=Graph}};
  +                          graph=Graph,
  +                          tree=Tree}};
   
   handle_info(Msg, State) ->
       _ = lager:warning("Unhandled messages: ~p", [Msg]),
  
positive.code: 
      %% Get all running nodes, because we need the list of *everything*
      %% to analyze the graph for connectedness.
      ClientsFromMarathon = clients_from_marathon(),
      ServersFromMarathon = servers_from_marathon(),
      Nodes = sets:union(ClientsFromMarathon, ServersFromMarathon),
  
      %% Build the graph.
      Graph = digraph:new(),
  
      %% Get bucket name.
      BucketName = bucket_name(),
  
      GraphFun = fun({N, _, _}=Peer, OrphanedNodes) ->
                         Node = prefix(atom_to_list(N)),
                         try
                             Result = erlcloud_s3:get_object(BucketName, Node),
                             Body = proplists:get_value(content, Result, undefined),
                             case Body of
                                 undefined ->
                                     OrphanedNodes;
                                 _ ->
                                     Membership = binary_to_term(Body),
                                     case Membership of
                                         [N] ->
                                             populate_graph(N, [], Graph),
                                             [Peer|OrphanedNodes];
                                         _ ->
                                             populate_graph(N, Membership, Graph),
                                             OrphanedNodes
                                     end
                             end
                         catch
                             _:{aws_error, Error} ->
                                 populate_graph(N, [], Graph),
                                 lager:info("Could not get graph object; ~p", [Error]),
                                 OrphanedNodes
                         end
                 end,
  
      Orphaned = sets:fold(GraphFun, [], Nodes),
  
      {SymmetricViews, VisitedNames} = breath_first(node(), Graph, ordsets:new()),
      AllNodesVisited = sets:size(Nodes) == length(VisitedNames),
  
negative.code:     [Name|node_names(T)].
  
  %% @private
  populate_graph(Nodes, Graph) ->
      %% Get bucket name.
      BucketName = bucket_name(),
  
      lists:foldl(
          fun(Node, OrphanedNodes) ->
              File = prefix(atom_to_list(Node)),
              try
                  Result = erlcloud_s3:get_object(BucketName, File),
                  Body = proplists:get_value(content, Result, undefined),
                  case Body of
                      undefined ->
                          OrphanedNodes;
                      _ ->
                          Membership = binary_to_term(Body),
                          case Membership of
                              [Node] ->
                                  add_edges(Node, [], Graph),
                                  [Node|OrphanedNodes];
                              _ ->
                                  add_edges(Node, Membership, Graph),
                                  OrphanedNodes
                          end
                  end
              catch
                  _:{aws_error, Error} ->
                      add_edges(Node, [], Graph),
                      lager:info("Could not get graph object; ~p", [Error]),
                      OrphanedNodes
              end
          end,
          [],
          Nodes
      ).
  
  %% @private
  populate_tree(Root, Nodes, Tree) ->
      DebugTree = plumtree_broadcast:debug_get_tree(Root, Nodes),
      lists:foreach(
          fun({Node, Peers}) ->
              case Peers of
                  down ->
                      add_edges(Node, [], Tree);
                  {Eager, _Lazy} ->
                      add_edges(Node, Eager, Tree)
              end
          end,
          DebugTree
      ).
  
  %% @private
  add_edges(Name, Membership, Graph) ->
      %% Add node to graph.
      digraph:add_vertex(Graph, Name),
  
      lists:foldl(
          fun(N, _) ->
              %% Add node to graph.
              digraph:add_vertex(Graph, N),
  
              %% Add edge to graph.
              digraph:add_edge(Graph, Name, N)
          end,
          Graph,
          Membership
      ).
  