s/DumpCache/FlushAllBlocks option

Author: rvagg

api/api_full.go

@@ -8,6 +8,7 @@ import (
 
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
@@ -385,7 +386,7 @@ type FullNode interface {
 	// StateCall applies the message to the tipset's parent state. The
 	// message is not applied on-top-of the messages in the passed-in
 	// tipset.
-	StateCall(context.Context, *types.Message, types.TipSetKey) (*InvocResult, error) //perm:read
+	StateCall(ctx context.Context, p StateCallParams) (*InvocResult, error) //perm:read
 	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	//
 	// If a tipset key is provided, and a replacing message is not found on chain,
@@ -1270,7 +1271,12 @@ type InvocResult struct {
 	ExecutionTrace types.ExecutionTrace
 	Error          string
 	Duration       time.Duration
-	CachedBlocks   []Block `json:",omitempty"`
+	Blocks         *InvocBlocks `json:",omitempty"`
+}
+
+type InvocBlocks struct {
+	Root   cid.Cid
+	Blocks []Block
 }
 
 type Block struct {
@@ -1475,3 +1481,62 @@ type EthTxReceipt struct {
 	Logs              []ethtypes.EthLog    `json:"logs"`
 	Type              ethtypes.EthUint64   `json:"type"`
 }
+
+type StateCallParams struct {
+	Message       *types.Message  `json:"message"`
+	TipSetKey     types.TipSetKey `json:"tipsetKey"`
+	IncludeBlocks bool            `json:"includeBlocks,omitempty"`
+}
+
+func (e *StateCallParams) ToArg() jsonrpc.RawParams {
+	b, err := json.Marshal(e)
+	if err != nil {
+		return nil
+	}
+	return jsonrpc.RawParams(b)
+}
+
+func (e *StateCallParams) UnmarshalJSON(b []byte) error {
+	if len(b) == 0 {
+		return xerrors.New("empty input")
+	}
+
+	// If input is an object, decode it directly into a temporary struct
+	if b[0] == '{' {
+		type stateCallParamsAlias StateCallParams
+		var alias stateCallParamsAlias
+		if err := json.Unmarshal(b, &alias); err != nil {
+			return err
+		}
+		*e = StateCallParams(alias)
+		return nil
+	}
+
+	// If input is an array, expect exactly two elements: Message and TipSetKey
+	if b[0] == '[' {
+		var params []json.RawMessage
+		if err := json.Unmarshal(b, &params); err != nil {
+			return err
+		}
+		if len(params) != 2 {
+			return xerrors.Errorf("expected two parameters, got %d", len(params))
+		}
+		if err := json.Unmarshal(params[0], &e.Message); err != nil {
+			return xerrors.Errorf("failed to unmarshal message: %w", err)
+		}
+		if err := json.Unmarshal(params[1], &e.TipSetKey); err != nil {
+			return xerrors.Errorf("failed to unmarshal tipset key: %w", err)
+		}
+		return nil
+	}
+
+	return xerrors.Errorf("unexpected JSON input: expected object or array, got %q", string(b[0]))
+}
+
+func (e *StateCallParams) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]interface{}{
+		"message":       e.Message,
+		"tipsetKey":     e.TipSetKey,
+		"includeBlocks": e.IncludeBlocks,
+	})
+}

chain/consensus/compute_state.go

