Allow passing options to sub protocols

Before this commit we had an issue where configuring a
Websocket connection was simply not possible without
doing magic, adding callbacks or extra return values.
The init/2 function only allowed setting hibernate
and timeout options.

After this commit, when switching to a different
type of handler you can either return

  {module, Req, State}

or

  {module, Req, State, Opts}

where Opts is any value (as far as the sub protocol
interface is concerned) and is ultimately checked
by the custom handlers.

A large protocol like Websocket would accept only
a map there, with many different options, while a
small interface like loop handlers would allow
passing hibernate and nothing else.

For Websocket, hibernate must be set from the
websocket_init/1 callback, because init/2 executes
in a separate process.

Sub protocols now have two callbacks: one with the
Opts value, one without.

The loop handler code was largely reworked and
simplified. It does not need to manage a timeout
or read from the socket anymore, it's the job of
the protocol code. A lot of unnecessary stuff was
therefore removed.

Websocket compression must now be enabled from
the handler options instead of per listener. This
means that a project can have two separate Websocket
handlers with different options. Compression is
still disabled by default, and the idle_timeout
value was changed from inifnity to 60000 (60 seconds),
as that's safer and is also a good value for mobile
devices.

1 files changed, 4 insertions, 10 deletions

diff --git a/src/cowboy_handler.erl b/src/cowboy_handler.erl
index 61c1b6a..3249f76 100644
--- a/src/cowboy_handler.erl
+++ b/src/cowboy_handler.erl
@@ -25,9 +25,7 @@
 
 -callback init(Req, any())
 	-> {ok | module(), Req, any()}
-	| {module(), Req, any(), hibernate}
-	| {module(), Req, any(), timeout()}
-	| {module(), Req, any(), timeout(), hibernate}
+	| {module(), Req, any(), any()}
 	when Req::cowboy_req:req().
 
 -callback terminate(any(), cowboy_req:req(), any()) -> ok.
@@ -41,13 +39,9 @@ execute(Req, Env=#{handler := Handler, handler_opts := HandlerOpts}) ->
 			Result = terminate(normal, Req2, State, Handler),
 			{ok, Req2, Env#{result => Result}};
 		{Mod, Req2, State} ->
-			Mod:upgrade(Req2, Env, Handler, State, infinity, run);
-		{Mod, Req2, State, hibernate} ->
-			Mod:upgrade(Req2, Env, Handler, State, infinity, hibernate);
-		{Mod, Req2, State, Timeout} ->
-			Mod:upgrade(Req2, Env, Handler, State, Timeout, run);
-		{Mod, Req2, State, Timeout, hibernate} ->
-			Mod:upgrade(Req2, Env, Handler, State, Timeout, hibernate)
+			Mod:upgrade(Req2, Env, Handler, State);
+		{Mod, Req2, State, Opts} ->
+			Mod:upgrade(Req2, Env, Handler, State, Opts)
 	catch Class:Reason ->
 		terminate({crash, Class, Reason}, Req, HandlerOpts, Handler),
 		erlang:raise(Class, Reason, erlang:get_stacktrace())