P2P 与分布式存储 / 系统课时
如何定义请求响应协议并处理超时
如何定义请求响应协议并处理超时
实现节点 A 向节点 B 发起一次请求、取得对应响应,并区分业务错误、读取超时与远端提前关闭。示例使用 go-libp2p,在同一个程序中启动两个本地节点,逐次验证四种结果。
学习目标
- 定义有协议版本和
requestId的请求响应消息。 - 使用独立 Stream 完成一次请求和响应,设置完整操作时限。
- 区分成功、业务错误、超时与远端关闭,并决定何时重试。
消息字段与关联规则
选用协议标识 /anystack/reqresp/1.0.0,请求和响应各是一个 JSON 对象。requestId 由发起方生成,服务端必须原样回填;op 指定操作;result 与 error 只出现其一。协议名的版本用于防止新旧消息格式被误当成相同协议。
| 方向 | 关键字段 | 示例 |
|---|---|---|
| 请求 | requestId、op |
q-01、ping |
| 成功响应 | requestId、result |
q-01、pong |
| 错误响应 | requestId、error |
q-02、UNKNOWN_OP |
一次请求使用一个双向 Stream。它运行在已有 libp2p 连接上,并不要求每次都重新建立 TCP 连接。客户端向 Stream 写入一条 JSON 消息,服务端读取后回写一条 JSON 响应,随后双方关闭 Stream。json.Encoder.Encode 会附带换行,json.Decoder.Decode 能在读到完整 JSON 对象后返回,不必等待对方先关闭连接。
虽然独立 Stream 已经隔离并发请求,仍要校验响应里的 requestId:这样能发现服务端回错消息,也便于日志关联。真实系统应保证该 ID 在重试和并发请求中可追踪且不与其他业务请求冲突。
一次请求的时序和失败分支
节点 A 先连接 B,然后以约定的协议 ID 打开 Stream;B 的 SetStreamHandler 接收该 Stream。成功路径为“写请求、处理、写响应、校验 ID、关闭”。遇到未知操作时,B 返回结构化的 error;遇到超时或异常关闭,A 不能将其当作业务错误响应。