@@ -245,10 +245,12 @@ func (t *TipSetExecutor) ApplyBlocks(
 				if err := em.MessageApplied(ctx, ts, cm.Cid(), m, r, false); err != nil {
 					log.Debugw("ApplyBlocks ExecMonitor#MessageApplied callback failed", "error", err)
 					if cacheStore != nil {
+						/* TODO:
 						log.Debug("Dumping vm cache blocks to provided cacheStore")
 						if err := vmi.DumpCache(cacheStore); err != nil {
 							return cid.Undef, cid.Undef, xerrors.Errorf("dumping vm cache: %w", err)
 						}
+						*/
 					}
 					return cid.Undef, cid.Undef, err
 				}
@@ -307,10 +309,12 @@ func (t *TipSetExecutor) ApplyBlocks(
 	}
 
 	if cacheStore != nil {
+		/* TODO:
 		log.Debug("Dumping vm cache blocks to provided cacheStore")
 		if err := vmi.DumpCache(cacheStore); err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("dumping vm cache: %w", err)
 		}
+		*/
 	}
 
 	st, err := vmi.Flush(ctx)

chain/stmgr/call.go

@@ -38,15 +38,15 @@ var ErrExpensiveFork = errors.New("refusing explicit call due to state fork at e
 // Call applies the given message to the given tipset's parent state, at the epoch following the
 // tipset's parent. In the presence of null blocks, the height at which the message is invoked may
 // be less than the specified tipset.
-func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
+func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet, flushAllBlocks bool) (*api.InvocResult, error) {
 	buffStore := blockstore.NewTieredBstore(sm.cs.StateBlockstore(), blockstore.NewMemorySync())
-	return sm.CallWithStore(ctx, msg, ts, buffStore)
+	return sm.CallWithStore(ctx, msg, ts, buffStore, flushAllBlocks)
 }
 
 // CallWithStore applies the given message to the given tipset's parent state, at the epoch following the
 // tipset's parent. In the presence of null blocks, the height at which the message is invoked may
 // be less than the specified tipset.
-func (sm *StateManager) CallWithStore(ctx context.Context, msg *types.Message, ts *types.TipSet, bstore blockstore.Blockstore) (*api.InvocResult, error) {
+func (sm *StateManager) CallWithStore(ctx context.Context, msg *types.Message, ts *types.TipSet, bstore blockstore.Blockstore, flushAllBlocks bool) (*api.InvocResult, error) {
 	// Copy the message as we modify it below.
 	msgCopy := *msg
 	msg = &msgCopy
@@ -63,13 +63,13 @@ func (sm *StateManager) CallWithStore(ctx context.Context, msg *types.Message, t
 	if msg.Value == types.EmptyInt {
 		msg.Value = types.NewInt(0)
 	}
-	return sm.callInternal(ctx, msg, nil, ts, cid.Undef, sm.GetNetworkVersion, false, execSameSenderMessages, bstore)
+	return sm.callInternal(ctx, msg, nil, ts, cid.Undef, sm.GetNetworkVersion, false, execSameSenderMessages, bstore, flushAllBlocks)
 }
 
 // ApplyOnStateWithGas applies the given message on top of the given state root with gas tracing enabled
 func (sm *StateManager) ApplyOnStateWithGas(ctx context.Context, stateCid cid.Cid, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
 	buffStore := blockstore.NewTieredBstore(sm.cs.StateBlockstore(), blockstore.NewMemorySync())
-	return sm.callInternal(ctx, msg, nil, ts, stateCid, sm.GetNetworkVersion, true, execNoMessages, buffStore)
+	return sm.callInternal(ctx, msg, nil, ts, stateCid, sm.GetNetworkVersion, true, execNoMessages, buffStore, false)
 }
 
 // CallWithGas calculates the state for a given tipset, and then applies the given message on top of that state.
@@ -81,7 +81,7 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 		strategy = execSameSenderMessages
 	}
 	buffStore := blockstore.NewTieredBstore(sm.cs.StateBlockstore(), blockstore.NewMemorySync())
-	return sm.callInternal(ctx, msg, priorMsgs, ts, cid.Undef, sm.GetNetworkVersion, true, strategy, buffStore)
+	return sm.callInternal(ctx, msg, priorMsgs, ts, cid.Undef, sm.GetNetworkVersion, true, strategy, buffStore, false)
 }
 
 // CallAtStateAndVersion allows you to specify a message to execute on the given stateCid and network version.
@@ -93,7 +93,7 @@ func (sm *StateManager) CallAtStateAndVersion(ctx context.Context, msg *types.Me
 		return v
 	}
 	buffStore := blockstore.NewTieredBstore(sm.cs.StateBlockstore(), blockstore.NewMemorySync())
-	return sm.callInternal(ctx, msg, nil, nil, stateCid, nvGetter, true, execSameSenderMessages, buffStore)
+	return sm.callInternal(ctx, msg, nil, nil, stateCid, nvGetter, true, execSameSenderMessages, buffStore, false)
 }
 
 //   - If no tipset is specified, the first tipset without an expensive migration or one in its parent is used.
