Struct tiny_http::Request
[−]
[src]
pub struct Request { /* fields omitted */ }
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 orConnection: 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.
Methods
impl Request
[src]
fn secure(&self) -> bool
Returns true if the request was made through HTTPS.
fn method(&self) -> &Method
Returns the method requested by the client (eg. GET
, POST
, etc.).
fn url(&self) -> &str
Returns the resource requested by the client.
fn headers(&self) -> &[Header]
Returns a list of all headers sent by the client.
fn http_version(&self) -> &HTTPVersion
Returns the HTTP version of the request.
fn body_length(&self) -> Option<usize>
Returns the length of the body in bytes.
Returns None
if the length is unknown.
fn remote_addr(&self) -> &SocketAddr
Returns the address of the client that sent this request.
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.
fn as_reader(&mut self) -> &mut 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(); }Run
If the client sent a Expect: 100-continue
header with the request, calling this
function will send back a 100 Continue
response.
fn into_writer(self) -> Box<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.
fn respond<R>(self, response: Response<R>) -> Result<(), IoError> where R: Read
Sends a response to this request.
Trait Implementations
impl Debug for Request
[src]
fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>
Formats the value using the given formatter.