Struct simplist::HttpSyncClient
[−]
[src]
pub struct HttpSyncClient { /* fields omitted */ }a synchronous, blocking http client.
a class for sending http requests and receiving http responses from a resource identified by a uri. this class uses tokio behind the scenes, but exposes a blocking, synchronous api.
all examples here assume that you have an existing tokio reactor you can use. if you not already have a tokio core, a complete example demonstrating the initialization and usage of tokio together with this http client is available at https://github.com/hinaria/simplist/blob/master/examples/basic-sync.rs.
methods
this struct provides two sets of operations for performing http operations: one for returning the response as a
Vec<u8>, and another for returning the response as a
String.
finally, there is a separate method, fn request(...) that takes a
HttpRequest and allows you to manually set the http method, as well as set http
headers.
rustdoc currently generates some pretty unreadable documentation for this struct, so we'll summarize the available methods here.
methods returning a Vec<u8>:
.
fn options(url, Option<body>) -> Result<Vec<u8>, HttpError>;
fn get (url) -> Result<Vec<u8>, HttpError>;
fn post (url, Option<body>) -> Result<Vec<u8>, HttpError>;
fn put (url, Option<body>) -> Result<Vec<u8>, HttpError>;
fn delete (url) -> Result<Vec<u8>, HttpError>;
fn head (url) -> Result<Vec<u8>, HttpError>;
fn trace (url) -> Result<Vec<u8>, HttpError>;
fn connect(url) -> Result<Vec<u8>, HttpError>;
fn patch (url, Option<body>) -> Result<Vec<u8>, HttpError>;
methods returning a String<u8>:
.
fn options_string(url, Option<body>) -> Result<String, HttpError>;
fn get_string (url) -> Result<String, HttpError>;
fn post_string (url, Option<body>) -> Result<String, HttpError>;
fn put_string (url, Option<body>) -> Result<String, HttpError>;
fn delete_string (url) -> Result<String, HttpError>;
fn head_string (url) -> Result<String, HttpError>;
fn trace_string (url) -> Result<String, HttpError>;
fn connect_string(url) -> Result<String, HttpError>;
fn patch_string (url, Option<body>) -> Result<String, HttpError>;
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let html = http.get_string("https://hinaria.com")?; println!("{:?}", html); // => "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"utf-8\"> ..."
Methods
impl HttpSyncClient[src]
fn new(remote: Remote) -> HttpSyncClient[src]
creates a new http client.
this method is very cheap, and does not perform any kind of initialization.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle);
fn request(&self, request: HttpRequest) -> Result<HttpSyncResponse, HttpError>[src]
sends a http request.
examples
use simplist::HttpClient; use simplist::HttpMethod; let http = HttpClient::new(handle); let url = "https://hinaria.com".parse()?; let operation = HttpRequest::with(url, HttpMethod::Get); let response = http.request(operation)?; assert_eq!(response.status(), StatusCode::Ok);
impl HttpSyncClient[src]
fn options<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
Vec<u8>.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post("https://hinaria.com/users/@me/database", body)?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn options_string<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
String.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post_string("https://hinaria.com/users/@me/database", body)?, "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"utf-8\"> ...");
impl HttpSyncClient[src]
fn get<TUrl>(&self, url: TUrl) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
sends an http request, returning the response as a
Vec<u8>.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); assert_eq!( &http.get("https://hinaria.com")?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn get_string<TUrl>(&self, url: TUrl) -> Result<String, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
impl HttpSyncClient[src]
fn post<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
Vec<u8>.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post("https://hinaria.com/users/@me/database", body)?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn post_string<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
String.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post_string("https://hinaria.com/users/@me/database", body)?, "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"utf-8\"> ...");
impl HttpSyncClient[src]
fn put<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
Vec<u8>.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post("https://hinaria.com/users/@me/database", body)?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn put_string<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
String.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post_string("https://hinaria.com/users/@me/database", body)?, "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"utf-8\"> ...");
impl HttpSyncClient[src]
fn delete<TUrl>(&self, url: TUrl) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
sends an http request, returning the response as a
Vec<u8>.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); assert_eq!( &http.get("https://hinaria.com")?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn delete_string<TUrl>(&self, url: TUrl) -> Result<String, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
impl HttpSyncClient[src]
fn head<TUrl>(&self, url: TUrl) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
sends an http request, returning the response as a
Vec<u8>.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); assert_eq!( &http.get("https://hinaria.com")?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn head_string<TUrl>(&self, url: TUrl) -> Result<String, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
impl HttpSyncClient[src]
fn trace<TUrl>(&self, url: TUrl) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
sends an http request, returning the response as a
Vec<u8>.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); assert_eq!( &http.get("https://hinaria.com")?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn trace_string<TUrl>(&self, url: TUrl) -> Result<String, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
impl HttpSyncClient[src]
fn connect<TUrl>(&self, url: TUrl) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
sends an http request, returning the response as a
Vec<u8>.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); assert_eq!( &http.get("https://hinaria.com")?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn connect_string<TUrl>(&self, url: TUrl) -> Result<String, HttpError> where
TUrl: IntoUrl, [src]
TUrl: IntoUrl,
impl HttpSyncClient[src]
fn patch<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<Vec<u8>, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
Vec<u8>.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post("https://hinaria.com/users/@me/database", body)?, &[60, 33, 68, 79, 67, 84, 89, 80, 69, 32, 104, 116, ...]);
fn patch_string<TUrl, TContent>(
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>, [src]
&self,
url: TUrl,
content: Option<TContent>
) -> Result<String, HttpError> where
TUrl: IntoUrl,
TContent: Into<HttpContent>,
sends an asynchronous http request, returning the response as a
String.
the request body can be any type that is convertible to a HttpContent.
refer to HttpContent to see a list of types that can be used.
examples
use simplist::HttpSyncClient; let http = HttpSyncClient::new(handle); let body = Some("{ id: 1234 }"); assert_eq!( &http.post_string("https://hinaria.com/users/@me/database", body)?, "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"utf-8\"> ...");
Trait Implementations
impl Clone for HttpSyncClient[src]
fn clone(&self) -> HttpSyncClient[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)1.0.0[src]
Performs copy-assignment from source. Read more