add DNS fault support

Signed-off-by: Sylvain Hellegouarch <[email protected]>

Author: Lawouach

CHANGELOG.md

@@ -2,4 +2,4 @@
 
 ## Changed
 
-- Fix ghcr repository URL
+- Add proper DNS fault support

Cargo.toml

@@ -4,7 +4,7 @@ members = ["fault-cli", "fault-ebpf-programs"]
 default-members = ["fault-cli"]
 
 [workspace.package]
-version = "0.15.1"
+version = "0.16.0"
 edition = "2024"
 rust-version = "1.85"
 license-file = "LICENSE"

fault-cli/src/cli.rs

@@ -22,6 +22,7 @@ use crate::types::BandwidthUnit;
 use crate::types::DbCase;
 use crate::types::DbTarget;
 use crate::types::Direction;
+use crate::types::DnsCase;
 use crate::types::LatencyDistribution;
 use crate::types::LlmCase;
 use crate::types::LlmTarget;
@@ -377,6 +378,22 @@ pub struct DbOptions {
     pub corruption_rate: f64,
 }
 
+#[derive(Parser, Clone, Debug)]
+#[clap(next_help_heading = "DNS Options")]
+pub struct DnsOptions {
+    /// Remote resolver for passing queries (IP, IP:PORT)
+    #[clap(long, default_value = "127.0.0.1:53", env = "FAULT_DNS_RESOLVER")]
+    pub resolver: String,
+
+    /// Probability for injection [0, 1] (never to always)
+    #[clap(long, default_value = "1.0", value_parser = validate_probability, env = "FAULT_LLM_PROBABILITY",)]
+    pub probability: f64,
+
+    /// Delay per query (e.g. "200ms")
+    #[clap(long, value_parser = validate_parse_human_duration, env = "FAULT_DNS_DELAY")]
+    pub delay: Option<Duration>,
+}
+
 #[derive(Subcommand, Clone, Debug)]
 #[clap(subcommand_required = false, subcommand = "proxy")]
 pub enum RunCommands {
@@ -397,7 +414,7 @@ pub enum RunCommands {
         settings: LlmOptions,
     },
 
-    #[clap(next_help_heading = "Databaase-specific faults")]
+    #[clap(next_help_heading = "Database-specific faults")]
     Db {
         /// Which database to target
         #[clap(value_enum)]
@@ -410,6 +427,16 @@ pub enum RunCommands {
         #[clap(flatten)]
         settings: DbOptions,
     },
+
+    #[clap(next_help_heading = "DNS-specific faults")]
+    Dns {
+        /// Which scenarios to run
+        #[clap(value_enum, long = "case")]
+        cases: Vec<DnsCase>,
+
+        #[clap(flatten)]
+        settings: DnsOptions,
+    },
 }
 
 #[derive(Parser, Debug, Serialize, Deserialize, Clone)]
@@ -678,41 +705,6 @@ pub struct JitterOptions {
     pub jitter_sched: Option<String>,
 }
 
-#[derive(Parser, Debug, Serialize, Deserialize, Clone)]
-pub struct DnsOptions {
-    /// Dns fault enabled
-    #[arg(
-        help_heading = "DNS Options",
-        action,
-        name = "dns_enabled",
-        long = "with-dns",
-        default_value_t = false,
-        help = "Enable dns network fault.",
-        env = "FAULT_WITH_DNS"
-    )]
-    pub enabled: bool,
-
-    /// Probability to inject the error between 0 and 100
-    #[arg(
-        help_heading = "DNS Options",
-        long,
-        default_value_t = 0.5,
-        help = "Probability to trigger the DNS failure between 0.0 and 1.0.",
-        value_parser = validate_probability,
-        env = "FAULT_DNS_PROBABILITY",
-    )]
-    pub dns_rate: f64,
-
-    /// Dns period
-    #[arg(
-        help_heading = "DNS Options",
-        long,
-        help = "Dns schedule",
-        env = "FAULT_DNS_SCHED"
-    )]
-    pub dns_sched: Option<String>,
-}
-
 #[derive(Parser, Debug, Serialize, Deserialize, Clone)]
 pub struct PacketLossOptions {
     /// Packet Loss fault enabled
@@ -938,10 +930,6 @@ pub struct RunCommonOptions {
     #[command(flatten)]
     pub jitter: JitterOptions,
 
-    // Dns Options
-    #[command(flatten)]
-    pub dns: DnsOptions,
-
     // Packet Loss Options
     #[command(flatten)]
     pub packet_loss: PacketLossOptions,

fault-cli/src/config.rs

@@ -17,13 +17,12 @@ use crate::cli::LlmOptions;
 //use crate::cli::PacketDuplicationOptions;
 use crate::cli::PacketLossOptions;
 use crate::cli::RunCommonOptions;
-use crate::fault::content::ContentInjectSettings;
-use crate::fault::llm::openai::OpenAiInjector;
 use crate::fault::llm::openai::OpenAiSettings;
 use crate::fault::llm::openai::SlowStreamSettings;
 use crate::types::BandwidthUnit;
 use crate::types::DbCase;
 use crate::types::Direction;
+use crate::types::DnsCase;
 use crate::types::LatencyDistribution;
 use crate::types::LlmCase;
 use crate::types::ProtocolType;
@@ -78,11 +77,12 @@ pub struct JitterSettings {
 }
 
 /// Internal Configuration for DNS Fault
-#[derive(Clone, Debug, Serialize, Deserialize, Default, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct DnsSettings {
-    pub kind: FaultKind,
     pub enabled: bool,
-    pub rate: f64, // between 0 and 1.0
+    pub probability: f64,
+    pub case: DnsCase,
+    pub delay_ms: Option<Duration>,
 }
 
 /// Internal Configuration for Packet Duplication Fault
@@ -139,7 +139,6 @@ pub struct LlmSettings {}
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub enum FaultConfig {
     // network
-    Dns(DnsSettings),
     Latency(LatencySettings),
     PacketLoss(PacketLossSettings),
     Bandwidth(BandwidthSettings),
@@ -153,6 +152,9 @@ pub enum FaultConfig {
     PromptScramble(OpenAiSettings),
     InjectBias(OpenAiSettings),
     TruncateResponse(OpenAiSettings),
+
+    // dns
+    Dns(DnsSettings),
 }
 
 /// Implement Default manually for FaultConfig
@@ -165,7 +167,6 @@ impl Default for FaultConfig {
 impl fmt::Display for FaultConfig {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            FaultConfig::Dns(_) => write!(f, "dns"),
             FaultConfig::Latency(_) => write!(f, "latency"),
             FaultConfig::PacketLoss(_) => write!(f, "packet-loss"),
             FaultConfig::Bandwidth(_) => write!(f, "bandwidth"),
@@ -181,14 +182,14 @@ impl fmt::Display for FaultConfig {
                 write!(f, "llm-truncate-response")
             }
             FaultConfig::SlowStream(_) => write!(f, "llm-slow-stream"),
+            FaultConfig::Dns(_) => write!(f, "dns"),
         }
     }
 }
 
 impl FaultConfig {
     pub fn kind(&self) -> FaultKind {
         match self {
-            FaultConfig::Dns(_) => FaultKind::Dns,
             FaultConfig::Latency(_) => FaultKind::Latency,
             FaultConfig::PacketLoss(_) => FaultKind::PacketLoss,
             FaultConfig::Bandwidth(_) => FaultKind::Bandwidth,
@@ -200,6 +201,7 @@ impl FaultConfig {
             FaultConfig::InjectBias(_) => FaultKind::InjectBias,
             FaultConfig::TruncateResponse(_) => FaultKind::TruncateResponse,
             FaultConfig::SlowStream(_) => FaultKind::SlowStream,
+            FaultConfig::Dns(_) => FaultKind::Dns,
         }
     }
 }
@@ -212,7 +214,6 @@ pub enum FaultKind {
     Unknown,
 
     // network
-    Dns,
     Latency,
     PacketLoss,
     Bandwidth,
@@ -228,13 +229,15 @@ pub enum FaultKind {
     PromptScramble,
     InjectBias,
     TruncateResponse,
+
+    // dns
+    Dns,
 }
 
 impl fmt::Display for FaultKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             FaultKind::Unknown => write!(f, "unknown"),
-            FaultKind::Dns => write!(f, "dns"),
             FaultKind::Latency => write!(f, "latency"),
             FaultKind::PacketLoss => write!(f, "packet-loss"),
             FaultKind::Bandwidth => write!(f, "bandwidth"),
@@ -248,6 +251,7 @@ impl fmt::Display for FaultKind {
             FaultKind::InjectBias => write!(f, "inject-bias"),
             FaultKind::TruncateResponse => write!(f, "truncate-response"),
             FaultKind::SlowStream => write!(f, "slow-stream"),
+            FaultKind::Dns => write!(f, "dns"),
         }
     }
 }
@@ -279,10 +283,6 @@ impl From<RunCommonOptions> for ProxyConfig {
             faults.push(FaultConfig::Bandwidth((&cli.bandwidth).into()));
         }
 
-        if cli.dns.enabled && cli.dns.dns_sched.is_none() {
-            faults.push(FaultConfig::Dns((&cli.dns).into()));
-        }
-
         if cli.jitter.enabled && cli.jitter.jitter_sched.is_none() {
             faults.push(FaultConfig::Jitter((&cli.jitter).into()));
         }
@@ -360,16 +360,6 @@ impl From<&JitterOptions> for JitterSettings {
     }
 }
 
