Skip to content

M
mybee
Commit c3c87289 authored by Peter Mrekaj's avatar Peter Mrekaj Committed by GitHub
Browse files
Options

feat(localstore): add migration for batch-index (#2112)

parent 2c84af85
Hide whitespace changes
Inline Side-by-side
Showing with 589 additions and 337 deletions
cmd/bee/cmd/db.go
View file @ c3c87289
...@@ -58,7 +58,7 @@ func dbExportCmd(cmd *cobra.Command) { ...@@ -58,7 +58,7 @@ func dbExportCmd(cmd *cobra.Command) {
path := filepath.Join(dataDir, "localstore") path := filepath.Join(dataDir, "localstore")
storer, err := localstore.New(path, nil, nil, logger) storer, err := localstore.New(path, nil, nil, nil, logger)
if err != nil { if err != nil {
return fmt.Errorf("localstore: %w", err) return fmt.Errorf("localstore: %w", err)
} }
...@@ -118,7 +118,7 @@ func dbImportCmd(cmd *cobra.Command) { ...@@ -118,7 +118,7 @@ func dbImportCmd(cmd *cobra.Command) {
path := filepath.Join(dataDir, "localstore") path := filepath.Join(dataDir, "localstore")
storer, err := localstore.New(path, nil, nil, logger) storer, err := localstore.New(path, nil, nil, nil, logger)
if err != nil { if err != nil {
return fmt.Errorf("localstore: %w", err) return fmt.Errorf("localstore: %w", err)
} }
......
pkg/localstore/gc_test.go
View file @ c3c87289
...@@ -486,7 +486,7 @@ func TestDB_gcSize(t *testing.T) { ...@@ -486,7 +486,7 @@ func TestDB_gcSize(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
db, err := New(dir, baseKey, nil, logger) db, err := New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
...@@ -514,7 +514,7 @@ func TestDB_gcSize(t *testing.T) { ...@@ -514,7 +514,7 @@ func TestDB_gcSize(t *testing.T) {
if err := db.Close(); err != nil { if err := db.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
db, err = New(dir, baseKey, nil, logger) db, err = New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
......
pkg/localstore/localstore.go
View file @ c3c87289
...@@ -25,6 +25,7 @@ import ( ...@@ -25,6 +25,7 @@ import (
"time" "time"
"github.com/ethersphere/bee/pkg/logging" "github.com/ethersphere/bee/pkg/logging"
"github.com/ethersphere/bee/pkg/pinning"
"github.com/ethersphere/bee/pkg/postage" "github.com/ethersphere/bee/pkg/postage"
"github.com/ethersphere/bee/pkg/postage/batchstore" "github.com/ethersphere/bee/pkg/postage/batchstore"
"github.com/ethersphere/bee/pkg/shed" "github.com/ethersphere/bee/pkg/shed"
...@@ -62,6 +63,9 @@ type DB struct { ...@@ -62,6 +63,9 @@ type DB struct {
shed *shed.DB shed *shed.DB
tags *tags.Tags tags *tags.Tags
// stateStore is needed to access the pinning Service.Pins() method.
stateStore storage.StateStorer
// schema name of loaded data // schema name of loaded data
schemaName shed.StringField schemaName shed.StringField
...@@ -176,7 +180,7 @@ type Options struct { ...@@ -176,7 +180,7 @@ type Options struct {
// New returns a new DB. All fields and indexes are initialized // New returns a new DB. All fields and indexes are initialized
// and possible conflicts with schema from existing database is checked. // and possible conflicts with schema from existing database is checked.
// One goroutine for writing batches is created. // One goroutine for writing batches is created.
func New(path string, baseKey []byte, o *Options, logger logging.Logger) (db *DB, err error) { func New(path string, baseKey []byte, ss storage.StateStorer, o *Options, logger logging.Logger) (db *DB, err error) {
if o == nil { if o == nil {
// default options // default options
o = &Options{ o = &Options{
...@@ -185,6 +189,7 @@ func New(path string, baseKey []byte, o *Options, logger logging.Logger) (db *DB ...@@ -185,6 +189,7 @@ func New(path string, baseKey []byte, o *Options, logger logging.Logger) (db *DB
} }
db = &DB{ db = &DB{
stateStore: ss,
cacheCapacity: o.Capacity, cacheCapacity: o.Capacity,
baseKey: baseKey, baseKey: baseKey,
tags: o.Tags, tags: o.Tags,
...@@ -241,7 +246,7 @@ func New(path string, baseKey []byte, o *Options, logger logging.Logger) (db *DB ...@@ -241,7 +246,7 @@ func New(path string, baseKey []byte, o *Options, logger logging.Logger) (db *DB
} }
if schemaName == "" { if schemaName == "" {
// initial new localstore run // initial new localstore run
err := db.schemaName.Put(DbSchemaCurrent) err := db.schemaName.Put(DBSchemaCurrent)
if err != nil { if err != nil {
return nil, err return nil, err
} }
...@@ -585,6 +590,16 @@ func (db *DB) DebugIndices() (indexInfo map[string]int, err error) { ...@@ -585,6 +590,16 @@ func (db *DB) DebugIndices() (indexInfo map[string]int, err error) {
return indexInfo, err return indexInfo, err
} }
// stateStoreHasPins returns true if the state-store
// contains any pins, otherwise false is returned.
func (db *DB) stateStoreHasPins() (bool, error) {
pins, err := pinning.NewService(nil, db.stateStore, nil).Pins()
if err != nil {
return false, err
}
return len(pins) > 0, nil
}
// chunkToItem creates new Item with data provided by the Chunk. // chunkToItem creates new Item with data provided by the Chunk.
func chunkToItem(ch swarm.Chunk) shed.Item { func chunkToItem(ch swarm.Chunk) shed.Item {
return shed.Item{ return shed.Item{
......
pkg/localstore/localstore_test.go
View file @ c3c87289
...@@ -158,7 +158,7 @@ func newTestDB(t testing.TB, o *Options) *DB { ...@@ -158,7 +158,7 @@ func newTestDB(t testing.TB, o *Options) *DB {
t.Fatal(err) t.Fatal(err)
} }
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
db, err := New("", baseKey, o, logger) db, err := New("", baseKey, nil, o, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
......
pkg/localstore/migration.go
View file @ c3c87289
...@@ -17,13 +17,10 @@ ...@@ -17,13 +17,10 @@
package localstore package localstore
import ( import (
"encoding/binary"
"errors" "errors"
"fmt" "fmt"
"time"
"github.com/ethersphere/bee/pkg/shed" "github.com/ethersphere/bee/pkg/shed"
"github.com/ethersphere/bee/pkg/swarm"
"github.com/syndtr/goleveldb/leveldb" "github.com/syndtr/goleveldb/leveldb"
) )
...@@ -31,40 +28,39 @@ var errMissingCurrentSchema = errors.New("could not find current db schema") ...@@ -31,40 +28,39 @@ var errMissingCurrentSchema = errors.New("could not find current db schema")
var errMissingTargetSchema = errors.New("could not find target db schema") var errMissingTargetSchema = errors.New("could not find target db schema")
type migration struct { type migration struct {
name string // name of the schema schemaName string
fn func(db *DB) error // the migration function that needs to be performed in order to get to the current schema name // The migration function that needs to be performed
// in order to get to the current schema name.
fn func(db *DB) error
} }
// schemaMigrations contains an ordered list of the database schemes, that is // schemaMigrations contains an ordered list of the database schemes, that is
// in order to run data migrations in the correct sequence // in order to run data migrations in the correct sequence
var schemaMigrations = []migration{ var schemaMigrations = []migration{
{name: DbSchemaCode, fn: func(_ *DB) error { return nil }}, {schemaName: DBSchemaCode, fn: func(*DB) error { return nil }},
{name: DbSchemaYuj, fn: migrateYuj}, {schemaName: DBSchemaYuj, fn: migrateYuj},
{schemaName: DBSchemaBatchIndex, fn: migrateBatchIndex},
} }
func (db *DB) migrate(schemaName string) error { func (db *DB) migrate(schemaName string) error {
migrations, err := getMigrations(schemaName, DbSchemaCurrent, schemaMigrations, db) migrations, err := getMigrations(schemaName, DBSchemaCurrent, schemaMigrations, db)
if err != nil { if err != nil {
return fmt.Errorf("error getting migrations for current schema (%s): %v", schemaName, err) return fmt.Errorf("error getting migrations for current schema %q: %w", schemaName, err)
} }
// no migrations to run if len(migrations) == 0 {
if migrations == nil {
return nil return nil
} }
db.logger.Infof("localstore migration: need to run %v data migrations on localstore to schema %s", len(migrations), schemaName) db.logger.Infof("localstore migration: need to run %v data migrations on localstore to schema %s", len(migrations), schemaName)
for i := 0; i < len(migrations); i++ { for i, migration := range migrations {
err := migrations[i].fn(db) if err := migration.fn(db); err != nil {
if err != nil {
return err return err
} }
err = db.schemaName.Put(migrations[i].name) // put the name of the current schema if err = db.schemaName.Put(migration.schemaName); err != nil {
if err != nil {
return err return err
} }
schemaName, err = db.schemaName.Get() if schemaName, err = db.schemaName.Get(); err != nil {
if err != nil {
return err return err
} }
db.logger.Infof("localstore migration: successfully ran migration: id %v current schema: %s", i, schemaName) db.logger.Infof("localstore migration: successfully ran migration: id %v current schema: %s", i, schemaName)
...@@ -76,19 +72,22 @@ func (db *DB) migrate(schemaName string) error { ...@@ -76,19 +72,22 @@ func (db *DB) migrate(schemaName string) error {
// with no errors in order to bring the localstore to the most up-to-date // with no errors in order to bring the localstore to the most up-to-date
// schema definition // schema definition
func getMigrations(currentSchema, targetSchema string, allSchemeMigrations []migration, db *DB) (migrations []migration, err error) { func getMigrations(currentSchema, targetSchema string, allSchemeMigrations []migration, db *DB) (migrations []migration, err error) {
foundCurrent := false if currentSchema == DBSchemaCurrent {
foundTarget := false
if currentSchema == DbSchemaCurrent {
return nil, nil return nil, nil
} }
var (
foundCurrent = false
foundTarget = false
)
for i, v := range allSchemeMigrations { for i, v := range allSchemeMigrations {
switch v.name { switch v.schemaName {
case currentSchema: case currentSchema:
if foundCurrent { if foundCurrent {
return nil, errors.New("found schema name for the second time when looking for migrations") return nil, errors.New("found schema name for the second time when looking for migrations")
} }
foundCurrent = true foundCurrent = true
db.logger.Infof("localstore migration: found current localstore schema %s, migrate to %s, total migrations %d", currentSchema, DbSchemaCurrent, len(allSchemeMigrations)-i) db.logger.Infof("localstore migration: found current localstore schema %s, migrate to %s, total migrations %d", currentSchema, DBSchemaCurrent, len(allSchemeMigrations)-i)
continue // current schema migration should not be executed (already has been when schema was migrated to) continue // current schema migration should not be executed (already has been when schema was migrated to)
case targetSchema: case targetSchema:
foundTarget = true foundTarget = true
...@@ -106,266 +105,29 @@ func getMigrations(currentSchema, targetSchema string, allSchemeMigrations []mig ...@@ -106,266 +105,29 @@ func getMigrations(currentSchema, targetSchema string, allSchemeMigrations []mig
return migrations, nil return migrations, nil
} }
// migrateYuj removes all existing database content, unless // truncateIndex truncates the given index for the given db.
// pinned content is detected, in which case it aborts the func truncateIndex(db *DB, idx shed.Index) (n int, err error) {
// operation for the user to resolve. const maxBatchSize = 10000
func migrateYuj(db *DB) error {
pinIndex, err := db.shed.NewIndex("Hash->PinCounter", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b[:8], fields.PinCounter)
return b, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.PinCounter = binary.BigEndian.Uint64(value[:8])
return e, nil
},
})
if err != nil {
return err
}
hasPinned := false
_ = pinIndex.Iterate(func(item shed.Item) (stop bool, err error) {
hasPinned = true
return true, nil
}, nil)
if hasPinned {
return errors.New("failed to update your node due to the existence of pinned content. Please refer to the release notes on how to safely migrate your pinned content.")
}
// define the old indexes from the previous schema
// and swipe them clean.
retrievalDataIndex, err := db.shed.NewIndex("Address->StoreTimestamp|BinID|Data", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
b := make([]byte, 16)
binary.BigEndian.PutUint64(b[:8], fields.BinID)
binary.BigEndian.PutUint64(b[8:16], uint64(fields.StoreTimestamp))
value = append(b, fields.Data...)
return value, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.StoreTimestamp = int64(binary.BigEndian.Uint64(value[8:16]))
e.BinID = binary.BigEndian.Uint64(value[:8])
e.Data = value[16:]
return e, nil
},
})
if err != nil {
return err
}
retrievalAccessIndex, err := db.shed.NewIndex("Address->AccessTimestamp", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(fields.AccessTimestamp))
return b, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.AccessTimestamp = int64(binary.BigEndian.Uint64(value))
return e, nil
},
})
if err != nil {
return err
}
// pull index allows history and live syncing per po bin
pullIndex, err := db.shed.NewIndex("PO|BinID->Hash|Tag", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
key = make([]byte, 41)
key[0] = db.po(swarm.NewAddress(fields.Address))
binary.BigEndian.PutUint64(key[1:9], fields.BinID)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.BinID = binary.BigEndian.Uint64(key[1:9])
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
value = make([]byte, 36) // 32 bytes address, 4 bytes tag
copy(value, fields.Address)
if fields.Tag != 0 { batch := new(leveldb.Batch)
binary.BigEndian.PutUint32(value[32:], fields.Tag) if err = idx.Iterate(func(item shed.Item) (stop bool, err error) {
} if err = idx.DeleteInBatch(batch, item); err != nil {
return true, err
return value, nil }
}, db.logger.Debugf("truncateIndex: deleted %x", item.Address)
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.Address = value[:32]
if len(value) > 32 {
e.Tag = binary.BigEndian.Uint32(value[32:])
}
return e, nil
},
})
if err != nil {
return err
}
// create a vector for bin IDs
binIDs, err := db.shed.NewUint64Vector("bin-ids")
if err != nil {
return err
}
pushIndex, err := db.shed.NewIndex("StoreTimestamp|Hash->Tags", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
key = make([]byte, 40)
binary.BigEndian.PutUint64(key[:8], uint64(fields.StoreTimestamp))
copy(key[8:], fields.Address)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key[8:]
e.StoreTimestamp = int64(binary.BigEndian.Uint64(key[:8]))
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
tag := make([]byte, 4)
binary.BigEndian.PutUint32(tag, fields.Tag)
return tag, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
if len(value) == 4 { // only values with tag should be decoded
e.Tag = binary.BigEndian.Uint32(value)
}
return e, nil
},
})
if err != nil {
return err
}
gcIndex, err := db.shed.NewIndex("AccessTimestamp|BinID|Hash->nil", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
b := make([]byte, 16, 16+len(fields.Address))
binary.BigEndian.PutUint64(b[:8], uint64(fields.AccessTimestamp))
binary.BigEndian.PutUint64(b[8:16], fields.BinID)
key = append(b, fields.Address...)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.AccessTimestamp = int64(binary.BigEndian.Uint64(key[:8]))
e.BinID = binary.BigEndian.Uint64(key[8:16])
e.Address = key[16:]
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
return nil, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
return e, nil
},
})
if err != nil {
return err
}
// Create a index structure for excluding pinned chunks from gcIndex
gcExcludeIndex, err := db.shed.NewIndex("Hash->nil", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
return nil, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
return e, nil
},
})
if err != nil {
return err
}
var lim = 10000
count := 0
truncate := func(i shed.Index) error {
batch := new(leveldb.Batch)
count = 0
err := i.Iterate(func(item shed.Item) (stop bool, err error) { if n++; n%maxBatchSize == 0 {
if err = i.DeleteInBatch(batch, item); err != nil { db.logger.Debugf("truncateIndex: writing batch; processed %d", n)
err := db.shed.WriteBatch(batch)
if err != nil {
return true, err return true, err
} }
count++ batch.Reset()
if count%lim == 0 {
db.logger.Debugf("truncate writing batch. processed %d", count)
err := db.shed.WriteBatch(batch)
if err != nil {
return true, err
}
batch = new(leveldb.Batch)
}
return false, nil
}, nil)
if err != nil {
return err
}
return db.shed.WriteBatch(batch)
}
start := time.Now()
db.logger.Debug("truncating indexes")
for _, v := range []struct {
name string
idx shed.Index
}{
{"pullsync", pullIndex},
{"pushsync", pushIndex},
{"gc", gcIndex},
{"gcExclude", gcExcludeIndex},
{"retrievalAccess", retrievalAccessIndex},
{"retrievalData", retrievalDataIndex},
} {
db.logger.Debugf("truncating %s index", v.name)
err := truncate(v.idx)
if err != nil {
return fmt.Errorf("truncate %s index: %w", v.name, err)
} }
db.logger.Debugf("truncated %d %s index entries", count, v.name)
}
gcSize, err := db.shed.NewUint64Field("gc-size")
if err != nil {
return fmt.Errorf("gc size index: %w", err)
}
err = gcSize.Put(0) return false, nil
if err != nil { }, nil); err != nil {
return fmt.Errorf("put gcsize: %w", err) return n, err
} }
return n, db.shed.WriteBatch(batch)
for i := 0; i < int(swarm.MaxBins); i++ {
if err := binIDs.Put(uint64(i), 0); err != nil {
return fmt.Errorf("zero binsIDs: %w", err)
}
}
db.logger.Debugf("done truncating indexes. took %s", time.Since(start))
return nil
} }
pkg/localstore/migration_batch_index.go 0 → 100644
View file @ c3c87289
// Copyright 2021 The Swarm Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package localstore
import (
"encoding/binary"
"errors"
"fmt"
"time"
"github.com/ethersphere/bee/pkg/shed"
"github.com/ethersphere/bee/pkg/swarm"
)
// DBSchemaBatchIndex is the bee schema identifier for batch index.
const DBSchemaBatchIndex = "batch-index"
// migrateBatchIndex removes all existing database content, unless pinned
// content is detected, in which case it aborts the operation for the user to
// resolve.
func migrateBatchIndex(db *DB) error {
has, err := db.stateStoreHasPins()
if err != nil {
return err
}
if has {
return errors.New("failed to update your node due to the existence of pinned content; please refer to the release notes on how to safely migrate your pinned content")
}
// Define the old indexes from the previous schema and swipe them clean.
retrievalDataIndex, err := db.shed.NewIndex("Address->StoreTimestamp|BinID|BatchID|Sig|Data", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
return nil, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
return keyItem, nil
},
})
if err != nil {
return err
}
retrievalAccessIndex, err := db.shed.NewIndex("Address->AccessTimestamp", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(fields.AccessTimestamp))
return b, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.AccessTimestamp = int64(binary.BigEndian.Uint64(value))
return e, nil
},
})
if err != nil {
return err
}
// pull index allows history and live syncing per po bin
pullIndex, err := db.shed.NewIndex("PO|BinID->Hash|Tag", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
key = make([]byte, 41)
key[0] = db.po(swarm.NewAddress(fields.Address))
binary.BigEndian.PutUint64(key[1:9], fields.BinID)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.BinID = binary.BigEndian.Uint64(key[1:9])
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
value = make([]byte, 36) // 32 bytes address, 4 bytes tag
copy(value, fields.Address)
if fields.Tag != 0 {
binary.BigEndian.PutUint32(value[32:], fields.Tag)
}
return value, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.Address = value[:32]
if len(value) > 32 {
e.Tag = binary.BigEndian.Uint32(value[32:])
}
return e, nil
},
})
if err != nil {
return err
}
// create a vector for bin IDs
binIDs, err := db.shed.NewUint64Vector("bin-ids")
if err != nil {
return err
}
pushIndex, err := db.shed.NewIndex("StoreTimestamp|Hash->Tags", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
key = make([]byte, 40)
binary.BigEndian.PutUint64(key[:8], uint64(fields.StoreTimestamp))
copy(key[8:], fields.Address)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key[8:]
e.StoreTimestamp = int64(binary.BigEndian.Uint64(key[:8]))
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
tag := make([]byte, 4)
binary.BigEndian.PutUint32(tag, fields.Tag)
return tag, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
if len(value) == 4 { // only values with tag should be decoded
e.Tag = binary.BigEndian.Uint32(value)
}
return e, nil
},
})
if err != nil {
return err
}
gcIndex, err := db.shed.NewIndex("AccessTimestamp|BinID|Hash->nil", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
b := make([]byte, 16, 16+len(fields.Address))
binary.BigEndian.PutUint64(b[:8], uint64(fields.AccessTimestamp))
binary.BigEndian.PutUint64(b[8:16], fields.BinID)
key = append(b, fields.Address...)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.AccessTimestamp = int64(binary.BigEndian.Uint64(key[:8]))
e.BinID = binary.BigEndian.Uint64(key[8:16])
e.Address = key[16:]
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
return nil, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
return e, nil
},
})
if err != nil {
return err
}
// Create a index structure for excluding pinned chunks from gcIndex
gcExcludeIndex, err := db.shed.NewIndex("Hash->nil", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
return nil, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
return e, nil
},
})
if err != nil {
return err
}
start := time.Now()
db.logger.Debug("truncating indexes")
var count int
for _, v := range []struct {
name string
idx shed.Index
}{
{"pullsync", pullIndex},
{"pushsync", pushIndex},
{"gc", gcIndex},
{"gcExclude", gcExcludeIndex},
{"retrievalAccess", retrievalAccessIndex},
{"retrievalData", retrievalDataIndex},
} {
db.logger.Debugf("truncating %s index", v.name)
n, err := truncateIndex(db, v.idx)
if err != nil {
return fmt.Errorf("truncate %s index: %w", v.name, err)
}
count += n
db.logger.Debugf("truncated %d %s index entries", count, v.name)
}
gcSize, err := db.shed.NewUint64Field("gc-size")
if err != nil {
return fmt.Errorf("gc size index: %w", err)
}
err = gcSize.Put(0)
if err != nil {
return fmt.Errorf("put gcsize: %w", err)
}
for i := 0; i < int(swarm.MaxBins); i++ {
if err := binIDs.Put(uint64(i), 0); err != nil {
return fmt.Errorf("zero binsIDs: %w", err)
}
}
db.logger.Debugf("done truncating indexes. took %s", time.Since(start))
return nil
}
pkg/localstore/migration_test.go
View file @ c3c87289
...@@ -29,20 +29,20 @@ import ( ...@@ -29,20 +29,20 @@ import (
func TestOneMigration(t *testing.T) { func TestOneMigration(t *testing.T) {
defer func(v []migration, s string) { defer func(v []migration, s string) {
schemaMigrations = v schemaMigrations = v
DbSchemaCurrent = s DBSchemaCurrent = s
}(schemaMigrations, DbSchemaCurrent) }(schemaMigrations, DBSchemaCurrent)
DbSchemaCurrent = DbSchemaCode DBSchemaCurrent = DBSchemaCode
dbSchemaNext := "dbSchemaNext" dbSchemaNext := "dbSchemaNext"
ran := false ran := false
shouldNotRun := false shouldNotRun := false
schemaMigrations = []migration{ schemaMigrations = []migration{
{name: DbSchemaCode, fn: func(db *DB) error { {schemaName: DBSchemaCode, fn: func(db *DB) error {
shouldNotRun = true // this should not be executed shouldNotRun = true // this should not be executed
return nil return nil
}}, }},
{name: dbSchemaNext, fn: func(db *DB) error { {schemaName: dbSchemaNext, fn: func(db *DB) error {
ran = true ran = true
return nil return nil
}}, }},
...@@ -61,7 +61,7 @@ func TestOneMigration(t *testing.T) { ...@@ -61,7 +61,7 @@ func TestOneMigration(t *testing.T) {
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
// start the fresh localstore with the sanctuary schema name // start the fresh localstore with the sanctuary schema name
db, err := New(dir, baseKey, nil, logger) db, err := New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
...@@ -71,10 +71,10 @@ func TestOneMigration(t *testing.T) { ...@@ -71,10 +71,10 @@ func TestOneMigration(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
DbSchemaCurrent = dbSchemaNext DBSchemaCurrent = dbSchemaNext
// start the existing localstore and expect the migration to run // start the existing localstore and expect the migration to run
db, err = New(dir, baseKey, nil, logger) db, err = New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
...@@ -105,32 +105,32 @@ func TestOneMigration(t *testing.T) { ...@@ -105,32 +105,32 @@ func TestOneMigration(t *testing.T) {
func TestManyMigrations(t *testing.T) { func TestManyMigrations(t *testing.T) {
defer func(v []migration, s string) { defer func(v []migration, s string) {
schemaMigrations = v schemaMigrations = v
DbSchemaCurrent = s DBSchemaCurrent = s
}(schemaMigrations, DbSchemaCurrent) }(schemaMigrations, DBSchemaCurrent)
DbSchemaCurrent = DbSchemaCode DBSchemaCurrent = DBSchemaCode
shouldNotRun := false shouldNotRun := false
executionOrder := []int{-1, -1, -1, -1} executionOrder := []int{-1, -1, -1, -1}
schemaMigrations = []migration{ schemaMigrations = []migration{
{name: DbSchemaCode, fn: func(db *DB) error { {schemaName: DBSchemaCode, fn: func(db *DB) error {
shouldNotRun = true // this should not be executed shouldNotRun = true // this should not be executed
return nil return nil
}}, }},
{name: "keju", fn: func(db *DB) error { {schemaName: "keju", fn: func(db *DB) error {
executionOrder[0] = 0 executionOrder[0] = 0
return nil return nil
}}, }},
{name: "coconut", fn: func(db *DB) error { {schemaName: "coconut", fn: func(db *DB) error {
executionOrder[1] = 1 executionOrder[1] = 1
return nil return nil
}}, }},
{name: "mango", fn: func(db *DB) error { {schemaName: "mango", fn: func(db *DB) error {
executionOrder[2] = 2 executionOrder[2] = 2
return nil return nil
}}, }},
{name: "salvation", fn: func(db *DB) error { {schemaName: "salvation", fn: func(db *DB) error {
executionOrder[3] = 3 executionOrder[3] = 3
return nil return nil
}}, }},
...@@ -148,7 +148,7 @@ func TestManyMigrations(t *testing.T) { ...@@ -148,7 +148,7 @@ func TestManyMigrations(t *testing.T) {
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
// start the fresh localstore with the sanctuary schema name // start the fresh localstore with the sanctuary schema name
db, err := New(dir, baseKey, nil, logger) db, err := New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
...@@ -158,10 +158,10 @@ func TestManyMigrations(t *testing.T) { ...@@ -158,10 +158,10 @@ func TestManyMigrations(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
DbSchemaCurrent = "salvation" DBSchemaCurrent = "salvation"
// start the existing localstore and expect the migration to run // start the existing localstore and expect the migration to run
db, err = New(dir, baseKey, nil, logger) db, err = New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
...@@ -195,22 +195,22 @@ func TestManyMigrations(t *testing.T) { ...@@ -195,22 +195,22 @@ func TestManyMigrations(t *testing.T) {
func TestMigrationErrorFrom(t *testing.T) { func TestMigrationErrorFrom(t *testing.T) {
defer func(v []migration, s string) { defer func(v []migration, s string) {
schemaMigrations = v schemaMigrations = v
DbSchemaCurrent = s DBSchemaCurrent = s
}(schemaMigrations, DbSchemaCurrent) }(schemaMigrations, DBSchemaCurrent)
DbSchemaCurrent = "koo-koo-schema" DBSchemaCurrent = "koo-koo-schema"
shouldNotRun := false shouldNotRun := false
schemaMigrations = []migration{ schemaMigrations = []migration{
{name: "langur", fn: func(db *DB) error { {schemaName: "langur", fn: func(db *DB) error {
shouldNotRun = true shouldNotRun = true
return nil return nil
}}, }},
{name: "coconut", fn: func(db *DB) error { {schemaName: "coconut", fn: func(db *DB) error {
shouldNotRun = true shouldNotRun = true
return nil return nil
}}, }},
{name: "chutney", fn: func(db *DB) error { {schemaName: "chutney", fn: func(db *DB) error {
shouldNotRun = true shouldNotRun = true
return nil return nil
}}, }},
...@@ -228,7 +228,7 @@ func TestMigrationErrorFrom(t *testing.T) { ...@@ -228,7 +228,7 @@ func TestMigrationErrorFrom(t *testing.T) {
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
// start the fresh localstore with the sanctuary schema name // start the fresh localstore with the sanctuary schema name
db, err := New(dir, baseKey, nil, logger) db, err := New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
...@@ -238,10 +238,10 @@ func TestMigrationErrorFrom(t *testing.T) { ...@@ -238,10 +238,10 @@ func TestMigrationErrorFrom(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
DbSchemaCurrent = "foo" DBSchemaCurrent = "foo"
// start the existing localstore and expect the migration to run // start the existing localstore and expect the migration to run
_, err = New(dir, baseKey, nil, logger) _, err = New(dir, baseKey, nil, nil, logger)
if !strings.Contains(err.Error(), errMissingCurrentSchema.Error()) { if !strings.Contains(err.Error(), errMissingCurrentSchema.Error()) {
t.Fatalf("expected errCannotFindSchema but got %v", err) t.Fatalf("expected errCannotFindSchema but got %v", err)
} }
...@@ -255,22 +255,22 @@ func TestMigrationErrorFrom(t *testing.T) { ...@@ -255,22 +255,22 @@ func TestMigrationErrorFrom(t *testing.T) {
func TestMigrationErrorTo(t *testing.T) { func TestMigrationErrorTo(t *testing.T) {
defer func(v []migration, s string) { defer func(v []migration, s string) {
schemaMigrations = v schemaMigrations = v
DbSchemaCurrent = s DBSchemaCurrent = s
}(schemaMigrations, DbSchemaCurrent) }(schemaMigrations, DBSchemaCurrent)
DbSchemaCurrent = "langur" DBSchemaCurrent = "langur"
shouldNotRun := false shouldNotRun := false
schemaMigrations = []migration{ schemaMigrations = []migration{
{name: "langur", fn: func(db *DB) error { {schemaName: "langur", fn: func(db *DB) error {
shouldNotRun = true shouldNotRun = true
return nil return nil
}}, }},
{name: "coconut", fn: func(db *DB) error { {schemaName: "coconut", fn: func(db *DB) error {
shouldNotRun = true shouldNotRun = true
return nil return nil
}}, }},
{name: "chutney", fn: func(db *DB) error { {schemaName: "chutney", fn: func(db *DB) error {
shouldNotRun = true shouldNotRun = true
return nil return nil
}}, }},
...@@ -289,7 +289,7 @@ func TestMigrationErrorTo(t *testing.T) { ...@@ -289,7 +289,7 @@ func TestMigrationErrorTo(t *testing.T) {
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
// start the fresh localstore with the sanctuary schema name // start the fresh localstore with the sanctuary schema name
db, err := New(dir, baseKey, nil, logger) db, err := New(dir, baseKey, nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
...@@ -299,10 +299,10 @@ func TestMigrationErrorTo(t *testing.T) { ...@@ -299,10 +299,10 @@ func TestMigrationErrorTo(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
DbSchemaCurrent = "foo" DBSchemaCurrent = "foo"
// start the existing localstore and expect the migration to run // start the existing localstore and expect the migration to run
_, err = New(dir, baseKey, nil, logger) _, err = New(dir, baseKey, nil, nil, logger)
if !strings.Contains(err.Error(), errMissingTargetSchema.Error()) { if !strings.Contains(err.Error(), errMissingTargetSchema.Error()) {
t.Fatalf("expected errMissingTargetSchema but got %v", err) t.Fatalf("expected errMissingTargetSchema but got %v", err)
} }
......
pkg/localstore/migration_yuj.go 0 → 100644
View file @ c3c87289
// Copyright 2021 The Swarm Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package localstore
import (
"encoding/binary"
"errors"
"fmt"
"time"
"github.com/ethersphere/bee/pkg/shed"
"github.com/ethersphere/bee/pkg/swarm"
)
// DBSchemaYuj is the bee schema identifier for storage incentives initial iteration.
const DBSchemaYuj = "yuj"
// migrateYuj removes all existing database content, unless
// pinned content is detected, in which case it aborts the
// operation for the user to resolve.
func migrateYuj(db *DB) error {
pinIndex, err := db.shed.NewIndex("Hash->PinCounter", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b[:8], fields.PinCounter)
return b, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.PinCounter = binary.BigEndian.Uint64(value[:8])
return e, nil
},
})
if err != nil {
return err
}
hasPins := false
_ = pinIndex.Iterate(func(item shed.Item) (stop bool, err error) {
hasPins = true
return true, nil
}, nil)
if hasPins {
return errors.New("failed to update your node due to the existence of pinned content; please refer to the release notes on how to safely migrate your pinned content")
}
// Define the old indexes from the previous schema and swipe them clean.
retrievalDataIndex, err := db.shed.NewIndex("Address->StoreTimestamp|BinID|Data", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
b := make([]byte, 16)
binary.BigEndian.PutUint64(b[:8], fields.BinID)
binary.BigEndian.PutUint64(b[8:16], uint64(fields.StoreTimestamp))
value = append(b, fields.Data...)
return value, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.StoreTimestamp = int64(binary.BigEndian.Uint64(value[8:16]))
e.BinID = binary.BigEndian.Uint64(value[:8])
e.Data = value[16:]
return e, nil
},
})
if err != nil {
return err
}
retrievalAccessIndex, err := db.shed.NewIndex("Address->AccessTimestamp", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(fields.AccessTimestamp))
return b, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.AccessTimestamp = int64(binary.BigEndian.Uint64(value))
return e, nil
},
})
if err != nil {
return err
}
// pull index allows history and live syncing per po bin
pullIndex, err := db.shed.NewIndex("PO|BinID->Hash|Tag", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
key = make([]byte, 41)
key[0] = db.po(swarm.NewAddress(fields.Address))
binary.BigEndian.PutUint64(key[1:9], fields.BinID)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.BinID = binary.BigEndian.Uint64(key[1:9])
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
value = make([]byte, 36) // 32 bytes address, 4 bytes tag
copy(value, fields.Address)
if fields.Tag != 0 {
binary.BigEndian.PutUint32(value[32:], fields.Tag)
}
return value, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
e.Address = value[:32]
if len(value) > 32 {
e.Tag = binary.BigEndian.Uint32(value[32:])
}
return e, nil
},
})
if err != nil {
return err
}
// create a vector for bin IDs
binIDs, err := db.shed.NewUint64Vector("bin-ids")
if err != nil {
return err
}
pushIndex, err := db.shed.NewIndex("StoreTimestamp|Hash->Tags", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
key = make([]byte, 40)
binary.BigEndian.PutUint64(key[:8], uint64(fields.StoreTimestamp))
copy(key[8:], fields.Address)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key[8:]
e.StoreTimestamp = int64(binary.BigEndian.Uint64(key[:8]))
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
tag := make([]byte, 4)
binary.BigEndian.PutUint32(tag, fields.Tag)
return tag, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
if len(value) == 4 { // only values with tag should be decoded
e.Tag = binary.BigEndian.Uint32(value)
}
return e, nil
},
})
if err != nil {
return err
}
gcIndex, err := db.shed.NewIndex("AccessTimestamp|BinID|Hash->nil", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
b := make([]byte, 16, 16+len(fields.Address))
binary.BigEndian.PutUint64(b[:8], uint64(fields.AccessTimestamp))
binary.BigEndian.PutUint64(b[8:16], fields.BinID)
key = append(b, fields.Address...)
return key, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.AccessTimestamp = int64(binary.BigEndian.Uint64(key[:8]))
e.BinID = binary.BigEndian.Uint64(key[8:16])
e.Address = key[16:]
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
return nil, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
return e, nil
},
})
if err != nil {
return err
}
// Create a index structure for excluding pinned chunks from gcIndex
gcExcludeIndex, err := db.shed.NewIndex("Hash->nil", shed.IndexFuncs{
EncodeKey: func(fields shed.Item) (key []byte, err error) {
return fields.Address, nil
},
DecodeKey: func(key []byte) (e shed.Item, err error) {
e.Address = key
return e, nil
},
EncodeValue: func(fields shed.Item) (value []byte, err error) {
return nil, nil
},
DecodeValue: func(keyItem shed.Item, value []byte) (e shed.Item, err error) {
return e, nil
},
})
if err != nil {
return err
}
start := time.Now()
db.logger.Debug("truncating indexes")
var count int
for _, v := range []struct {
name string
idx shed.Index
}{
{"pullsync", pullIndex},
{"pushsync", pushIndex},
{"gc", gcIndex},
{"gcExclude", gcExcludeIndex},
{"retrievalAccess", retrievalAccessIndex},
{"retrievalData", retrievalDataIndex},
} {
db.logger.Debugf("truncating %s index", v.name)
n, err := truncateIndex(db, v.idx)
if err != nil {
return fmt.Errorf("truncate %s index: %w", v.name, err)
}
count += n
db.logger.Debugf("truncated %d %s index entries", count, v.name)
}
gcSize, err := db.shed.NewUint64Field("gc-size")
if err != nil {
return fmt.Errorf("gc size index: %w", err)
}
err = gcSize.Put(0)
if err != nil {
return fmt.Errorf("put gcsize: %w", err)
}
for i := 0; i < int(swarm.MaxBins); i++ {
if err := binIDs.Put(uint64(i), 0); err != nil {
return fmt.Errorf("zero binsIDs: %w", err)
}
}
db.logger.Debugf("done truncating indexes. took %s", time.Since(start))
return nil
}
pkg/localstore/schema.go
View file @ c3c87289
...@@ -16,16 +16,9 @@ ...@@ -16,16 +16,9 @@
package localstore package localstore
// The DB schema we want to use. The actual/current DB schema might differ // DBSchemaCode is the first bee schema identifier.
// until migrations are run. const DBSchemaCode = "code"
var DbSchemaCurrent = DbSchemaYuj
// There was a time when we had no schema at all. // DBSchemaCurrent represents the DB schema we want to use.
const DbSchemaNone = "" // The actual/current DB schema might differ until migrations are run.
var DBSchemaCurrent = DBSchemaBatchIndex
// DbSchemaCode is the first bee schema identifier
const DbSchemaCode = "code"
// DbSchemaYuj is the bee schema indentifier for storage incentives
// initial iteration.
const DbSchemaYuj = "yuj"
pkg/node/node.go
View file @ c3c87289
...@@ -348,7 +348,7 @@ func NewBee(addr string, swarmAddress swarm.Address, publicKey ecdsa.PublicKey, ...@@ -348,7 +348,7 @@ func NewBee(addr string, swarmAddress swarm.Address, publicKey ecdsa.PublicKey,
DisableSeeksCompaction: o.DBDisableSeeksCompaction, DisableSeeksCompaction: o.DBDisableSeeksCompaction,
} }
storer, err := localstore.New(path, swarmAddress.Bytes(), lo, logger) storer, err := localstore.New(path, swarmAddress.Bytes(), stateStore, lo, logger)
if err != nil { if err != nil {
return nil, fmt.Errorf("localstore: %w", err) return nil, fmt.Errorf("localstore: %w", err)
} }
......
pkg/pullsync/pullstorage/pullstorage_test.go
View file @ c3c87289
...@@ -562,7 +562,7 @@ func newTestDB(t testing.TB, o *localstore.Options) (baseKey []byte, db *localst ...@@ -562,7 +562,7 @@ func newTestDB(t testing.TB, o *localstore.Options) (baseKey []byte, db *localst
} }
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
db, err := localstore.New("", baseKey, o, logger) db, err := localstore.New("", baseKey, nil, o, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
......
pkg/pusher/pusher_test.go
View file @ c3c87289
...@@ -420,7 +420,7 @@ func TestPusherRetryShallow(t *testing.T) { ...@@ -420,7 +420,7 @@ func TestPusherRetryShallow(t *testing.T) {
func createPusher(t *testing.T, addr swarm.Address, pushSyncService pushsync.PushSyncer, mockOpts ...mock.Option) (*tags.Tags, *pusher.Service, *Store) { func createPusher(t *testing.T, addr swarm.Address, pushSyncService pushsync.PushSyncer, mockOpts ...mock.Option) (*tags.Tags, *pusher.Service, *Store) {
t.Helper() t.Helper()
logger := logging.New(ioutil.Discard, 0) logger := logging.New(ioutil.Discard, 0)
storer, err := localstore.New("", addr.Bytes(), nil, logger) storer, err := localstore.New("", addr.Bytes(), nil, nil, logger)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment