why etcdserver need not to apply type:raftpb.EntryConfChangeV2 Entry

[lastdz]

In etcdserver apply function etcdserver only apply raftpb.EntryNormal and raftpb.EntryConfChange but in raft state machine we append entry which type is EntryConfChangeV2 ,it might panic? please help me

	func (s *EtcdServer) apply(
		es []raftpb.Entry,
		confState *raftpb.ConfState,
	) (appliedt uint64, appliedi uint64, shouldStop bool) {
		s.lg.Debug("Applying entries", zap.Int("num-entries", len(es)))
		for i := range es {
			e := es[i]
			s.lg.Debug("Applying entry",
				zap.Uint64("index", e.Index),
				zap.Uint64("term", e.Term),
				zap.Stringer("type", e.Type))
			switch e.Type {
			**case raftpb.EntryNormal:**
				s.applyEntryNormal(&e)
				s.setAppliedIndex(e.Index)
				s.setTerm(e.Term)

			**case raftpb.EntryConfChange:**
				// We need to apply all WAL entries on top of v2store
				// and only 'unapplied' (e.Index>backend.ConsistentIndex) on the backend.
				shouldApplyV3 := membership.ApplyV2storeOnly

				// set the consistent index of current executing entry
				if e.Index > s.consistIndex.ConsistentIndex() {
					s.consistIndex.SetConsistentApplyingIndex(e.Index, e.Term)
					shouldApplyV3 = membership.ApplyBoth
				}

				var cc raftpb.ConfChange
				pbutil.MustUnmarshal(&cc, e.Data)
				removedSelf, err := s.applyConfChange(cc, confState, shouldApplyV3)
				s.setAppliedIndex(e.Index)
				s.setTerm(e.Term)
				shouldStop = shouldStop || removedSelf
				s.w.Trigger(cc.ID, &confChangeResponse{s.cluster.Members(), err})

			default:
				lg := s.Logger()
				lg.Panic(
					"unknown entry type; must be either EntryNormal or EntryConfChange",
					zap.String("type", e.Type.String()),
				)
			}
			appliedi, appliedt = e.Index, e.Term
		}
		return appliedt, appliedi, shouldStop
	}

---

	func (r *raft) advance(rd Ready) {
		r.reduceUncommittedSize(rd.CommittedEntries)

		// If entries were applied (or a snapshot), update our cursor for
		// the next Ready. Note that if the current HardState contains a
		// new Commit index, this does not mean that we're also applying
		// all of the new entries due to commit pagination by size.
		if newApplied := rd.appliedCursor(); newApplied > 0 {
			oldApplied := r.raftLog.applied
			r.raftLog.appliedTo(newApplied)

			if r.prs.Config.AutoLeave && oldApplied <= r.pendingConfIndex && newApplied >= r.pendingConfIndex && r.state == StateLeader {
				// If the current (and most recent, at least for this leader's term)
				// configuration should be auto-left, initiate that now. We use a
				// nil Data which unmarshals into an empty ConfChangeV2 and has the
				// benefit that appendEntry can never refuse it based on its size
				// (which registers as zero).
				ent := pb.Entry{
					Type: pb.EntryConfChangeV2,            
					Data: nil,
				}
				// There's no way in which this proposal should be able to be rejected.
				if !r.appendEntry(ent) {
					panic("refused un-refusable auto-leaving ConfChangeV2")
				}
				r.pendingConfIndex = r.raftLog.lastIndex()
				r.logger.Infof("initiating automatic transition out of joint configuration %s", r.prs.Config)
			}
		}

		if len(rd.Entries) > 0 {
			e := rd.Entries[len(rd.Entries)-1]
			r.raftLog.stableTo(e.Index, e.Term)
		}
		if !IsEmptySnap(rd.Snapshot) {
			r.raftLog.stableSnapTo(rd.Snapshot.Metadata.Index)
		}
	}