lotus/chain/state/statetree.go

351 lines
7.8 KiB
Go
Raw Normal View History

package state
2019-07-05 14:29:17 +00:00
import (
"context"
"fmt"
2020-02-25 20:54:58 +00:00
"github.com/filecoin-project/specs-actors/actors/builtin"
2020-02-21 17:13:50 +00:00
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
2019-07-08 12:51:45 +00:00
2020-02-12 07:22:55 +00:00
"github.com/filecoin-project/specs-actors/actors/util/adt"
2019-07-05 14:29:17 +00:00
"github.com/ipfs/go-cid"
2020-02-04 22:19:05 +00:00
cbor "github.com/ipfs/go-ipld-cbor"
logging "github.com/ipfs/go-log/v2"
"go.opencensus.io/trace"
2019-09-10 02:05:24 +00:00
"golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/lotus/chain/types"
2019-07-05 14:29:17 +00:00
)
var log = logging.Logger("statetree")
// StateTree stores actors state by their ID.
2019-07-05 14:29:17 +00:00
type StateTree struct {
root *adt.Map
2020-02-04 22:19:05 +00:00
Store cbor.IpldStore
2019-07-05 14:29:17 +00:00
snaps *stateSnaps
}
type stateSnaps struct {
layers []*stateSnapLayer
}
type stateSnapLayer struct {
actors map[address.Address]streeOp
resolveCache map[address.Address]address.Address
}
func newStateSnapLayer() *stateSnapLayer {
return &stateSnapLayer{
actors: make(map[address.Address]streeOp),
resolveCache: make(map[address.Address]address.Address),
}
}
type streeOp struct {
Act types.Actor
Delete bool
}
func newStateSnaps() *stateSnaps {
ss := &stateSnaps{}
ss.addLayer()
return ss
}
func (ss *stateSnaps) addLayer() {
ss.layers = append(ss.layers, newStateSnapLayer())
}
func (ss *stateSnaps) dropLayer() {
ss.layers[len(ss.layers)-1] = nil // allow it to be GCed
ss.layers = ss.layers[:len(ss.layers)-1]
}
func (ss *stateSnaps) mergeLastLayer() {
last := ss.layers[len(ss.layers)-1]
nextLast := ss.layers[len(ss.layers)-2]
for k, v := range last.actors {
nextLast.actors[k] = v
}
for k, v := range last.resolveCache {
nextLast.resolveCache[k] = v
}
ss.dropLayer()
}
func (ss *stateSnaps) resolveAddress(addr address.Address) (address.Address, bool) {
for i := len(ss.layers) - 1; i >= 0; i-- {
resa, ok := ss.layers[i].resolveCache[addr]
if ok {
return resa, true
}
}
return address.Undef, false
}
func (ss *stateSnaps) cacheResolveAddress(addr, resa address.Address) {
ss.layers[len(ss.layers)-1].resolveCache[addr] = resa
}
func (ss *stateSnaps) getActor(addr address.Address) (*types.Actor, error) {
for i := len(ss.layers) - 1; i >= 0; i-- {
act, ok := ss.layers[i].actors[addr]
if ok {
if act.Delete {
return nil, types.ErrActorNotFound
}
return &act.Act, nil
}
}
return nil, nil
}
func (ss *stateSnaps) setActor(addr address.Address, act *types.Actor) {
ss.layers[len(ss.layers)-1].actors[addr] = streeOp{Act: *act}
}
func (ss *stateSnaps) deleteActor(addr address.Address) {
ss.layers[len(ss.layers)-1].actors[addr] = streeOp{Delete: true}
2019-07-05 14:29:17 +00:00
}
2020-02-04 22:19:05 +00:00
func NewStateTree(cst cbor.IpldStore) (*StateTree, error) {
2019-07-05 14:29:17 +00:00
return &StateTree{
root: adt.MakeEmptyMap(adt.WrapStore(context.TODO(), cst)),
Store: cst,
snaps: newStateSnaps(),
2019-07-05 14:29:17 +00:00
}, nil
}
2020-02-04 22:19:05 +00:00
func LoadStateTree(cst cbor.IpldStore, c cid.Cid) (*StateTree, error) {
nd, err := adt.AsMap(adt.WrapStore(context.TODO(), cst), c)
2019-07-05 14:29:17 +00:00
if err != nil {
2019-07-30 16:04:36 +00:00
log.Errorf("loading hamt node %s failed: %s", c, err)
2019-07-05 14:29:17 +00:00
return nil, err
}
return &StateTree{
root: nd,
Store: cst,
snaps: newStateSnaps(),
2019-07-05 14:29:17 +00:00
}, nil
}
func (st *StateTree) SetActor(addr address.Address, act *types.Actor) error {
2019-11-15 16:39:43 +00:00
iaddr, err := st.LookupID(addr)
if err != nil {
return xerrors.Errorf("ID lookup failed: %w", err)
2019-07-05 14:29:17 +00:00
}
2019-11-15 16:39:43 +00:00
addr = iaddr
2019-07-05 14:29:17 +00:00
st.snaps.setActor(addr, act)
return nil
2019-07-05 14:29:17 +00:00
}
// LookupID gets the ID address of this actor's `addr` stored in the `InitActor`.
2019-11-15 16:39:43 +00:00
func (st *StateTree) LookupID(addr address.Address) (address.Address, error) {
if addr.Protocol() == address.ID {
return addr, nil
}
resa, ok := st.snaps.resolveAddress(addr)
if ok {
return resa, nil
}
2020-02-25 20:54:58 +00:00
act, err := st.GetActor(builtin.InitActorAddr)
2019-07-05 14:29:17 +00:00
if err != nil {
2019-09-10 02:05:24 +00:00
return address.Undef, xerrors.Errorf("getting init actor: %w", err)
2019-07-05 14:29:17 +00:00
}
2020-02-25 20:35:15 +00:00
var ias init_.State
if err := st.Store.Get(context.TODO(), act.Head, &ias); err != nil {
2019-09-10 02:05:24 +00:00
return address.Undef, xerrors.Errorf("loading init actor state: %w", err)
2019-07-05 14:29:17 +00:00
}
a, found, err := ias.ResolveAddress(&AdtStore{st.Store}, addr)
if err == nil && !found {
err = types.ErrActorNotFound
}
2020-02-22 13:10:46 +00:00
if err != nil {
return address.Undef, xerrors.Errorf("resolve address %s: %w", addr, err)
}
st.snaps.cacheResolveAddress(addr, a)
2020-02-22 13:10:46 +00:00
return a, nil
2019-07-05 14:29:17 +00:00
}
// GetActor returns the actor from any type of `addr` provided.
func (st *StateTree) GetActor(addr address.Address) (*types.Actor, error) {
if addr == address.Undef {
return nil, fmt.Errorf("GetActor called on undefined address")
}
// Transform `addr` to its ID format.
2019-11-15 16:39:43 +00:00
iaddr, err := st.LookupID(addr)
if err != nil {
if xerrors.Is(err, types.ErrActorNotFound) {
2020-02-22 13:10:46 +00:00
return nil, xerrors.Errorf("resolution lookup failed (%s): %w", addr, err)
2019-07-05 14:29:17 +00:00
}
2019-11-15 16:39:43 +00:00
return nil, xerrors.Errorf("address resolution: %w", err)
2019-07-05 14:29:17 +00:00
}
2019-11-15 16:39:43 +00:00
addr = iaddr
2019-07-05 14:29:17 +00:00
snapAct, err := st.snaps.getActor(addr)
if err != nil {
return nil, err
}
if snapAct != nil {
return snapAct, nil
2019-07-05 14:29:17 +00:00
}
2019-09-17 01:56:37 +00:00
var act types.Actor
if found, err := st.root.Get(adt.AddrKey(addr), &act); err != nil {
2019-09-30 23:55:35 +00:00
return nil, xerrors.Errorf("hamt find failed: %w", err)
} else if !found {
return nil, types.ErrActorNotFound
2019-07-05 14:29:17 +00:00
}
st.snaps.setActor(addr, &act)
2019-07-05 14:29:17 +00:00
return &act, nil
}
func (st *StateTree) DeleteActor(addr address.Address) error {
if addr == address.Undef {
return xerrors.Errorf("DeleteActor called on undefined address")
}
iaddr, err := st.LookupID(addr)
if err != nil {
if xerrors.Is(err, types.ErrActorNotFound) {
return xerrors.Errorf("resolution lookup failed (%s): %w", addr, err)
}
return xerrors.Errorf("address resolution: %w", err)
}
addr = iaddr
_, err = st.GetActor(addr)
if err != nil {
return err
}
st.snaps.deleteActor(addr)
return nil
}
func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
ctx, span := trace.StartSpan(ctx, "stateTree.Flush") //nolint:staticcheck
defer span.End()
if len(st.snaps.layers) != 1 {
return cid.Undef, xerrors.Errorf("tried to flush state tree with snapshots on the stack")
}
for addr, sto := range st.snaps.layers[0].actors {
if sto.Delete {
if err := st.root.Delete(adt.AddrKey(addr)); err != nil {
return cid.Undef, err
}
} else {
if err := st.root.Put(adt.AddrKey(addr), &sto.Act); err != nil {
return cid.Undef, err
}
2019-07-05 14:29:17 +00:00
}
}
return st.root.Root()
2019-07-05 14:29:17 +00:00
}
func (st *StateTree) Snapshot(ctx context.Context) error {
ctx, span := trace.StartSpan(ctx, "stateTree.SnapShot") //nolint:staticcheck
defer span.End()
st.snaps.addLayer()
2019-07-05 14:29:17 +00:00
return nil
}
func (st *StateTree) ClearSnapshot() {
st.snaps.mergeLastLayer()
}
func (st *StateTree) RegisterNewAddress(addr address.Address) (address.Address, error) {
2019-07-05 14:29:17 +00:00
var out address.Address
2020-02-25 20:54:58 +00:00
err := st.MutateActor(builtin.InitActorAddr, func(initact *types.Actor) error {
2020-02-25 20:35:15 +00:00
var ias init_.State
if err := st.Store.Get(context.TODO(), initact.Head, &ias); err != nil {
2019-07-05 14:29:17 +00:00
return err
}
2020-02-18 21:37:59 +00:00
oaddr, err := ias.MapAddressToNewID(&AdtStore{st.Store}, addr)
2019-07-05 14:29:17 +00:00
if err != nil {
return err
}
out = oaddr
ncid, err := st.Store.Put(context.TODO(), &ias)
2019-07-05 14:29:17 +00:00
if err != nil {
return err
}
initact.Head = ncid
return nil
})
if err != nil {
return address.Undef, err
}
return out, nil
}
2020-02-18 21:37:59 +00:00
type AdtStore struct{ cbor.IpldStore }
2020-02-12 07:22:55 +00:00
2020-02-18 21:37:59 +00:00
func (a *AdtStore) Context() context.Context {
2020-02-12 07:22:55 +00:00
return context.TODO()
}
2020-02-18 21:37:59 +00:00
var _ adt.Store = (*AdtStore)(nil)
2020-02-12 07:22:55 +00:00
2019-07-05 14:29:17 +00:00
func (st *StateTree) Revert() error {
st.snaps.dropLayer()
st.snaps.addLayer()
2019-07-05 14:29:17 +00:00
return nil
}
func (st *StateTree) MutateActor(addr address.Address, f func(*types.Actor) error) error {
2019-07-05 14:29:17 +00:00
act, err := st.GetActor(addr)
if err != nil {
return err
}
if err := f(act); err != nil {
return err
}
return st.SetActor(addr, act)
}
func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error {
var act types.Actor
return st.root.ForEach(&act, func(k string) error {
addr, err := address.NewFromBytes([]byte(k))
if err != nil {
return xerrors.Errorf("invalid address (%x) found in state tree key: %w", []byte(k), err)
}
return f(addr, &act)
})
}