func NewServer(cfg config.ServerConfig) (srv *EtcdServer, err error) {
    // 1. 引导启动（bootstrap）：加载或初始化集群配置
    b, err := bootstrap(cfg)
    
    // 2. 创建 EtcdServer 实例
    srv = &EtcdServer{
        Cfg:       cfg,
        lg:        cfg.Logger,
        memberID:  b.cluster.nodeID,
        cluster:   b.cluster.cl,
        // ... 初始化字段
    }
    
    // 3. 初始化 Backend（BoltDB）
    srv.be = b.storage.backend.be
    
    // 4. 初始化 Lessor（租约管理）
    srv.lessor = lease.NewLessor(srv.Logger(), srv.be, srv.cluster, ...)
    
    // 5. 初始化 MVCC Store
    srv.kv = mvcc.New(srv.Logger(), srv.be, srv.lessor, mvccStoreConfig)
    
    // 6. 初始化 AuthStore（认证授权）
    srv.authStore = auth.NewAuthStore(srv.Logger(), ...)
    
    // 7. 初始化 Compactor（自动压缩）
    srv.compactor, _ = v3compactor.New(cfg.Logger(), ...)
    
    // 8. 初始化 Raft Transport（节点间通信）
    tr := &rafthttp.Transport{...}
    tr.Start()
    srv.r.transport = tr
    
    return srv, nil
}

func (s *EtcdServer) Start() {
    s.start()  // 启动核心 run 循环
    
    // 启动后台 goroutines
    s.GoAttach(func() { s.adjustTicks() })                // 调整选举 tick
    s.GoAttach(func() { s.publishV3(s.Cfg.ReqTimeout()) }) // 发布成员信息
    s.GoAttach(s.purgeFile)                               // 清理过期文件
    s.GoAttach(func() { monitorFileDescriptor(...) })     // 监控文件描述符
    s.GoAttach(s.monitorClusterVersions)                  // 监控集群版本
    s.GoAttach(s.monitorStorageVersion)                   // 监控存储版本
    s.GoAttach(s.linearizableReadLoop)                    // 线性化读循环
    s.GoAttach(s.monitorKVHash)                           // 监控数据一致性
    s.GoAttach(s.monitorCompactHash)                      // 监控压缩 hash
    s.GoAttach(s.monitorDowngrade)                        // 监控降级状态
}

func (s *EtcdServer) run() {
    // 初始化调度器
    sched := schedule.NewFIFOScheduler(lg)
    
    // 启动 Raft Node
    s.r.start(rh)
    
    // 主循环
    for {
        select {
        case ap := <-s.r.apply():
            // 应用已提交的 Raft 日志
            f := schedule.NewJob("server_applyAll",
                func(ctx) { s.applyAll(&ep, &ap) })
            sched.Schedule(f)
            
        case leases := <-expiredLeaseC:
            // 吊销过期的租约
            s.revokeExpiredLeases(leases)
            
        case err := <-s.errorc:
            // 致命错误，停止服务
            return
            
        case <-s.stop:
            // 正常停止
            return
        }
    }
}

func (s *EtcdServer) Stop() {
    // 1. 尝试转移 Leader（如果是 Leader）
    s.TryTransferLeadershipOnShutdown()
    
    // 2. 硬停止
    s.HardStop()
}

func (s *EtcdServer) HardStop() {
    // 1. 发送停止信号
    s.stop <- struct{}{}
    
    // 2. 等待所有 goroutines 退出
    <-s.done
}

