anchor.diff:  
   	    %% Call service edge with local addresses (sorted and de-duped) and
   	    %% the services to register.
  -	    service_edge_rpc:register_remote_services(Services, lists:usort(LocalSvcAddresses))
  +	    service_edge_rpc:
  +		register_remote_services(St#st.cs, 
  +					 Services, 
  +					 lists:usort(LocalSvcAddresses))
       end,
  -    {reply, [ok], State };
  +    {reply, [ok], St };
   
   
   %%
   %% Delete all services registered under the given address
   %%
  -handle_call({rvi_call, unregister_remote_services_by_address, [Address]}, _From, State) ->
  +handle_call({rvi_call, unregister_remote_services_by_address, [Address]}, _From, St) ->
   
       %% Retrieve all services associated with the remote address
       Svcs = ets:lookup(?REMOTE_ADDRESS_TABLE, Address),
  
positive.code: 
      Services = RemoteSvc++LocalSvc,
  
      {reply,  [ok, Services], State };
  
  handle_call({rvi_call, get_remote_network_addresses, _Args}, _From, State) ->
      Addresses =  get_network_addresses_(?REMOTE_ADDRESS_TABLE),
      {reply, [ ok, Addresses ], State };
  
  
  handle_call({rvi_call, resolve_local_service, [RawService]}, _From, State) ->
      Service = rvi_common:sanitize_service_string(RawService),
      ?debug("service_discovery_rpc:resolve_local_service(): RawService:      ~p", [RawService]),
      ?debug("service_discovery_rpc:resolve_local_service(): Cleaned Service: ~p", [Service]),
  
      case resolve_service_(?LOCAL_SERVICE_TABLE, Service) of 
  	not_found ->
  	    { reply, [not_found], State };
  	
  	{ok, NetworkAddress } ->
  	    { reply, [ok, NetworkAddress], State}
      end;
  
  
  handle_call({rvi_call, get_local_services, _Args}, _From, State) ->
      Services = get_services_(?LOCAL_SERVICE_TABLE),
      {reply,  [ok,  Services ], State };
  
  handle_call({rvi_call, get_local_network_addresses, _Args}, _From, State) ->
      Addresses = get_network_addresses_(?LOCAL_SERVICE_TABLE),
      {reply, [ ok, Addresses ], State };
  
  handle_call(Other, _From, State) ->
      ?warning("service_discovery_rpc:handle_call(~p): unknown", [ Other ]),
      { reply,  [unknown_command] , State}.
  
  handle_cast(_Msg, State) ->
      {noreply, State}.
  
  handle_info(_Info, State) ->
      {noreply, State}.
  
  terminate(_Reason, _State) ->
      ok.
  code_change(_OldVsn, State, _Extra) ->
      {ok, State}.
  
  
  %%
  
negative.code: 		    ?info("service_discovery_rpc:resolve_remote_service(~p): Service not found.", 
  			   [Service]),
  		    
  		    {reply, [not_found], St };
  
  		NetworkAddress -> %% Found
  		    ?debug("service_discovery_rpc:resolve_service(~p): Service is on static node ~p", 
  			   [Service, NetworkAddress]),
  		    
  		    {reply, [ok, NetworkAddress ], St}
  	    end
      end;
  
  handle_call({rvi_call, get_remote_services, _Args}, _From, St) ->
      Services = get_services_(?REMOTE_SERVICE_TABLE),
      {reply,  [ok, Services ], St };
  
  handle_call({rvi_call, get_all_services, _Args}, _From, St) ->
      RemoteSvc = ets:foldl(fun(#service_entry {service = ServiceName}, Acc) -> 
  				  [ ServiceName  | Acc ] end, 
  			  [], ?REMOTE_SERVICE_TABLE),
  