Struct Request

pub struct Request { /* private fields */ }

Represents an HTTP request made by a client.

A Request object is what is produced by the server, and is your what your code must analyse and answer.

This object implements the Send trait, therefore you can dispatch your requests to worker threads.

Pipelining

If a client sends multiple requests in a row (without waiting for the response), then you will get multiple Request objects simultaneously. This is called requests pipelining. Tiny-http automatically reorders the responses so that you don’t need to worry about the order in which you call respond or into_writer.

This mechanic is disabled if:

• The body of a request is large enough (handling requires pipelining requires storing the body of the request in a buffer ; if the body is too big, tiny-http will avoid doing that)
• A request sends a Expect: 100-continue header (which means that the client waits to know whether its body will be processed before sending it)
• A request sends a Connection: close header or Connection: upgrade header (used for websockets), which indicates that this is the last request that will be received on this connection

Automatic cleanup

If a Request object is destroyed without into_writer or respond being called, an empty response with a 500 status code (internal server error) will automatically be sent back to the client. This means that if your code fails during the handling of a request, this “internal server error” response will automatically be sent during the stack unwinding.

Testing

If you want to build fake requests to test your server, use TestRequest.

Implementations

impl Request

pub fn secure(&self) -> bool

Returns true if the request was made through HTTPS.

pub fn method(&self) -> &Method

Returns the method requested by the client (eg. GET, POST, etc.).

pub fn url(&self) -> &str

Returns the resource requested by the client.

pub fn headers(&self) -> &[Header]

Returns a list of all headers sent by the client.

pub fn http_version(&self) -> &HTTPVersion

Returns the HTTP version of the request.

pub fn body_length(&self) -> Option<usize>

Returns the length of the body in bytes.

Returns None if the length is unknown.

pub fn remote_addr(&self) -> Option<&SocketAddr>

Returns the address of the client that sent this request.

The address is always Some for TCP listeners, but always None for UNIX listeners (as the remote address of a UNIX client is almost always unnamed).

Note that this is gathered from the socket. If you receive the request from a proxy, this function will return the address of the proxy and not the address of the actual user.

pub fn upgrade<R: Read>( self, protocol: &str, response: Response<R>, ) -> Box<dyn ReadWrite + Send>

Sends a response with a Connection: upgrade header, then turns the Request into a Stream.

The main purpose of this function is to support websockets. If you detect that the request wants to use some kind of protocol upgrade, you can call this function to obtain full control of the socket stream.

If you call this on a non-websocket request, tiny-http will wait until this Stream object is destroyed before continuing to read or write on the socket. Therefore you should always destroy it as soon as possible.

pub fn as_reader(&mut self) -> &mut dyn Read

Allows to read the body of the request.

Example

let mut request = server.recv().unwrap();

if get_content_type(&request) == "application/json" {
    let mut content = String::new();
    request.as_reader().read_to_string(&mut content).unwrap();
    let json: Json = content.parse().unwrap();
}

If the client sent a Expect: 100-continue header with the request, calling this function will send back a 100 Continue response.

pub fn into_writer(self) -> Box<dyn Write + Send + 'static>

Turns the Request into a writer.

The writer has a raw access to the stream to the user. This function is useful for things like CGI.

Note that the destruction of the Writer object may trigger some events. For exemple if a client has sent multiple requests and the requests have been processed in parallel, the destruction of a writer will trigger the writing of the next response. Therefore you should always destroy the Writer as soon as possible.

pub fn respond<R>(self, response: Response<R>) -> Result<(), IoError>

where R: Read,

Sends a response to this request.

Trait Implementations

impl Debug for Request

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Drop for Request

fn drop(&mut self)

Executes the destructor for this type.

impl From<TestRequest> for Request

fn from(mock: TestRequest) -> Request

Converts to this type from the input type.