flowchart TB
    subgraph External["外部接口"]
        GRPC[gRPC Server]
        HTTP[HTTP Handler]
        Peer[Peer Raft Messages]
    end

    subgraph EtcdServer["EtcdServer 核心"]
        Router[请求路由]
        RaftPropose[Raft 提案]
        ApplyLoop[Apply 循环]
        ReadLoop[线性化读循环]
    end

    subgraph RaftLayer["Raft 层"]
        RaftNode[Raft Node]
        WAL[WAL]
        Transport[Raft Transport]
    end

    subgraph ApplyLayer["Apply 层"]
        UberApplier[UberApplier]
        ApplyKV[Apply KV]
        ApplyLease[Apply Lease]
        ApplyAuth[Apply Auth]
    end

    subgraph Storage["存储与支撑"]
        MVCC[MVCC Store]
        Lessor[Lessor]
        AuthStore[AuthStore]
        Membership[Membership]
    end

    GRPC --> Router
    HTTP --> Router
    Peer --> RaftNode

    Router --> RaftPropose
    Router --> ReadLoop

    RaftPropose --> RaftNode
    RaftNode --> WAL
    RaftNode --> Transport
    RaftNode --> ApplyLoop

    ApplyLoop --> UberApplier
    UberApplier --> ApplyKV
    UberApplier --> ApplyLease
    UberApplier --> ApplyAuth

    ApplyKV --> MVCC
    ApplyLease --> Lessor
    ApplyAuth --> AuthStore
    Router --> Membership

    ReadLoop --> MVCC

    style EtcdServer fill:#e1f5ff
    style RaftLayer fill:#fff4e6
    style ApplyLayer fill:#f3e5f5
    style Storage fill:#e8f5e9

// processInternalRaftRequestOnce 处理单次写请求
func (s *EtcdServer) processInternalRaftRequestOnce(
    ctx context.Context,
    r pb.InternalRaftRequest,
) (*apply.Result, error) {
    // 1. 检查 appliedIndex 和 committedIndex 差距
    //    防止 Apply 慢导致内存堆积
    ai := s.getAppliedIndex()
    ci := s.getCommittedIndex()
    if ci > ai+maxGapBetweenApplyAndCommitIndex {
        return nil, errors.ErrTooManyRequests
    }

    // 2. 分配唯一请求 ID
    r.Header = &pb.RequestHeader{
        ID: s.reqIDGen.Next(),
    }

    // 3. 添加认证信息
    authInfo, err := s.AuthInfoFromCtx(ctx)
    if authInfo != nil {
        r.Header.Username = authInfo.Username
        r.Header.AuthRevision = authInfo.Revision
    }

    // 4. 序列化请求
    data, err := r.Marshal()
    if len(data) > int(s.Cfg.MaxRequestBytes) {
        return nil, errors.ErrRequestTooLarge
    }

    // 5. 注册等待通道（用于接收 Apply 结果）
    id := r.Header.ID
    ch := s.w.Register(id)

    // 6. 提交 Raft 提案
    cctx, cancel := context.WithTimeout(ctx, s.Cfg.ReqTimeout())
    defer cancel()
    
    err = s.r.Propose(cctx, data)
    if err != nil {
        s.w.Trigger(id, nil)  // 清理等待通道
        return nil, err
    }

    // 7. 等待 Apply 结果
    select {
    case x := <-ch:
        return x.(*apply.Result), nil
    case <-cctx.Done():
        return nil, s.parseProposeCtxErr(cctx.Err(), start)
    case <-s.stopping:
        return nil, errors.ErrStopped
    }
}

// linearizableReadNotify 确保线性化读
func (s *EtcdServer) linearizableReadNotify(ctx context.Context) error {
    // 1. 检查当前节点是否是 Leader
    s.readMu.RLock()
    nc := s.readNotifier
    s.readMu.RUnlock()

    // 2. 发起 ReadIndex 请求
    //    Raft 会确认当前节点仍是 Leader，并返回当前已提交的 index
    s.readwaitc <- struct{}{}
    select {
    case <-nc.c:
        // ReadIndex 确认完成
        return nc.err
    case <-ctx.Done():
        return ctx.Err()
    case <-s.stopping:
        return errors.ErrStopped
    }
}

// linearizableReadLoop 后台循环处理 ReadIndex
func (s *EtcdServer) linearizableReadLoop() {
    for {
        // 1. 等待读请求
        select {
        case <-s.readwaitc:
        case <-s.stopping:
            return
        }

        // 2. 批量收集读请求（100ms 窗口）
        nextnr := newNotifier()
        s.readMu.Lock()
        nr := s.readNotifier
        s.readNotifier = nextnr
        s.readMu.Unlock()

        // 3. 发起 ReadIndex
        cctx, cancel := context.WithTimeout(context.Background(),
            s.Cfg.ReqTimeout())
        
        // 等待 appliedIndex >= ReadIndex
        if ai := s.getAppliedIndex(); ai < s.r.Index() {
            select {
            case <-s.applyWait.Wait(s.r.Index()):
            case <-cctx.Done():
                cancel()
                nr.notify(cctx.Err())
                continue
            }
        }
        
        cancel()
        nr.notify(nil)  // 通知所有等待的读请求
    }
}

