Struct rsntp::SntpClient

pub struct SntpClient { /* private fields */ }

Blocking client instance

This is the main entry point of the blocking API.

Implementations

impl SntpClient

pub fn new() -> SntpClient

Creates a new instance with default configuration

Example

use rsntp::SntpClient;

let client = SntpClient::new();

Examples found in repository

examples/blocking_without_chrono.rs (line 2)

fn main() {
    let client = rsntp::SntpClient::new();
    let time_info = client.synchronize("pool.ntp.org").unwrap();

    println!(
        "Clock offset: {} ms",
        time_info.clock_offset().as_secs_f64() * 1000.0
    );
    println!(
        "Round trip delay: {} ms",
        time_info.round_trip_delay().as_secs_f64() * 1000.0
    );
    println!(
        "Server UTC UNIX timestamp: {}",
        time_info.datetime().unix_timestamp().unwrap().as_secs()
    );

    println!(
        "Reference identifier: {}",
        time_info.reference_identifier().to_string()
    );
    println!("Stratum: {}", time_info.stratum());
}

examples/blocking_with_chrono.rs (line 6)

fn chrono_example() {
    let client = rsntp::SntpClient::new();
    let time_info = client.synchronize("pool.ntp.org").unwrap();

    let clock_offset: Duration = time_info.clock_offset().try_into().unwrap();
    println!("Clock offset: {} ms", clock_offset);

    let round_trip_delay: Duration = time_info.clock_offset().try_into().unwrap();
    println!("Round trip delay: {} ms", round_trip_delay);

    let datetime_utc: DateTime<Utc> = time_info.datetime().try_into().unwrap();
    let local_time: DateTime<Local> = DateTime::from(datetime_utc);
    println!("Local time: {}", local_time);

    println!(
        "Reference identifier: {}",
        time_info.reference_identifier().to_string()
    );
    println!("Stratum: {}", time_info.stratum());
}

pub fn with_config(config: Config) -> SntpClient

Creates a new instance with the specified configuration

Example

use rsntp::{Config, SntpClient};

let client = SntpClient::with_config(Config::default());

pub fn synchronize<A: ToServerAddrs>( &self, server_address: A ) -> Result<SynchronizationResult, SynchronizationError>

Synchronize with the server

Sends a request to the server, waits for the reply, and processes it. This is a blocking call and can block for a long time. After sending the request, it waits for a timeout; if no reply is received, an error is returned.

If the supplied server address resolves to multiple addresses, only the first one is used.

Example

use rsntp::SntpClient;

let client = SntpClient::new();
let result = client.synchronize("pool.ntp.org");

Examples found in repository

examples/blocking_without_chrono.rs (line 3)

fn main() {
    let client = rsntp::SntpClient::new();
    let time_info = client.synchronize("pool.ntp.org").unwrap();

    println!(
        "Clock offset: {} ms",
        time_info.clock_offset().as_secs_f64() * 1000.0
    );
    println!(
        "Round trip delay: {} ms",
        time_info.round_trip_delay().as_secs_f64() * 1000.0
    );
    println!(
        "Server UTC UNIX timestamp: {}",
        time_info.datetime().unix_timestamp().unwrap().as_secs()
    );

    println!(
        "Reference identifier: {}",
        time_info.reference_identifier().to_string()
    );
    println!("Stratum: {}", time_info.stratum());
}

examples/blocking_with_chrono.rs (line 7)

fn chrono_example() {
    let client = rsntp::SntpClient::new();
    let time_info = client.synchronize("pool.ntp.org").unwrap();

    let clock_offset: Duration = time_info.clock_offset().try_into().unwrap();
    println!("Clock offset: {} ms", clock_offset);

    let round_trip_delay: Duration = time_info.clock_offset().try_into().unwrap();
    println!("Round trip delay: {} ms", round_trip_delay);

    let datetime_utc: DateTime<Utc> = time_info.datetime().try_into().unwrap();
    let local_time: DateTime<Local> = DateTime::from(datetime_utc);
    println!("Local time: {}", local_time);

    println!(
        "Reference identifier: {}",
        time_info.reference_identifier().to_string()
    );
    println!("Stratum: {}", time_info.stratum());
}

pub fn set_timeout(&mut self, timeout: Duration)

Sets synchronization timeout

Sets the time the client waits for a reply after the request has been sent. Default is 3 seconds.

Example

use rsntp::SntpClient;
use std::time::Duration;

let mut client = SntpClient::new();
client.set_timeout(Duration::from_secs(10));

pub fn set_bind_address(&mut self, address: SocketAddr)

Set UDP bind address

Sets the local address which is used to send/receive UDP packets. By default, it is “0.0.0.0:0” which means that IPv4 address and port are chosen automatically.

To synchronize with IPv6 servers, you might need to set it to an IPv6 address.

Example

use rsntp::SntpClient;

let mut client = SntpClient::new();
client.set_bind_address("192.168.0.1:0".parse().unwrap());

pub fn set_config(&mut self, config: Config)

Set the configuration

Example

use rsntp::{Config, SntpClient};

let client = SntpClient::new();
let config = Config::default().bind_address("192.168.0.1:0".parse().unwrap());

Trait Implementations

impl Clone for SntpClient

fn clone(&self) -> SntpClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SntpClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SntpClient

fn default() -> Self

Returns the “default value” for a type.

impl Hash for SntpClient

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.