Struct trust_dns::client::MemoizeClientHandle

#[must_use = "queries can only be sent through a ClientHandle"]
pub struct MemoizeClientHandle<H: ClientHandle> { /* fields omitted */ }

A ClienHandle for memoized (cached) responses to queries.

This wraps a ClientHandle, changing the implementation send() to store the response against the Message.Query that was sent. This should reduce network traffic especially during things like DNSSec validation. Warning this will currently cache for the life of the Client.

Methods

impl<H> MemoizeClientHandle<H> where
    H: ClientHandle, 

fn new(client: H) -> MemoizeClientHandle<H>

Returns a new handle wrapping the specified client

Trait Implementations

impl<H: Clone + ClientHandle> Clone for MemoizeClientHandle<H>

fn clone(&self) -> MemoizeClientHandle<H>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H> ClientHandle for MemoizeClientHandle<H> where
    H: ClientHandle, 

fn send(
    &mut self,
    message: Message
) -> Box<Future<Item = Message, Error = ClientError>>

Send a message via the channel in the client

fn query(
    &mut self,
    name: Name,
    query_class: DNSClass,
    query_type: RecordType
) -> Box<Future<Item = Message, Error = ClientError>>

A classic DNS query

fn notify<R>(
    &mut self,
    name: Name,
    query_class: DNSClass,
    query_type: RecordType,
    rrset: Option<R>
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Sends a NOTIFY message to the remote system

fn create<R>(
    &mut self,
    rrset: R,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Sends a record to create on the server, this will fail if the record exists (atomicity depends on the server)

fn append<R>(
    &mut self,
    rrset: R,
    zone_origin: Name,
    must_exist: bool
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Appends a record to an existing rrset, optionally require the rrset to exis (atomicity depends on the server)

fn compare_and_swap<C, N>(
    &mut self,
    current: C,
    new: N,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>> where
    C: IntoRecordSet,
    N: IntoRecordSet, 

Compares and if it matches, swaps it for the new value (atomicity depends on the server)

fn delete_by_rdata<R>(
    &mut self,
    rrset: R,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Deletes a record (by rdata) from an rrset, optionally require the rrset to exist.

fn delete_rrset(
    &mut self,
    record: Record,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>>

Deletes an entire rrset, optionally require the rrset to exist.

fn delete_all(
    &mut self,
    name_of_records: Name,
    zone_origin: Name,
    dns_class: DNSClass
) -> Box<Future<Item = Message, Error = ClientError>>

Deletes all records at the specified name