anchor.diff:  handle_call(_Request, _From, State) ->
       {reply, ok, State}.
   
  -handle_cast({send, ClientName, Message}, #state{}=State) ->
  -    do_send(State, ClientName, Message),
  +handle_cast({send, OrgName, NodeName, Message}, #state{}=State) ->
  +    do_send(State, OrgName, NodeName, Message),
       {noreply, State};
  -handle_cast({send_multi, ClientName, Message}, #state{}=State) ->
  -    do_send_multi(State, ClientName, Message),
  +handle_cast({send_multi, OrgName, Nodes, Message}, #state{}=State) ->
  +    do_send_multi(State, OrgName, Nodes, Message),
       {noreply, State};
   handle_cast(_Msg, State) ->
       {noreply, State}.
   
   handle_info({zmq, _CommandSock, Address, [rcvmore]},
               State) ->
  -    read_address_separator(),
  +    error_logger:info_msg("Receiving message with address ~w~n", [Address]),
  +
       Header = read_header(),
  +    ?debugVal(Address),
  +    ?debugVal(Header),
       Body = pushy_util:read_body(),
  +    ?debugVal(Body),
  +
  +    error_logger:info_msg("Received message with address ~p~n~p~n~p~n", [Address, Header, Body]),
       State1 = case catch pushy_util:do_authenticate_message(Header, Body) of
                    ok ->
                        process_message(State, Address, Header, Body);
  
positive.code: %% Utility functions; we should generalize these and move elsewhere.
  %%
  
  read_address_separator() ->
      receive
          {zmq, _Sock, <<>>, [rcvmore]} ->
              ok
      end.
  
  read_header() ->
      receive
          {zmq, _Sock, HeaderFrame, [rcvmore]} ->
              HeaderFrame
      end.
  
  
  addr_node_map_new() ->
      { dict:new(), dict:new() }.
  
  kill_crossref(Forward, Backward, Key) ->
      case dict:find(Forward, Key) of
          {ok, OldValue} ->
              dict:erase(OldValue, Backward);
  
negative.code: 
  do_send(#state{addr_node_map = AddrNodeMap,
                 command_sock = CommandSocket},
          Org, Node, Message) ->
      Address = addr_node_map_lookup_by_node(AddrNodeMap, {Org, Node}),
      send_multipart(CommandSocket, Address, Message).
  
  do_send_multi(State, Org, Nodes, Message) ->
      [ do_send(State, Org, Node, Message) || Node <- Nodes ].
  
  process_message(State, Address, _Header, Body) ->
      case catch jiffy:decode(Body) of
          {Data} ->
              ?debugVal(Data),
              NodeName = ej:get({<<"node">>}, Data ),
              ?debugVal(NodeName),
              OrgName  = ej:get({<<"org">>}, Data ),
              ?debugVal(OrgName),
              ClientName = ej:get({<<"client">>}, Data ),
              ?debugVal(ClientName),
              _JobName = ej:get({<<"job_id">>}, Data, unknown ),
  
              State2 = addr_node_map_update(State, Address, {OrgName, NodeName}),
              %%% TODO SETH ADDS call here
              %%% send_to_job_controller(JobName, Body)
              State2;
          {'EXIT', Error} ->
              error_logger:error_msg("Status message JSON parsing failed: body=~s, error=~s~n", [Body,Error]),
  