::: cowboy_handler The `cowboy_handler` middleware executes the handler passed through the environment values `handler` and `handler_opts`, and adds the result of this execution to the environment as the value `result`, indicating that the request has been handled and received a response. Environment input: * handler = module() * handler_opts = any() Environment output: * result = ok This module also defines the `cowboy_handler` behaviour that defines the basic interface for handlers. All Cowboy handlers implement at least the `init/2` callback, and may implement the `terminate/3` callback optionally. :: Terminate reasons The following values may be received as the terminate reason in the optional `terminate/3` callback. Different handler types may define additional terminate reasons. : normal The connection was closed normally. : {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. :: Callbacks : init(Req, Opts) -> {ok, Req, State} | {Module, Req, State} | {Module, Req, State, hibernate} | {Module, Req, State, Timeout} | {Module, Req, State, Timeout, hibernate} Types: * Req = cowboy_req:req() * Opts = any() * State = any() * Module = module() * Timeout = timeout() Process the request. This function can be used to switch to an alternate handler type by returning the name of the module to be used, along with a few options. For basic handlers this is the function where the response should be sent. If no response is sent, Cowboy will ensure that a `204 No Content` response is sent. A crash in this callback will result in `terminate/3` being called if it is defined, with the `State` argument set to the value of `Opts` originally given to the `init/2` callback. : terminate(Reason, Req, State) -> ok Types: * Reason = any() * Req = cowboy_req:req() * State = any() Perform any necessary cleanup of the state. This callback should release any resource currently in use, clear any active timer and reset the process to its original state, as it might be reused for future requests sent on the same connection. Typical plain HTTP handlers rarely need to use it. A crash in this callback or an invalid return value will result in the closing of the connection and the termination of the process. :: Exports : terminate(Reason, Req, State, Handler) -> ok Types: * Reason = any() * Req = cowboy_req:req() * State = any() * Handler = module() Call the optional `terminate/3` callback if it exists. This function should always be called at the end of the execution of a handler, to give it a chance to clean up or perform miscellaneous operations.