// applyAll 应用所有已提交的日志
func (s *EtcdServer) applyAll(ep *etcdProgress, apply *toApply) {
    // 1. 应用 Snapshot（如果有）
    s.applySnapshot(ep, apply)
    
    // 2. 应用日志条目
    s.applyEntries(ep, apply)
    
    // 3. 验证 Backend 一致性
    backend.VerifyBackendConsistency(s.Backend(), s.Logger(), true, ...)
    
    // 4. 更新 Prometheus 指标
    proposalsApplied.Set(float64(ep.appliedi))
    
    // 5. 触发等待的请求
    s.applyWait.Trigger(ep.appliedi)
    
    // 6. 等待 Raft 完成磁盘写入
    <-apply.notifyc
    
    // 7. 触发 Snapshot（如果需要）
    s.snapshotIfNeededAndCompactRaftLog(ep)
}

// applyEntries 应用日志条目
func (s *EtcdServer) applyEntries(ep *etcdProgress, apply *toApply) {
    for i := range apply.entries {
        e := apply.entries[i]
        
        shouldApplyV3 := membership.ApplyBoth
        if e.Index <= s.consistIndex.ConsistentIndex() {
            shouldApplyV3 = membership.ApplyV2storeOnly
        }
        
        switch e.Type {
        case raftpb.EntryNormal:
            // 应用普通日志
            s.applyEntryNormal(&e, shouldApplyV3)
            s.setAppliedIndex(e.Index)
            
        case raftpb.EntryConfChange:
            // 应用配置变更
            var cc raftpb.ConfChange
            pbutil.MustUnmarshal(&cc, e.Data)
            removedSelf, err := s.applyConfChange(cc, confState, shouldApplyV3)
            s.setAppliedIndex(e.Index)
            s.w.Trigger(cc.ID, &confChangeResponse{...})
        }
    }
}

// applyEntryNormal 应用普通日志
func (s *EtcdServer) applyEntryNormal(e *raftpb.Entry, shouldApplyV3 bool) {
    // 1. 空日志（no-op）：Leader 确认
    if len(e.Data) == 0 {
        s.firstCommitInTerm.Notify()
        if s.isLeader() {
            s.lessor.Promote(s.Cfg.ElectionTimeout())
        }
        return
    }
    
    // 2. 应用请求
    ar, id := apply.Apply(s.lg, e, s.uberApply, s.w, shouldApplyV3)
    
    // 3. 检查空间配额
    if errors.Is(ar.Err, errors.ErrNoSpace) {
        // 触发 NOSPACE 告警
        s.GoAttach(func() {
            a := &pb.AlarmRequest{
                MemberID: uint64(s.MemberID()),
                Action:   pb.AlarmRequest_ACTIVATE,
                Alarm:    pb.AlarmType_NOSPACE,
            }
            s.raftRequest(s.ctx, pb.InternalRaftRequest{Alarm: a})
            s.w.Trigger(id, ar)
        })
        return
    }
    
    // 4. 触发等待的请求
    s.w.Trigger(id, ar)
}

// RangeRequest 读取请求
type RangeRequest struct {
    // key 是范围的起始键
    Key []byte
    
    // range_end 是范围的结束键（不包含）
    // 如果 range_end 是 '\0'，则读取所有 >= key 的键
    // 如果 range_end 是 key+1，则读取所有以 key 为前缀的键
    RangeEnd []byte
    
    // limit 限制返回的键数量，0 表示无限制
    Limit int64
    
    // revision 指定读取的版本，<= 0 表示读取最新版本
    Revision int64
    
    // sort_order 指定排序顺序
    SortOrder RangeRequest_SortOrder  // NONE, ASCEND, DESCEND
    
    // sort_target 指定排序字段
    SortTarget RangeRequest_SortTarget  // KEY, VERSION, CREATE, MOD, VALUE
    
    // serializable 为 true 时使用本地读，不保证线性化
    Serializable bool
    
    // keys_only 为 true 时只返回键，不返回值
    KeysOnly bool
    
    // count_only 为 true 时只返回计数，不返回键值对
    CountOnly bool
    
    // min_mod_revision 过滤 mod_revision < 此值的键
    MinModRevision int64
    
    // max_mod_revision 过滤 mod_revision > 此值的键
    MaxModRevision int64
    
    // min_create_revision 过滤 create_revision < 此值的键
    MinCreateRevision int64
    
    // max_create_revision 过滤 create_revision > 此值的键
    MaxCreateRevision int64
}