-impl From<&DnsOptions> for DnsSettings {
-    fn from(cli: &DnsOptions) -> Self {
-        DnsSettings {
-            enabled: cli.enabled,
-            kind: FaultKind::Dns,
-            rate: cli.dns_rate,
-        }
-    }
-}
-
 impl From<&PacketLossOptions> for PacketLossSettings {
     fn from(cli: &PacketLossOptions) -> Self {
         PacketLossSettings {
@@ -526,3 +516,58 @@ impl From<(DbCase, &DbOptions)> for FaultConfig {
         }
     }
 }
+
+impl From<(DnsCase, &DnsOptions)> for FaultConfig {
+    fn from((case, options): (DnsCase, &DnsOptions)) -> Self {
+        match case {
+            DnsCase::NxDomain => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::NxDomain,
+                delay_ms: options.delay,
+            }),
+            DnsCase::ServFail => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::ServFail,
+                delay_ms: options.delay,
+            }),
+            DnsCase::Refused => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::Refused,
+                delay_ms: options.delay,
+            }),
+            DnsCase::Timeout => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::Timeout,
+                delay_ms: options.delay,
+            }),
+            DnsCase::Truncated => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::Truncated,
+                delay_ms: options.delay,
+            }),
+            DnsCase::Delay => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::Delay,
+                delay_ms: options.delay,
+            }),
+            DnsCase::RandomA => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::RandomA,
+                delay_ms: options.delay,
+            }),
+            DnsCase::EmptyAnswer => FaultConfig::Dns(DnsSettings {
+                enabled: true,
+                probability: options.probability,
+                case: DnsCase::EmptyAnswer,
+                delay_ms: options.delay,
+            }),
+        }
+    }
+}

fault-cli/src/event.rs

@@ -407,6 +407,7 @@ pub enum FaultEvent {
     Dns {
         direction: Direction,
         side: StreamSide,
+        case: String,
         triggered: Option<bool>,
     },
     Bandwidth {