@@ -109,6 +109,7 @@ func (sm *StateManager) callInternal(
 	checkGas bool,
 	strategy execMessageStrategy,
 	bstore blockstore.Blockstore,
+	flushAllBlocks bool,
 ) (*api.InvocResult, error) {
 	ctx, span := trace.StartSpan(ctx, "statemanager.callInternal")
 	defer span.End()
@@ -183,6 +184,7 @@ func (sm *StateManager) callInternal(
 		LookbackState:  LookbackStateGetterForTipset(sm, ts),
 		TipSetGetter:   TipSetGetterForTipset(sm.cs, ts),
 		Tracing:        true,
+		FlushAllBlocks: flushAllBlocks,
 	}
 	vmi, err := sm.newVM(ctx, vmopt)
 	if err != nil {

chain/vm/execution.go

@@ -10,7 +10,6 @@ import (
 	"go.opencensus.io/stats"
 	"go.opencensus.io/tag"
 
-	"github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/metrics"
 )
@@ -59,10 +58,6 @@ func (e *vmExecutor) Flush(ctx context.Context) (cid.Cid, error) {
 	return e.vmi.Flush(ctx)
 }
 
-func (e *vmExecutor) DumpCache(bs blockstore.Blockstore) error {
-	return e.vmi.DumpCache(bs)
-}
-
 type executionToken struct {
 	lane     ExecutionLane
 	reserved int

chain/vm/fvm.go

@@ -538,10 +538,6 @@ func (vm *FVM) Flush(ctx context.Context) (cid.Cid, error) {
 	return vm.fvm.Flush()
 }
 
-func (vm *FVM) DumpCache(cacheStore blockstore.Blockstore) error {
-	return vm.fvm.DumpCache(cacheStore)
-}
-
 type dualExecutionFVM struct {
 	main  *FVM
 	debug *FVM
@@ -612,10 +608,6 @@ func (vm *dualExecutionFVM) Flush(ctx context.Context) (cid.Cid, error) {
 	return vm.main.Flush(ctx)
 }
 
-func (vm *dualExecutionFVM) DumpCache(cacheStore blockstore.Blockstore) error {
-	return vm.main.DumpCache(cacheStore)
-}
-
 // Passing this as a pointer of structs has proven to be an enormous PiTA; hence this code.
 type xRedirect struct{ from, to cid.Cid }
 type xMapping struct{ redirects []xRedirect }

chain/vm/vm.go

@@ -249,6 +249,11 @@ type VMOpts struct {
 	LookbackState  LookbackStateGetter
 	TipSetGetter   TipSetGetter
 	Tracing        bool
+	// FlushAllBlocks is used to control whether the VM should flush all blocks
+	// created during execution to the blockstore. This is used for testing
+	// purposes, where we want to inspect all blocks created during execution, not
+	// just those connected to the final state root.
+	FlushAllBlocks bool
 	// ReturnEvents decodes and returns emitted events.
 	ReturnEvents bool
 	// ExecutionLane specifies the execution priority of the created vm

chain/vm/vmi.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/filecoin-project/go-state-types/network"
 
-	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -36,9 +35,6 @@ type Interface interface {
 	ApplyImplicitMessage(ctx context.Context, msg *types.Message) (*ApplyRet, error)
 	// Flush all buffered objects into the state store provided to the VM at construction.
 	Flush(ctx context.Context) (cid.Cid, error)
-	// Dump the contents of the caching blockstore to the provided blockstore. This will include the
-	// final state tree as well as any intermediate objects created during messagae execution.
-	DumpCache(bs bstore.Blockstore) error
 }
 
 // WARNING: You will not affect your node's execution by misusing this feature, but you will confuse yourself thoroughly!