chain

Documentation

Index

• Constants
• Variables
• type GapFiller
  • func NewGapFiller(node lens.API, db *storage.Database, name string, minHeight, maxHeight uint64, ...) *GapFiller
  • func (g *GapFiller) Done() <-chan struct{}
  • func (g *GapFiller) Run(ctx context.Context) error
• type GapIndexer
  • func NewGapIndexer(node lens.API, db *storage.Database, name string, minHeight, maxHeight uint64, ...) *GapIndexer
  • func (g *GapIndexer) Done() <-chan struct{}
  • func (g *GapIndexer) Find(ctx context.Context) (visor.GapReportList, error)
  • func (g *GapIndexer) Run(ctx context.Context) error
• type HeadEvent
• type HeadNotifier
• type TaskHeight
• type TipSetCache
  • func NewTipSetCache(size int) *TipSetCache
  • func (c *TipSetCache) Add(ts *types.TipSet) (*types.TipSet, error)
  • func (c *TipSetCache) Confidence() int
  • func (c *TipSetCache) Head() (*types.TipSet, error)
  • func (c *TipSetCache) Height() abi.ChainEpoch
  • func (c *TipSetCache) Len() int
  • func (c *TipSetCache) Reset()
  • func (c *TipSetCache) Revert(ts *types.TipSet) error
  • func (c *TipSetCache) SetCurrent(ts *types.TipSet) error
  • func (c *TipSetCache) Size() int
  • func (c *TipSetCache) Tail() (*types.TipSet, error)
  • func (c *TipSetCache) TailHeight() abi.ChainEpoch
  • func (c *TipSetCache) Warm(ctx context.Context, head *types.TipSet, ...) error
• type TipSetObserver
  • func (h *TipSetObserver) Apply(ctx context.Context, from, to *types.TipSet) error
  • func (h *TipSetObserver) Cancel(err error)
  • func (h *TipSetObserver) Err() error
  • func (h *TipSetObserver) HeadEvents() <-chan *HeadEvent
  • func (h *TipSetObserver) Revert(ctx context.Context, from, to *types.TipSet) error
  • func (h *TipSetObserver) SetCurrent(ctx context.Context, ts *types.TipSet) error
• type Walker
  • func NewWalker(obs *indexer.Manager, node lens.API, name string, minHeight, maxHeight int64) *Walker
  • func (c *Walker) Done() <-chan struct{}
  • func (c *Walker) Run(ctx context.Context) error
  • func (c *Walker) WalkChain(ctx context.Context, node lens.API, ts *types.TipSet) error
• type Watcher
  • func NewWatcher(api WatcherAPI, indexer *indexer.Manager, name string, confidence int, ...) *Watcher
  • func (c *Watcher) Done() <-chan struct{}
  • func (c *Watcher) Run(ctx context.Context) error
• type WatcherAPI

Constants

const (
	// HeadEventRevert indicates that the event signals a reversion of a tipset from the chain
	HeadEventRevert = "revert"

	// HeadEventRevert indicates that the event signals the application of a tipset to the chain
	HeadEventApply = "apply"

	// HeadEventRevert indicates that the event signals the current known head tipset
	HeadEventCurrent = "current"
)

Constants for HeadEvent types

Variables

var (
	ErrCacheEmpty       = errors.New("cache empty")
	ErrAddOutOfOrder    = errors.New("added tipset height lower than current head")
	ErrRevertOutOfOrder = errors.New("reverted tipset does not match current head")
	ErrEmptyRevert      = errors.New("reverted received on empty cache")
)

Types

type GapFiller

type GapFiller struct {
	DB *storage.Database
	// contains filtered or unexported fields
}

func NewGapFiller

func NewGapFiller(node lens.API, db *storage.Database, name string, minHeight, maxHeight uint64, tasks []string) *GapFiller

func (*GapFiller) Done

func (g *GapFiller) Done() <-chan struct{}

func (*GapFiller) Run

func (g *GapFiller) Run(ctx context.Context) error

type GapIndexer

type GapIndexer struct {
	DB *storage.Database
	// contains filtered or unexported fields
}

func NewGapIndexer

func NewGapIndexer(node lens.API, db *storage.Database, name string, minHeight, maxHeight uint64, tasks []string) *GapIndexer

func (*GapIndexer) Done

func (g *GapIndexer) Done() <-chan struct{}

func (*GapIndexer) Find

func (g *GapIndexer) Find(ctx context.Context) (visor.GapReportList, error)

func (*GapIndexer) Run

func (g *GapIndexer) Run(ctx context.Context) error

type HeadEvent

type HeadEvent struct {
	Type   string
	TipSet *types.TipSet
}

A HeadEvent is a notification of a change at the head of the chain

type HeadNotifier

