Struct trust_dns_client::client::SyncClient

pub struct SyncClient<CC: ClientConnection> { /* private fields */ }

The Client is abstracted over either trust_dns_client::tcp::TcpClientConnection or trust_dns_client::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.

Implementations

impl<CC: ClientConnection> SyncClient<CC>

pub fn new(conn: CC) -> Self

Creates a new DNS client with the specified connection type

Arguments

• conn - the ClientConnection to use for all communication

pub fn with_signer(conn: CC, signer: Signer) -> Self

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

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

Arguments

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

Trait Implementations

impl<CC: ClientConnection> Client for SyncClient<CC>

type Response = DnsExchangeSend

The result future that will resolve into a DnsResponse

type Handle = AsyncClient

The AsyncClient type used

fn new_future(
    &self
) -> Pin<Box<dyn Future<Output = Result<(Self::Handle, Box<dyn Future<Output = Result<(), ProtoError>> + Send + Unpin + 'static>), ProtoError>> + Send + 'static>>

Return the inner Futures items

fn spawn_client(&self) -> ClientResult<(Self::Handle, Runtime)>

This will create a new AsyncClient and spawn it into a new Runtime

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

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

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

Sends a NOTIFY message to the remote system

fn create<R>(&self, rrset: R, zone_origin: Name) -> ClientResult<DnsResponse> where
    R: Into<RecordSet>, 

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<DnsResponse> where
    R: Into<RecordSet>, 

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

fn compare_and_swap<CR, NR>(
    &self,
    current: CR,
    new: NR,
    zone_origin: Name
) -> ClientResult<DnsResponse> where
    CR: Into<RecordSet>,
    NR: Into<RecordSet>, 

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<DnsResponse> where
    R: Into<RecordSet>, 

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

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

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<DnsResponse>

Deletes all records at the specified name