[−][src]Trait k8_client::prelude::Configurable
Provides additional methods when building a request for configuring various execution-related options on how the request should be sent.
This trait can be used to either configure requests individually by invoking
them on an [http::request::Builder
], or to configure the default settings
for an HttpClient
by invoking them on an
HttpClientBuilder
.
This trait is sealed and cannot be implemented for types outside of Isahc.
Provided methods
fn timeout(self, timeout: Duration) -> Self
Set a maximum amount of time that a request is allowed to take before being aborted.
If not set, no timeout will be enforced.
Examples
use isahc::prelude::*; use std::time::Duration; // This page is too slow and won't respond in time. let response = Request::get("https://httpbin.org/delay/10") .timeout(Duration::from_secs(5)) .body(())? .send() .expect_err("page should time out");
fn connect_timeout(self, timeout: Duration) -> Self
Set a timeout for the initial connection phase.
If not set, a connect timeout of 300 seconds will be used.
fn version_negotiation(self, negotiation: VersionNegotiation) -> Self
Configure how the use of HTTP versions should be negotiated with the server.
The default is VersionNegotiation::latest_compatible
.
Examples
use isahc::config::VersionNegotiation; use isahc::prelude::*; // Never use anything newer than HTTP/1.x for this client. let http11_client = HttpClient::builder() .version_negotiation(VersionNegotiation::http11()) .build()?; // HTTP/2 with prior knowledge. let http2_client = HttpClient::builder() .version_negotiation(VersionNegotiation::http2()) .build()?;
fn redirect_policy(self, policy: RedirectPolicy) -> Self
Set a policy for automatically following server redirects.
The default is to not follow redirects.
Examples
use isahc::config::RedirectPolicy; use isahc::prelude::*; // This URL redirects us to where we want to go. let response = Request::get("https://httpbin.org/redirect/1") .redirect_policy(RedirectPolicy::Follow) .body(())? .send()?; // This URL redirects too much! let error = Request::get("https://httpbin.org/redirect/10") .redirect_policy(RedirectPolicy::Limit(5)) .body(())? .send() .expect_err("too many redirects");
fn auto_referer(self) -> Self
Update the Referer
header automatically when following redirects.
fn authentication(self, authentication: Authentication) -> Self
Set one or more default HTTP authentication methods to attempt to use when authenticating with the server.
Depending on the authentication schemes enabled, you will also need to
set credentials to use for authentication using
Configurable::credentials
.
Examples
let client = HttpClient::builder() .authentication(Authentication::basic() | Authentication::digest()) .credentials(Credentials::new("clark", "qwerty")) .build()?;
fn credentials(self, credentials: Credentials) -> Self
Set the credentials to use for HTTP authentication.
This setting will do nothing unless you also set one or more
authentication methods using Configurable::authentication
.
fn tcp_keepalive(self, interval: Duration) -> Self
Enable TCP keepalive with a given probe interval.
fn tcp_nodelay(self) -> Self
Enables the TCP_NODELAY
option on connect.
fn interface(self, interface: impl Into<NetworkInterface>) -> Self
Bind local socket connections to a particular network interface.
Examples
Bind to an IP address.
use isahc::{ prelude::*, config::NetworkInterface, }; use std::net::IpAddr; // Bind to an IP address. let client = HttpClient::builder() .interface(IpAddr::from([192, 168, 1, 2])) .build()?; // Bind to an interface by name (not supported on Windows). let client = HttpClient::builder() .interface(NetworkInterface::name("eth0")) .build()?; // Reset to using whatever interface the TCP stack finds suitable (the // default). let request = Request::get("https://example.org") .interface(NetworkInterface::any()) .body(())?;
fn dial(self, dialer: impl Into<Dialer>) -> Self
Specify a socket to connect to instead of the using the host and port defined in the request URI.
Examples
Connecting to a Unix socket:
use isahc::{ config::Dialer, prelude::*, }; let request = Request::get("http://localhost/containers") .dial(Dialer::unix_socket("/path/to/my.sock")) .body(())?;
Connecting to a specific Internet socket address:
use isahc::{ config::Dialer, prelude::*, }; use std::net::Ipv4Addr; let request = Request::get("http://exmaple.org") // Actually issue the request to localhost on port 8080. The host // header will remain unchanged. .dial(Dialer::ip_socket((Ipv4Addr::LOCALHOST, 8080))) .body(())?;
fn proxy(self, proxy: impl Into<Option<Uri>>) -> Self
Set a proxy to use for requests.
The proxy protocol is specified by the URI scheme.
http
: Proxy. Default when no scheme is specified.https
: HTTPS Proxy. (Added in 7.52.0 for OpenSSL, GnuTLS and NSS)socks4
: SOCKS4 Proxy.socks4a
: SOCKS4a Proxy. Proxy resolves URL hostname.socks5
: SOCKS5 Proxy.socks5h
: SOCKS5 Proxy. Proxy resolves URL hostname.
By default no proxy will be used, unless one is specified in either the
http_proxy
or https_proxy
environment variables.
Setting to None
explicitly disables the use of a proxy.
Examples
Using http://proxy:80
as a proxy:
let client = HttpClient::builder() .proxy(Some("http://proxy:80".parse()?)) .build()?;
Explicitly disable the use of a proxy:
let client = HttpClient::builder() .proxy(None) .build()?;
fn proxy_blacklist<I, T>(self, hosts: I) -> Self where
I: IntoIterator<Item = T>,
T: Into<String>,
I: IntoIterator<Item = T>,
T: Into<String>,
Disable proxy usage for the provided list of hosts.
Examples
let client = HttpClient::builder() // Disable proxy for specified hosts. .proxy_blacklist(vec!["a.com", "b.org"]) .build()?;
fn proxy_authentication(self, authentication: Authentication) -> Self
Set one or more HTTP authentication methods to attempt to use when authenticating with a proxy.
Depending on the authentication schemes enabled, you will also need to
set credentials to use for authentication using
Configurable::proxy_credentials
.
Examples
let client = HttpClient::builder() .proxy("http://proxy:80".parse::<http::Uri>()?) .proxy_authentication(Authentication::basic()) .proxy_credentials(Credentials::new("clark", "qwerty")) .build()?;
fn proxy_credentials(self, credentials: Credentials) -> Self
Set the credentials to use for proxy authentication.
This setting will do nothing unless you also set one or more proxy
authentication methods using
Configurable::proxy_authentication
.
fn max_upload_speed(self, max: u64) -> Self
Set a maximum upload speed for the request body, in bytes per second.
The default is unlimited.
fn max_download_speed(self, max: u64) -> Self
Set a maximum download speed for the response body, in bytes per second.
The default is unlimited.
fn dns_servers<I, T>(self, servers: I) -> Self where
I: IntoIterator<Item = T>,
T: Into<SocketAddr>,
I: IntoIterator<Item = T>,
T: Into<SocketAddr>,
Set a list of specific DNS servers to be used for DNS resolution.
By default this option is not set and the system's built-in DNS resolver is used. This option can only be used if libcurl is compiled with c-ares, otherwise this option has no effect.
fn ssl_client_certificate(self, certificate: ClientCertificate) -> Self
Set a custom SSL/TLS client certificate to use for client connections.
If a format is not supported by the underlying SSL/TLS engine, an error will be returned when attempting to send a request using the offending certificate.
The default value is none.
Examples
use isahc::config::{ClientCertificate, PrivateKey}; use isahc::prelude::*; let response = Request::get("localhost:3999") .ssl_client_certificate(ClientCertificate::pem_file( "client.pem", PrivateKey::pem_file("key.pem", String::from("secret")), )) .body(())? .send()?;
let client = HttpClient::builder() .ssl_client_certificate(ClientCertificate::pem_file( "client.pem", PrivateKey::pem_file("key.pem", String::from("secret")), )) .build()?;
fn ssl_ca_certificate(self, certificate: CaCertificate) -> Self
Set a custom SSL/TLS CA certificate bundle to use for client connections.
The default value is none.
Notes
On Windows it may be necessary to combine this with
SslOption::DANGER_ACCEPT_REVOKED_CERTS
in order to work depending on
the contents of your CA bundle.
Examples
let client = HttpClient::builder() .ssl_ca_certificate(CaCertificate::file("ca.pem")) .build()?;
fn ssl_ciphers<I, T>(self, ciphers: I) -> Self where
I: IntoIterator<Item = T>,
T: Into<String>,
I: IntoIterator<Item = T>,
T: Into<String>,
Set a list of ciphers to use for SSL/TLS connections.
The list of valid cipher names is dependent on the underlying SSL/TLS engine in use. You can find an up-to-date list of potential cipher names at https://curl.haxx.se/docs/ssl-ciphers.html.
The default is unset and will result in the system defaults being used.
fn ssl_options(self, options: SslOption) -> Self
Set various options for this request that control SSL/TLS behavior.
Most options are for disabling security checks that introduce security risks, but may be required as a last resort. Note that the most secure options are already the default and do not need to be specified.
The default value is SslOption::NONE
.
Warning
You should think very carefully before using this method. Using any options that alter how certificates are validated can introduce significant security vulnerabilities.
Examples
let response = Request::get("https://badssl.com") .ssl_options(SslOption::DANGER_ACCEPT_INVALID_CERTS | SslOption::DANGER_ACCEPT_REVOKED_CERTS) .body(())? .send()?;
let client = HttpClient::builder() .ssl_options(SslOption::DANGER_ACCEPT_INVALID_CERTS | SslOption::DANGER_ACCEPT_REVOKED_CERTS) .build()?;
fn title_case_headers(self, enable: bool) -> Self
Enable or disable sending HTTP header names in Title-Case instead of lowercase form.
This option only affects user-supplied headers and does not affect
low-level headers that are automatically supplied for HTTP protocol
details, such as Connection
and Host
(unless you override such a
header yourself).
This option has no effect when using HTTP/2 or newer where headers are required to be lowercase.
fn metrics(self, enable: bool) -> Self
Enable or disable comprehensive per-request metrics collection.
When enabled, detailed timing metrics will be tracked while a request is
in progress, such as bytes sent and received, estimated size, DNS lookup
time, etc. For a complete list of the available metrics that can be
inspected, see the Metrics
documentation.
When enabled, to access a view of the current metrics values you can use
ResponseExt::metrics
.
While effort is taken to optimize hot code in metrics collection, it is likely that enabling it will have a small effect on overall throughput. Disabling metrics may be necessary for absolute peak performance.
By default metrics are disabled.