Documentation

Gets a single header from the list

If you want to skip the footers, i.e., they are empty, use this function to convert an ordinary Source to a DataAndConclusion.

The name part of a header

The value part of a header

The complete header

List of headers. The first part of each tuple is the header name (be sure to conform to the HTTP/2 convention of using lowercase) and the second part is the headers contents. This list needs to include the special :method, :scheme, :authority and :path pseudo-headers for requests; and :status (with a plain numeric value represented in ascii digits) for responses.

Finalization headers. If you don't know what they are, chances are that you don't need to worry about them for now. The support in this library for those are at best sketchy.

A request is a set of headers and a request body.... which will normally be empty, except for POST and PUT requests. But this library enforces none of that.

Finalization headers

Data related to the request

Sometimes a response needs to be handled a bit specially, for example by reporting delivery details back to the worker

Main type of this library. You implement one of these for your server. This is a callback that the library calls as soon as it has all the headers of a request. For GET requests that's the entire request basically, but for POST and PUT requests this is just before the data starts arriving to the server.

It is important that you consume the data in the cases where there is an input stream, otherwise the memory is lost for the duration of the request, and a malicious client can use that.

Also, notice that when handling requests your worker can be interrupted with an asynchronous exception of type StreamCancelledException, if the peer cancels the stream

Has kind * -> * Used to allow for registered cleanup functions to be safely called, evenspecially in the event of a BrowserUser hanging-up the connection before the worker has finished doing its work. Alleviates the need for handling async. execeptions.

You use this type to answer a request. The Headers are thus response headers and they should contain the :status pseudo-header. The PushedStreams is a list of pushed streams... they will be pushed to the client.

A list of pushed streams. Notice that a list of IO computations is required here. These computations only happen when and if the streams are pushed to the client. The lazy nature of Haskell helps to avoid unneeded computations if the streams are not going to be sent to the client.

A pushed stream, represented by a list of request headers, a list of response headers, and the usual response body (which may include final footers (not implemented yet)).

A source-like conduit with the data returned in the response. The return value of the conduit is a list of footers. For now that list can be anything (even bottom), I'm not handling it just yet.

A CoherentWorker is a simplified callback that you can implement to handle requests. Then you can convert it to an AwareWorker with tupledPrincipalStreamToPrincipalStream.

This is a Source conduit (see Haskell Data.Conduit library from Michael Snoyman) that you can use to retrieve the data sent by the peer piece-wise.

A tuple representing the data alone that you usually need to give as a response, that is, the headers in the response (including the HTTP/2 :status), any pushed streams, a stream with the response data and the footers.

A tuple representing the data alone usually needed to create a response. That is, the headers (including HTTP/2 :path, :authority, etc) and maybe an input data stream for requests that include it, that is, POST and PUT.

First argument is the ordinal of this data frame, second an approximation of when the frame was delivered, according to the monotonic clock. Do not linger in this call, it may delay some important thread

Types of interrupt effects that can be signaled by aware workers. These include whole connection shutdowns and stream resets. In all the cases, the reason given will be NO_ERROR.

Valid priority effects

In certain circunstances a stream can use an internal priority, not given by the browser and the protocol. Lowest values here are given more priority. Default (when Nothing) is given zero. Cases with negative numbers also work. Since higher numbers mean *lower* priority, we often call this number *calm*, so that higher numbers mean higher calm.

Notice that SecondTransfer still assigns "system priorities" to frames which are used before the priorities computed by this mechanism.

Convert between the two types of callback.