path: root/doc
diff options
authorLoïc Hoguin <[email protected]>2017-02-18 18:26:20 +0100
committerLoïc Hoguin <[email protected]>2017-02-18 18:26:20 +0100
commita45813c60f0f983a24ea29d491b37f0590fdd087 (patch)
treec7e741ac4a684b365e70f7ff73d0c4b6e34232a7 /doc
parent80f8cda7ff8fe6a575b4c2eaedd8451acf4fcef3 (diff)
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.
Diffstat (limited to 'doc')
8 files changed, 69 insertions, 106 deletions
diff --git a/doc/src/guide/loop_handlers.asciidoc b/doc/src/guide/loop_handlers.asciidoc
index 2c82c53..dbee927 100644
--- a/doc/src/guide/loop_handlers.asciidoc
+++ b/doc/src/guide/loop_handlers.asciidoc
@@ -34,7 +34,7 @@ loop handler behavior. This tuple may optionally contain
a timeout value and/or the atom `hibernate` to make the
process enter hibernation until a message is received.
-This snippet enables the loop handler.
+This snippet enables the loop handler:
@@ -42,14 +42,12 @@ init(Req, State) ->
{cowboy_loop, Req, State}.
-However it is largely recommended that you set a timeout
-value. The next example sets a timeout value of 30s and
-also makes the process hibernate.
+This also makes the process hibernate:
init(Req, State) ->
- {cowboy_loop, Req, State, 30000, hibernate}.
+ {cowboy_loop, Req, State, hibernate}.
=== Receive loop
@@ -123,25 +121,6 @@ a subsequent request.
Please refer to the xref:handlers[Handlers chapter]
for general instructions about cleaning up.
-=== Timeout
-Note that this feature currently does not work. It will be
-brought back in a future 2.0 pre-release.
-By default Cowboy will not attempt to close the connection
-if there is no activity from the client. This is not always
-desirable, which is why you can set a timeout. Cowboy will
-close the connection if no data was received from the client
-after the configured time. The timeout only needs to be set
-once and can't be modified afterwards.
-Because the request may have had a body, or may be followed
-by another request, Cowboy is forced to buffer all data it
-receives. This data may grow to become too large though,
-so there is a configurable limit for it. The default buffer
-size is of 5000 bytes, but it may be changed by setting the
-`loop_max_buffer` middleware environment value.
=== Hibernate
To save memory, you may hibernate the process in between
diff --git a/doc/src/guide/sub_protocols.asciidoc b/doc/src/guide/sub_protocols.asciidoc
index 2ab96bc..83fa975 100644
--- a/doc/src/guide/sub_protocols.asciidoc
+++ b/doc/src/guide/sub_protocols.asciidoc
@@ -20,31 +20,31 @@ init(Req, State) ->
{cowboy_websocket, Req, State}.
-The return value may also have a `Timeout` value and/or the
-atom `hibernate`. These options are useful for long living
-connections. When they are not provided, the timeout value
-defaults to `infinity` and the hibernate value to `run`.
+The returned tuple may also have a fourth element containing
+options for the sub protocol. No option is universal. While
+it will usually be a map of options, it doesn't have to be.
+For example loop handlers accept the atom `hibernate`.
The following snippet switches to the `my_protocol` sub
protocol, sets the timeout value to 5 seconds and enables
-// @todo Yeah maybe what we really need is an Opts map.
init(Req, State) ->
- {my_protocol, Req, State, 5000, hibernate}.
+ {my_protocol, Req, State, #{
+ timeout => 5000,
+ compress => true}}.
-If a sub protocol does not make use of these options, it should
-crash if it receives anything other than the default values.
+Sub protocols should ignore unknown options so as to not waste
+resources doing unnecessary validation.
=== Upgrade
-After the `init/2` function returns, Cowboy will then call the
-`upgrade/6` function. This is the only callback defined by the
-`cowboy_sub_protocol` behavior.
+After the `init/2` function returns, Cowboy will call either
+the `upgrade/4` or the `upgrade/5` function. The former is called
+when no options were given; the latter when they were given.
The function is named `upgrade` because it mimics the mechanism
of HTTP protocol upgrades. For some sub protocols, like Websocket,
@@ -53,16 +53,19 @@ only an upgrade at Cowboy's level and the client has nothing to
do about it.
The upgrade callback receives the Req object, the middleware
-environment, the handler and its options, and the aforementioned
-timeout and hibernate values.
+environment, the handler and its state, and for `upgrade/5`
+also the aformentioned options.
-upgrade(Req, Env, Handler, HandlerOpts, Timeout, Hibernate) ->
+upgrade(Req, Env, Handler, State) ->
+ %% Sub protocol code here.
+upgrade(Req, Env, Handler, State, Opts) ->
%% Sub protocol code here.
-This callback is expected to behave like a middleware and to
+These callbacks are expected to behave like middlewares and to
return an updated environment and Req object.
Sub protocols are expected to call the `cowboy_handler:terminate/4`
diff --git a/doc/src/guide/ws_handlers.asciidoc b/doc/src/guide/ws_handlers.asciidoc
index 011aa31..2c38b87 100644
--- a/doc/src/guide/ws_handlers.asciidoc
+++ b/doc/src/guide/ws_handlers.asciidoc
@@ -60,13 +60,13 @@ be:
init(Req, State) ->
case cowboy_req:parse_header(<<"sec-websocket-protocol">>, Req) of
undefined ->
- {ok, Req, State};
+ {cowboy_websocket, Req, State};
Subprotocols ->
case lists:keymember(<<"mqtt">>, 1, Subprotocols) of
true ->
Req2 = cowboy_req:set_resp_header(<<"sec-websocket-protocol">>,
<<"mqtt">>, Req),
- {ok, Req2, State};
+ {cowboy_websocket, Req2, State};
false ->
{stop, Req, State}
@@ -210,12 +210,13 @@ than needed.
The `init/2` callback can set the timeout to be used
for the connection. For example, this would make Cowboy
-close connections idle for more than 60 seconds:
+close connections idle for more than 30 seconds:
init(Req, State) ->
- {cowboy_websocket, Req, State, 60000}.
+ {cowboy_websocket, Req, State, #{
+ idle_timeout => 30000}}.
This value cannot be changed once it is set. It defaults to
diff --git a/doc/src/guide/ws_protocol.asciidoc b/doc/src/guide/ws_protocol.asciidoc
index 127c829..8fa0673 100644
--- a/doc/src/guide/ws_protocol.asciidoc
+++ b/doc/src/guide/ws_protocol.asciidoc
@@ -65,6 +65,5 @@ Cowboy's Websocket implementation also includes the
permessage-deflate and x-webkit-deflate-frame compression
-Cowboy will automatically use compression as long as the
-`websocket_compress` protocol option is set when starting
-the listener.
+Cowboy will automatically use compression when the
+`compress` option is returned from the `init/2` function.
diff --git a/doc/src/manual/cowboy_app.asciidoc b/doc/src/manual/cowboy_app.asciidoc
index 42c03e4..29c4497 100644
--- a/doc/src/manual/cowboy_app.asciidoc
+++ b/doc/src/manual/cowboy_app.asciidoc
@@ -59,8 +59,6 @@ Middlewares:
* ssl - Secure communication over sockets
* crypto - Crypto functions
-// @todo Explicitly depend on ssl.
All these applications must be started before the `cowboy`
application. To start Cowboy and all dependencies at once:
diff --git a/doc/src/manual/cowboy_loop.asciidoc b/doc/src/manual/cowboy_loop.asciidoc
index 3f4cfed..605e265 100644
--- a/doc/src/manual/cowboy_loop.asciidoc
+++ b/doc/src/manual/cowboy_loop.asciidoc
@@ -29,8 +29,6 @@ Loop handlers implement the following interface:
init(Req, State)
-> {cowboy_loop, Req, State}
| {cowboy_loop, Req, State, hibernate}
- | {cowboy_loop, Req, State, timeout()}
- | {cowboy_loop, Req, State, timeout(), hibernate}
info(Info, Req, State)
-> {ok, Req, State}
@@ -42,7 +40,7 @@ terminate(Reason, Req, State) -> ok %% optional
Req :: cowboy_req:req()
State :: any()
Info :: any()
-Reason :: stop | timeout
+Reason :: stop
| {crash, error | exit | throw, any()}
@@ -65,37 +63,15 @@ stop::
The handler requested to close the connection by returning
a `stop` tuple.
- The connection has been closed due to inactivity. The timeout
- value can be configured from `init/2`. The response sent when
- this happens is a `204 No Content`.
{crash, Class, Reason}::
A crash occurred in the handler. `Class` and `Reason` can be
used to obtain more information about the crash. The function
`erlang:get_stacktrace/0` can also be called to obtain the
stacktrace of the process when the crash occurred.
-//{error, overflow}::
-// The connection is being closed and the process terminated
-// because the buffer Cowboy uses to keep data sent by the
-// client has reached its maximum. The buffer size can be
-// configured through the environment value `loop_max_buffer`
-// and defaults to 5000 bytes.
-// +
-// If the long running request comes with a body it is recommended
-// to process this body before switching to the loop sub protocol.
-//{error, closed}::
-// The socket has been closed brutally without a close frame being
-// received first.
-//{error, Reason}::
-// A socket error ocurred.
== Changelog
-* *2.0*: Cowboy temporarily no longer checks the socket for data with HTTP/1.1.
+* *2.0*: Loop handlers no longer need to handle overflow/timeouts.
* *1.0*: Behavior introduced.
== See also
diff --git a/doc/src/manual/cowboy_rest.asciidoc b/doc/src/manual/cowboy_rest.asciidoc
index 26515fb..73adb23 100644
--- a/doc/src/manual/cowboy_rest.asciidoc
+++ b/doc/src/manual/cowboy_rest.asciidoc
@@ -21,9 +21,6 @@ REST handlers implement the following interface:
init(Req, State)
-> {cowboy_rest, Req, State}
- | {cowboy_rest, Req, State, hibernate}
- | {cowboy_rest, Req, State, timeout()}
- | {cowboy_rest, Req, State, timeout(), hibernate}
Callback(Req, State)
-> {Result, Req, State}
diff --git a/doc/src/manual/cowboy_websocket.asciidoc b/doc/src/manual/cowboy_websocket.asciidoc
index 73f5e72..b728edf 100644
--- a/doc/src/manual/cowboy_websocket.asciidoc
+++ b/doc/src/manual/cowboy_websocket.asciidoc
@@ -10,31 +10,6 @@ The module `cowboy_websocket` implements Websocket
as a Ranch protocol. It also defines a callback interface
for handling Websocket connections.
-== Options
-opts() :: #{
- websocket_compress := boolean()
-Configuration for the Websocket protocol.
-This configuration is passed to Cowboy when starting listeners
-using `cowboy:start_clear/4` or `cowboy:start_tls/4` functions.
-It can be updated without restarting listeners using the
-Ranch functions `ranch:get_protocol_options/1` and
-The default value is given next to the option name:
-websocket_compress (false)::
- Whether to enable the Websocket frame compression
- extension. Frames will only be compressed for the
- clients that support this extension.
== Callbacks
Websocket handlers must implement the following callback
@@ -44,9 +19,7 @@ interface:
init(Req, State)
-> {cowboy_websocket, Req, State}
- | {cowboy_websocket, Req, State, hibernate}
- | {cowboy_websocket, Req, State, timeout()}
- | {cowboy_websocket, Req, State, timeout(), hibernate}
+ | {cowboy_websocket, Req, State, Opts}
websocket_init(State) -> CallResult %% optional
websocket_handle(InFrame, State) -> CallResult
@@ -56,6 +29,7 @@ terminate(Reason, undefined, State) -> ok %% optional
Req :: cowboy_req:req()
State :: any()
+Opts :: cowboy_websocket:opts()
InFrame :: {text | binary | ping | pong, binary()}
OutFrame :: cow_ws:frame()
Info :: any()
@@ -152,6 +126,42 @@ timeout::
{error, Reason}::
A socket error ocurred.
+== Types
+=== opts()
+opts() :: #{
+ compress => boolean(),
+ idle_timeout => timeout()
+Websocket handler options.
+This configuration is passed to Cowboy from the `init/2`
+init(Req, State) ->
+ Opts = #{compress => true},
+ {cowboy_websocket, Req, State, Opts}.
+The default value is given next to the option name:
+compress (false)::
+ Whether to enable the Websocket frame compression
+ extension. Frames will only be compressed for the
+ clients that support this extension.
+idle_timeout (60000)::
+ Time in milliseconds that Cowboy will keep the
+ connection open without receiving anything from
+ the client.
== Changelog
* *2.0*: The Req object is no longer passed to Websocket callbacks.