Struct solicit::client::SimpleClient [−] [src]

pub struct SimpleClient<S> where S: TransportStream {
    // some fields omitted
}

A struct implementing a simple HTTP/2 client.

This client works as an HTTP/1.1 client with a Keep-Alive connection and pipelining might work.

Multiple requests can be queued up (and sent to the server) by calling request multiple times, before any get_response.

Once a get_response is issued, the client blocks until it receives the response for the particular request that was referenced in the get_response call.

Therefore, by doing request -> get_response we can use the HTTP/2 connection as a Keep-Alive HTTP/1.1 connection and a pipelined flow by queuing up a sequence of requests and then "joining" over them by calling get_response for each of them.

The responses that are returned by the client are very raw representations of the response.

Examples

Issue a simple GET request using the helper get method. Premade connection passed to the client.

use std::net::TcpStream;
use solicit::http::HttpScheme;
use solicit::http::connection::HttpConnection;
use solicit::http::client::write_preface;
use solicit::client::SimpleClient;
use std::str;

// Prepare a stream manually... We must write the preface ourselves in this case.
// This is a more advanced way to use the client and the `HttpConnect` implementations
// should usually be preferred for their convenience.
let mut stream = TcpStream::connect(&("http2bin.org", 80)).unwrap();
write_preface(&mut stream);
// Connect to an HTTP/2 aware server
let conn = HttpConnection::<TcpStream, TcpStream>::with_stream(
                               stream,
                               HttpScheme::Http);
let mut client = SimpleClient::with_connection(conn, "http2bin.org".into()).unwrap();
let response = client.get(b"/", &[]).unwrap();
assert_eq!(response.stream_id, 1);
assert_eq!(response.status_code().unwrap(), 200);
// Dump the headers and the response body to stdout.
// They are returned as raw bytes for the user to do as they please.
// (Note: in general directly decoding assuming a utf8 encoding might not
// always work -- this is meant as a simple example that shows that the
// response is well formed.)
for header in response.headers.iter() {
    println!("{}: {}",
        str::from_utf8(&header.0).unwrap(),
        str::from_utf8(&header.1).unwrap());
}
println!("{}", str::from_utf8(&response.body).unwrap());

Issue a simple GET request using the helper get method. Pass a connector to establish a new connection.

use solicit::http::client::CleartextConnector;
use solicit::client::SimpleClient;
use std::str;

// Connect to an HTTP/2 aware server
let connector = CleartextConnector::new("http2bin.org");
let mut client = SimpleClient::with_connector(connector).unwrap();
let response = client.get(b"/", &[]).unwrap();
assert_eq!(response.stream_id, 1);
assert_eq!(response.status_code().unwrap(), 200);
// Dump the headers and the response body to stdout.
// They are returned as raw bytes for the user to do as they please.
// (Note: in general directly decoding assuming a utf8 encoding might not
// always work -- this is meant as a simple example that shows that the
// response is well formed.)
for header in response.headers.iter() {
    println!("{}: {}",
        str::from_utf8(&header.0).unwrap(),
        str::from_utf8(&header.1).unwrap());
}
println!("{}", str::from_utf8(&response.body).unwrap());

Methods

`impl<S> SimpleClient<S> where S: TransportStream`

`fn with_connection(conn: HttpConnection<S, S>, host: String) -> HttpResult<SimpleClient<S>>`

Create a new SimpleClient instance that will use the given HttpConnection to communicate to the server.

It assumes that the connection stream is initialized and will not automatically write the client preface.

`fn with_connector<C>(connector: C) -> HttpResult<SimpleClient<S>> where C: HttpConnect<Stream=S>`

A convenience constructor that first tries to establish an HTTP/2 connection by using the given connector instance (an implementation of the HttpConnect trait).

Panics

Currently, it panics if the connector returns an error.

`fn request(&mut self, method: &[u8], path: &[u8], extras: &[Header], body: Option<Vec<u8>>) -> HttpResult<StreamId>`

Send a request to the server. Blocks until the entire request has been sent.

The request is described by the method, the path on which it should be invoked and the "real" headers that should be included. Clients should never put pseudo-headers in the headers parameter, as those are automatically included based on metadata.

Returns

If the full request is successfully sent, returns the ID of the stream on which the request was sent. Clients can use this ID to refer to the response.

Any IO errors are propagated.

`fn get_response(&mut self, stream_id: StreamId) -> HttpResult<Response>`

Gets the response for the stream with the given ID. If a valid stream ID is given, it blocks until a response is received.

Returns

A Response if the response can be successfully read.

Any underlying IO errors are propagated. Errors in the HTTP/2 protocol also stop processing and are returned to the client.

`fn get(&mut self, path: &[u8], extra_headers: &[Header]) -> HttpResult<Response>`

Performs a GET request on the given path. This is a shortcut method for calling request followed by get_response for the returned stream ID.

`fn post(&mut self, path: &[u8], extra_headers: &[Header], body: Vec<u8>) -> HttpResult<Response>`

Performs a POST request on the given path.