// RangeResponse 读取响应
type RangeResponse struct {
    Header *ResponseHeader
    
    // kvs 是匹配的键值对列表
    Kvs []*mvccpb.KeyValue
    
    // more 指示是否还有更多数据（受 Limit 限制）
    More bool
    
    // count 是范围内的键总数（不受 Limit 影响）
    Count int64
}

// ResponseHeader 响应头（所有响应共用）
type ResponseHeader struct {
    ClusterId uint64    // 集群 ID
    MemberId  uint64    // 成员 ID
    Revision  int64     // 操作时的 revision
    RaftTerm  uint64    // 操作时的 Raft Term
}

// Range 处理读取请求
func (s *EtcdServer) Range(ctx context.Context, r *pb.RangeRequest) (*pb.RangeResponse, error) {
    // 1. 创建追踪上下文
    ctx, trace := traceutil.EnsureTrace(ctx, s.Logger(), "range")
    
    // 2. 线性化读：需要确认 Leader 身份
    if !r.Serializable {
        err := s.linearizableReadNotify(ctx)
        trace.Step("agreement among raft nodes before linearized reading")
        if err != nil {
            return nil, err
        }
    }
    
    // 3. 权限检查
    chk := func(ai *auth.AuthInfo) error {
        return s.authStore.IsRangePermitted(ai, r.Key, r.RangeEnd)
    }
    
    // 4. 执行读取
    var resp *pb.RangeResponse
    var err error
    get := func() {
        resp, _, err = txn.Range(ctx, s.Logger(), s.KV(), r)
    }
    
    // 5. 序列化执行（带权限检查）
    if serr := s.doSerialize(ctx, chk, get); serr != nil {
        return nil, serr
    }
    
    return resp, err
}

graph TD
    A[gRPC Client] -->|Range RPC| B[kvServer.Range]
    B -->|参数校验| C[checkRangeRequest]
    C -->|调用| D[EtcdServer.Range]
    D -->|线性化读| E[linearizableReadNotify]
    E -->|ReadIndex| F[Raft Node]
    D -->|权限检查| G[AuthStore.IsRangePermitted]
    D -->|执行读取| H[txn.Range]
    H -->|查询| I[MVCC Store]
    I -->|返回| J[RangeResponse]
    J -->|填充 Header| K[kvServer.hdr.fill]
    K -->|返回| A

// kvServer.Range - gRPC 适配层
func (s *kvServer) Range(ctx context.Context, r *pb.RangeRequest) (*pb.RangeResponse, error) {
    // 1. 参数校验
    if err := checkRangeRequest(r); err != nil {
        return nil, err
    }
    
    // 2. 调用 EtcdServer.Range
    resp, err := s.kv.Range(ctx, r)
    if err != nil {
        return nil, togRPCError(err)  // 转换为 gRPC 错误
    }
    
    // 3. 填充 Header（ClusterId、MemberId）
    s.hdr.fill(resp.Header)
    return resp, nil
}

// checkRangeRequest - 参数校验
func checkRangeRequest(r *pb.RangeRequest) error {
    if len(r.Key) == 0 {
        return rpctypes.ErrGRPCEmptyKey
    }
    
    if _, ok := pb.RangeRequest_SortOrder_name[int32(r.SortOrder)]; !ok {
        return rpctypes.ErrGRPCInvalidSortOption
    }
    
    return nil
}

