golang源码分析：etcd(14)

func newBackend(cfg config.ServerConfig, hooks backend.Hooks) backend.Backend {
      bcfg := backend.DefaultBackendConfig(cfg.Logger)
      bcfg.Hooks = hooks
      return backend.New(bcfg)

func OpenSnapshotBackend(cfg config.ServerConfig, ss *snap.Snapshotter, snapshot raftpb.Snapshot, hooks *BackendHooks) (backend.Backend, error) {
      snapPath, err := ss.DBFilePath(snapshot.Metadata.Index)
      return OpenBackend(cfg, hooks), nil

func OpenBackend(cfg config.ServerConfig, hooks backend.Hooks) backend.Backend {
        go func() {
    beOpened <- newBackend(cfg, hooks)
  }()

func RecoverSnapshotBackend(cfg config.ServerConfig, oldbe backend.Backend, snapshot raftpb.Snapshot, beExist bool, hooks *BackendHooks) (backend.Backend, error) {
      consistentIndex, _ = schema.ReadConsistentIndex(oldbe.ReadTx())
      return OpenSnapshotBackend(cfg, snap.New(cfg.Logger, cfg.SnapDir()), snapshot, hooks)

type BackendHooks struct {
  indexer cindex.ConsistentIndexer
  lg      *zap.Logger


  // confState to Be written in the next submitted Backend transaction (if dirty)
  confState raftpb.ConfState
  // first write changes it to 'dirty'. false by default, so
  // not initialized `confState` is meaningless.
  confStateDirty bool
  confStateLock  sync.Mutex
}

func NewBackendHooks(lg *zap.Logger, indexer cindex.ConsistentIndexer) *BackendHooks {
  return &BackendHooks{lg: lg, indexer: indexer}
}

func (bh *BackendHooks) OnPreCommitUnsafe(tx backend.BatchTx) {
      schema.MustUnsafeSaveConfStateToBackend(bh.lg, tx, &bh.confState)

func (bh *BackendHooks) SetConfState(confState *raftpb.ConfState) {

prometheus.MustRegister(quotaBackendBytes)

type Quota interface {
  // Available judges whether the given request fits within the quota.
  Available(req interface{}) bool
  // Cost computes the charge against the quota for a given request.
  Cost(req interface{}) int
  // Remaining is the amount of charge left for the quota.
  Remaining() int64
}

type passthroughQuota struct{}

func (*passthroughQuota) Available(interface{}) bool { return true }

type BackendQuota struct {
  be              backend.Backend
  maxBackendBytes int64
}

func NewBackendQuota(lg *zap.Logger, quotaBackendBytesCfg int64, be backend.Backend, name string) Quota {
      return &BackendQuota{be, quotaBackendBytesCfg}

func (b *BackendQuota) Available(v interface{}) bool {
      return b.be.Size()+int64(cost) < b.maxBackendBytes

type Storage interface {
  // Save function saves ents and state to the underlying stable storage.
  // Save MUST block until st and ents are on stable storage.
  Save(st raftpb.HardState, ents []raftpb.Entry) error
  // SaveSnap function saves snapshot to the underlying stable storage.
  SaveSnap(snap raftpb.Snapshot) error
  // Close closes the Storage and performs finalization.
  Close() error
  // Release releases the locked wal files older than the provided snapshot.
  Release(snap raftpb.Snapshot) error
  // Sync WAL
  Sync() error
  // MinimalEtcdVersion returns minimal etcd storage able to interpret WAL log.
  MinimalEtcdVersion() *semver.Version
}

type storage struct {
  lg *zap.Logger
  s  *snap.Snapshotter


  // Mutex protected variables
  mux sync.RWMutex
  w   *wal.WAL
}

func NewStorage(lg *zap.Logger, w *wal.WAL, s *snap.Snapshotter) Storage {
  return &storage{lg: lg, w: w, s: s}
}

func (st *storage) SaveSnap(snap raftpb.Snapshot) error {
      walsnap := walpb.Snapshot{
      err := st.s.SaveSnap(snap)
      return st.w.SaveSnapshot(walsnap)

func (st *storage) Release(snap raftpb.Snapshot) error {
      if err := st.w.ReleaseLockTo(snap.Metadata.Index); err != nil {
      return st.s.ReleaseSnapDBs(snap)

func (st *storage) Save(s raftpb.HardState, ents []raftpb.Entry) error {
      return st.w.Save(s, ents)

func CreateConfigChangeEnts(lg *zap.Logger, ids []uint64, self uint64, term, index uint64) []raftpb.Entry {

func GetEffectiveNodeIDsFromWalEntries(lg *zap.Logger, snap *raftpb.Snapshot, ents []raftpb.Entry) []uint64 {