Merge pull request #41 from mitchellwrosen/master

More accurate type spec for websocket_terminate, other minor cleanup

Author: jeremyong

src/websocket_client.erl

@@ -154,33 +154,30 @@ receive_handshake(Buffer, Transport, Socket) ->
     end.
 
 %% @doc Send frame to server
+-spec send(websocket_req:frame(), websocket_req:req()) -> ok | {error, term()}.
 send(Frame, WSReq) ->
   Socket = websocket_req:socket(WSReq),
   Transport = websocket_req:transport(WSReq),
   Transport:send(Socket, encode_frame(Frame)).
 
-
 %% @doc Main loop
 -spec websocket_loop(WSReq :: websocket_req:req(), HandlerState :: any(),
                      Buffer :: binary()) ->
                             ok.
 websocket_loop(WSReq, HandlerState, Buffer) ->
   receive
-    Message -> handle_websocket_message(WSReq, HandlerState, Buffer, Message)
+      Message -> handle_websocket_message(WSReq, HandlerState, Buffer, Message)
   end.
 
 handle_websocket_message(WSReq, HandlerState, Buffer, Message) ->
     [Handler, Remaining, Socket] =
         websocket_req:get([handler, remaining, socket], WSReq),
     case Message of
         keepalive ->
-            case websocket_req:get([keepalive_timer], WSReq) of
-              [undefined] -> ok;
-              [OldTimer] -> erlang:cancel_timer(OldTimer)
-            end,
+            cancel_keepalive_timer(WSReq),
             ok = send({ping, <<>>}, WSReq),
             KATimer = erlang:send_after(websocket_req:keepalive(WSReq), self(), keepalive),
-            websocket_loop(websocket_req:set([{keepalive_timer,KATimer}], WSReq), HandlerState, Buffer);
+            websocket_loop(websocket_req:keepalive_timer(KATimer, WSReq), HandlerState, Buffer);
         {cast, Frame} ->
             ok = send(Frame, WSReq),
             websocket_loop(WSReq, HandlerState, Buffer);
@@ -196,7 +193,6 @@ handle_websocket_message(WSReq, HandlerState, Buffer, Message) ->
                                    websocket_req:opcode(WSReq), Remaining, Data, Buffer)
             end;
         Msg ->
-            Handler = websocket_req:handler(WSReq),
             try Handler:websocket_info(Msg, WSReq, HandlerState) of
               HandlerResponse ->
                 handle_response(WSReq, HandlerResponse, Buffer)
@@ -213,6 +209,16 @@ handle_websocket_message(WSReq, HandlerState, Buffer, Message) ->
             end
     end.
 
+-spec cancel_keepalive_timer(websocket_req:req()) -> ok.
+cancel_keepalive_timer(WSReq) ->
+    case websocket_req:keepalive_timer(WSReq) of
+        undefined ->
+            ok;
+        OldTimer ->
+            erlang:cancel_timer(OldTimer),
+            ok
+    end.
+
 -spec websocket_close(WSReq :: websocket_req:req(),
                       HandlerState :: any(),
                       Reason :: tuple()) -> ok.

src/websocket_client_handler.erl

@@ -2,7 +2,35 @@
 
 -type state() :: any().
 -type keepalive() :: integer().
--type close_type() :: normal | error | remote.
+
+-type close_reason() ::
+    % Either the local end was closed via a `{closed, Reason, State}` tuple
+    % returned from websocket_handle/3 or websocket_info/3, or the remote end
+    % was closed during graceful teardown of the connection via a close frame
+    % (see https://tools.ietf.org/html/rfc6455#section-5.5.1).
+    {normal, binary()} |
+    % The transport failed to send (see http://erlang.org/doc/man/gen_tcp.html#send-2
+    % or http://erlang.org/doc/man/ssl.html#send-2)
+    {error, term()} |
+    % The remote end was closed due to a protocol error
+    % (see https://tools.ietf.org/html/rfc6455#section-7.4.1, status code 1002).
+    {error, badframe, binary()} |
+    % The remote end was closed due to an encoding error
+    % (see https://tools.ietf.org/html/rfc6455#section-7.4.1, status code 1007).
+    {error, badencoding, binary()} |
+    % The remote end was closed unexpectedly
+    % (see https://tools.ietf.org/html/rfc6455#section-7.4.1, status code 1011).
+    {error, handler, binary()} |
+    % The remote host closed the socket.
+    {remote, closed} |
+    % The remote end was closed for some other reason
+    % (see https://tools.ietf.org/html/rfc6455#section-7.4.1).
+    {remote, integer(), binary()} |
+    % The remote host closed the socket.
+    % TODO: How is this different than `{remote, closed}`?
+    {remote, binary()} |
+    % The handler terminated unexpectedly in websocket_handle/3 or websocket_info/3.
+    term().
 
 -callback init(list(), websocket_req:req()) ->
     {ok, state()}
@@ -18,6 +46,4 @@
         | {reply, websocket_req:frame(), state()}
         | {close, binary(),  state()}.
 
--callback websocket_terminate({close_type(), term()} | {close_type(), integer(), binary()},
-                              websocket_req:req(), state()) ->
-    ok.
+-callback websocket_terminate(close_reason(), websocket_req:req(), state()) -> ok.

src/websocket_req.erl

@@ -40,6 +40,7 @@
          port/2, port/1,
          path/2, path/1,
          keepalive/2, keepalive/1,
+         keepalive_timer/2, keepalive_timer/1,
          socket/2, socket/1,
          transport/2, transport/1,
          handler/2, handler/1,
@@ -134,6 +135,14 @@ keepalive(K, Req) ->
     Req#websocket_req{keepalive = K}.
 
 
+-spec keepalive_timer(req()) -> undefined | reference().
+keepalive_timer(#websocket_req{keepalive_timer = K}) -> K.
+
+-spec keepalive_timer(reference(), req()) -> req().
+keepalive_timer(K, Req) ->
+    Req#websocket_req{keepalive_timer = K}.
+
+
 -spec socket(req()) -> inet:socket() | ssl:sslsocket().
 socket(#websocket_req{socket = S}) -> S.