feat(measurement): refine measurement setup and IRTT engine behavior

src/main.rs

@@ -174,16 +174,55 @@ fn resolve_reflectors(
         } else {
             0
         };
-        for endpoint in (definition.host.as_str(), port).to_socket_addrs()? {
+        let endpoints = match (definition.host.as_str(), port).to_socket_addrs() {
+            Ok(endpoints) => endpoints,
+            Err(error) => {
+                warn!("Failed to resolve reflector {}: {error}", definition.host);
+                continue;
+            }
+        };
+        for endpoint in endpoints {
             if protocol != ReflectorProtocol::Irtt && endpoint.is_ipv6() {
                 continue;
             }
-            resolved.insert(endpoint, definition.clone());
+            insert_reflector(&mut resolved, endpoint, definition.clone())?;
         }
     }
     Ok(resolved)
 }
 
+fn insert_reflector(
+    reflectors: &mut HashMap<SocketAddr, ReflectorDefinition>,
+    endpoint: SocketAddr,
+    definition: ReflectorDefinition,
+) -> anyhow::Result<()> {
+    if let Some(existing) = reflectors.get(&endpoint) {
+        let same_country = match (&existing.country, &definition.country) {
+            (Some(a), Some(b)) => a.eq_ignore_ascii_case(b),
+            (None, None) => true,
+            _ => false,
+        };
+        let same_protocols = existing
+            .protocols
+            .iter()
+            .all(|p| definition.protocols.contains(p))
+            && definition
+                .protocols
+                .iter()
+                .all(|p| existing.protocols.contains(p));
+        if !same_country
+            || !same_protocols
+            || existing.irtt_port.unwrap_or(2112) != definition.irtt_port.unwrap_or(2112)
+            || existing.irtt_hmac != definition.irtt_hmac
+        {
+            anyhow::bail!("conflicting reflector definitions for resolved endpoint {endpoint}");
+        }
+    } else {
+        reflectors.insert(endpoint, definition);
+    }
+    Ok(())
+}
+
 fn setup_reflectors(settings: &Settings) -> anyhow::Result<ReflectorSetup> {
     let protocol = settings.advanced_settings.measurement_type;
     let configured = resolve_reflectors(
@@ -194,11 +233,12 @@ fn setup_reflectors(settings: &Settings) -> anyhow::Result<ReflectorSetup> {
     )?;
     let bootstrap = resolve_reflectors(&settings.reflectors.bootstrap, protocol, &[], false)?;
     let mut reflectors = bootstrap.clone();
-    reflectors.extend(
-        configured
-            .iter()
-            .map(|(endpoint, definition)| (*endpoint, definition.clone())),
-    );
+    for (endpoint, definition) in &configured {
+        insert_reflector(&mut reflectors, *endpoint, definition.clone())?;
+    }
+    if reflectors.is_empty() {
+        anyhow::bail!("no usable reflectors for measurement protocol {protocol}");
+    }
     let mut pool = configured.keys().copied().collect::<Vec<_>>();
     pool.sort();
     let mut initial = bootstrap.keys().copied().collect::<Vec<_>>();
@@ -332,6 +372,7 @@ fn run(settings: &Settings) -> anyhow::Result<()> {
         Arc::clone(&active_streams),
         Arc::clone(&endpoint_streams),
         source,
+        Duration::from_secs_f64(settings.advanced_settings.tick_interval),
     );
     let icmp_engine = {
         let _guard = rt.enter();