cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

Plumb contexts through

Browse Source
This commit is contained in:
Aayush Rajasekaran 2021-12-11 16:03:00 -05:00
parent 6c31cecc7d
commit dfb65ed89f
71 changed files with 595 additions and 577 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
blockstore/api.go
View File

@ -61,6 +61,6 @@ func (a *apiBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)
return nil, xerrors.New("not supported") return nil, xerrors.New("not supported")
} }
func (a *apiBlockstore) HashOnRead(ctx context.Context, enabled bool) { func (a *apiBlockstore) HashOnRead(enabled bool) {
return return
} }

2
blockstore/badger/blockstore.go
View File

@ -927,7 +927,7 @@ func (b *Blockstore) ForEachKey(f func(cid.Cid) error) error {
// HashOnRead implements Blockstore.HashOnRead. It is not supported by this // HashOnRead implements Blockstore.HashOnRead. It is not supported by this
// blockstore. // blockstore.
func (b *Blockstore) HashOnRead(ctx context.Context, _ bool) { func (b *Blockstore) HashOnRead(_ bool) {
log.Warnf("called HashOnRead on badger blockstore; function not supported; ignoring") log.Warnf("called HashOnRead on badger blockstore; function not supported; ignoring")
} }

6
blockstore/buffered.go
View File

@ -160,9 +160,9 @@ func (bs *BufferedBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error)
return bs.read.Has(ctx, c) return bs.read.Has(ctx, c)
} }
func (bs *BufferedBlockstore) HashOnRead(ctx context.Context, hor bool) { func (bs *BufferedBlockstore) HashOnRead(hor bool) {
bs.read.HashOnRead(ctx, hor) bs.read.HashOnRead(hor)
bs.write.HashOnRead(ctx, hor) bs.write.HashOnRead(hor)
} }
func (bs *BufferedBlockstore) PutMany(ctx context.Context, blks []block.Block) error { func (bs *BufferedBlockstore) PutMany(ctx context.Context, blks []block.Block) error {

4
blockstore/discard.go
View File

@ -22,8 +22,8 @@ func (b *discardstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
return b.bs.Has(ctx, cid) return b.bs.Has(ctx, cid)
} }
func (b *discardstore) HashOnRead(ctx context.Context, hor bool) { func (b *discardstore) HashOnRead(hor bool) {
b.bs.HashOnRead(ctx, hor) b.bs.HashOnRead(hor)
} }
func (b *discardstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) { func (b *discardstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {

4
blockstore/idstore.go
View File

@ -162,8 +162,8 @@ func (b *idstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
return b.bs.AllKeysChan(ctx) return b.bs.AllKeysChan(ctx)
} }
func (b *idstore) HashOnRead(ctx context.Context, enabled bool) { func (b *idstore) HashOnRead(enabled bool) {
b.bs.HashOnRead(ctx, enabled) b.bs.HashOnRead(enabled)
} }
func (b *idstore) Close() error { func (b *idstore) Close() error {

2
blockstore/ipfs.go
View File

@ -150,6 +150,6 @@ func (i *IPFSBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error
return nil, xerrors.Errorf("not supported") return nil, xerrors.Errorf("not supported")
} }
func (i *IPFSBlockstore) HashOnRead(ctx context.Context, enabled bool) { func (i *IPFSBlockstore) HashOnRead(enabled bool) {
return // TODO: We could technically support this, but.. return // TODO: We could technically support this, but..
} }

2
blockstore/mem.go
View File

@ -97,6 +97,6 @@ func (m MemBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error)
// HashOnRead specifies if every read block should be // HashOnRead specifies if every read block should be
// rehashed to make sure it matches its CID. // rehashed to make sure it matches its CID.
func (m MemBlockstore) HashOnRead(ctx context.Context, enabled bool) { func (m MemBlockstore) HashOnRead(enabled bool) {
// no-op // no-op
} }

46
blockstore/splitstore/splitstore.go
View File

@ -216,17 +216,17 @@ func Open(path string, ds dstore.Datastore, hot, cold bstore.Blockstore, cfg *Co
} }
// Blockstore interface // Blockstore interface
func (s *SplitStore) DeleteBlock(_ cid.Cid) error { func (s *SplitStore) DeleteBlock(_ context.Context, _ cid.Cid) error {
// afaict we don't seem to be using this method, so it's not implemented // afaict we don't seem to be using this method, so it's not implemented
return errors.New("DeleteBlock not implemented on SplitStore; don't do this Luke!") //nolint return errors.New("DeleteBlock not implemented on SplitStore; don't do this Luke!") //nolint
} }
func (s *SplitStore) DeleteMany(_ []cid.Cid) error { func (s *SplitStore) DeleteMany(_ context.Context, _ []cid.Cid) error {
// afaict we don't seem to be using this method, so it's not implemented // afaict we don't seem to be using this method, so it's not implemented
return errors.New("DeleteMany not implemented on SplitStore; don't do this Luke!") //nolint return errors.New("DeleteMany not implemented on SplitStore; don't do this Luke!") //nolint
} }
func (s *SplitStore) Has(cid cid.Cid) (bool, error) { func (s *SplitStore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
if isIdentiyCid(cid) { if isIdentiyCid(cid) {
return true, nil return true, nil
} }
@ -234,7 +234,7 @@ func (s *SplitStore) Has(cid cid.Cid) (bool, error) {
s.txnLk.RLock() s.txnLk.RLock()
defer s.txnLk.RUnlock() defer s.txnLk.RUnlock()
has, err := s.hot.Has(cid) has, err := s.hot.Has(ctx, cid)
if err != nil { if err != nil {
return has, err return has, err
@ -245,10 +245,10 @@ func (s *SplitStore) Has(cid cid.Cid) (bool, error) {
return true, nil return true, nil
} }
return s.cold.Has(cid) return s.cold.Has(ctx, cid)
} }
func (s *SplitStore) Get(cid cid.Cid) (blocks.Block, error) { func (s *SplitStore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
if isIdentiyCid(cid) { if isIdentiyCid(cid) {
data, err := decodeIdentityCid(cid) data, err := decodeIdentityCid(cid)
if err != nil { if err != nil {
@ -261,7 +261,7 @@ func (s *SplitStore) Get(cid cid.Cid) (blocks.Block, error) {
s.txnLk.RLock() s.txnLk.RLock()
defer s.txnLk.RUnlock() defer s.txnLk.RUnlock()
blk, err := s.hot.Get(cid) blk, err := s.hot.Get(ctx, cid)
switch err { switch err {
case nil: case nil:
@ -273,7 +273,7 @@ func (s *SplitStore) Get(cid cid.Cid) (blocks.Block, error) {
s.debug.LogReadMiss(cid) s.debug.LogReadMiss(cid)
} }
blk, err = s.cold.Get(cid) blk, err = s.cold.Get(ctx, cid)
if err == nil { if err == nil {
stats.Record(s.ctx, metrics.SplitstoreMiss.M(1)) stats.Record(s.ctx, metrics.SplitstoreMiss.M(1))
@ -285,7 +285,7 @@ func (s *SplitStore) Get(cid cid.Cid) (blocks.Block, error) {
} }
} }
func (s *SplitStore) GetSize(cid cid.Cid) (int, error) { func (s *SplitStore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
if isIdentiyCid(cid) { if isIdentiyCid(cid) {
data, err := decodeIdentityCid(cid) data, err := decodeIdentityCid(cid)
if err != nil { if err != nil {
@ -298,7 +298,7 @@ func (s *SplitStore) GetSize(cid cid.Cid) (int, error) {
s.txnLk.RLock() s.txnLk.RLock()
defer s.txnLk.RUnlock() defer s.txnLk.RUnlock()
size, err := s.hot.GetSize(cid) size, err := s.hot.GetSize(ctx, cid)
switch err { switch err {
case nil: case nil:
@ -310,7 +310,7 @@ func (s *SplitStore) GetSize(cid cid.Cid) (int, error) {
s.debug.LogReadMiss(cid) s.debug.LogReadMiss(cid)
} }
size, err = s.cold.GetSize(cid) size, err = s.cold.GetSize(ctx, cid)
if err == nil { if err == nil {
stats.Record(s.ctx, metrics.SplitstoreMiss.M(1)) stats.Record(s.ctx, metrics.SplitstoreMiss.M(1))
} }
@ -321,7 +321,7 @@ func (s *SplitStore) GetSize(cid cid.Cid) (int, error) {
} }
} }
func (s *SplitStore) Put(blk blocks.Block) error { func (s *SplitStore) Put(ctx context.Context, blk blocks.Block) error {
if isIdentiyCid(blk.Cid()) { if isIdentiyCid(blk.Cid()) {
return nil return nil
} }
@ -329,7 +329,7 @@ func (s *SplitStore) Put(blk blocks.Block) error {
s.txnLk.RLock() s.txnLk.RLock()
defer s.txnLk.RUnlock() defer s.txnLk.RUnlock()
err := s.hot.Put(blk) err := s.hot.Put(ctx, blk)
if err != nil { if err != nil {
return err return err
} }
@ -340,7 +340,7 @@ func (s *SplitStore) Put(blk blocks.Block) error {
return nil return nil
} }
func (s *SplitStore) PutMany(blks []blocks.Block) error { func (s *SplitStore) PutMany(ctx context.Context, blks []blocks.Block) error {
// filter identites // filter identites
idcids := 0 idcids := 0
for _, blk := range blks { for _, blk := range blks {
@ -374,7 +374,7 @@ func (s *SplitStore) PutMany(blks []blocks.Block) error {
s.txnLk.RLock() s.txnLk.RLock()
defer s.txnLk.RUnlock() defer s.txnLk.RUnlock()
err := s.hot.PutMany(blks) err := s.hot.PutMany(ctx, blks)
if err != nil { if err != nil {
return err return err
} }
@ -430,7 +430,7 @@ func (s *SplitStore) HashOnRead(enabled bool) {
s.cold.HashOnRead(enabled) s.cold.HashOnRead(enabled)
} }
func (s *SplitStore) View(cid cid.Cid, cb func([]byte) error) error { func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) error) error {
if isIdentiyCid(cid) { if isIdentiyCid(cid) {
data, err := decodeIdentityCid(cid) data, err := decodeIdentityCid(cid)
if err != nil { if err != nil {
@ -451,14 +451,14 @@ func (s *SplitStore) View(cid cid.Cid, cb func([]byte) error) error {
s.protectView(cid) s.protectView(cid)
defer s.viewDone() defer s.viewDone()
err := s.hot.View(cid, cb) err := s.hot.View(ctx, cid, cb)
switch err { switch err {
case bstore.ErrNotFound: case bstore.ErrNotFound:
if s.isWarm() { if s.isWarm() {
s.debug.LogReadMiss(cid) s.debug.LogReadMiss(cid)
} }
err = s.cold.View(cid, cb) err = s.cold.View(ctx, cid, cb)
if err == nil { if err == nil {
stats.Record(s.ctx, metrics.SplitstoreMiss.M(1)) stats.Record(s.ctx, metrics.SplitstoreMiss.M(1))
} }
@ -502,7 +502,7 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
// load base epoch from metadata ds // load base epoch from metadata ds
// if none, then use current epoch because it's a fresh start // if none, then use current epoch because it's a fresh start
bs, err := s.ds.Get(baseEpochKey) bs, err := s.ds.Get(s.ctx, baseEpochKey)
switch err { switch err {
case nil: case nil:
s.baseEpoch = bytesToEpoch(bs) s.baseEpoch = bytesToEpoch(bs)
@ -523,7 +523,7 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
} }
// load warmup epoch from metadata ds // load warmup epoch from metadata ds
bs, err = s.ds.Get(warmupEpochKey) bs, err = s.ds.Get(s.ctx, warmupEpochKey)
switch err { switch err {
case nil: case nil:
s.warmupEpoch = bytesToEpoch(bs) s.warmupEpoch = bytesToEpoch(bs)
@ -536,7 +536,7 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
} }
// load markSetSize from metadata ds to provide a size hint for marksets // load markSetSize from metadata ds to provide a size hint for marksets
bs, err = s.ds.Get(markSetSizeKey) bs, err = s.ds.Get(s.ctx, markSetSizeKey)
switch err { switch err {
case nil: case nil:
s.markSetSize = bytesToInt64(bs) s.markSetSize = bytesToInt64(bs)
@ -547,7 +547,7 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
} }
// load compactionIndex from metadata ds to provide a hint as to when to perform moving gc // load compactionIndex from metadata ds to provide a hint as to when to perform moving gc
bs, err = s.ds.Get(compactionIndexKey) bs, err = s.ds.Get(s.ctx, compactionIndexKey)
switch err { switch err {
case nil: case nil:
s.compactionIndex = bytesToInt64(bs) s.compactionIndex = bytesToInt64(bs)
@ -609,5 +609,5 @@ func (s *SplitStore) checkClosing() error {
func (s *SplitStore) setBaseEpoch(epoch abi.ChainEpoch) error { func (s *SplitStore) setBaseEpoch(epoch abi.ChainEpoch) error {
s.baseEpoch = epoch s.baseEpoch = epoch
return s.ds.Put(baseEpochKey, epochToBytes(epoch)) return s.ds.Put(s.ctx, baseEpochKey, epochToBytes(epoch))
} }

4
blockstore/splitstore/splitstore_check.go
View File

@ -96,7 +96,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
return errStopWalk return errStopWalk
} }
has, err := s.hot.Has(c) has, err := s.hot.Has(s.ctx, c)
if err != nil { if err != nil {
return xerrors.Errorf("error checking hotstore: %w", err) return xerrors.Errorf("error checking hotstore: %w", err)
} }
@ -105,7 +105,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
return nil return nil
} }
has, err = s.cold.Has(c) has, err = s.cold.Has(s.ctx, c)
if err != nil { if err != nil {
return xerrors.Errorf("error checking coldstore: %w", err) return xerrors.Errorf("error checking coldstore: %w", err)
} }

20
blockstore/splitstore/splitstore_compact.go
View File

@ -577,13 +577,13 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
return xerrors.Errorf("error saving base epoch: %w", err) return xerrors.Errorf("error saving base epoch: %w", err)
} }
err = s.ds.Put(markSetSizeKey, int64ToBytes(s.markSetSize)) err = s.ds.Put(s.ctx, markSetSizeKey, int64ToBytes(s.markSetSize))
if err != nil { if err != nil {
return xerrors.Errorf("error saving mark set size: %w", err) return xerrors.Errorf("error saving mark set size: %w", err)
} }
s.compactionIndex++ s.compactionIndex++
err = s.ds.Put(compactionIndexKey, int64ToBytes(s.compactionIndex)) err = s.ds.Put(s.ctx, compactionIndexKey, int64ToBytes(s.compactionIndex))
if err != nil { if err != nil {
return xerrors.Errorf("error saving compaction index: %w", err) return xerrors.Errorf("error saving compaction index: %w", err)
} }
@ -835,10 +835,10 @@ func (s *SplitStore) view(c cid.Cid, cb func([]byte) error) error {
return cb(data) return cb(data)
} }
err := s.hot.View(c, cb) err := s.hot.View(s.ctx, c, cb)
switch err { switch err {
case bstore.ErrNotFound: case bstore.ErrNotFound:
return s.cold.View(c, cb) return s.cold.View(s.ctx, c, cb)
default: default:
return err return err
@ -850,13 +850,13 @@ func (s *SplitStore) has(c cid.Cid) (bool, error) {
return true, nil return true, nil
} }
has, err := s.hot.Has(c) has, err := s.hot.Has(s.ctx, c)
if has || err != nil { if has || err != nil {
return has, err return has, err
} }
return s.cold.Has(c) return s.cold.Has(s.ctx, c)
} }
func (s *SplitStore) moveColdBlocks(cold []cid.Cid) error { func (s *SplitStore) moveColdBlocks(cold []cid.Cid) error {
@ -867,7 +867,7 @@ func (s *SplitStore) moveColdBlocks(cold []cid.Cid) error {
return err return err
} }
blk, err := s.hot.Get(c) blk, err := s.hot.Get(s.ctx, c)
if err != nil { if err != nil {
if err == bstore.ErrNotFound { if err == bstore.ErrNotFound {
log.Warnf("hotstore missing block %s", c) log.Warnf("hotstore missing block %s", c)
@ -879,7 +879,7 @@ func (s *SplitStore) moveColdBlocks(cold []cid.Cid) error {
batch = append(batch, blk) batch = append(batch, blk)
if len(batch) == batchSize { if len(batch) == batchSize {
err = s.cold.PutMany(batch) err = s.cold.PutMany(s.ctx, batch)
if err != nil { if err != nil {
return xerrors.Errorf("error putting batch to coldstore: %w", err) return xerrors.Errorf("error putting batch to coldstore: %w", err)
} }
@ -888,7 +888,7 @@ func (s *SplitStore) moveColdBlocks(cold []cid.Cid) error {
} }
if len(batch) > 0 { if len(batch) > 0 {
err := s.cold.PutMany(batch) err := s.cold.PutMany(s.ctx, batch)
if err != nil { if err != nil {
return xerrors.Errorf("error putting batch to coldstore: %w", err) return xerrors.Errorf("error putting batch to coldstore: %w", err)
} }
@ -1058,7 +1058,7 @@ func (s *SplitStore) purge(cids []cid.Cid, markSet MarkSetVisitor) error {
deadCids = append(deadCids, c) deadCids = append(deadCids, c)
} }
err := s.hot.DeleteMany(deadCids) err := s.hot.DeleteMany(s.ctx, deadCids)
if err != nil { if err != nil {
return xerrors.Errorf("error purging cold objects: %w", err) return xerrors.Errorf("error purging cold objects: %w", err)
} }

36
blockstore/splitstore/splitstore_expose.go
View File

@ -20,28 +20,28 @@ func (s *SplitStore) Expose() bstore.Blockstore {
return &exposedSplitStore{s: s} return &exposedSplitStore{s: s}
} }
func (es *exposedSplitStore) DeleteBlock(_ cid.Cid) error { func (es *exposedSplitStore) DeleteBlock(_ context.Context, _ cid.Cid) error {
return errors.New("DeleteBlock: operation not supported") return errors.New("DeleteBlock: operation not supported")
} }
func (es *exposedSplitStore) DeleteMany(_ []cid.Cid) error { func (es *exposedSplitStore) DeleteMany(_ context.Context, _ []cid.Cid) error {
return errors.New("DeleteMany: operation not supported") return errors.New("DeleteMany: operation not supported")
} }
func (es *exposedSplitStore) Has(c cid.Cid) (bool, error) { func (es *exposedSplitStore) Has(ctx context.Context, c cid.Cid) (bool, error) {
if isIdentiyCid(c) { if isIdentiyCid(c) {
return true, nil return true, nil
} }
has, err := es.s.hot.Has(c) has, err := es.s.hot.Has(ctx, c)
if has || err != nil { if has || err != nil {
return has, err return has, err
} }
return es.s.cold.Has(c) return es.s.cold.Has(ctx, c)
} }
func (es *exposedSplitStore) Get(c cid.Cid) (blocks.Block, error) { func (es *exposedSplitStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error) {
if isIdentiyCid(c) { if isIdentiyCid(c) {
data, err := decodeIdentityCid(c) data, err := decodeIdentityCid(c)
if err != nil { if err != nil {
@ -51,16 +51,16 @@ func (es *exposedSplitStore) Get(c cid.Cid) (blocks.Block, error) {
return blocks.NewBlockWithCid(data, c) return blocks.NewBlockWithCid(data, c)
} }
blk, err := es.s.hot.Get(c) blk, err := es.s.hot.Get(ctx, c)
switch err { switch err {
case bstore.ErrNotFound: case bstore.ErrNotFound:
return es.s.cold.Get(c) return es.s.cold.Get(ctx, c)
default: default:
return blk, err return blk, err
} }
} }
func (es *exposedSplitStore) GetSize(c cid.Cid) (int, error) { func (es *exposedSplitStore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
if isIdentiyCid(c) { if isIdentiyCid(c) {
data, err := decodeIdentityCid(c) data, err := decodeIdentityCid(c)
if err != nil { if err != nil {
@ -70,21 +70,21 @@ func (es *exposedSplitStore) GetSize(c cid.Cid) (int, error) {
return len(data), nil return len(data), nil
} }
size, err := es.s.hot.GetSize(c) size, err := es.s.hot.GetSize(ctx, c)
switch err { switch err {
case bstore.ErrNotFound: case bstore.ErrNotFound:
return es.s.cold.GetSize(c) return es.s.cold.GetSize(ctx, c)
default: default:
return size, err return size, err
} }
} }
func (es *exposedSplitStore) Put(blk blocks.Block) error { func (es *exposedSplitStore) Put(ctx context.Context, blk blocks.Block) error {
return es.s.Put(blk) return es.s.Put(ctx, blk)
} }
func (es *exposedSplitStore) PutMany(blks []blocks.Block) error { func (es *exposedSplitStore) PutMany(ctx context.Context, blks []blocks.Block) error {
return es.s.PutMany(blks) return es.s.PutMany(ctx, blks)
} }
func (es *exposedSplitStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) { func (es *exposedSplitStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
@ -93,7 +93,7 @@ func (es *exposedSplitStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, e
func (es *exposedSplitStore) HashOnRead(enabled bool) {} func (es *exposedSplitStore) HashOnRead(enabled bool) {}
func (es *exposedSplitStore) View(c cid.Cid, f func([]byte) error) error { func (es *exposedSplitStore) View(ctx context.Context, c cid.Cid, f func([]byte) error) error {
if isIdentiyCid(c) { if isIdentiyCid(c) {
data, err := decodeIdentityCid(c) data, err := decodeIdentityCid(c)
if err != nil { if err != nil {
@ -103,10 +103,10 @@ func (es *exposedSplitStore) View(c cid.Cid, f func([]byte) error) error {
return f(data) return f(data)
} }
err := es.s.hot.View(c, f) err := es.s.hot.View(ctx, c, f)
switch err { switch err {
case bstore.ErrNotFound: case bstore.ErrNotFound:
return es.s.cold.View(c, f) return es.s.cold.View(ctx, c, f)
default: default:
return err return err

14
blockstore/splitstore/splitstore_warmup.go
View File

@ -75,7 +75,7 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
count++ count++
has, err := s.hot.Has(c) has, err := s.hot.Has(s.ctx, c)
if err != nil { if err != nil {
return err return err
} }
@ -84,7 +84,7 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
return nil return nil
} }
blk, err := s.cold.Get(c) blk, err := s.cold.Get(s.ctx, c)
if err != nil { if err != nil {
if err == bstore.ErrNotFound { if err == bstore.ErrNotFound {
missing++ missing++
@ -97,7 +97,7 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
batchHot = append(batchHot, blk) batchHot = append(batchHot, blk)
if len(batchHot) == batchSize { if len(batchHot) == batchSize {
err = s.hot.PutMany(batchHot) err = s.hot.PutMany(s.ctx, batchHot)
if err != nil { if err != nil {
return err return err
} }
@ -112,7 +112,7 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
} }
if len(batchHot) > 0 { if len(batchHot) > 0 {
err = s.hot.PutMany(batchHot) err = s.hot.PutMany(s.ctx, batchHot)
if err != nil { if err != nil {
return err return err
} }
@ -121,13 +121,13 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
log.Infow("warmup stats", "visited", count, "warm", xcount, "missing", missing) log.Infow("warmup stats", "visited", count, "warm", xcount, "missing", missing)
s.markSetSize = count + count>>2 // overestimate a bit s.markSetSize = count + count>>2 // overestimate a bit
err = s.ds.Put(markSetSizeKey, int64ToBytes(s.markSetSize)) err = s.ds.Put(s.ctx, markSetSizeKey, int64ToBytes(s.markSetSize))
if err != nil { if err != nil {
log.Warnf("error saving mark set size: %s", err) log.Warnf("error saving mark set size: %s", err)
} }
// save the warmup epoch // save the warmup epoch
err = s.ds.Put(warmupEpochKey, epochToBytes(epoch)) err = s.ds.Put(s.ctx, warmupEpochKey, epochToBytes(epoch))
if err != nil { if err != nil {
return xerrors.Errorf("error saving warm up epoch: %w", err) return xerrors.Errorf("error saving warm up epoch: %w", err)
} }
@ -136,7 +136,7 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
s.mx.Unlock() s.mx.Unlock()
// also save the compactionIndex, as this is used as an indicator of warmup for upgraded nodes // also save the compactionIndex, as this is used as an indicator of warmup for upgraded nodes
err = s.ds.Put(compactionIndexKey, int64ToBytes(s.compactionIndex)) err = s.ds.Put(s.ctx, compactionIndexKey, int64ToBytes(s.compactionIndex))
if err != nil { if err != nil {
return xerrors.Errorf("error saving compaction index: %w", err) return xerrors.Errorf("error saving compaction index: %w", err)
} }

2
blockstore/sync.go
View File

@ -76,6 +76,6 @@ func (m *SyncBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error
return m.bs.AllKeysChan(ctx) return m.bs.AllKeysChan(ctx)
} }
func (m *SyncBlockstore) HashOnRead(ctx context.Context, enabled bool) { func (m *SyncBlockstore) HashOnRead(enabled bool) {
// noop // noop
} }

4
blockstore/union.go
View File

@ -112,8 +112,8 @@ func (m unionBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error
return outCh, nil return outCh, nil
} }
func (m unionBlockstore) HashOnRead(ctx context.Context, enabled bool) { func (m unionBlockstore) HashOnRead(enabled bool) {
for _, bs := range m { for _, bs := range m {
bs.HashOnRead(ctx, enabled) bs.HashOnRead(enabled)
} }
} }

8
chain/checkpoint.go
View File

@ -13,7 +13,7 @@ func (syncer *Syncer) SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) e
return xerrors.Errorf("called with empty tsk") return xerrors.Errorf("called with empty tsk")
} }
ts, err := syncer.ChainStore().LoadTipSet(tsk) ts, err := syncer.ChainStore().LoadTipSet(ctx, tsk)
if err != nil { if err != nil {
tss, err := syncer.Exchange.GetBlocks(ctx, tsk, 1) tss, err := syncer.Exchange.GetBlocks(ctx, tsk, 1)
if err != nil { if err != nil {
@ -28,7 +28,7 @@ func (syncer *Syncer) SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) e
return xerrors.Errorf("failed to switch chain when syncing checkpoint: %w", err) return xerrors.Errorf("failed to switch chain when syncing checkpoint: %w", err)
} }
if err := syncer.ChainStore().SetCheckpoint(ts); err != nil { if err := syncer.ChainStore().SetCheckpoint(ctx, ts); err != nil {
return xerrors.Errorf("failed to set the chain checkpoint: %w", err) return xerrors.Errorf("failed to set the chain checkpoint: %w", err)
} }
@ -41,7 +41,7 @@ func (syncer *Syncer) switchChain(ctx context.Context, ts *types.TipSet) error {
return nil return nil
} }
if anc, err := syncer.store.IsAncestorOf(ts, hts); err == nil && anc { if anc, err := syncer.store.IsAncestorOf(ctx, ts, hts); err == nil && anc {
return nil return nil
} }
@ -50,7 +50,7 @@ func (syncer *Syncer) switchChain(ctx context.Context, ts *types.TipSet) error {
return xerrors.Errorf("failed to collect chain for checkpoint: %w", err) return xerrors.Errorf("failed to collect chain for checkpoint: %w", err)
} }
if err := syncer.ChainStore().SetHead(ts); err != nil { if err := syncer.ChainStore().SetHead(ctx, ts); err != nil {
return xerrors.Errorf("failed to set the chain head: %w", err) return xerrors.Errorf("failed to set the chain head: %w", err)
} }
return nil return nil

2
chain/consensus/filcns/compute_state.go
View File

@ -289,7 +289,7 @@ func (t *TipSetExecutor) ExecuteTipSet(ctx context.Context, sm *stmgr.StateManag
var parentEpoch abi.ChainEpoch var parentEpoch abi.ChainEpoch
pstate := blks[0].ParentStateRoot pstate := blks[0].ParentStateRoot
if blks[0].Height > 0 { if blks[0].Height > 0 {
parent, err := sm.ChainStore().GetBlock(blks[0].Parents[0]) parent, err := sm.ChainStore().GetBlock(ctx, blks[0].Parents[0])
if err != nil { if err != nil {
return cid.Undef, cid.Undef, xerrors.Errorf("getting parent block: %w", err) return cid.Undef, cid.Undef, xerrors.Errorf("getting parent block: %w", err)
} }

4
chain/consensus/filcns/filecoin.go
View File

@ -90,7 +90,7 @@ func (filec *FilecoinEC) ValidateBlock(ctx context.Context, b *types.FullBlock)
h := b.Header h := b.Header
baseTs, err := filec.store.LoadTipSet(types.NewTipSetKey(h.Parents...)) baseTs, err := filec.store.LoadTipSet(ctx, types.NewTipSetKey(h.Parents...))
if err != nil { if err != nil {
return xerrors.Errorf("load parent tipset failed (%s): %w", h.Parents, err) return xerrors.Errorf("load parent tipset failed (%s): %w", h.Parents, err)
} }
@ -102,7 +102,7 @@ func (filec *FilecoinEC) ValidateBlock(ctx context.Context, b *types.FullBlock)
return xerrors.Errorf("failed to get lookback tipset for block: %w", err) return xerrors.Errorf("failed to get lookback tipset for block: %w", err)
} }
prevBeacon, err := filec.store.GetLatestBeaconEntry(baseTs) prevBeacon, err := filec.store.GetLatestBeaconEntry(ctx, baseTs)
if err != nil { if err != nil {
return xerrors.Errorf("failed to get latest beacon entry: %w", err) return xerrors.Errorf("failed to get latest beacon entry: %w", err)
} }

2
chain/consensus/filcns/mine.go
View File

@ -15,7 +15,7 @@ import (
) )
func (filec *FilecoinEC) CreateBlock(ctx context.Context, w api.Wallet, bt *api.BlockTemplate) (*types.FullBlock, error) { func (filec *FilecoinEC) CreateBlock(ctx context.Context, w api.Wallet, bt *api.BlockTemplate) (*types.FullBlock, error) {
pts, err := filec.sm.ChainStore().LoadTipSet(bt.Parents) pts, err := filec.sm.ChainStore().LoadTipSet(ctx, bt.Parents)
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load parent tipset: %w", err) return nil, xerrors.Errorf("failed to load parent tipset: %w", err)
} }

2
chain/consensus/filcns/upgrades.go
View File

@ -625,7 +625,7 @@ func splitGenesisMultisig0(ctx context.Context, em stmgr.ExecMonitor, addr addre
// TODO: After the Liftoff epoch, refactor this to use resetMultisigVesting // TODO: After the Liftoff epoch, refactor this to use resetMultisigVesting
func resetGenesisMsigs0(ctx context.Context, sm *stmgr.StateManager, store adt0.Store, tree *state.StateTree, startEpoch abi.ChainEpoch) error { func resetGenesisMsigs0(ctx context.Context, sm *stmgr.StateManager, store adt0.Store, tree *state.StateTree, startEpoch abi.ChainEpoch) error {
gb, err := sm.ChainStore().GetGenesis() gb, err := sm.ChainStore().GetGenesis(ctx)
if err != nil { if err != nil {
return xerrors.Errorf("getting genesis block: %w", err) return xerrors.Errorf("getting genesis block: %w", err)
} }

6
chain/exchange/server.go
View File

@ -136,7 +136,7 @@ func (s *server) serviceRequest(ctx context.Context, req *validatedRequest) (*Re
_, span := trace.StartSpan(ctx, "chainxchg.ServiceRequest") _, span := trace.StartSpan(ctx, "chainxchg.ServiceRequest")
defer span.End() defer span.End()
chain, err := collectChainSegment(s.cs, req) chain, err := collectChainSegment(ctx, s.cs, req)
if err != nil { if err != nil {
log.Warn("block sync request: collectChainSegment failed: ", err) log.Warn("block sync request: collectChainSegment failed: ", err)
return &Response{ return &Response{
@ -156,13 +156,13 @@ func (s *server) serviceRequest(ctx context.Context, req *validatedRequest) (*Re
}, nil }, nil
} }
func collectChainSegment(cs *store.ChainStore, req *validatedRequest) ([]*BSTipSet, error) { func collectChainSegment(ctx context.Context, cs *store.ChainStore, req *validatedRequest) ([]*BSTipSet, error) {
var bstips []*BSTipSet var bstips []*BSTipSet
cur := req.head cur := req.head
for { for {
var bst BSTipSet var bst BSTipSet
ts, err := cs.LoadTipSet(cur) ts, err := cs.LoadTipSet(ctx, cur)
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed loading tipset %s: %w", cur, err) return nil, xerrors.Errorf("failed loading tipset %s: %w", cur, err)
} }

4
chain/gen/gen.go
View File

@ -239,7 +239,7 @@ func NewGeneratorWithSectorsAndUpgradeSchedule(numSectors int, us stmgr.UpgradeS
genfb := &types.FullBlock{Header: genb.Genesis} genfb := &types.FullBlock{Header: genb.Genesis}
gents := store.NewFullTipSet([]*types.FullBlock{genfb}) gents := store.NewFullTipSet([]*types.FullBlock{genfb})
if err := cs.SetGenesis(genb.Genesis); err != nil { if err := cs.SetGenesis(context.TODO(), genb.Genesis); err != nil {
return nil, xerrors.Errorf("set genesis failed: %w", err) return nil, xerrors.Errorf("set genesis failed: %w", err)
} }
@ -469,7 +469,7 @@ func (cg *ChainGen) NextTipSetFromMinersWithMessagesAndNulls(base *types.TipSet,
return nil, xerrors.Errorf("making a block for next tipset failed: %w", err) return nil, xerrors.Errorf("making a block for next tipset failed: %w", err)
} }
if err := cg.cs.PersistBlockHeaders(fblk.Header); err != nil { if err := cg.cs.PersistBlockHeaders(context.TODO(), fblk.Header); err != nil {
return nil, xerrors.Errorf("chainstore AddBlock: %w", err) return nil, xerrors.Errorf("chainstore AddBlock: %w", err)
} }

6
chain/gen/genesis/genesis.go
View File

@ -591,7 +591,7 @@ func MakeGenesisBlock(ctx context.Context, j journal.Journal, bs bstore.Blocksto
if err != nil { if err != nil {
return nil, xerrors.Errorf("serializing msgmeta failed: %w", err) return nil, xerrors.Errorf("serializing msgmeta failed: %w", err)
} }
if err := bs.Put(mmb); err != nil { if err := bs.Put(ctx, mmb); err != nil {
return nil, xerrors.Errorf("putting msgmeta block to blockstore: %w", err) return nil, xerrors.Errorf("putting msgmeta block to blockstore: %w", err)
} }
@ -621,7 +621,7 @@ func MakeGenesisBlock(ctx context.Context, j journal.Journal, bs bstore.Blocksto
return nil, xerrors.Errorf("filecoinGenesisCid != gblk.Cid") return nil, xerrors.Errorf("filecoinGenesisCid != gblk.Cid")
} }
if err := bs.Put(gblk); err != nil { if err := bs.Put(ctx, gblk); err != nil {
return nil, xerrors.Errorf("failed writing filecoin genesis block to blockstore: %w", err) return nil, xerrors.Errorf("failed writing filecoin genesis block to blockstore: %w", err)
} }
@ -652,7 +652,7 @@ func MakeGenesisBlock(ctx context.Context, j journal.Journal, bs bstore.Blocksto
return nil, xerrors.Errorf("serializing block header failed: %w", err) return nil, xerrors.Errorf("serializing block header failed: %w", err)
} }
if err := bs.Put(sb); err != nil { if err := bs.Put(ctx, sb); err != nil {
return nil, xerrors.Errorf("putting header to blockstore: %w", err) return nil, xerrors.Errorf("putting header to blockstore: %w", err)
} }

21
chain/gen/slashfilter/slashfilter.go
View File

@ -1,6 +1,7 @@
package slashfilter package slashfilter
import ( import (
"context"
"fmt" "fmt"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
@ -27,7 +28,7 @@ func New(dstore ds.Batching) *SlashFilter {
} }
} }
func (f *SlashFilter) MinedBlock(bh *types.BlockHeader, parentEpoch abi.ChainEpoch) error { func (f *SlashFilter) MinedBlock(ctx context.Context, bh *types.BlockHeader, parentEpoch abi.ChainEpoch) error {
if build.IsNearUpgrade(bh.Height, build.UpgradeOrangeHeight) { if build.IsNearUpgrade(bh.Height, build.UpgradeOrangeHeight) {
return nil return nil
} }
@ -35,7 +36,7 @@ func (f *SlashFilter) MinedBlock(bh *types.BlockHeader, parentEpoch abi.ChainEpo
epochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, bh.Height)) epochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, bh.Height))
{ {
// double-fork mining (2 blocks at one epoch) // double-fork mining (2 blocks at one epoch)
if err := checkFault(f.byEpoch, epochKey, bh, "double-fork mining faults"); err != nil { if err := checkFault(ctx, f.byEpoch, epochKey, bh, "double-fork mining faults"); err != nil {
return err return err
} }
} }
@ -43,7 +44,7 @@ func (f *SlashFilter) MinedBlock(bh *types.BlockHeader, parentEpoch abi.ChainEpo
parentsKey := ds.NewKey(fmt.Sprintf("/%s/%x", bh.Miner, types.NewTipSetKey(bh.Parents...).Bytes())) parentsKey := ds.NewKey(fmt.Sprintf("/%s/%x", bh.Miner, types.NewTipSetKey(bh.Parents...).Bytes()))
{ {
// time-offset mining faults (2 blocks with the same parents) // time-offset mining faults (2 blocks with the same parents)
if err := checkFault(f.byParents, parentsKey, bh, "time-offset mining faults"); err != nil { if err := checkFault(ctx, f.byParents, parentsKey, bh, "time-offset mining faults"); err != nil {
return err return err
} }
} }
@ -53,14 +54,14 @@ func (f *SlashFilter) MinedBlock(bh *types.BlockHeader, parentEpoch abi.ChainEpo
// First check if we have mined a block on the parent epoch // First check if we have mined a block on the parent epoch
parentEpochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, parentEpoch)) parentEpochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, parentEpoch))
have, err := f.byEpoch.Has(parentEpochKey) have, err := f.byEpoch.Has(ctx, parentEpochKey)
if err != nil { if err != nil {
return err return err
} }
if have { if have {
// If we had, make sure it's in our parent tipset // If we had, make sure it's in our parent tipset
cidb, err := f.byEpoch.Get(parentEpochKey) cidb, err := f.byEpoch.Get(ctx, parentEpochKey)
if err != nil { if err != nil {
return xerrors.Errorf("getting other block cid: %w", err) return xerrors.Errorf("getting other block cid: %w", err)
} }
@ -83,25 +84,25 @@ func (f *SlashFilter) MinedBlock(bh *types.BlockHeader, parentEpoch abi.ChainEpo
} }
} }
if err := f.byParents.Put(parentsKey, bh.Cid().Bytes()); err != nil { if err := f.byParents.Put(ctx, parentsKey, bh.Cid().Bytes()); err != nil {
return xerrors.Errorf("putting byEpoch entry: %w", err) return xerrors.Errorf("putting byEpoch entry: %w", err)
} }
if err := f.byEpoch.Put(epochKey, bh.Cid().Bytes()); err != nil { if err := f.byEpoch.Put(ctx, epochKey, bh.Cid().Bytes()); err != nil {
return xerrors.Errorf("putting byEpoch entry: %w", err) return xerrors.Errorf("putting byEpoch entry: %w", err)
} }
return nil return nil
} }
func checkFault(t ds.Datastore, key ds.Key, bh *types.BlockHeader, faultType string) error { func checkFault(ctx context.Context, t ds.Datastore, key ds.Key, bh *types.BlockHeader, faultType string) error {
fault, err := t.Has(key) fault, err := t.Has(ctx, key)
if err != nil { if err != nil {
return err return err
} }
if fault { if fault {
cidb, err := t.Get(key) cidb, err := t.Get(ctx, key)
if err != nil { if err != nil {
return xerrors.Errorf("getting other block cid: %w", err) return xerrors.Errorf("getting other block cid: %w", err)
} }

4
chain/market/fundmanager.go
View File

@ -89,7 +89,7 @@ func (fm *FundManager) Start() error {
// - in State() only load addresses with in-progress messages // - in State() only load addresses with in-progress messages
// - load the others just-in-time from getFundedAddress // - load the others just-in-time from getFundedAddress
// - delete(fm.fundedAddrs, addr) when the queue has been processed // - delete(fm.fundedAddrs, addr) when the queue has been processed
return fm.str.forEach(func(state *FundedAddressState) { return fm.str.forEach(fm.ctx, func(state *FundedAddressState) {
fa := newFundedAddress(fm, state.Addr) fa := newFundedAddress(fm, state.Addr)
fa.state = state fa.state = state
fm.fundedAddrs[fa.state.Addr] = fa fm.fundedAddrs[fa.state.Addr] = fa
@ -322,7 +322,7 @@ func (a *fundedAddress) clearWaitState() {
// Save state to datastore // Save state to datastore
func (a *fundedAddress) saveState() { func (a *fundedAddress) saveState() {
// Not much we can do if saving to the datastore fails, just log // Not much we can do if saving to the datastore fails, just log
err := a.str.save(a.state) err := a.str.save(a.ctx, a.state)
if err != nil { if err != nil {
log.Errorf("saving state to store for addr %s: %v", a.state.Addr, err) log.Errorf("saving state to store for addr %s: %v", a.state.Addr, err)
} }

13
chain/market/store.go
View File

@ -2,6 +2,7 @@ package market
import ( import (
"bytes" "bytes"
"context"
cborrpc "github.com/filecoin-project/go-cbor-util" cborrpc "github.com/filecoin-project/go-cbor-util"
"github.com/ipfs/go-datastore" "github.com/ipfs/go-datastore"
@ -27,7 +28,7 @@ func newStore(ds dtypes.MetadataDS) *Store {
} }
// save the state to the datastore // save the state to the datastore
func (ps *Store) save(state *FundedAddressState) error { func (ps *Store) save(ctx context.Context, state *FundedAddressState) error {
k := dskeyForAddr(state.Addr) k := dskeyForAddr(state.Addr)
b, err := cborrpc.Dump(state) b, err := cborrpc.Dump(state)
@ -35,14 +36,14 @@ func (ps *Store) save(state *FundedAddressState) error {
return err return err
} }
return ps.ds.Put(k, b) return ps.ds.Put(ctx, k, b)
} }
// get the state for the given address // get the state for the given address
func (ps *Store) get(addr address.Address) (*FundedAddressState, error) { func (ps *Store) get(ctx context.Context, addr address.Address) (*FundedAddressState, error) {
k := dskeyForAddr(addr) k := dskeyForAddr(addr)
data, err := ps.ds.Get(k) data, err := ps.ds.Get(ctx, k)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -56,8 +57,8 @@ func (ps *Store) get(addr address.Address) (*FundedAddressState, error) {
} }
// forEach calls iter with each address in the datastore // forEach calls iter with each address in the datastore
func (ps *Store) forEach(iter func(*FundedAddressState)) error { func (ps *Store) forEach(ctx context.Context, iter func(*FundedAddressState)) error {
res, err := ps.ds.Query(dsq.Query{Prefix: dsKeyAddr}) res, err := ps.ds.Query(ctx, dsq.Query{Prefix: dsKeyAddr})
if err != nil { if err != nil {
return err return err
} }

15
chain/messagepool/config.go
View File

@ -1,6 +1,7 @@
package messagepool package messagepool
import ( import (
"context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"time" "time"
@ -20,8 +21,8 @@ var (
ConfigKey = datastore.NewKey("/mpool/config") ConfigKey = datastore.NewKey("/mpool/config")
) )
func loadConfig(ds dtypes.MetadataDS) (*types.MpoolConfig, error) { func loadConfig(ctx context.Context, ds dtypes.MetadataDS) (*types.MpoolConfig, error) {
haveCfg, err := ds.Has(ConfigKey) haveCfg, err := ds.Has(ctx, ConfigKey)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -30,7 +31,7 @@ func loadConfig(ds dtypes.MetadataDS) (*types.MpoolConfig, error) {
return DefaultConfig(), nil return DefaultConfig(), nil
} }
cfgBytes, err := ds.Get(ConfigKey) cfgBytes, err := ds.Get(ctx, ConfigKey)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -39,12 +40,12 @@ func loadConfig(ds dtypes.MetadataDS) (*types.MpoolConfig, error) {
return cfg, err return cfg, err
} }
func saveConfig(cfg *types.MpoolConfig, ds dtypes.MetadataDS) error { func saveConfig(ctx context.Context, cfg *types.MpoolConfig, ds dtypes.MetadataDS) error {
cfgBytes, err := json.Marshal(cfg) cfgBytes, err := json.Marshal(cfg)
if err != nil { if err != nil {
return err return err
} }
return ds.Put(ConfigKey, cfgBytes) return ds.Put(ctx, ConfigKey, cfgBytes)
} }
func (mp *MessagePool) GetConfig() *types.MpoolConfig { func (mp *MessagePool) GetConfig() *types.MpoolConfig {
@ -68,7 +69,7 @@ func validateConfg(cfg *types.MpoolConfig) error {
return nil return nil
} }
func (mp *MessagePool) SetConfig(cfg *types.MpoolConfig) error { func (mp *MessagePool) SetConfig(ctx context.Context, cfg *types.MpoolConfig) error {
if err := validateConfg(cfg); err != nil { if err := validateConfg(cfg); err != nil {
return err return err
} }
@ -76,7 +77,7 @@ func (mp *MessagePool) SetConfig(cfg *types.MpoolConfig) error {
mp.cfgLk.Lock() mp.cfgLk.Lock()
mp.cfg = cfg mp.cfg = cfg
err := saveConfig(cfg, mp.ds) err := saveConfig(ctx, cfg, mp.ds)
if err != nil { if err != nil {
log.Warnf("error persisting mpool config: %s", err) log.Warnf("error persisting mpool config: %s", err)
} }

16
chain/messagepool/messagepool.go
View File

@ -358,11 +358,11 @@ func (ms *msgSet) toSlice() []*types.SignedMessage {
return set return set
} }
func New(api Provider, ds dtypes.MetadataDS, us stmgr.UpgradeSchedule, netName dtypes.NetworkName, j journal.Journal) (*MessagePool, error) { func New(ctx context.Context, api Provider, ds dtypes.MetadataDS, us stmgr.UpgradeSchedule, netName dtypes.NetworkName, j journal.Journal) (*MessagePool, error) {
cache, _ := lru.New2Q(build.BlsSignatureCacheSize) cache, _ := lru.New2Q(build.BlsSignatureCacheSize)
verifcache, _ := lru.New2Q(build.VerifSigCacheSize) verifcache, _ := lru.New2Q(build.VerifSigCacheSize)
cfg, err := loadConfig(ds) cfg, err := loadConfig(ctx, ds)
if err != nil { if err != nil {
return nil, xerrors.Errorf("error loading mpool config: %w", err) return nil, xerrors.Errorf("error loading mpool config: %w", err)
} }
@ -601,7 +601,7 @@ func (mp *MessagePool) addLocal(ctx context.Context, m *types.SignedMessage) err
return xerrors.Errorf("error serializing message: %w", err) return xerrors.Errorf("error serializing message: %w", err)
} }
if err := mp.localMsgs.Put(datastore.NewKey(string(m.Cid().Bytes())), msgb); err != nil { if err := mp.localMsgs.Put(ctx, datastore.NewKey(string(m.Cid().Bytes())), msgb); err != nil {
return xerrors.Errorf("persisting local message: %w", err) return xerrors.Errorf("persisting local message: %w", err)
} }
@ -1207,7 +1207,7 @@ func (mp *MessagePool) HeadChange(ctx context.Context, revert []*types.TipSet, a
var merr error var merr error
for _, ts := range revert { for _, ts := range revert {
pts, err := mp.api.LoadTipSet(ts.Parents()) pts, err := mp.api.LoadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
log.Errorf("error loading reverted tipset parent: %s", err) log.Errorf("error loading reverted tipset parent: %s", err)
merr = multierror.Append(merr, err) merr = multierror.Append(merr, err)
@ -1338,7 +1338,7 @@ func (mp *MessagePool) HeadChange(ctx context.Context, revert []*types.TipSet, a
return merr return merr
} }
func (mp *MessagePool) runHeadChange(from *types.TipSet, to *types.TipSet, rmsgs map[address.Address]map[uint64]*types.SignedMessage) error { func (mp *MessagePool) runHeadChange(ctx context.Context, from *types.TipSet, to *types.TipSet, rmsgs map[address.Address]map[uint64]*types.SignedMessage) error {
add := func(m *types.SignedMessage) { add := func(m *types.SignedMessage) {
s, ok := rmsgs[m.Message.From] s, ok := rmsgs[m.Message.From]
if !ok { if !ok {
@ -1360,7 +1360,7 @@ func (mp *MessagePool) runHeadChange(from *types.TipSet, to *types.TipSet, rmsgs
} }
revert, apply, err := store.ReorgOps(mp.api.LoadTipSet, from, to) revert, apply, err := store.ReorgOps(ctx, mp.api.LoadTipSet, from, to)
if err != nil { if err != nil {
return xerrors.Errorf("failed to compute reorg ops for mpool pending messages: %w", err) return xerrors.Errorf("failed to compute reorg ops for mpool pending messages: %w", err)
} }
@ -1477,7 +1477,7 @@ func (mp *MessagePool) Updates(ctx context.Context) (<-chan api.MpoolUpdate, err
} }
func (mp *MessagePool) loadLocal(ctx context.Context) error { func (mp *MessagePool) loadLocal(ctx context.Context) error {
res, err := mp.localMsgs.Query(query.Query{}) res, err := mp.localMsgs.Query(ctx, query.Query{})
if err != nil { if err != nil {
return xerrors.Errorf("query local messages: %w", err) return xerrors.Errorf("query local messages: %w", err)
} }
@ -1525,7 +1525,7 @@ func (mp *MessagePool) Clear(ctx context.Context, local bool) {
if ok { if ok {
for _, m := range mset.msgs { for _, m := range mset.msgs {
err := mp.localMsgs.Delete(datastore.NewKey(string(m.Cid().Bytes()))) err := mp.localMsgs.Delete(ctx, datastore.NewKey(string(m.Cid().Bytes())))
if err != nil { if err != nil {
log.Warnf("error deleting local message: %s", err) log.Warnf("error deleting local message: %s", err)
} }

6
chain/messagepool/provider.go
View File

@ -29,7 +29,7 @@ type Provider interface {
StateAccountKeyAtFinality(context.Context, address.Address, *types.TipSet) (address.Address, error) StateAccountKeyAtFinality(context.Context, address.Address, *types.TipSet) (address.Address, error)
MessagesForBlock(*types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) MessagesForBlock(*types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error)
MessagesForTipset(*types.TipSet) ([]types.ChainMsg, error) MessagesForTipset(*types.TipSet) ([]types.ChainMsg, error)
LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) LoadTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error) ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error)
IsLite() bool IsLite() bool
} }
@ -111,8 +111,8 @@ func (mpp *mpoolProvider) MessagesForTipset(ts *types.TipSet) ([]types.ChainMsg,
return mpp.sm.ChainStore().MessagesForTipset(ts) return mpp.sm.ChainStore().MessagesForTipset(ts)
} }
func (mpp *mpoolProvider) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) { func (mpp *mpoolProvider) LoadTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
return mpp.sm.ChainStore().LoadTipSet(tsk) return mpp.sm.ChainStore().LoadTipSet(ctx, tsk)
} }
func (mpp *mpoolProvider) ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error) { func (mpp *mpoolProvider) ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {

2
chain/messagepool/pruning.go
View File

@ -49,7 +49,7 @@ func (mp *MessagePool) pruneMessages(ctx context.Context, ts *types.TipSet) erro
} }
baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactor) baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactor)
pending, _ := mp.getPendingMessages(ts, ts) pending, _ := mp.getPendingMessages(ctx, ts, ts)
// protected actors -- not pruned // protected actors -- not pruned
protected := make(map[address.Address]struct{}) protected := make(map[address.Address]struct{})

8
chain/messagepool/selection.go
View File

@ -73,7 +73,7 @@ func (mp *MessagePool) selectMessagesOptimal(ctx context.Context, curTs, ts *typ
// 0. Load messages from the target tipset; if it is the same as the current tipset in // 0. Load messages from the target tipset; if it is the same as the current tipset in
// the mpool, then this is just the pending messages // the mpool, then this is just the pending messages
pending, err := mp.getPendingMessages(curTs, ts) pending, err := mp.getPendingMessages(ctx, curTs, ts)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -397,7 +397,7 @@ func (mp *MessagePool) selectMessagesGreedy(ctx context.Context, curTs, ts *type
// 0. Load messages for the target tipset; if it is the same as the current tipset in the mpool // 0. Load messages for the target tipset; if it is the same as the current tipset in the mpool
// then this is just the pending messages // then this is just the pending messages
pending, err := mp.getPendingMessages(curTs, ts) pending, err := mp.getPendingMessages(ctx, curTs, ts)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -634,7 +634,7 @@ tailLoop:
return result, gasLimit return result, gasLimit
} }
func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.Address]map[uint64]*types.SignedMessage, error) { func (mp *MessagePool) getPendingMessages(ctx context.Context, curTs, ts *types.TipSet) (map[address.Address]map[uint64]*types.SignedMessage, error) {
start := time.Now() start := time.Now()
result := make(map[address.Address]map[uint64]*types.SignedMessage) result := make(map[address.Address]map[uint64]*types.SignedMessage)
@ -670,7 +670,7 @@ func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.
return result, nil return result, nil
} }
if err := mp.runHeadChange(curTs, ts, result); err != nil { if err := mp.runHeadChange(ctx, curTs, ts, result); err != nil {
return nil, xerrors.Errorf("failed to process difference between mpool head and given head: %w", err) return nil, xerrors.Errorf("failed to process difference between mpool head and given head: %w", err)
} }

8
chain/messagesigner/messagesigner.go
View File

@ -84,7 +84,7 @@ func (ms *MessageSigner) SignMessage(ctx context.Context, msg *types.Message, cb
} }
// If the callback executed successfully, write the nonce to the datastore // If the callback executed successfully, write the nonce to the datastore
if err := ms.saveNonce(msg.From, nonce); err != nil { if err := ms.saveNonce(ctx, msg.From, nonce); err != nil {
return nil, xerrors.Errorf("failed to save nonce: %w", err) return nil, xerrors.Errorf("failed to save nonce: %w", err)
} }
@ -105,7 +105,7 @@ func (ms *MessageSigner) nextNonce(ctx context.Context, addr address.Address) (u
// Get the next nonce for this address from the datastore // Get the next nonce for this address from the datastore
addrNonceKey := ms.dstoreKey(addr) addrNonceKey := ms.dstoreKey(addr)
dsNonceBytes, err := ms.ds.Get(addrNonceKey) dsNonceBytes, err := ms.ds.Get(ctx, addrNonceKey)
switch { switch {
case xerrors.Is(err, datastore.ErrNotFound): case xerrors.Is(err, datastore.ErrNotFound):
@ -139,7 +139,7 @@ func (ms *MessageSigner) nextNonce(ctx context.Context, addr address.Address) (u
// saveNonce increments the nonce for this address and writes it to the // saveNonce increments the nonce for this address and writes it to the
// datastore // datastore
func (ms *MessageSigner) saveNonce(addr address.Address, nonce uint64) error { func (ms *MessageSigner) saveNonce(ctx context.Context, addr address.Address, nonce uint64) error {
// Increment the nonce // Increment the nonce
nonce++ nonce++
@ -150,7 +150,7 @@ func (ms *MessageSigner) saveNonce(addr address.Address, nonce uint64) error {
if err != nil { if err != nil {
return xerrors.Errorf("failed to marshall nonce: %w", err) return xerrors.Errorf("failed to marshall nonce: %w", err)
} }
err = ms.ds.Put(addrNonceKey, buf.Bytes()) err = ms.ds.Put(ctx, addrNonceKey, buf.Bytes())
if err != nil { if err != nil {
return xerrors.Errorf("failed to write nonce to datastore: %w", err) return xerrors.Errorf("failed to write nonce to datastore: %w", err)
} }

10
chain/rand/rand.go
View File

@ -48,7 +48,7 @@ func (sr *stateRand) GetBeaconRandomnessTipset(ctx context.Context, round abi.Ch
defer span.End() defer span.End()
span.AddAttributes(trace.Int64Attribute("round", int64(round))) span.AddAttributes(trace.Int64Attribute("round", int64(round)))
ts, err := sr.cs.LoadTipSet(types.NewTipSetKey(sr.blks...)) ts, err := sr.cs.LoadTipSet(ctx, types.NewTipSetKey(sr.blks...))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -75,7 +75,7 @@ func (sr *stateRand) GetChainRandomness(ctx context.Context, pers crypto.DomainS
defer span.End() defer span.End()
span.AddAttributes(trace.Int64Attribute("round", int64(round))) span.AddAttributes(trace.Int64Attribute("round", int64(round)))
ts, err := sr.cs.LoadTipSet(types.NewTipSetKey(sr.blks...)) ts, err := sr.cs.LoadTipSet(ctx, types.NewTipSetKey(sr.blks...))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -132,7 +132,7 @@ func (sr *stateRand) GetBeaconRandomnessV1(ctx context.Context, pers crypto.Doma
return nil, err return nil, err
} }
be, err := sr.cs.GetLatestBeaconEntry(randTs) be, err := sr.cs.GetLatestBeaconEntry(ctx, randTs)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -149,7 +149,7 @@ func (sr *stateRand) GetBeaconRandomnessV2(ctx context.Context, pers crypto.Doma
return nil, err return nil, err
} }
be, err := sr.cs.GetLatestBeaconEntry(randTs) be, err := sr.cs.GetLatestBeaconEntry(ctx, randTs)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -190,7 +190,7 @@ func (sr *stateRand) extractBeaconEntryForEpoch(ctx context.Context, filecoinEpo
} }
} }
next, err := sr.cs.LoadTipSet(randTs.Parents()) next, err := sr.cs.LoadTipSet(ctx, randTs.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load parents when searching back for beacon entry: %w", err) return nil, xerrors.Errorf("failed to load parents when searching back for beacon entry: %w", err)
} }

5
chain/stmgr/actors.go
View File

@ -14,6 +14,7 @@ import (
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
cid "github.com/ipfs/go-cid" cid "github.com/ipfs/go-cid"
"golang.org/x/xerrors" "golang.org/x/xerrors"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
@ -300,12 +301,12 @@ func ListMinerActors(ctx context.Context, sm *StateManager, ts *types.TipSet) ([
} }
func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) { func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
ts, err := sm.ChainStore().LoadTipSet(tsk) ts, err := sm.ChainStore().LoadTipSet(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load tipset for mining base: %w", err) return nil, xerrors.Errorf("failed to load tipset for mining base: %w", err)
} }
prev, err := sm.ChainStore().GetLatestBeaconEntry(ts) prev, err := sm.ChainStore().GetLatestBeaconEntry(ctx, ts)
if err != nil { if err != nil {
if os.Getenv("LOTUS_IGNORE_DRAND") != "_yes_" { if os.Getenv("LOTUS_IGNORE_DRAND") != "_yes_" {
return nil, xerrors.Errorf("failed to get latest beacon entry: %w", err) return nil, xerrors.Errorf("failed to get latest beacon entry: %w", err)

8
chain/stmgr/call.go
View File

@ -40,7 +40,7 @@ func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.
ts = sm.cs.GetHeaviestTipSet() ts = sm.cs.GetHeaviestTipSet()
// Search back till we find a height with no fork, or we reach the beginning. // Search back till we find a height with no fork, or we reach the beginning.
for ts.Height() > 0 { for ts.Height() > 0 {
pts, err := sm.cs.GetTipSetFromKey(ts.Parents()) pts, err := sm.cs.GetTipSetFromKey(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err) return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err)
} }
@ -51,7 +51,7 @@ func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.
ts = pts ts = pts
} }
} else if ts.Height() > 0 { } else if ts.Height() > 0 {
pts, err := sm.cs.LoadTipSet(ts.Parents()) pts, err := sm.cs.LoadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load parent tipset: %w", err) return nil, xerrors.Errorf("failed to load parent tipset: %w", err)
} }
@ -155,7 +155,7 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
// height to have no fork, because we'll run it inside this // height to have no fork, because we'll run it inside this
// function before executing the given message. // function before executing the given message.
for ts.Height() > 0 { for ts.Height() > 0 {
pts, err := sm.cs.GetTipSetFromKey(ts.Parents()) pts, err := sm.cs.GetTipSetFromKey(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err) return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err)
} }
@ -166,7 +166,7 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
ts = pts ts = pts
} }
} else if ts.Height() > 0 { } else if ts.Height() > 0 {
pts, err := sm.cs.GetTipSetFromKey(ts.Parents()) pts, err := sm.cs.GetTipSetFromKey(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err) return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err)
} }

8
chain/stmgr/read.go
View File

@ -13,8 +13,8 @@ import (
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
) )
func (sm *StateManager) ParentStateTsk(tsk types.TipSetKey) (*state.StateTree, error) { func (sm *StateManager) ParentStateTsk(ctx context.Context, tsk types.TipSetKey) (*state.StateTree, error) {
ts, err := sm.cs.GetTipSetFromKey(tsk) ts, err := sm.cs.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -57,8 +57,8 @@ func (sm *StateManager) LoadActor(_ context.Context, addr address.Address, ts *t
return state.GetActor(addr) return state.GetActor(addr)
} }
func (sm *StateManager) LoadActorTsk(_ context.Context, addr address.Address, tsk types.TipSetKey) (*types.Actor, error) { func (sm *StateManager) LoadActorTsk(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*types.Actor, error) {
state, err := sm.ParentStateTsk(tsk) state, err := sm.ParentStateTsk(ctx, tsk)
if err != nil { if err != nil {
return nil, err return nil, err
} }

14
chain/stmgr/searchwait.go
View File

@ -40,7 +40,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
return nil, nil, cid.Undef, fmt.Errorf("expected current head on SHC stream (got %s)", head[0].Type) return nil, nil, cid.Undef, fmt.Errorf("expected current head on SHC stream (got %s)", head[0].Type)
} }
r, foundMsg, err := sm.tipsetExecutedMessage(head[0].Val, mcid, msg.VMMessage(), allowReplaced) r, foundMsg, err := sm.tipsetExecutedMessage(ctx, head[0].Val, mcid, msg.VMMessage(), allowReplaced)
if err != nil { if err != nil {
return nil, nil, cid.Undef, err return nil, nil, cid.Undef, err
} }
@ -93,7 +93,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
if candidateTs != nil && val.Val.Height() >= candidateTs.Height()+abi.ChainEpoch(confidence) { if candidateTs != nil && val.Val.Height() >= candidateTs.Height()+abi.ChainEpoch(confidence) {
return candidateTs, candidateRcp, candidateFm, nil return candidateTs, candidateRcp, candidateFm, nil
} }
r, foundMsg, err := sm.tipsetExecutedMessage(val.Val, mcid, msg.VMMessage(), allowReplaced) r, foundMsg, err := sm.tipsetExecutedMessage(ctx, val.Val, mcid, msg.VMMessage(), allowReplaced)
if err != nil { if err != nil {
return nil, nil, cid.Undef, err return nil, nil, cid.Undef, err
} }
@ -135,7 +135,7 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, head *types.TipSet
return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err) return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err)
} }
r, foundMsg, err := sm.tipsetExecutedMessage(head, mcid, msg.VMMessage(), allowReplaced) r, foundMsg, err := sm.tipsetExecutedMessage(ctx, head, mcid, msg.VMMessage(), allowReplaced)
if err != nil { if err != nil {
return nil, nil, cid.Undef, err return nil, nil, cid.Undef, err
} }
@ -201,7 +201,7 @@ func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet
return nil, nil, cid.Undef, nil return nil, nil, cid.Undef, nil
} }
pts, err := sm.cs.LoadTipSet(cur.Parents()) pts, err := sm.cs.LoadTipSet(ctx, cur.Parents())
if err != nil { if err != nil {
return nil, nil, cid.Undef, xerrors.Errorf("failed to load tipset during msg wait searchback: %w", err) return nil, nil, cid.Undef, xerrors.Errorf("failed to load tipset during msg wait searchback: %w", err)
} }
@ -214,7 +214,7 @@ func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet
// check that between cur and parent tipset the nonce fell into range of our message // check that between cur and parent tipset the nonce fell into range of our message
if actorNoExist || (curActor.Nonce > mNonce && act.Nonce <= mNonce) { if actorNoExist || (curActor.Nonce > mNonce && act.Nonce <= mNonce) {
r, foundMsg, err := sm.tipsetExecutedMessage(cur, m.Cid(), m.VMMessage(), allowReplaced) r, foundMsg, err := sm.tipsetExecutedMessage(ctx, cur, m.Cid(), m.VMMessage(), allowReplaced)
if err != nil { if err != nil {
return nil, nil, cid.Undef, xerrors.Errorf("checking for message execution during lookback: %w", err) return nil, nil, cid.Undef, xerrors.Errorf("checking for message execution during lookback: %w", err)
} }
@ -229,13 +229,13 @@ func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet
} }
} }
func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm *types.Message, allowReplaced bool) (*types.MessageReceipt, cid.Cid, error) { func (sm *StateManager) tipsetExecutedMessage(ctx context.Context, ts *types.TipSet, msg cid.Cid, vmm *types.Message, allowReplaced bool) (*types.MessageReceipt, cid.Cid, error) {
// The genesis block did not execute any messages // The genesis block did not execute any messages
if ts.Height() == 0 { if ts.Height() == 0 {
return nil, cid.Undef, nil return nil, cid.Undef, nil
} }
pts, err := sm.cs.LoadTipSet(ts.Parents()) pts, err := sm.cs.LoadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, cid.Undef, err return nil, cid.Undef, err
} }

6
chain/stmgr/stmgr.go
View File

@ -320,7 +320,7 @@ func (sm *StateManager) LookupID(ctx context.Context, addr address.Address, ts *
func (sm *StateManager) ValidateChain(ctx context.Context, ts *types.TipSet) error { func (sm *StateManager) ValidateChain(ctx context.Context, ts *types.TipSet) error {
tschain := []*types.TipSet{ts} tschain := []*types.TipSet{ts}
for ts.Height() != 0 { for ts.Height() != 0 {
next, err := sm.cs.LoadTipSet(ts.Parents()) next, err := sm.cs.LoadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return err return err
} }
@ -372,7 +372,7 @@ func (sm *StateManager) VMSys() vm.SyscallBuilder {
} }
func (sm *StateManager) GetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) { func (sm *StateManager) GetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) {
pts, err := sm.ChainStore().GetTipSetFromKey(tsk) pts, err := sm.ChainStore().GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -391,7 +391,7 @@ func (sm *StateManager) GetRandomnessFromBeacon(ctx context.Context, personaliza
} }
func (sm *StateManager) GetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) { func (sm *StateManager) GetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) {
pts, err := sm.ChainStore().LoadTipSet(tsk) pts, err := sm.ChainStore().LoadTipSet(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset key: %w", err) return nil, xerrors.Errorf("loading tipset key: %w", err)
} }

2
chain/stmgr/supply.go
View File

@ -31,7 +31,7 @@ import (
// sets up information about the vesting schedule // sets up information about the vesting schedule
func (sm *StateManager) setupGenesisVestingSchedule(ctx context.Context) error { func (sm *StateManager) setupGenesisVestingSchedule(ctx context.Context) error {
gb, err := sm.cs.GetGenesis() gb, err := sm.cs.GetGenesis(ctx)
if err != nil { if err != nil {
return xerrors.Errorf("getting genesis block: %w", err) return xerrors.Errorf("getting genesis block: %w", err)
} }

2
chain/stmgr/utils.go
View File

@ -155,7 +155,7 @@ func GetLookbackTipSetForRound(ctx context.Context, sm *StateManager, ts *types.
} }
lbts, err := sm.ChainStore().GetTipSetFromKey(nextTs.Parents()) lbts, err := sm.ChainStore().GetTipSetFromKey(ctx, nextTs.Parents())
if err != nil { if err != nil {
return nil, cid.Undef, xerrors.Errorf("failed to resolve lookback tipset: %w", err) return nil, cid.Undef, xerrors.Errorf("failed to resolve lookback tipset: %w", err)
} }

32
chain/store/index.go
View File

@ -31,7 +31,7 @@ type ChainIndex struct {
skipLength abi.ChainEpoch skipLength abi.ChainEpoch
} }
type loadTipSetFunc func(types.TipSetKey) (*types.TipSet, error) type loadTipSetFunc func(context.Context, types.TipSetKey) (*types.TipSet, error)
func NewChainIndex(lts loadTipSetFunc) *ChainIndex { func NewChainIndex(lts loadTipSetFunc) *ChainIndex {
sc, _ := lru.NewARC(DefaultChainIndexCacheSize) sc, _ := lru.NewARC(DefaultChainIndexCacheSize)
@ -49,12 +49,12 @@ type lbEntry struct {
target types.TipSetKey target types.TipSetKey
} }
func (ci *ChainIndex) GetTipsetByHeight(_ context.Context, from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) { func (ci *ChainIndex) GetTipsetByHeight(ctx context.Context, from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) {
if from.Height()-to <= ci.skipLength { if from.Height()-to <= ci.skipLength {
return ci.walkBack(from, to) return ci.walkBack(ctx, from, to)
} }
rounded, err := ci.roundDown(from) rounded, err := ci.roundDown(ctx, from)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -63,7 +63,7 @@ func (ci *ChainIndex) GetTipsetByHeight(_ context.Context, from *types.TipSet, t
for { for {
cval, ok := ci.skipCache.Get(cur) cval, ok := ci.skipCache.Get(cur)
if !ok { if !ok {
fc, err := ci.fillCache(cur) fc, err := ci.fillCache(ctx, cur)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -74,19 +74,19 @@ func (ci *ChainIndex) GetTipsetByHeight(_ context.Context, from *types.TipSet, t
if lbe.ts.Height() == to || lbe.parentHeight < to { if lbe.ts.Height() == to || lbe.parentHeight < to {
return lbe.ts, nil return lbe.ts, nil
} else if to > lbe.targetHeight { } else if to > lbe.targetHeight {
return ci.walkBack(lbe.ts, to) return ci.walkBack(ctx, lbe.ts, to)
} }
cur = lbe.target cur = lbe.target
} }
} }
func (ci *ChainIndex) GetTipsetByHeightWithoutCache(from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) { func (ci *ChainIndex) GetTipsetByHeightWithoutCache(ctx context.Context, from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) {
return ci.walkBack(from, to) return ci.walkBack(ctx, from, to)
} }
func (ci *ChainIndex) fillCache(tsk types.TipSetKey) (*lbEntry, error) { func (ci *ChainIndex) fillCache(ctx context.Context, tsk types.TipSetKey) (*lbEntry, error) {
ts, err := ci.loadTipSet(tsk) ts, err := ci.loadTipSet(ctx, tsk)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -101,7 +101,7 @@ func (ci *ChainIndex) fillCache(tsk types.TipSetKey) (*lbEntry, error) {
// will either be equal to ts.Height, or at least > ts.Parent.Height() // will either be equal to ts.Height, or at least > ts.Parent.Height()
rheight := ci.roundHeight(ts.Height()) rheight := ci.roundHeight(ts.Height())
parent, err := ci.loadTipSet(ts.Parents()) parent, err := ci.loadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -115,7 +115,7 @@ func (ci *ChainIndex) fillCache(tsk types.TipSetKey) (*lbEntry, error) {
if parent.Height() < rheight { if parent.Height() < rheight {
skipTarget = parent skipTarget = parent
} else { } else {
skipTarget, err = ci.walkBack(parent, rheight) skipTarget, err = ci.walkBack(ctx, parent, rheight)
if err != nil { if err != nil {
return nil, xerrors.Errorf("fillCache walkback: %w", err) return nil, xerrors.Errorf("fillCache walkback: %w", err)
} }
@ -137,10 +137,10 @@ func (ci *ChainIndex) roundHeight(h abi.ChainEpoch) abi.ChainEpoch {
return (h / ci.skipLength) * ci.skipLength return (h / ci.skipLength) * ci.skipLength
} }
func (ci *ChainIndex) roundDown(ts *types.TipSet) (*types.TipSet, error) { func (ci *ChainIndex) roundDown(ctx context.Context, ts *types.TipSet) (*types.TipSet, error) {
target := ci.roundHeight(ts.Height()) target := ci.roundHeight(ts.Height())
rounded, err := ci.walkBack(ts, target) rounded, err := ci.walkBack(ctx, ts, target)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -148,7 +148,7 @@ func (ci *ChainIndex) roundDown(ts *types.TipSet) (*types.TipSet, error) {
return rounded, nil return rounded, nil
} }
func (ci *ChainIndex) walkBack(from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) { func (ci *ChainIndex) walkBack(ctx context.Context, from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) {
if to > from.Height() { if to > from.Height() {
return nil, xerrors.Errorf("looking for tipset with height greater than start point") return nil, xerrors.Errorf("looking for tipset with height greater than start point")
} }
@ -160,7 +160,7 @@ func (ci *ChainIndex) walkBack(from *types.TipSet, to abi.ChainEpoch) (*types.Ti
ts := from ts := from
for { for {
pts, err := ci.loadTipSet(ts.Parents()) pts, err := ci.loadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, err return nil, err
} }

6
chain/store/messages.go
View File

@ -29,7 +29,7 @@ func PutMessage(bs bstore.Blockstore, m storable) (cid.Cid, error) {
return cid.Undef, err return cid.Undef, err
} }
if err := bs.Put(b); err != nil { if err := bs.Put(context.TODO(), b); err != nil {
return cid.Undef, err return cid.Undef, err
} }
@ -54,7 +54,7 @@ func (cs *ChainStore) GetCMessage(c cid.Cid) (types.ChainMsg, error) {
func (cs *ChainStore) GetMessage(c cid.Cid) (*types.Message, error) { func (cs *ChainStore) GetMessage(c cid.Cid) (*types.Message, error) {
var msg *types.Message var msg *types.Message
err := cs.chainLocalBlockstore.View(c, func(b []byte) (err error) { err := cs.chainLocalBlockstore.View(context.TODO(), c, func(b []byte) (err error) {
msg, err = types.DecodeMessage(b) msg, err = types.DecodeMessage(b)
return err return err
}) })
@ -63,7 +63,7 @@ func (cs *ChainStore) GetMessage(c cid.Cid) (*types.Message, error) {
func (cs *ChainStore) GetSignedMessage(c cid.Cid) (*types.SignedMessage, error) { func (cs *ChainStore) GetSignedMessage(c cid.Cid) (*types.SignedMessage, error) {
var msg *types.SignedMessage var msg *types.SignedMessage
err := cs.chainLocalBlockstore.View(c, func(b []byte) (err error) { err := cs.chainLocalBlockstore.View(context.TODO(), c, func(b []byte) (err error) {
msg, err = types.DecodeSignedMessage(b) msg, err = types.DecodeSignedMessage(b)
return err return err
}) })

19
chain/store/snapshot.go
View File

@ -30,7 +30,7 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
unionBs := bstore.Union(cs.stateBlockstore, cs.chainBlockstore) unionBs := bstore.Union(cs.stateBlockstore, cs.chainBlockstore)
return cs.WalkSnapshot(ctx, ts, inclRecentRoots, skipOldMsgs, true, func(c cid.Cid) error { return cs.WalkSnapshot(ctx, ts, inclRecentRoots, skipOldMsgs, true, func(c cid.Cid) error {
blk, err := unionBs.Get(c) blk, err := unionBs.Get(ctx, c)
if err != nil { if err != nil {
return xerrors.Errorf("writing object to car, bs.Get: %w", err) return xerrors.Errorf("writing object to car, bs.Get: %w", err)
} }
@ -44,17 +44,18 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
} }
func (cs *ChainStore) Import(r io.Reader) (*types.TipSet, error) { func (cs *ChainStore) Import(r io.Reader) (*types.TipSet, error) {
ctx := context.TODO()
// TODO: writing only to the state blockstore is incorrect. // TODO: writing only to the state blockstore is incorrect.
// At this time, both the state and chain blockstores are backed by the // At this time, both the state and chain blockstores are backed by the
// universal store. When we physically segregate the stores, we will need // universal store. When we physically segregate the stores, we will need
// to route state objects to the state blockstore, and chain objects to // to route state objects to the state blockstore, and chain objects to
// the chain blockstore. // the chain blockstore.
header, err := car.LoadCar(cs.StateBlockstore(), r) header, err := car.LoadCar(ctx, cs.StateBlockstore(), r)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loadcar failed: %w", err) return nil, xerrors.Errorf("loadcar failed: %w", err)
} }
root, err := cs.LoadTipSet(types.NewTipSetKey(header.Roots...)) root, err := cs.LoadTipSet(ctx, types.NewTipSetKey(header.Roots...))
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load root tipset from chainfile: %w", err) return nil, xerrors.Errorf("failed to load root tipset from chainfile: %w", err)
} }
@ -82,7 +83,7 @@ func (cs *ChainStore) WalkSnapshot(ctx context.Context, ts *types.TipSet, inclRe
return err return err
} }
data, err := cs.chainBlockstore.Get(blk) data, err := cs.chainBlockstore.Get(ctx, blk)
if err != nil { if err != nil {
return xerrors.Errorf("getting block: %w", err) return xerrors.Errorf("getting block: %w", err)
} }
@ -102,7 +103,7 @@ func (cs *ChainStore) WalkSnapshot(ctx context.Context, ts *types.TipSet, inclRe
var cids []cid.Cid var cids []cid.Cid
if !skipOldMsgs || b.Height > ts.Height()-inclRecentRoots { if !skipOldMsgs || b.Height > ts.Height()-inclRecentRoots {
if walked.Visit(b.Messages) { if walked.Visit(b.Messages) {
mcids, err := recurseLinks(cs.chainBlockstore, walked, b.Messages, []cid.Cid{b.Messages}) mcids, err := recurseLinks(ctx, cs.chainBlockstore, walked, b.Messages, []cid.Cid{b.Messages})
if err != nil { if err != nil {
return xerrors.Errorf("recursing messages failed: %w", err) return xerrors.Errorf("recursing messages failed: %w", err)
} }
@ -123,7 +124,7 @@ func (cs *ChainStore) WalkSnapshot(ctx context.Context, ts *types.TipSet, inclRe
if b.Height == 0 || b.Height > ts.Height()-inclRecentRoots { if b.Height == 0 || b.Height > ts.Height()-inclRecentRoots {
if walked.Visit(b.ParentStateRoot) { if walked.Visit(b.ParentStateRoot) {
cids, err := recurseLinks(cs.stateBlockstore, walked, b.ParentStateRoot, []cid.Cid{b.ParentStateRoot}) cids, err := recurseLinks(ctx, cs.stateBlockstore, walked, b.ParentStateRoot, []cid.Cid{b.ParentStateRoot})
if err != nil { if err != nil {
return xerrors.Errorf("recursing genesis state failed: %w", err) return xerrors.Errorf("recursing genesis state failed: %w", err)
} }
@ -168,12 +169,12 @@ func (cs *ChainStore) WalkSnapshot(ctx context.Context, ts *types.TipSet, inclRe
return nil return nil
} }
func recurseLinks(bs bstore.Blockstore, walked *cid.Set, root cid.Cid, in []cid.Cid) ([]cid.Cid, error) { func recurseLinks(ctx context.Context, bs bstore.Blockstore, walked *cid.Set, root cid.Cid, in []cid.Cid) ([]cid.Cid, error) {
if root.Prefix().Codec != cid.DagCBOR { if root.Prefix().Codec != cid.DagCBOR {
return in, nil return in, nil
} }
data, err := bs.Get(root) data, err := bs.Get(ctx, root)
if err != nil { if err != nil {
return nil, xerrors.Errorf("recurse links get (%s) failed: %w", root, err) return nil, xerrors.Errorf("recurse links get (%s) failed: %w", root, err)
} }
@ -192,7 +193,7 @@ func recurseLinks(bs bstore.Blockstore, walked *cid.Set, root cid.Cid, in []cid.
in = append(in, c) in = append(in, c)
var err error var err error
in, err = recurseLinks(bs, walked, c, in) in, err = recurseLinks(ctx, bs, walked, c, in)
if err != nil { if err != nil {
rerr = err rerr = err
} }

160
chain/store/store.go
View File

@ -207,17 +207,17 @@ func (cs *ChainStore) Close() error {
return nil return nil
} }
func (cs *ChainStore) Load() error { func (cs *ChainStore) Load(ctx context.Context) error {
if err := cs.loadHead(); err != nil { if err := cs.loadHead(ctx); err != nil {
return err return err
} }
if err := cs.loadCheckpoint(); err != nil { if err := cs.loadCheckpoint(ctx); err != nil {
return err return err
} }
return nil return nil
} }
func (cs *ChainStore) loadHead() error { func (cs *ChainStore) loadHead(ctx context.Context) error {
head, err := cs.metadataDs.Get(chainHeadKey) head, err := cs.metadataDs.Get(ctx, chainHeadKey)
if err == dstore.ErrNotFound { if err == dstore.ErrNotFound {
log.Warn("no previous chain state found") log.Warn("no previous chain state found")
return nil return nil
@ -231,7 +231,7 @@ func (cs *ChainStore) loadHead() error {
return xerrors.Errorf("failed to unmarshal stored chain head: %w", err) return xerrors.Errorf("failed to unmarshal stored chain head: %w", err)
} }
ts, err := cs.LoadTipSet(types.NewTipSetKey(tscids...)) ts, err := cs.LoadTipSet(ctx, types.NewTipSetKey(tscids...))
if err != nil { if err != nil {
return xerrors.Errorf("loading tipset: %w", err) return xerrors.Errorf("loading tipset: %w", err)
} }
@ -241,8 +241,8 @@ func (cs *ChainStore) loadHead() error {
return nil return nil
} }
func (cs *ChainStore) loadCheckpoint() error { func (cs *ChainStore) loadCheckpoint(ctx context.Context) error {
tskBytes, err := cs.metadataDs.Get(checkpointKey) tskBytes, err := cs.metadataDs.Get(ctx, checkpointKey)
if err == dstore.ErrNotFound { if err == dstore.ErrNotFound {
return nil return nil
} }
@ -256,7 +256,7 @@ func (cs *ChainStore) loadCheckpoint() error {
return err return err
} }
ts, err := cs.LoadTipSet(tsk) ts, err := cs.LoadTipSet(ctx, tsk)
if err != nil { if err != nil {
return xerrors.Errorf("loading tipset: %w", err) return xerrors.Errorf("loading tipset: %w", err)
} }
@ -266,13 +266,13 @@ func (cs *ChainStore) loadCheckpoint() error {
return nil return nil
} }
func (cs *ChainStore) writeHead(ts *types.TipSet) error { func (cs *ChainStore) writeHead(ctx context.Context, ts *types.TipSet) error {
data, err := json.Marshal(ts.Cids()) data, err := json.Marshal(ts.Cids())
if err != nil { if err != nil {
return xerrors.Errorf("failed to marshal tipset: %w", err) return xerrors.Errorf("failed to marshal tipset: %w", err)
} }
if err := cs.metadataDs.Put(chainHeadKey, data); err != nil { if err := cs.metadataDs.Put(ctx, chainHeadKey, data); err != nil {
return xerrors.Errorf("failed to write chain head to datastore: %w", err) return xerrors.Errorf("failed to write chain head to datastore: %w", err)
} }
@ -341,13 +341,13 @@ func (cs *ChainStore) SubscribeHeadChanges(f ReorgNotifee) {
func (cs *ChainStore) IsBlockValidated(ctx context.Context, blkid cid.Cid) (bool, error) { func (cs *ChainStore) IsBlockValidated(ctx context.Context, blkid cid.Cid) (bool, error) {
key := blockValidationCacheKeyPrefix.Instance(blkid.String()) key := blockValidationCacheKeyPrefix.Instance(blkid.String())
return cs.metadataDs.Has(key) return cs.metadataDs.Has(ctx, key)
} }
func (cs *ChainStore) MarkBlockAsValidated(ctx context.Context, blkid cid.Cid) error { func (cs *ChainStore) MarkBlockAsValidated(ctx context.Context, blkid cid.Cid) error {
key := blockValidationCacheKeyPrefix.Instance(blkid.String()) key := blockValidationCacheKeyPrefix.Instance(blkid.String())
if err := cs.metadataDs.Put(key, []byte{0}); err != nil { if err := cs.metadataDs.Put(ctx, key, []byte{0}); err != nil {
return xerrors.Errorf("cache block validation: %w", err) return xerrors.Errorf("cache block validation: %w", err)
} }
@ -357,34 +357,34 @@ func (cs *ChainStore) MarkBlockAsValidated(ctx context.Context, blkid cid.Cid) e
func (cs *ChainStore) UnmarkBlockAsValidated(ctx context.Context, blkid cid.Cid) error { func (cs *ChainStore) UnmarkBlockAsValidated(ctx context.Context, blkid cid.Cid) error {
key := blockValidationCacheKeyPrefix.Instance(blkid.String()) key := blockValidationCacheKeyPrefix.Instance(blkid.String())
if err := cs.metadataDs.Delete(key); err != nil { if err := cs.metadataDs.Delete(ctx, key); err != nil {
return xerrors.Errorf("removing from valid block cache: %w", err) return xerrors.Errorf("removing from valid block cache: %w", err)
} }
return nil return nil
} }
func (cs *ChainStore) SetGenesis(b *types.BlockHeader) error { func (cs *ChainStore) SetGenesis(ctx context.Context, b *types.BlockHeader) error {
ts, err := types.NewTipSet([]*types.BlockHeader{b}) ts, err := types.NewTipSet([]*types.BlockHeader{b})
if err != nil { if err != nil {
return err return err
} }
if err := cs.PutTipSet(context.TODO(), ts); err != nil { if err := cs.PutTipSet(ctx, ts); err != nil {
return err return err
} }
return cs.metadataDs.Put(dstore.NewKey("0"), b.Cid().Bytes()) return cs.metadataDs.Put(ctx, dstore.NewKey("0"), b.Cid().Bytes())
} }
func (cs *ChainStore) PutTipSet(ctx context.Context, ts *types.TipSet) error { func (cs *ChainStore) PutTipSet(ctx context.Context, ts *types.TipSet) error {
for _, b := range ts.Blocks() { for _, b := range ts.Blocks() {
if err := cs.PersistBlockHeaders(b); err != nil { if err := cs.PersistBlockHeaders(ctx, b); err != nil {
return err return err
} }
} }
expanded, err := cs.expandTipset(ts.Blocks()[0]) expanded, err := cs.expandTipset(ctx, ts.Blocks()[0])
if err != nil { if err != nil {
return xerrors.Errorf("errored while expanding tipset: %w", err) return xerrors.Errorf("errored while expanding tipset: %w", err)
} }
@ -435,7 +435,7 @@ func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipS
// difference between 'bootstrap sync' and 'caught up' sync, we need // difference between 'bootstrap sync' and 'caught up' sync, we need
// some other heuristic. // some other heuristic.
exceeds, err := cs.exceedsForkLength(cs.heaviest, ts) exceeds, err := cs.exceedsForkLength(ctx, cs.heaviest, ts)
if err != nil { if err != nil {
return err return err
} }
@ -458,7 +458,7 @@ func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipS
// FIXME: We may want to replace some of the logic in `syncFork()` with this. // FIXME: We may want to replace some of the logic in `syncFork()` with this.
// `syncFork()` counts the length on both sides of the fork at the moment (we // `syncFork()` counts the length on both sides of the fork at the moment (we
// need to settle on that) but here we just enforce it on the `synced` side. // need to settle on that) but here we just enforce it on the `synced` side.
func (cs *ChainStore) exceedsForkLength(synced, external *types.TipSet) (bool, error) { func (cs *ChainStore) exceedsForkLength(ctx context.Context, synced, external *types.TipSet) (bool, error) {
if synced == nil || external == nil { if synced == nil || external == nil {
// FIXME: If `cs.heaviest` is nil we should just bypass the entire // FIXME: If `cs.heaviest` is nil we should just bypass the entire
// `MaybeTakeHeavierTipSet` logic (instead of each of the called // `MaybeTakeHeavierTipSet` logic (instead of each of the called
@ -482,7 +482,7 @@ func (cs *ChainStore) exceedsForkLength(synced, external *types.TipSet) (bool, e
// length). // length).
return true, nil return true, nil
} }
external, err = cs.LoadTipSet(external.Parents()) external, err = cs.LoadTipSet(ctx, external.Parents())
if err != nil { if err != nil {
return false, xerrors.Errorf("failed to load parent tipset in external chain: %w", err) return false, xerrors.Errorf("failed to load parent tipset in external chain: %w", err)
} }
@ -505,7 +505,7 @@ func (cs *ChainStore) exceedsForkLength(synced, external *types.TipSet) (bool, e
// there is no common ancestor. // there is no common ancestor.
return true, nil return true, nil
} }
synced, err = cs.LoadTipSet(synced.Parents()) synced, err = cs.LoadTipSet(ctx, synced.Parents())
if err != nil { if err != nil {
return false, xerrors.Errorf("failed to load parent tipset in synced chain: %w", err) return false, xerrors.Errorf("failed to load parent tipset in synced chain: %w", err)
} }
@ -521,17 +521,17 @@ func (cs *ChainStore) exceedsForkLength(synced, external *types.TipSet) (bool, e
// CAUTION: Use it only for testing, such as to teleport the chain to a // CAUTION: Use it only for testing, such as to teleport the chain to a
// particular tipset to carry out a benchmark, verification, etc. on a chain // particular tipset to carry out a benchmark, verification, etc. on a chain
// segment. // segment.
func (cs *ChainStore) ForceHeadSilent(_ context.Context, ts *types.TipSet) error { func (cs *ChainStore) ForceHeadSilent(ctx context.Context, ts *types.TipSet) error {
log.Warnf("(!!!) forcing a new head silently; new head: %s", ts) log.Warnf("(!!!) forcing a new head silently; new head: %s", ts)
cs.heaviestLk.Lock() cs.heaviestLk.Lock()
defer cs.heaviestLk.Unlock() defer cs.heaviestLk.Unlock()
if err := cs.removeCheckpoint(); err != nil { if err := cs.removeCheckpoint(ctx); err != nil {
return err return err
} }
cs.heaviest = ts cs.heaviest = ts
err := cs.writeHead(ts) err := cs.writeHead(ctx, ts)
if err != nil { if err != nil {
err = xerrors.Errorf("failed to write chain head: %s", err) err = xerrors.Errorf("failed to write chain head: %s", err)
} }
@ -561,7 +561,7 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
notifees = append(notifees, n) notifees = append(notifees, n)
case r := <-out: case r := <-out:
revert, apply, err := cs.ReorgOps(r.old, r.new) revert, apply, err := cs.ReorgOps(ctx, r.old, r.new)
if err != nil { if err != nil {
log.Error("computing reorg ops failed: ", err) log.Error("computing reorg ops failed: ", err)
continue continue
@ -646,7 +646,7 @@ func (cs *ChainStore) takeHeaviestTipSet(ctx context.Context, ts *types.TipSet)
log.Infof("New heaviest tipset! %s (height=%d)", ts.Cids(), ts.Height()) log.Infof("New heaviest tipset! %s (height=%d)", ts.Cids(), ts.Height())
cs.heaviest = ts cs.heaviest = ts
if err := cs.writeHead(ts); err != nil { if err := cs.writeHead(ctx, ts); err != nil {
log.Errorf("failed to write chain head: %s", err) log.Errorf("failed to write chain head: %s", err)
return nil return nil
} }
@ -656,14 +656,14 @@ func (cs *ChainStore) takeHeaviestTipSet(ctx context.Context, ts *types.TipSet)
// FlushValidationCache removes all results of block validation from the // FlushValidationCache removes all results of block validation from the
// chain metadata store. Usually the first step after a new chain import. // chain metadata store. Usually the first step after a new chain import.
func (cs *ChainStore) FlushValidationCache() error { func (cs *ChainStore) FlushValidationCache(ctx context.Context) error {
return FlushValidationCache(cs.metadataDs) return FlushValidationCache(ctx, cs.metadataDs)
} }
func FlushValidationCache(ds dstore.Batching) error { func FlushValidationCache(ctx context.Context, ds dstore.Batching) error {
log.Infof("clearing block validation cache...") log.Infof("clearing block validation cache...")
dsWalk, err := ds.Query(query.Query{ dsWalk, err := ds.Query(ctx, query.Query{
// Potential TODO: the validation cache is not a namespace on its own // Potential TODO: the validation cache is not a namespace on its own
// but is rather constructed as prefixed-key `foo:bar` via .Instance(), which // but is rather constructed as prefixed-key `foo:bar` via .Instance(), which
// in turn does not work with the filter, which can match only on `foo/bar` // in turn does not work with the filter, which can match only on `foo/bar`
@ -683,7 +683,7 @@ func FlushValidationCache(ds dstore.Batching) error {
return xerrors.Errorf("failed to run key listing query: %w", err) return xerrors.Errorf("failed to run key listing query: %w", err)
} }
batch, err := ds.Batch() batch, err := ds.Batch(ctx)
if err != nil { if err != nil {
return xerrors.Errorf("failed to open a DS batch: %w", err) return xerrors.Errorf("failed to open a DS batch: %w", err)
} }
@ -692,11 +692,11 @@ func FlushValidationCache(ds dstore.Batching) error {
for _, k := range allKeys { for _, k := range allKeys {
if strings.HasPrefix(k.Key, blockValidationCacheKeyPrefix.String()) { if strings.HasPrefix(k.Key, blockValidationCacheKeyPrefix.String()) {
delCnt++ delCnt++
batch.Delete(dstore.RawKey(k.Key)) // nolint:errcheck batch.Delete(ctx, dstore.RawKey(k.Key)) // nolint:errcheck
} }
} }
if err := batch.Commit(); err != nil { if err := batch.Commit(ctx); err != nil {
return xerrors.Errorf("failed to commit the DS batch: %w", err) return xerrors.Errorf("failed to commit the DS batch: %w", err)
} }
@ -709,24 +709,24 @@ func FlushValidationCache(ds dstore.Batching) error {
// This should only be called if something is broken and needs fixing. // This should only be called if something is broken and needs fixing.
// //
// This function will bypass and remove any checkpoints. // This function will bypass and remove any checkpoints.
func (cs *ChainStore) SetHead(ts *types.TipSet) error { func (cs *ChainStore) SetHead(ctx context.Context, ts *types.TipSet) error {
cs.heaviestLk.Lock() cs.heaviestLk.Lock()
defer cs.heaviestLk.Unlock() defer cs.heaviestLk.Unlock()
if err := cs.removeCheckpoint(); err != nil { if err := cs.removeCheckpoint(ctx); err != nil {
return err return err
} }
return cs.takeHeaviestTipSet(context.TODO(), ts) return cs.takeHeaviestTipSet(context.TODO(), ts)
} }
// RemoveCheckpoint removes the current checkpoint. // RemoveCheckpoint removes the current checkpoint.
func (cs *ChainStore) RemoveCheckpoint() error { func (cs *ChainStore) RemoveCheckpoint(ctx context.Context) error {
cs.heaviestLk.Lock() cs.heaviestLk.Lock()
defer cs.heaviestLk.Unlock() defer cs.heaviestLk.Unlock()
return cs.removeCheckpoint() return cs.removeCheckpoint(ctx)
} }
func (cs *ChainStore) removeCheckpoint() error { func (cs *ChainStore) removeCheckpoint(ctx context.Context) error {
if err := cs.metadataDs.Delete(checkpointKey); err != nil { if err := cs.metadataDs.Delete(ctx, checkpointKey); err != nil {
return err return err
} }
cs.checkpoint = nil cs.checkpoint = nil
@ -736,7 +736,7 @@ func (cs *ChainStore) removeCheckpoint() error {
// SetCheckpoint will set a checkpoint past which the chainstore will not allow forks. // SetCheckpoint will set a checkpoint past which the chainstore will not allow forks.
// //
// NOTE: Checkpoints cannot be set beyond ForkLengthThreshold epochs in the past. // NOTE: Checkpoints cannot be set beyond ForkLengthThreshold epochs in the past.
func (cs *ChainStore) SetCheckpoint(ts *types.TipSet) error { func (cs *ChainStore) SetCheckpoint(ctx context.Context, ts *types.TipSet) error {
tskBytes, err := json.Marshal(ts.Key()) tskBytes, err := json.Marshal(ts.Key())
if err != nil { if err != nil {
return err return err
@ -755,7 +755,7 @@ func (cs *ChainStore) SetCheckpoint(ts *types.TipSet) error {
} }
if !ts.Equals(cs.heaviest) { if !ts.Equals(cs.heaviest) {
anc, err := cs.IsAncestorOf(ts, cs.heaviest) anc, err := cs.IsAncestorOf(ctx, ts, cs.heaviest)
if err != nil { if err != nil {
return xerrors.Errorf("cannot determine whether checkpoint tipset is in main-chain: %w", err) return xerrors.Errorf("cannot determine whether checkpoint tipset is in main-chain: %w", err)
} }
@ -764,7 +764,7 @@ func (cs *ChainStore) SetCheckpoint(ts *types.TipSet) error {
return xerrors.Errorf("cannot mark tipset as checkpoint, since it isn't in the main-chain: %w", err) return xerrors.Errorf("cannot mark tipset as checkpoint, since it isn't in the main-chain: %w", err)
} }
} }
err = cs.metadataDs.Put(checkpointKey, tskBytes) err = cs.metadataDs.Put(ctx, checkpointKey, tskBytes)
if err != nil { if err != nil {
return err return err
} }
@ -781,9 +781,9 @@ func (cs *ChainStore) GetCheckpoint() *types.TipSet {
} }
// Contains returns whether our BlockStore has all blocks in the supplied TipSet. // Contains returns whether our BlockStore has all blocks in the supplied TipSet.
func (cs *ChainStore) Contains(ts *types.TipSet) (bool, error) { func (cs *ChainStore) Contains(ctx context.Context, ts *types.TipSet) (bool, error) {
for _, c := range ts.Cids() { for _, c := range ts.Cids() {
has, err := cs.chainBlockstore.Has(c) has, err := cs.chainBlockstore.Has(ctx, c)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -797,16 +797,16 @@ func (cs *ChainStore) Contains(ts *types.TipSet) (bool, error) {
// GetBlock fetches a BlockHeader with the supplied CID. It returns // GetBlock fetches a BlockHeader with the supplied CID. It returns
// blockstore.ErrNotFound if the block was not found in the BlockStore. // blockstore.ErrNotFound if the block was not found in the BlockStore.
func (cs *ChainStore) GetBlock(c cid.Cid) (*types.BlockHeader, error) { func (cs *ChainStore) GetBlock(ctx context.Context, c cid.Cid) (*types.BlockHeader, error) {
var blk *types.BlockHeader var blk *types.BlockHeader
err := cs.chainLocalBlockstore.View(c, func(b []byte) (err error) { err := cs.chainLocalBlockstore.View(ctx, c, func(b []byte) (err error) {
blk, err = types.DecodeBlock(b) blk, err = types.DecodeBlock(b)
return err return err
}) })
return blk, err return blk, err
} }
func (cs *ChainStore) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) { func (cs *ChainStore) LoadTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
v, ok := cs.tsCache.Get(tsk) v, ok := cs.tsCache.Get(tsk)
if ok { if ok {
return v.(*types.TipSet), nil return v.(*types.TipSet), nil
@ -819,7 +819,7 @@ func (cs *ChainStore) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
for i, c := range cids { for i, c := range cids {
i, c := i, c i, c := i, c
eg.Go(func() error { eg.Go(func() error {
b, err := cs.GetBlock(c) b, err := cs.GetBlock(ctx, c)
if err != nil { if err != nil {
return xerrors.Errorf("get block %s: %w", c, err) return xerrors.Errorf("get block %s: %w", c, err)
} }
@ -844,14 +844,14 @@ func (cs *ChainStore) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
} }
// IsAncestorOf returns true if 'a' is an ancestor of 'b' // IsAncestorOf returns true if 'a' is an ancestor of 'b'
func (cs *ChainStore) IsAncestorOf(a, b *types.TipSet) (bool, error) { func (cs *ChainStore) IsAncestorOf(ctx context.Context, a, b *types.TipSet) (bool, error) {
if b.Height() <= a.Height() { if b.Height() <= a.Height() {
return false, nil return false, nil
} }
cur := b cur := b
for !a.Equals(cur) && cur.Height() > a.Height() { for !a.Equals(cur) && cur.Height() > a.Height() {
next, err := cs.LoadTipSet(cur.Parents()) next, err := cs.LoadTipSet(ctx, cur.Parents())
if err != nil { if err != nil {
return false, err return false, err
} }
@ -862,13 +862,13 @@ func (cs *ChainStore) IsAncestorOf(a, b *types.TipSet) (bool, error) {
return cur.Equals(a), nil return cur.Equals(a), nil
} }
func (cs *ChainStore) NearestCommonAncestor(a, b *types.TipSet) (*types.TipSet, error) { func (cs *ChainStore) NearestCommonAncestor(ctx context.Context, a, b *types.TipSet) (*types.TipSet, error) {
l, _, err := cs.ReorgOps(a, b) l, _, err := cs.ReorgOps(ctx, a, b)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return cs.LoadTipSet(l[len(l)-1].Parents()) return cs.LoadTipSet(ctx, l[len(l)-1].Parents())
} }
// ReorgOps takes two tipsets (which can be at different heights), and walks // ReorgOps takes two tipsets (which can be at different heights), and walks
@ -879,11 +879,11 @@ func (cs *ChainStore) NearestCommonAncestor(a, b *types.TipSet) (*types.TipSet,
// ancestor. // ancestor.
// //
// If an error happens along the way, we return the error with nil slices. // If an error happens along the way, we return the error with nil slices.
func (cs *ChainStore) ReorgOps(a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) { func (cs *ChainStore) ReorgOps(ctx context.Context, a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) {
return ReorgOps(cs.LoadTipSet, a, b) return ReorgOps(ctx, cs.LoadTipSet, a, b)
} }
func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) { func ReorgOps(ctx context.Context, lts func(ctx context.Context, _ types.TipSetKey) (*types.TipSet, error), a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) {
left := a left := a
right := b right := b
@ -891,7 +891,7 @@ func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipS
for !left.Equals(right) { for !left.Equals(right) {
if left.Height() > right.Height() { if left.Height() > right.Height() {
leftChain = append(leftChain, left) leftChain = append(leftChain, left)
par, err := lts(left.Parents()) par, err := lts(ctx, left.Parents())
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
@ -899,7 +899,7 @@ func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipS
left = par left = par
} else { } else {
rightChain = append(rightChain, right) rightChain = append(rightChain, right)
par, err := lts(right.Parents()) par, err := lts(ctx, right.Parents())
if err != nil { if err != nil {
log.Infof("failed to fetch right.Parents: %s", err) log.Infof("failed to fetch right.Parents: %s", err)
return nil, nil, err return nil, nil, err
@ -921,7 +921,7 @@ func (cs *ChainStore) GetHeaviestTipSet() (ts *types.TipSet) {
return return
} }
func (cs *ChainStore) AddToTipSetTracker(b *types.BlockHeader) error { func (cs *ChainStore) AddToTipSetTracker(ctx context.Context, b *types.BlockHeader) error {
cs.tstLk.Lock() cs.tstLk.Lock()
defer cs.tstLk.Unlock() defer cs.tstLk.Unlock()
@ -931,7 +931,7 @@ func (cs *ChainStore) AddToTipSetTracker(b *types.BlockHeader) error {
log.Debug("tried to add block to tipset tracker that was already there") log.Debug("tried to add block to tipset tracker that was already there")
return nil return nil
} }
h, err := cs.GetBlock(oc) h, err := cs.GetBlock(ctx, oc)
if err == nil && h != nil { if err == nil && h != nil {
if h.Miner == b.Miner { if h.Miner == b.Miner {
log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache %s-%s", b.Miner, b.Height, b.Cid(), h.Cid()) log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache %s-%s", b.Miner, b.Height, b.Cid(), h.Cid())
@ -960,7 +960,7 @@ func (cs *ChainStore) AddToTipSetTracker(b *types.BlockHeader) error {
return nil return nil
} }
func (cs *ChainStore) PersistBlockHeaders(b ...*types.BlockHeader) error { func (cs *ChainStore) PersistBlockHeaders(ctx context.Context, b ...*types.BlockHeader) error {
sbs := make([]block.Block, len(b)) sbs := make([]block.Block, len(b))
for i, header := range b { for i, header := range b {
@ -982,13 +982,13 @@ func (cs *ChainStore) PersistBlockHeaders(b ...*types.BlockHeader) error {
end = len(b) end = len(b)
} }
err = multierr.Append(err, cs.chainLocalBlockstore.PutMany(sbs[start:end])) err = multierr.Append(err, cs.chainLocalBlockstore.PutMany(ctx, sbs[start:end]))
} }
return err return err
} }
func (cs *ChainStore) expandTipset(b *types.BlockHeader) (*types.TipSet, error) { func (cs *ChainStore) expandTipset(ctx context.Context, b *types.BlockHeader) (*types.TipSet, error) {
// Hold lock for the whole function for now, if it becomes a problem we can // Hold lock for the whole function for now, if it becomes a problem we can
// fix pretty easily // fix pretty easily
cs.tstLk.Lock() cs.tstLk.Lock()
@ -1007,7 +1007,7 @@ func (cs *ChainStore) expandTipset(b *types.BlockHeader) (*types.TipSet, error)
continue continue
} }
h, err := cs.GetBlock(bhc) h, err := cs.GetBlock(ctx, bhc)
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load block (%s) for tipset expansion: %w", bhc, err) return nil, xerrors.Errorf("failed to load block (%s) for tipset expansion: %w", bhc, err)
} }
@ -1029,11 +1029,11 @@ func (cs *ChainStore) expandTipset(b *types.BlockHeader) (*types.TipSet, error)
} }
func (cs *ChainStore) AddBlock(ctx context.Context, b *types.BlockHeader) error { func (cs *ChainStore) AddBlock(ctx context.Context, b *types.BlockHeader) error {
if err := cs.PersistBlockHeaders(b); err != nil { if err := cs.PersistBlockHeaders(ctx, b); err != nil {
return err return err
} }
ts, err := cs.expandTipset(b) ts, err := cs.expandTipset(ctx, b)
if err != nil { if err != nil {
return err return err
} }
@ -1045,8 +1045,8 @@ func (cs *ChainStore) AddBlock(ctx context.Context, b *types.BlockHeader) error
return nil return nil
} }
func (cs *ChainStore) GetGenesis() (*types.BlockHeader, error) { func (cs *ChainStore) GetGenesis(ctx context.Context) (*types.BlockHeader, error) {
data, err := cs.metadataDs.Get(dstore.NewKey("0")) data, err := cs.metadataDs.Get(ctx, dstore.NewKey("0"))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -1056,22 +1056,22 @@ func (cs *ChainStore) GetGenesis() (*types.BlockHeader, error) {
return nil, err return nil, err
} }
return cs.GetBlock(c) return cs.GetBlock(ctx, c)
} }
// GetPath returns the sequence of atomic head change operations that // GetPath returns the sequence of atomic head change operations that
// need to be applied in order to switch the head of the chain from the `from` // need to be applied in order to switch the head of the chain from the `from`
// tipset to the `to` tipset. // tipset to the `to` tipset.
func (cs *ChainStore) GetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*api.HeadChange, error) { func (cs *ChainStore) GetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*api.HeadChange, error) {
fts, err := cs.LoadTipSet(from) fts, err := cs.LoadTipSet(ctx, from)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading from tipset %s: %w", from, err) return nil, xerrors.Errorf("loading from tipset %s: %w", from, err)
} }
tts, err := cs.LoadTipSet(to) tts, err := cs.LoadTipSet(ctx, to)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading to tipset %s: %w", to, err) return nil, xerrors.Errorf("loading to tipset %s: %w", to, err)
} }
revert, apply, err := cs.ReorgOps(fts, tts) revert, apply, err := cs.ReorgOps(ctx, fts, tts)
if err != nil { if err != nil {
return nil, xerrors.Errorf("error getting tipset branches: %w", err) return nil, xerrors.Errorf("error getting tipset branches: %w", err)
} }
@ -1154,7 +1154,7 @@ func (cs *ChainStore) GetTipsetByHeight(ctx context.Context, h abi.ChainEpoch, t
if lbts.Height() < h { if lbts.Height() < h {
log.Warnf("chain index returned the wrong tipset at height %d, using slow retrieval", h) log.Warnf("chain index returned the wrong tipset at height %d, using slow retrieval", h)
lbts, err = cs.cindex.GetTipsetByHeightWithoutCache(ts, h) lbts, err = cs.cindex.GetTipsetByHeightWithoutCache(ctx, ts, h)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -1164,7 +1164,7 @@ func (cs *ChainStore) GetTipsetByHeight(ctx context.Context, h abi.ChainEpoch, t
return lbts, nil return lbts, nil
} }
return cs.LoadTipSet(lbts.Parents()) return cs.LoadTipSet(ctx, lbts.Parents())
} }
func (cs *ChainStore) Weight(ctx context.Context, hts *types.TipSet) (types.BigInt, error) { // todo remove func (cs *ChainStore) Weight(ctx context.Context, hts *types.TipSet) (types.BigInt, error) { // todo remove
@ -1190,14 +1190,14 @@ func breakWeightTie(ts1, ts2 *types.TipSet) bool {
return false return false
} }
func (cs *ChainStore) GetTipSetFromKey(tsk types.TipSetKey) (*types.TipSet, error) { func (cs *ChainStore) GetTipSetFromKey(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
if tsk.IsEmpty() { if tsk.IsEmpty() {
return cs.GetHeaviestTipSet(), nil return cs.GetHeaviestTipSet(), nil
} }
return cs.LoadTipSet(tsk) return cs.LoadTipSet(ctx, tsk)
} }
func (cs *ChainStore) GetLatestBeaconEntry(ts *types.TipSet) (*types.BeaconEntry, error) { func (cs *ChainStore) GetLatestBeaconEntry(ctx context.Context, ts *types.TipSet) (*types.BeaconEntry, error) {
cur := ts cur := ts
for i := 0; i < 20; i++ { for i := 0; i < 20; i++ {
cbe := cur.Blocks()[0].BeaconEntries cbe := cur.Blocks()[0].BeaconEntries
@ -1209,7 +1209,7 @@ func (cs *ChainStore) GetLatestBeaconEntry(ts *types.TipSet) (*types.BeaconEntry
return nil, xerrors.Errorf("made it back to genesis block without finding beacon entry") return nil, xerrors.Errorf("made it back to genesis block without finding beacon entry")
} }
next, err := cs.LoadTipSet(cur.Parents()) next, err := cs.LoadTipSet(ctx, cur.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load parents when searching back for latest beacon entry: %w", err) return nil, xerrors.Errorf("failed to load parents when searching back for latest beacon entry: %w", err)
} }

32
chain/sync.go
View File

@ -119,8 +119,8 @@ type SyncManagerCtor func(syncFn SyncFunc) SyncManager
type Genesis *types.TipSet type Genesis *types.TipSet
func LoadGenesis(sm *stmgr.StateManager) (Genesis, error) { func LoadGenesis(ctx context.Context, sm *stmgr.StateManager) (Genesis, error) {
gen, err := sm.ChainStore().GetGenesis() gen, err := sm.ChainStore().GetGenesis(ctx)
if err != nil { if err != nil {
return nil, xerrors.Errorf("getting genesis block: %w", err) return nil, xerrors.Errorf("getting genesis block: %w", err)
} }
@ -227,7 +227,7 @@ func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool {
// TODO: IMPORTANT(GARBAGE) this needs to be put in the 'temporary' side of // TODO: IMPORTANT(GARBAGE) this needs to be put in the 'temporary' side of
// the blockstore // the blockstore
if err := syncer.store.PersistBlockHeaders(fts.TipSet().Blocks()...); err != nil { if err := syncer.store.PersistBlockHeaders(ctx, fts.TipSet().Blocks()...); err != nil {
log.Warn("failed to persist incoming block header: ", err) log.Warn("failed to persist incoming block header: ", err)
return false return false
} }
@ -360,7 +360,7 @@ func copyBlockstore(ctx context.Context, from, to bstore.Blockstore) error {
// TODO: should probably expose better methods on the blockstore for this operation // TODO: should probably expose better methods on the blockstore for this operation
var blks []blocks.Block var blks []blocks.Block
for c := range cids { for c := range cids {
b, err := from.Get(c) b, err := from.Get(ctx, c)
if err != nil { if err != nil {
return err return err
} }
@ -368,7 +368,7 @@ func copyBlockstore(ctx context.Context, from, to bstore.Blockstore) error {
blks = append(blks, b) blks = append(blks, b)
} }
if err := to.PutMany(blks); err != nil { if err := to.PutMany(ctx, blks); err != nil {
return err return err
} }
@ -463,7 +463,7 @@ func computeMsgMeta(bs cbor.IpldStore, bmsgCids, smsgCids []cid.Cid) (cid.Cid, e
// {hint/usage} This is used from the HELLO protocol, to fetch the greeting // {hint/usage} This is used from the HELLO protocol, to fetch the greeting
// peer's heaviest tipset if we don't have it. // peer's heaviest tipset if we don't have it.
func (syncer *Syncer) FetchTipSet(ctx context.Context, p peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error) { func (syncer *Syncer) FetchTipSet(ctx context.Context, p peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error) {
if fts, err := syncer.tryLoadFullTipSet(tsk); err == nil { if fts, err := syncer.tryLoadFullTipSet(ctx, tsk); err == nil {
return fts, nil return fts, nil
} }
@ -474,8 +474,8 @@ func (syncer *Syncer) FetchTipSet(ctx context.Context, p peer.ID, tsk types.TipS
// tryLoadFullTipSet queries the tipset in the ChainStore, and returns a full // tryLoadFullTipSet queries the tipset in the ChainStore, and returns a full
// representation of it containing FullBlocks. If ALL blocks are not found // representation of it containing FullBlocks. If ALL blocks are not found
// locally, it errors entirely with blockstore.ErrNotFound. // locally, it errors entirely with blockstore.ErrNotFound.
func (syncer *Syncer) tryLoadFullTipSet(tsk types.TipSetKey) (*store.FullTipSet, error) { func (syncer *Syncer) tryLoadFullTipSet(ctx context.Context, tsk types.TipSetKey) (*store.FullTipSet, error) {
ts, err := syncer.store.LoadTipSet(tsk) ts, err := syncer.store.LoadTipSet(ctx, tsk)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -583,7 +583,7 @@ func (syncer *Syncer) ValidateTipSet(ctx context.Context, fts *store.FullTipSet,
return xerrors.Errorf("validating block %s: %w", b.Cid(), err) return xerrors.Errorf("validating block %s: %w", b.Cid(), err)
} }
if err := syncer.sm.ChainStore().AddToTipSetTracker(b.Header); err != nil { if err := syncer.sm.ChainStore().AddToTipSetTracker(ctx, b.Header); err != nil {
return xerrors.Errorf("failed to add validated header to tipset tracker: %w", err) return xerrors.Errorf("failed to add validated header to tipset tracker: %w", err)
} }
return nil return nil
@ -755,7 +755,7 @@ loop:
} }
// If, for some reason, we have a suffix of the chain locally, handle that here // If, for some reason, we have a suffix of the chain locally, handle that here
ts, err := syncer.store.LoadTipSet(at) ts, err := syncer.store.LoadTipSet(ctx, at)
if err == nil { if err == nil {
acceptedBlocks = append(acceptedBlocks, at.Cids()...) acceptedBlocks = append(acceptedBlocks, at.Cids()...)
@ -838,7 +838,7 @@ loop:
return blockSet, nil return blockSet, nil
} }
knownParent, err := syncer.store.LoadTipSet(known.Parents()) knownParent, err := syncer.store.LoadTipSet(ctx, known.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load next local tipset: %w", err) return nil, xerrors.Errorf("failed to load next local tipset: %w", err)
} }
@ -892,7 +892,7 @@ func (syncer *Syncer) syncFork(ctx context.Context, incoming *types.TipSet, know
return nil, err return nil, err
} }
nts, err := syncer.store.LoadTipSet(known.Parents()) nts, err := syncer.store.LoadTipSet(ctx, known.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load next local tipset: %w", err) return nil, xerrors.Errorf("failed to load next local tipset: %w", err)
} }
@ -928,7 +928,7 @@ func (syncer *Syncer) syncFork(ctx context.Context, incoming *types.TipSet, know
return nil, ErrForkCheckpoint return nil, ErrForkCheckpoint
} }
nts, err = syncer.store.LoadTipSet(nts.Parents()) nts, err = syncer.store.LoadTipSet(ctx, nts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading next local tipset: %w", err) return nil, xerrors.Errorf("loading next local tipset: %w", err)
} }
@ -1201,7 +1201,7 @@ func (syncer *Syncer) collectChain(ctx context.Context, ts *types.TipSet, hts *t
for _, ts := range headers { for _, ts := range headers {
toPersist = append(toPersist, ts.Blocks()...) toPersist = append(toPersist, ts.Blocks()...)
} }
if err := syncer.store.PersistBlockHeaders(toPersist...); err != nil { if err := syncer.store.PersistBlockHeaders(ctx, toPersist...); err != nil {
err = xerrors.Errorf("failed to persist synced blocks to the chainstore: %w", err) err = xerrors.Errorf("failed to persist synced blocks to the chainstore: %w", err)
ss.Error(err) ss.Error(err)
return err return err
@ -1245,7 +1245,7 @@ func (syncer *Syncer) CheckBadBlockCache(blk cid.Cid) (string, bool) {
return bbr.String(), ok return bbr.String(), ok
} }
func (syncer *Syncer) getLatestBeaconEntry(_ context.Context, ts *types.TipSet) (*types.BeaconEntry, error) { func (syncer *Syncer) getLatestBeaconEntry(ctx context.Context, ts *types.TipSet) (*types.BeaconEntry, error) {
cur := ts cur := ts
for i := 0; i < 20; i++ { for i := 0; i < 20; i++ {
cbe := cur.Blocks()[0].BeaconEntries cbe := cur.Blocks()[0].BeaconEntries
@ -1257,7 +1257,7 @@ func (syncer *Syncer) getLatestBeaconEntry(_ context.Context, ts *types.TipSet)
return nil, xerrors.Errorf("made it back to genesis block without finding beacon entry") return nil, xerrors.Errorf("made it back to genesis block without finding beacon entry")
} }
next, err := syncer.store.LoadTipSet(cur.Parents()) next, err := syncer.store.LoadTipSet(ctx, cur.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to load parents when searching back for latest beacon entry: %w", err) return nil, xerrors.Errorf("failed to load parents when searching back for latest beacon entry: %w", err)
} }

26
chain/vm/vm.go
View File

@ -82,10 +82,10 @@ type gasChargingBlocks struct {
under cbor.IpldBlockstore under cbor.IpldBlockstore
} }
func (bs *gasChargingBlocks) View(c cid.Cid, cb func([]byte) error) error { func (bs *gasChargingBlocks) View(ctx context.Context, c cid.Cid, cb func([]byte) error) error {
if v, ok := bs.under.(blockstore.Viewer); ok { if v, ok := bs.under.(blockstore.Viewer); ok {
bs.chargeGas(bs.pricelist.OnIpldGet()) bs.chargeGas(bs.pricelist.OnIpldGet())
return v.View(c, func(b []byte) error { return v.View(ctx, c, func(b []byte) error {
// we have successfully retrieved the value; charge for it, even if the user-provided function fails. // we have successfully retrieved the value; charge for it, even if the user-provided function fails.
bs.chargeGas(newGasCharge("OnIpldViewEnd", 0, 0).WithExtra(len(b))) bs.chargeGas(newGasCharge("OnIpldViewEnd", 0, 0).WithExtra(len(b)))
bs.chargeGas(gasOnActorExec) bs.chargeGas(gasOnActorExec)
@ -93,16 +93,16 @@ func (bs *gasChargingBlocks) View(c cid.Cid, cb func([]byte) error) error {
}) })
} }
// the underlying blockstore doesn't implement the viewer interface, fall back to normal Get behaviour. // the underlying blockstore doesn't implement the viewer interface, fall back to normal Get behaviour.
blk, err := bs.Get(c) blk, err := bs.Get(ctx, c)
if err == nil && blk != nil { if err == nil && blk != nil {
return cb(blk.RawData()) return cb(blk.RawData())
} }
return err return err
} }
func (bs *gasChargingBlocks) Get(c cid.Cid) (block.Block, error) { func (bs *gasChargingBlocks) Get(ctx context.Context, c cid.Cid) (block.Block, error) {
bs.chargeGas(bs.pricelist.OnIpldGet()) bs.chargeGas(bs.pricelist.OnIpldGet())
blk, err := bs.under.Get(c) blk, err := bs.under.Get(ctx, c)
if err != nil { if err != nil {
return nil, aerrors.Escalate(err, "failed to get block from blockstore") return nil, aerrors.Escalate(err, "failed to get block from blockstore")
} }
@ -112,10 +112,10 @@ func (bs *gasChargingBlocks) Get(c cid.Cid) (block.Block, error) {
return blk, nil return blk, nil
} }
func (bs *gasChargingBlocks) Put(blk block.Block) error { func (bs *gasChargingBlocks) Put(ctx context.Context, blk block.Block) error {
bs.chargeGas(bs.pricelist.OnIpldPut(len(blk.RawData()))) bs.chargeGas(bs.pricelist.OnIpldPut(len(blk.RawData())))
if err := bs.under.Put(blk); err != nil { if err := bs.under.Put(ctx, blk); err != nil {
return aerrors.Escalate(err, "failed to write data to disk") return aerrors.Escalate(err, "failed to write data to disk")
} }
bs.chargeGas(gasOnActorExec) bs.chargeGas(gasOnActorExec)
@ -706,7 +706,7 @@ func Copy(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid) err
go func() { go func() {
for b := range toFlush { for b := range toFlush {
if err := to.PutMany(b); err != nil { if err := to.PutMany(ctx, b); err != nil {
close(freeBufs) close(freeBufs)
errFlushChan <- xerrors.Errorf("batch put in copy: %w", err) errFlushChan <- xerrors.Errorf("batch put in copy: %w", err)
return return
@ -735,7 +735,7 @@ func Copy(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid) err
return nil return nil
} }
if err := copyRec(from, to, root, batchCp); err != nil { if err := copyRec(ctx, from, to, root, batchCp); err != nil {
return xerrors.Errorf("copyRec: %w", err) return xerrors.Errorf("copyRec: %w", err)
} }
@ -760,13 +760,13 @@ func Copy(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid) err
return nil return nil
} }
func copyRec(from, to blockstore.Blockstore, root cid.Cid, cp func(block.Block) error) error { func copyRec(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid, cp func(block.Block) error) error {
if root.Prefix().MhType == 0 { if root.Prefix().MhType == 0 {
// identity cid, skip // identity cid, skip
return nil return nil
} }
blk, err := from.Get(root) blk, err := from.Get(ctx, root)
if err != nil { if err != nil {
return xerrors.Errorf("get %s failed: %w", root, err) return xerrors.Errorf("get %s failed: %w", root, err)
} }
@ -791,7 +791,7 @@ func copyRec(from, to blockstore.Blockstore, root cid.Cid, cp func(block.Block)
} }
} else { } else {
// If we have an object, we already have its children, skip the object. // If we have an object, we already have its children, skip the object.
has, err := to.Has(link) has, err := to.Has(ctx, link)
if err != nil { if err != nil {
lerr = xerrors.Errorf("has: %w", err) lerr = xerrors.Errorf("has: %w", err)
return return
@ -801,7 +801,7 @@ func copyRec(from, to blockstore.Blockstore, root cid.Cid, cp func(block.Block)
} }
} }
if err := copyRec(from, to, link, cp); err != nil { if err := copyRec(ctx, from, to, link, cp); err != nil {
lerr = err lerr = err
return return
} }

22
chain/wallet/ledger/ledger.go
View File

@ -39,7 +39,7 @@ type LedgerKeyInfo struct {
var _ api.Wallet = (*LedgerWallet)(nil) var _ api.Wallet = (*LedgerWallet)(nil)
func (lw LedgerWallet) WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta api.MsgMeta) (*crypto.Signature, error) { func (lw LedgerWallet) WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta api.MsgMeta) (*crypto.Signature, error) {
ki, err := lw.getKeyInfo(signer) ki, err := lw.getKeyInfo(ctx, signer)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -80,8 +80,8 @@ func (lw LedgerWallet) WalletSign(ctx context.Context, signer address.Address, t
}, nil }, nil
} }
func (lw LedgerWallet) getKeyInfo(addr address.Address) (*LedgerKeyInfo, error) { func (lw LedgerWallet) getKeyInfo(ctx context.Context, addr address.Address) (*LedgerKeyInfo, error) {
kib, err := lw.ds.Get(keyForAddr(addr)) kib, err := lw.ds.Get(ctx, keyForAddr(addr))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -95,7 +95,7 @@ func (lw LedgerWallet) getKeyInfo(addr address.Address) (*LedgerKeyInfo, error)
} }
func (lw LedgerWallet) WalletDelete(ctx context.Context, k address.Address) error { func (lw LedgerWallet) WalletDelete(ctx context.Context, k address.Address) error {
return lw.ds.Delete(keyForAddr(k)) return lw.ds.Delete(ctx, keyForAddr(k))
} }
func (lw LedgerWallet) WalletExport(ctx context.Context, k address.Address) (*types.KeyInfo, error) { func (lw LedgerWallet) WalletExport(ctx context.Context, k address.Address) (*types.KeyInfo, error) {
@ -103,7 +103,7 @@ func (lw LedgerWallet) WalletExport(ctx context.Context, k address.Address) (*ty
} }
func (lw LedgerWallet) WalletHas(ctx context.Context, k address.Address) (bool, error) { func (lw LedgerWallet) WalletHas(ctx context.Context, k address.Address) (bool, error) {
_, err := lw.ds.Get(keyForAddr(k)) _, err := lw.ds.Get(ctx, keyForAddr(k))
if err == nil { if err == nil {
return true, nil return true, nil
} }
@ -118,10 +118,10 @@ func (lw LedgerWallet) WalletImport(ctx context.Context, kinfo *types.KeyInfo) (
if err := json.Unmarshal(kinfo.PrivateKey, &ki); err != nil { if err := json.Unmarshal(kinfo.PrivateKey, &ki); err != nil {
return address.Undef, err return address.Undef, err
} }
return lw.importKey(ki) return lw.importKey(ctx, ki)
} }
func (lw LedgerWallet) importKey(ki LedgerKeyInfo) (address.Address, error) { func (lw LedgerWallet) importKey(ctx context.Context, ki LedgerKeyInfo) (address.Address, error) {
if ki.Address == address.Undef { if ki.Address == address.Undef {
return address.Undef, fmt.Errorf("no address given in imported key info") return address.Undef, fmt.Errorf("no address given in imported key info")
} }
@ -133,7 +133,7 @@ func (lw LedgerWallet) importKey(ki LedgerKeyInfo) (address.Address, error) {
return address.Undef, xerrors.Errorf("marshaling key info: %w", err) return address.Undef, xerrors.Errorf("marshaling key info: %w", err)
} }
if err := lw.ds.Put(keyForAddr(ki.Address), bb); err != nil { if err := lw.ds.Put(ctx, keyForAddr(ki.Address), bb); err != nil {
return address.Undef, err return address.Undef, err
} }
@ -141,7 +141,7 @@ func (lw LedgerWallet) importKey(ki LedgerKeyInfo) (address.Address, error) {
} }
func (lw LedgerWallet) WalletList(ctx context.Context) ([]address.Address, error) { func (lw LedgerWallet) WalletList(ctx context.Context) ([]address.Address, error) {
res, err := lw.ds.Query(query.Query{Prefix: dsLedgerPrefix}) res, err := lw.ds.Query(ctx, query.Query{Prefix: dsLedgerPrefix})
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -175,7 +175,7 @@ func (lw LedgerWallet) WalletNew(ctx context.Context, t types.KeyType) (address.
t, types.KTSecp256k1Ledger) t, types.KTSecp256k1Ledger)
} }
res, err := lw.ds.Query(query.Query{Prefix: dsLedgerPrefix}) res, err := lw.ds.Query(ctx, query.Query{Prefix: dsLedgerPrefix})
if err != nil { if err != nil {
return address.Undef, err return address.Undef, err
} }
@ -224,7 +224,7 @@ func (lw LedgerWallet) WalletNew(ctx context.Context, t types.KeyType) (address.
lki.Address = a lki.Address = a
lki.Path = path lki.Path = path
return lw.importKey(lki) return lw.importKey(ctx, lki)
} }
func (lw *LedgerWallet) Get() api.Wallet { func (lw *LedgerWallet) Get() api.Wallet {

2
cli/backup.go
View File

@ -66,7 +66,7 @@ func BackupCmd(repoFlag string, rt repo.RepoType, getApi BackupApiFn) *cli.Comma
return xerrors.Errorf("opening backup file %s: %w", fpath, err) return xerrors.Errorf("opening backup file %s: %w", fpath, err)
} }
if err := bds.Backup(out); err != nil { if err := bds.Backup(cctx.Context, out); err != nil {
if cerr := out.Close(); cerr != nil { if cerr := out.Close(); cerr != nil {
log.Errorw("error closing backup file while handling backup error", "closeErr", cerr, "backupErr", err) log.Errorw("error closing backup file while handling backup error", "closeErr", cerr, "backupErr", err)
} }

8
go.mod
View File

@ -36,7 +36,7 @@ require (
github.com/filecoin-project/go-data-transfer v1.12.0 github.com/filecoin-project/go-data-transfer v1.12.0
github.com/filecoin-project/go-fil-commcid v0.1.0 github.com/filecoin-project/go-fil-commcid v0.1.0
github.com/filecoin-project/go-fil-commp-hashhash v0.1.0 github.com/filecoin-project/go-fil-commp-hashhash v0.1.0
github.com/filecoin-project/go-fil-markets v1.13.3-0.20211211193119-ab98aecd0969 github.com/filecoin-project/go-fil-markets v1.13.3-0.20211211202606-e111ec29d24d
github.com/filecoin-project/go-jsonrpc v0.1.5 github.com/filecoin-project/go-jsonrpc v0.1.5
github.com/filecoin-project/go-padreader v0.0.1 github.com/filecoin-project/go-padreader v0.0.1
github.com/filecoin-project/go-paramfetch v0.0.2 github.com/filecoin-project/go-paramfetch v0.0.2
@ -74,7 +74,7 @@ require (
github.com/ipfs/go-datastore v0.5.1 github.com/ipfs/go-datastore v0.5.1
github.com/ipfs/go-ds-badger2 v0.1.2-0.20211119002906-7318f1b76158 github.com/ipfs/go-ds-badger2 v0.1.2-0.20211119002906-7318f1b76158
github.com/ipfs/go-ds-leveldb v0.5.0 github.com/ipfs/go-ds-leveldb v0.5.0
github.com/ipfs/go-ds-measure v0.1.0 github.com/ipfs/go-ds-measure v0.2.0
github.com/ipfs/go-ds-pebble v0.0.2-0.20200921225637-ce220f8ac459 github.com/ipfs/go-ds-pebble v0.0.2-0.20200921225637-ce220f8ac459
github.com/ipfs/go-fs-lock v0.0.6 github.com/ipfs/go-fs-lock v0.0.6
github.com/ipfs/go-graphsync v0.11.0 github.com/ipfs/go-graphsync v0.11.0
@ -88,7 +88,7 @@ require (
github.com/ipfs/go-ipfs-http-client v0.0.6 github.com/ipfs/go-ipfs-http-client v0.0.6
github.com/ipfs/go-ipfs-routing v0.2.1 github.com/ipfs/go-ipfs-routing v0.2.1
github.com/ipfs/go-ipfs-util v0.0.2 github.com/ipfs/go-ipfs-util v0.0.2
github.com/ipfs/go-ipld-cbor v0.0.5 github.com/ipfs/go-ipld-cbor v0.0.6-0.20211211202953-0412412d04c4
github.com/ipfs/go-ipld-format v0.2.0 github.com/ipfs/go-ipld-format v0.2.0
github.com/ipfs/go-log/v2 v2.3.0 github.com/ipfs/go-log/v2 v2.3.0
github.com/ipfs/go-merkledag v0.5.1 github.com/ipfs/go-merkledag v0.5.1
@ -109,7 +109,7 @@ require (
github.com/libp2p/go-libp2p-connmgr v0.2.4 github.com/libp2p/go-libp2p-connmgr v0.2.4
github.com/libp2p/go-libp2p-core v0.11.0 github.com/libp2p/go-libp2p-core v0.11.0
github.com/libp2p/go-libp2p-discovery v0.6.0 github.com/libp2p/go-libp2p-discovery v0.6.0
github.com/libp2p/go-libp2p-kad-dht v0.13.0 github.com/libp2p/go-libp2p-kad-dht v0.15.0
github.com/libp2p/go-libp2p-noise v0.3.0 github.com/libp2p/go-libp2p-noise v0.3.0
github.com/libp2p/go-libp2p-peerstore v0.4.0 github.com/libp2p/go-libp2p-peerstore v0.4.0
github.com/libp2p/go-libp2p-pubsub v0.5.6 github.com/libp2p/go-libp2p-pubsub v0.5.6

16
go.sum
View File

@ -334,8 +334,8 @@ github.com/filecoin-project/go-fil-commcid v0.1.0 h1:3R4ds1A9r6cr8mvZBfMYxTS88Oq
github.com/filecoin-project/go-fil-commcid v0.1.0/go.mod h1:Eaox7Hvus1JgPrL5+M3+h7aSPHc0cVqpSxA+TxIEpZQ= github.com/filecoin-project/go-fil-commcid v0.1.0/go.mod h1:Eaox7Hvus1JgPrL5+M3+h7aSPHc0cVqpSxA+TxIEpZQ=
github.com/filecoin-project/go-fil-commp-hashhash v0.1.0 h1:imrrpZWEHRnNqqv0tN7LXep5bFEVOVmQWHJvl2mgsGo= github.com/filecoin-project/go-fil-commp-hashhash v0.1.0 h1:imrrpZWEHRnNqqv0tN7LXep5bFEVOVmQWHJvl2mgsGo=
github.com/filecoin-project/go-fil-commp-hashhash v0.1.0/go.mod h1:73S8WSEWh9vr0fDJVnKADhfIv/d6dCbAGaAGWbdJEI8= github.com/filecoin-project/go-fil-commp-hashhash v0.1.0/go.mod h1:73S8WSEWh9vr0fDJVnKADhfIv/d6dCbAGaAGWbdJEI8=
github.com/filecoin-project/go-fil-markets v1.13.3-0.20211211193119-ab98aecd0969 h1:5N/aEyr+uuJC1dd+rdFgV+RQT7o6LqfkshSh8en3YiI= github.com/filecoin-project/go-fil-markets v1.13.3-0.20211211202606-e111ec29d24d h1:TkBhjnKRNKrOxnESYqMQRjMbzK/NayYg1oxejxF1cGg=
github.com/filecoin-project/go-fil-markets v1.13.3-0.20211211193119-ab98aecd0969/go.mod h1:vXOHH3q2+zLk929W+lIq3etuDFTyJJ8nG2DwGHG2R1E= github.com/filecoin-project/go-fil-markets v1.13.3-0.20211211202606-e111ec29d24d/go.mod h1:vXOHH3q2+zLk929W+lIq3etuDFTyJJ8nG2DwGHG2R1E=
github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM= github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM=
github.com/filecoin-project/go-hamt-ipld v0.1.5/go.mod h1:6Is+ONR5Cd5R6XZoCse1CWaXZc0Hdb/JeX+EQCQzX24= github.com/filecoin-project/go-hamt-ipld v0.1.5/go.mod h1:6Is+ONR5Cd5R6XZoCse1CWaXZc0Hdb/JeX+EQCQzX24=
github.com/filecoin-project/go-hamt-ipld/v2 v2.0.0 h1:b3UDemBYN2HNfk3KOXNuxgTTxlWi3xVvbQP0IT38fvM= github.com/filecoin-project/go-hamt-ipld/v2 v2.0.0 h1:b3UDemBYN2HNfk3KOXNuxgTTxlWi3xVvbQP0IT38fvM=
@ -693,7 +693,6 @@ github.com/ipfs/go-datastore v0.0.1/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAK
github.com/ipfs/go-datastore v0.0.5/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= github.com/ipfs/go-datastore v0.0.5/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
github.com/ipfs/go-datastore v0.1.0/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= github.com/ipfs/go-datastore v0.1.0/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
github.com/ipfs/go-datastore v0.1.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw= github.com/ipfs/go-datastore v0.1.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
github.com/ipfs/go-datastore v0.3.0/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
github.com/ipfs/go-datastore v0.3.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw= github.com/ipfs/go-datastore v0.3.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
github.com/ipfs/go-datastore v0.4.0/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA= github.com/ipfs/go-datastore v0.4.0/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
github.com/ipfs/go-datastore v0.4.1/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA= github.com/ipfs/go-datastore v0.4.1/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
@ -722,8 +721,8 @@ github.com/ipfs/go-ds-leveldb v0.4.1/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1
github.com/ipfs/go-ds-leveldb v0.4.2/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1Ii2r79Hh9s= github.com/ipfs/go-ds-leveldb v0.4.2/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1Ii2r79Hh9s=
github.com/ipfs/go-ds-leveldb v0.5.0 h1:s++MEBbD3ZKc9/8/njrn4flZLnCuY9I79v94gBUNumo= github.com/ipfs/go-ds-leveldb v0.5.0 h1:s++MEBbD3ZKc9/8/njrn4flZLnCuY9I79v94gBUNumo=
github.com/ipfs/go-ds-leveldb v0.5.0/go.mod h1:d3XG9RUDzQ6V4SHi8+Xgj9j1XuEk1z82lquxrVbml/Q= github.com/ipfs/go-ds-leveldb v0.5.0/go.mod h1:d3XG9RUDzQ6V4SHi8+Xgj9j1XuEk1z82lquxrVbml/Q=
github.com/ipfs/go-ds-measure v0.1.0 h1:vE4TyY4aeLeVgnnPBC5QzKIjKrqzha0NCujTfgvVbVQ= github.com/ipfs/go-ds-measure v0.2.0 h1:sG4goQe0KDTccHMyT45CY1XyUbxe5VwTKpg2LjApYyQ=
github.com/ipfs/go-ds-measure v0.1.0/go.mod h1:1nDiFrhLlwArTME1Ees2XaBOl49OoCgd2A3f8EchMSY= github.com/ipfs/go-ds-measure v0.2.0/go.mod h1:SEUD/rE2PwRa4IQEC5FuNAmjJCyYObZr9UvVh8V3JxE=
github.com/ipfs/go-ds-pebble v0.0.2-0.20200921225637-ce220f8ac459 h1:W3YMLEvOXqdW+sYMiguhWP6txJwQvIQqhvpU8yAMGQs= github.com/ipfs/go-ds-pebble v0.0.2-0.20200921225637-ce220f8ac459 h1:W3YMLEvOXqdW+sYMiguhWP6txJwQvIQqhvpU8yAMGQs=
github.com/ipfs/go-ds-pebble v0.0.2-0.20200921225637-ce220f8ac459/go.mod h1:oh4liWHulKcDKVhCska5NLelE3MatWl+1FwSz3tY91g= github.com/ipfs/go-ds-pebble v0.0.2-0.20200921225637-ce220f8ac459/go.mod h1:oh4liWHulKcDKVhCska5NLelE3MatWl+1FwSz3tY91g=
github.com/ipfs/go-filestore v1.1.0 h1:Pu4tLBi1bucu6/HU9llaOmb9yLFk/sgP+pW764zNDoE= github.com/ipfs/go-filestore v1.1.0 h1:Pu4tLBi1bucu6/HU9llaOmb9yLFk/sgP+pW764zNDoE=
@ -785,8 +784,9 @@ github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdr
github.com/ipfs/go-ipld-cbor v0.0.2/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc= github.com/ipfs/go-ipld-cbor v0.0.2/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc=
github.com/ipfs/go-ipld-cbor v0.0.3/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc= github.com/ipfs/go-ipld-cbor v0.0.3/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc=
github.com/ipfs/go-ipld-cbor v0.0.4/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4= github.com/ipfs/go-ipld-cbor v0.0.4/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4=
github.com/ipfs/go-ipld-cbor v0.0.5 h1:ovz4CHKogtG2KB/h1zUp5U0c/IzZrL435rCh5+K/5G8=
github.com/ipfs/go-ipld-cbor v0.0.5/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4= github.com/ipfs/go-ipld-cbor v0.0.5/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4=
github.com/ipfs/go-ipld-cbor v0.0.6-0.20211211202953-0412412d04c4 h1:is/7IfZF1xug/95JAvZKTVvJrqnrXpSRNgBQORiqQf4=
github.com/ipfs/go-ipld-cbor v0.0.6-0.20211211202953-0412412d04c4/go.mod h1:ssdxxaLJPXH7OjF5V4NSjBbcfh+evoR4ukuru0oPXMA=
github.com/ipfs/go-ipld-format v0.0.1/go.mod h1:kyJtbkDALmFHv3QR6et67i35QzO3S0dCDnkOJhcZkms= github.com/ipfs/go-ipld-format v0.0.1/go.mod h1:kyJtbkDALmFHv3QR6et67i35QzO3S0dCDnkOJhcZkms=
github.com/ipfs/go-ipld-format v0.0.2/go.mod h1:4B6+FM2u9OJ9zCV+kSbgFAZlOrv1Hqbf0INGQgiKf9k= github.com/ipfs/go-ipld-format v0.0.2/go.mod h1:4B6+FM2u9OJ9zCV+kSbgFAZlOrv1Hqbf0INGQgiKf9k=
github.com/ipfs/go-ipld-format v0.2.0 h1:xGlJKkArkmBvowr+GMCX0FEZtkro71K1AwiKnL37mwA= github.com/ipfs/go-ipld-format v0.2.0 h1:xGlJKkArkmBvowr+GMCX0FEZtkro71K1AwiKnL37mwA=
@ -1082,8 +1082,8 @@ github.com/libp2p/go-libp2p-interface-connmgr v0.0.4/go.mod h1:GarlRLH0LdeWcLnYM
github.com/libp2p/go-libp2p-interface-connmgr v0.0.5/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k= github.com/libp2p/go-libp2p-interface-connmgr v0.0.5/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k=
github.com/libp2p/go-libp2p-interface-pnet v0.0.1/go.mod h1:el9jHpQAXK5dnTpKA4yfCNBZXvrzdOU75zz+C6ryp3k= github.com/libp2p/go-libp2p-interface-pnet v0.0.1/go.mod h1:el9jHpQAXK5dnTpKA4yfCNBZXvrzdOU75zz+C6ryp3k=
github.com/libp2p/go-libp2p-kad-dht v0.2.1/go.mod h1:k7ONOlup7HKzQ68dE6lSnp07cdxdkmnRa+6B4Fh9/w0= github.com/libp2p/go-libp2p-kad-dht v0.2.1/go.mod h1:k7ONOlup7HKzQ68dE6lSnp07cdxdkmnRa+6B4Fh9/w0=
github.com/libp2p/go-libp2p-kad-dht v0.13.0 h1:qBNYzee8BVS6RkD8ukIAGRG6LmVz8+kkeponyI7W+yA= github.com/libp2p/go-libp2p-kad-dht v0.15.0 h1:Ke+Oj78gX5UDXnA6HBdrgvi+fStJxgYTDa51U0TsCLo=
github.com/libp2p/go-libp2p-kad-dht v0.13.0/go.mod h1:NkGf28RNhPrcsGYWJHm6EH8ULkiJ2qxsWmpE7VTL3LI= github.com/libp2p/go-libp2p-kad-dht v0.15.0/go.mod h1:rZtPxYu1TnHHz6n1RggdGrxUX/tA1C2/Wiw3ZMUDrU0=
github.com/libp2p/go-libp2p-kbucket v0.2.1/go.mod h1:/Rtu8tqbJ4WQ2KTCOMJhggMukOLNLNPY1EtEWWLxUvc= github.com/libp2p/go-libp2p-kbucket v0.2.1/go.mod h1:/Rtu8tqbJ4WQ2KTCOMJhggMukOLNLNPY1EtEWWLxUvc=
github.com/libp2p/go-libp2p-kbucket v0.3.1/go.mod h1:oyjT5O7tS9CQurok++ERgc46YLwEpuGoFq9ubvoUOio= github.com/libp2p/go-libp2p-kbucket v0.3.1/go.mod h1:oyjT5O7tS9CQurok++ERgc46YLwEpuGoFq9ubvoUOio=
github.com/libp2p/go-libp2p-kbucket v0.4.7 h1:spZAcgxifvFZHBD8tErvppbnNiKA5uokDu3CV7axu70= github.com/libp2p/go-libp2p-kbucket v0.4.7 h1:spZAcgxifvFZHBD8tErvppbnNiKA5uokDu3CV7axu70=

7
markets/dagstore/blockstore.go
View File

@ -1,6 +1,7 @@
package dagstore package dagstore
import ( import (
"context"
"io" "io"
blocks "github.com/ipfs/go-block-format" blocks "github.com/ipfs/go-block-format"
@ -20,14 +21,14 @@ type Blockstore struct {
var _ bstore.Blockstore = (*Blockstore)(nil) var _ bstore.Blockstore = (*Blockstore)(nil)
func (b *Blockstore) DeleteBlock(c cid.Cid) error { func (b *Blockstore) DeleteBlock(context.Context, cid.Cid) error {
return xerrors.Errorf("DeleteBlock called but not implemented") return xerrors.Errorf("DeleteBlock called but not implemented")
} }
func (b *Blockstore) Put(block blocks.Block) error { func (b *Blockstore) Put(context.Context, blocks.Block) error {
return xerrors.Errorf("Put called but not implemented") return xerrors.Errorf("Put called but not implemented")
} }
func (b *Blockstore) PutMany(blocks []blocks.Block) error { func (b *Blockstore) PutMany(context.Context, []blocks.Block) error {
return xerrors.Errorf("PutMany called but not implemented") return xerrors.Errorf("PutMany called but not implemented")
} }

2
markets/storageadapter/provider.go
View File

@ -228,7 +228,7 @@ func (n *ProviderNodeAdapter) GetBalance(ctx context.Context, addr address.Addre
// TODO: why doesnt this method take in a sector ID? // TODO: why doesnt this method take in a sector ID?
func (n *ProviderNodeAdapter) LocatePieceForDealWithinSector(ctx context.Context, dealID abi.DealID, encodedTs shared.TipSetToken) (sectorID abi.SectorNumber, offset abi.PaddedPieceSize, length abi.PaddedPieceSize, err error) { func (n *ProviderNodeAdapter) LocatePieceForDealWithinSector(ctx context.Context, dealID abi.DealID, encodedTs shared.TipSetToken) (sectorID abi.SectorNumber, offset abi.PaddedPieceSize, length abi.PaddedPieceSize, err error) {
refs, err := n.secb.GetRefs(dealID) refs, err := n.secb.GetRefs(ctx, dealID)
if err != nil { if err != nil {
return 0, 0, 0, err return 0, 0, 0, err
} }

2
miner/miner.go
View File

@ -325,7 +325,7 @@ minerLoop:
"block-time", btime, "time", build.Clock.Now(), "difference", build.Clock.Since(btime)) "block-time", btime, "time", build.Clock.Now(), "difference", build.Clock.Since(btime))
} }
if err := m.sf.MinedBlock(b.Header, base.TipSet.Height()+base.NullRounds); err != nil { if err := m.sf.MinedBlock(ctx, b.Header, base.TipSet.Height()+base.NullRounds); err != nil {
log.Errorf("<!!> SLASH FILTER ERROR: %s", err) log.Errorf("<!!> SLASH FILTER ERROR: %s", err)
if os.Getenv("LOTUS_MINER_NO_SLASHFILTER") != "_yes_i_know_i_can_and_probably_will_lose_all_my_fil_and_power_" { if os.Getenv("LOTUS_MINER_NO_SLASHFILTER") != "_yes_i_know_i_can_and_probably_will_lose_all_my_fil_and_power_" {
continue continue

2
node/hello/hello.go
View File

@ -141,7 +141,7 @@ func (hs *Service) SayHello(ctx context.Context, pid peer.ID) error {
return err return err
} }
gen, err := hs.cs.GetGenesis() gen, err := hs.cs.GetGenesis(ctx)
if err != nil { if err != nil {
return err return err
} }

5
node/impl/backup.go
View File

@ -1,6 +1,7 @@
package impl package impl
import ( import (
"context"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
@ -12,7 +13,7 @@ import (
"github.com/filecoin-project/lotus/node/modules/dtypes" "github.com/filecoin-project/lotus/node/modules/dtypes"
) )
func backup(mds dtypes.MetadataDS, fpath string) error { func backup(ctx context.Context, mds dtypes.MetadataDS, fpath string) error {
bb, ok := os.LookupEnv("LOTUS_BACKUP_BASE_PATH") bb, ok := os.LookupEnv("LOTUS_BACKUP_BASE_PATH")
if !ok { if !ok {
return xerrors.Errorf("LOTUS_BACKUP_BASE_PATH env var not set") return xerrors.Errorf("LOTUS_BACKUP_BASE_PATH env var not set")
@ -52,7 +53,7 @@ func backup(mds dtypes.MetadataDS, fpath string) error {
return xerrors.Errorf("open %s: %w", fpath, err) return xerrors.Errorf("open %s: %w", fpath, err)
} }
if err := bds.Backup(out); err != nil { if err := bds.Backup(ctx, out); err != nil {
if cerr := out.Close(); cerr != nil { if cerr := out.Close(); cerr != nil {
log.Errorw("error closing backup file while handling backup error", "closeErr", cerr, "backupErr", err) log.Errorw("error closing backup file while handling backup error", "closeErr", cerr, "backupErr", err)
} }

8
node/impl/client/client.go
View File

@ -150,7 +150,7 @@ func (a *API) dealStarter(ctx context.Context, params *api.StartDealParams, isSt
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to find blockstore for root CID: %w", err) return nil, xerrors.Errorf("failed to find blockstore for root CID: %w", err)
} }
if has, err := bs.Has(params.Data.Root); err != nil { if has, err := bs.Has(ctx, params.Data.Root); err != nil {
return nil, xerrors.Errorf("failed to query blockstore for root CID: %w", err) return nil, xerrors.Errorf("failed to query blockstore for root CID: %w", err)
} else if !has { } else if !has {
return nil, xerrors.Errorf("failed to find root CID in blockstore: %w", err) return nil, xerrors.Errorf("failed to find root CID in blockstore: %w", err)
@ -520,7 +520,7 @@ func (a *API) ClientImport(ctx context.Context, ref api.FileRef) (res *api.Impor
} }
defer f.Close() //nolint:errcheck defer f.Close() //nolint:errcheck
hd, _, err := car.ReadHeader(bufio.NewReader(f)) hd, err := car.ReadHeader(bufio.NewReader(f))
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to read CAR header: %w", err) return nil, xerrors.Errorf("failed to read CAR header: %w", err)
} }
@ -1028,7 +1028,7 @@ func (a *API) outputCAR(ctx context.Context, ds format.DAGService, bs bstore.Blo
} }
if cs.Visit(c) { if cs.Visit(c) {
nb, err := bs.Get(c) nb, err := bs.Get(ctx, c)
if err != nil { if err != nil {
return xerrors.Errorf("getting block data: %w", err) return xerrors.Errorf("getting block data: %w", err)
} }
@ -1285,7 +1285,7 @@ func (a *API) ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet
} }
// check that the data is a car file; if it's not, retrieval won't work // check that the data is a car file; if it's not, retrieval won't work
_, _, err = car.ReadHeader(bufio.NewReader(rdr)) _, err = car.ReadHeader(bufio.NewReader(rdr))
if err != nil { if err != nil {
return nil, xerrors.Errorf("not a car file: %w", err) return nil, xerrors.Errorf("not a car file: %w", err)
} }

2
node/impl/full.go
View File

@ -42,7 +42,7 @@ type FullNodeAPI struct {
} }
func (n *FullNodeAPI) CreateBackup(ctx context.Context, fpath string) error { func (n *FullNodeAPI) CreateBackup(ctx context.Context, fpath string) error {
return backup(n.DS, fpath) return backup(ctx, n.DS, fpath)
} }
func (n *FullNodeAPI) NodeStatus(ctx context.Context, inclChainStatus bool) (status api.NodeStatus, err error) { func (n *FullNodeAPI) NodeStatus(ctx context.Context, inclChainStatus bool) (status api.NodeStatus, err error) {

42
node/impl/full/chain.go
View File

@ -99,11 +99,11 @@ func (m *ChainModule) ChainHead(context.Context) (*types.TipSet, error) {
} }
func (a *ChainAPI) ChainGetBlock(ctx context.Context, msg cid.Cid) (*types.BlockHeader, error) { func (a *ChainAPI) ChainGetBlock(ctx context.Context, msg cid.Cid) (*types.BlockHeader, error) {
return a.Chain.GetBlock(msg) return a.Chain.GetBlock(ctx, msg)
} }
func (m *ChainModule) ChainGetTipSet(ctx context.Context, key types.TipSetKey) (*types.TipSet, error) { func (m *ChainModule) ChainGetTipSet(ctx context.Context, key types.TipSetKey) (*types.TipSet, error) {
return m.Chain.LoadTipSet(key) return m.Chain.LoadTipSet(ctx, key)
} }
func (m *ChainModule) ChainGetPath(ctx context.Context, from, to types.TipSetKey) ([]*api.HeadChange, error) { func (m *ChainModule) ChainGetPath(ctx context.Context, from, to types.TipSetKey) ([]*api.HeadChange, error) {
@ -111,7 +111,7 @@ func (m *ChainModule) ChainGetPath(ctx context.Context, from, to types.TipSetKey
} }
func (m *ChainModule) ChainGetBlockMessages(ctx context.Context, msg cid.Cid) (*api.BlockMessages, error) { func (m *ChainModule) ChainGetBlockMessages(ctx context.Context, msg cid.Cid) (*api.BlockMessages, error) {
b, err := m.Chain.GetBlock(msg) b, err := m.Chain.GetBlock(ctx, msg)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -143,7 +143,7 @@ func (a *ChainAPI) ChainGetPath(ctx context.Context, from types.TipSetKey, to ty
} }
func (a *ChainAPI) ChainGetParentMessages(ctx context.Context, bcid cid.Cid) ([]api.Message, error) { func (a *ChainAPI) ChainGetParentMessages(ctx context.Context, bcid cid.Cid) ([]api.Message, error) {
b, err := a.Chain.GetBlock(bcid) b, err := a.Chain.GetBlock(ctx, bcid)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -154,7 +154,7 @@ func (a *ChainAPI) ChainGetParentMessages(ctx context.Context, bcid cid.Cid) ([]
} }
// TODO: need to get the number of messages better than this // TODO: need to get the number of messages better than this
pts, err := a.Chain.LoadTipSet(types.NewTipSetKey(b.Parents...)) pts, err := a.Chain.LoadTipSet(ctx, types.NewTipSetKey(b.Parents...))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -176,7 +176,7 @@ func (a *ChainAPI) ChainGetParentMessages(ctx context.Context, bcid cid.Cid) ([]
} }
func (a *ChainAPI) ChainGetParentReceipts(ctx context.Context, bcid cid.Cid) ([]*types.MessageReceipt, error) { func (a *ChainAPI) ChainGetParentReceipts(ctx context.Context, bcid cid.Cid) ([]*types.MessageReceipt, error) {
b, err := a.Chain.GetBlock(bcid) b, err := a.Chain.GetBlock(ctx, bcid)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -186,7 +186,7 @@ func (a *ChainAPI) ChainGetParentReceipts(ctx context.Context, bcid cid.Cid) ([]
} }
// TODO: need to get the number of messages better than this // TODO: need to get the number of messages better than this
pts, err := a.Chain.LoadTipSet(types.NewTipSetKey(b.Parents...)) pts, err := a.Chain.LoadTipSet(ctx, types.NewTipSetKey(b.Parents...))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -210,7 +210,7 @@ func (a *ChainAPI) ChainGetParentReceipts(ctx context.Context, bcid cid.Cid) ([]
} }
func (a *ChainAPI) ChainGetMessagesInTipset(ctx context.Context, tsk types.TipSetKey) ([]api.Message, error) { func (a *ChainAPI) ChainGetMessagesInTipset(ctx context.Context, tsk types.TipSetKey) ([]api.Message, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -237,7 +237,7 @@ func (a *ChainAPI) ChainGetMessagesInTipset(ctx context.Context, tsk types.TipSe
} }
func (m *ChainModule) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) { func (m *ChainModule) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -245,7 +245,7 @@ func (m *ChainModule) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpo
} }
func (m *ChainModule) ChainGetTipSetAfterHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) { func (m *ChainModule) ChainGetTipSetAfterHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -253,7 +253,7 @@ func (m *ChainModule) ChainGetTipSetAfterHeight(ctx context.Context, h abi.Chain
} }
func (m *ChainModule) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte, error) { func (m *ChainModule) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte, error) {
blk, err := m.ExposedBlockstore.Get(obj) blk, err := m.ExposedBlockstore.Get(ctx, obj)
if err != nil { if err != nil {
return nil, xerrors.Errorf("blockstore get: %w", err) return nil, xerrors.Errorf("blockstore get: %w", err)
} }
@ -262,11 +262,11 @@ func (m *ChainModule) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte, er
} }
func (a *ChainAPI) ChainDeleteObj(ctx context.Context, obj cid.Cid) error { func (a *ChainAPI) ChainDeleteObj(ctx context.Context, obj cid.Cid) error {
return a.ExposedBlockstore.DeleteBlock(obj) return a.ExposedBlockstore.DeleteBlock(ctx, obj)
} }
func (m *ChainModule) ChainHasObj(ctx context.Context, obj cid.Cid) (bool, error) { func (m *ChainModule) ChainHasObj(ctx context.Context, obj cid.Cid) (bool, error) {
return m.ExposedBlockstore.Has(obj) return m.ExposedBlockstore.Has(ctx, obj)
} }
func (a *ChainAPI) ChainStatObj(ctx context.Context, obj cid.Cid, base cid.Cid) (api.ObjStat, error) { func (a *ChainAPI) ChainStatObj(ctx context.Context, obj cid.Cid, base cid.Cid) (api.ObjStat, error) {
@ -318,7 +318,7 @@ func (a *ChainAPI) ChainStatObj(ctx context.Context, obj cid.Cid, base cid.Cid)
} }
func (a *ChainAPI) ChainSetHead(ctx context.Context, tsk types.TipSetKey) error { func (a *ChainAPI) ChainSetHead(ctx context.Context, tsk types.TipSetKey) error {
newHeadTs, err := a.Chain.GetTipSetFromKey(tsk) newHeadTs, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return xerrors.Errorf("loading tipset %s: %w", tsk, err) return xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -342,11 +342,11 @@ func (a *ChainAPI) ChainSetHead(ctx context.Context, tsk types.TipSetKey) error
} }
} }
return a.Chain.SetHead(newHeadTs) return a.Chain.SetHead(ctx, newHeadTs)
} }
func (a *ChainAPI) ChainGetGenesis(ctx context.Context) (*types.TipSet, error) { func (a *ChainAPI) ChainGetGenesis(ctx context.Context) (*types.TipSet, error) {
genb, err := a.Chain.GetGenesis() genb, err := a.Chain.GetGenesis(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -355,7 +355,7 @@ func (a *ChainAPI) ChainGetGenesis(ctx context.Context) (*types.TipSet, error) {
} }
func (a *ChainAPI) ChainTipSetWeight(ctx context.Context, tsk types.TipSetKey) (types.BigInt, error) { func (a *ChainAPI) ChainTipSetWeight(ctx context.Context, tsk types.TipSetKey) (types.BigInt, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err) return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -434,7 +434,7 @@ func resolveOnce(bs blockstore.Blockstore, tse stmgr.Executor) func(ctx context.
return nil, nil, err return nil, nil, err
} }
if err := bs.Put(n); err != nil { if err := bs.Put(ctx, n); err != nil {
return nil, nil, xerrors.Errorf("put hamt val: %w", err) return nil, nil, xerrors.Errorf("put hamt val: %w", err)
} }
@ -482,7 +482,7 @@ func resolveOnce(bs blockstore.Blockstore, tse stmgr.Executor) func(ctx context.
return nil, nil, err return nil, nil, err
} }
if err := bs.Put(n); err != nil { if err := bs.Put(ctx, n); err != nil {
return nil, nil, xerrors.Errorf("put amt val: %w", err) return nil, nil, xerrors.Errorf("put amt val: %w", err)
} }
@ -530,7 +530,7 @@ func resolveOnce(bs blockstore.Blockstore, tse stmgr.Executor) func(ctx context.
return nil, nil, err return nil, nil, err
} }
if err := bs.Put(n); err != nil { if err := bs.Put(ctx, n); err != nil {
return nil, nil, xerrors.Errorf("put amt val: %w", err) return nil, nil, xerrors.Errorf("put amt val: %w", err)
} }
@ -586,7 +586,7 @@ func (m *ChainModule) ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.M
} }
func (a *ChainAPI) ChainExport(ctx context.Context, nroots abi.ChainEpoch, skipoldmsgs bool, tsk types.TipSetKey) (<-chan []byte, error) { func (a *ChainAPI) ChainExport(ctx context.Context, nroots abi.ChainEpoch, skipoldmsgs bool, tsk types.TipSetKey) (<-chan []byte, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }

14
node/impl/full/gas.go
View File

@ -173,7 +173,7 @@ func (a *GasAPI) GasEstimateGasPremium(
gaslimit int64, gaslimit int64,
_ types.TipSetKey, _ types.TipSetKey,
) (types.BigInt, error) { ) (types.BigInt, error) {
return gasEstimateGasPremium(a.Chain, a.PriceCache, nblocksincl) return gasEstimateGasPremium(ctx, a.Chain, a.PriceCache, nblocksincl)
} }
func (m *GasModule) GasEstimateGasPremium( func (m *GasModule) GasEstimateGasPremium(
ctx context.Context, ctx context.Context,
@ -182,9 +182,9 @@ func (m *GasModule) GasEstimateGasPremium(
gaslimit int64, gaslimit int64,
_ types.TipSetKey, _ types.TipSetKey,
) (types.BigInt, error) { ) (types.BigInt, error) {
return gasEstimateGasPremium(m.Chain, m.PriceCache, nblocksincl) return gasEstimateGasPremium(ctx, m.Chain, m.PriceCache, nblocksincl)
} }
func gasEstimateGasPremium(cstore *store.ChainStore, cache *GasPriceCache, nblocksincl uint64) (types.BigInt, error) { func gasEstimateGasPremium(ctx context.Context, cstore *store.ChainStore, cache *GasPriceCache, nblocksincl uint64) (types.BigInt, error) {
if nblocksincl == 0 { if nblocksincl == 0 {
nblocksincl = 1 nblocksincl = 1
} }
@ -198,7 +198,7 @@ func gasEstimateGasPremium(cstore *store.ChainStore, cache *GasPriceCache, nbloc
break // genesis break // genesis
} }
pts, err := cstore.LoadTipSet(ts.Parents()) pts, err := cstore.LoadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return types.BigInt{}, err return types.BigInt{}, err
} }
@ -236,14 +236,14 @@ func gasEstimateGasPremium(cstore *store.ChainStore, cache *GasPriceCache, nbloc
} }
func (a *GasAPI) GasEstimateGasLimit(ctx context.Context, msgIn *types.Message, tsk types.TipSetKey) (int64, error) { func (a *GasAPI) GasEstimateGasLimit(ctx context.Context, msgIn *types.Message, tsk types.TipSetKey) (int64, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return -1, xerrors.Errorf("getting tipset: %w", err) return -1, xerrors.Errorf("getting tipset: %w", err)
} }
return gasEstimateGasLimit(ctx, a.Chain, a.Stmgr, a.Mpool, msgIn, ts) return gasEstimateGasLimit(ctx, a.Chain, a.Stmgr, a.Mpool, msgIn, ts)
} }
func (m *GasModule) GasEstimateGasLimit(ctx context.Context, msgIn *types.Message, tsk types.TipSetKey) (int64, error) { func (m *GasModule) GasEstimateGasLimit(ctx context.Context, msgIn *types.Message, tsk types.TipSetKey) (int64, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return -1, xerrors.Errorf("getting tipset: %w", err) return -1, xerrors.Errorf("getting tipset: %w", err)
} }
@ -283,7 +283,7 @@ func gasEstimateGasLimit(
if err != stmgr.ErrExpensiveFork { if err != stmgr.ErrExpensiveFork {
break break
} }
ts, err = cstore.GetTipSetFromKey(ts.Parents()) ts, err = cstore.GetTipSetFromKey(ctx, ts.Parents())
if err != nil { if err != nil {
return -1, xerrors.Errorf("getting parent tipset: %w", err) return -1, xerrors.Errorf("getting parent tipset: %w", err)
} }

8
node/impl/full/mpool.go
View File

@ -51,11 +51,11 @@ func (a *MpoolAPI) MpoolGetConfig(context.Context) (*types.MpoolConfig, error) {
} }
func (a *MpoolAPI) MpoolSetConfig(ctx context.Context, cfg *types.MpoolConfig) error { func (a *MpoolAPI) MpoolSetConfig(ctx context.Context, cfg *types.MpoolConfig) error {
return a.Mpool.SetConfig(cfg) return a.Mpool.SetConfig(ctx, cfg)
} }
func (a *MpoolAPI) MpoolSelect(ctx context.Context, tsk types.TipSetKey, ticketQuality float64) ([]*types.SignedMessage, error) { func (a *MpoolAPI) MpoolSelect(ctx context.Context, tsk types.TipSetKey, ticketQuality float64) ([]*types.SignedMessage, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -64,7 +64,7 @@ func (a *MpoolAPI) MpoolSelect(ctx context.Context, tsk types.TipSetKey, ticketQ
} }
func (a *MpoolAPI) MpoolPending(ctx context.Context, tsk types.TipSetKey) ([]*types.SignedMessage, error) { func (a *MpoolAPI) MpoolPending(ctx context.Context, tsk types.TipSetKey) ([]*types.SignedMessage, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -115,7 +115,7 @@ func (a *MpoolAPI) MpoolPending(ctx context.Context, tsk types.TipSetKey) ([]*ty
return pending, nil return pending, nil
} }
ts, err = a.Chain.LoadTipSet(ts.Parents()) ts, err = a.Chain.LoadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading parent tipset: %w", err) return nil, xerrors.Errorf("loading parent tipset: %w", err)
} }

76
node/impl/full/state.go
View File

@ -132,7 +132,7 @@ func (a *StateAPI) StateMinerActiveSectors(ctx context.Context, maddr address.Ad
} }
func (m *StateModule) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) { func (m *StateModule) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return miner.MinerInfo{}, xerrors.Errorf("failed to load tipset: %w", err) return miner.MinerInfo{}, xerrors.Errorf("failed to load tipset: %w", err)
} }
@ -250,7 +250,7 @@ func (a *StateAPI) StateMinerPartitions(ctx context.Context, m address.Address,
} }
func (m *StateModule) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) { func (m *StateModule) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -345,7 +345,7 @@ func (a *StateAPI) StateMinerRecoveries(ctx context.Context, addr address.Addres
} }
func (m *StateModule) StateMinerPower(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*api.MinerPower, error) { func (m *StateModule) StateMinerPower(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*api.MinerPower, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -363,7 +363,7 @@ func (m *StateModule) StateMinerPower(ctx context.Context, addr address.Address,
} }
func (a *StateAPI) StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (res *api.InvocResult, err error) { func (a *StateAPI) StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (res *api.InvocResult, err error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -372,7 +372,7 @@ func (a *StateAPI) StateCall(ctx context.Context, msg *types.Message, tsk types.
if err != stmgr.ErrExpensiveFork { if err != stmgr.ErrExpensiveFork {
break break
} }
ts, err = a.Chain.GetTipSetFromKey(ts.Parents()) ts, err = a.Chain.GetTipSetFromKey(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("getting parent tipset: %w", err) return nil, xerrors.Errorf("getting parent tipset: %w", err)
} }
@ -395,17 +395,17 @@ func (a *StateAPI) StateReplay(ctx context.Context, tsk types.TipSetKey, mc cid.
msgToReplay = mlkp.Message msgToReplay = mlkp.Message
executionTs, err := a.Chain.GetTipSetFromKey(mlkp.TipSet) executionTs, err := a.Chain.GetTipSetFromKey(ctx, mlkp.TipSet)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", mlkp.TipSet, err) return nil, xerrors.Errorf("loading tipset %s: %w", mlkp.TipSet, err)
} }
ts, err = a.Chain.LoadTipSet(executionTs.Parents()) ts, err = a.Chain.LoadTipSet(ctx, executionTs.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading parent tipset %s: %w", mlkp.TipSet, err) return nil, xerrors.Errorf("loading parent tipset %s: %w", mlkp.TipSet, err)
} }
} else { } else {
ts, err = a.Chain.LoadTipSet(tsk) ts, err = a.Chain.LoadTipSet(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading specified tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading specified tipset %s: %w", tsk, err)
} }
@ -433,7 +433,7 @@ func (a *StateAPI) StateReplay(ctx context.Context, tsk types.TipSetKey, mc cid.
} }
func (m *StateModule) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (a *types.Actor, err error) { func (m *StateModule) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (a *types.Actor, err error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -441,7 +441,7 @@ func (m *StateModule) StateGetActor(ctx context.Context, actor address.Address,
} }
func (m *StateModule) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) { func (m *StateModule) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err) return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -450,7 +450,7 @@ func (m *StateModule) StateLookupID(ctx context.Context, addr address.Address, t
} }
func (m *StateModule) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) { func (m *StateModule) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err) return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -459,7 +459,7 @@ func (m *StateModule) StateAccountKey(ctx context.Context, addr address.Address,
} }
func (a *StateAPI) StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*api.ActorState, error) { func (a *StateAPI) StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*api.ActorState, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -468,7 +468,7 @@ func (a *StateAPI) StateReadState(ctx context.Context, actor address.Address, ts
return nil, xerrors.Errorf("getting actor: %w", err) return nil, xerrors.Errorf("getting actor: %w", err)
} }
blk, err := a.Chain.StateBlockstore().Get(act.Head) blk, err := a.Chain.StateBlockstore().Get(ctx, act.Head)
if err != nil { if err != nil {
return nil, xerrors.Errorf("getting actor head: %w", err) return nil, xerrors.Errorf("getting actor head: %w", err)
} }
@ -585,7 +585,7 @@ func (m *StateModule) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence
} }
func (m *StateModule) StateSearchMsg(ctx context.Context, tsk types.TipSetKey, msg cid.Cid, lookbackLimit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) { func (m *StateModule) StateSearchMsg(ctx context.Context, tsk types.TipSetKey, msg cid.Cid, lookbackLimit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) {
fromTs, err := m.Chain.GetTipSetFromKey(tsk) fromTs, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -607,7 +607,7 @@ func (m *StateModule) StateSearchMsg(ctx context.Context, tsk types.TipSetKey, m
} }
func (m *StateModule) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) { func (m *StateModule) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -615,7 +615,7 @@ func (m *StateModule) StateListMiners(ctx context.Context, tsk types.TipSetKey)
} }
func (a *StateAPI) StateListActors(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) { func (a *StateAPI) StateListActors(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -623,7 +623,7 @@ func (a *StateAPI) StateListActors(ctx context.Context, tsk types.TipSetKey) ([]
} }
func (m *StateModule) StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error) { func (m *StateModule) StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return api.MarketBalance{}, xerrors.Errorf("loading tipset %s: %w", tsk, err) return api.MarketBalance{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -633,7 +633,7 @@ func (m *StateModule) StateMarketBalance(ctx context.Context, addr address.Addre
func (a *StateAPI) StateMarketParticipants(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketBalance, error) { func (a *StateAPI) StateMarketParticipants(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketBalance, error) {
out := map[string]api.MarketBalance{} out := map[string]api.MarketBalance{}
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -673,7 +673,7 @@ func (a *StateAPI) StateMarketParticipants(ctx context.Context, tsk types.TipSet
func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketDeal, error) { func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketDeal, error) {
out := map[string]api.MarketDeal{} out := map[string]api.MarketDeal{}
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -712,7 +712,7 @@ func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (m
} }
func (m *StateModule) StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error) { func (m *StateModule) StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -777,7 +777,7 @@ func (a *StateAPI) StateMinerSectorCount(ctx context.Context, addr address.Addre
} }
func (a *StateAPI) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) { func (a *StateAPI) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return miner.SectorPreCommitOnChainInfo{}, xerrors.Errorf("loading tipset %s: %w", tsk, err) return miner.SectorPreCommitOnChainInfo{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -793,7 +793,7 @@ func (a *StateAPI) StateSectorPreCommitInfo(ctx context.Context, maddr address.A
} }
func (m *StateModule) StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) { func (m *StateModule) StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -825,7 +825,7 @@ func (a *StateAPI) StateSectorPartition(ctx context.Context, maddr address.Addre
} }
func (a *StateAPI) StateListMessages(ctx context.Context, match *api.MessageMatch, tsk types.TipSetKey, toheight abi.ChainEpoch) ([]cid.Cid, error) { func (a *StateAPI) StateListMessages(ctx context.Context, match *api.MessageMatch, tsk types.TipSetKey, toheight abi.ChainEpoch) ([]cid.Cid, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -889,7 +889,7 @@ func (a *StateAPI) StateListMessages(ctx context.Context, match *api.MessageMatc
break break
} }
next, err := a.Chain.LoadTipSet(ts.Parents()) next, err := a.Chain.LoadTipSet(ctx, ts.Parents())
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading next tipset: %w", err) return nil, xerrors.Errorf("loading next tipset: %w", err)
} }
@ -901,7 +901,7 @@ func (a *StateAPI) StateListMessages(ctx context.Context, match *api.MessageMatc
} }
func (a *StateAPI) StateCompute(ctx context.Context, height abi.ChainEpoch, msgs []*types.Message, tsk types.TipSetKey) (*api.ComputeStateOutput, error) { func (a *StateAPI) StateCompute(ctx context.Context, height abi.ChainEpoch, msgs []*types.Message, tsk types.TipSetKey) (*api.ComputeStateOutput, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -917,7 +917,7 @@ func (a *StateAPI) StateCompute(ctx context.Context, height abi.ChainEpoch, msgs
} }
func (m *StateModule) MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error) { func (m *StateModule) MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err) return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -938,7 +938,7 @@ func (m *StateModule) MsigGetAvailableBalance(ctx context.Context, addr address.
} }
func (a *StateAPI) MsigGetVestingSchedule(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MsigVesting, error) { func (a *StateAPI) MsigGetVestingSchedule(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MsigVesting, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return api.EmptyVesting, xerrors.Errorf("loading tipset %s: %w", tsk, err) return api.EmptyVesting, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -976,12 +976,12 @@ func (a *StateAPI) MsigGetVestingSchedule(ctx context.Context, addr address.Addr
} }
func (m *StateModule) MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error) { func (m *StateModule) MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error) {
startTs, err := m.Chain.GetTipSetFromKey(start) startTs, err := m.Chain.GetTipSetFromKey(ctx, start)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading start tipset %s: %w", start, err) return types.EmptyInt, xerrors.Errorf("loading start tipset %s: %w", start, err)
} }
endTs, err := m.Chain.GetTipSetFromKey(end) endTs, err := m.Chain.GetTipSetFromKey(ctx, end)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading end tipset %s: %w", end, err) return types.EmptyInt, xerrors.Errorf("loading end tipset %s: %w", end, err)
} }
@ -1016,7 +1016,7 @@ func (m *StateModule) MsigGetVested(ctx context.Context, addr address.Address, s
} }
func (m *StateModule) MsigGetPending(ctx context.Context, addr address.Address, tsk types.TipSetKey) ([]*api.MsigTransaction, error) { func (m *StateModule) MsigGetPending(ctx context.Context, addr address.Address, tsk types.TipSetKey) ([]*api.MsigTransaction, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err) return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1053,7 +1053,7 @@ var initialPledgeNum = types.NewInt(110)
var initialPledgeDen = types.NewInt(100) var initialPledgeDen = types.NewInt(100)
func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) { func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err) return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1114,7 +1114,7 @@ func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr
func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) { func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
// TODO: this repeats a lot of the previous function. Fix that. // TODO: this repeats a lot of the previous function. Fix that.
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err) return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1190,7 +1190,7 @@ func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr
} }
func (a *StateAPI) StateMinerAvailableBalance(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (types.BigInt, error) { func (a *StateAPI) StateMinerAvailableBalance(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err) return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1219,7 +1219,7 @@ func (a *StateAPI) StateMinerAvailableBalance(ctx context.Context, maddr address
} }
func (a *StateAPI) StateMinerSectorAllocated(ctx context.Context, maddr address.Address, s abi.SectorNumber, tsk types.TipSetKey) (bool, error) { func (a *StateAPI) StateMinerSectorAllocated(ctx context.Context, maddr address.Address, s abi.SectorNumber, tsk types.TipSetKey) (bool, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return false, xerrors.Errorf("loading tipset %s: %w", tsk, err) return false, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1319,7 +1319,7 @@ var dealProviderCollateralDen = types.NewInt(100)
// StateDealProviderCollateralBounds returns the min and max collateral a storage provider // StateDealProviderCollateralBounds returns the min and max collateral a storage provider
// can issue. It takes the deal size and verified status as parameters. // can issue. It takes the deal size and verified status as parameters.
func (m *StateModule) StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error) { func (m *StateModule) StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return api.DealCollateralBounds{}, xerrors.Errorf("loading tipset %s: %w", tsk, err) return api.DealCollateralBounds{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1376,7 +1376,7 @@ func (m *StateModule) StateDealProviderCollateralBounds(ctx context.Context, siz
} }
func (a *StateAPI) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (abi.TokenAmount, error) { func (a *StateAPI) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (abi.TokenAmount, error) {
ts, err := a.Chain.GetTipSetFromKey(tsk) ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err) return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1397,7 +1397,7 @@ func stateVMCirculatingSupplyInternal(
cstore *store.ChainStore, cstore *store.ChainStore,
smgr *stmgr.StateManager, smgr *stmgr.StateManager,
) (api.CirculatingSupply, error) { ) (api.CirculatingSupply, error) {
ts, err := cstore.GetTipSetFromKey(tsk) ts, err := cstore.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return api.CirculatingSupply{}, xerrors.Errorf("loading tipset %s: %w", tsk, err) return api.CirculatingSupply{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }
@ -1411,7 +1411,7 @@ func stateVMCirculatingSupplyInternal(
} }
func (m *StateModule) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (network.Version, error) { func (m *StateModule) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (network.Version, error) {
ts, err := m.Chain.GetTipSetFromKey(tsk) ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
if err != nil { if err != nil {
return network.VersionMax, xerrors.Errorf("loading tipset %s: %w", tsk, err) return network.VersionMax, xerrors.Errorf("loading tipset %s: %w", tsk, err)
} }

6
node/impl/full/sync.go
View File

@ -51,13 +51,13 @@ func (a *SyncAPI) SyncState(ctx context.Context) (*api.SyncState, error) {
} }
func (a *SyncAPI) SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) error { func (a *SyncAPI) SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) error {
parent, err := a.Syncer.ChainStore().GetBlock(blk.Header.Parents[0]) parent, err := a.Syncer.ChainStore().GetBlock(ctx, blk.Header.Parents[0])
if err != nil { if err != nil {
return xerrors.Errorf("loading parent block: %w", err) return xerrors.Errorf("loading parent block: %w", err)
} }
if a.SlashFilter != nil { if a.SlashFilter != nil {
if err := a.SlashFilter.MinedBlock(blk.Header, parent.Height); err != nil { if err := a.SlashFilter.MinedBlock(ctx, blk.Header, parent.Height); err != nil {
log.Errorf("<!!> SLASH FILTER ERROR: %s", err) log.Errorf("<!!> SLASH FILTER ERROR: %s", err)
return xerrors.Errorf("<!!> SLASH FILTER ERROR: %w", err) return xerrors.Errorf("<!!> SLASH FILTER ERROR: %w", err)
} }
@ -137,7 +137,7 @@ func (a *SyncAPI) SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error
} }
func (a *SyncAPI) SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error) { func (a *SyncAPI) SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error) {
ts, err := a.Syncer.ChainStore().LoadTipSet(tsk) ts, err := a.Syncer.ChainStore().LoadTipSet(ctx, tsk)
if err != nil { if err != nil {
return false, err return false, err
} }

12
node/impl/paych/paych.go
View File

@ -35,11 +35,11 @@ func (a *PaychAPI) PaychGet(ctx context.Context, from, to address.Address, amt t
} }
func (a *PaychAPI) PaychAvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error) { func (a *PaychAPI) PaychAvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error) {
return a.PaychMgr.AvailableFunds(ch) return a.PaychMgr.AvailableFunds(ctx, ch)
} }
func (a *PaychAPI) PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*api.ChannelAvailableFunds, error) { func (a *PaychAPI) PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*api.ChannelAvailableFunds, error) {
return a.PaychMgr.AvailableFundsByFromTo(from, to) return a.PaychMgr.AvailableFundsByFromTo(ctx, from, to)
} }
func (a *PaychAPI) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid) (address.Address, error) { func (a *PaychAPI) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid) (address.Address, error) {
@ -47,7 +47,7 @@ func (a *PaychAPI) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid) (add
} }
func (a *PaychAPI) PaychAllocateLane(ctx context.Context, ch address.Address) (uint64, error) { func (a *PaychAPI) PaychAllocateLane(ctx context.Context, ch address.Address) (uint64, error) {
return a.PaychMgr.AllocateLane(ch) return a.PaychMgr.AllocateLane(ctx, ch)
} }
func (a *PaychAPI) PaychNewPayment(ctx context.Context, from, to address.Address, vouchers []api.VoucherSpec) (*api.PaymentInfo, error) { func (a *PaychAPI) PaychNewPayment(ctx context.Context, from, to address.Address, vouchers []api.VoucherSpec) (*api.PaymentInfo, error) {
@ -60,7 +60,7 @@ func (a *PaychAPI) PaychNewPayment(ctx context.Context, from, to address.Address
return nil, err return nil, err
} }
lane, err := a.PaychMgr.AllocateLane(ch.Channel) lane, err := a.PaychMgr.AllocateLane(ctx, ch.Channel)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -95,11 +95,11 @@ func (a *PaychAPI) PaychNewPayment(ctx context.Context, from, to address.Address
} }
func (a *PaychAPI) PaychList(ctx context.Context) ([]address.Address, error) { func (a *PaychAPI) PaychList(ctx context.Context) ([]address.Address, error) {
return a.PaychMgr.ListChannels() return a.PaychMgr.ListChannels(ctx)
} }
func (a *PaychAPI) PaychStatus(ctx context.Context, pch address.Address) (*api.PaychStatus, error) { func (a *PaychAPI) PaychStatus(ctx context.Context, pch address.Address) (*api.PaychStatus, error) {
ci, err := a.PaychMgr.GetChannelInfo(pch) ci, err := a.PaychMgr.GetChannelInfo(ctx, pch)
if err != nil { if err != nil {
return nil, err return nil, err
} }

6
node/impl/storminer.go
View File

@ -300,11 +300,11 @@ func (sm *StorageMinerAPI) StorageLocal(ctx context.Context) (map[stores.ID]stri
return out, nil return out, nil
} }
func (sm *StorageMinerAPI) SectorsRefs(context.Context) (map[string][]api.SealedRef, error) { func (sm *StorageMinerAPI) SectorsRefs(ctx context.Context) (map[string][]api.SealedRef, error) {
// json can't handle cids as map keys // json can't handle cids as map keys
out := map[string][]api.SealedRef{} out := map[string][]api.SealedRef{}
refs, err := sm.SectorBlocks.List() refs, err := sm.SectorBlocks.List(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -948,7 +948,7 @@ func (sm *StorageMinerAPI) PiecesGetCIDInfo(ctx context.Context, payloadCid cid.
} }
func (sm *StorageMinerAPI) CreateBackup(ctx context.Context, fpath string) error { func (sm *StorageMinerAPI) CreateBackup(ctx context.Context, fpath string) error {
return backup(sm.DS, fpath) return backup(ctx, sm.DS, fpath)
} }
func (sm *StorageMinerAPI) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []sto.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) { func (sm *StorageMinerAPI) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []sto.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) {

4
node/modules/lp2p/host.go
View File

@ -34,8 +34,6 @@ type P2PHostIn struct {
type RawHost host.Host type RawHost host.Host
func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (RawHost, error) { func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (RawHost, error) {
ctx := helpers.LifecycleCtx(mctx, lc)
pkey := params.Peerstore.PrivKey(params.ID) pkey := params.Peerstore.PrivKey(params.ID)
if pkey == nil { if pkey == nil {
return nil, fmt.Errorf("missing private key for node ID: %s", params.ID.Pretty()) return nil, fmt.Errorf("missing private key for node ID: %s", params.ID.Pretty())
@ -52,7 +50,7 @@ func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (RawHost,
opts = append(opts, o...) opts = append(opts, o...)
} }
h, err := libp2p.New(ctx, opts...) h, err := libp2p.New(opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }

24
node/repo/imports/manager.go
View File

@ -1,6 +1,7 @@
package imports package imports
import ( import (
"context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"os" "os"
@ -107,6 +108,7 @@ type Meta struct {
// CreateImport initializes a new import, returning its ID and optionally a // CreateImport initializes a new import, returning its ID and optionally a
// CAR path where to place the data, if requested. // CAR path where to place the data, if requested.
func (m *Manager) CreateImport() (id ID, err error) { func (m *Manager) CreateImport() (id ID, err error) {
ctx := context.TODO()
id = ID(m.counter.Next()) id = ID(m.counter.Next())
meta := &Meta{Labels: map[LabelKey]LabelValue{ meta := &Meta{Labels: map[LabelKey]LabelValue{
@ -118,7 +120,7 @@ func (m *Manager) CreateImport() (id ID, err error) {
return 0, xerrors.Errorf("marshaling store metadata: %w", err) return 0, xerrors.Errorf("marshaling store metadata: %w", err)
} }
err = m.ds.Put(id.dsKey(), metajson) err = m.ds.Put(ctx, id.dsKey(), metajson)
if err != nil { if err != nil {
return 0, xerrors.Errorf("failed to insert import metadata: %w", err) return 0, xerrors.Errorf("failed to insert import metadata: %w", err)
} }
@ -129,7 +131,8 @@ func (m *Manager) CreateImport() (id ID, err error) {
// AllocateCAR creates a new CAR allocated to the supplied import under the // AllocateCAR creates a new CAR allocated to the supplied import under the
// root directory. // root directory.
func (m *Manager) AllocateCAR(id ID) (path string, err error) { func (m *Manager) AllocateCAR(id ID) (path string, err error) {
meta, err := m.ds.Get(id.dsKey()) ctx := context.TODO()
meta, err := m.ds.Get(ctx, id.dsKey())
if err != nil { if err != nil {
return "", xerrors.Errorf("getting metadata form datastore: %w", err) return "", xerrors.Errorf("getting metadata form datastore: %w", err)
} }
@ -163,14 +166,15 @@ func (m *Manager) AllocateCAR(id ID) (path string, err error) {
return "", xerrors.Errorf("marshaling store metadata: %w", err) return "", xerrors.Errorf("marshaling store metadata: %w", err)
} }
err = m.ds.Put(id.dsKey(), meta) err = m.ds.Put(ctx, id.dsKey(), meta)
return path, err return path, err
} }
// AddLabel adds a label associated with an import, such as the source, // AddLabel adds a label associated with an import, such as the source,
// car path, CID, etc. // car path, CID, etc.
func (m *Manager) AddLabel(id ID, key LabelKey, value LabelValue) error { func (m *Manager) AddLabel(id ID, key LabelKey, value LabelValue) error {
meta, err := m.ds.Get(id.dsKey()) ctx := context.TODO()
meta, err := m.ds.Get(ctx, id.dsKey())
if err != nil { if err != nil {
return xerrors.Errorf("getting metadata form datastore: %w", err) return xerrors.Errorf("getting metadata form datastore: %w", err)
} }
@ -187,14 +191,15 @@ func (m *Manager) AddLabel(id ID, key LabelKey, value LabelValue) error {
return xerrors.Errorf("marshaling store meta: %w", err) return xerrors.Errorf("marshaling store meta: %w", err)
} }
return m.ds.Put(id.dsKey(), meta) return m.ds.Put(ctx, id.dsKey(), meta)
} }
// List returns all import IDs known by this Manager. // List returns all import IDs known by this Manager.
func (m *Manager) List() ([]ID, error) { func (m *Manager) List() ([]ID, error) {
ctx := context.TODO()
var keys []ID var keys []ID
qres, err := m.ds.Query(query.Query{KeysOnly: true}) qres, err := m.ds.Query(ctx, query.Query{KeysOnly: true})
if err != nil { if err != nil {
return nil, xerrors.Errorf("query error: %w", err) return nil, xerrors.Errorf("query error: %w", err)
} }
@ -218,7 +223,9 @@ func (m *Manager) List() ([]ID, error) {
// Info returns the metadata known to this store for the specified import ID. // Info returns the metadata known to this store for the specified import ID.
func (m *Manager) Info(id ID) (*Meta, error) { func (m *Manager) Info(id ID) (*Meta, error) {
meta, err := m.ds.Get(id.dsKey()) ctx := context.TODO()
meta, err := m.ds.Get(ctx, id.dsKey())
if err != nil { if err != nil {
return nil, xerrors.Errorf("getting metadata form datastore: %w", err) return nil, xerrors.Errorf("getting metadata form datastore: %w", err)
} }
@ -233,7 +240,8 @@ func (m *Manager) Info(id ID) (*Meta, error) {
// Remove drops all data associated with the supplied import ID. // Remove drops all data associated with the supplied import ID.
func (m *Manager) Remove(id ID) error { func (m *Manager) Remove(id ID) error {
if err := m.ds.Delete(id.dsKey()); err != nil { ctx := context.TODO()
if err := m.ds.Delete(ctx, id.dsKey()); err != nil {
return xerrors.Errorf("removing import metadata: %w", err) return xerrors.Errorf("removing import metadata: %w", err)
} }
return nil return nil

10
paychmgr/accessorcache.go
View File

@ -1,6 +1,10 @@
package paychmgr package paychmgr
import "github.com/filecoin-project/go-address" import (
"context"
"github.com/filecoin-project/go-address"
)
// accessorByFromTo gets a channel accessor for a given from / to pair. // accessorByFromTo gets a channel accessor for a given from / to pair.
// The channel accessor facilitates locking a channel so that operations // The channel accessor facilitates locking a channel so that operations
@ -36,10 +40,10 @@ func (pm *Manager) accessorByFromTo(from address.Address, to address.Address) (*
// The channel accessor facilitates locking a channel so that operations // The channel accessor facilitates locking a channel so that operations
// must be performed sequentially on a channel (but can be performed at // must be performed sequentially on a channel (but can be performed at
// the same time on different channels). // the same time on different channels).
func (pm *Manager) accessorByAddress(ch address.Address) (*channelAccessor, error) { func (pm *Manager) accessorByAddress(ctx context.Context, ch address.Address) (*channelAccessor, error) {
// Get the channel from / to // Get the channel from / to
pm.lk.RLock() pm.lk.RLock()
channelInfo, err := pm.store.ByAddress(ch) channelInfo, err := pm.store.ByAddress(ctx, ch)
pm.lk.RUnlock() pm.lk.RUnlock()
if err != nil { if err != nil {
return nil, err return nil, err

52
paychmgr/manager.go
View File

@ -92,7 +92,7 @@ func newManager(pchstore *Store, pchapi managerAPI) (*Manager, error) {
// Start restarts tracking of any messages that were sent to chain. // Start restarts tracking of any messages that were sent to chain.
func (pm *Manager) Start() error { func (pm *Manager) Start() error {
return pm.restartPending() return pm.restartPending(pm.ctx)
} }
// Stop shuts down any processes used by the manager // Stop shuts down any processes used by the manager
@ -110,27 +110,27 @@ func (pm *Manager) GetPaych(ctx context.Context, from, to address.Address, amt t
return chanAccessor.getPaych(ctx, amt) return chanAccessor.getPaych(ctx, amt)
} }
func (pm *Manager) AvailableFunds(ch address.Address) (*api.ChannelAvailableFunds, error) { func (pm *Manager) AvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ctx, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ci, err := ca.getChannelInfo(ch) ci, err := ca.getChannelInfo(ctx, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return ca.availableFunds(ci.ChannelID) return ca.availableFunds(ctx, ci.ChannelID)
} }
func (pm *Manager) AvailableFundsByFromTo(from address.Address, to address.Address) (*api.ChannelAvailableFunds, error) { func (pm *Manager) AvailableFundsByFromTo(ctx context.Context, from address.Address, to address.Address) (*api.ChannelAvailableFunds, error) {
ca, err := pm.accessorByFromTo(from, to) ca, err := pm.accessorByFromTo(from, to)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ci, err := ca.outboundActiveByFromTo(from, to) ci, err := ca.outboundActiveByFromTo(ctx, from, to)
if err == ErrChannelNotTracked { if err == ErrChannelNotTracked {
// If there is no active channel between from / to we still want to // If there is no active channel between from / to we still want to
// return an empty ChannelAvailableFunds, so that clients can check // return an empty ChannelAvailableFunds, so that clients can check
@ -151,7 +151,7 @@ func (pm *Manager) AvailableFundsByFromTo(from address.Address, to address.Addre
return nil, err return nil, err
} }
return ca.availableFunds(ci.ChannelID) return ca.availableFunds(ctx, ci.ChannelID)
} }
// GetPaychWaitReady waits until the create channel / add funds message with the // GetPaychWaitReady waits until the create channel / add funds message with the
@ -160,7 +160,7 @@ func (pm *Manager) AvailableFundsByFromTo(from address.Address, to address.Addre
func (pm *Manager) GetPaychWaitReady(ctx context.Context, mcid cid.Cid) (address.Address, error) { func (pm *Manager) GetPaychWaitReady(ctx context.Context, mcid cid.Cid) (address.Address, error) {
// Find the channel associated with the message CID // Find the channel associated with the message CID
pm.lk.Lock() pm.lk.Lock()
ci, err := pm.store.ByMessageCid(mcid) ci, err := pm.store.ByMessageCid(ctx, mcid)
pm.lk.Unlock() pm.lk.Unlock()
if err != nil { if err != nil {
@ -178,25 +178,25 @@ func (pm *Manager) GetPaychWaitReady(ctx context.Context, mcid cid.Cid) (address
return chanAccessor.getPaychWaitReady(ctx, mcid) return chanAccessor.getPaychWaitReady(ctx, mcid)
} }
func (pm *Manager) ListChannels() ([]address.Address, error) { func (pm *Manager) ListChannels(ctx context.Context) ([]address.Address, error) {
// Need to take an exclusive lock here so that channel operations can't run // Need to take an exclusive lock here so that channel operations can't run
// in parallel (see channelLock) // in parallel (see channelLock)
pm.lk.Lock() pm.lk.Lock()
defer pm.lk.Unlock() defer pm.lk.Unlock()
return pm.store.ListChannels() return pm.store.ListChannels(ctx)
} }
func (pm *Manager) GetChannelInfo(addr address.Address) (*ChannelInfo, error) { func (pm *Manager) GetChannelInfo(ctx context.Context, addr address.Address) (*ChannelInfo, error) {
ca, err := pm.accessorByAddress(addr) ca, err := pm.accessorByAddress(ctx, addr)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return ca.getChannelInfo(addr) return ca.getChannelInfo(ctx, addr)
} }
func (pm *Manager) CreateVoucher(ctx context.Context, ch address.Address, voucher paych.SignedVoucher) (*api.VoucherCreateResult, error) { func (pm *Manager) CreateVoucher(ctx context.Context, ch address.Address, voucher paych.SignedVoucher) (*api.VoucherCreateResult, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ctx, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -223,7 +223,7 @@ func (pm *Manager) CheckVoucherSpendable(ctx context.Context, ch address.Address
if len(proof) > 0 { if len(proof) > 0 {
return false, errProofNotSupported return false, errProofNotSupported
} }
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ctx, ch)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -237,7 +237,7 @@ func (pm *Manager) AddVoucherOutbound(ctx context.Context, ch address.Address, s
if len(proof) > 0 { if len(proof) > 0 {
return types.NewInt(0), errProofNotSupported return types.NewInt(0), errProofNotSupported
} }
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ctx, ch)
if err != nil { if err != nil {
return types.NewInt(0), err return types.NewInt(0), err
} }
@ -283,7 +283,7 @@ func (pm *Manager) trackInboundChannel(ctx context.Context, ch address.Address)
defer pm.lk.Unlock() defer pm.lk.Unlock()
// Check if channel is in store // Check if channel is in store
ci, err := pm.store.ByAddress(ch) ci, err := pm.store.ByAddress(ctx, ch)
if err == nil { if err == nil {
// Channel is in store, so it's already being tracked // Channel is in store, so it's already being tracked
return ci, nil return ci, nil
@ -316,7 +316,7 @@ func (pm *Manager) trackInboundChannel(ctx context.Context, ch address.Address)
} }
// Save channel to store // Save channel to store
return pm.store.TrackChannel(stateCi) return pm.store.TrackChannel(ctx, stateCi)
} }
// TODO: secret vs proof doesn't make sense, there is only one, not two // TODO: secret vs proof doesn't make sense, there is only one, not two
@ -324,23 +324,23 @@ func (pm *Manager) SubmitVoucher(ctx context.Context, ch address.Address, sv *pa
if len(proof) > 0 { if len(proof) > 0 {
return cid.Undef, errProofNotSupported return cid.Undef, errProofNotSupported
} }
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ctx, ch)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err
} }
return ca.submitVoucher(ctx, ch, sv, secret) return ca.submitVoucher(ctx, ch, sv, secret)
} }
func (pm *Manager) AllocateLane(ch address.Address) (uint64, error) { func (pm *Manager) AllocateLane(ctx context.Context, ch address.Address) (uint64, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ctx, ch)
if err != nil { if err != nil {
return 0, err return 0, err
} }
return ca.allocateLane(ch) return ca.allocateLane(ctx, ch)
} }
func (pm *Manager) ListVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) { func (pm *Manager) ListVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ctx, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -348,7 +348,7 @@ func (pm *Manager) ListVouchers(ctx context.Context, ch address.Address) ([]*Vou
} }
func (pm *Manager) Settle(ctx context.Context, addr address.Address) (cid.Cid, error) { func (pm *Manager) Settle(ctx context.Context, addr address.Address) (cid.Cid, error) {
ca, err := pm.accessorByAddress(addr) ca, err := pm.accessorByAddress(ctx, addr)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err
} }
@ -356,7 +356,7 @@ func (pm *Manager) Settle(ctx context.Context, addr address.Address) (cid.Cid, e
} }
func (pm *Manager) Collect(ctx context.Context, addr address.Address) (cid.Cid, error) { func (pm *Manager) Collect(ctx context.Context, addr address.Address) (cid.Cid, error) {
ca, err := pm.accessorByAddress(addr) ca, err := pm.accessorByAddress(ctx, addr)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err
} }

38
paychmgr/paych.go
View File

@ -95,18 +95,18 @@ func (ca *channelAccessor) messageBuilder(ctx context.Context, from address.Addr
return paych.Message(av, from), nil return paych.Message(av, from), nil
} }
func (ca *channelAccessor) getChannelInfo(addr address.Address) (*ChannelInfo, error) { func (ca *channelAccessor) getChannelInfo(ctx context.Context, addr address.Address) (*ChannelInfo, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
return ca.store.ByAddress(addr) return ca.store.ByAddress(ctx, addr)
} }
func (ca *channelAccessor) outboundActiveByFromTo(from, to address.Address) (*ChannelInfo, error) { func (ca *channelAccessor) outboundActiveByFromTo(ctx context.Context, from, to address.Address) (*ChannelInfo, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
return ca.store.OutboundActiveByFromTo(from, to) return ca.store.OutboundActiveByFromTo(ctx, from, to)
} }
// createVoucher creates a voucher with the given specification, setting its // createVoucher creates a voucher with the given specification, setting its
@ -118,7 +118,7 @@ func (ca *channelAccessor) createVoucher(ctx context.Context, ch address.Address
defer ca.lk.Unlock() defer ca.lk.Unlock()
// Find the channel for the voucher // Find the channel for the voucher
ci, err := ca.store.ByAddress(ch) ci, err := ca.store.ByAddress(ctx, ch)
if err != nil { if err != nil {
return nil, xerrors.Errorf("failed to get channel info by address: %w", err) return nil, xerrors.Errorf("failed to get channel info by address: %w", err)
} }
@ -229,7 +229,7 @@ func (ca *channelAccessor) checkVoucherValidUnlocked(ctx context.Context, ch add
} }
// Check the voucher against the highest known voucher nonce / value // Check the voucher against the highest known voucher nonce / value
laneStates, err := ca.laneState(pchState, ch) laneStates, err := ca.laneState(ctx, pchState, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -298,7 +298,7 @@ func (ca *channelAccessor) checkVoucherSpendable(ctx context.Context, ch address
return false, err return false, err
} }
ci, err := ca.store.ByAddress(ch) ci, err := ca.store.ByAddress(ctx, ch)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -351,7 +351,7 @@ func (ca *channelAccessor) addVoucher(ctx context.Context, ch address.Address, s
} }
func (ca *channelAccessor) addVoucherUnlocked(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, minDelta types.BigInt) (types.BigInt, error) { func (ca *channelAccessor) addVoucherUnlocked(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, minDelta types.BigInt) (types.BigInt, error) {
ci, err := ca.store.ByAddress(ch) ci, err := ca.store.ByAddress(ctx, ch)
if err != nil { if err != nil {
return types.BigInt{}, err return types.BigInt{}, err
} }
@ -400,14 +400,14 @@ func (ca *channelAccessor) addVoucherUnlocked(ctx context.Context, ch address.Ad
ci.NextLane = sv.Lane + 1 ci.NextLane = sv.Lane + 1
} }
return delta, ca.store.putChannelInfo(ci) return delta, ca.store.putChannelInfo(ctx, ci)
} }
func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte) (cid.Cid, error) { func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte) (cid.Cid, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
ci, err := ca.store.ByAddress(ch) ci, err := ca.store.ByAddress(ctx, ch)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err
} }
@ -453,7 +453,7 @@ func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address
} }
// Mark the voucher and any lower-nonce vouchers as having been submitted // Mark the voucher and any lower-nonce vouchers as having been submitted
err = ca.store.MarkVoucherSubmitted(ci, sv) err = ca.store.MarkVoucherSubmitted(ctx, ci, sv)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err
} }
@ -461,11 +461,11 @@ func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address
return smsg.Cid(), nil return smsg.Cid(), nil
} }
func (ca *channelAccessor) allocateLane(ch address.Address) (uint64, error) { func (ca *channelAccessor) allocateLane(ctx context.Context, ch address.Address) (uint64, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
return ca.store.AllocateLane(ch) return ca.store.AllocateLane(ctx, ch)
} }
func (ca *channelAccessor) listVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) { func (ca *channelAccessor) listVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) {
@ -474,12 +474,12 @@ func (ca *channelAccessor) listVouchers(ctx context.Context, ch address.Address)
// TODO: just having a passthrough method like this feels odd. Seems like // TODO: just having a passthrough method like this feels odd. Seems like
// there should be some filtering we're doing here // there should be some filtering we're doing here
return ca.store.VouchersForPaych(ch) return ca.store.VouchersForPaych(ctx, ch)
} }
// laneState gets the LaneStates from chain, then applies all vouchers in // laneState gets the LaneStates from chain, then applies all vouchers in
// the data store over the chain state // the data store over the chain state
func (ca *channelAccessor) laneState(state paych.State, ch address.Address) (map[uint64]paych.LaneState, error) { func (ca *channelAccessor) laneState(ctx context.Context, state paych.State, ch address.Address) (map[uint64]paych.LaneState, error) {
// TODO: we probably want to call UpdateChannelState with all vouchers to be fully correct // TODO: we probably want to call UpdateChannelState with all vouchers to be fully correct
// (but technically dont't need to) // (but technically dont't need to)
@ -501,7 +501,7 @@ func (ca *channelAccessor) laneState(state paych.State, ch address.Address) (map
} }
// Apply locally stored vouchers // Apply locally stored vouchers
vouchers, err := ca.store.VouchersForPaych(ch) vouchers, err := ca.store.VouchersForPaych(ctx, ch)
if err != nil && err != ErrChannelNotTracked { if err != nil && err != ErrChannelNotTracked {
return nil, err return nil, err
} }
@ -583,7 +583,7 @@ func (ca *channelAccessor) settle(ctx context.Context, ch address.Address) (cid.
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
ci, err := ca.store.ByAddress(ch) ci, err := ca.store.ByAddress(ctx, ch)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err
} }
@ -602,7 +602,7 @@ func (ca *channelAccessor) settle(ctx context.Context, ch address.Address) (cid.
} }
ci.Settling = true ci.Settling = true
err = ca.store.putChannelInfo(ci) err = ca.store.putChannelInfo(ctx, ci)
if err != nil { if err != nil {
log.Errorf("Error marking channel as settled: %s", err) log.Errorf("Error marking channel as settled: %s", err)
} }
@ -614,7 +614,7 @@ func (ca *channelAccessor) collect(ctx context.Context, ch address.Address) (cid
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
ci, err := ca.store.ByAddress(ch) ci, err := ca.store.ByAddress(ctx, ch)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err
} }

90
paychmgr/simple.go
View File

@ -159,7 +159,7 @@ func (m *mergedFundsReq) sum() types.BigInt {
func (ca *channelAccessor) getPaych(ctx context.Context, amt types.BigInt) (address.Address, cid.Cid, error) { func (ca *channelAccessor) getPaych(ctx context.Context, amt types.BigInt) (address.Address, cid.Cid, error) {
// Add the request to add funds to a queue and wait for the result // Add the request to add funds to a queue and wait for the result
freq := newFundsReq(ctx, amt) freq := newFundsReq(ctx, amt)
ca.enqueue(freq) ca.enqueue(ctx, freq)
select { select {
case res := <-freq.promise: case res := <-freq.promise:
return res.channel, res.mcid, res.err return res.channel, res.mcid, res.err
@ -170,16 +170,16 @@ func (ca *channelAccessor) getPaych(ctx context.Context, amt types.BigInt) (addr
} }
// Queue up an add funds operation // Queue up an add funds operation
func (ca *channelAccessor) enqueue(task *fundsReq) { func (ca *channelAccessor) enqueue(ctx context.Context, task *fundsReq) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
ca.fundsReqQueue = append(ca.fundsReqQueue, task) ca.fundsReqQueue = append(ca.fundsReqQueue, task)
go ca.processQueue("") // nolint: errcheck go ca.processQueue(ctx, "") // nolint: errcheck
} }
// Run the operations in the queue // Run the operations in the queue
func (ca *channelAccessor) processQueue(channelID string) (*api.ChannelAvailableFunds, error) { func (ca *channelAccessor) processQueue(ctx context.Context, channelID string) (*api.ChannelAvailableFunds, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
@ -188,7 +188,7 @@ func (ca *channelAccessor) processQueue(channelID string) (*api.ChannelAvailable
// If there's nothing in the queue, bail out // If there's nothing in the queue, bail out
if len(ca.fundsReqQueue) == 0 { if len(ca.fundsReqQueue) == 0 {
return ca.currentAvailableFunds(channelID, types.NewInt(0)) return ca.currentAvailableFunds(ctx, channelID, types.NewInt(0))
} }
// Merge all pending requests into one. // Merge all pending requests into one.
@ -199,7 +199,7 @@ func (ca *channelAccessor) processQueue(channelID string) (*api.ChannelAvailable
if amt.IsZero() { if amt.IsZero() {
// Note: The amount can be zero if requests are cancelled as we're // Note: The amount can be zero if requests are cancelled as we're
// building the mergedFundsReq // building the mergedFundsReq
return ca.currentAvailableFunds(channelID, amt) return ca.currentAvailableFunds(ctx, channelID, amt)
} }
res := ca.processTask(merged.ctx, amt) res := ca.processTask(merged.ctx, amt)
@ -209,7 +209,7 @@ func (ca *channelAccessor) processQueue(channelID string) (*api.ChannelAvailable
if res == nil { if res == nil {
// Stop processing the fundsReqQueue and wait. When the event occurs it will // Stop processing the fundsReqQueue and wait. When the event occurs it will
// call processQueue() again // call processQueue() again
return ca.currentAvailableFunds(channelID, amt) return ca.currentAvailableFunds(ctx, channelID, amt)
} }
// Finished processing so clear the queue // Finished processing so clear the queue
@ -218,7 +218,7 @@ func (ca *channelAccessor) processQueue(channelID string) (*api.ChannelAvailable
// Call the task callback with its results // Call the task callback with its results
merged.onComplete(res) merged.onComplete(res)
return ca.currentAvailableFunds(channelID, types.NewInt(0)) return ca.currentAvailableFunds(ctx, channelID, types.NewInt(0))
} }
// filterQueue filters cancelled requests out of the queue // filterQueue filters cancelled requests out of the queue
@ -255,12 +255,12 @@ func (ca *channelAccessor) queueSize() int {
// msgWaitComplete is called when the message for a previous task is confirmed // msgWaitComplete is called when the message for a previous task is confirmed
// or there is an error. // or there is an error.
func (ca *channelAccessor) msgWaitComplete(mcid cid.Cid, err error) { func (ca *channelAccessor) msgWaitComplete(ctx context.Context, mcid cid.Cid, err error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
// Save the message result to the store // Save the message result to the store
dserr := ca.store.SaveMessageResult(mcid, err) dserr := ca.store.SaveMessageResult(ctx, mcid, err)
if dserr != nil { if dserr != nil {
log.Errorf("saving message result: %s", dserr) log.Errorf("saving message result: %s", dserr)
} }
@ -271,16 +271,16 @@ func (ca *channelAccessor) msgWaitComplete(mcid cid.Cid, err error) {
// The queue may have been waiting for msg completion to proceed, so // The queue may have been waiting for msg completion to proceed, so
// process the next queue item // process the next queue item
if len(ca.fundsReqQueue) > 0 { if len(ca.fundsReqQueue) > 0 {
go ca.processQueue("") // nolint: errcheck go ca.processQueue(ctx, "") // nolint: errcheck
} }
} }
func (ca *channelAccessor) currentAvailableFunds(channelID string, queuedAmt types.BigInt) (*api.ChannelAvailableFunds, error) { func (ca *channelAccessor) currentAvailableFunds(ctx context.Context, channelID string, queuedAmt types.BigInt) (*api.ChannelAvailableFunds, error) {
if len(channelID) == 0 { if len(channelID) == 0 {
return nil, nil return nil, nil
} }
channelInfo, err := ca.store.ByChannelID(channelID) channelInfo, err := ca.store.ByChannelID(ctx, channelID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -302,7 +302,7 @@ func (ca *channelAccessor) currentAvailableFunds(channelID string, queuedAmt typ
return nil, err return nil, err
} }
laneStates, err := ca.laneState(pchState, ch) laneStates, err := ca.laneState(ctx, pchState, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -337,7 +337,7 @@ func (ca *channelAccessor) processTask(ctx context.Context, amt types.BigInt) *p
// Get the payment channel for the from/to addresses. // Get the payment channel for the from/to addresses.
// Note: It's ok if we get ErrChannelNotTracked. It just means we need to // Note: It's ok if we get ErrChannelNotTracked. It just means we need to
// create a channel. // create a channel.
channelInfo, err := ca.store.OutboundActiveByFromTo(ca.from, ca.to) channelInfo, err := ca.store.OutboundActiveByFromTo(ctx, ca.from, ca.to)
if err != nil && err != ErrChannelNotTracked { if err != nil && err != ErrChannelNotTracked {
return &paychFundsRes{err: err} return &paychFundsRes{err: err}
} }
@ -393,26 +393,26 @@ func (ca *channelAccessor) createPaych(ctx context.Context, amt types.BigInt) (c
mcid := smsg.Cid() mcid := smsg.Cid()
// Create a new channel in the store // Create a new channel in the store
ci, err := ca.store.CreateChannel(ca.from, ca.to, mcid, amt) ci, err := ca.store.CreateChannel(ctx, ca.from, ca.to, mcid, amt)
if err != nil { if err != nil {
log.Errorf("creating channel: %s", err) log.Errorf("creating channel: %s", err)
return cid.Undef, err return cid.Undef, err
} }
// Wait for the channel to be created on chain // Wait for the channel to be created on chain
go ca.waitForPaychCreateMsg(ci.ChannelID, mcid) go ca.waitForPaychCreateMsg(ctx, ci.ChannelID, mcid)
return mcid, nil return mcid, nil
} }
// waitForPaychCreateMsg waits for mcid to appear on chain and stores the robust address of the // waitForPaychCreateMsg waits for mcid to appear on chain and stores the robust address of the
// created payment channel // created payment channel
func (ca *channelAccessor) waitForPaychCreateMsg(channelID string, mcid cid.Cid) { func (ca *channelAccessor) waitForPaychCreateMsg(ctx context.Context, channelID string, mcid cid.Cid) {
err := ca.waitPaychCreateMsg(channelID, mcid) err := ca.waitPaychCreateMsg(ctx, channelID, mcid)
ca.msgWaitComplete(mcid, err) ca.msgWaitComplete(ctx, mcid, err)
} }
func (ca *channelAccessor) waitPaychCreateMsg(channelID string, mcid cid.Cid) error { func (ca *channelAccessor) waitPaychCreateMsg(ctx context.Context, channelID string, mcid cid.Cid) error {
mwait, err := ca.api.StateWaitMsg(ca.chctx, mcid, build.MessageConfidence, api.LookbackNoLimit, true) mwait, err := ca.api.StateWaitMsg(ca.chctx, mcid, build.MessageConfidence, api.LookbackNoLimit, true)
if err != nil { if err != nil {
log.Errorf("wait msg: %v", err) log.Errorf("wait msg: %v", err)
@ -425,7 +425,7 @@ func (ca *channelAccessor) waitPaychCreateMsg(channelID string, mcid cid.Cid) er
defer ca.lk.Unlock() defer ca.lk.Unlock()
// Channel creation failed, so remove the channel from the datastore // Channel creation failed, so remove the channel from the datastore
dserr := ca.store.RemoveChannel(channelID) dserr := ca.store.RemoveChannel(ctx, channelID)
if dserr != nil { if dserr != nil {
log.Errorf("failed to remove channel %s: %s", channelID, dserr) log.Errorf("failed to remove channel %s: %s", channelID, dserr)
} }
@ -449,7 +449,7 @@ func (ca *channelAccessor) waitPaychCreateMsg(channelID string, mcid cid.Cid) er
defer ca.lk.Unlock() defer ca.lk.Unlock()
// Store robust address of channel // Store robust address of channel
ca.mutateChannelInfo(channelID, func(channelInfo *ChannelInfo) { ca.mutateChannelInfo(ctx, channelID, func(channelInfo *ChannelInfo) {
channelInfo.Channel = &decodedReturn.RobustAddress channelInfo.Channel = &decodedReturn.RobustAddress
channelInfo.Amount = channelInfo.PendingAmount channelInfo.Amount = channelInfo.PendingAmount
channelInfo.PendingAmount = big.NewInt(0) channelInfo.PendingAmount = big.NewInt(0)
@ -475,30 +475,30 @@ func (ca *channelAccessor) addFunds(ctx context.Context, channelInfo *ChannelInf
mcid := smsg.Cid() mcid := smsg.Cid()
// Store the add funds message CID on the channel // Store the add funds message CID on the channel
ca.mutateChannelInfo(channelInfo.ChannelID, func(ci *ChannelInfo) { ca.mutateChannelInfo(ctx, channelInfo.ChannelID, func(ci *ChannelInfo) {
ci.PendingAmount = amt ci.PendingAmount = amt
ci.AddFundsMsg = &mcid ci.AddFundsMsg = &mcid
}) })
// Store a reference from the message CID to the channel, so that we can // Store a reference from the message CID to the channel, so that we can
// look up the channel from the message CID // look up the channel from the message CID
err = ca.store.SaveNewMessage(channelInfo.ChannelID, mcid) err = ca.store.SaveNewMessage(ctx, channelInfo.ChannelID, mcid)
if err != nil { if err != nil {
log.Errorf("saving add funds message CID %s: %s", mcid, err) log.Errorf("saving add funds message CID %s: %s", mcid, err)
} }
go ca.waitForAddFundsMsg(channelInfo.ChannelID, mcid) go ca.waitForAddFundsMsg(ctx, channelInfo.ChannelID, mcid)
return &mcid, nil return &mcid, nil
} }
// waitForAddFundsMsg waits for mcid to appear on chain and returns error, if any // waitForAddFundsMsg waits for mcid to appear on chain and returns error, if any
func (ca *channelAccessor) waitForAddFundsMsg(channelID string, mcid cid.Cid) { func (ca *channelAccessor) waitForAddFundsMsg(ctx context.Context, channelID string, mcid cid.Cid) {
err := ca.waitAddFundsMsg(channelID, mcid) err := ca.waitAddFundsMsg(ctx, channelID, mcid)
ca.msgWaitComplete(mcid, err) ca.msgWaitComplete(ctx, mcid, err)
} }
func (ca *channelAccessor) waitAddFundsMsg(channelID string, mcid cid.Cid) error { func (ca *channelAccessor) waitAddFundsMsg(ctx context.Context, channelID string, mcid cid.Cid) error {
mwait, err := ca.api.StateWaitMsg(ca.chctx, mcid, build.MessageConfidence, api.LookbackNoLimit, true) mwait, err := ca.api.StateWaitMsg(ca.chctx, mcid, build.MessageConfidence, api.LookbackNoLimit, true)
if err != nil { if err != nil {
log.Error(err) log.Error(err)
@ -512,7 +512,7 @@ func (ca *channelAccessor) waitAddFundsMsg(channelID string, mcid cid.Cid) error
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
ca.mutateChannelInfo(channelID, func(channelInfo *ChannelInfo) { ca.mutateChannelInfo(ctx, channelID, func(channelInfo *ChannelInfo) {
channelInfo.PendingAmount = big.NewInt(0) channelInfo.PendingAmount = big.NewInt(0)
channelInfo.AddFundsMsg = nil channelInfo.AddFundsMsg = nil
}) })
@ -524,7 +524,7 @@ func (ca *channelAccessor) waitAddFundsMsg(channelID string, mcid cid.Cid) error
defer ca.lk.Unlock() defer ca.lk.Unlock()
// Store updated amount // Store updated amount
ca.mutateChannelInfo(channelID, func(channelInfo *ChannelInfo) { ca.mutateChannelInfo(ctx, channelID, func(channelInfo *ChannelInfo) {
channelInfo.Amount = types.BigAdd(channelInfo.Amount, channelInfo.PendingAmount) channelInfo.Amount = types.BigAdd(channelInfo.Amount, channelInfo.PendingAmount)
channelInfo.PendingAmount = big.NewInt(0) channelInfo.PendingAmount = big.NewInt(0)
channelInfo.AddFundsMsg = nil channelInfo.AddFundsMsg = nil
@ -534,8 +534,8 @@ func (ca *channelAccessor) waitAddFundsMsg(channelID string, mcid cid.Cid) error
} }
// Change the state of the channel in the store // Change the state of the channel in the store
func (ca *channelAccessor) mutateChannelInfo(channelID string, mutate func(*ChannelInfo)) { func (ca *channelAccessor) mutateChannelInfo(ctx context.Context, channelID string, mutate func(*ChannelInfo)) {
channelInfo, err := ca.store.ByChannelID(channelID) channelInfo, err := ca.store.ByChannelID(ctx, channelID)
// If there's an error reading or writing to the store just log an error. // If there's an error reading or writing to the store just log an error.
// For now we're assuming it's unlikely to happen in practice. // For now we're assuming it's unlikely to happen in practice.
@ -549,7 +549,7 @@ func (ca *channelAccessor) mutateChannelInfo(channelID string, mutate func(*Chan
mutate(channelInfo) mutate(channelInfo)
err = ca.store.putChannelInfo(channelInfo) err = ca.store.putChannelInfo(ctx, channelInfo)
if err != nil { if err != nil {
log.Errorf("Error writing channel info to store: %s", err) log.Errorf("Error writing channel info to store: %s", err)
} }
@ -560,8 +560,8 @@ func (ca *channelAccessor) mutateChannelInfo(channelID string, mutate func(*Chan
// messages. // messages.
// Outstanding messages can occur if a create / add funds message was sent and // Outstanding messages can occur if a create / add funds message was sent and
// then the system was shut down or crashed before the result was received. // then the system was shut down or crashed before the result was received.
func (pm *Manager) restartPending() error { func (pm *Manager) restartPending(ctx context.Context) error {
cis, err := pm.store.WithPendingAddFunds() cis, err := pm.store.WithPendingAddFunds(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -575,16 +575,16 @@ func (pm *Manager) restartPending() error {
if err != nil { if err != nil {
return xerrors.Errorf("error initializing payment channel manager %s -> %s: %s", ci.Control, ci.Target, err) return xerrors.Errorf("error initializing payment channel manager %s -> %s: %s", ci.Control, ci.Target, err)
} }
go ca.waitForPaychCreateMsg(ci.ChannelID, *ci.CreateMsg) go ca.waitForPaychCreateMsg(ctx, ci.ChannelID, *ci.CreateMsg)
return nil return nil
}) })
} else if ci.AddFundsMsg != nil { } else if ci.AddFundsMsg != nil {
group.Go(func() error { group.Go(func() error {
ca, err := pm.accessorByAddress(*ci.Channel) ca, err := pm.accessorByAddress(ctx, *ci.Channel)
if err != nil { if err != nil {
return xerrors.Errorf("error initializing payment channel manager %s: %s", ci.Channel, err) return xerrors.Errorf("error initializing payment channel manager %s: %s", ci.Channel, err)
} }
go ca.waitForAddFundsMsg(ci.ChannelID, *ci.AddFundsMsg) go ca.waitForAddFundsMsg(ctx, ci.ChannelID, *ci.AddFundsMsg)
return nil return nil
}) })
} }
@ -598,7 +598,7 @@ func (ca *channelAccessor) getPaychWaitReady(ctx context.Context, mcid cid.Cid)
ca.lk.Lock() ca.lk.Lock()
// First check if the message has completed // First check if the message has completed
msgInfo, err := ca.store.GetMessage(mcid) msgInfo, err := ca.store.GetMessage(ctx, mcid)
if err != nil { if err != nil {
ca.lk.Unlock() ca.lk.Unlock()
@ -617,7 +617,7 @@ func (ca *channelAccessor) getPaychWaitReady(ctx context.Context, mcid cid.Cid)
ca.lk.Unlock() ca.lk.Unlock()
// Get the channel address // Get the channel address
ci, err := ca.store.ByMessageCid(mcid) ci, err := ca.store.ByMessageCid(ctx, mcid)
if err != nil { if err != nil {
return address.Undef, err return address.Undef, err
} }
@ -660,7 +660,7 @@ func (ca *channelAccessor) msgPromise(ctx context.Context, mcid cid.Cid) chan on
res := onMsgRes{err: err} res := onMsgRes{err: err}
if res.err == nil { if res.err == nil {
// Get the channel associated with the message cid // Get the channel associated with the message cid
ci, err := ca.store.ByMessageCid(mcid) ci, err := ca.store.ByMessageCid(ctx, mcid)
if err != nil { if err != nil {
res.err = err res.err = err
} else { } else {
@ -689,6 +689,6 @@ func (ca *channelAccessor) msgPromise(ctx context.Context, mcid cid.Cid) chan on
return promise return promise
} }
func (ca *channelAccessor) availableFunds(channelID string) (*api.ChannelAvailableFunds, error) { func (ca *channelAccessor) availableFunds(ctx context.Context, channelID string) (*api.ChannelAvailableFunds, error) {
return ca.processQueue(channelID) return ca.processQueue(ctx, channelID)
} }

85
paychmgr/store.go
View File

@ -2,6 +2,7 @@ package paychmgr
import ( import (
"bytes" "bytes"
"context"
"errors" "errors"
"fmt" "fmt"
@ -157,26 +158,26 @@ func (ci *ChannelInfo) wasVoucherSubmitted(sv *paych.SignedVoucher) (bool, error
// TrackChannel stores a channel, returning an error if the channel was already // TrackChannel stores a channel, returning an error if the channel was already
// being tracked // being tracked
func (ps *Store) TrackChannel(ci *ChannelInfo) (*ChannelInfo, error) { func (ps *Store) TrackChannel(ctx context.Context, ci *ChannelInfo) (*ChannelInfo, error) {
_, err := ps.ByAddress(*ci.Channel) _, err := ps.ByAddress(ctx, *ci.Channel)
switch err { switch err {
default: default:
return nil, err return nil, err
case nil: case nil:
return nil, fmt.Errorf("already tracking channel: %s", ci.Channel) return nil, fmt.Errorf("already tracking channel: %s", ci.Channel)
case ErrChannelNotTracked: case ErrChannelNotTracked:
err = ps.putChannelInfo(ci) err = ps.putChannelInfo(ctx, ci)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return ps.ByAddress(*ci.Channel) return ps.ByAddress(ctx, *ci.Channel)
} }
} }
// ListChannels returns the addresses of all channels that have been created // ListChannels returns the addresses of all channels that have been created
func (ps *Store) ListChannels() ([]address.Address, error) { func (ps *Store) ListChannels(ctx context.Context) ([]address.Address, error) {
cis, err := ps.findChans(func(ci *ChannelInfo) bool { cis, err := ps.findChans(ctx, func(ci *ChannelInfo) bool {
return ci.Channel != nil return ci.Channel != nil
}, 0) }, 0)
if err != nil { if err != nil {
@ -193,8 +194,8 @@ func (ps *Store) ListChannels() ([]address.Address, error) {
// findChan finds a single channel using the given filter. // findChan finds a single channel using the given filter.
// If there isn't a channel that matches the filter, returns ErrChannelNotTracked // If there isn't a channel that matches the filter, returns ErrChannelNotTracked
func (ps *Store) findChan(filter func(ci *ChannelInfo) bool) (*ChannelInfo, error) { func (ps *Store) findChan(ctx context.Context, filter func(ci *ChannelInfo) bool) (*ChannelInfo, error) {
cis, err := ps.findChans(filter, 1) cis, err := ps.findChans(ctx, filter, 1)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -208,8 +209,8 @@ func (ps *Store) findChan(filter func(ci *ChannelInfo) bool) (*ChannelInfo, erro
// findChans loops over all channels, only including those that pass the filter. // findChans loops over all channels, only including those that pass the filter.
// max is the maximum number of channels to return. Set to zero to return unlimited channels. // max is the maximum number of channels to return. Set to zero to return unlimited channels.
func (ps *Store) findChans(filter func(*ChannelInfo) bool, max int) ([]ChannelInfo, error) { func (ps *Store) findChans(ctx context.Context, filter func(*ChannelInfo) bool, max int) ([]ChannelInfo, error) {
res, err := ps.ds.Query(dsq.Query{Prefix: dsKeyChannelInfo}) res, err := ps.ds.Query(ctx, dsq.Query{Prefix: dsKeyChannelInfo})
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -251,8 +252,8 @@ func (ps *Store) findChans(filter func(*ChannelInfo) bool, max int) ([]ChannelIn
} }
// AllocateLane allocates a new lane for the given channel // AllocateLane allocates a new lane for the given channel
func (ps *Store) AllocateLane(ch address.Address) (uint64, error) { func (ps *Store) AllocateLane(ctx context.Context, ch address.Address) (uint64, error) {
ci, err := ps.ByAddress(ch) ci, err := ps.ByAddress(ctx, ch)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -260,12 +261,12 @@ func (ps *Store) AllocateLane(ch address.Address) (uint64, error) {
out := ci.NextLane out := ci.NextLane
ci.NextLane++ ci.NextLane++
return out, ps.putChannelInfo(ci) return out, ps.putChannelInfo(ctx, ci)
} }
// VouchersForPaych gets the vouchers for the given channel // VouchersForPaych gets the vouchers for the given channel
func (ps *Store) VouchersForPaych(ch address.Address) ([]*VoucherInfo, error) { func (ps *Store) VouchersForPaych(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) {
ci, err := ps.ByAddress(ch) ci, err := ps.ByAddress(ctx, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -273,17 +274,17 @@ func (ps *Store) VouchersForPaych(ch address.Address) ([]*VoucherInfo, error) {
return ci.Vouchers, nil return ci.Vouchers, nil
} }
func (ps *Store) MarkVoucherSubmitted(ci *ChannelInfo, sv *paych.SignedVoucher) error { func (ps *Store) MarkVoucherSubmitted(ctx context.Context, ci *ChannelInfo, sv *paych.SignedVoucher) error {
err := ci.markVoucherSubmitted(sv) err := ci.markVoucherSubmitted(sv)
if err != nil { if err != nil {
return err return err
} }
return ps.putChannelInfo(ci) return ps.putChannelInfo(ctx, ci)
} }
// ByAddress gets the channel that matches the given address // ByAddress gets the channel that matches the given address
func (ps *Store) ByAddress(addr address.Address) (*ChannelInfo, error) { func (ps *Store) ByAddress(ctx context.Context, addr address.Address) (*ChannelInfo, error) {
return ps.findChan(func(ci *ChannelInfo) bool { return ps.findChan(ctx, func(ci *ChannelInfo) bool {
return ci.Channel != nil && *ci.Channel == addr return ci.Channel != nil && *ci.Channel == addr
}) })
} }
@ -307,7 +308,7 @@ func dskeyForMsg(mcid cid.Cid) datastore.Key {
} }
// SaveNewMessage is called when a message is sent // SaveNewMessage is called when a message is sent
func (ps *Store) SaveNewMessage(channelID string, mcid cid.Cid) error { func (ps *Store) SaveNewMessage(ctx context.Context, channelID string, mcid cid.Cid) error {
k := dskeyForMsg(mcid) k := dskeyForMsg(mcid)
b, err := cborrpc.Dump(&MsgInfo{ChannelID: channelID, MsgCid: mcid}) b, err := cborrpc.Dump(&MsgInfo{ChannelID: channelID, MsgCid: mcid})
@ -315,12 +316,12 @@ func (ps *Store) SaveNewMessage(channelID string, mcid cid.Cid) error {
return err return err
} }
return ps.ds.Put(k, b) return ps.ds.Put(ctx, k, b)
} }
// SaveMessageResult is called when the result of a message is received // SaveMessageResult is called when the result of a message is received
func (ps *Store) SaveMessageResult(mcid cid.Cid, msgErr error) error { func (ps *Store) SaveMessageResult(ctx context.Context, mcid cid.Cid, msgErr error) error {
minfo, err := ps.GetMessage(mcid) minfo, err := ps.GetMessage(ctx, mcid)
if err != nil { if err != nil {
return err return err
} }
@ -336,17 +337,17 @@ func (ps *Store) SaveMessageResult(mcid cid.Cid, msgErr error) error {
return err return err
} }
return ps.ds.Put(k, b) return ps.ds.Put(ctx, k, b)
} }
// ByMessageCid gets the channel associated with a message // ByMessageCid gets the channel associated with a message
func (ps *Store) ByMessageCid(mcid cid.Cid) (*ChannelInfo, error) { func (ps *Store) ByMessageCid(ctx context.Context, mcid cid.Cid) (*ChannelInfo, error) {
minfo, err := ps.GetMessage(mcid) minfo, err := ps.GetMessage(ctx, mcid)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ci, err := ps.findChan(func(ci *ChannelInfo) bool { ci, err := ps.findChan(ctx, func(ci *ChannelInfo) bool {
return ci.ChannelID == minfo.ChannelID return ci.ChannelID == minfo.ChannelID
}) })
if err != nil { if err != nil {
@ -357,10 +358,10 @@ func (ps *Store) ByMessageCid(mcid cid.Cid) (*ChannelInfo, error) {
} }
// GetMessage gets the message info for a given message CID // GetMessage gets the message info for a given message CID
func (ps *Store) GetMessage(mcid cid.Cid) (*MsgInfo, error) { func (ps *Store) GetMessage(ctx context.Context, mcid cid.Cid) (*MsgInfo, error) {
k := dskeyForMsg(mcid) k := dskeyForMsg(mcid)
val, err := ps.ds.Get(k) val, err := ps.ds.Get(ctx, k)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -375,8 +376,8 @@ func (ps *Store) GetMessage(mcid cid.Cid) (*MsgInfo, error) {
// OutboundActiveByFromTo looks for outbound channels that have not been // OutboundActiveByFromTo looks for outbound channels that have not been
// settled, with the given from / to addresses // settled, with the given from / to addresses
func (ps *Store) OutboundActiveByFromTo(from address.Address, to address.Address) (*ChannelInfo, error) { func (ps *Store) OutboundActiveByFromTo(ctx context.Context, from address.Address, to address.Address) (*ChannelInfo, error) {
return ps.findChan(func(ci *ChannelInfo) bool { return ps.findChan(ctx, func(ci *ChannelInfo) bool {
if ci.Direction != DirOutbound { if ci.Direction != DirOutbound {
return false return false
} }
@ -390,8 +391,8 @@ func (ps *Store) OutboundActiveByFromTo(from address.Address, to address.Address
// WithPendingAddFunds is used on startup to find channels for which a // WithPendingAddFunds is used on startup to find channels for which a
// create channel or add funds message has been sent, but lotus shut down // create channel or add funds message has been sent, but lotus shut down
// before the response was received. // before the response was received.
func (ps *Store) WithPendingAddFunds() ([]ChannelInfo, error) { func (ps *Store) WithPendingAddFunds(ctx context.Context) ([]ChannelInfo, error) {
return ps.findChans(func(ci *ChannelInfo) bool { return ps.findChans(ctx, func(ci *ChannelInfo) bool {
if ci.Direction != DirOutbound { if ci.Direction != DirOutbound {
return false return false
} }
@ -400,10 +401,10 @@ func (ps *Store) WithPendingAddFunds() ([]ChannelInfo, error) {
} }
// ByChannelID gets channel info by channel ID // ByChannelID gets channel info by channel ID
func (ps *Store) ByChannelID(channelID string) (*ChannelInfo, error) { func (ps *Store) ByChannelID(ctx context.Context, channelID string) (*ChannelInfo, error) {
var stored ChannelInfo var stored ChannelInfo
res, err := ps.ds.Get(dskeyForChannel(channelID)) res, err := ps.ds.Get(ctx, dskeyForChannel(channelID))
if err != nil { if err != nil {
if err == datastore.ErrNotFound { if err == datastore.ErrNotFound {
return nil, ErrChannelNotTracked return nil, ErrChannelNotTracked
@ -415,7 +416,7 @@ func (ps *Store) ByChannelID(channelID string) (*ChannelInfo, error) {
} }
// CreateChannel creates an outbound channel for the given from / to // CreateChannel creates an outbound channel for the given from / to
func (ps *Store) CreateChannel(from address.Address, to address.Address, createMsgCid cid.Cid, amt types.BigInt) (*ChannelInfo, error) { func (ps *Store) CreateChannel(ctx context.Context, from address.Address, to address.Address, createMsgCid cid.Cid, amt types.BigInt) (*ChannelInfo, error) {
ci := &ChannelInfo{ ci := &ChannelInfo{
Direction: DirOutbound, Direction: DirOutbound,
NextLane: 0, NextLane: 0,
@ -426,13 +427,13 @@ func (ps *Store) CreateChannel(from address.Address, to address.Address, createM
} }
// Save the new channel // Save the new channel
err := ps.putChannelInfo(ci) err := ps.putChannelInfo(ctx, ci)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Save a reference to the create message // Save a reference to the create message
err = ps.SaveNewMessage(ci.ChannelID, createMsgCid) err = ps.SaveNewMessage(ctx, ci.ChannelID, createMsgCid)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -441,8 +442,8 @@ func (ps *Store) CreateChannel(from address.Address, to address.Address, createM
} }
// RemoveChannel removes the channel with the given channel ID // RemoveChannel removes the channel with the given channel ID
func (ps *Store) RemoveChannel(channelID string) error { func (ps *Store) RemoveChannel(ctx context.Context, channelID string) error {
return ps.ds.Delete(dskeyForChannel(channelID)) return ps.ds.Delete(ctx, dskeyForChannel(channelID))
} }
// The datastore key used to identify the channel info // The datastore key used to identify the channel info
@ -451,7 +452,7 @@ func dskeyForChannel(channelID string) datastore.Key {
} }
// putChannelInfo stores the channel info in the datastore // putChannelInfo stores the channel info in the datastore
func (ps *Store) putChannelInfo(ci *ChannelInfo) error { func (ps *Store) putChannelInfo(ctx context.Context, ci *ChannelInfo) error {
if len(ci.ChannelID) == 0 { if len(ci.ChannelID) == 0 {
ci.ChannelID = uuid.New().String() ci.ChannelID = uuid.New().String()
} }
@ -462,7 +463,7 @@ func (ps *Store) putChannelInfo(ci *ChannelInfo) error {
return err return err
} }
return ps.ds.Put(k, b) return ps.ds.Put(ctx, k, b)
} }
// TODO: This is a hack to get around not being able to CBOR marshall a nil // TODO: This is a hack to get around not being able to CBOR marshall a nil

24
storage/sectorblocks/blocks.go
View File

@ -68,11 +68,11 @@ func NewSectorBlocks(sb SectorBuilder, ds dtypes.MetadataDS) *SectorBlocks {
return sbc return sbc
} }
func (st *SectorBlocks) writeRef(dealID abi.DealID, sectorID abi.SectorNumber, offset abi.PaddedPieceSize, size abi.UnpaddedPieceSize) error { func (st *SectorBlocks) writeRef(ctx context.Context, dealID abi.DealID, sectorID abi.SectorNumber, offset abi.PaddedPieceSize, size abi.UnpaddedPieceSize) error {
st.keyLk.Lock() // TODO: make this multithreaded st.keyLk.Lock() // TODO: make this multithreaded
defer st.keyLk.Unlock() defer st.keyLk.Unlock()
v, err := st.keys.Get(DealIDToDsKey(dealID)) v, err := st.keys.Get(ctx, DealIDToDsKey(dealID))
if err == datastore.ErrNotFound { if err == datastore.ErrNotFound {
err = nil err = nil
} }
@ -97,7 +97,7 @@ func (st *SectorBlocks) writeRef(dealID abi.DealID, sectorID abi.SectorNumber, o
if err != nil { if err != nil {
return xerrors.Errorf("serializing refs: %w", err) return xerrors.Errorf("serializing refs: %w", err)
} }
return st.keys.Put(DealIDToDsKey(dealID), newRef) // TODO: batch somehow return st.keys.Put(ctx, DealIDToDsKey(dealID), newRef) // TODO: batch somehow
} }
func (st *SectorBlocks) AddPiece(ctx context.Context, size abi.UnpaddedPieceSize, r io.Reader, d api.PieceDealInfo) (abi.SectorNumber, abi.PaddedPieceSize, error) { func (st *SectorBlocks) AddPiece(ctx context.Context, size abi.UnpaddedPieceSize, r io.Reader, d api.PieceDealInfo) (abi.SectorNumber, abi.PaddedPieceSize, error) {
@ -107,7 +107,7 @@ func (st *SectorBlocks) AddPiece(ctx context.Context, size abi.UnpaddedPieceSize
} }
// TODO: DealID has very low finality here // TODO: DealID has very low finality here
err = st.writeRef(d.DealID, so.Sector, so.Offset, size) err = st.writeRef(ctx, d.DealID, so.Sector, so.Offset, size)
if err != nil { if err != nil {
return 0, 0, xerrors.Errorf("writeRef: %w", err) return 0, 0, xerrors.Errorf("writeRef: %w", err)
} }
@ -115,8 +115,8 @@ func (st *SectorBlocks) AddPiece(ctx context.Context, size abi.UnpaddedPieceSize
return so.Sector, so.Offset, nil return so.Sector, so.Offset, nil
} }
func (st *SectorBlocks) List() (map[uint64][]api.SealedRef, error) { func (st *SectorBlocks) List(ctx context.Context) (map[uint64][]api.SealedRef, error) {
res, err := st.keys.Query(query.Query{}) res, err := st.keys.Query(ctx, query.Query{})
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -144,8 +144,8 @@ func (st *SectorBlocks) List() (map[uint64][]api.SealedRef, error) {
return out, nil return out, nil
} }
func (st *SectorBlocks) GetRefs(dealID abi.DealID) ([]api.SealedRef, error) { // TODO: track local sectors func (st *SectorBlocks) GetRefs(ctx context.Context, dealID abi.DealID) ([]api.SealedRef, error) { // TODO: track local sectors
ent, err := st.keys.Get(DealIDToDsKey(dealID)) ent, err := st.keys.Get(ctx, DealIDToDsKey(dealID))
if err == datastore.ErrNotFound { if err == datastore.ErrNotFound {
err = ErrNotFound err = ErrNotFound
} }
@ -161,8 +161,8 @@ func (st *SectorBlocks) GetRefs(dealID abi.DealID) ([]api.SealedRef, error) { //
return refs.Refs, nil return refs.Refs, nil
} }
func (st *SectorBlocks) GetSize(dealID abi.DealID) (uint64, error) { func (st *SectorBlocks) GetSize(ctx context.Context, dealID abi.DealID) (uint64, error) {
refs, err := st.GetRefs(dealID) refs, err := st.GetRefs(ctx, dealID)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -170,7 +170,7 @@ func (st *SectorBlocks) GetSize(dealID abi.DealID) (uint64, error) {
return uint64(refs[0].Size), nil return uint64(refs[0].Size), nil
} }
func (st *SectorBlocks) Has(dealID abi.DealID) (bool, error) { func (st *SectorBlocks) Has(ctx context.Context, dealID abi.DealID) (bool, error) {
// TODO: ensure sector is still there // TODO: ensure sector is still there
return st.keys.Has(DealIDToDsKey(dealID)) return st.keys.Has(ctx, DealIDToDsKey(dealID))
} }