anchor.diff:    reload_sync_servers(State, NewState),
     save_state(NewState),
   	{reply, {ok, NewState}, NewState#membership{config=Config}};
  -	
  -handle_call({share, NewState}, _From, State = #membership{config=Config}) ->
  -  % error_logger:info_msg("sharing state ~p ~p~n", [State#membership.config, NewState#membership.config]),
  -  case vector_clock:compare(State#membership.version, NewState#membership.version) of
  -    less -> 
  -      reload_storage_servers(State, NewState),
  -      reload_sync_servers(State, NewState),
  -      save_state(NewState),
  -      {reply, NewState, NewState};
  -    greater -> {reply, State, State};
  -    equal -> {reply, State, State};
  -    concurrent -> 
  -      Merged = merge_states(NewState, State),
  -      reload_storage_servers(State, Merged),
  -      reload_sync_servers(State, Merged),
  -      save_state(Merged),
  -      {reply, Merged, Merged#membership{config=State#membership.config}}
  -  end;
  +
  +handle_call({gossip_with, Node}, From, State = #membership{nodes = Nodes}) ->
  +  error_logger:info_msg("firing gossip at ~p~n", [Node]),
  +
  +  % share our state with target node - expects a response back, but we don't
  +  % want to wait for it
  +  Self = self(),
  +  GosFun =
  +    fun() ->
  +        {ok, RemoteState} = gen_server:call({membership, Node}, {share, State}),
  +        {ok, ModState} = gen_server:call(Self, {merge_state, RemoteState}),
  +        gen_server:reply(From, {ok, ModState})
  +    end,
  +  spawn_link(GosFun),
  +  {noreply, State};
  +
  +handle_call({merge_state, RemoteState}, _From, State) ->
  +  {ok, NewState} = merge_and_save_state(RemoteState, State),
  +  {reply, {ok, NewState}, NewState};
  +
  +%%
  +% Another node is sharing their state with us. Need to merge them in
  +% and reply with the merged state
  +%%
  +handle_call({share, RemoteState}, _From, State = #membership{config=Config}) ->
  +  {ok, Merged} = merge_and_save_state(RemoteState, State),
  +  {reply, {ok, Merged}, Merged};
   	
   handle_call(nodes, _From, State = #membership{nodes=Nodes}) ->
     {reply, Nodes, State};
     
   handle_call(state, _From, State) -> {reply, State, State};
  -
  -handle_call({state, NewState}, _From, State = #membership{config=Config}) -> 
  -  save_state(NewState#membership{config=Config}),
  -  {reply, ok, NewState#membership{config=Config}};
   	
   handle_call(old_partitions, _From, State = #membership{old_partitions=P}) when is_list(P) ->
     {reply, P, State};
  
positive.code: state() ->
    gen_server:call(membership, state).
    
  state(State) ->
    gen_server:call(membership, {state, State}).
    
  replica_nodes(Node) ->
    gen_server:call(membership, {replica_nodes, Node}).
    
  
negative.code:     partitions=Partitions,
      config=Config
    }.
  
  % Merges in another state, reloads any storage
  % and sync servers that changed, saves state
  % to disk.
  %
  % merge_and_save_state(state(), state()) -> {ok, NewState :: state()}
  merge_and_save_state(RemoteState, State) ->
    Merged =
      case vector_clock:compare(State#membership.version, RemoteState#membership.version) of
        less -> % remote state is strictly newer than ours
          RemoteState;
        greater -> % remote state is strictly older
          State;
        equal -> % same vector clock
          State;
        concurrent -> % must merge
          merge_states(RemoteState, State)
    end,
    NewState = Merged#membership{config = State#membership.config},
    reload_storage_servers(State, NewState),
    reload_sync_servers(State, NewState),
    save_state(NewState),
    {ok, NewState}.
  
  
  reload_sync_servers(empty, NewState) ->
    Config = configuration:get_config(),
  