func (ms *maintenanceServer) Snapshot(sr *pb.SnapshotRequest, srv pb.Maintenance_SnapshotServer) error {
    // 读取存储版本信息，并将其存储在storageVersion变量中
    ver := schema.ReadStorageVersion(ms.bg.Backend().ReadTx())
    storageVersion := ""
    if ver != nil {
        storageVersion = ver.String()
    }
    // 创建一个数据库的快照，并将快照结果存储在snap变量中
    snap := ms.bg.Backend().Snapshot()
    // 创建了一个io.Pipe对象，并将其分为读端pr和写端pw。
    // 这将用于将快照数据写入管道，并从管道中读取数据发送给客户端。
    pr, pw := io.Pipe()


    defer pr.Close()

    // 启动一个goroutine，其中调用snap.WriteTo(pw)方法将快照数据写入管道，并在写入完成后关闭pipe写端。
    go func() {
        snap.WriteTo(pw)
        if err := snap.Close(); err != nil {
            ms.lg.Warn("failed to close snapshot", zap.Error(err))
        }
        pw.Close()
    }()


    // 用于计算快照数据的SHA256校验和。
    h := sha256.New()

    // 初始化发送数据量
    sent := int64(0)
    // 获取快照数据的总大小
    total := snap.Size()
    // 格式化为人类可读的格式
    size := humanize.Bytes(uint64(total))

    // 记录发送快照数据的开始时间，打印快照的总字节数、大小、存储版本等信息
    start := time.Now()
    ms.lg.Info("sending database snapshot to client",
        zap.Int64("total-bytes", total),
        zap.String("size", size),
        zap.String("storage-version", storageVersion),
    )
    for total-sent > 0 {
        // buffer仅用于保存从流中读取的字节
        // 响应的大小是操作系统页面大小的倍数，在boltdb中获取
        // e.g. 4*1024
        // NOTE: 方法不会等待客户端接收到消息。因此，在发送操作之间，不能安全地重用缓冲区。
        // 简而言之，这段注释提醒开发者，在发送操作之间不能重用缓冲区，
        // 因为srv.Send方法不会等待消息被客户端接收完毕。
        // 申请一个缓存区：32 * 1024
        buf := make([]byte, snapshotSendBufferSize)

        // 从管道中读取快照数据到缓存区buf中
        n, err := io.ReadFull(pr, buf)
        if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
            return togRPCError(err)
        }
        // 将读取的字节数加到sent变量中
        sent += int64(n)


        // 创建一个pb.SnapshotResponse对象，存储读取的快照数据、剩余字节数和存储版本
        resp := &pb.SnapshotResponse{
            RemainingBytes: uint64(total - sent),
            Blob:           buf[:n],
            Version:        storageVersion,
        }
        // 将pb.SnapshotResponse对象发送给客户端，并使用h.Write()方法将快照数据写入SHA256校验和的计算器中。
        if err = srv.Send(resp); err != nil {
            return togRPCError(err)
        }
        h.Write(buf[:n])
        // 循环继续，直到发送完所有的快照数据
    }
    // 计算SHA256校验和
    sha := h.Sum(nil)

    // 省略部分代码，这段代码大概就是记录快照相关日志，创建pb.SnapshotResponse对象，发送response给客户端
    ... ...
    return nil
}

2.backend.Snapshot()函数

func (b *backend) Snapshot() Snapshot {
    // 提交一个批处理事务。
    b.batchTx.Commit()

    // 在互斥锁b.mu上获取一个读锁，并在函数执行结束后释放该锁。
    b.mu.RLock()
    defer b.mu.RUnlock()
    // 开启一个只读事务
    tx, err := b.db.Begin(false)
    if err != nil {
        b.lg.Fatal("failed to begin tx", zap.Error(err))
    }


    stopc, donec := make(chan struct{}), make(chan struct{})
    // 计算事务的大小
    dbBytes := tx.Size()
    go func() {
        defer close(donec)
        // sendRateBytes是基于在1千兆比特/秒的连接上传输快照数据的假设下计算出来的，假设TCP的最小吞吐量为100MB/秒。
        var sendRateBytes int64 = 100 * 1024 * 1024
        // 根据事务大小计算出一个警告超时时间
        warningTimeout := time.Duration(int64((float64(dbBytes) / float64(sendRateBytes)) * float64(time.Second)))
        if warningTimeout < minSnapshotWarningTimeout {
            warningTimeout = minSnapshotWarningTimeout
        }
        
        // 计算传输快照数据所需的时间，并在超过一定阈值时记录一个警告日志。
        // 这个goroutine会不断循环，直到接收到stopc通道的信号。
        start := time.Now()
        ticker := time.NewTicker(warningTimeout)
        defer ticker.Stop()
        for {
            select {
            case <-ticker.C:
                b.lg.Warn(
                    "snapshotting taking too long to transfer",
                    zap.Duration("taking", time.Since(start)),
                    zap.Int64("bytes", dbBytes),
                    zap.String("size", humanize.Bytes(uint64(dbBytes))),
                )


            case <-stopc:
                snapshotTransferSec.Observe(time.Since(start).Seconds())
                return
            }
        }
    }()

    // 返回一个指向snapshot结构体的指针，其中核心是包含了一个数据库读事务
    return &snapshot{tx, stopc, donec}
}