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 不能将其当作业务错误响应。

请求响应独立 Stream 时序及三类失败分支

本机运行四种请求结果

使用 Go 1.26 与 go-libp2p v0.50.0。在空目录执行以下命令,创建模块并安装固定版本依赖:

bash
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。

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 截止时间。

运行程序:

bash
go run .

预期输出(只列出本程序打印的业务结果):

text
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 解码就能识别一条完整消息。若以后改成单流承载多条消息,应增加明确的长度前缀、帧大小上限和并发响应分发逻辑,不能直接复用当前的一问一答处理方式。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

如何定义请求响应协议并处理超时

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通