refactor: dns flow runtime refresh

Author: ThisSeanZhang

landscape-common/src/config/runtime.rs

@@ -66,7 +66,7 @@ pub struct MetricRuntimeConfig {
     pub aggregate_interval_secs: u64,
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct DnsRuntimeConfig {
     pub cache_capacity: u32,
     pub cache_ttl: u32,

landscape-common/src/dns/config.rs

@@ -59,7 +59,7 @@ impl Default for DnsUpstreamConfig {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 pub struct DnsBindConfig {
     /// 绑定地址 v4 (可选)

landscape-common/src/dns/mod.rs

@@ -8,14 +8,32 @@ pub mod check;
 pub mod config;
 pub mod redirect;
 pub mod rule;
+pub mod runtime;
 pub mod upstream;
 
+pub use runtime::{
+    CacheRuntimeConfig, DohRuntimeConfig, FlowDnsDependencies, FlowDnsDesiredState, RuntimeDnsRule,
+    RuntimeRedirectRule, RuntimeUpstreamTarget,
+};
+
 #[derive(Default, Debug)]
 pub struct ChainDnsServerInitInfo {
     pub dns_rules: Vec<DNSRuntimeRule>,
     pub redirect_rules: Vec<DNSRedirectRuntimeRule>,
 }
 
+impl From<ChainDnsServerInitInfo> for FlowDnsDesiredState {
+    fn from(value: ChainDnsServerInitInfo) -> Self {
+        Self {
+            flow_id: 0,
+            dns_rules: value.dns_rules.into_iter().map(Into::into).collect(),
+            redirect_rules: value.redirect_rules.into_iter().map(Into::into).collect(),
+            cache_runtime: CacheRuntimeConfig::default(),
+            doh_runtime: None,
+        }
+    }
+}
+
 pub fn gen_default_dns_rule_and_upstream() -> (DNSRuleConfig, DnsUpstreamConfig) {
     let upstream = DnsUpstreamConfig::default();
     let rule = DNSRuleConfig {

landscape-common/src/dns/rule.rs

@@ -111,7 +111,7 @@ pub enum DomainMatchType {
     Full = 3,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[serde(rename_all = "snake_case")]
 pub enum FilterResult {

landscape-common/src/dns/runtime.rs

@@ -0,0 +1,167 @@
+use std::collections::HashSet;
+use std::net::IpAddr;
+
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::dns::config::{DnsBindConfig, DnsUpstreamConfig};
+use crate::dns::redirect::DNSRedirectRuntimeRule;
+use crate::dns::redirect::DnsRedirectAnswerMode;
+use crate::dns::rule::{DNSRuntimeRule, DomainConfig, FilterResult};
+use crate::dns::upstream::DnsUpstreamMode;
+use crate::flow::mark::FlowMark;
+use crate::geo::GeoFileCacheKey;
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct CacheRuntimeConfig {
+    pub cache_capacity: u32,
+    pub cache_ttl: u32,
+    pub negative_cache_ttl: u32,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct DohRuntimeConfig {
+    pub listen_port: u16,
+    pub http_endpoint: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct RuntimeUpstreamTarget {
+    pub mode: DnsUpstreamMode,
+    #[cfg_attr(feature = "openapi", schema(value_type = Vec<String>))]
+    pub ips: Vec<IpAddr>,
+    #[cfg_attr(feature = "openapi", schema(required = true, nullable = true))]
+    pub port: Option<u16>,
+    pub enable_ip_validation: bool,
+}
+
+impl From<&DnsUpstreamConfig> for RuntimeUpstreamTarget {
+    fn from(value: &DnsUpstreamConfig) -> Self {
+        Self {
+            mode: value.mode.clone(),
+            ips: value.ips.clone(),
+            port: value.port,
+            enable_ip_validation: value.enable_ip_validation.unwrap_or(false),
+        }
+    }
+}
+
+impl From<RuntimeUpstreamTarget> for DnsUpstreamConfig {
+    fn from(value: RuntimeUpstreamTarget) -> Self {
+        Self {
+            id: Uuid::nil(),
+            remark: String::new(),
+            mode: value.mode,
+            ips: value.ips,
+            port: value.port,
+            enable_ip_validation: Some(value.enable_ip_validation),
+            update_at: 0.0,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct RuntimeDnsRule {
+    pub rule_id: Uuid,
+    pub order: u32,
+    pub filter: FilterResult,
+    pub upstream: RuntimeUpstreamTarget,
+    pub bind_config: DnsBindConfig,
+    pub mark: FlowMark,
+    pub sources: Vec<DomainConfig>,
+}
+
+impl From<DNSRuntimeRule> for RuntimeDnsRule {
+    fn from(value: DNSRuntimeRule) -> Self {
+        Self {
+            rule_id: value.id,
+            order: value.index,
+            filter: value.filter,
+            upstream: RuntimeUpstreamTarget::from(&value.resolve_mode),
+            bind_config: value.bind_config,
+            mark: value.mark,
+            sources: value.source,
+        }
+    }
+}
+
+impl From<RuntimeDnsRule> for DNSRuntimeRule {
+    fn from(value: RuntimeDnsRule) -> Self {
+        Self {
+            id: value.rule_id,
+            name: String::new(),
+            index: value.order,
+            enable: true,
+            filter: value.filter,
+            resolve_mode: value.upstream.into(),
+            bind_config: value.bind_config,
+            mark: value.mark,
+            source: value.sources,
+            flow_id: 0,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct RuntimeRedirectRule {
+    #[cfg_attr(feature = "openapi", schema(nullable = false))]
+    pub redirect_id: Option<Uuid>,
+    #[cfg_attr(feature = "openapi", schema(nullable = false))]
+    pub dynamic_source_id: Option<String>,
+    pub order: u32,
+    pub answer_mode: DnsRedirectAnswerMode,
+    pub match_rules: Vec<DomainConfig>,
+    #[cfg_attr(feature = "openapi", schema(value_type = Vec<String>))]
+    pub result_ips: Vec<IpAddr>,
+    pub ttl_secs: u32,
+}
+
+impl From<DNSRedirectRuntimeRule> for RuntimeRedirectRule {
+    fn from(value: DNSRedirectRuntimeRule) -> Self {
+        Self {
+            redirect_id: value.redirect_id,
+            dynamic_source_id: value.dynamic_redirect_source,
+            order: 0,
+            answer_mode: value.answer_mode,
+            match_rules: value.match_rules,
+            result_ips: value.result_info,
+            ttl_secs: value.ttl_secs,
+        }
+    }
+}
+
+impl From<RuntimeRedirectRule> for DNSRedirectRuntimeRule {
+    fn from(value: RuntimeRedirectRule) -> Self {
+        Self {
+            redirect_id: value.redirect_id,
+            dynamic_redirect_source: value.dynamic_source_id,
+            answer_mode: value.answer_mode,
+            match_rules: value.match_rules,
+            result_info: value.result_ips,
+            ttl_secs: value.ttl_secs,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct FlowDnsDesiredState {
+    pub flow_id: u32,
+    pub dns_rules: Vec<RuntimeDnsRule>,
+    pub redirect_rules: Vec<RuntimeRedirectRule>,
+    pub cache_runtime: CacheRuntimeConfig,
+    #[cfg_attr(feature = "openapi", schema(nullable = false))]
+    pub doh_runtime: Option<DohRuntimeConfig>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct FlowDnsDependencies {
+    pub geo_keys: HashSet<GeoFileCacheKey>,
+    pub upstream_ids: HashSet<Uuid>,
+    pub dynamic_redirect_sources: HashSet<String>,
+}

landscape-common/src/dns/upstream.rs

@@ -11,7 +11,7 @@ pub enum DnsUpstreamError {
     NotFound(ConfigId),
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[serde(rename_all = "snake_case")]
 #[serde(tag = "t")]

landscape-common/src/event/dns.rs

@@ -1,6 +1,17 @@
+use std::collections::HashSet;
+
+use uuid::Uuid;
+
+use crate::geo::GeoFileCacheKey;
+
+#[derive(Clone, Debug)]
 pub enum DnsEvent {
-    RuleUpdated { flow_id: Option<u32> },
-    GeositeUpdated,
+    RulesChanged { flow_id: Option<u32> },
+    RedirectsChanged { flow_id: Option<u32> },
+    DynamicRedirectsChanged { flow_id: Option<u32>, source_id: String },
+    UpstreamsChanged { upstream_ids: Vec<Uuid> },
+    GeoSitesChanged { changed_keys: Option<HashSet<GeoFileCacheKey>> },
+    RuntimeConfigChanged,
     FlowUpdated,
 }
 

landscape-dns/src/bin/test_dns_server.rs

@@ -1,22 +1,21 @@
-use landscape_common::{
-    config::DnsRuntimeConfig, dns::rule::DNSRuntimeRule, dns::ChainDnsServerInitInfo,
-};
-use landscape_dns::server::LandscapeDnsServer;
+use landscape_common::{dns::rule::DNSRuntimeRule, dns::ChainDnsServerInitInfo};
+use landscape_dns::server::{CacheRuntimeConfig, LandscapeDnsServer};
 
 /// cargo run --package landscape-dns --bin test_dns_server
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
     landscape_common::init_tracing!();
 
     let listen_port = 54;
-    let server = LandscapeDnsServer::new(listen_port, None, None, None);
+    let server =
+        LandscapeDnsServer::new(listen_port, None, CacheRuntimeConfig::default(), None, None);
 
     // handler
     let default_rule = vec![DNSRuntimeRule::default()];
 
     let info = ChainDnsServerInitInfo { dns_rules: default_rule, redirect_rules: vec![] };
     println!("=============================================");
-    server.refresh_flow_server(0, info, DnsRuntimeConfig::default()).await;
+    server.refresh_flow_server(info.into()).await;
 
     let _ = tokio::signal::ctrl_c().await;
 

landscape-dns/src/connection/mod.rs

@@ -7,10 +7,7 @@ use hickory_resolver::{
 };
 
 use landscape_common::{
-    dns::{
-        config::{DnsBindConfig, DnsUpstreamConfig},
-        upstream::DnsUpstreamMode,
-    },
+    dns::{config::DnsBindConfig, upstream::DnsUpstreamMode, RuntimeUpstreamTarget},
     flow::mark::FlowMark,
 };
 
@@ -24,7 +21,7 @@ pub(crate) fn create_resolver(
     flow_id: u32,
     mark: FlowMark,
     bind_config: DnsBindConfig,
-    DnsUpstreamConfig { mode, ips, port, .. }: DnsUpstreamConfig,
+    RuntimeUpstreamTarget { mode, ips, port, .. }: RuntimeUpstreamTarget,
 ) -> LandscapeMarkDNSResolver {
     let name_server = match mode {
         DnsUpstreamMode::Plaintext => {

landscape-dns/src/lib.rs

@@ -35,8 +35,6 @@ pub mod error;
 pub mod listener;
 pub mod server;
 
-const DEFAULT_ENABLE_IP_VALIDATION: bool = false;
-
 static RESOLVER_CONF: &'static str = "/etc/resolv.conf";
 static RESOLVER_CONF_LD_BACK: &'static str = "/etc/resolv.conf.ld_back";
 
@@ -68,6 +66,10 @@ fn check_resolver_conf() {
     std::fs::write(&resolver_file, new_content).unwrap();
 }
 
+pub fn prepare_system_dns() {
+    check_resolver_conf();
+}
+
 /// 停止时恢复 /etc/resolv.conf
 pub fn restore_resolver_conf() {
     let resolver_file = PathBuf::from(RESOLVER_CONF);
@@ -101,6 +103,8 @@ pub struct CacheDNSItem {
     pub min_ttl: u32,
     pub mark: DnsRuntimeMarkInfo,
     pub filter: FilterResult,
+    pub matched_rule_id: Option<uuid::Uuid>,
+    pub matched_rule_order: Option<u32>,
 }
 
 impl CacheDNSItem {