sequenceDiagram
    autonumber
    participant C as Client
    participant GS as gRPC Server<br/>(kvServer)
    participant ES as EtcdServer
    participant RN as Raft Node
    participant AS as AuthStore
    participant MVCC as MVCC Store

    C->>GS: Range(RangeRequest)
    GS->>GS: checkRangeRequest()
    GS->>ES: Range(ctx, req)
    
    alt Serializable = false (线性化读)
        ES->>RN: ReadIndex
        RN-->>ES: 确认 Leader
    end
    
    ES->>AS: IsRangePermitted()
    AS-->>ES: 权限检查通过
    
    ES->>MVCC: Range(req)
    MVCC->>MVCC: 查询 TreeIndex
    MVCC->>MVCC: 读取 Backend
    MVCC-->>ES: RangeResponse
    
    ES-->>GS: RangeResponse
    GS->>GS: hdr.fill()
    GS-->>C: RangeResponse

// PutRequest 写入请求
type PutRequest struct {
    // key 是要写入的键
    Key []byte
    
    // value 是要写入的值
    Value []byte
    
    // lease 是关联的租约 ID，0 表示无租约
    Lease int64
    
    // prev_kv 为 true 时返回修改前的键值对
    PrevKv bool
    
    // ignore_value 为 true 时保持现有值不变（仅更新租约）
    IgnoreValue bool
    
    // ignore_lease 为 true 时保持现有租约不变
    IgnoreLease bool
}

// PutResponse 写入响应
type PutResponse struct {
    Header *ResponseHeader
    
    // prev_kv 是修改前的键值对（如果 PrevKv=true）
    PrevKv *mvccpb.KeyValue
}

// Put 处理写入请求
func (s *EtcdServer) Put(ctx context.Context, r *pb.PutRequest) (*pb.PutResponse, error) {
    // 1. 创建追踪
    ctx, span := traceutil.Tracer.Start(ctx, "put")
    defer span.End()
    
    // 2. 通过 Raft 提交（写操作必须经过 Raft 共识）
    ctx = context.WithValue(ctx, traceutil.StartTimeKey{}, time.Now())
    resp, err := s.raftRequest(ctx, pb.InternalRaftRequest{Put: r})
    if err != nil {
        return nil, err
    }
    
    return resp.(*pb.PutResponse), nil
}

// raftRequest 提交 Raft 请求（所有写操作的入口）
func (s *EtcdServer) raftRequest(ctx context.Context, r pb.InternalRaftRequest) (proto.Message, error) {
    return s.raftRequestOnce(ctx, r)
}

// raftRequestOnce 提交单次 Raft 请求
func (s *EtcdServer) raftRequestOnce(ctx context.Context, r pb.InternalRaftRequest) (proto.Message, error) {
    result, err := s.processInternalRaftRequestOnce(ctx, r)
    if err != nil {
        return nil, err
    }
    if result.Err != nil {
        return nil, result.Err
    }
    return result.Resp, nil
}

graph TD
    A[gRPC Client] -->|Put RPC| B[kvServer.Put]
    B -->|参数校验| C[checkPutRequest]
    C -->|调用| D[EtcdServer.Put]
    D -->|封装提案| E[raftRequest]
    E -->|提交| F[processInternalRaftRequestOnce]
    F -->|序列化| G[Marshal]
    F -->|提案| H[Raft.Propose]
    H -->|等待| I[wait.Register]
    I -->|Apply 完成| J[Apply 层]
    J -->|权限检查| K[authApplierV3.Put]
    K -->|写入| L[MVCC.Put]
    L -->|持久化| M[Backend]
    M -->|返回| N[PutResponse]
    N -->|唤醒等待| I
    I -->|返回| D

sequenceDiagram
    autonumber
    participant C as Client
    participant GS as gRPC Server
    participant ES as EtcdServer
    participant RN as Raft Node
    participant WAL as WAL
    participant P as Peer
    participant Apply as Apply 层
    participant MVCC as MVCC
    participant BE as Backend

    C->>GS: Put(PutRequest)
    GS->>GS: checkPutRequest()
    GS->>ES: Put(ctx, req)
    
    ES->>ES: processInternalRaftRequestOnce()
    ES->>ES: Marshal(req)
    ES->>ES: wait.Register(id)
    
    ES->>RN: Propose(data)
    RN->>WAL: 持久化日志
    WAL-->>RN: 完成
    
    par 复制到 Peer
        RN->>P: AppendEntries
        P-->>RN: 确认
    end
    
    Note over RN: 多数派确认
    
    RN->>Apply: 提交已确认日志
    Apply->>Apply: authApplierV3.Put()
    Apply->>MVCC: Put(key, value)
    MVCC->>MVCC: 更新 TreeIndex
    MVCC->>BE: 写入 BoltDB
    BE-->>MVCC: 完成
    MVCC-->>Apply: PutResponse
    
    Apply->>ES: wait.Trigger(id, resp)
    ES-->>GS: PutResponse
    GS-->>C: PutResponse

