lotus/chain/events/events_height.go

161 lines
3.1 KiB
Go
Raw Normal View History

2019-09-05 07:40:50 +00:00
package events
2019-09-04 16:09:08 +00:00
import (
"sync"
2019-09-05 07:40:50 +00:00
"github.com/filecoin-project/go-lotus/chain/types"
2019-09-04 16:09:08 +00:00
)
type heightEvents struct {
lk sync.Mutex
tsc *tipSetCache
gcConfidence uint64
ctr triggerId
heightTriggers map[triggerId]*heightHandler
htTriggerHeights map[triggerH][]triggerId
htHeights map[msgH][]triggerId
}
func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
2019-09-18 11:01:52 +00:00
// highest tipset is always the first (see api.ReorgOps)
2019-09-04 16:09:08 +00:00
newH := app[0].Height()
for _, ts := range rev {
// TODO: log error if h below gcconfidence
// revert height-based triggers
2019-10-04 22:43:04 +00:00
revert := func(h uint64, ts *types.TipSet) {
for _, tid := range e.htHeights[h] {
// don't revert if newH is above this ts
if newH >= h {
continue
}
err := e.heightTriggers[tid].revert(ts)
if err != nil {
log.Errorf("reverting chain trigger (@H %d): %s", h, err)
}
2019-09-04 16:09:08 +00:00
}
2019-10-04 22:43:04 +00:00
}
revert(ts.Height(), ts)
2019-09-04 16:09:08 +00:00
2019-10-04 22:43:04 +00:00
subh := ts.Height() - 1
for {
cts, err := e.tsc.get(subh)
2019-09-04 16:09:08 +00:00
if err != nil {
2019-10-04 22:43:04 +00:00
return err
}
if cts != nil {
break
2019-09-04 16:09:08 +00:00
}
2019-10-04 22:43:04 +00:00
2019-10-04 23:49:18 +00:00
revert(subh, ts)
2019-10-04 22:43:04 +00:00
subh--
2019-09-04 16:09:08 +00:00
}
if err := e.tsc.revert(ts); err != nil {
return err
}
}
2019-09-05 07:57:12 +00:00
tail := len(app) - 1
for i := range app {
ts := app[tail-i]
2019-09-04 16:09:08 +00:00
if err := e.tsc.add(ts); err != nil {
return err
}
// height triggers
2019-10-04 22:43:04 +00:00
apply := func(h uint64, ts *types.TipSet) error {
for _, tid := range e.htTriggerHeights[h] {
hnd := e.heightTriggers[tid]
triggerH := h - uint64(hnd.confidence)
incTs, err := e.tsc.getNonNull(triggerH)
2019-10-04 22:43:04 +00:00
if err != nil {
return err
}
if err := hnd.handle(incTs, h); err != nil {
log.Errorf("chain trigger (@H %d, called @ %d) failed: %s", triggerH, ts.Height(), err)
}
}
return nil
}
2019-09-04 16:09:08 +00:00
2019-10-04 22:43:04 +00:00
if err := apply(ts.Height(), ts); err != nil {
return err
}
subh := ts.Height() - 1
for {
cts, err := e.tsc.get(subh)
2019-09-04 16:09:08 +00:00
if err != nil {
return err
}
2019-10-04 22:43:04 +00:00
if cts != nil {
break
}
2019-10-04 23:49:18 +00:00
if err := apply(subh, ts); err != nil {
2019-10-04 22:43:04 +00:00
return err
2019-09-04 16:09:08 +00:00
}
2019-10-04 22:43:04 +00:00
subh--
2019-09-04 16:09:08 +00:00
}
2019-10-04 22:43:04 +00:00
2019-09-04 16:09:08 +00:00
}
return nil
}
2019-09-05 08:27:08 +00:00
// ChainAt invokes the specified `HeightHandler` when the chain reaches the
// specified height+confidence threshold. If the chain is rolled-back under the
// specified height, `RevertHandler` will be called.
2019-10-04 23:49:18 +00:00
//
// ts passed to handlers is the tipset at the specified, or above, if lower tipsets were null
func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence int, h uint64) error {
2019-09-04 16:09:08 +00:00
e.lk.Lock()
defer e.lk.Unlock()
bestH := e.tsc.best().Height()
if bestH >= h+uint64(confidence) {
ts, err := e.tsc.get(h)
if err != nil {
log.Warnf("events.ChainAt: calling HandleFunc with nil tipset, not found in cache: %s", err)
}
if err := hnd(ts, bestH); err != nil {
return err
}
}
if bestH >= h+uint64(confidence)+e.gcConfidence {
return nil
}
triggerAt := h + uint64(confidence)
id := e.ctr
e.ctr++
e.heightTriggers[id] = &heightHandler{
confidence: confidence,
handle: hnd,
revert: rev,
}
e.htHeights[h] = append(e.htHeights[h], id)
e.htTriggerHeights[triggerAt] = append(e.htTriggerHeights[triggerAt], id)
return nil
}