turn most cast's into call's, for more synchronisity

3 files changed, 30 insertions, 20 deletions

diff --git a/p11p-daemon/src/p11p_remote.erl b/p11p-daemon/src/p11p_remote.erl
index 3790971..c968aad 100644
--- a/p11p-daemon/src/p11p_remote.erl
+++ b/p11p-daemon/src/p11p_remote.erl
@@ -14,7 +14,7 @@
 
 %% API.
 -export([start_link/3]).
--export([request/3, add_to_outbuf/2]).
+-export([request/2, add_to_outbuf/2]).
 
 -include("p11p_rpc.hrl").
 
@@ -41,12 +41,12 @@ start_link(ServName, TokName, ModPath) ->
     lager:info("~p: p11p_remote starting for ~s", [ServName, ModPath]),
     gen_server:start_link({local, ServName}, ?MODULE, [TokName, ModPath], []).
 
--spec request(pid(), pid(), p11rpc_msg()) -> ok.
-request(From, Remote, Request) ->
-    gen_server:cast(Remote, {request, From, Request}).
+-spec request(pid(), p11rpc_msg()) -> ok.
+request(Remote, Request) ->
+    gen_server:call(Remote, {request, Request}).
 
 add_to_outbuf(Remote, Data) ->
-    gen_server:cast(Remote, {add_to_outbuf, Data}).
+    gen_server:call(Remote, {add_to_outbuf, Data}).
 
 %% Genserver callbacks.
 init([TokName, ModPath]) ->
@@ -55,19 +55,16 @@ init([TokName, ModPath]) ->
     lager:debug("~p: ~s: New port: ~p", [self(), ?P11KITREMOTE_PATH, Port]),
     {ok, #state{port = Port, token = TokName}}.
 
+handle_call({add_to_outbuf,  Data}, _From, State) ->
+    {reply, ok, do_add_to_outbuf(Data, State)};
+handle_call({request, Request}, {FromPid, _Tag}, #state{port = Port} = State) ->
+    lager:debug("~p: sending request from ~p to remote ~p", [self(), FromPid, Port]),
+    NewState = do_send(do_add_to_outbuf(p11p_rpc:serialise(Request), State)),
+    {reply, ok, NewState#state{replyto = FromPid, timer = start_timer(Port)}};
 handle_call(Request, _From, State) ->
     lager:debug("~p: Unhandled call: ~p~n", [self(), Request]),
     {reply, unhandled, State}.
 
-handle_cast({add_to_outbuf,  Data}, State) ->
-    {noreply, do_add_to_outbuf(Data, State)};
-handle_cast({request, From, Request}, #state{port = Port} = State) ->
-    lager:debug("~p: sending request to remote ~p", [self(), Port]),
-    NewState = do_add_to_outbuf(p11p_rpc:serialise(Request), State),
-    NewState2 = do_send(NewState),
-    Timer = erlang:start_timer(3000, self(), Port), % Keep below gen_server:call timeout (default 5000).
-    NewState3 = NewState2#state{replyto = From, timer = Timer},
-    {noreply, NewState3};
 handle_cast(Request, State) ->
     lager:debug("~p: Unhandled cast: ~p~n", [self(), Request]),
     {noreply, State}.
@@ -80,14 +77,17 @@ handle_info({Port, {data, Data}}, #state{replyto = Pid} = State) when Port == St
 handle_info({Port, {data, Data}}, #state{msg = Msg} = State) when Port == State#state.port ->
     {noreply, handle_remote_data(State, Msg, Data)};
 handle_info({timeout, Timer, Port}, #state{token = TokName} = State) when Port == State#state.port, Timer == State#state.timer ->
-    p11p_remote_manager:timeout(TokName),
+    lager:info("~p: rpc request timed out, exiting", [self()]),
+    fixme = p11p_remote_manager:timeout(TokName),
     NewState = State#state{timer = undefined},
-    {noreply, NewState};
+    {stop, normal, NewState};
 handle_info(Info, State) ->
     lager:debug("~p: Unhandled info: ~p~n", [self(), Info]),
     {noreply, State}.
 
-terminate(_Reason, _State) ->
+terminate(Reason, #state{port = Port}) ->
+    lager:debug("~p: remote terminating with reason ~p", [self(), Reason]),
+    port_close(Port),
     ok.
 
 code_change(_OldVersion, State, _Extra) ->
@@ -107,9 +107,17 @@ do_send(#state{port = Port, outbuf = Buf} = State) ->
 handle_remote_data(#state{replyto = Pid, timer = Timer} = State, Msg, Data) ->
     case p11p_rpc:parse(Msg, list_to_binary(Data)) of
 	{done, NewMsg} ->
-	    erlang:cancel_timer(Timer, [{async, true}, {info, false}]),
+	    cancel_timer(Timer),
 	    ok = p11p_server:reply(Pid, NewMsg),
 	    State#state{msg = p11p_rpc:new(NewMsg#p11rpc_msg.buffer)};
 	{needmore, NewMsg} ->
 	    State#state{msg = NewMsg}
     end.
+
+start_timer(Port) ->
+    lager:debug("~p: starting timer", [self()]),
+    erlang:start_timer(3000, self(), Port).
+
+cancel_timer(Timer) ->
+    lager:debug("~p: canceling timer", [self()]),
+    erlang:cancel_timer(Timer, [{async, true}, {info, false}]).
diff --git a/p11p-daemon/src/p11p_remote_manager.erl b/p11p-daemon/src/p11p_remote_manager.erl
index 3b3013b..f5dc233 100644
--- a/p11p-daemon/src/p11p_remote_manager.erl
+++ b/p11p-daemon/src/p11p_remote_manager.erl
@@ -41,7 +41,7 @@ remote_for_token(TokName) ->
 p11init_done(_Done) ->
     todo.
 timeout(_TokName) ->
-    todo.
+    fixme.					% TODO: shift remotes
 
 send(TokName, Data) ->
     gen_server:cast(?MODULE, {send, TokName, Data}).
@@ -90,6 +90,8 @@ init_tokens([H|T], Acc)->
     init_tokens(T, Acc#{TokName => new_token(TokName, H)}).
 
 new_token(TokName, ConfToken) ->
+    %% TODO: This approach is too static. Instead of storing pids
+    %% here, let remote genservers register with us in their init/1.
     Remotes = start_remotes(TokName, p11p_config:modules_for_token(p11p_config:nameof(ConfToken))),
     #token{remotes = Remotes}.
 
diff --git a/p11p-daemon/src/p11p_server.erl b/p11p-daemon/src/p11p_server.erl
index 684c6e1..ab71c6d 100644
--- a/p11p-daemon/src/p11p_server.erl
+++ b/p11p-daemon/src/p11p_server.erl
@@ -107,7 +107,7 @@ handle_client_data(#state{tokname = TokName} = State, Msg, Data) ->
     case p11p_rpc:parse(Msg, Data) of
 	{done, NewMsg} ->
 	    Remote = p11p_remote_manager:remote_for_token(TokName),
-	    ok = p11p_remote:request(self(), Remote, NewMsg),
+	    ok = p11p_remote:request(Remote, NewMsg),
 	    State#state{msg = p11p_rpc:new(NewMsg#p11rpc_msg.buffer)};
 	{needmore, NewMsg} ->
 	    State#state{msg = NewMsg}