本机运行四种请求结果
使用 Go 1.26 与 go-libp2p v0.50.0。在空目录执行以下命令,创建模块并安装固定版本依赖:
go mod init example.com/p2p-reqresp
go get github.com/libp2p/go-libp2p@v0.50.0预期结果:当前目录生成 go.mod,其中记录 go-libp2p v0.50.0;依赖下载的具体日志因环境而异。将以下完整代码保存为 main.go。
package main
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"time"
libp2p "github.com/libp2p/go-libp2p"
"github.com/libp2p/go-libp2p/core/host"
"github.com/libp2p/go-libp2p/core/network"
"github.com/libp2p/go-libp2p/core/peer"
"github.com/libp2p/go-libp2p/core/protocol"
)
const protocolID protocol.ID = "/anystack/reqresp/1.0.0"
type Request struct {
ID string `json:"requestId"`
Op string `json:"op"`
}
type Reply struct {
ID string `json:"requestId"`
Result string `json:"result,omitempty"`
Error string `json:"error,omitempty"`
}
func handle(s network.Stream) {
defer s.Close()
_ = s.SetDeadline(time.Now().Add(2 * time.Second))
var req Request
// 限制单条请求读取量,避免无限读取占用内存。
if err := json.NewDecoder(io.LimitReader(s, 4096)).Decode(&req); err != nil {
return
}
if req.Op == "close" {
return // 模拟远端尚未响应就关闭
}
if req.Op == "slow" {
time.Sleep(400 * time.Millisecond)
}
reply := Reply{ID: req.ID}
switch req.Op {
case "ping":
reply.Result = "pong"
case "slow":
reply.Result = "late"
default:
reply.Error = "UNKNOWN_OP"
}
_ = json.NewEncoder(s).Encode(reply)
}
func call(ctx context.Context, h host.Host, to peer.ID, req Request, timeout time.Duration) (Reply, error) {
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
s, err := h.NewStream(ctx, to, protocolID)
if err != nil {
return Reply{}, err
}
defer s.Close()
// Context 限制开流;Deadline 才能限制后续读写。
deadline, _ := ctx.Deadline()
if err := s.SetDeadline(deadline); err != nil {
_ = s.Reset()
return Reply{}, err
}
if err := json.NewEncoder(s).Encode(req); err != nil {
_ = s.Reset()
return Reply{}, err
}
var reply Reply
if err := json.NewDecoder(io.LimitReader(s, 4096)).Decode(&reply); err != nil {
_ = s.Reset()
return Reply{}, err
}
if reply.ID != req.ID {
_ = s.Reset()
return Reply{}, fmt.Errorf("响应 ID 不匹配")
}
if reply.Error != "" {
return reply, fmt.Errorf("业务错误: %s", reply.Error)
}
return reply, nil
}
func main() {
ctx := context.Background()
a, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))
if err != nil {
panic(err)
}
defer a.Close()
b, err := libp2p.New(libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))
if err != nil {
panic(err)
}
defer b.Close()
b.SetStreamHandler(protocolID, handle)
if err := a.Connect(ctx, peer.AddrInfo{ID: b.ID(), Addrs: b.Addrs()}); err != nil {
panic(err)
}
tests := []struct {
req Request
timeout time.Duration
}{
{Request{"q-01", "ping"}, time.Second},
{Request{"q-02", "unknown"}, time.Second},
{Request{"q-03", "slow"}, 100 * time.Millisecond},
{Request{"q-04", "close"}, time.Second},
}
for _, tc := range tests {
reply, err := call(ctx, a, b.ID(), tc.req, tc.timeout)
if err == nil {
fmt.Printf("%s: %s\n", tc.req.ID, reply.Result)
continue
}
var netErr net.Error
switch {
case errors.Is(err, context.DeadlineExceeded) || (errors.As(err, &netErr) && netErr.Timeout()):
fmt.Printf("%s: 超时\n", tc.req.ID)
case errors.Is(err, io.EOF) || errors.Is(err, network.ErrReset):
fmt.Printf("%s: 远端关闭\n", tc.req.ID)
default:
fmt.Printf("%s: %v\n", tc.req.ID, err)
}
}
}预期结果:四次调用分别独立开流,不需要为每次请求重连;slow 操作在服务端延迟 400ms,超过客户端的 100ms 截止时间。
运行程序:
go run .预期输出(只列出本程序打印的业务结果):
q-01: pong
q-02: 业务错误: UNKNOWN_OP
q-03: 超时
q-04: 远端关闭示例中的 /tcp/0 表示让操作系统分配本地监听端口;实际端口每次可能不同。这里的 q-01 等是固定演示请求 ID,真实业务应使用唯一标识。
错误处理与重试边界
代码用 context.WithTimeout 限制拨号及开流阶段,用 Stream.SetDeadline 限制随后的写入和读取;只给 NewStream 设置 Context,不能保证 Decode 按时结束。超时后使用 Reset 结束这次 Stream,避免继续占用资源。
| 现象 | 判断与处理 |
|---|---|
收到 error=UNKNOWN_OP |
已收到有效响应;检查操作名或协议版本,不要盲目重试 |
| 截止时间到达 | 记录 requestId 和耗时,停止本次等待,按策略重试 |
读到 io.EOF 或 network.ErrReset |
对端没有完整回包;检查远端关闭、崩溃或流重置 |
| 响应 ID 不一致 | 当作协议错误并丢弃,不可交给当前请求的调用方 |
这个最小协议规定一条 Stream 只承载一问一答,因此用 JSON 解码就能识别一条完整消息。若以后改成单流承载多条消息,应增加明确的长度前缀、帧大小上限和并发响应分发逻辑,不能直接复用当前的一问一答处理方式。