Struct trust_dns::client::BasicClientHandle

#[must_use = "queries can only be sent through a ClientHandle"]
pub struct BasicClientHandle { /* fields omitted */ }

Root ClientHandle implementaton returned by ClientFuture

This can be used directly to perform queries. See trust_dns::client::SecureClientHandle for a DNSSEc chain validator.

Trait Implementations

impl Clone for BasicClientHandle

fn clone(&self) -> BasicClientHandle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ClientHandle for BasicClientHandle

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