用 Rust 从零搭一个 DNS 服务器:TTL 不是缓存时长,是缓存上限
前面的系统都在处理"数据"。这一篇处理的是一种更微妙的东西:一个你明知道会过期的答案,要不要把它记下来,记多久。
DNS 的全部难度都在这句话里。协议本身很简单(一个请求一个响应),但**"能不能缓存、缓存多久、过期了怎么办"这套语义,比报文格式难得多。**
而且它有个特别之处:这些语义是上游通过响应本身告诉你的。 你不是在自己设计缓存策略,你是在执行别人的策略。
第一步:报文解析——一个为省字节而设计的格式
DNS 头是固定 12 字节:
pub struct Header {
pub id: u16, // 事务 id,用来匹配请求和响应
pub flags: u16,
pub qdcount: u16, // question 数量
pub ancount: u16, // answer 数量
pub nscount: u16, // authority 数量
pub arcount: u16, // additional 数量
}
impl Header {
/// QR: 0 查询 / 1 响应
pub fn is_response(&self) -> bool { self.flags & 0x8000 != 0 }
/// TC: 响应被截断,客户端应该改用 TCP 重试
pub fn is_truncated(&self) -> bool { self.flags & 0x0200 != 0 }
/// RD: 期望递归
pub fn recursion_desired(&self) -> bool { self.flags & 0x0100 != 0 }
/// RA: 服务器支持递归
pub fn recursion_available(&self) -> bool { self.flags & 0x0080 != 0 }
/// RCODE: 4 位返回码
pub fn rcode(&self) -> Rcode { Rcode::from(self.flags & 0x000F) }
}注意 id 只有 16 位。 这意味着上游并发查询最多 65536 个还没回来的请求——超了就会 id 冲突,把 A 请求的响应错配给 B 请求。这不是理论问题:一个高频解析器不加限制地向上游并发,几秒内就能撞上这个上限。
域名压缩:3 个字节换来的复杂
为了省空间,DNS 报文里的域名可以用"指针"表示:
问题:www.example.com
答案:www.example.com A 1.2.3.4
↑ 这里不重复写一遍,而是写一个指向前面那个名字的偏移量
编码:0xC0 0x0C ← 高两位是 11,剩下 14 位是偏移量 12这个设计给解析器埋了两个坑:
坑一:指针可以指向自己,造成无限循环。 一个恶意构造的报文可以让解析器在几个偏移量之间反复跳。
坑二:指针可以指向"还没解析到的地方",甚至指向报文之外。
标准做法是限制跳转次数 + 严格边界检查:
const MAX_JUMPS: usize = 32; // 常见的实现上界
pub fn parse_name(buf: &[u8], mut pos: usize) -> Result<(Name, usize)> {
let mut labels = Vec::new();
let mut jumps = 0;
// 真实位置:指针跳转后,调用方要接着跳转前的位置往下读
let mut consumed_end: Option<usize> = None;
loop {
if pos >= buf.len() {
return Err(Error::Truncated);
}
let len = buf[pos];
if len == 0 {
// 根标签,名字结束
pos += 1;
if consumed_end.is_none() {
consumed_end = Some(pos);
}
break;
}
if len & 0xC0 == 0xC0 {
// 压缩指针
if pos + 1 >= buf.len() {
return Err(Error::Truncated);
}
let offset = (((len as usize) & 0x3F) << 8) | buf[pos + 1] as usize;
if consumed_end.is_none() {
consumed_end = Some(pos + 2); // 指针本身占 2 字节
}
jumps += 1;
if jumps > MAX_JUMPS {
return Err(Error::TooManyJumps); // 明确的错误,不是静默截断
}
if offset >= buf.len() {
return Err(Error::PointerOutOfBounds);
}
pos = offset;
continue;
}
if len as usize > 63 {
// 单个 label 最长 63 字节
return Err(Error::LabelTooLong);
}
let end = pos + 1 + len as usize;
if end > buf.len() {
return Err(Error::Truncated);
}
// 这里可以借用 &buf[pos+1..end],但为了后面统一处理,先复制
labels.push(buf[pos + 1..end].to_vec());
pos = end;
}
Ok((Name::from_labels(labels), consumed_end.unwrap()))
}三个细节值得单独说:
第一,consumed_end 是必须的。 指针出现之后,"这个名字在哪里结束"和"解析完之后从哪继续"变成了两个不同的位置——很多手写解析器在这里出错,把后续的记录整个读错位。
第二,jumps 上限必须是一个明确的错误,不能是静默截断。 如果超限了就返回一个"部分解析的名字",你会得到一个看起来合法的域名,然后把它缓存起来。这比直接报错危险得多。
第三,MAX_JUMPS = 32 是一个取舍。 太大的话单次解析可能被拖慢(拒绝服务);太小的话正常的深层域名会解析失败。真实实现大多用"跳转不增加 label 数"或类似的约束,比单纯计数更严谨。
报文解析是所有协议实现的共同考点:边界检查不是防御性编程,而是正确性的一部分。 讲零拷贝的那篇、讲 WebSocket 帧协议的那篇,栽的地方都是同一类——长度字段来自不可信输入,而代码信任了它。
能不能零拷贝?
理论上应该可以:
/// 解析结果借用原始缓冲区 —— 理想情况
pub struct ParsedName<'a> {
labels: Vec<&'a [u8]>,
}但压缩指针破坏了这条路。 因为一个名字的各个 label 可能分散在报文的任意位置,"零拷贝的名字"只能表示成"一串指向原缓冲区的切片",也就是一个 Vec<&[u8]>——还是要分配。
所以真实的 DNS 实现通常不追求名字解析的零拷贝,而是:
| 环节 | 是否零拷贝 | 说明 |
|---|---|---|
| 读取报文 | 是 | 用 mmap/recv 直接读进缓冲区 |
| 解析名字 | 否 | 压缩指针让切片表达不了,只能复制 |
| 转发响应 | 是 | 整个缓冲区直接转发(sendfile / writev) |
真正值得零拷贝的是"转发路径",不是"解析路径"。 因为解析只发生一次,而转发可能要把同一个报文发给几十个下游——这才是零拷贝真正能省下大钱的地方。
第二步:名字索引——为什么要倒过来存
一个递归解析器要维护"哪些域名归哪个上游管"(转发区配置),还要做最长后缀匹配。最自然的做法是把域名反转后再存:
原始: www.api.example.com
反转: com.example.api.www反转之后,"最长后缀匹配"就变成了"最长前缀匹配"——而这个正好是 Trie 的强项。
pub struct NameTrie {
/// 双数组 Trie,但键是反转后的 label 序列
base: Vec<i32>,
check: Vec<i32>,
/// 每个节点对应一个 label,而不是一个字符
node_labels: Vec<Box<[u8]>>,
/// 命中某个前缀时,它对应的转发目标
values: HashMap<usize, ForwardZone>,
}注意这里 Trie 的边是"label"而不是"字节"。 域名天然是按 label 分层的(com / example / www),按 label 建 Trie 的深度是个位数,按字节建 Trie 的深度是几十——后者会把缓存行浪费在拆字符上。
但这个 Trie 和普通的前缀树有两个不同点:
第一,大小写不敏感。 DNS 的名字比较是 ASCII case-insensitive 的,所以入库前必须统一规范化(通常转小写)。否则 Example.COM 和 example.com 会命中不同的节点——而且这个 bug 只在大小写混用的输入下出现,测试里很难覆盖。
第二,有通配符。 *.example.com 这种配置要求"如果具体名字没命中,就往上找通配符节点":
impl NameTrie {
pub fn longest_match(&self, name: &Name) -> Option<&ForwardZone> {
let mut node = self.root();
let mut best: Option<&ForwardZone> = None;
// 记录沿途遇到的通配符候选,因为通配符的优先级低于具体匹配
let mut wildcard: Option<(usize, &ForwardZone)> = None;
for label in name.reversed_labels() {
match self.child(node, label) {
Some(next) => {
node = next;
if let Some(z) = self.values.get(&node) {
best = Some(z);
}
// 顺路记下 "*" 子节点
if let Some(w) = self.child(node, b"*").and_then(|n| self.values.get(&n)) {
wildcard = Some((label.len(), w));
}
}
None => break,
}
}
// 具体匹配优先;没有具体匹配才回落到通配符
best.or(wildcard.map(|(_, z)| z))
}
}"具体匹配优先于通配符"这条规则听起来显然,但它在 Trie 上的实现要求你沿途记录候选。 只做"贪心往下走,走到走不动为止"的话,www.example.com 有具体配置时你会在中途先撞上 *.example.com 并返回它——一个纯 Trie 写法几乎必然踩的坑。
匹配规则的优先级不能靠数据结构的遍历顺序来隐式表达。 Trie 的遍历顺序是"从短到长"或者"从长到短",而业务规则的优先级可能完全是第三种顺序。把"候选收集"和"优先级判定"分成两步,是唯一稳妥的写法。
第三步:查询路径——为什么必须同时实现 UDP 和 TCP
DNS 主要跑在 UDP 上,原因很直接:一次问答只有两个报文,为它建一条 TCP 连接的话,握手的开销比查询本身还大。
但 UDP 有个硬限制:传统 DNS 响应最大 512 字节。 超了怎么办?
pub enum Transport {
Udp,
Tcp,
}
impl Server {
fn respond(&self, req: &Request, answer: &Response, transport: Transport) -> Result<Vec<u8>> {
let encoded = encode_response(answer)?;
match transport {
Transport::Udp if encoded.len() > self.max_udp_size => {
// 关键:不是截断,而是置 TC 位,让客户端改用 TCP 重试
let mut truncated = encode_header_only(answer)?;
truncated.set_truncated(true); // TC = 1
Ok(truncated)
}
_ => Ok(encoded),
}
}
}TC 位是"换个协议再来"的信号,不是"响应不完整"的错误。
这里有一个极容易写错的细节:置了 TC 的响应应该只包含头(可能加问题区),而不是"截断的答案"。 如果返回了部分答案,客户端可能会把不完整的记录当成有效数据。正确做法是让客户端明确知道"这次没用,请用 TCP 重来"。
TCP 上的 DNS 和 UDP 只差一层:报文前面多了 2 字节长度前缀。
impl Server {
fn handle_tcp(&self, stream: &mut TcpStream) -> Result<()> {
loop {
// 长度前缀:2 字节,大端
let mut len_buf = [0u8; 2];
match stream.read_exact(&mut len_buf) {
Ok(()) => {}
Err(e) if e.kind() == ErrorKind::UnexpectedEof => break, // 正常关闭
Err(e) => return Err(e.into()),
}
let len = u16::from_be_bytes(len_buf) as usize;
if len == 0 || len > self.max_tcp_message {
return Err(Error::BadLength(len));
}
let mut buf = vec![0u8; len];
stream.read_exact(&mut buf)?;
let response = self.handle_query(&buf, Transport::Tcp)?;
stream.write_all(&(response.len() as u16).to_be_bytes())?;
stream.write_all(&response)?;
}
Ok(())
}
}注意 loop——TCP 上一条连接会跑多个查询,不能答完一个就关。 而且必须限制单连接的总查询数或闲置时长,否则就是一个连接耗尽资源的入口(这和长连接的通用坑是同一类)。
EDNS0 改变了这个上限: 客户端可以在 OPT 记录里声明自己支持更大的 UDP 报文(通常 1232 或 4096 字节)。但服务器必须自己再设一个上限——因为"客户端声称支持 4096"和"网络真的能过 4096"是两回事,分片丢弃(fragmentation)会让大 UDP 报文静默消失。
"客户端说它支持"永远不能当作"链路能承载"。 这是 MTU 相关问题的统一形态:发送方看到的成功,只是"本地网卡接受了",和"对方收到了"没有必然关系。 所以响应越大,越应该退回 TCP——不是为了性能,是为了可达性。
第四步:缓存——TTL 的语义是这篇的核心
现在到全文最重要的部分。
先看一个几乎每个自研 DNS 都会踩的坑
// 错误写法:原样返回上游的 TTL
pub fn respond_from_cache(&self, entry: &CacheEntry) -> Response {
let mut resp = entry.to_response();
// resp 里的 TTL 就是上游给的 300
resp
}这段代码看起来完全正常,但它有一个会累积的 bug。
设想一条链:客户端 → 我的解析器 → 上游。
- 上游说 TTL=300
- 我缓存了 300 秒
- 第 200 秒时客户端来查,我把 TTL=300 原样返回
- 客户端于是把这份"已经存在了 200 秒"的数据又缓存了 300 秒
结果:数据最多可以存在 500 秒,超过上游允许的 300 秒。 更糟的是,如果下游也是一层解析器,每多一跳就多叠一次 TTL,新鲜度承诺被彻底架空。
正确做法:返回"剩余 TTL",而不是"原始 TTL"。
impl CacheEntry {
/// 剩余的 TTL:从 300 开始往下减,到 0 就是过期
pub fn remaining_ttl(&self, now: Instant) -> u32 {
self.expires_at
.checked_duration_since(now)
.map(|d| d.as_secs() as u32)
.unwrap_or(0)
}
/// 返回给下游时,必须用剩余 TTL
pub fn to_response(&self, now: Instant) -> Response {
let ttl = self.remaining_ttl(now);
let mut resp = self.records.clone();
for r in &mut resp.records {
// 用 min 更保守:如果不同记录 TTL 不同,取最小的那个
r.ttl = r.ttl.min(ttl);
}
resp
}
}这就引出了这篇文章真正的主题句:
TTL 不是"你应该缓存多久",而是"上游允许你最多缓存多久"。
这两句话的差别,是整个缓存设计的分界线:
| 理解 | 后果 |
|---|---|
| "TTL 是我该缓存的时间" | 你把它当指令,只能照做 |
| "TTL 是我能缓存的上限" | 你可以在上限内自由决定(比如更保守地只缓存 1/3) |
第二种理解带来两个实际好处:
好处一:你可以比 TTL 更短,以便在故障时快速切换。 如果某个域名要紧急改 IP,而 TTL 是 24 小时,那么"比 TTL 更保守地缓存"(比如 300 秒)能让你在几分钟内完成切换。代价是查询量上升——这是一个可以直接量化的运维选择。
好处二:你必须在 TTL 到期时真的失效。 不能"反正是缓存,多留一会儿也没事"——这是把上游的新鲜度承诺当成了建议,而它是契约。
缓存里存什么:绝对时刻,不是剩余秒数
pub struct CacheEntry {
pub key: CacheKey,
pub records: Vec<Record>,
/// 绝对过期时刻 —— 不是 remaining_ttl
pub expires_at: Instant,
/// 上游的原始 TTL,用于观测和调优
pub original_ttl: u32,
}
pub struct CacheKey {
/// 规范化后的名字(小写)
pub name: Name,
/// 记录类型:A / AAAA / CNAME / MX ...
pub rtype: RecordType,
/// 类别,几乎总是 IN,但必须在键里
pub class: RecordClass,
}两个设计点都是关键:
点一:存 Instant(绝对时刻),不存剩余秒数。
如果存 remaining_ttl: u32,那么每次读取都必须做 remaining -= elapsed 并写回去——读操作变成了写操作,缓存立刻需要锁或者原子操作,而且并发读会互相干扰。
存绝对时刻之后,读是完全只读的,多线程共享一把读锁都不需要。代价是 Instant 在序列化/持久化上更麻烦——但 DNS 缓存本来就不需要持久化(重启重新解析即可)。
点二:缓存键是三元组 (name, type, class)。
只用 name 做键是最常见的设计错误: 同一个域名有 A 记录(IPv4)和 AAAA 记录(IPv6),只用名字做键会导致 A 记录把 AAAA 记录覆盖掉,于是 IPv6 用户突然拿到 IPv4 地址,或者反过来——而且这个错误只在"同一域名两种类型都被查询过"时出现,单测里完美通过。
impl Cache {
pub fn get(&self, key: &CacheKey, now: Instant) -> Option<&CacheEntry> {
let entry = self.map.get(key)?;
if entry.expires_at <= now {
// 惰性过期:读的时候顺手标记,交给后台清理
return None;
}
Some(entry)
}
}负缓存:这篇最容易被漏掉的一步
NXDOMAIN(这个名字不存在)也是可以缓存的,而且必须缓存。
pub enum CacheValue {
/// 正常记录
Records(Vec<Record>),
/// NXDOMAIN:名字不存在
NameError { ttl: u32 },
/// NODATA:名字存在,但这个类型没有记录
NoData { ttl: u32 },
}为什么必须缓存? 设想一个页面引用了 cdn.example.com,但配置写错了,写成了 cdn.exmaple.com(拼错)。如果 NXDOMAIN 不缓存,每一次页面加载都会向上游发起一次查询,而且是查一个永远不存在的名字。
放大效果很可观: 一个每天访问 100 万次的页面 × 3 个拼错的资源引用 = 每天 300 万次注定失败的查询,全部穿透到上游。
NXDOMAIN 的 TTL 从哪里来? 不在答案区,而在权威区的 SOA 记录里:
impl Resolver {
fn cache_negative(&mut self, resp: &Response, now: Instant) -> Result<()> {
// RFC 2308:负缓存的 TTL 取 SOA 的 minimum 字段,
// 或者 SOA 记录自己的 TTL,取二者较小
let soa = resp.authority.iter()
.find(|r| r.rtype == RecordType::SOA)
.ok_or(Error::MissingSoa)?;
let ttl = soa.ttl.min(soa.minimum);
// 加个上限,防止上游给出一个荒谬的巨大值(比如 7 天)
let ttl = ttl.min(self.max_negative_ttl);
self.cache.insert(key, CacheValue::NameError { ttl }, now + Duration::from_secs(ttl as u64));
Ok(())
}
}soa.minimum 这个字段的名字有误导性——它不表示"最小 TTL",而是 RFC 2308 里指定的"负缓存时长"。把它当"最小值"用的实现,行为会和预期完全不同。
负缓存的缺失是"看起来没问题但成本巨大"的典型:功能上一切正常,只是每次错误都打到上游。 而这类问题的排查方式只有一种——看查询日志里"重复的、注定失败的查询"占了多大比例。 这个比例往往比想象的高得多。
缓存还要防一件事:TTL 递减到 0 的边界
/// 一个容易忽略的边界:TTL 恰好为 0 的记录
pub fn is_cacheable(records: &[Record]) -> bool {
// TTL = 0 表示"可以用于本次响应,但不应该被缓存"
records.iter().all(|r| r.ttl > 0)
}TTL=0 有明确含义:这份数据可以回答当前这次查询,但不许缓存。 上游用它的场景包括"服务正在故障转移,我不确定这个答案五分钟内还有效"。
很多实现在这里做了"善意"的处理——把 0 当成 1 秒来避免每次都查。 这直接违背了上游的意图,而且会让故障转移期间的所有客户端卡在一个可能错误的答案上。
协议里的"边界值"往往不是"极端情况",而是"另一种语义"。
TTL = 0、HTTP 的Cache-Control: no-store、max-age=0——它们说的是"不要缓存",而不是"缓存很短时间"。 把语义当成数值处理,是缓存类 bug 最主要的来源。**
第五步:淘汰——两个互相独立的维度
DNS 缓存的条目会在两种完全不同的原因下离开:
pub struct Cache {
map: LruMap<CacheKey, CacheEntry>,
/// 容量上限
capacity: usize,
}
impl Cache {
/// 维度一:容量满 → LRU 淘汰
pub fn insert(&mut self, key: CacheKey, entry: CacheEntry) {
if self.map.len() >= self.capacity {
// LRU 自己会淘汰最久未用的
}
self.map.insert(key, entry);
}
/// 维度二:时间到期 → 惰性删除 + 后台清理
pub fn sweep(&mut self, now: Instant) -> usize {
// 定期扫描,清掉过期的
let expired: Vec<CacheKey> = self.map.iter()
.filter(|(_, e)| e.expires_at <= now)
.map(|(k, _)| k.clone())
.collect();
for k in &expired {
self.map.remove(k);
}
expired.len()
}
}为什么必须区分这两个维度?因为它们的最优策略完全不同:
| 维度 | 触发原因 | 正确策略 |
|---|---|---|
| 容量 | 条目太多 | LRU(借"最近用过的大概率还用") |
| 时间 | TTL 到期 | 精确按 expires_at,和访问模式无关 |
如果把两者混在一起——比如"到期的条目按 LRU 顺序淘汰"——就会出现:一个刚被访问过一次、但早就过期的条目,比一个很久没访问、但还很新鲜的条目活得更久。 前者是错误数据,后者是可用的。
惰性删除和定期清理必须都做:
- 只做惰性(读时发现过期就删):一个再也不会被读的键会永远占着内存
- 只做定期:两次扫描之间,读操作会拿到过期数据
而惰性删除的正确写法是"读时判定过期",不是"读时删除"——因为删除需要写锁,会把只读路径变成读写路径。判定过期 → 返回未命中 → 交给后台清理,这样读路径能保持完全无锁。
关于 DNS 缓存的淘汰压力,有一个和普通缓存不同的特点:TTL 决定了条目本来就会自然死亡。
普通 LRU 缓存的条目可能永远不死(比如热点数据的 key 不变),所以容量淘汰是主要机制。DNS 缓存的每个条目都有一个明确的死期(几秒到几小时),所以"时间淘汰"承担了大部分清理工作,LRU 只在缓存被恶意/异常打满时才起作用。
这也意味着容量可以设得比直觉大。 因为大部分条目会自己消失,容量只要够覆盖"一个 TTL 周期内的活跃域名"就够了——实践中通常是"QPS × 平均 TTL × 若干倍"。
"条目会自己死掉"是对缓存容量的最大解放。 反过来看,如果缓存的条目寿命不受控(比如永久有效),那么容量规划就变成了一个必须精确计算的问题——这也是为什么"给缓存设置一个上限 TTL"通常是好主意,哪怕上游给的 TTL 更长。
第六步:查上游——超时和错误语义比缓存更容易出错
缓存未命中就要问上游。这一步是异步的、慢的(几十到几百毫秒),而且它有几个容易搞错的语义边界。
超时必须有界,而且必须真的取消
pub async fn resolve_upstream(&self, query: &Query) -> Result<Response> {
// 超时不是"选一个数字",而是"客户端等得起多久"
// 客户端自己通常有 2 秒超时,所以上游预算必须远小于它
let timeout = self.upstream_timeout; // 比如 800ms
match tokio::time::timeout(timeout, self.send_and_await(query)).await {
Ok(Ok(resp)) => Ok(resp),
Ok(Err(net_err)) => Err(Error::Upstream(net_err)),
Err(_elapsed) => Err(Error::Timeout), // 明确的超时,不是通用的网络错误
}
}超时值的选取有一条硬的约束:上游预算 + 本地处理时间 < 客户端超时。 如果客户端等 2 秒而你的上游预算也是 2 秒,那么每次超时都意味着客户端先放弃,你继续消耗资源去等一个没人要的答案。
而且超时之后必须真的取消上游请求。 只"不再等"但让请求继续跑,会出现**"上游还在处理,我已经返回失败,然后我缓存了失败,但上游其实成功了"**——这类不一致会持续到缓存过期。
超时返回什么:SERVFAIL 而不是 NXDOMAIN
这是整篇里第二重要的语义(仅次于 TTL):
pub fn error_to_response(err: &Error, query: &Query) -> Response {
match err {
// 上游超时 / 网络错误 / 上游返回 SERVFAIL
// → 我不知道答案,请稍后重试
Error::Timeout | Error::Upstream(_) => Response::servfail(query),
// 上游明确说"这个名字不存在"
// → 这是一个确定的答案,且可以被负缓存
Error::NameError => Response::nxdomain(query),
// 上游拒绝了这个查询(策略限制)
Error::Refused => Response::refused(query),
}
}为什么这两个不能混?
| 返回码 | 语义 | 客户端的反应 | 能不能缓存 |
|---|---|---|---|
| NXDOMAIN | 这个名字确定不存在 | 放弃,报"域名不存在" | 能(长时间) |
| SERVFAIL | 我现在查不到 | 重试其他解析器 | 不能(最多几秒) |
把超时返回成 NXDOMAIN,等于把"临时故障"固化成"永久答案"。 而且因为它可以被负缓存,这个错误的答案会被缓存几小时——用户会看到"域名不存在",一直看到缓存过期。
更糟的是这个错误会传染: 你的下游如果也是一层解析器,它会继续把这个 NXDOMAIN 缓存并传播下去。一次上游抖动,可能变成一片区域的"域名全部不存在"。
"我不知道"和"它不存在"必须是两种不同的回答。 这个区分在缓存系统里尤其重要,因为只有"确定性的答案"才允许被缓存,而错误信息几乎总是非确定性的。 把错误当成答案缓存,是一个会自我放大的故障。
上游也要防放大:单域名去重
上游请求是稀缺资源,而**"同一时刻大量客户端查同一个域名"是常态**——比如一批机器同时启动、同一个页面的一堆用户。
pub struct SingleFlight {
/// 正在进行的上游查询:域名 → 等待中的通知通道
inflight: Mutex<HashMap<CacheKey, Vec<oneshot::Sender<Response>>>>,
}
impl SingleFlight {
pub async fn resolve(
&self,
key: CacheKey,
do_query: impl Future<Output = Result<Response>>,
) -> Result<Response> {
// 第一个到的人负责真正去查
let (tx, rx) = oneshot::channel();
let leader = {
let mut map = self.inflight.lock().unwrap();
match map.entry(key.clone()) {
Entry::Occupied(mut e) => {
e.get_mut().push(tx); // 后来者排队
false
}
Entry::Vacant(e) => {
e.insert(vec![tx]);
true
}
}
};
if leader {
let result = do_query.await;
// 无论成功失败,都要唤醒所有等待者并从表里摘掉
let waiters = self.inflight.lock().unwrap().remove(&key).unwrap_or_default();
for w in waiters {
let _ = w.send(result.clone().unwrap_or_else(|e| Response::servfail_from(&e)));
}
result
} else {
rx.await.map_err(|_| Error::LeaderFailed)
}
}
}这段代码里最容易漏的是"失败也要唤醒等待者"。
如果 leader 失败后直接 return Err(...) 而忘了通知,所有等待者会永远挂在那里等一个不会来的消息——表现是"上游一抖动,解析器就开始堆积请求直到 OOM"。和讲幂等的那篇是同一类问题:状态机的每一个出口都必须有对应的动作。
注意这里唤醒的是 Response 而不是 Result——因为等待者需要的是一个"上游到底说了什么"的答案,包括"上游超时了"这个答案本身,它应该被独立地转换成 SERVFAIL。
去重(single-flight)几乎是所有"昂贵资源 + 高并发相同请求"场景的标配方案。 它的实现模式非常固定:第一个到的人做事,其他人排队;无论成功、失败还是超时,都必须唤醒队列。 而它的收益也总是很大——热门对象失效时,把 N 次上游请求压成 1 次。
第七步:并发与响应放大
最后一件必须做的事:防止自己被当成放大攻击的跳板。
pub struct ResponseRateLimit {
/// 对同一客户端的同一响应,限制每秒发送次数
buckets: ShardedMap<IpPrefix, TokenBucket>,
}
impl ResponseRateLimit {
pub fn allow(&mut self, client: IpAddr, response: &Response, now: Instant) -> bool {
// 关键:惩罚"小问题得到大响应"的查询
let cost = response.encoded_size() / response.question_size() + 1;
self.buckets.entry_mut(client.to_prefix(24)).allow_cost(cost, now)
}
}为什么成本按"响应大小 / 请求大小"算?
因为放大攻击的形状就是"1 个 64 字节的请求,换来 4000 字节的响应"。ANY 类型查询是经典的放大器(一个请求要回所有记录类型)。 所以:
第一,成本高的查询要消耗更多令牌。 正常查询成本是 1,一个 XXX 元的放大查询成本是 60。这样正常用户不受影响,攻击者几秒内就被限掉。
第二,按前缀(/24)而不是按单个 IP 限。 攻击者可以用海量伪造源 IP,按单个 IP 限速等于没限。 而按前缀聚合能把"同一网段来的洪水"识别出来——代价是同一网段里的正常用户可能被误伤,这是必须接受的天平倾斜。
限流的粒度永远是一个取舍:粒度越细越精准,越容易被绕过。 讲限流器的那篇说的是"保护自己",这里多了一层——当你是一个可以放大流量的服务时,限流同时是"保护别人"。
结论
DNS 服务器的代码量不大,但它是这一整个系列里"接口语义"最密集的一个系统。真正的工作量分布:
报文解析与边界检查 ~30% (长度、指针、跳转次数,全部来自不可信输入)
名字索引与匹配规则 ~15% (反转 Trie + 通配符优先级)
缓存语义 ~30% (TTL 是上限、绝对时刻、负缓存、TTL=0)
上游交互与错误语义 ~25% (超时预算、SERVFAIL vs NXDOMAIN、去重、唤醒)注意"算法"在这里几乎不存在。 没有复杂的排序、没有图搜索、没有分布式共识——整个系统难在"每一条语义都不能搞混"。
三条最值得记住的判断:
- TTL 是"允许缓存的上限",不是"应该缓存的时间"。 由此推出:返回剩余 TTL、TTL=0 不缓存、负缓存必须做。
- "我不知道"和"它不存在"是两种回答,对应 SERVFAIL 和 NXDOMAIN。 由此推出:错误不能被当作答案缓存。
- 可以放大的服务,限流是保护别人。 由此推出:限流成本要按放大比算,粒度要按前缀聚合。
这三条有个共同点:它们的错误形态都不是"崩溃",而是"多一点流量""慢一点生效""偶尔返回不存在的域名"。 系统一直"能用",只是持续地在某些方向上放大错误——这类问题只有靠对协议语义的清晰理解才能发现,性能图表上是看不出来的。
下一篇从"语义密集"换到"状态密集":一个必须为用户维护持久状态的实时系统(IM),会看到前面所有缓存和存储的取舍被重新排列一次。