From e265ce2d52a52f7087cdbde9becd2f98062214ee Mon Sep 17 00:00:00 2001 From: Pavel Karpy Date: Fri, 20 May 2022 19:48:14 +0300 Subject: [PATCH] [#1418] meta: Do not use pointers as parameters Signed-off-by: Pavel Karpy --- pkg/local_object_storage/metabase/delete.go | 11 +- pkg/local_object_storage/metabase/exists.go | 11 +- pkg/local_object_storage/metabase/get.go | 21 +- pkg/local_object_storage/metabase/get_test.go | 6 +- .../metabase/graveyard.go | 16 +- .../metabase/graveyard_test.go | 184 +++++++++--------- pkg/local_object_storage/metabase/inhume.go | 23 +-- .../metabase/inhume_test.go | 44 +++-- .../metabase/iterators_test.go | 19 +- pkg/local_object_storage/metabase/list.go | 14 +- .../metabase/lock_test.go | 6 +- pkg/local_object_storage/metabase/movable.go | 28 +-- pkg/local_object_storage/metabase/put.go | 19 +- pkg/local_object_storage/metabase/select.go | 16 +- pkg/local_object_storage/metabase/small.go | 11 +- pkg/local_object_storage/shard/control.go | 2 +- pkg/local_object_storage/shard/gc.go | 30 +-- pkg/local_object_storage/shard/head.go | 6 +- pkg/local_object_storage/shard/inhume.go | 3 +- pkg/local_object_storage/shard/list.go | 5 +- 20 files changed, 252 insertions(+), 223 deletions(-) diff --git a/pkg/local_object_storage/metabase/delete.go b/pkg/local_object_storage/metabase/delete.go index 68bd9457b..134aaddde 100644 --- a/pkg/local_object_storage/metabase/delete.go +++ b/pkg/local_object_storage/metabase/delete.go @@ -24,17 +24,18 @@ type DeleteRes struct{} // WithAddresses is a Delete option to set the addresses of the objects to delete. // // Option is required. -func (p *DeletePrm) WithAddresses(addrs ...oid.Address) *DeletePrm { +func (p *DeletePrm) WithAddresses(addrs ...oid.Address) { if p != nil { p.addrs = addrs } - - return p } // Delete removes objects from DB. func Delete(db *DB, addrs ...oid.Address) error { - _, err := db.Delete(new(DeletePrm).WithAddresses(addrs...)) + var deletePrm DeletePrm + deletePrm.WithAddresses(addrs...) + + _, err := db.Delete(deletePrm) return err } @@ -49,7 +50,7 @@ type referenceNumber struct { type referenceCounter map[string]*referenceNumber // Delete removed object records from metabase indexes. -func (db *DB) Delete(prm *DeletePrm) (*DeleteRes, error) { +func (db *DB) Delete(prm DeletePrm) (*DeleteRes, error) { err := db.boltDB.Update(func(tx *bbolt.Tx) error { return db.deleteGroup(tx, prm.addrs) }) diff --git a/pkg/local_object_storage/metabase/exists.go b/pkg/local_object_storage/metabase/exists.go index d9840d5ea..399a1f899 100644 --- a/pkg/local_object_storage/metabase/exists.go +++ b/pkg/local_object_storage/metabase/exists.go @@ -24,12 +24,10 @@ type ExistsRes struct { var ErrLackSplitInfo = errors.New("no split info on parent object") // WithAddress is an Exists option to set object checked for existence. -func (p *ExistsPrm) WithAddress(addr oid.Address) *ExistsPrm { +func (p *ExistsPrm) WithAddress(addr oid.Address) { if p != nil { p.addr = addr } - - return p } // Exists returns the fact that the object is in the metabase. @@ -41,7 +39,10 @@ func (p *ExistsRes) Exists() bool { // // See DB.Exists docs. func Exists(db *DB, addr oid.Address) (bool, error) { - r, err := db.Exists(new(ExistsPrm).WithAddress(addr)) + var existsPrm ExistsPrm + existsPrm.WithAddress(addr) + + r, err := db.Exists(existsPrm) if err != nil { return false, err } @@ -53,7 +54,7 @@ func Exists(db *DB, addr oid.Address) (bool, error) { // returns true if addr is in primary index or false if it is not. // // Returns an error of type apistatus.ObjectAlreadyRemoved if object has been placed in graveyard. -func (db *DB) Exists(prm *ExistsPrm) (res *ExistsRes, err error) { +func (db *DB) Exists(prm ExistsPrm) (res *ExistsRes, err error) { res = new(ExistsRes) err = db.boltDB.View(func(tx *bbolt.Tx) error { diff --git a/pkg/local_object_storage/metabase/get.go b/pkg/local_object_storage/metabase/get.go index 77da0de49..6f2997f2d 100644 --- a/pkg/local_object_storage/metabase/get.go +++ b/pkg/local_object_storage/metabase/get.go @@ -24,23 +24,19 @@ type GetRes struct { // WithAddress is a Get option to set the address of the requested object. // // Option is required. -func (p *GetPrm) WithAddress(addr oid.Address) *GetPrm { +func (p *GetPrm) WithAddress(addr oid.Address) { if p != nil { p.addr = addr } - - return p } // WithRaw is a Get option to set raw flag value. If flag is unset, then Get // returns header of virtual object, otherwise it returns SplitInfo of virtual // object. -func (p *GetPrm) WithRaw(raw bool) *GetPrm { +func (p *GetPrm) WithRaw(raw bool) { if p != nil { p.raw = raw } - - return p } // Header returns the requested object header. @@ -50,7 +46,10 @@ func (r *GetRes) Header() *objectSDK.Object { // Get reads the object from DB. func Get(db *DB, addr oid.Address) (*objectSDK.Object, error) { - r, err := db.Get(new(GetPrm).WithAddress(addr)) + var getPrm GetPrm + getPrm.WithAddress(addr) + + r, err := db.Get(getPrm) if err != nil { return nil, err } @@ -60,7 +59,11 @@ func Get(db *DB, addr oid.Address) (*objectSDK.Object, error) { // GetRaw reads physically stored object from DB. func GetRaw(db *DB, addr oid.Address, raw bool) (*objectSDK.Object, error) { - r, err := db.Get(new(GetPrm).WithAddress(addr).WithRaw(raw)) + var getPrm GetPrm + getPrm.WithAddress(addr) + getPrm.WithRaw(raw) + + r, err := db.Get(getPrm) if err != nil { return nil, err } @@ -72,7 +75,7 @@ func GetRaw(db *DB, addr oid.Address, raw bool) (*objectSDK.Object, error) { // // Returns an error of type apistatus.ObjectNotFound if object is missing in DB. // Returns an error of type apistatus.ObjectAlreadyRemoved if object has been placed in graveyard. -func (db *DB) Get(prm *GetPrm) (res *GetRes, err error) { +func (db *DB) Get(prm GetPrm) (res *GetRes, err error) { res = new(GetRes) err = db.boltDB.View(func(tx *bbolt.Tx) error { diff --git a/pkg/local_object_storage/metabase/get_test.go b/pkg/local_object_storage/metabase/get_test.go index a62051c39..e9f7eca49 100644 --- a/pkg/local_object_storage/metabase/get_test.go +++ b/pkg/local_object_storage/metabase/get_test.go @@ -123,7 +123,11 @@ func TestDB_Get(t *testing.T) { require.ErrorAs(t, err, new(apistatus.ObjectAlreadyRemoved)) obj = oidtest.Address() - _, err = db.Inhume(new(meta.InhumePrm).WithAddresses(obj)) + + var prm meta.InhumePrm + prm.WithAddresses(obj) + + _, err = db.Inhume(prm) require.NoError(t, err) _, err = meta.Get(db, obj) require.ErrorAs(t, err, new(apistatus.ObjectNotFound)) diff --git a/pkg/local_object_storage/metabase/graveyard.go b/pkg/local_object_storage/metabase/graveyard.go index db7750ef4..3b96bcb5f 100644 --- a/pkg/local_object_storage/metabase/graveyard.go +++ b/pkg/local_object_storage/metabase/graveyard.go @@ -32,9 +32,8 @@ type GarbageIterationPrm struct { // SetHandler sets a handler that will be called on every // GarbageObject. -func (g *GarbageIterationPrm) SetHandler(h GarbageHandler) *GarbageIterationPrm { +func (g *GarbageIterationPrm) SetHandler(h GarbageHandler) { g.h = h - return g } // SetOffset sets an offset of the iteration operation. @@ -49,9 +48,8 @@ func (g *GarbageIterationPrm) SetHandler(h GarbageHandler) *GarbageIterationPrm // next element. // // Nil offset means start an integration from the beginning. -func (g *GarbageIterationPrm) SetOffset(offset oid.Address) *GarbageIterationPrm { +func (g *GarbageIterationPrm) SetOffset(offset oid.Address) { g.offset = &offset - return g } // IterateOverGarbage iterates over all objects @@ -59,7 +57,7 @@ func (g *GarbageIterationPrm) SetOffset(offset oid.Address) *GarbageIterationPrm // // If h returns ErrInterruptIterator, nil returns immediately. // Returns other errors of h directly. -func (db *DB) IterateOverGarbage(p *GarbageIterationPrm) error { +func (db *DB) IterateOverGarbage(p GarbageIterationPrm) error { return db.boltDB.View(func(tx *bbolt.Tx) error { return db.iterateDeletedObj(tx, gcHandler{p.h}, p.offset) }) @@ -95,9 +93,8 @@ type GraveyardIterationPrm struct { // SetHandler sets a handler that will be called on every // TombstonedObject. -func (g *GraveyardIterationPrm) SetHandler(h TombstonedHandler) *GraveyardIterationPrm { +func (g *GraveyardIterationPrm) SetHandler(h TombstonedHandler) { g.h = h - return g } // SetOffset sets an offset of the iteration operation. @@ -112,16 +109,15 @@ func (g *GraveyardIterationPrm) SetHandler(h TombstonedHandler) *GraveyardIterat // next element. // // Nil offset means start an integration from the beginning. -func (g *GraveyardIterationPrm) SetOffset(offset oid.Address) *GraveyardIterationPrm { +func (g *GraveyardIterationPrm) SetOffset(offset oid.Address) { g.offset = &offset - return g } // IterateOverGraveyard iterates over all graves in DB. // // If h returns ErrInterruptIterator, nil returns immediately. // Returns other errors of h directly. -func (db *DB) IterateOverGraveyard(p *GraveyardIterationPrm) error { +func (db *DB) IterateOverGraveyard(p GraveyardIterationPrm) error { return db.boltDB.View(func(tx *bbolt.Tx) error { return db.iterateDeletedObj(tx, graveyardHandler{p.h}, p.offset) }) diff --git a/pkg/local_object_storage/metabase/graveyard_test.go b/pkg/local_object_storage/metabase/graveyard_test.go index 6ff0e6a60..63e006577 100644 --- a/pkg/local_object_storage/metabase/graveyard_test.go +++ b/pkg/local_object_storage/metabase/graveyard_test.go @@ -14,21 +14,24 @@ func TestDB_IterateDeletedObjects_EmptyDB(t *testing.T) { db := newDB(t) var counter int - iterGravePRM := new(meta.GraveyardIterationPrm) + var iterGravePRM meta.GraveyardIterationPrm - err := db.IterateOverGraveyard(iterGravePRM.SetHandler(func(garbage meta.TombstonedObject) error { + iterGravePRM.SetHandler(func(garbage meta.TombstonedObject) error { counter++ return nil - })) + }) + + err := db.IterateOverGraveyard(iterGravePRM) require.NoError(t, err) require.Zero(t, counter) - iterGCPRM := new(meta.GarbageIterationPrm) - - err = db.IterateOverGarbage(iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { + var iterGCPRM meta.GarbageIterationPrm + iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { counter++ return nil - })) + }) + + err = db.IterateOverGarbage(iterGCPRM) require.NoError(t, err) require.Zero(t, counter) } @@ -60,29 +63,25 @@ func TestDB_Iterate_OffsetNotFound(t *testing.T) { err = putBig(db, obj1) require.NoError(t, err) - _, err = db.Inhume(new(meta.InhumePrm). - WithAddresses(object.AddressOf(obj1)). - WithGCMark(), - ) + var inhumePrm meta.InhumePrm + inhumePrm.WithAddresses(object.AddressOf(obj1)) + inhumePrm.WithGCMark() + + _, err = db.Inhume(inhumePrm) require.NoError(t, err) var counter int - iterGCPRM := new(meta.GarbageIterationPrm). - SetOffset(object.AddressOf(obj2)). - SetHandler(func(garbage meta.GarbageObject) error { - require.Equal(t, garbage.Address(), addr1) - counter++ - - return nil - }) - - err = db.IterateOverGarbage(iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { + var iterGCPRM meta.GarbageIterationPrm + iterGCPRM.SetOffset(object.AddressOf(obj2)) + iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { require.Equal(t, garbage.Address(), addr1) counter++ return nil - })) + }) + + err = db.IterateOverGarbage(iterGCPRM) require.NoError(t, err) // the second object would be put after the @@ -91,12 +90,14 @@ func TestDB_Iterate_OffsetNotFound(t *testing.T) { require.Equal(t, 0, counter) iterGCPRM.SetOffset(addr3) - err = db.IterateOverGarbage(iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { + iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { require.Equal(t, garbage.Address(), addr1) counter++ return nil - })) + }) + + err = db.IterateOverGarbage(iterGCPRM) require.NoError(t, err) // the third object would be put before the @@ -128,22 +129,22 @@ func TestDB_IterateDeletedObjects(t *testing.T) { err = putBig(db, obj4) require.NoError(t, err) - inhumePrm := new(meta.InhumePrm) + var inhumePrm meta.InhumePrm // inhume with tombstone addrTombstone := oidtest.Address() - _, err = db.Inhume(inhumePrm. - WithAddresses(object.AddressOf(obj1), object.AddressOf(obj2)). - WithTombstoneAddress(addrTombstone), - ) + inhumePrm.WithAddresses(object.AddressOf(obj1), object.AddressOf(obj2)) + inhumePrm.WithTombstoneAddress(addrTombstone) + + _, err = db.Inhume(inhumePrm) require.NoError(t, err) + inhumePrm.WithAddresses(object.AddressOf(obj3), object.AddressOf(obj4)) + inhumePrm.WithGCMark() + // inhume with GC mark - _, err = db.Inhume(inhumePrm. - WithAddresses(object.AddressOf(obj3), object.AddressOf(obj4)). - WithGCMark(), - ) + _, err = db.Inhume(inhumePrm) require.NoError(t, err) var ( @@ -151,26 +152,28 @@ func TestDB_IterateDeletedObjects(t *testing.T) { buriedTS, buriedGC []oid.Address ) - iterGravePRM := new(meta.GraveyardIterationPrm) - - err = db.IterateOverGraveyard(iterGravePRM.SetHandler(func(tomstoned meta.TombstonedObject) error { + var iterGravePRM meta.GraveyardIterationPrm + iterGravePRM.SetHandler(func(tomstoned meta.TombstonedObject) error { require.Equal(t, addrTombstone, tomstoned.Tombstone()) buriedTS = append(buriedTS, tomstoned.Address()) counterAll++ return nil - })) + }) + + err = db.IterateOverGraveyard(iterGravePRM) require.NoError(t, err) - iterGCPRM := new(meta.GarbageIterationPrm) - - err = db.IterateOverGarbage(iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { + var iterGCPRM meta.GarbageIterationPrm + iterGCPRM.SetHandler(func(garbage meta.GarbageObject) error { buriedGC = append(buriedGC, garbage.Address()) counterAll++ return nil - })) + }) + + err = db.IterateOverGarbage(iterGCPRM) require.NoError(t, err) // objects covered with a tombstone @@ -212,15 +215,16 @@ func TestDB_IterateOverGraveyard_Offset(t *testing.T) { err = putBig(db, obj4) require.NoError(t, err) - inhumePrm := new(meta.InhumePrm) - // inhume with tombstone addrTombstone := oidtest.Address() - _, err = db.Inhume(inhumePrm. - WithAddresses(object.AddressOf(obj1), object.AddressOf(obj2), object.AddressOf(obj3), object.AddressOf(obj4)). - WithTombstoneAddress(addrTombstone), - ) + var inhumePrm meta.InhumePrm + inhumePrm.WithAddresses( + object.AddressOf(obj1), object.AddressOf(obj2), + object.AddressOf(obj3), object.AddressOf(obj4)) + inhumePrm.WithTombstoneAddress(addrTombstone) + + _, err = db.Inhume(inhumePrm) require.NoError(t, err) expectedGraveyard := []oid.Address{ @@ -235,9 +239,8 @@ func TestDB_IterateOverGraveyard_Offset(t *testing.T) { gotGraveyard []oid.Address ) - iterGraveyardPrm := new(meta.GraveyardIterationPrm) - - err = db.IterateOverGraveyard(iterGraveyardPrm.SetHandler(func(tombstoned meta.TombstonedObject) error { + var iterGraveyardPrm meta.GraveyardIterationPrm + iterGraveyardPrm.SetHandler(func(tombstoned meta.TombstonedObject) error { require.Equal(t, addrTombstone, tombstoned.Tombstone()) gotGraveyard = append(gotGraveyard, tombstoned.Address()) @@ -248,7 +251,9 @@ func TestDB_IterateOverGraveyard_Offset(t *testing.T) { } return nil - })) + }) + + err = db.IterateOverGraveyard(iterGraveyardPrm) require.NoError(t, err) require.Equal(t, firstIterationSize, counter) require.Equal(t, firstIterationSize, len(gotGraveyard)) @@ -256,15 +261,16 @@ func TestDB_IterateOverGraveyard_Offset(t *testing.T) { // last received address is an offset offset := gotGraveyard[len(gotGraveyard)-1] iterGraveyardPrm.SetOffset(offset) - - err = db.IterateOverGraveyard(iterGraveyardPrm.SetHandler(func(tombstoned meta.TombstonedObject) error { + iterGraveyardPrm.SetHandler(func(tombstoned meta.TombstonedObject) error { require.Equal(t, addrTombstone, tombstoned.Tombstone()) gotGraveyard = append(gotGraveyard, tombstoned.Address()) counter++ return nil - })) + }) + + err = db.IterateOverGraveyard(iterGraveyardPrm) require.NoError(t, err) require.Equal(t, len(expectedGraveyard), counter) require.ElementsMatch(t, gotGraveyard, expectedGraveyard) @@ -273,13 +279,13 @@ func TestDB_IterateOverGraveyard_Offset(t *testing.T) { // should lead to no iteration at all offset = gotGraveyard[len(gotGraveyard)-1] iterGraveyardPrm.SetOffset(offset) - iWasCalled := false - - err = db.IterateOverGraveyard(iterGraveyardPrm.SetHandler(func(tombstoned meta.TombstonedObject) error { + iterGraveyardPrm.SetHandler(func(tombstoned meta.TombstonedObject) error { iWasCalled = true return nil - })) + }) + + err = db.IterateOverGraveyard(iterGraveyardPrm) require.NoError(t, err) require.False(t, iWasCalled) } @@ -307,12 +313,13 @@ func TestDB_IterateOverGarbage_Offset(t *testing.T) { err = putBig(db, obj4) require.NoError(t, err) - inhumePrm := new(meta.InhumePrm) + var inhumePrm meta.InhumePrm + inhumePrm.WithAddresses( + object.AddressOf(obj1), object.AddressOf(obj2), + object.AddressOf(obj3), object.AddressOf(obj4)) + inhumePrm.WithGCMark() - _, err = db.Inhume(inhumePrm. - WithAddresses(object.AddressOf(obj1), object.AddressOf(obj2), object.AddressOf(obj3), object.AddressOf(obj4)). - WithGCMark(), - ) + _, err = db.Inhume(inhumePrm) require.NoError(t, err) expectedGarbage := []oid.Address{ @@ -327,9 +334,8 @@ func TestDB_IterateOverGarbage_Offset(t *testing.T) { gotGarbage []oid.Address ) - iterGarbagePrm := new(meta.GarbageIterationPrm) - - err = db.IterateOverGarbage(iterGarbagePrm.SetHandler(func(garbage meta.GarbageObject) error { + var iterGarbagePrm meta.GarbageIterationPrm + iterGarbagePrm.SetHandler(func(garbage meta.GarbageObject) error { gotGarbage = append(gotGarbage, garbage.Address()) counter++ @@ -338,7 +344,9 @@ func TestDB_IterateOverGarbage_Offset(t *testing.T) { } return nil - })) + }) + + err = db.IterateOverGarbage(iterGarbagePrm) require.NoError(t, err) require.Equal(t, firstIterationSize, counter) require.Equal(t, firstIterationSize, len(gotGarbage)) @@ -346,13 +354,14 @@ func TestDB_IterateOverGarbage_Offset(t *testing.T) { // last received address is an offset offset := gotGarbage[len(gotGarbage)-1] iterGarbagePrm.SetOffset(offset) - - err = db.IterateOverGarbage(iterGarbagePrm.SetHandler(func(garbage meta.GarbageObject) error { + iterGarbagePrm.SetHandler(func(garbage meta.GarbageObject) error { gotGarbage = append(gotGarbage, garbage.Address()) counter++ return nil - })) + }) + + err = db.IterateOverGarbage(iterGarbagePrm) require.NoError(t, err) require.Equal(t, len(expectedGarbage), counter) require.ElementsMatch(t, gotGarbage, expectedGarbage) @@ -361,13 +370,13 @@ func TestDB_IterateOverGarbage_Offset(t *testing.T) { // should lead to no iteration at all offset = gotGarbage[len(gotGarbage)-1] iterGarbagePrm.SetOffset(offset) - iWasCalled := false - - err = db.IterateOverGarbage(iterGarbagePrm.SetHandler(func(garbage meta.GarbageObject) error { + iterGarbagePrm.SetHandler(func(garbage meta.GarbageObject) error { iWasCalled = true return nil - })) + }) + + err = db.IterateOverGarbage(iterGarbagePrm) require.NoError(t, err) require.False(t, iWasCalled) } @@ -387,27 +396,27 @@ func TestDB_DropGraves(t *testing.T) { err = putBig(db, obj2) require.NoError(t, err) - inhumePrm := new(meta.InhumePrm) - // inhume with tombstone addrTombstone := oidtest.Address() - _, err = db.Inhume(inhumePrm. - WithAddresses(object.AddressOf(obj1), object.AddressOf(obj2)). - WithTombstoneAddress(addrTombstone), - ) + var inhumePrm meta.InhumePrm + inhumePrm.WithAddresses(object.AddressOf(obj1), object.AddressOf(obj2)) + inhumePrm.WithTombstoneAddress(addrTombstone) + + _, err = db.Inhume(inhumePrm) require.NoError(t, err) buriedTS := make([]meta.TombstonedObject, 0) - iterGravePRM := new(meta.GraveyardIterationPrm) + var iterGravePRM meta.GraveyardIterationPrm var counter int - - err = db.IterateOverGraveyard(iterGravePRM.SetHandler(func(tomstoned meta.TombstonedObject) error { + iterGravePRM.SetHandler(func(tomstoned meta.TombstonedObject) error { buriedTS = append(buriedTS, tomstoned) counter++ return nil - })) + }) + + err = db.IterateOverGraveyard(iterGravePRM) require.NoError(t, err) require.Equal(t, 2, counter) @@ -415,11 +424,12 @@ func TestDB_DropGraves(t *testing.T) { require.NoError(t, err) counter = 0 - - err = db.IterateOverGraveyard(iterGravePRM.SetHandler(func(_ meta.TombstonedObject) error { + iterGravePRM.SetHandler(func(_ meta.TombstonedObject) error { counter++ return nil - })) + }) + + err = db.IterateOverGraveyard(iterGravePRM) require.NoError(t, err) require.Zero(t, counter) } diff --git a/pkg/local_object_storage/metabase/inhume.go b/pkg/local_object_storage/metabase/inhume.go index 4a9f8ee33..4fb304def 100644 --- a/pkg/local_object_storage/metabase/inhume.go +++ b/pkg/local_object_storage/metabase/inhume.go @@ -22,45 +22,40 @@ type InhumePrm struct { type InhumeRes struct{} // WithAddresses sets a list of object addresses that should be inhumed. -func (p *InhumePrm) WithAddresses(addrs ...oid.Address) *InhumePrm { +func (p *InhumePrm) WithAddresses(addrs ...oid.Address) { if p != nil { p.target = addrs } - - return p } // WithTombstoneAddress sets tombstone address as the reason for inhume operation. // // addr should not be nil. // Should not be called along with WithGCMark. -func (p *InhumePrm) WithTombstoneAddress(addr oid.Address) *InhumePrm { +func (p *InhumePrm) WithTombstoneAddress(addr oid.Address) { if p != nil { p.tomb = &addr } - - return p } // WithGCMark marks the object to be physically removed. // // Should not be called along with WithTombstoneAddress. -func (p *InhumePrm) WithGCMark() *InhumePrm { +func (p *InhumePrm) WithGCMark() { if p != nil { p.tomb = nil } - - return p } // Inhume inhumes the object by specified address. // // tomb should not be nil. func Inhume(db *DB, target, tomb oid.Address) error { - _, err := db.Inhume(new(InhumePrm). - WithAddresses(target). - WithTombstoneAddress(tomb), - ) + var inhumePrm InhumePrm + inhumePrm.WithAddresses(target) + inhumePrm.WithTombstoneAddress(tomb) + + _, err := db.Inhume(inhumePrm) return err } @@ -71,7 +66,7 @@ var errBreakBucketForEach = errors.New("bucket ForEach break") // // Allows inhuming non-locked objects only. Returns apistatus.ObjectLocked // if at least one object is locked. -func (db *DB) Inhume(prm *InhumePrm) (res *InhumeRes, err error) { +func (db *DB) Inhume(prm InhumePrm) (res *InhumeRes, err error) { err = db.boltDB.Update(func(tx *bbolt.Tx) error { garbageBKT := tx.Bucket(garbageBucketName) diff --git a/pkg/local_object_storage/metabase/inhume_test.go b/pkg/local_object_storage/metabase/inhume_test.go index 0dd0467ae..915184181 100644 --- a/pkg/local_object_storage/metabase/inhume_test.go +++ b/pkg/local_object_storage/metabase/inhume_test.go @@ -41,50 +41,56 @@ func TestInhumeTombOnTomb(t *testing.T) { addr1 = oidtest.Address() addr2 = oidtest.Address() addr3 = oidtest.Address() - inhumePrm = new(meta.InhumePrm) - existsPrm = new(meta.ExistsPrm) + inhumePrm meta.InhumePrm + existsPrm meta.ExistsPrm ) + inhumePrm.WithAddresses(addr1) + inhumePrm.WithTombstoneAddress(addr2) + // inhume addr1 via addr2 - _, err = db.Inhume(inhumePrm. - WithAddresses(addr1). - WithTombstoneAddress(addr2), - ) + _, err = db.Inhume(inhumePrm) require.NoError(t, err) + existsPrm.WithAddress(addr1) + // addr1 should become inhumed {addr1:addr2} - _, err = db.Exists(existsPrm.WithAddress(addr1)) + _, err = db.Exists(existsPrm) require.ErrorAs(t, err, new(apistatus.ObjectAlreadyRemoved)) + inhumePrm.WithAddresses(addr3) + inhumePrm.WithTombstoneAddress(addr1) + // try to inhume addr3 via addr1 - _, err = db.Inhume(inhumePrm. - WithAddresses(addr3). - WithTombstoneAddress(addr1), - ) + _, err = db.Inhume(inhumePrm) require.NoError(t, err) // record with {addr1:addr2} should be removed from graveyard // as a tomb-on-tomb; metabase should return ObjectNotFound // NOT ObjectAlreadyRemoved since that record has been removed // from graveyard but addr1 is still marked with GC - _, err = db.Exists(existsPrm.WithAddress(addr1)) + _, err = db.Exists(existsPrm) require.ErrorAs(t, err, new(apistatus.ObjectNotFound)) + existsPrm.WithAddress(addr3) + // addr3 should be inhumed {addr3: addr1} - _, err = db.Exists(existsPrm.WithAddress(addr3)) + _, err = db.Exists(existsPrm) require.ErrorAs(t, err, new(apistatus.ObjectAlreadyRemoved)) + inhumePrm.WithAddresses(addr1) + inhumePrm.WithTombstoneAddress(oidtest.Address()) + // try to inhume addr1 (which is already a tombstone in graveyard) - _, err = db.Inhume(inhumePrm. - WithAddresses(addr1). - WithTombstoneAddress(oidtest.Address()), - ) + _, err = db.Inhume(inhumePrm) require.NoError(t, err) + existsPrm.WithAddress(addr1) + // record with addr1 key should not appear in graveyard // (tomb can not be inhumed) but should be kept as object // with GC mark - _, err = db.Exists(existsPrm.WithAddress(addr1)) + _, err = db.Exists(existsPrm) require.ErrorAs(t, err, new(apistatus.ObjectNotFound)) } @@ -99,7 +105,7 @@ func TestInhumeLocked(t *testing.T) { var prm meta.InhumePrm prm.WithAddresses(locked) - _, err = db.Inhume(&prm) + _, err = db.Inhume(prm) var e apistatus.ObjectLocked require.ErrorAs(t, err, &e) diff --git a/pkg/local_object_storage/metabase/iterators_test.go b/pkg/local_object_storage/metabase/iterators_test.go index 114b3ab15..52fb17361 100644 --- a/pkg/local_object_storage/metabase/iterators_test.go +++ b/pkg/local_object_storage/metabase/iterators_test.go @@ -74,20 +74,19 @@ func TestDB_IterateCoveredByTombstones(t *testing.T) { protectedLocked := oidtest.Address() garbage := oidtest.Address() - prm := new(meta.InhumePrm) - + var prm meta.InhumePrm var err error - _, err = db.Inhume(prm. - WithTombstoneAddress(ts). - WithAddresses(protected1, protected2, protectedLocked), - ) + prm.WithAddresses(protected1, protected2, protectedLocked) + prm.WithTombstoneAddress(ts) + + _, err = db.Inhume(prm) require.NoError(t, err) - _, err = db.Inhume(prm. - WithAddresses(garbage). - WithGCMark(), - ) + prm.WithAddresses(garbage) + prm.WithGCMark() + + _, err = db.Inhume(prm) require.NoError(t, err) var handled []oid.Address diff --git a/pkg/local_object_storage/metabase/list.go b/pkg/local_object_storage/metabase/list.go index 252b4a828..e1c3ce4a6 100644 --- a/pkg/local_object_storage/metabase/list.go +++ b/pkg/local_object_storage/metabase/list.go @@ -27,17 +27,15 @@ type ListPrm struct { } // WithCount sets maximum amount of addresses that ListWithCursor should return. -func (l *ListPrm) WithCount(count uint32) *ListPrm { +func (l *ListPrm) WithCount(count uint32) { l.count = int(count) - return l } // WithCursor sets cursor for ListWithCursor operation. For initial request // ignore this param or use nil value. For consecutive requests, use value // from ListRes. -func (l *ListPrm) WithCursor(cursor *Cursor) *ListPrm { +func (l *ListPrm) WithCursor(cursor *Cursor) { l.cursor = cursor - return l } // ListRes contains values returned from ListWithCursor operation. @@ -63,7 +61,11 @@ func (l ListRes) Cursor() *Cursor { // Returns ErrEndOfListing if there are no more objects to return or count // parameter set to zero. func ListWithCursor(db *DB, count uint32, cursor *Cursor) ([]oid.Address, *Cursor, error) { - r, err := db.ListWithCursor(new(ListPrm).WithCount(count).WithCursor(cursor)) + var listPrm ListPrm + listPrm.WithCount(count) + listPrm.WithCursor(cursor) + + r, err := db.ListWithCursor(listPrm) if err != nil { return nil, nil, err } @@ -77,7 +79,7 @@ func ListWithCursor(db *DB, count uint32, cursor *Cursor) ([]oid.Address, *Curso // // Returns ErrEndOfListing if there are no more objects to return or count // parameter set to zero. -func (db *DB) ListWithCursor(prm *ListPrm) (res *ListRes, err error) { +func (db *DB) ListWithCursor(prm ListPrm) (res *ListRes, err error) { err = db.boltDB.View(func(tx *bbolt.Tx) error { res = new(ListRes) res.addrList, res.cursor, err = db.listWithCursor(tx, prm.count, prm.cursor) diff --git a/pkg/local_object_storage/metabase/lock_test.go b/pkg/local_object_storage/metabase/lock_test.go index 8f8cbbb78..9743602c0 100644 --- a/pkg/local_object_storage/metabase/lock_test.go +++ b/pkg/local_object_storage/metabase/lock_test.go @@ -78,8 +78,12 @@ func TestDB_Lock(t *testing.T) { err = meta.Inhume(db, objectcore.AddressOf(obj), tombAddr) require.ErrorAs(t, err, new(apistatus.ObjectLocked)) + var inhumePrm meta.InhumePrm + inhumePrm.WithAddresses(tombAddr) + inhumePrm.WithGCMark() + // inhume the tombstone - _, err = db.Inhume(new(meta.InhumePrm).WithAddresses(tombAddr).WithGCMark()) + _, err = db.Inhume(inhumePrm) require.NoError(t, err) // now we can inhume the object diff --git a/pkg/local_object_storage/metabase/movable.go b/pkg/local_object_storage/metabase/movable.go index 60fcfe664..f7d15473d 100644 --- a/pkg/local_object_storage/metabase/movable.go +++ b/pkg/local_object_storage/metabase/movable.go @@ -16,12 +16,10 @@ type ToMoveItPrm struct { type ToMoveItRes struct{} // WithAddress sets address of the object to move into another shard. -func (p *ToMoveItPrm) WithAddress(addr oid.Address) *ToMoveItPrm { +func (p *ToMoveItPrm) WithAddress(addr oid.Address) { if p != nil { p.addr = addr } - - return p } // DoNotMovePrm groups the parameters of DoNotMove operation. @@ -33,12 +31,10 @@ type DoNotMovePrm struct { type DoNotMoveRes struct{} // WithAddress sets address of the object to prevent moving into another shard. -func (p *DoNotMovePrm) WithAddress(addr oid.Address) *DoNotMovePrm { +func (p *DoNotMovePrm) WithAddress(addr oid.Address) { if p != nil { p.addr = addr } - - return p } // MovablePrm groups the parameters of Movable operation. @@ -50,19 +46,22 @@ type MovableRes struct { } // AddressList returns resulting addresses of Movable operation. -func (p *MovableRes) AddressList() []oid.Address { +func (p MovableRes) AddressList() []oid.Address { return p.addrList } // ToMoveIt marks object to move it into another shard. func ToMoveIt(db *DB, addr oid.Address) error { - _, err := db.ToMoveIt(new(ToMoveItPrm).WithAddress(addr)) + var toMovePrm ToMoveItPrm + toMovePrm.WithAddress(addr) + + _, err := db.ToMoveIt(toMovePrm) return err } // ToMoveIt marks objects to move it into another shard. This useful for // faster HRW fetching. -func (db *DB) ToMoveIt(prm *ToMoveItPrm) (res *ToMoveItRes, err error) { +func (db *DB) ToMoveIt(prm ToMoveItPrm) (res *ToMoveItRes, err error) { err = db.boltDB.Update(func(tx *bbolt.Tx) error { toMoveIt, err := tx.CreateBucketIfNotExists(toMoveItBucketName) if err != nil { @@ -77,12 +76,15 @@ func (db *DB) ToMoveIt(prm *ToMoveItPrm) (res *ToMoveItRes, err error) { // DoNotMove prevents the object to be moved into another shard. func DoNotMove(db *DB, addr oid.Address) error { - _, err := db.DoNotMove(new(DoNotMovePrm).WithAddress(addr)) + var doNotMovePrm DoNotMovePrm + doNotMovePrm.WithAddress(addr) + + _, err := db.DoNotMove(doNotMovePrm) return err } // DoNotMove removes `MoveIt` mark from the object. -func (db *DB) DoNotMove(prm *DoNotMovePrm) (res *DoNotMoveRes, err error) { +func (db *DB) DoNotMove(prm DoNotMovePrm) (res *DoNotMoveRes, err error) { err = db.boltDB.Update(func(tx *bbolt.Tx) error { toMoveIt := tx.Bucket(toMoveItBucketName) if toMoveIt == nil { @@ -97,7 +99,7 @@ func (db *DB) DoNotMove(prm *DoNotMovePrm) (res *DoNotMoveRes, err error) { // Movable returns all movable objects of DB. func Movable(db *DB) ([]oid.Address, error) { - r, err := db.Movable(new(MovablePrm)) + r, err := db.Movable(MovablePrm{}) if err != nil { return nil, err } @@ -106,7 +108,7 @@ func Movable(db *DB) ([]oid.Address, error) { } // Movable returns list of marked objects to move into other shard. -func (db *DB) Movable(prm *MovablePrm) (*MovableRes, error) { +func (db *DB) Movable(_ MovablePrm) (*MovableRes, error) { var strAddrs []string err := db.boltDB.View(func(tx *bbolt.Tx) error { diff --git a/pkg/local_object_storage/metabase/put.go b/pkg/local_object_storage/metabase/put.go index f2fedc838..9fd18a330 100644 --- a/pkg/local_object_storage/metabase/put.go +++ b/pkg/local_object_storage/metabase/put.go @@ -34,21 +34,17 @@ type PutPrm struct { type PutRes struct{} // WithObject is a Put option to set object to save. -func (p *PutPrm) WithObject(obj *objectSDK.Object) *PutPrm { +func (p *PutPrm) WithObject(obj *objectSDK.Object) { if p != nil { p.obj = obj } - - return p } // WithBlobovniczaID is a Put option to set blobovnicza ID to save. -func (p *PutPrm) WithBlobovniczaID(id *blobovnicza.ID) *PutPrm { +func (p *PutPrm) WithBlobovniczaID(id *blobovnicza.ID) { if p != nil { p.id = id } - - return p } var ( @@ -61,10 +57,11 @@ var ( // // See DB.Put docs. func Put(db *DB, obj *objectSDK.Object, id *blobovnicza.ID) error { - _, err := db.Put(new(PutPrm). - WithObject(obj). - WithBlobovniczaID(id), - ) + var putPrm PutPrm + putPrm.WithObject(obj) + putPrm.WithBlobovniczaID(id) + + _, err := db.Put(putPrm) return err } @@ -73,7 +70,7 @@ func Put(db *DB, obj *objectSDK.Object, id *blobovnicza.ID) error { // Big objects have nil blobovniczaID. // // Returns an error of type apistatus.ObjectAlreadyRemoved if object has been placed in graveyard. -func (db *DB) Put(prm *PutPrm) (res *PutRes, err error) { +func (db *DB) Put(prm PutPrm) (res *PutRes, err error) { err = db.boltDB.Batch(func(tx *bbolt.Tx) error { return db.put(tx, prm.obj, prm.id, nil) }) diff --git a/pkg/local_object_storage/metabase/select.go b/pkg/local_object_storage/metabase/select.go index cef43f59c..2a7206a1e 100644 --- a/pkg/local_object_storage/metabase/select.go +++ b/pkg/local_object_storage/metabase/select.go @@ -40,21 +40,17 @@ type SelectRes struct { } // WithContainerID is a Select option to set the container id to search in. -func (p *SelectPrm) WithContainerID(cnr cid.ID) *SelectPrm { +func (p *SelectPrm) WithContainerID(cnr cid.ID) { if p != nil { p.cnr = cnr } - - return p } // WithFilters is a Select option to set the object filters. -func (p *SelectPrm) WithFilters(fs object.SearchFilters) *SelectPrm { +func (p *SelectPrm) WithFilters(fs object.SearchFilters) { if p != nil { p.filters = fs } - - return p } // AddressList returns list of addresses of the selected objects. @@ -64,7 +60,11 @@ func (r *SelectRes) AddressList() []oid.Address { // Select selects the objects from DB with filtering. func Select(db *DB, cnr cid.ID, fs object.SearchFilters) ([]oid.Address, error) { - r, err := db.Select(new(SelectPrm).WithFilters(fs).WithContainerID(cnr)) + var selectPrm SelectPrm + selectPrm.WithFilters(fs) + selectPrm.WithContainerID(cnr) + + r, err := db.Select(selectPrm) if err != nil { return nil, err } @@ -73,7 +73,7 @@ func Select(db *DB, cnr cid.ID, fs object.SearchFilters) ([]oid.Address, error) } // Select returns list of addresses of objects that match search filters. -func (db *DB) Select(prm *SelectPrm) (res *SelectRes, err error) { +func (db *DB) Select(prm SelectPrm) (res *SelectRes, err error) { res = new(SelectRes) if blindlyProcess(prm.filters) { diff --git a/pkg/local_object_storage/metabase/small.go b/pkg/local_object_storage/metabase/small.go index 72986f911..2b5a3e1a0 100644 --- a/pkg/local_object_storage/metabase/small.go +++ b/pkg/local_object_storage/metabase/small.go @@ -18,12 +18,10 @@ type IsSmallRes struct { } // WithAddress is a IsSmall option to set the object address to check. -func (p *IsSmallPrm) WithAddress(addr oid.Address) *IsSmallPrm { +func (p *IsSmallPrm) WithAddress(addr oid.Address) { if p != nil { p.addr = addr } - - return p } // BlobovniczaID returns blobovnicza identifier. @@ -35,7 +33,10 @@ func (r *IsSmallRes) BlobovniczaID() *blobovnicza.ID { // address and other parameters by default. Returns only // the blobovnicza identifier. func IsSmall(db *DB, addr oid.Address) (*blobovnicza.ID, error) { - r, err := db.IsSmall(new(IsSmallPrm).WithAddress(addr)) + var isSmallPrm IsSmallPrm + isSmallPrm.WithAddress(addr) + + r, err := db.IsSmall(isSmallPrm) if err != nil { return nil, err } @@ -47,7 +48,7 @@ func IsSmall(db *DB, addr oid.Address) (*blobovnicza.ID, error) { // Small objects stored in blobovnicza instances. Big objects stored in FS by // shallow path which is calculated from address and therefore it is not // indexed in metabase. -func (db *DB) IsSmall(prm *IsSmallPrm) (res *IsSmallRes, err error) { +func (db *DB) IsSmall(prm IsSmallPrm) (res *IsSmallRes, err error) { res = new(IsSmallRes) err = db.boltDB.View(func(tx *bbolt.Tx) error { diff --git a/pkg/local_object_storage/shard/control.go b/pkg/local_object_storage/shard/control.go index 29fe80b08..87115ffa4 100644 --- a/pkg/local_object_storage/shard/control.go +++ b/pkg/local_object_storage/shard/control.go @@ -104,7 +104,7 @@ func (s *Shard) refillMetabase() error { inhumePrm.WithTombstoneAddress(tombAddr) inhumePrm.WithAddresses(tombMembers...) - _, err = s.metaBase.Inhume(&inhumePrm) + _, err = s.metaBase.Inhume(inhumePrm) if err != nil { return fmt.Errorf("could not inhume objects: %w", err) } diff --git a/pkg/local_object_storage/shard/gc.go b/pkg/local_object_storage/shard/gc.go index 9d8f79a23..bdfd6b219 100644 --- a/pkg/local_object_storage/shard/gc.go +++ b/pkg/local_object_storage/shard/gc.go @@ -185,11 +185,8 @@ func (s *Shard) removeGarbage() { buf := make([]oid.Address, 0, s.rmBatchSize) - iterPrm := new(meta.GarbageIterationPrm) - - // iterate over metabase's objects with GC mark - // (no more than s.rmBatchSize objects) - err := s.metaBase.IterateOverGarbage(iterPrm.SetHandler(func(g meta.GarbageObject) error { + var iterPrm meta.GarbageIterationPrm + iterPrm.SetHandler(func(g meta.GarbageObject) error { buf = append(buf, g.Address()) if len(buf) == s.rmBatchSize { @@ -197,7 +194,11 @@ func (s *Shard) removeGarbage() { } return nil - })) + }) + + // iterate over metabase's objects with GC mark + // (no more than s.rmBatchSize objects) + err := s.metaBase.IterateOverGarbage(iterPrm) if err != nil { s.log.Warn("iterator over metabase graveyard failed", zap.String("error", err.Error()), @@ -232,11 +233,13 @@ func (s *Shard) collectExpiredObjects(ctx context.Context, e Event) { return } + var inhumePrm meta.InhumePrm + + inhumePrm.WithAddresses(expired...) + inhumePrm.WithGCMark() + // inhume the collected objects - _, err = s.metaBase.Inhume(new(meta.InhumePrm). - WithAddresses(expired...). - WithGCMark(), - ) + _, err = s.metaBase.Inhume(inhumePrm) if err != nil { s.log.Warn("could not inhume the objects", zap.String("error", err.Error()), @@ -256,7 +259,8 @@ func (s *Shard) collectExpiredTombstones(ctx context.Context, e Event) { tss := make([]meta.TombstonedObject, 0, tssDeleteBatch) tssExp := make([]meta.TombstonedObject, 0, tssDeleteBatch) - iterPrm := new(meta.GraveyardIterationPrm).SetHandler(func(deletedObject meta.TombstonedObject) error { + var iterPrm meta.GraveyardIterationPrm + iterPrm.SetHandler(func(deletedObject meta.TombstonedObject) error { tss = append(tss, deletedObject) if len(tss) == tssDeleteBatch { @@ -348,7 +352,7 @@ func (s *Shard) HandleExpiredTombstones(tss []meta.TombstonedObject) { pInhume.WithAddresses(tsAddrs...) // inhume tombstones - _, err := s.metaBase.Inhume(&pInhume) + _, err := s.metaBase.Inhume(pInhume) if err != nil { s.log.Warn("could not mark tombstones as garbage", zap.String("error", err.Error()), @@ -381,7 +385,7 @@ func (s *Shard) HandleExpiredLocks(lockers []oid.Address) { pInhume.WithAddresses(lockers...) pInhume.WithGCMark() - _, err = s.metaBase.Inhume(&pInhume) + _, err = s.metaBase.Inhume(pInhume) if err != nil { s.log.Warn("failure to mark lockers as garbage", zap.String("error", err.Error()), diff --git a/pkg/local_object_storage/shard/head.go b/pkg/local_object_storage/shard/head.go index 8d5f7b802..a84884efa 100644 --- a/pkg/local_object_storage/shard/head.go +++ b/pkg/local_object_storage/shard/head.go @@ -71,9 +71,9 @@ func (s *Shard) Head(prm *HeadPrm) (*HeadRes, error) { // otherwise object seems to be flushed to metabase } - headParams := new(meta.GetPrm). - WithAddress(prm.addr). - WithRaw(prm.raw) + var headParams meta.GetPrm + headParams.WithAddress(prm.addr) + headParams.WithRaw(prm.raw) res, err := s.metaBase.Get(headParams) if err != nil { diff --git a/pkg/local_object_storage/shard/inhume.go b/pkg/local_object_storage/shard/inhume.go index 3de993c00..e16ac8561 100644 --- a/pkg/local_object_storage/shard/inhume.go +++ b/pkg/local_object_storage/shard/inhume.go @@ -61,7 +61,8 @@ func (s *Shard) Inhume(prm *InhumePrm) (*InhumeRes, error) { } } - metaPrm := new(meta.InhumePrm).WithAddresses(prm.target...) + var metaPrm meta.InhumePrm + metaPrm.WithAddresses(prm.target...) if prm.tombstone != nil { metaPrm.WithTombstoneAddress(*prm.tombstone) diff --git a/pkg/local_object_storage/shard/list.go b/pkg/local_object_storage/shard/list.go index d4c3628e8..c0b85945b 100644 --- a/pkg/local_object_storage/shard/list.go +++ b/pkg/local_object_storage/shard/list.go @@ -118,7 +118,10 @@ func ListContainers(s *Shard) ([]cid.ID, error) { // Returns ErrEndOfListing if there are no more objects to return or count // parameter set to zero. func (s *Shard) ListWithCursor(prm *ListWithCursorPrm) (*ListWithCursorRes, error) { - metaPrm := new(meta.ListPrm).WithCount(prm.count).WithCursor(prm.cursor) + var metaPrm meta.ListPrm + metaPrm.WithCount(prm.count) + metaPrm.WithCursor(prm.cursor) + res, err := s.metaBase.ListWithCursor(metaPrm) if err != nil { return nil, fmt.Errorf("could not get list of objects: %w", err)