anchor.diff:  
   %% @doc Wait until all nodes agree about all ownership views
   -spec wait_until_nodes_agree_about_ownership([node()]) -> boolean().
  -wait_until_nodes_agree_about_ownership([MainNode | _] = Nodes) ->
  +wait_until_nodes_agree_about_ownership(Nodes) ->
       SortedNodes = lists:usort(Nodes),
       true = lists:all(fun(Node) ->
           Res = wait_until(fun() ->
  -            case owners_according_to(Node, MainNode) of
  +            case sorted_ring_owners(Node) of
                   {ok, SortedNodes} ->
                       true;
                   _ ->
  
positive.code: %% @doc Build clusters out of the given node list
  -spec join_cluster(list(atom())) -> ok.
  join_cluster([MainNode | OtherNodes] = Nodes) ->
      %% Ensure nodes have non-overlapping rings according to the master node,
      %% also, each node should own its entire ring
      true = lists:all(fun(Node) ->
          case owners_according_to(Node, MainNode) of
              {ok, [Node]} ->
                  true;
              _ ->
                  false
          end
      end, Nodes),
  
      ok = case OtherNodes of
          [] ->
              %% no other nodes, nothing to join/plan/commit
              ok;
  
          _ ->
              %% Do a plan/commit staged join, instead of sequential joins
              ok = lists:foreach(fun(N) -> request_join(N, MainNode) end, OtherNodes),
              ok = wait_plan_ready(MainNode),
              ok = commit_plan(MainNode),
              ok = try_cluster_ready(Nodes)
      end,
  
      ok = wait_until_nodes_ready(Nodes),
  
  
negative.code:         error ->
              usage();
  
          {ok, [_SingleNode]} ->
              io:format("Single-node cluster, nothing to join"),
              halt();
  
          {ok, Nodes} ->
              io:format("Starting clustering of nodes ~p~n", [Nodes]),
              lists:foreach(fun(N) -> erlang:set_cookie(N, antidote) end, Nodes),
  