type HeadNotifier interface {
	// HeadEvents returns a channel that receives head events. It may be closed
	// by the sender of the events, in which case Err will return a non-nil error
	// explaining why. HeadEvents may return nil if this implementation will never
	// notify any events.
	HeadEvents() <-chan *HeadEvent

	// Err returns the reason for the closing of the HeadEvents channel.
	Err() error
}

A HeadNotifier reports tipset events that occur at the head of the chain

type TaskHeight

type TaskHeight struct {
	Task   string
	Height uint64
	Status string
}

type TipSetCache

type TipSetCache struct {
	// contains filtered or unexported fields
}

TipSetCache is a cache of recent tipsets that can keep track of reversions. Inspired by tipSetCache in Lotus chain/events package.

func NewTipSetCache

func NewTipSetCache(size int) *TipSetCache

func (*TipSetCache) Add

func (c *TipSetCache) Add(ts *types.TipSet) (*types.TipSet, error)

Add adds a new tipset which becomes the new head of the cache. If the buffer is full, the tail being evicted is also returned.

func (*TipSetCache) Confidence

func (c *TipSetCache) Confidence() int

Confidence returns the number of tipset that the cache must hold before tipsets are evicted on Add.

func (*TipSetCache) Head

func (c *TipSetCache) Head() (*types.TipSet, error)

Head returns the tipset at the head of the cache.

func (*TipSetCache) Height

func (c *TipSetCache) Height() abi.ChainEpoch

Height returns the height of the current head or zero if the cache is empty.

func (*TipSetCache) Len

func (c *TipSetCache) Len() int

Len returns the number of tipsets in the cache. This will never exceed the size of the cache.

func (*TipSetCache) Reset

func (c *TipSetCache) Reset()

Reset removes all tipsets from the cache

func (*TipSetCache) Revert

func (c *TipSetCache) Revert(ts *types.TipSet) error

Revert removes the head tipset

func (*TipSetCache) SetCurrent

func (c *TipSetCache) SetCurrent(ts *types.TipSet) error

SetCurrent replaces the current head

func (*TipSetCache) Size

func (c *TipSetCache) Size() int

Size returns the maximum number of tipsets that may be present in the cache.

func (*TipSetCache) Tail

func (c *TipSetCache) Tail() (*types.TipSet, error)

Tail returns the tipset at the tail of the cache.

func (*TipSetCache) TailHeight

func (c *TipSetCache) TailHeight() abi.ChainEpoch

TailHeight returns the height of the current tail or zero if the cache is empty.

func (*TipSetCache) Warm

func (c *TipSetCache) Warm(ctx context.Context, head *types.TipSet, getTipSetFn func(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)) error

Warm fills the TipSetCache with confidence tipsets so that subsequent calls to Add return a tipset.

type TipSetObserver

type TipSetObserver struct {
	// contains filtered or unexported fields
}

func (*TipSetObserver) Apply

func (h *TipSetObserver) Apply(ctx context.Context, from, to *types.TipSet) error

func (*TipSetObserver) Cancel

func (h *TipSetObserver) Cancel(err error)

func (*TipSetObserver) Err

func (h *TipSetObserver) Err() error

func (*TipSetObserver) HeadEvents

func (h *TipSetObserver) HeadEvents() <-chan *HeadEvent

func (*TipSetObserver) Revert

func (h *TipSetObserver) Revert(ctx context.Context, from, to *types.TipSet) error

func (*TipSetObserver) SetCurrent

func (h *TipSetObserver) SetCurrent(ctx context.Context, ts *types.TipSet) error

type Walker

type Walker struct {
	// contains filtered or unexported fields
}

Walker is a job that indexes blocks by walking the chain history.

func NewWalker

func NewWalker(obs *indexer.Manager, node lens.API, name string, minHeight, maxHeight int64) *Walker

func (*Walker) Done

func (c *Walker) Done() <-chan struct{}

func (*Walker) Run

func (c *Walker) Run(ctx context.Context) error

Run starts walking the chain history and continues until the context is done or the start of the chain is reached.

func (*Walker) WalkChain

func (c *Walker) WalkChain(ctx context.Context, node lens.API, ts *types.TipSet) error

type Watcher

type Watcher struct {
	// contains filtered or unexported fields
}

Watcher is a task that indexes blocks by following the chain head.

func NewWatcher

func NewWatcher(api WatcherAPI, indexer *indexer.Manager, name string, confidence int, poolSize int, bufferSize int) *Watcher

NewWatcher creates a new Watcher. confidence sets the number of tipsets that will be held in a cache awaiting possible reversion. Tipsets will be written to the database when they are evicted from the cache due to incoming later tipsets.

func (*Watcher) Done

func (c *Watcher) Done() <-chan struct{}

func (*Watcher) Run

func (c *Watcher) Run(ctx context.Context) error

Run starts following the chain head and blocks until the context is done or an error occurs.

type WatcherAPI

type WatcherAPI interface {
	Observe(obs events.TipSetObserver) *types.TipSet
	//Unregister(obs events.TipSetObserver) bool
	ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
}