aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--src/cowboy_websocket.erl222
-rw-r--r--test/ws_SUITE_data/ws_echo.erl20
-rw-r--r--test/ws_SUITE_data/ws_echo_timer.erl30
-rw-r--r--test/ws_SUITE_data/ws_send_many.erl18
-rw-r--r--test/ws_SUITE_data/ws_subprotocol.erl12
-rw-r--r--test/ws_SUITE_data/ws_timeout_cancel.erl16
-rw-r--r--test/ws_SUITE_data/ws_timeout_hibernate.erl12
7 files changed, 161 insertions, 169 deletions
diff --git a/src/cowboy_websocket.erl b/src/cowboy_websocket.erl
index bc9bd31..7971442 100644
--- a/src/cowboy_websocket.erl
+++ b/src/cowboy_websocket.erl
@@ -19,7 +19,13 @@
-export([upgrade/6]).
-export([takeover/7]).
--export([handler_loop/4]).
+-export([handler_loop/3]).
+
+-type call_result(State) :: {ok, State}
+ | {ok, State, hibernate}
+ | {reply, cow_ws:frame() | [cow_ws:frame()], State}
+ | {reply, cow_ws:frame() | [cow_ws:frame()], State, hibernate}
+ | {stop, State}.
-type terminate_reason() :: normal | stop | timeout
| remote | {remote, cow_ws:close_code(), binary()}
@@ -33,26 +39,18 @@
| {module(), Req, any(), timeout(), hibernate}
when Req::cowboy_req:req().
--callback websocket_init(Req, State)
- -> {ok, Req, State}
- when Req::cowboy_req:req(), State::any().
--optional_callbacks([websocket_init/2]).
+-callback websocket_init(State)
+ %% @todo Make that call_result/1.
+ -> {ok, State} when State::any().
+-optional_callbacks([websocket_init/1]).
--callback websocket_handle({text | binary | ping | pong, binary()}, Req, State)
- -> {ok, Req, State}
- | {ok, Req, State, hibernate}
- | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State}
- | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State, hibernate}
- | {stop, Req, State}
- when Req::cowboy_req:req(), State::any().
--callback websocket_info(any(), Req, State)
- -> {ok, Req, State}
- | {ok, Req, State, hibernate}
- | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State}
- | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State, hibernate}
- | {stop, Req, State}
- when Req::cowboy_req:req(), State::any().
+-callback websocket_handle({text | binary | ping | pong, binary()}, State)
+ -> call_result(State) when State::any().
+-callback websocket_info(any(), State)
+ -> call_result(State) when State::any().
+%% @todo OK this I am not sure what to do about it. We don't have a Req anymore.
+%% We probably should have a websocket_terminate instead.
-callback terminate(any(), cowboy_req:req(), any()) -> ok.
-optional_callbacks([terminate/3]).
@@ -163,41 +161,40 @@ websocket_handshake(State=#state{key=Key},
<<"upgrade">> => <<"websocket">>,
<<"sec-websocket-accept">> => Challenge
}, Req),
- Pid ! {{Pid, StreamID}, {switch_protocol, Headers, ?MODULE, {Req, State, HandlerState}}},
+ Pid ! {{Pid, StreamID}, {switch_protocol, Headers, ?MODULE, {State, HandlerState}}},
{ok, Req, Env}.
%% Connection process.
%% @todo Keep parent and handle system messages.
-spec takeover(pid(), ranch:ref(), inet:socket(), module(), any(), binary(),
- {cowboy_req:req(), #state{}, any()}) -> ok.
+ {#state{}, any()}) -> ok.
takeover(_Parent, Ref, Socket, Transport, _Opts, Buffer,
- {Req0, State=#state{handler=Handler}, HandlerState0}) ->
+ {State=#state{handler=Handler}, HandlerState0}) ->
ranch:remove_connection(Ref),
- %% @todo Remove Req from Websocket callbacks.
%% @todo Allow sending a reply from websocket_init.
%% @todo Try/catch.
- {ok, Req, HandlerState} = case erlang:function_exported(Handler, websocket_init, 2) of
- true -> Handler:websocket_init(Req0, HandlerState0);
- false -> {ok, Req0, HandlerState0}
+ {ok, HandlerState} = case erlang:function_exported(Handler, websocket_init, 1) of
+ true -> Handler:websocket_init(HandlerState0);
+ false -> {ok, HandlerState0}
end,
State2 = handler_loop_timeout(State#state{socket=Socket, transport=Transport}),
handler_before_loop(State2#state{key=undefined,
- messages=Transport:messages()}, Req, HandlerState, Buffer).
+ messages=Transport:messages()}, HandlerState, Buffer).
--spec handler_before_loop(#state{}, Req, any(), binary())
- -> {ok, Req, cowboy_middleware:env()}
- when Req::cowboy_req:req().
+-spec handler_before_loop(#state{}, any(), binary())
+%% @todo Yeah not env.
+ -> {ok, cowboy_middleware:env()}.
handler_before_loop(State=#state{
socket=Socket, transport=Transport, hibernate=true},
- Req, HandlerState, SoFar) ->
+ HandlerState, SoFar) ->
Transport:setopts(Socket, [{active, once}]),
proc_lib:hibernate(?MODULE, handler_loop,
- [State#state{hibernate=false}, Req, HandlerState, SoFar]);
+ [State#state{hibernate=false}, HandlerState, SoFar]);
handler_before_loop(State=#state{socket=Socket, transport=Transport},
- Req, HandlerState, SoFar) ->
+ HandlerState, SoFar) ->
Transport:setopts(Socket, [{active, once}]),
- handler_loop(State, Req, HandlerState, SoFar).
+ handler_loop(State, HandlerState, SoFar).
-spec handler_loop_timeout(#state{}) -> #state{}.
handler_loop_timeout(State=#state{timeout=infinity}) ->
@@ -208,171 +205,168 @@ handler_loop_timeout(State=#state{timeout=Timeout, timeout_ref=PrevRef}) ->
TRef = erlang:start_timer(Timeout, self(), ?MODULE),
State#state{timeout_ref=TRef}.
--spec handler_loop(#state{}, Req, any(), binary())
- -> {ok, Req, cowboy_middleware:env()}
- when Req::cowboy_req:req().
+-spec handler_loop(#state{}, any(), binary())
+ -> {ok, cowboy_middleware:env()}.
handler_loop(State=#state{socket=Socket, messages={OK, Closed, Error},
- timeout_ref=TRef}, Req, HandlerState, SoFar) ->
+ timeout_ref=TRef}, HandlerState, SoFar) ->
receive
{OK, Socket, Data} ->
State2 = handler_loop_timeout(State),
- websocket_data(State2, Req, HandlerState,
+ websocket_data(State2, HandlerState,
<< SoFar/binary, Data/binary >>);
{Closed, Socket} ->
- handler_terminate(State, Req, HandlerState, {error, closed});
+ handler_terminate(State, HandlerState, {error, closed});
{Error, Socket, Reason} ->
- handler_terminate(State, Req, HandlerState, {error, Reason});
+ handler_terminate(State, HandlerState, {error, Reason});
{timeout, TRef, ?MODULE} ->
- websocket_close(State, Req, HandlerState, timeout);
+ websocket_close(State, HandlerState, timeout);
{timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) ->
- handler_loop(State, Req, HandlerState, SoFar);
+ handler_loop(State, HandlerState, SoFar);
Message ->
- handler_call(State, Req, HandlerState,
- SoFar, websocket_info, Message, fun handler_before_loop/4)
+ handler_call(State, HandlerState,
+ SoFar, websocket_info, Message, fun handler_before_loop/3)
end.
--spec websocket_data(#state{}, Req, any(), binary())
- -> {ok, Req, cowboy_middleware:env()}
- when Req::cowboy_req:req().
-websocket_data(State=#state{frag_state=FragState, extensions=Extensions}, Req, HandlerState, Data) ->
+-spec websocket_data(#state{}, any(), binary())
+ -> {ok, cowboy_middleware:env()}.
+websocket_data(State=#state{frag_state=FragState, extensions=Extensions}, HandlerState, Data) ->
case cow_ws:parse_header(Data, Extensions, FragState) of
%% All frames sent from the client to the server are masked.
{_, _, _, _, undefined, _} ->
- websocket_close(State, Req, HandlerState, {error, badframe});
+ websocket_close(State, HandlerState, {error, badframe});
{Type, FragState2, Rsv, Len, MaskKey, Rest} ->
- websocket_payload(State#state{frag_state=FragState2}, Req, HandlerState, Type, Len, MaskKey, Rsv, undefined, <<>>, 0, Rest);
+ websocket_payload(State#state{frag_state=FragState2}, HandlerState, Type, Len, MaskKey, Rsv, undefined, <<>>, 0, Rest);
more ->
- handler_before_loop(State, Req, HandlerState, Data);
+ handler_before_loop(State, HandlerState, Data);
error ->
- websocket_close(State, Req, HandlerState, {error, badframe})
+ websocket_close(State, HandlerState, {error, badframe})
end.
websocket_payload(State=#state{frag_state=FragState, utf8_state=Incomplete, extensions=Extensions},
- Req, HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen, Data) ->
+ HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen, Data) ->
case cow_ws:parse_payload(Data, MaskKey, Incomplete, UnmaskedLen, Type, Len, FragState, Extensions, Rsv) of
{ok, CloseCode2, Payload, Utf8State, Rest} ->
websocket_dispatch(State#state{utf8_state=Utf8State},
- Req, HandlerState, Type, << Unmasked/binary, Payload/binary >>, CloseCode2, Rest);
+ HandlerState, Type, << Unmasked/binary, Payload/binary >>, CloseCode2, Rest);
{ok, Payload, Utf8State, Rest} ->
websocket_dispatch(State#state{utf8_state=Utf8State},
- Req, HandlerState, Type, << Unmasked/binary, Payload/binary >>, CloseCode, Rest);
+ HandlerState, Type, << Unmasked/binary, Payload/binary >>, CloseCode, Rest);
{more, CloseCode2, Payload, Utf8State} ->
websocket_payload_loop(State#state{utf8_state=Utf8State},
- Req, HandlerState, Type, Len - byte_size(Data), MaskKey, Rsv, CloseCode2,
+ HandlerState, Type, Len - byte_size(Data), MaskKey, Rsv, CloseCode2,
<< Unmasked/binary, Payload/binary >>, UnmaskedLen + byte_size(Data));
{more, Payload, Utf8State} ->
websocket_payload_loop(State#state{utf8_state=Utf8State},
- Req, HandlerState, Type, Len - byte_size(Data), MaskKey, Rsv, CloseCode,
+ HandlerState, Type, Len - byte_size(Data), MaskKey, Rsv, CloseCode,
<< Unmasked/binary, Payload/binary >>, UnmaskedLen + byte_size(Data));
Error = {error, _Reason} ->
- websocket_close(State, Req, HandlerState, Error)
+ websocket_close(State, HandlerState, Error)
end.
websocket_payload_loop(State=#state{socket=Socket, transport=Transport,
messages={OK, Closed, Error}, timeout_ref=TRef},
- Req, HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen) ->
+ HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen) ->
Transport:setopts(Socket, [{active, once}]),
receive
{OK, Socket, Data} ->
State2 = handler_loop_timeout(State),
- websocket_payload(State2, Req, HandlerState,
+ websocket_payload(State2, HandlerState,
Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen, Data);
{Closed, Socket} ->
- handler_terminate(State, Req, HandlerState, {error, closed});
+ handler_terminate(State, HandlerState, {error, closed});
{Error, Socket, Reason} ->
- handler_terminate(State, Req, HandlerState, {error, Reason});
+ handler_terminate(State, HandlerState, {error, Reason});
{timeout, TRef, ?MODULE} ->
- websocket_close(State, Req, HandlerState, timeout);
+ websocket_close(State, HandlerState, timeout);
{timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) ->
- websocket_payload_loop(State, Req, HandlerState,
+ websocket_payload_loop(State, HandlerState,
Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen);
Message ->
- handler_call(State, Req, HandlerState,
+ handler_call(State, HandlerState,
<<>>, websocket_info, Message,
- fun (State2, Req2, HandlerState2, _) ->
- websocket_payload_loop(State2, Req2, HandlerState2,
+ fun (State2, HandlerState2, _) ->
+ websocket_payload_loop(State2, HandlerState2,
Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen)
end)
end.
websocket_dispatch(State=#state{socket=Socket, transport=Transport, frag_state=FragState, frag_buffer=SoFar, extensions=Extensions},
- Req, HandlerState, Type0, Payload0, CloseCode0, RemainingData) ->
+ HandlerState, Type0, Payload0, CloseCode0, RemainingData) ->
case cow_ws:make_frame(Type0, Payload0, CloseCode0, FragState) of
%% @todo Allow receiving fragments.
{fragment, nofin, _, Payload} ->
- websocket_data(State#state{frag_buffer= << SoFar/binary, Payload/binary >>}, Req, HandlerState, RemainingData);
+ websocket_data(State#state{frag_buffer= << SoFar/binary, Payload/binary >>}, HandlerState, RemainingData);
{fragment, fin, Type, Payload} ->
- handler_call(State#state{frag_state=undefined, frag_buffer= <<>>}, Req, HandlerState, RemainingData,
- websocket_handle, {Type, << SoFar/binary, Payload/binary >>}, fun websocket_data/4);
+ handler_call(State#state{frag_state=undefined, frag_buffer= <<>>}, HandlerState, RemainingData,
+ websocket_handle, {Type, << SoFar/binary, Payload/binary >>}, fun websocket_data/3);
close ->
- websocket_close(State, Req, HandlerState, remote);
+ websocket_close(State, HandlerState, remote);
{close, CloseCode, Payload} ->
- websocket_close(State, Req, HandlerState, {remote, CloseCode, Payload});
+ websocket_close(State, HandlerState, {remote, CloseCode, Payload});
Frame = ping ->
Transport:send(Socket, cow_ws:frame(pong, Extensions)),
- handler_call(State, Req, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/4);
+ handler_call(State, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/3);
Frame = {ping, Payload} ->
Transport:send(Socket, cow_ws:frame({pong, Payload}, Extensions)),
- handler_call(State, Req, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/4);
+ handler_call(State, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/3);
Frame ->
- handler_call(State, Req, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/4)
+ handler_call(State, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/3)
end.
--spec handler_call(#state{}, Req, any(), binary(), atom(), any(), fun())
- -> {ok, Req, cowboy_middleware:env()}
- when Req::cowboy_req:req().
-handler_call(State=#state{handler=Handler}, Req, HandlerState,
+-spec handler_call(#state{}, any(), binary(), atom(), any(), fun())
+ -> {ok, cowboy_middleware:env()}.
+handler_call(State=#state{handler=Handler}, HandlerState,
RemainingData, Callback, Message, NextState) ->
- try Handler:Callback(Message, Req, HandlerState) of
- {ok, Req2, HandlerState2} ->
- NextState(State, Req2, HandlerState2, RemainingData);
- {ok, Req2, HandlerState2, hibernate} ->
+ try Handler:Callback(Message, HandlerState) of
+ {ok, HandlerState2} ->
+ NextState(State, HandlerState2, RemainingData);
+ {ok, HandlerState2, hibernate} ->
NextState(State#state{hibernate=true},
- Req2, HandlerState2, RemainingData);
- {reply, Payload, Req2, HandlerState2}
+ HandlerState2, RemainingData);
+ {reply, Payload, HandlerState2}
when is_list(Payload) ->
case websocket_send_many(Payload, State) of
ok ->
- NextState(State, Req2, HandlerState2, RemainingData);
+ NextState(State, HandlerState2, RemainingData);
stop ->
- handler_terminate(State, Req2, HandlerState2, stop);
+ handler_terminate(State, HandlerState2, stop);
Error = {error, _} ->
- handler_terminate(State, Req2, HandlerState2, Error)
+ handler_terminate(State, HandlerState2, Error)
end;
- {reply, Payload, Req2, HandlerState2, hibernate}
+ {reply, Payload, HandlerState2, hibernate}
when is_list(Payload) ->
case websocket_send_many(Payload, State) of
ok ->
NextState(State#state{hibernate=true},
- Req2, HandlerState2, RemainingData);
+ HandlerState2, RemainingData);
stop ->
- handler_terminate(State, Req2, HandlerState2, stop);
+ handler_terminate(State, HandlerState2, stop);
Error = {error, _} ->
- handler_terminate(State, Req2, HandlerState2, Error)
+ handler_terminate(State, HandlerState2, Error)
end;
- {reply, Payload, Req2, HandlerState2} ->
+ {reply, Payload, HandlerState2} ->
case websocket_send(Payload, State) of
ok ->
- NextState(State, Req2, HandlerState2, RemainingData);
+ NextState(State, HandlerState2, RemainingData);
stop ->
- handler_terminate(State, Req2, HandlerState2, stop);
+ handler_terminate(State, HandlerState2, stop);
Error = {error, _} ->
- handler_terminate(State, Req2, HandlerState2, Error)
+ handler_terminate(State, HandlerState2, Error)
end;
- {reply, Payload, Req2, HandlerState2, hibernate} ->
+ {reply, Payload, HandlerState2, hibernate} ->
case websocket_send(Payload, State) of
ok ->
NextState(State#state{hibernate=true},
- Req2, HandlerState2, RemainingData);
+ HandlerState2, RemainingData);
stop ->
- handler_terminate(State, Req2, HandlerState2, stop);
+ handler_terminate(State, HandlerState2, stop);
Error = {error, _} ->
- handler_terminate(State, Req2, HandlerState2, Error)
+ handler_terminate(State, HandlerState2, Error)
end;
- {stop, Req2, HandlerState2} ->
- websocket_close(State, Req2, HandlerState2, stop)
+ {stop, HandlerState2} ->
+ websocket_close(State, HandlerState2, stop)
catch Class:Reason ->
- _ = websocket_close(State, Req, HandlerState, {crash, Class, Reason}),
+ _ = websocket_close(State, HandlerState, {crash, Class, Reason}),
erlang:raise(Class, Reason, erlang:get_stacktrace())
end.
@@ -396,11 +390,10 @@ websocket_send_many([Frame|Tail], State) ->
Error -> Error
end.
--spec websocket_close(#state{}, Req, any(), terminate_reason())
- -> {ok, Req, cowboy_middleware:env()}
- when Req::cowboy_req:req().
+-spec websocket_close(#state{}, any(), terminate_reason())
+ -> {ok, cowboy_middleware:env()}.
websocket_close(State=#state{socket=Socket, transport=Transport, extensions=Extensions},
- Req, HandlerState, Reason) ->
+ HandlerState, Reason) ->
case Reason of
Normal when Normal =:= stop; Normal =:= timeout ->
Transport:send(Socket, cow_ws:frame({close, 1000, <<>>}, Extensions));
@@ -415,12 +408,11 @@ websocket_close(State=#state{socket=Socket, transport=Transport, extensions=Exte
{remote, Code, _} ->
Transport:send(Socket, cow_ws:frame({close, Code, <<>>}, Extensions))
end,
- handler_terminate(State, Req, HandlerState, Reason).
+ handler_terminate(State, HandlerState, Reason).
--spec handler_terminate(#state{}, Req, any(), terminate_reason())
- -> {ok, Req, cowboy_middleware:env()}
- when Req::cowboy_req:req().
+-spec handler_terminate(#state{}, any(), terminate_reason())
+ -> {ok, cowboy_middleware:env()}.
handler_terminate(#state{handler=Handler},
- Req, HandlerState, Reason) ->
- cowboy_handler:terminate(Reason, Req, HandlerState, Handler),
+ HandlerState, Reason) ->
+ cowboy_handler:terminate(Reason, undefined, HandlerState, Handler),
exit(normal).
diff --git a/test/ws_SUITE_data/ws_echo.erl b/test/ws_SUITE_data/ws_echo.erl
index 89ebcb6..4b832df 100644
--- a/test/ws_SUITE_data/ws_echo.erl
+++ b/test/ws_SUITE_data/ws_echo.erl
@@ -3,18 +3,18 @@
-module(ws_echo).
-export([init/2]).
--export([websocket_handle/3]).
--export([websocket_info/3]).
+-export([websocket_handle/2]).
+-export([websocket_info/2]).
init(Req, _) ->
{cowboy_websocket, Req, undefined}.
-websocket_handle({text, Data}, Req, State) ->
- {reply, {text, Data}, Req, State};
-websocket_handle({binary, Data}, Req, State) ->
- {reply, {binary, Data}, Req, State};
-websocket_handle(_Frame, Req, State) ->
- {ok, Req, State}.
+websocket_handle({text, Data}, State) ->
+ {reply, {text, Data}, State};
+websocket_handle({binary, Data}, State) ->
+ {reply, {binary, Data}, State};
+websocket_handle(_Frame, State) ->
+ {ok, State}.
-websocket_info(_Info, Req, State) ->
- {ok, Req, State}.
+websocket_info(_Info, State) ->
+ {ok, State}.
diff --git a/test/ws_SUITE_data/ws_echo_timer.erl b/test/ws_SUITE_data/ws_echo_timer.erl
index 9761e1f..7f37229 100644
--- a/test/ws_SUITE_data/ws_echo_timer.erl
+++ b/test/ws_SUITE_data/ws_echo_timer.erl
@@ -3,26 +3,26 @@
-module(ws_echo_timer).
-export([init/2]).
--export([websocket_init/2]).
--export([websocket_handle/3]).
--export([websocket_info/3]).
+-export([websocket_init/1]).
+-export([websocket_handle/2]).
+-export([websocket_info/2]).
init(Req, _) ->
{cowboy_websocket, Req, undefined}.
-websocket_init(Req, State) ->
+websocket_init(State) ->
erlang:start_timer(1000, self(), <<"websocket_init">>),
- {ok, Req, State}.
+ {ok, State}.
-websocket_handle({text, Data}, Req, State) ->
- {reply, {text, Data}, Req, State};
-websocket_handle({binary, Data}, Req, State) ->
- {reply, {binary, Data}, Req, State};
-websocket_handle(_Frame, Req, State) ->
- {ok, Req, State}.
+websocket_handle({text, Data}, State) ->
+ {reply, {text, Data}, State};
+websocket_handle({binary, Data}, State) ->
+ {reply, {binary, Data}, State};
+websocket_handle(_Frame, State) ->
+ {ok, State}.
-websocket_info({timeout, _Ref, Msg}, Req, State) ->
+websocket_info({timeout, _Ref, Msg}, State) ->
erlang:start_timer(1000, self(), <<"websocket_handle">>),
- {reply, {text, Msg}, Req, State};
-websocket_info(_Info, Req, State) ->
- {ok, Req, State}.
+ {reply, {text, Msg}, State};
+websocket_info(_Info, State) ->
+ {ok, State}.
diff --git a/test/ws_SUITE_data/ws_send_many.erl b/test/ws_SUITE_data/ws_send_many.erl
index 9cee75e..d621a3d 100644
--- a/test/ws_SUITE_data/ws_send_many.erl
+++ b/test/ws_SUITE_data/ws_send_many.erl
@@ -3,19 +3,19 @@
-module(ws_send_many).
-export([init/2]).
--export([websocket_init/2]).
--export([websocket_handle/3]).
--export([websocket_info/3]).
+-export([websocket_init/1]).
+-export([websocket_handle/2]).
+-export([websocket_info/2]).
init(Req, Opts) ->
{cowboy_websocket, Req, Opts}.
-websocket_init(Req, State) ->
+websocket_init(State) ->
erlang:send_after(10, self(), send_many),
- {ok, Req, State}.
+ {ok, State}.
-websocket_handle(_Frame, Req, State) ->
- {ok, Req, State}.
+websocket_handle(_Frame, State) ->
+ {ok, State}.
-websocket_info(send_many, Req, State = [{sequence, Sequence}]) ->
- {reply, Sequence, Req, State}.
+websocket_info(send_many, State = [{sequence, Sequence}]) ->
+ {reply, Sequence, State}.
diff --git a/test/ws_SUITE_data/ws_subprotocol.erl b/test/ws_SUITE_data/ws_subprotocol.erl
index a042dd2..3079bc6 100644
--- a/test/ws_SUITE_data/ws_subprotocol.erl
+++ b/test/ws_SUITE_data/ws_subprotocol.erl
@@ -3,16 +3,16 @@
-module(ws_subprotocol).
-export([init/2]).
--export([websocket_handle/3]).
--export([websocket_info/3]).
+-export([websocket_handle/2]).
+-export([websocket_info/2]).
init(Req, Opts) ->
[Protocol | _] = cowboy_req:parse_header(<<"sec-websocket-protocol">>, Req),
Req2 = cowboy_req:set_resp_header(<<"sec-websocket-protocol">>, Protocol, Req),
{cowboy_websocket, Req2, Opts, 1000}.
-websocket_handle(_Frame, Req, State) ->
- {ok, Req, State}.
+websocket_handle(_Frame, State) ->
+ {ok, State}.
-websocket_info(_Info, Req, State) ->
- {ok, Req, State}.
+websocket_info(_Info, State) ->
+ {ok, State}.
diff --git a/test/ws_SUITE_data/ws_timeout_cancel.erl b/test/ws_SUITE_data/ws_timeout_cancel.erl
index 7376140..8883d2f 100644
--- a/test/ws_SUITE_data/ws_timeout_cancel.erl
+++ b/test/ws_SUITE_data/ws_timeout_cancel.erl
@@ -3,18 +3,18 @@
-module(ws_timeout_cancel).
-export([init/2]).
--export([websocket_handle/3]).
--export([websocket_info/3]).
+-export([websocket_handle/2]).
+-export([websocket_info/2]).
init(Req, _) ->
erlang:start_timer(500, self(), should_not_cancel_timer),
{cowboy_websocket, Req, undefined, 1000}.
-websocket_handle({text, Data}, Req, State) ->
- {reply, {text, Data}, Req, State};
-websocket_handle({binary, Data}, Req, State) ->
- {reply, {binary, Data}, Req, State}.
+websocket_handle({text, Data}, State) ->
+ {reply, {text, Data}, State};
+websocket_handle({binary, Data}, State) ->
+ {reply, {binary, Data}, State}.
-websocket_info(_Info, Req, State) ->
+websocket_info(_Info, State) ->
erlang:start_timer(500, self(), should_not_cancel_timer),
- {ok, Req, State}.
+ {ok, State}.
diff --git a/test/ws_SUITE_data/ws_timeout_hibernate.erl b/test/ws_SUITE_data/ws_timeout_hibernate.erl
index 15cde66..b9646ac 100644
--- a/test/ws_SUITE_data/ws_timeout_hibernate.erl
+++ b/test/ws_SUITE_data/ws_timeout_hibernate.erl
@@ -3,14 +3,14 @@
-module(ws_timeout_hibernate).
-export([init/2]).
--export([websocket_handle/3]).
--export([websocket_info/3]).
+-export([websocket_handle/2]).
+-export([websocket_info/2]).
init(Req, _) ->
{cowboy_websocket, Req, undefined, 1000, hibernate}.
-websocket_handle(_Frame, Req, State) ->
- {ok, Req, State, hibernate}.
+websocket_handle(_Frame, State) ->
+ {ok, State, hibernate}.
-websocket_info(_Info, Req, State) ->
- {ok, Req, State, hibernate}.
+websocket_info(_Info, State) ->
+ {ok, State, hibernate}.