LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

refactor(x/genutil,server): add export functions to x/gentutil (#18303)

Browse Source
This commit is contained in:
Julien Robert
2023-10-30 15:49:49 +00:00
committed by GitHub
parent 393de266c8
commit d82503e24e
14 changed files with 78 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/cmt_cmds.go
+1 -1
View File
@@ -372,7 +372,7 @@ func BootstrapStateCmd(appCreator types.AppCreator) *cobra.Command {
}
if height == 0 {
home := serverCtx.Viper.GetString(flags.FlagHome)
db, err := openDB(home, GetAppDBBackend(serverCtx.Viper))
db, err := OpenDB(home, GetAppDBBackend(serverCtx.Viper))
if err != nil {
return err
}
server/constructors_test.go
+2 -2
View File
@@ -8,9 +8,9 @@ import (
"github.com/stretchr/testify/require"
)
func Test_openDB(t *testing.T) {
func Test_OpenDB(t *testing.T) {
t.Parallel()
_, err := openDB(t.TempDir(), dbm.GoLevelDBBackend)
_, err := OpenDB(t.TempDir(), dbm.GoLevelDBBackend)
require.NoError(t, err)
}
server/export.go
-122
View File
@@ -1,122 +0,0 @@
package server
import (
"bytes"
"encoding/json"
"fmt"
"io"
"os"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/server/types"
"github.com/cosmos/cosmos-sdk/version"
genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
)
const (
FlagHeight = "height"
FlagForZeroHeight = "for-zero-height"
FlagJailAllowedAddrs = "jail-allowed-addrs"
FlagModulesToExport = "modules-to-export"
)
// ExportCmd dumps app state to JSON.
func ExportCmd(appExporter types.AppExporter) *cobra.Command {
cmd := &cobra.Command{
Use: "export",
Short: "Export state to JSON",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, _ []string) error {
serverCtx := GetServerContextFromCmd(cmd)
config := serverCtx.Config
if _, err := os.Stat(config.GenesisFile()); os.IsNotExist(err) {
return err
}
db, err := openDB(config.RootDir, GetAppDBBackend(serverCtx.Viper))
if err != nil {
return err
}
if appExporter == nil {
if _, err := fmt.Fprintln(cmd.ErrOrStderr(), "WARNING: App exporter not defined. Returning genesis file."); err != nil {
return err
}
// Open file in read-only mode so we can copy it to stdout.
// It is possible that the genesis file is large,
// so we don't need to read it all into memory
// before we stream it out.
f, err := os.OpenFile(config.GenesisFile(), os.O_RDONLY, 0)
if err != nil {
return err
}
defer f.Close()
if _, err := io.Copy(cmd.OutOrStdout(), f); err != nil {
return err
}
return nil
}
traceWriterFile, _ := cmd.Flags().GetString(flagTraceStore)
traceWriter, err := openTraceWriter(traceWriterFile)
if err != nil {
return err
}
height, _ := cmd.Flags().GetInt64(FlagHeight)
forZeroHeight, _ := cmd.Flags().GetBool(FlagForZeroHeight)
jailAllowedAddrs, _ := cmd.Flags().GetStringSlice(FlagJailAllowedAddrs)
modulesToExport, _ := cmd.Flags().GetStringSlice(FlagModulesToExport)
outputDocument, _ := cmd.Flags().GetString(flags.FlagOutputDocument)
exported, err := appExporter(serverCtx.Logger, db, traceWriter, height, forZeroHeight, jailAllowedAddrs, serverCtx.Viper, modulesToExport)
if err != nil {
return fmt.Errorf("error exporting state: %w", err)
}
appGenesis, err := genutiltypes.AppGenesisFromFile(serverCtx.Config.GenesisFile())
if err != nil {
return err
}
// set current binary version
appGenesis.AppName = version.AppName
appGenesis.AppVersion = version.Version
appGenesis.AppState = exported.AppState
appGenesis.InitialHeight = exported.Height
appGenesis.Consensus = genutiltypes.NewConsensusGenesis(exported.ConsensusParams, exported.Validators)
out, err := json.Marshal(appGenesis)
if err != nil {
return err
}
if outputDocument == "" {
// Copy the entire genesis file to stdout.
_, err := io.Copy(cmd.OutOrStdout(), bytes.NewReader(out))
return err
}
if err = appGenesis.SaveAs(outputDocument); err != nil {
return err
}
return nil
},
}
cmd.Flags().Int64(FlagHeight, -1, "Export state from a particular height (-1 means latest height)")
cmd.Flags().Bool(FlagForZeroHeight, false, "Export state to start at height zero (perform preproccessing)")
cmd.Flags().StringSlice(FlagJailAllowedAddrs, []string{}, "Comma-separated list of operator addresses of jailed validators to unjail")
cmd.Flags().StringSlice(FlagModulesToExport, []string{}, "Comma-separated list of modules to export. If empty, will export all modules")
cmd.Flags().String(flags.FlagOutputDocument, "", "Exported state is written to the given file instead of STDOUT")
return cmd
}
server/export_test.go
-353
View File
@@ -1,353 +0,0 @@
package server_test
import (
"context"
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
"testing"
"time"
cmtcfg "github.com/cometbft/cometbft/config"
cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
cmttypes "github.com/cometbft/cometbft/types"
dbm "github.com/cosmos/cosmos-db"
"github.com/rs/zerolog"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
"cosmossdk.io/log"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/server"
"github.com/cosmos/cosmos-sdk/server/types"
"github.com/cosmos/cosmos-sdk/testutil/cmdtest"
"github.com/cosmos/cosmos-sdk/types/module"
genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli"
genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
)
// ExportSystem wraps a (*cmdtest).System
// and sets up appropriate client and server contexts,
// to simplify testing the export CLI.
type ExportSystem struct {
sys *cmdtest.System
Ctx context.Context
Sctx *server.Context
Cctx client.Context
HomeDir string
}
// newExportSystem returns a cmdtest.System with export as a child command,
// and it returns a context.Background with an associated *server.Context value.
func NewExportSystem(t *testing.T, exporter types.AppExporter) *ExportSystem {
t.Helper()
homeDir := t.TempDir()
// Unclear why we have to create the config directory ourselves,
// but tests fail without this.
if err := os.MkdirAll(filepath.Join(homeDir, "config"), 0o700); err != nil {
t.Fatal(err)
}
sys := cmdtest.NewSystem()
sys.AddCommands(
server.ExportCmd(exporter),
genutilcli.InitCmd(module.NewBasicManager()),
)
tw := zerolog.NewTestWriter(t)
tw.Frame = 5 // Seems to be the magic number to get source location to match logger calls.
sCtx := server.NewContext(
viper.New(),
cmtcfg.DefaultConfig(),
log.NewCustomLogger(zerolog.New(tw)),
)
sCtx.Config.SetRoot(homeDir)
cCtx := (client.Context{}).WithHomeDir(homeDir)
ctx := context.WithValue(context.Background(), server.ServerContextKey, sCtx)
ctx = context.WithValue(ctx, client.ClientContextKey, &cCtx)
return &ExportSystem{
sys: sys,
Ctx: ctx,
Sctx: sCtx,
Cctx: cCtx,
HomeDir: homeDir,
}
}
// Run wraps (*cmdtest.System).RunC, providing e's context.
func (s *ExportSystem) Run(args ...string) cmdtest.RunResult {
return s.sys.RunC(s.Ctx, args...)
}
// MustRun wraps (*cmdtest.System).MustRunC, providing e's context.
func (s *ExportSystem) MustRun(t *testing.T, args ...string) cmdtest.RunResult {
t.Helper()
return s.sys.MustRunC(t, s.Ctx, args...)
}
// isZeroExportedApp reports whether all fields of a are unset.
//
// This is for the mockExporter to check if a return value was ever set.
func isZeroExportedApp(a types.ExportedApp) bool {
return a.AppState == nil &&
len(a.Validators) == 0 &&
a.Height == 0 &&
a.ConsensusParams == cmtproto.ConsensusParams{}
}
// mockExporter provides an Export method matching server/types.AppExporter,
// and it tracks relevant arguments when that method is called.
type mockExporter struct {
// The values to return from Export().
ExportApp types.ExportedApp
Err error
// Whether Export was called at all.
WasCalled bool
// Called tracks the interesting arguments passed to Export().
Called struct {
Height int64
ForZeroHeight bool
JailAllowedAddrs []string
ModulesToExport []string
}
}
// SetDefaultExportApp sets a valid ExportedApp to be returned
// when e.Export is called.
func (e *mockExporter) SetDefaultExportApp() {
e.ExportApp = types.ExportedApp{
ConsensusParams: cmtproto.ConsensusParams{
Block: &cmtproto.BlockParams{
MaxBytes: 5 * 1024 * 1024,
MaxGas: -1,
},
Evidence: &cmtproto.EvidenceParams{
MaxAgeNumBlocks: 100,
MaxAgeDuration: time.Hour,
MaxBytes: 1024 * 1024,
},
Validator: &cmtproto.ValidatorParams{
PubKeyTypes: []string{cmttypes.ABCIPubKeyTypeEd25519},
},
},
}
}
// Export satisfies the server/types.AppExporter function type.
//
// e tracks relevant arguments under the e.Called struct.
//
// Export panics if neither e.ExportApp nor e.Err have been set.
func (e *mockExporter) Export(
logger log.Logger,
db dbm.DB,
traceWriter io.Writer,
height int64,
forZeroHeight bool,
jailAllowedAddrs []string,
opts types.AppOptions,
modulesToExport []string,
) (types.ExportedApp, error) {
if e.Err == nil && isZeroExportedApp(e.ExportApp) {
panic(fmt.Errorf("(*mockExporter).Export called without setting e.ExportApp or e.Err"))
}
e.WasCalled = true
e.Called.Height = height
e.Called.ForZeroHeight = forZeroHeight
e.Called.JailAllowedAddrs = jailAllowedAddrs
e.Called.ModulesToExport = modulesToExport
return e.ExportApp, e.Err
}
func TestExportCLI(t *testing.T) {
// Use t.Parallel in all of the subtests,
// because they all read from disk and risk blocking on io.
t.Run("fail on missing genesis file", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
sys := NewExportSystem(t, e.Export)
res := sys.Run("export")
require.Error(t, res.Err)
require.Truef(t, os.IsNotExist(res.Err), "expected resulting error to be os.IsNotExist, got %T (%v)", res.Err, res.Err)
require.False(t, e.WasCalled)
})
t.Run("prints to stdout by default", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
e.SetDefaultExportApp()
sys := NewExportSystem(t, e.Export)
_ = sys.MustRun(t, "init", "some_moniker")
res := sys.MustRun(t, "export")
require.Empty(t, res.Stderr.String())
CheckExportedGenesis(t, res.Stdout.Bytes())
})
t.Run("passes expected default values to the AppExporter", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
e.SetDefaultExportApp()
sys := NewExportSystem(t, e.Export)
_ = sys.MustRun(t, "init", "some_moniker")
_ = sys.MustRun(t, "export")
require.True(t, e.WasCalled)
require.Equal(t, int64(-1), e.Called.Height)
require.False(t, e.Called.ForZeroHeight)
require.Empty(t, e.Called.JailAllowedAddrs)
require.Empty(t, e.Called.ModulesToExport)
})
t.Run("passes flag values to the AppExporter", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
e.SetDefaultExportApp()
sys := NewExportSystem(t, e.Export)
_ = sys.MustRun(t, "init", "some_moniker")
_ = sys.MustRun(t, "export",
"--height=100",
"--jail-allowed-addrs", "addr1,addr2",
"--modules-to-export", "foo,bar",
)
require.True(t, e.WasCalled)
require.Equal(t, int64(100), e.Called.Height)
require.False(t, e.Called.ForZeroHeight)
require.Equal(t, []string{"addr1", "addr2"}, e.Called.JailAllowedAddrs)
require.Equal(t, []string{"foo", "bar"}, e.Called.ModulesToExport)
})
t.Run("passes --for-zero-height to the AppExporter", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
e.SetDefaultExportApp()
sys := NewExportSystem(t, e.Export)
_ = sys.MustRun(t, "init", "some_moniker")
_ = sys.MustRun(t, "export", "--for-zero-height")
require.True(t, e.WasCalled)
require.Equal(t, int64(-1), e.Called.Height)
require.True(t, e.Called.ForZeroHeight)
require.Empty(t, e.Called.JailAllowedAddrs)
require.Empty(t, e.Called.ModulesToExport)
})
t.Run("prints to a given file with --output-document", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
e.SetDefaultExportApp()
sys := NewExportSystem(t, e.Export)
_ = sys.MustRun(t, "init", "some_moniker")
outDir := t.TempDir()
outFile := filepath.Join(outDir, "export.json")
res := sys.MustRun(t, "export", "--output-document", outFile)
require.Empty(t, res.Stderr.String())
require.Empty(t, res.Stdout.String())
j, err := os.ReadFile(outFile)
require.NoError(t, err)
CheckExportedGenesis(t, j)
})
t.Run("prints genesis to stdout when no app exporter defined", func(t *testing.T) {
t.Parallel()
sys := NewExportSystem(t, nil)
_ = sys.MustRun(t, "init", "some_moniker")
res := sys.MustRun(t, "export")
require.Contains(t, res.Stderr.String(), "WARNING: App exporter not defined.")
origGenesis, err := os.ReadFile(filepath.Join(sys.HomeDir, "config", "genesis.json"))
require.NoError(t, err)
out := res.Stdout.Bytes()
require.Equal(t, origGenesis, out)
})
t.Run("returns app exporter error", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
e.Err = fmt.Errorf("whoopsie")
sys := NewExportSystem(t, e.Export)
_ = sys.MustRun(t, "init", "some_moniker")
res := sys.Run("export")
require.ErrorIs(t, res.Err, e.Err)
})
t.Run("rejects positional arguments", func(t *testing.T) {
t.Parallel()
e := new(mockExporter)
e.SetDefaultExportApp()
sys := NewExportSystem(t, e.Export)
_ = sys.MustRun(t, "init", "some_moniker")
outDir := t.TempDir()
outFile := filepath.Join(outDir, "export.json")
res := sys.Run("export", outFile)
require.Error(t, res.Err)
require.NoFileExists(t, outFile)
})
}
// CheckExportedGenesis fails t if j cannot be unmarshaled into a valid AppGenesis.
func CheckExportedGenesis(t *testing.T, j []byte) {
t.Helper()
var ag genutiltypes.AppGenesis
require.NoError(t, json.Unmarshal(j, &ag))
require.NotEmpty(t, ag.AppName)
require.NotZero(t, ag.GenesisTime)
require.NotEmpty(t, ag.ChainID)
require.NotNil(t, ag.Consensus)
}
server/rollback.go
+1 -1
View File
@@ -27,7 +27,7 @@ application.
RunE: func(cmd *cobra.Command, args []string) error {
ctx := GetServerContextFromCmd(cmd)
db, err := openDB(ctx.Config.RootDir, GetAppDBBackend(ctx.Viper))
db, err := OpenDB(ctx.Config.RootDir, GetAppDBBackend(ctx.Viper))
if err != nil {
return err
}
server/start.go
+7 -6
View File
@@ -27,6 +27,7 @@ import (
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"cosmossdk.io/log"
pruningtypes "cosmossdk.io/store/pruning/types"
"github.com/cosmos/cosmos-sdk/client"
@@ -113,7 +114,7 @@ func StartCmd(appCreator types.AppCreator) *cobra.Command {
// CometBFT.
func StartCmdWithOptions(appCreator types.AppCreator, opts StartCmdOptions) *cobra.Command {
if opts.DBOpener == nil {
opts.DBOpener = openDB
opts.DBOpener = OpenDB
}
cmd := &cobra.Command{
@@ -437,7 +438,7 @@ func getAndValidateConfig(svrCtx *Context) (serverconfig.Config, error) {
return config, nil
}
// returns a function which returns the genesis doc from the genesis file.
// getGenDocProvider returns a function which returns the genesis doc from the genesis file.
func getGenDocProvider(cfg *cmtcfg.Config) func() (*cmttypes.GenesisDoc, error) {
return func() (*cmttypes.GenesisDoc, error) {
appGenesis, err := genutiltypes.AppGenesisFromFile(cfg.GenesisFile())
@@ -449,11 +450,11 @@ func getGenDocProvider(cfg *cmtcfg.Config) func() (*cmttypes.GenesisDoc, error)
}
}
func setupTraceWriter(svrCtx *Context) (traceWriter io.WriteCloser, cleanup func(), err error) {
// SetupTraceWriter sets up the trace writer and returns a cleanup function.
func SetupTraceWriter(logger log.Logger, traceWriterFile string) (traceWriter io.WriteCloser, cleanup func(), err error) {
// clean up the traceWriter when the server is shutting down
cleanup = func() {}
traceWriterFile := svrCtx.Viper.GetString(flagTraceStore)
traceWriter, err = openTraceWriter(traceWriterFile)
if err != nil {
return traceWriter, cleanup, err
@@ -463,7 +464,7 @@ func setupTraceWriter(svrCtx *Context) (traceWriter io.WriteCloser, cleanup func
if traceWriter != nil {
cleanup = func() {
if err = traceWriter.Close(); err != nil {
svrCtx.Logger.Error("failed to close trace writer", "err", err)
logger.Error("failed to close trace writer", "err", err)
}
}
}
@@ -626,7 +627,7 @@ func getCtx(svrCtx *Context, block bool) (*errgroup.Group, context.Context) {
}
func startApp(svrCtx *Context, appCreator types.AppCreator, opts StartCmdOptions) (app types.Application, cleanupFn func(), err error) {
traceWriter, traceCleanupFn, err := setupTraceWriter(svrCtx)
traceWriter, traceCleanupFn, err := SetupTraceWriter(svrCtx.Logger, svrCtx.Viper.GetString(flagTraceStore))
if err != nil {
return app, traceCleanupFn, err
}
server/util.go
+3 -3
View File
@@ -321,7 +321,7 @@ func interceptConfigs(rootViper *viper.Viper, customAppTemplate string, customCo
}
// add server commands
func AddCommands(rootCmd *cobra.Command, appCreator types.AppCreator, appExport types.AppExporter, addStartFlags types.ModuleInitFlags) {
func AddCommands(rootCmd *cobra.Command, appCreator types.AppCreator, addStartFlags types.ModuleInitFlags) {
cometCmd := &cobra.Command{
Use: "comet",
Aliases: []string{"cometbft", "tendermint"},
@@ -344,7 +344,6 @@ func AddCommands(rootCmd *cobra.Command, appCreator types.AppCreator, appExport
rootCmd.AddCommand(
startCmd,
cometCmd,
ExportCmd(appExport),
version.NewVersionCommand(),
NewRollbackCmd(appCreator),
)
@@ -452,7 +451,8 @@ func addrToIP(addr net.Addr) net.IP {
return ip
}
func openDB(rootDir string, backendType dbm.BackendType) (dbm.DB, error) {
// OpenDB opens the application database using the appropriate driver.
func OpenDB(rootDir string, backendType dbm.BackendType) (dbm.DB, error) {
dataDir := filepath.Join(rootDir, "data")
return dbm.NewDB("application", backendType, dataDir)
}