// DeleteRangeRequest 删除请求
type DeleteRangeRequest struct {
    // key 是要删除的范围起始键
    Key []byte
    
    // range_end 是范围结束键（不包含）
    // 如果为空，则只删除 key
    // 如果是 '\0'，则删除所有 >= key 的键
    RangeEnd []byte
    
    // prev_kv 为 true 时返回删除的键值对
    PrevKv bool
}

// DeleteRangeResponse 删除响应
type DeleteRangeResponse struct {
    Header *ResponseHeader
    
    // deleted 是删除的键数量
    Deleted int64
    
    // prev_kvs 是删除的键值对列表（如果 PrevKv=true）
    PrevKvs []*mvccpb.KeyValue
}

// DeleteRange 处理删除请求
func (s *EtcdServer) DeleteRange(ctx context.Context, r *pb.DeleteRangeRequest) (*pb.DeleteRangeResponse, error) {
    ctx, span := traceutil.Tracer.Start(ctx, "delete_range")
    defer span.End()
    
    // 通过 Raft 提交
    resp, err := s.raftRequest(ctx, pb.InternalRaftRequest{DeleteRange: r})
    if err != nil {
        return nil, err
    }
    
    return resp.(*pb.DeleteRangeResponse), nil
}

// TxnRequest 事务请求（基于 Google Paxos 的 MultiOp 设计）
type TxnRequest struct {
    // compare 是条件判断列表（AND 关系）
    Compare []*Compare
    
    // success 是条件为真时执行的操作列表
    Success []*RequestOp
    
    // failure 是条件为假时执行的操作列表
    Failure []*RequestOp
}

// Compare 条件判断
type Compare struct {
    Result CompareResult  // EQUAL, GREATER, LESS, NOT_EQUAL
    Target CompareTarget  // VERSION, CREATE, MOD, VALUE, LEASE
    Key    []byte
    
    // 判断目标值（根据 Target 选择一个）
    Version        int64   // 版本号
    CreateRevision int64   // 创建版本
    ModRevision    int64   // 修改版本
    Value          []byte  // 值
    Lease          int64   // 租约
    
    RangeEnd       []byte  // 范围结束键
}

// RequestOp 操作（Range、Put、DeleteRange、Txn 之一）
type RequestOp struct {
    Request oneof {
        RequestRange       *RangeRequest
        RequestPut         *PutRequest
        RequestDeleteRange *DeleteRangeRequest
        RequestTxn         *TxnRequest  // 嵌套事务
    }
}

// TxnResponse 事务响应
type TxnResponse struct {
    Header    *ResponseHeader
    
    // succeeded 指示条件判断结果
    Succeeded bool
    
    // responses 是操作结果列表（对应 Success 或 Failure）
    Responses []*ResponseOp
}

// ResponseOp 操作结果
type ResponseOp struct {
    Response oneof {
        ResponseRange       *RangeResponse
        ResponsePut         *PutResponse
        ResponseDeleteRange *DeleteRangeResponse
        ResponseTxn         *TxnResponse
    }
}

