Struct trust_dns_client::client::AsyncClient

pub struct AsyncClient<R> where
    R: Future<Output = Result<DnsResponse, ProtoError>> + 'static + Send + Unpin,  { /* fields omitted */ }

A DNS Client implemented over futures-rs.

This Client is generic and capable of wrapping UDP, TCP, and other underlying DNS protocol implementations.

Implementations

impl AsyncClient<DnsMultiplexerSerialResponse>

pub fn new<F, S>(
    stream: F,
    stream_handle: Box<dyn DnsStreamHandle>,
    signer: Option<Arc<Signer>>
) -> AsyncClientConnect<DnsMultiplexerConnect<F, S, Signer>, DnsMultiplexer<S, Signer>, DnsMultiplexerSerialResponse> where
    F: Future<Output = Result<S, ProtoError>> + Send + Unpin + 'static,
    S: DnsClientStream + Unpin + 'static, 

Spawns a new AsyncClient Stream. This uses a default timeout of 5 seconds for all requests.

Arguments

• stream - A stream of bytes that can be used to send/receive DNS messages (see TcpClientStream or UdpClientStream)
• stream_handle - The handle for the stream on which bytes can be sent/received.
• signer - An optional signer for requests, needed for Updates with Sig0, otherwise not needed

pub fn with_timeout<F, S>(
    stream: F,
    stream_handle: Box<dyn DnsStreamHandle>,
    timeout_duration: Duration,
    signer: Option<Arc<Signer>>
) -> AsyncClientConnect<DnsMultiplexerConnect<F, S, Signer>, DnsMultiplexer<S, Signer>, DnsMultiplexerSerialResponse> where
    F: Future<Output = Result<S, ProtoError>> + 'static + Send + Unpin,
    S: DnsClientStream + Unpin + 'static, 

Spawns a new AsyncClient Stream.

Arguments

• stream - A stream of bytes that can be used to send/receive DNS messages (see TcpClientStream or UdpClientStream)
• timeout_duration - All requests may fail due to lack of response, this is the time to wait for a response before canceling the request.
• stream_handle - The handle for the stream on which bytes can be sent/received.
• signer - An optional signer for requests, needed for Updates with Sig0, otherwise not needed

impl<R> AsyncClient<R> where
    R: Future<Output = Result<DnsResponse, ProtoError>> + 'static + Send + Unpin, 

pub fn connect<F, S>(connect_future: F) -> AsyncClientConnect<F, S, R> where
    S: DnsRequestSender<DnsResponseFuture = R>,
    F: Future<Output = Result<S, ProtoError>> + 'static + Send + Unpin, 

Returns a future, which itself wraps a future which is awaiting connection.

The connect_future should be lazy.

Returns

This returns a tuple of Self a handle to send dns messages and an optional background. The background task must be run on an executor before handle is used, if it is Some. If it is None, then another thread has already run the background.

Trait Implementations

impl<R> Clone for AsyncClient<R> where
    R: Future<Output = Result<DnsResponse, ProtoError>> + 'static + Send + Unpin, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Resp> DnsHandle for AsyncClient<Resp> where
    Resp: Future<Output = Result<DnsResponse, ProtoError>> + 'static + Send + Unpin, 

type Response = DnsExchangeSend<Resp>

The associated response from the response future, this should resolve to the Response message

fn send<R: Into<DnsRequest> + Unpin + Send + 'static>(
    &mut self,
    request: R
) -> Self::Response

Send a message via the channel in the client

fn is_verifying_dnssec(&self) -> bool

Only returns true if and only if this DNS handle is validating DNSSec.

fn lookup(&mut self, query: Query, options: DnsRequestOptions) -> Self::Response

A classic DNS query