Struct trust_dns::client::SyncClient

pub struct SyncClient { /* fields omitted */ }

The Client is abstracted over either trust_dns::tcp::TcpClientConnection or trust_dns::udp::UdpClientConnection.

Usage of TCP or UDP is up to the user. Some DNS servers disallow TCP in some cases, so if TCP double check if UDP works.

Methods

impl SyncClient

fn new<CC: ClientConnection>(client_connection: CC) -> SyncClient where
    <CC as ClientConnection>::MessageStream: Stream<Item = Vec<u8>, Error = Error> + 'static, 

Creates a new DNS client with the specified connection type

Arguments

• client_connection - the client_connection to use for all communication

fn with_signer<CC: ClientConnection>(
    client_connection: CC,
    signer: Signer
) -> SyncClient where
    <CC as ClientConnection>::MessageStream: Stream<Item = Vec<u8>, Error = Error> + 'static, 

Creates a new DNS client with the specified connection type and a SIG0 signer.

This is necessary for signed udpate requests to update trust-dns-server entries.

Arguments

• client_connection - the client_connection to use for all communication
• signer - signer to use, this needs an associated private key

Trait Implementations

impl Client<BasicClientHandle> for SyncClient

fn get_io_loop(&self) -> RefMut<Core>

get a mutable reference to the tokio Core associated to the Client

fn get_client_handle(&self) -> RefMut<BasicClientHandle>

Get a mutable handle reference tot the Core assiated to the Client

fn query(
    &self,
    name: &Name,
    query_class: DNSClass,
    query_type: RecordType
) -> ClientResult<Message>

A classic DNS query, i.e. does not perform and DNSSec operations

fn notify<R>(
    &mut self,
    name: Name,
    query_class: DNSClass,
    query_type: RecordType,
    rrset: Option<R>
) -> ClientResult<Message> where
    R: IntoRecordSet, 

Sends a NOTIFY message to the remote system

fn create<R>(&self, rrset: R, zone_origin: Name) -> ClientResult<Message> 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>(
    &self,
    rrset: R,
    zone_origin: Name,
    must_exist: bool
) -> ClientResult<Message> 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<CR, NR>(
    &self,
    current: CR,
    new: NR,
    zone_origin: Name
) -> ClientResult<Message> where
    CR: IntoRecordSet,
    NR: IntoRecordSet, 

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

fn delete_by_rdata<R>(
    &self,
    record: R,
    zone_origin: Name
) -> ClientResult<Message> where
    R: IntoRecordSet, 

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

fn delete_rrset(
    &self,
    record: Record,
    zone_origin: Name
) -> ClientResult<Message>

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

fn delete_all(
    &self,
    name_of_records: Name,
    zone_origin: Name,
    dns_class: DNSClass
) -> ClientResult<Message>

Deletes all records at the specified name