Mirroristas/etcd
2
0
Fork 0
mirror of https://github.com/etcd-io/etcd.git synced 2024-09-27 06:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #13886 from serathius/backend-logger

Browse Source 
tests: Pass logger to backend
This commit is contained in:
Marek Siarkowicz 2022-04-05 16:35:07 +02:00 committed by GitHub
commit ad03f2076a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 88 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
etcdutl/etcdutl/backup_command.go
View File

@ -308,7 +308,7 @@ func saveDB(lg *zap.Logger, destDB, srcDB string, idx uint64, term uint64, desir
}
}
be := backend.NewDefaultBackend(destDB)
be := backend.NewDefaultBackend(lg, destDB)
defer be.Close()
ms := schema.NewMembershipBackend(lg, be)
if err := ms.TrimClusterFromBackend(); err != nil {

2
etcdutl/etcdutl/defrag_command.go
View File

@ -57,7 +57,7 @@ func DefragData(dataDir string) error {
dbDir := datadir.ToBackendFileName(dataDir)
go func() {
defer close(bch)
cfg := backend.DefaultBackendConfig()
cfg := backend.DefaultBackendConfig(lg)
cfg.Logger = lg
cfg.Path = dbDir
be = backend.New(cfg)

19
etcdutl/etcdutl/migrate_command.go
View File

@ -75,6 +75,7 @@ func (o *migrateOptions) AddFlags(cmd *cobra.Command) {
func (o *migrateOptions) Config() (*migrateConfig, error) {
c := &migrateConfig{
force: o.force,
lg: GetLogger(),
}
var err error
dotCount := strings.Count(o.targetVersion, ".")
@ -90,10 +91,10 @@ func (o *migrateOptions) Config() (*migrateConfig, error) {
}
dbPath := datadir.ToBackendFileName(o.dataDir)
c.be = backend.NewDefaultBackend(dbPath)
c.be = backend.NewDefaultBackend(GetLogger(), dbPath)
walPath := datadir.ToWalDir(o.dataDir)
w, err := wal.OpenForRead(GetLogger(), walPath, walpb.Snapshot{})
w, err := wal.OpenForRead(c.lg, walPath, walpb.Snapshot{})
if err != nil {
return nil, fmt.Errorf(`failed to open wal: %v`, err)
}
@ -107,6 +108,7 @@ func (o *migrateOptions) Config() (*migrateConfig, error) {
}
type migrateConfig struct {
lg *zap.Logger
be backend.Backend
targetVersion *semver.Version
walVersion schema.WALVersion
@ -115,24 +117,23 @@ type migrateConfig struct {
func migrateCommandFunc(c *migrateConfig) error {
defer c.be.Close()
lg := GetLogger()
tx := c.be.BatchTx()
current, err := schema.DetectSchemaVersion(lg, tx)
current, err := schema.DetectSchemaVersion(c.lg, tx)
if err != nil {
lg.Error("failed to detect storage version. Please make sure you are using data dir from etcd v3.5 and older")
c.lg.Error("failed to detect storage version. Please make sure you are using data dir from etcd v3.5 and older")
return err
}
if current == *c.targetVersion {
lg.Info("storage version up-to-date", zap.String("storage-version", storageVersionToString(&current)))
c.lg.Info("storage version up-to-date", zap.String("storage-version", storageVersionToString(&current)))
return nil
}
err = schema.Migrate(lg, tx, c.walVersion, *c.targetVersion)
err = schema.Migrate(c.lg, tx, c.walVersion, *c.targetVersion)
if err != nil {
if !c.force {
return err
}
lg.Info("normal migrate failed, trying with force", zap.Error(err))
migrateForce(lg, tx, c.targetVersion)
c.lg.Info("normal migrate failed, trying with force", zap.Error(err))
migrateForce(c.lg, tx, c.targetVersion)
}
c.be.ForceCommit()
return nil

6
etcdutl/snapshot/v3_snapshot.go
View File

@ -299,7 +299,7 @@ func (s *v3Manager) saveDB() error {
return err
}
be := backend.NewDefaultBackend(s.outDbPath())
be := backend.NewDefaultBackend(s.lg, s.outDbPath())
defer be.Close()
err = schema.NewMembershipBackend(s.lg, be).TrimMembershipFromBackend()
@ -397,7 +397,7 @@ func (s *v3Manager) saveWALAndSnap() (*raftpb.HardState, error) {
// add members again to persist them to the store we create.
st := v2store.New(etcdserver.StoreClusterPrefix, etcdserver.StoreKeysPrefix)
s.cl.SetStore(st)
be := backend.NewDefaultBackend(s.outDbPath())
be := backend.NewDefaultBackend(s.lg, s.outDbPath())
defer be.Close()
s.cl.SetBackend(schema.NewMembershipBackend(s.lg, be))
for _, m := range s.cl.Members() {
@ -480,7 +480,7 @@ func (s *v3Manager) saveWALAndSnap() (*raftpb.HardState, error) {
}
func (s *v3Manager) updateCIndex(commit uint64, term uint64) error {
be := backend.NewDefaultBackend(s.outDbPath())
be := backend.NewDefaultBackend(s.lg, s.outDbPath())
defer be.Close()
cindex.UpdateConsistentIndex(be.BatchTx(), commit, term, false)

3
server/etcdserver/cindex/cindex_test.go
View File

@ -23,6 +23,7 @@ import (
"go.etcd.io/etcd/server/v3/storage/backend"
betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
"go.etcd.io/etcd/server/v3/storage/schema"
"go.uber.org/zap/zaptest"
)
// TestConsistentIndex ensures that LoadConsistentIndex/Save/ConsistentIndex and backend.BatchTx can work well together.
@ -53,7 +54,7 @@ func TestConsistentIndex(t *testing.T) {
be.ForceCommit()
be.Close()
b := backend.NewDefaultBackend(tmpPath)
b := backend.NewDefaultBackend(zaptest.NewLogger(t), tmpPath)
defer b.Close()
ci.SetBackend(b)
index = ci.ConsistentIndex()

6
server/lease/lessor_test.go
View File

@ -31,6 +31,7 @@ import (
"go.etcd.io/etcd/server/v3/storage/backend"
"go.etcd.io/etcd/server/v3/storage/schema"
"go.uber.org/zap"
"go.uber.org/zap/zaptest"
)
const (
@ -310,7 +311,7 @@ func TestLessorRenewExtendPileup(t *testing.T) {
// simulate stop and recovery
le.Stop()
be.Close()
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(lg)
bcfg.Path = filepath.Join(dir, "be")
be = backend.New(bcfg)
defer be.Close()
@ -669,8 +670,9 @@ func (fd *fakeDeleter) DeleteRange(key, end []byte) (int64, int64) {
}
func NewTestBackend(t *testing.T) (string, backend.Backend) {
lg := zaptest.NewLogger(t)
tmpPath := t.TempDir()
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(lg)
bcfg.Path = filepath.Join(tmpPath, "be")
return tmpPath, backend.New(bcfg)
}

2
server/storage/backend.go
View File

@ -29,7 +29,7 @@ import (
)
func newBackend(cfg config.ServerConfig, hooks backend.Hooks) backend.Backend {
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(cfg.Logger)
bcfg.Path = cfg.BackendPath()
bcfg.UnsafeNoFsync = cfg.UnsafeNoFsync
if cfg.BackendBatchLimit != 0 {

11
server/storage/backend/backend.go
View File

@ -144,11 +144,12 @@ type BackendConfig struct {
Hooks Hooks
}
func DefaultBackendConfig() BackendConfig {
func DefaultBackendConfig(lg *zap.Logger) BackendConfig {
return BackendConfig{
BatchInterval: defaultBatchInterval,
BatchLimit: defaultBatchLimit,
MmapSize: initialMmapSize,
Logger: lg,
}
}
@ -156,17 +157,13 @@ func New(bcfg BackendConfig) Backend {
return newBackend(bcfg)
}
func NewDefaultBackend(path string) Backend {
bcfg := DefaultBackendConfig()
func NewDefaultBackend(lg *zap.Logger, path string) Backend {
bcfg := DefaultBackendConfig(lg)
bcfg.Path = path
return newBackend(bcfg)
}
func newBackend(bcfg BackendConfig) *backend {
if bcfg.Logger == nil {
bcfg.Logger = zap.NewNop()
}
bopts := &bolt.Options{}
if boltOpenOptions != nil {
*bopts = *boltOpenOptions

5
server/storage/backend/backend_test.go
View File

@ -26,6 +26,7 @@ import (
"go.etcd.io/etcd/server/v3/storage/backend"
betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
"go.etcd.io/etcd/server/v3/storage/schema"
"go.uber.org/zap/zaptest"
)
func TestBackendClose(t *testing.T) {
@ -71,7 +72,7 @@ func TestBackendSnapshot(t *testing.T) {
assert.NoError(t, f.Close())
// bootstrap new backend from the snapshot
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
bcfg.Path, bcfg.BatchInterval, bcfg.BatchLimit = f.Name(), time.Hour, 10000
nb := backend.New(bcfg)
defer betesting.Close(t, nb)
@ -122,7 +123,7 @@ func TestBackendBatchIntervalCommit(t *testing.T) {
}
func TestBackendDefrag(t *testing.T) {
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
// Make sure we change BackendFreelistType
// The goal is to verify that we restore config option after defrag.
if bcfg.BackendFreelistType == bolt.FreelistMapType {

7
server/storage/backend/hooks_test.go
View File

@ -23,6 +23,7 @@ import (
"go.etcd.io/etcd/server/v3/storage/backend"
betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
"go.etcd.io/etcd/server/v3/storage/schema"
"go.uber.org/zap/zaptest"
)
var (
@ -31,7 +32,7 @@ var (
)
func TestBackendPreCommitHook(t *testing.T) {
be := newTestHooksBackend(t, backend.DefaultBackendConfig())
be := newTestHooksBackend(t, backend.DefaultBackendConfig(zaptest.NewLogger(t)))
tx := be.BatchTx()
prepareBuckenAndKey(tx)
@ -48,7 +49,7 @@ func TestBackendPreCommitHook(t *testing.T) {
}
func TestBackendAutoCommitLimitHook(t *testing.T) {
cfg := backend.DefaultBackendConfig()
cfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
cfg.BatchLimit = 3
be := newTestHooksBackend(t, cfg)
@ -72,7 +73,7 @@ func TestBackendAutoCommitBatchIntervalHook(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
defer cancel()
cfg := backend.DefaultBackendConfig()
cfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
cfg.BatchInterval = 10 * time.Millisecond
be := newTestHooksBackend(t, cfg)
tx := be.BatchTx()

4
server/storage/backend/testing/betesting.go
View File

@ -38,13 +38,13 @@ func NewTmpBackendFromCfg(t testing.TB, bcfg backend.BackendConfig) (backend.Bac
// NewTmpBackend creates a backend implementation for testing.
func NewTmpBackend(t testing.TB, batchInterval time.Duration, batchLimit int) (backend.Backend, string) {
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(zaptest.NewLogger(t))
bcfg.BatchInterval, bcfg.BatchLimit = batchInterval, batchLimit
return NewTmpBackendFromCfg(t, bcfg)
}
func NewDefaultTmpBackend(t testing.TB) (backend.Backend, string) {
return NewTmpBackendFromCfg(t, backend.DefaultBackendConfig())
return NewTmpBackendFromCfg(t, backend.DefaultBackendConfig(zaptest.NewLogger(t)))
}
func Close(t testing.TB, b backend.Backend) {

7
server/storage/mvcc/store_test.go
View File

@ -7,6 +7,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
"go.uber.org/zap/zaptest"
"go.etcd.io/etcd/server/v3/storage/backend"
betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
@ -33,6 +34,7 @@ func TestScheduledCompact(t *testing.T) {
}
for _, tc := range tcs {
t.Run(fmt.Sprint(tc.value), func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
tx := be.BatchTx()
if tx == nil {
@ -45,7 +47,7 @@ func TestScheduledCompact(t *testing.T) {
be.ForceCommit()
be.Close()
b := backend.NewDefaultBackend(tmpPath)
b := backend.NewDefaultBackend(lg, tmpPath)
defer b.Close()
v, found := UnsafeReadScheduledCompact(b.BatchTx())
assert.Equal(t, true, found)
@ -74,6 +76,7 @@ func TestFinishedCompact(t *testing.T) {
}
for _, tc := range tcs {
t.Run(fmt.Sprint(tc.value), func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
tx := be.BatchTx()
if tx == nil {
@ -86,7 +89,7 @@ func TestFinishedCompact(t *testing.T) {
be.ForceCommit()
be.Close()
b := backend.NewDefaultBackend(tmpPath)
b := backend.NewDefaultBackend(lg, tmpPath)
defer b.Close()
v, found := UnsafeReadFinishedCompact(b.BatchTx())
assert.Equal(t, true, found)

14
server/storage/schema/auth_roles_test.go
View File

@ -109,8 +109,9 @@ func TestGetAllRoles(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
abe := NewAuthBackend(zaptest.NewLogger(t), be)
abe := NewAuthBackend(lg, be)
abe.CreateAuthBuckets()
tx := abe.BatchTx()
@ -121,9 +122,9 @@ func TestGetAllRoles(t *testing.T) {
abe.ForceCommit()
be.Close()
be2 := backend.NewDefaultBackend(tmpPath)
be2 := backend.NewDefaultBackend(lg, tmpPath)
defer be2.Close()
abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
abe2 := NewAuthBackend(lg, be2)
users := abe2.GetAllRoles()
assert.Equal(t, tc.want, users)
@ -205,8 +206,9 @@ func TestGetRole(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
abe := NewAuthBackend(zaptest.NewLogger(t), be)
abe := NewAuthBackend(lg, be)
abe.CreateAuthBuckets()
tx := abe.BatchTx()
@ -217,9 +219,9 @@ func TestGetRole(t *testing.T) {
abe.ForceCommit()
be.Close()
be2 := backend.NewDefaultBackend(tmpPath)
be2 := backend.NewDefaultBackend(lg, tmpPath)
defer be2.Close()
abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
abe2 := NewAuthBackend(lg, be2)
users := abe2.GetRole("role1")
assert.Equal(t, tc.want, users)

14
server/storage/schema/auth_test.go
View File

@ -52,8 +52,9 @@ func TestAuthEnabled(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
abe := NewAuthBackend(zaptest.NewLogger(t), be)
abe := NewAuthBackend(lg, be)
tx := abe.BatchTx()
abe.CreateAuthBuckets()
@ -65,9 +66,9 @@ func TestAuthEnabled(t *testing.T) {
abe.ForceCommit()
be.Close()
be2 := backend.NewDefaultBackend(tmpPath)
be2 := backend.NewDefaultBackend(lg, tmpPath)
defer be2.Close()
abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
abe2 := NewAuthBackend(lg, be2)
tx = abe2.BatchTx()
tx.Lock()
defer tx.Unlock()
@ -102,8 +103,9 @@ func TestAuthRevision(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
abe := NewAuthBackend(zaptest.NewLogger(t), be)
abe := NewAuthBackend(lg, be)
abe.CreateAuthBuckets()
if tc.setRevision != 0 {
@ -115,9 +117,9 @@ func TestAuthRevision(t *testing.T) {
abe.ForceCommit()
be.Close()
be2 := backend.NewDefaultBackend(tmpPath)
be2 := backend.NewDefaultBackend(lg, tmpPath)
defer be2.Close()
abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
abe2 := NewAuthBackend(lg, be2)
tx := abe2.BatchTx()
tx.Lock()
defer tx.Unlock()

14
server/storage/schema/auth_users_test.go
View File

@ -97,8 +97,9 @@ func TestGetAllUsers(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
abe := NewAuthBackend(zaptest.NewLogger(t), be)
abe := NewAuthBackend(lg, be)
abe.CreateAuthBuckets()
tx := abe.BatchTx()
@ -109,9 +110,9 @@ func TestGetAllUsers(t *testing.T) {
abe.ForceCommit()
be.Close()
be2 := backend.NewDefaultBackend(tmpPath)
be2 := backend.NewDefaultBackend(lg, tmpPath)
defer be2.Close()
abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
abe2 := NewAuthBackend(lg, be2)
users := abe2.GetAllUsers()
assert.Equal(t, tc.want, users)
@ -181,8 +182,9 @@ func TestGetUser(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
abe := NewAuthBackend(zaptest.NewLogger(t), be)
abe := NewAuthBackend(lg, be)
abe.CreateAuthBuckets()
tx := abe.BatchTx()
@ -193,9 +195,9 @@ func TestGetUser(t *testing.T) {
abe.ForceCommit()
be.Close()
be2 := backend.NewDefaultBackend(tmpPath)
be2 := backend.NewDefaultBackend(lg, tmpPath)
defer be2.Close()
abe2 := NewAuthBackend(zaptest.NewLogger(t), be2)
abe2 := NewAuthBackend(lg, be2)
users := abe2.GetUser("alice")
assert.Equal(t, tc.want, users)

4
server/storage/schema/lease_test.go
View File

@ -23,6 +23,7 @@ import (
"go.etcd.io/etcd/server/v3/lease/leasepb"
"go.etcd.io/etcd/server/v3/storage/backend"
betesting "go.etcd.io/etcd/server/v3/storage/backend/testing"
"go.uber.org/zap/zaptest"
)
func TestLeaseBackend(t *testing.T) {
@ -86,6 +87,7 @@ func TestLeaseBackend(t *testing.T) {
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
tx := be.BatchTx()
tx.Lock()
@ -96,7 +98,7 @@ func TestLeaseBackend(t *testing.T) {
be.ForceCommit()
be.Close()
be2 := backend.NewDefaultBackend(tmpPath)
be2 := backend.NewDefaultBackend(lg, tmpPath)
defer be2.Close()
leases := MustUnsafeGetAllLeases(be2.ReadTx())

6
server/storage/schema/schema_test.go
View File

@ -86,7 +86,7 @@ func TestValidate(t *testing.T) {
lg := zap.NewNop()
dataPath := setupBackendData(t, tc.version, tc.overrideKeys)
b := backend.NewDefaultBackend(dataPath)
b := backend.NewDefaultBackend(lg, dataPath)
defer b.Close()
err := Validate(lg, b.BatchTx())
if (err != nil) != tc.expectError {
@ -214,7 +214,7 @@ func TestMigrate(t *testing.T) {
t.Fatal(err)
}
b := backend.NewDefaultBackend(dataPath)
b := backend.NewDefaultBackend(lg, dataPath)
defer b.Close()
err = Migrate(lg, b.BatchTx(), walVersion, tc.targetVersion)
@ -258,7 +258,7 @@ func TestMigrateIsReversible(t *testing.T) {
lg := zap.NewNop()
dataPath := setupBackendData(t, tc.initialVersion, nil)
be := backend.NewDefaultBackend(dataPath)
be := backend.NewDefaultBackend(lg, dataPath)
defer be.Close()
tx := be.BatchTx()
tx.Lock()

4
server/storage/schema/version_test.go
View File

@ -21,6 +21,7 @@ import (
"github.com/coreos/go-semver/semver"
"github.com/stretchr/testify/assert"
"go.etcd.io/bbolt"
"go.uber.org/zap/zaptest"
"go.etcd.io/etcd/server/v3/storage/backend"
"go.etcd.io/etcd/server/v3/storage/backend/testing"
@ -55,6 +56,7 @@ func TestVersion(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.version, func(t *testing.T) {
lg := zaptest.NewLogger(t)
be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10)
tx := be.BatchTx()
if tx == nil {
@ -67,7 +69,7 @@ func TestVersion(t *testing.T) {
be.ForceCommit()
be.Close()
b := backend.NewDefaultBackend(tmpPath)
b := backend.NewDefaultBackend(lg, tmpPath)
defer b.Close()
v := UnsafeReadStorageVersion(b.BatchTx())

2
server/verify/verify.go
View File

@ -69,7 +69,7 @@ func Verify(cfg Config) error {
}
}()
beConfig := backend.DefaultBackendConfig()
beConfig := backend.DefaultBackendConfig(lg)
beConfig.Path = datadir.ToBackendFileName(cfg.DataDir)
beConfig.Logger = cfg.Logger

4
tests/e2e/utl_migrate_test.go
View File

@ -26,6 +26,7 @@ import (
"go.etcd.io/etcd/server/v3/storage/backend"
"go.etcd.io/etcd/server/v3/storage/schema"
"go.etcd.io/etcd/tests/v3/framework/e2e"
"go.uber.org/zap/zaptest"
)
func TestEtctlutlMigrate(t *testing.T) {
@ -105,6 +106,7 @@ func TestEtctlutlMigrate(t *testing.T) {
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
e2e.BeforeTest(t)
lg := zaptest.NewLogger(t)
if tc.binary != "" && !fileutil.Exist(tc.binary) {
t.Skipf("%q does not exist", lastReleaseBinary)
}
@ -154,7 +156,7 @@ func TestEtctlutlMigrate(t *testing.T) {
}
t.Log("etcdutl migrate...")
be := backend.NewDefaultBackend(dataDirPath + "/member/snap/db")
be := backend.NewDefaultBackend(lg, dataDirPath+"/member/snap/db")
defer be.Close()
ver := schema.ReadStorageVersion(be.ReadTx())

5
tests/integration/clientv3/maintenance_test.go
View File

@ -190,6 +190,7 @@ func TestMaintenanceSnapshotErrorInflight(t *testing.T) {
// will fail to read with corresponding context errors on inflight context cancel timeout.
func testMaintenanceSnapshotErrorInflight(t *testing.T, snapshot func(context.Context, *clientv3.Client) (io.ReadCloser, error)) {
integration2.BeforeTest(t)
lg := zaptest.NewLogger(t)
clus := integration2.NewCluster(t, &integration2.ClusterConfig{Size: 1, UseBridge: true})
defer clus.Terminate(t)
@ -197,8 +198,8 @@ func testMaintenanceSnapshotErrorInflight(t *testing.T, snapshot func(context.Co
// take about 1-second to read snapshot
clus.Members[0].Stop(t)
dpath := filepath.Join(clus.Members[0].DataDir, "member", "snap", "db")
b := backend.NewDefaultBackend(dpath)
s := mvcc.NewStore(zaptest.NewLogger(t), b, &lease.FakeLessor{}, mvcc.StoreConfig{CompactionBatchLimit: math.MaxInt32})
b := backend.NewDefaultBackend(lg, dpath)
s := mvcc.NewStore(lg, b, &lease.FakeLessor{}, mvcc.StoreConfig{CompactionBatchLimit: math.MaxInt32})
rev := 100000
for i := 2; i <= rev; i++ {
s.Put([]byte(fmt.Sprintf("%10d", i)), bytes.Repeat([]byte("a"), 1024), lease.NoLease)

9
tests/integration/v3_alarm_test.go
View File

@ -174,6 +174,7 @@ func TestV3AlarmDeactivate(t *testing.T) {
func TestV3CorruptAlarm(t *testing.T) {
integration.BeforeTest(t)
lg := zaptest.NewLogger(t)
clus := integration.NewCluster(t, &integration.ClusterConfig{Size: 3, UseBridge: true})
defer clus.Terminate(t)
@ -192,8 +193,8 @@ func TestV3CorruptAlarm(t *testing.T) {
// Corrupt member 0 by modifying backend offline.
clus.Members[0].Stop(t)
fp := filepath.Join(clus.Members[0].DataDir, "member", "snap", "db")
be := backend.NewDefaultBackend(fp)
s := mvcc.NewStore(zaptest.NewLogger(t), be, nil, mvcc.StoreConfig{})
be := backend.NewDefaultBackend(lg, fp)
s := mvcc.NewStore(lg, be, nil, mvcc.StoreConfig{})
// NOTE: cluster_proxy mode with namespacing won't set 'k', but namespace/'k'.
s.Put([]byte("abc"), []byte("def"), 0)
s.Put([]byte("xyz"), []byte("123"), 0)
@ -258,6 +259,7 @@ func TestV3CorruptAlarm(t *testing.T) {
func TestV3CorruptAlarmWithLeaseCorrupted(t *testing.T) {
integration.BeforeTest(t)
lg := zaptest.NewLogger(t)
clus := integration.NewCluster(t, &integration.ClusterConfig{
CorruptCheckTime: time.Second,
Size: 3,
@ -299,9 +301,8 @@ func TestV3CorruptAlarmWithLeaseCorrupted(t *testing.T) {
// Corrupt member 2 by modifying backend lease bucket offline.
clus.Members[2].Stop(t)
fp := filepath.Join(clus.Members[2].DataDir, "member", "snap", "db")
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(lg)
bcfg.Path = fp
bcfg.Logger = zaptest.NewLogger(t)
be := backend.New(bcfg)
olpb := leasepb.Lease{ID: int64(1), TTL: 60}

2
tools/benchmark/cmd/mvcc.go
View File

@ -35,7 +35,7 @@ var (
)
func initMVCC() {
bcfg := backend.DefaultBackendConfig()
bcfg := backend.DefaultBackendConfig(zap.NewNop())
bcfg.Path, bcfg.BatchInterval, bcfg.BatchLimit = "mvcc-bench", time.Duration(batchInterval)*time.Millisecond, batchLimit
be := backend.New(bcfg)
s = mvcc.NewStore(zap.NewExample(), be, &lease.FakeLessor{}, mvcc.StoreConfig{})

3
tools/etcd-dump-db/backend.go
View File

@ -21,6 +21,7 @@ import (
"go.etcd.io/etcd/api/v3/authpb"
"go.etcd.io/etcd/server/v3/storage/schema"
"go.uber.org/zap"
"go.etcd.io/etcd/api/v3/mvccpb"
"go.etcd.io/etcd/server/v3/lease/leasepb"
@ -176,7 +177,7 @@ func iterateBucket(dbPath, bucket string, limit uint64, decode bool) (err error)
}
func getHash(dbPath string) (hash uint32, err error) {
b := backend.NewDefaultBackend(dbPath)
b := backend.NewDefaultBackend(zap.NewNop(), dbPath)
return b.Hash(schema.DefaultIgnores)
}