Struct trust_dns_proto::xfer::DnsExchange

#[must_use = "futures do nothing unless polled"]pub struct DnsExchange<R> where
    R: Future<Output = Result<DnsResponse, ProtoError>> + 'static + Send + Unpin,  { /* fields omitted */ }

This is a generic Exchange implemented over multiplexed DNS connection providers.

The underlying DnsRequestSender is expected to multiplex any I/O connections. DnsExchange assumes that the underlying stream is responsible for this.

Methods

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

pub fn from_stream<S, TE>(stream: S) -> (Self, DnsExchangeBackground<S, R, TE>) where
    S: DnsRequestSender<DnsResponseFuture = R> + 'static + Send + Unpin, 

Initializes a TcpStream with an existing tcp::TcpStream.

This is intended for use with a TcpListener and Incoming.

Arguments

• stream - the established IO stream for communication

pub fn from_stream_with_receiver<S, TE>(
    stream: S,
    receiver: UnboundedReceiver<OneshotDnsRequest<R>>,
    sender: DnsRequestStreamHandle<R>
) -> (Self, DnsExchangeBackground<S, R, TE>) where
    S: DnsRequestSender<DnsResponseFuture = R> + 'static + Send + Unpin, 

Wraps a stream where a sender and receiver have already been established

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

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

The connect_future should be lazy.

Trait Implementations

impl<R> Clone for DnsExchange<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 DnsExchange<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