anchor.diff:  %% client/server topology, which requires all nodes talk to every other
   %% node to correctly compute the overlay.
   %%
  -cluster(Node, Nodes, Manager) when is_list(Nodes) ->
  +cluster({Name, _Node} = Myself, Nodes, Options) when is_list(Nodes) ->
  +    Manager = proplists:get_value(partisan_peer_service_manager, Options),
  +
  +    Servers = proplists:get_value(servers, Options, []),
  +    Clients = proplists:get_value(clients, Options, []),
  +
  +    AmIServer = lists:member(Name, Servers),
  +    AmIClient = lists:member(Name, Clients),
  +
       OtherNodes = case Manager of
                        partisan_default_peer_service_manager ->
  -                         Nodes -- [Node];
  +                         %% Omit just ourselves.
  +                         omit([Name], Nodes);
                        partisan_client_server_peer_service_manager ->
  -                         case Node of
  -                             {server, _} ->
  -                                 Nodes -- [Node];
  -                             _ ->
  -                                 Server = lists:keyfind(server, 1, Nodes),
  -                                 [Server]
  +                         case {AmIServer, AmIClient} of
  +                             {true, false} ->
  +                                %% If I'm a server, I connect to both
  +                                %% clients and servers!
  +                                omit([Name], Nodes);
  +                             {false, true} ->
  +                                %% I'm a client, pick servers.
  +                                omit(Clients, Nodes);
  +                             {_, _} ->
  +                                omit([Name], Nodes)
                            end;
                        partisan_hyparview_peer_service_manager ->
  -                         case Node of
  -                             {server, _} ->
  -                                 [];
  -                             _ ->
  -                                 Server = lists:keyfind(server, 1, Nodes),
  -                                 [Server]
  -                         end
  +                        case {AmIServer, AmIClient} of
  +                            {true, false} ->
  +                               %% If I'm a server, I connect to both
  +                               %% clients and servers!
  +                               omit([Name], Nodes);
  +                            {false, true} ->
  +                               %% I'm a client, pick servers.
  +                               omit(Clients, Nodes);
  +                            {_, _} ->
  +                               omit([Name], Nodes)
  +                        end
                    end,
  -    lists:map(fun(OtherNode) -> cluster(Node, OtherNode) end, OtherNodes).
  +    lists:map(fun(OtherNode) -> cluster(Myself, OtherNode) end, OtherNodes).
   cluster({_, Node}, {_, OtherNode}) ->
       PeerPort = rpc:call(OtherNode,
                           partisan_config,
  
positive.code:     lists:map(StartFun, Nodes),
  
      ct:pal("Clustering nodes."),
      Manager = proplists:get_value(partisan_peer_service_manager, Options),
      lists:map(fun(Node) -> cluster(Node, Nodes, Manager) end, Nodes),
  
      ct:pal("Partisan fully initialized."),
  
      Nodes.
  
  %% @private
  codepath() ->
  
negative.code:     Manager = partisan_client_server_peer_service_manager,
  
      %% Specify servers.
      Servers = [server_1, server_2],
  
      %% Specify clients.
      Clients = client_list(?CLIENT_NUMBER),
  