// Txn 处理事务请求
func (s *EtcdServer) Txn(ctx context.Context, r *pb.TxnRequest) (*pb.TxnResponse, error) {
    // 1. 判断是否为只读事务
    readOnly := txn.IsTxnReadonly(r)
    
    ctx, span := traceutil.Tracer.Start(ctx, "txn",
        trace.WithAttributes(attribute.Bool("read_only", readOnly)))
    defer span.End()
    
    if readOnly {
        // 2. 只读事务：直接从 MVCC 读取
        if !txn.IsTxnSerializable(r) {
            // 线性化读
            err := s.linearizableReadNotify(ctx)
            if err != nil {
                return nil, err
            }
        }
        
        // 3. 权限检查
        var resp *pb.TxnResponse
        var err error
        chk := func(ai *auth.AuthInfo) error {
            return txn.CheckTxnAuth(s.authStore, ai, r)
        }
        
        get := func() {
            resp, _, err = txn.Txn(ctx, s.Logger(), r, false, s.KV(), s.lessor)
        }
        
        if serr := s.doSerialize(ctx, chk, get); serr != nil {
            return nil, serr
        }
        
        return resp, err
    }
    
    // 4. 写事务：通过 Raft 提交
    resp, err := s.raftRequest(ctx, pb.InternalRaftRequest{Txn: r})
    if err != nil {
        return nil, err
    }
    
    return resp.(*pb.TxnResponse), nil
}

// Txn 执行事务（在 Apply 层调用）
func Txn(ctx context.Context, lg *zap.Logger, rt *pb.TxnRequest,
    txnModeWriteWithSharedBuffer bool, kv mvcc.WatchableKV,
    lessor lease.Lessor) (*pb.TxnResponse, int, error) {
    
    // 1. 开启 MVCC 事务
    txn := kv.Read(traceutil.TODO())
    defer txn.End()
    
    // 2. 评估条件判断
    ok := true
    for _, c := range rt.Compare {
        if !applyCompare(txn, c) {
            ok = false
            break
        }
    }
    
    // 3. 根据条件选择执行分支
    var reqs []*pb.RequestOp
    if ok {
        reqs = rt.Success
    } else {
        reqs = rt.Failure
    }
    
    // 4. 执行操作
    resps := make([]*pb.ResponseOp, len(reqs))
    txnCount := 0
    
    for i, req := range reqs {
        switch tv := req.Request.(type) {
        case *pb.RequestOp_RequestRange:
            resp, err := executeRange(ctx, lg, txn, tv.RequestRange)
            resps[i] = &pb.ResponseOp{
                Response: &pb.ResponseOp_ResponseRange{ResponseRange: resp},
            }
            
        case *pb.RequestOp_RequestPut:
            prevKV, _ := getPrevKV(trace, txn, tv.RequestPut)
            resp := put(ctx, txn, tv.RequestPut, prevKV)
            resps[i] = &pb.ResponseOp{
                Response: &pb.ResponseOp_ResponsePut{ResponsePut: resp},
            }
            
        case *pb.RequestOp_RequestDeleteRange:
            resp, _ := deleteRange(ctx, txn, tv.RequestDeleteRange)
            resps[i] = &pb.ResponseOp{
                Response: &pb.ResponseOp_ResponseDeleteRange{ResponseDeleteRange: resp},
            }
            
        case *pb.RequestOp_RequestTxn:
            // 嵌套事务
            resp := executeTxn(ctx, lg, txn, tv.RequestTxn, txnPath, resps[i])
            txnCount += resp.TxnCount
        }
    }
    
    // 5. 返回结果
    return &pb.TxnResponse{
        Succeeded: ok,
        Responses: resps,
    }, txnCount, nil
}

sequenceDiagram
    autonumber
    participant C as Client
    participant ES as EtcdServer
    participant MVCC as MVCC
    participant Raft as Raft

    C->>ES: Txn(TxnRequest)
    
    alt 只读事务
        ES->>ES: linearizableReadNotify()
        ES->>MVCC: Read()开启事务
        MVCC-->>ES: TxnRead
        
        loop 评估条件
            ES->>MVCC: Get(compare.key)
            MVCC-->>ES: value
            ES->>ES: applyCompare()
        end
        
        ES->>ES: 选择 Success/Failure
        
        loop 执行操作
            ES->>MVCC: Range/Get
            MVCC-->>ES: 结果
        end
        
        ES->>MVCC: End()提交事务
        ES-->>C: TxnResponse
    else 写事务
        ES->>Raft: Propose(Txn)
        Note over Raft: Raft 共识...
        Raft->>ES: Apply
        ES->>MVCC: Write()开启写事务
        Note over ES,MVCC: 执行条件判断与操作
        ES->>MVCC: End()提交事务
        ES-->>C: TxnResponse
    end