Struct tonic::transport::channel::Endpoint

pub struct Endpoint { /* private fields */ }

Channel builder.

This struct is used to build and configure HTTP/2 channels.

Implementations

impl Endpoint

pub fn from_static(s: &'static str) -> Self

Convert an Endpoint from a static string.

Panics

This function panics if the argument is an invalid URI.

Endpoint::from_static("https://example.com");

pub fn from_shared(s: impl Into<Bytes>) -> Result<Self, InvalidUri>

Convert an Endpoint from shared bytes.

Endpoint::from_shared("https://example.com".to_string());

pub fn user_agent<T>(self, user_agent: T) -> Result<Self, Error>where
    T: TryInto<HeaderValue>,

Set a custom user-agent header.

user_agent will be prepended to Tonic’s default user-agent string (tonic/x.x.x). It must be a value that can be converted into a valid http::HeaderValue or building the endpoint will fail.

builder.user_agent("Greeter").expect("Greeter should be a valid header value");
// user-agent: "Greeter tonic/x.x.x"

pub fn timeout(self, dur: Duration) -> Self

Apply a timeout to each request.

builder.timeout(Duration::from_secs(5));

Notes

This does not set the timeout metadata (grpc-timeout header) on the request, meaning the server will not be informed of this timeout, for that use Request::set_timeout.

pub fn connect_timeout(self, dur: Duration) -> Self

Apply a timeout to connecting to the uri.

Defaults to no timeout.

builder.connect_timeout(Duration::from_secs(5));

pub fn tcp_keepalive(self, tcp_keepalive: Option<Duration>) -> Self

Set whether TCP keepalive messages are enabled on accepted connections.

If None is specified, keepalive is disabled, otherwise the duration specified will be the time to remain idle before sending TCP keepalive probes.

Default is no keepalive (None)

pub fn concurrency_limit(self, limit: usize) -> Self

Apply a concurrency limit to each request.

builder.concurrency_limit(256);

pub fn rate_limit(self, limit: u64, duration: Duration) -> Self

Apply a rate limit to each request.

builder.rate_limit(32, Duration::from_secs(1));

pub fn initial_stream_window_size(self, sz: impl Into<Option<u32>>) -> Self

Sets the SETTINGS_INITIAL_WINDOW_SIZE option for HTTP2 stream-level flow control.

Default is 65,535

pub fn initial_connection_window_size(self, sz: impl Into<Option<u32>>) -> Self

Sets the max connection-level flow control for HTTP2

Default is 65,535

pub fn tls_config(self, tls_config: ClientTlsConfig) -> Result<Self, Error>

Configures TLS for the endpoint.

pub fn tcp_nodelay(self, enabled: bool) -> Self

Set the value of TCP_NODELAY option for accepted connections. Enabled by default.

pub fn http2_keep_alive_interval(self, interval: Duration) -> Self

Set http2 KEEP_ALIVE_INTERVAL. Uses hyper’s default otherwise.

pub fn keep_alive_timeout(self, duration: Duration) -> Self

Set http2 KEEP_ALIVE_TIMEOUT. Uses hyper’s default otherwise.

pub fn keep_alive_while_idle(self, enabled: bool) -> Self

Set http2 KEEP_ALIVE_WHILE_IDLE. Uses hyper’s default otherwise.

pub fn http2_adaptive_window(self, enabled: bool) -> Self

Sets whether to use an adaptive flow control. Uses hyper’s default otherwise.

pub async fn connect(&self) -> Result<Channel, Error>

Create a channel from this config.

pub fn connect_lazy(&self) -> Channel

Create a channel from this config.

The channel returned by this method does not attempt to connect to the endpoint until first use.

pub async fn connect_with_connector<C>(
    &self,
    connector: C
) -> Result<Channel, Error>where
    C: MakeConnection<Uri> + Send + 'static,
    C::Connection: Unpin + Send + 'static,
    C::Future: Send + 'static,
    Box<dyn Error + Send + Sync>: From<C::Error> + Send + 'static,

Connect with a custom connector.

This allows you to build a Channel that uses a non-HTTP transport. See the uds example for an example on how to use this function to build channel that uses a Unix socket transport.

The connect_timeout will still be applied.

pub fn connect_with_connector_lazy<C>(
    &self,
    connector: C
) -> Result<Channel, Error>where
    C: MakeConnection<Uri> + Send + 'static,
    C::Connection: Unpin + Send + 'static,
    C::Future: Send + 'static,
    Box<dyn Error + Send + Sync>: From<C::Error> + Send + 'static,

Connect with a custom connector lazily.

This allows you to build a Channel that uses a non-HTTP transport connec to it lazily.

See the uds example for an example on how to use this function to build channel that uses a Unix socket transport.

pub fn uri(&self) -> &Uri

Get the endpoint uri.

let endpoint = Endpoint::from_static("https://example.com");

assert_eq!(endpoint.uri(), &Uri::from_static("https://example.com"));

Trait Implementations

impl Clone for Endpoint

fn clone(&self) -> Endpoint

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Endpoint

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

Formats the value using the given formatter.

impl From<Uri> for Endpoint

fn from(uri: Uri) -> Self

Converts to this type from the input type.

impl FromStr for Endpoint

type Err = InvalidUri

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl TryFrom<&'static str> for Endpoint

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from(t: &'static str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Bytes> for Endpoint

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from(t: Bytes) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for Endpoint

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from(t: String) -> Result<Self, Self::Error>

Performs the conversion.