Add time synchronization service

Author: ThisSeanZhang

landscape-common/src/config/api.rs

@@ -1,6 +1,8 @@
 use serde::{Deserialize, Serialize};
 
-use crate::config::settings::{LandscapeDnsConfig, LandscapeMetricConfig, LandscapeUIConfig};
+use crate::config::settings::{
+    LandscapeDnsConfig, LandscapeMetricConfig, LandscapeTimeConfig, LandscapeUIConfig,
+};
 
 #[derive(Serialize, Debug, Clone)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
@@ -43,3 +45,17 @@ pub struct UpdateDnsConfigRequest {
     pub new_dns: LandscapeDnsConfig,
     pub expected_hash: String,
 }
+
+#[derive(Serialize, Debug, Clone)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct GetTimeConfigResponse {
+    pub time: LandscapeTimeConfig,
+    pub hash: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct UpdateTimeConfigRequest {
+    pub new_time: LandscapeTimeConfig,
+    pub expected_hash: String,
+}

landscape-common/src/config/loader.rs

@@ -6,11 +6,13 @@ use std::{
 use crate::args::WebCommArgs;
 use crate::config::runtime::{
     AuthRuntimeConfig, DnsRuntimeConfig, LogRuntimeConfig, MetricRuntimeConfig, RuntimeConfig,
-    StoreRuntimeConfig, WebRuntimeConfig,
+    StoreRuntimeConfig, TimeRuntimeConfig, WebRuntimeConfig,
 };
 use crate::config::settings::LandscapeConfig;
 use crate::gateway::settings::GatewayRuntimeConfig;
 use crate::{
+    DEFAULT_TIME_ENABLE, DEFAULT_TIME_SAMPLES_PER_SERVER, DEFAULT_TIME_SERVERS,
+    DEFAULT_TIME_STEP_THRESHOLD_MS, DEFAULT_TIME_SYNC_INTERVAL_SECS, DEFAULT_TIME_TIMEOUT_SECS,
     LANDSCAPE_CONFIG_DIR_NAME, LANDSCAPE_LOG_DIR_NAME, LANDSCAPE_WEBROOT_DIR_NAME, LAND_CONFIG,
 };
 
@@ -168,6 +170,27 @@ impl RuntimeConfig {
                 .unwrap_or_else(|| "/dns-query".to_string()),
         };
 
+        let time = TimeRuntimeConfig {
+            enabled: config.time.enabled.unwrap_or(DEFAULT_TIME_ENABLE),
+            servers: config.time.servers.clone().unwrap_or_else(|| {
+                DEFAULT_TIME_SERVERS.iter().map(|server| (*server).to_string()).collect()
+            }),
+            sync_interval_secs: config
+                .time
+                .sync_interval_secs
+                .unwrap_or(DEFAULT_TIME_SYNC_INTERVAL_SECS),
+            timeout_secs: config.time.timeout_secs.unwrap_or(DEFAULT_TIME_TIMEOUT_SECS),
+            step_threshold_ms: config
+                .time
+                .step_threshold_ms
+                .unwrap_or(DEFAULT_TIME_STEP_THRESHOLD_MS),
+            samples_per_server: config
+                .time
+                .samples_per_server
+                .unwrap_or(DEFAULT_TIME_SAMPLES_PER_SERVER)
+                .max(1),
+        };
+
         let gateway = GatewayRuntimeConfig::from_file_config(&config.gateway);
 
         RuntimeConfig {
@@ -179,6 +202,7 @@ impl RuntimeConfig {
             metric,
             dns,
             ui: config.ui.clone(),
+            time,
             gateway,
             file_config: config,
             auto: args.auto,

landscape-common/src/config/mod.rs

@@ -5,17 +5,19 @@ pub mod runtime;
 pub mod settings;
 
 pub use api::{
-    GetDnsConfigResponse, GetMetricConfigResponse, GetUIConfigResponse, UpdateDnsConfigRequest,
-    UpdateMetricConfigRequest, UpdateUIConfigRequest,
+    GetDnsConfigResponse, GetMetricConfigResponse, GetTimeConfigResponse, GetUIConfigResponse,
+    UpdateDnsConfigRequest, UpdateMetricConfigRequest, UpdateTimeConfigRequest,
+    UpdateUIConfigRequest,
 };
 pub use init::InitConfig;
 pub use runtime::{
     AuthRuntimeConfig, DnsRuntimeConfig, LogRuntimeConfig, MetricRuntimeConfig, RuntimeConfig,
-    StoreRuntimeConfig, WebRuntimeConfig,
+    StoreRuntimeConfig, TimeRuntimeConfig, WebRuntimeConfig,
 };
 pub use settings::{
     LandscapeAuthConfig, LandscapeConfig, LandscapeDnsConfig, LandscapeLogConfig,
-    LandscapeMetricConfig, LandscapeStoreConfig, LandscapeUIConfig, LandscapeWebConfig,
+    LandscapeMetricConfig, LandscapeStoreConfig, LandscapeTimeConfig, LandscapeUIConfig,
+    LandscapeWebConfig,
 };
 
 use uuid::Uuid;

landscape-common/src/config/runtime.rs

@@ -1,10 +1,15 @@
 use std::{net::IpAddr, path::PathBuf};
 
 use crate::config::settings::{
-    LandscapeConfig, LandscapeDnsConfig, LandscapeMetricConfig, LandscapeUIConfig,
+    LandscapeConfig, LandscapeDnsConfig, LandscapeMetricConfig, LandscapeTimeConfig,
+    LandscapeUIConfig,
 };
 use crate::gateway::settings::GatewayRuntimeConfig;
-use crate::LANDSCAPE_DB_SQLITE_NAME;
+use crate::{
+    DEFAULT_TIME_ENABLE, DEFAULT_TIME_SAMPLES_PER_SERVER, DEFAULT_TIME_SERVERS,
+    DEFAULT_TIME_STEP_THRESHOLD_MS, DEFAULT_TIME_SYNC_INTERVAL_SECS, DEFAULT_TIME_TIMEOUT_SECS,
+    LANDSCAPE_DB_SQLITE_NAME,
+};
 
 #[derive(Clone, Debug)]
 pub struct RuntimeConfig {
@@ -17,6 +22,7 @@ pub struct RuntimeConfig {
     pub metric: MetricRuntimeConfig,
     pub dns: DnsRuntimeConfig,
     pub ui: LandscapeUIConfig,
+    pub time: TimeRuntimeConfig,
     pub gateway: GatewayRuntimeConfig,
     pub auto: bool,
 }
@@ -75,6 +81,29 @@ pub struct DnsRuntimeConfig {
     pub doh_http_endpoint: String,
 }
 
+#[derive(Clone, Debug)]
+pub struct TimeRuntimeConfig {
+    pub enabled: bool,
+    pub servers: Vec<String>,
+    pub sync_interval_secs: u64,
+    pub timeout_secs: u64,
+    pub step_threshold_ms: u64,
+    pub samples_per_server: u8,
+}
+
+impl Default for TimeRuntimeConfig {
+    fn default() -> Self {
+        Self {
+            enabled: DEFAULT_TIME_ENABLE,
+            servers: DEFAULT_TIME_SERVERS.iter().map(|server| (*server).to_string()).collect(),
+            sync_interval_secs: DEFAULT_TIME_SYNC_INTERVAL_SECS,
+            timeout_secs: DEFAULT_TIME_TIMEOUT_SECS,
+            step_threshold_ms: DEFAULT_TIME_STEP_THRESHOLD_MS,
+            samples_per_server: DEFAULT_TIME_SAMPLES_PER_SERVER,
+        }
+    }
+}
+
 impl RuntimeConfig {
     pub fn to_string_summary(&self) -> String {
         let address_http_str = match self.web.address {
@@ -120,8 +149,16 @@ impl RuntimeConfig {
          DB Max Threads: {}\n\
          Cleanup Interval: {}s\n\
          Cleanup Budget: {}ms\n\
-         Cleanup Slice Window: {}s\n\
-         Aggregate Interval: {}s\n",
+          Cleanup Slice Window: {}s\n\
+          Aggregate Interval: {}s\n\
+          \n\
+          [Time]\n\
+          Enabled: {}\n\
+          NTP Servers: {}\n\
+          Sync Interval: {}s\n\
+          Timeout: {}s\n\
+          Step Threshold: {}ms\n\
+          Samples Per Server: {}\n",
             self.home_path.display(),
             self.auth.admin_user,
             self.auth.admin_pass,
@@ -147,6 +184,12 @@ impl RuntimeConfig {
             self.metric.cleanup_time_budget_ms,
             self.metric.cleanup_slice_window_secs,
             self.metric.aggregate_interval_secs,
+            self.time.enabled,
+            self.time.servers.join(", "),
+            self.time.sync_interval_secs,
+            self.time.timeout_secs,
+            self.time.step_threshold_ms,
+            self.time.samples_per_server,
         )
     }
 }
@@ -218,6 +261,29 @@ impl DnsRuntimeConfig {
     }
 }
 
+impl TimeRuntimeConfig {
+    pub fn update_from_file_config(&mut self, config: &LandscapeTimeConfig) {
+        if let Some(v) = config.enabled {
+            self.enabled = v;
+        }
+        if let Some(v) = &config.servers {
+            self.servers = v.clone();
+        }
+        if let Some(v) = config.sync_interval_secs {
+            self.sync_interval_secs = v;
+        }
+        if let Some(v) = config.timeout_secs {
+            self.timeout_secs = v;
+        }
+        if let Some(v) = config.step_threshold_ms {
+            self.step_threshold_ms = v;
+        }
+        if let Some(v) = config.samples_per_server {
+            self.samples_per_server = v;
+        }
+    }
+}
+
 impl StoreRuntimeConfig {
     pub fn create_default_db_store(home_path: &PathBuf) -> String {
         let path = home_path.join(LANDSCAPE_DB_SQLITE_NAME);

landscape-common/src/config/settings.rs

@@ -127,6 +127,29 @@ pub struct LandscapeUIConfig {
     pub theme: Option<String>,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct LandscapeTimeConfig {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "openapi", schema(required = false, nullable = false))]
+    pub enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "openapi", schema(required = false, nullable = false))]
+    pub servers: Option<Vec<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "openapi", schema(required = false, nullable = false))]
+    pub sync_interval_secs: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "openapi", schema(required = false, nullable = false))]
+    pub timeout_secs: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "openapi", schema(required = false, nullable = false))]
+    pub step_threshold_ms: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "openapi", schema(required = false, nullable = false))]
+    pub samples_per_server: Option<u8>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 pub struct LandscapeConfig {
@@ -153,5 +176,8 @@ pub struct LandscapeConfig {
     pub ui: LandscapeUIConfig,
     #[serde(default)]
     #[cfg_attr(feature = "openapi", schema(required = true))]
+    pub time: LandscapeTimeConfig,
+    #[serde(default)]
+    #[cfg_attr(feature = "openapi", schema(required = true))]
     pub gateway: LandscapeGatewayConfig,
 }

landscape-common/src/lib.rs

@@ -99,6 +99,16 @@ pub const DEFAULT_DNS_CACHE_TTL: u32 = 24 * 60 * 60;
 pub const DEFAULT_DNS_NEGATIVE_CACHE_TTL: u32 = 120;
 pub const DEFAULT_DNS_DOH_LISTEN_PORT: u16 = 6053;
 
+// --- Time Settings ---
+pub const DEFAULT_TIME_ENABLE: bool = false;
+pub const DEFAULT_TIME_SERVERS: &[&str] =
+    &["ntp.aliyun.com:123", "time.cloudflare.com:123", "pool.ntp.org:123"];
+pub const DEFAULT_TIME_FALLBACK_SERVER: &str = "pool.ntp.org:123";
+pub const DEFAULT_TIME_SYNC_INTERVAL_SECS: u64 = 300;
+pub const DEFAULT_TIME_TIMEOUT_SECS: u64 = 3;
+pub const DEFAULT_TIME_STEP_THRESHOLD_MS: u64 = 500;
+pub const DEFAULT_TIME_SAMPLES_PER_SERVER: u8 = 3;
+
 #[cfg(debug_assertions)]
 pub const DEFAULT_METRIC_CLEANUP_INTERVAL_SECS: u64 = 60;
 #[cfg(not(debug_assertions))]

landscape-common/src/sys_config/mod.rs

@@ -1,9 +1,28 @@
 use crate::SYSCTL_IPV4_ARP_IGNORE_PATTERN;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 pub fn init_sysctl_setting() {
     set_ipv4_arp_ignore_to_1();
 }
 
+pub fn set_system_time(time: SystemTime) -> std::io::Result<()> {
+    let duration = time.duration_since(UNIX_EPOCH).map_err(|_| {
+        std::io::Error::new(std::io::ErrorKind::InvalidInput, "system time is before UNIX_EPOCH")
+    })?;
+
+    let ts = libc::timespec {
+        tv_sec: duration.as_secs() as libc::time_t,
+        tv_nsec: duration.subsec_nanos() as libc::c_long,
+    };
+
+    let result = unsafe { libc::clock_settime(libc::CLOCK_REALTIME, &ts) };
+    if result == 0 {
+        Ok(())
+    } else {
+        Err(std::io::Error::last_os_error())
+    }
+}
+
 fn set_ipv4_arp_ignore_to_1() {
     use sysctl::Sysctl;
     if let Ok(ctl) = sysctl::Ctl::new(&SYSCTL_IPV4_ARP_IGNORE_PATTERN.replace("{}", "all")) {