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

chore: remove snapshot commands (#23015)

Browse Source
This commit is contained in:
Julien Robert
2024-12-19 19:34:44 +00:00
committed by GitHub
parent 65ceca640b
commit 4f5c3d8ca0
7 changed files with 0 additions and 459 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client/snapshot/cmd.go
-24
View File
@@ -1,24 +0,0 @@
package snapshot
import (
"github.com/spf13/cobra"
servertypes "github.com/cosmos/cosmos-sdk/server/types"
)
// Cmd returns the snapshots group command
func Cmd[T servertypes.Application](appCreator servertypes.AppCreator[T]) *cobra.Command {
cmd := &cobra.Command{
Use: "snapshots",
Short: "Manage local snapshots",
}
cmd.AddCommand(
ListSnapshotsCmd,
RestoreSnapshotCmd(appCreator),
ExportSnapshotCmd(appCreator),
DumpArchiveCmd(),
LoadArchiveCmd(),
DeleteSnapshotCmd(),
)
return cmd
}
client/snapshot/delete.go
-37
View File
@@ -1,37 +0,0 @@
package snapshot
import (
"strconv"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/server"
)
func DeleteSnapshotCmd() *cobra.Command {
return &cobra.Command{
Use: "delete <height> <format>",
Short: "Delete a local snapshot",
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
viper := client.GetViperFromCmd(cmd)
height, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
format, err := strconv.ParseUint(args[1], 10, 32)
if err != nil {
return err
}
snapshotStore, err := server.GetSnapshotStore(viper)
if err != nil {
return err
}
return snapshotStore.Delete(height, uint32(format))
},
}
}
client/snapshot/dump.go
-136
View File
@@ -1,136 +0,0 @@
package snapshot
import (
"archive/tar"
"compress/gzip"
"errors"
"fmt"
"io"
"os"
"strconv"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/server"
)
// DumpArchiveCmd returns a command to dump the snapshot as portable archive format
func DumpArchiveCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "dump <height> <format>",
Short: "Dump the snapshot as portable archive format",
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
viper := client.GetViperFromCmd(cmd)
snapshotStore, err := server.GetSnapshotStore(viper)
if err != nil {
return err
}
output, err := cmd.Flags().GetString("output")
if err != nil {
return err
}
height, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
format, err := strconv.ParseUint(args[1], 10, 32)
if err != nil {
return err
}
if output == "" {
output = fmt.Sprintf("%d-%d.tar.gz", height, format)
}
snapshot, err := snapshotStore.Get(height, uint32(format))
if err != nil {
return err
}
if snapshot == nil {
return errors.New("snapshot doesn't exist")
}
bz, err := snapshot.Marshal()
if err != nil {
return err
}
fp, err := os.Create(output)
if err != nil {
return err
}
defer fp.Close()
// since the chunk files are already compressed, we just use fastest compression here
gzipWriter, err := gzip.NewWriterLevel(fp, gzip.BestSpeed)
if err != nil {
return err
}
tarWriter := tar.NewWriter(gzipWriter)
if err := tarWriter.WriteHeader(&tar.Header{
Name: SnapshotFileName,
Mode: 0o644,
Size: int64(len(bz)),
}); err != nil {
return fmt.Errorf("failed to write snapshot header to tar: %w", err)
}
if _, err := tarWriter.Write(bz); err != nil {
return fmt.Errorf("failed to write snapshot to tar: %w", err)
}
for i := uint32(0); i < snapshot.Chunks; i++ {
path := snapshotStore.PathChunk(height, uint32(format), i)
tarName := strconv.FormatUint(uint64(i), 10)
if err := processChunk(tarWriter, path, tarName); err != nil {
return err
}
}
if err := tarWriter.Close(); err != nil {
return fmt.Errorf("failed to close tar writer: %w", err)
}
if err := gzipWriter.Close(); err != nil {
return fmt.Errorf("failed to close gzip writer: %w", err)
}
return fp.Close()
},
}
cmd.Flags().StringP("output", "o", "", "output file")
return cmd
}
func processChunk(tarWriter *tar.Writer, path, tarName string) error {
file, err := os.Open(path)
if err != nil {
return fmt.Errorf("failed to open chunk file %s: %w", path, err)
}
defer file.Close()
st, err := file.Stat()
if err != nil {
return fmt.Errorf("failed to stat chunk file %s: %w", path, err)
}
if err := tarWriter.WriteHeader(&tar.Header{
Name: tarName,
Mode: 0o644,
Size: st.Size(),
}); err != nil {
return fmt.Errorf("failed to write chunk header to tar: %w", err)
}
if _, err := io.Copy(tarWriter, file); err != nil {
return fmt.Errorf("failed to write chunk to tar: %w", err)
}
return nil
}
client/snapshot/export.go
-54
View File
@@ -1,54 +0,0 @@
package snapshot
import (
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/server"
servertypes "github.com/cosmos/cosmos-sdk/server/types"
)
// ExportSnapshotCmd returns a command to take a snapshot of the application state
func ExportSnapshotCmd[T servertypes.Application](appCreator servertypes.AppCreator[T]) *cobra.Command {
cmd := &cobra.Command{
Use: "export",
Short: "Export app state to snapshot store",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
viper := client.GetViperFromCmd(cmd)
logger := client.GetLoggerFromCmd(cmd)
height, err := cmd.Flags().GetInt64("height")
if err != nil {
return err
}
home := viper.GetString(flags.FlagHome)
db, err := openDB(home, server.GetAppDBBackend(viper))
if err != nil {
return err
}
app := appCreator(logger, db, nil, viper)
if height == 0 {
height = app.CommitMultiStore().LastCommitID().Version
}
cmd.Printf("Exporting snapshot for height %d\n", height)
sm := app.SnapshotManager()
snapshot, err := sm.Create(uint64(height))
if err != nil {
return err
}
cmd.Printf("Snapshot created at height %d, format %d, chunks %d\n", snapshot.Height, snapshot.Format, snapshot.Chunks)
return nil
},
}
cmd.Flags().Int64("height", 0, "Height to export, default to latest state height")
return cmd
}
client/snapshot/list.go
-37
View File
@@ -1,37 +0,0 @@
package snapshot
import (
"fmt"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/server"
)
// ListSnapshotsCmd returns the command to list local snapshots
var ListSnapshotsCmd = &cobra.Command{
Use: "list",
Short: "List local snapshots",
RunE: func(cmd *cobra.Command, args []string) error {
viper := client.GetViperFromCmd(cmd)
snapshotStore, err := server.GetSnapshotStore(viper)
if err != nil {
return err
}
snapshots, err := snapshotStore.List()
if err != nil {
return fmt.Errorf("failed to list snapshots: %w", err)
}
if len(snapshots) == 0 {
cmd.Println("no snapshots found")
}
for _, snapshot := range snapshots {
cmd.Println("height:", snapshot.Height, "format:", snapshot.Format, "chunks:", snapshot.Chunks)
}
return nil
},
}
client/snapshot/load.go
-116
View File
@@ -1,116 +0,0 @@
package snapshot
import (
"archive/tar"
"bytes"
"compress/gzip"
"errors"
"fmt"
"io"
"os"
"reflect"
"strconv"
"github.com/spf13/cobra"
snapshottypes "cosmossdk.io/store/snapshots/types"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/server"
)
const SnapshotFileName = "_snapshot"
// LoadArchiveCmd load a portable archive format snapshot into snapshot store
func LoadArchiveCmd() *cobra.Command {
return &cobra.Command{
Use: "load <archive-file>",
Short: "Load a snapshot archive file (.tar.gz) into snapshot store",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
viper := client.GetViperFromCmd(cmd)
snapshotStore, err := server.GetSnapshotStore(viper)
if err != nil {
return err
}
path := args[0]
fp, err := os.Open(path)
if err != nil {
return fmt.Errorf("failed to open archive file: %w", err)
}
reader, err := gzip.NewReader(fp)
if err != nil {
return fmt.Errorf("failed to create gzip reader: %w", err)
}
var snapshot snapshottypes.Snapshot
tr := tar.NewReader(reader)
if err != nil {
return fmt.Errorf("failed to create tar reader: %w", err)
}
hdr, err := tr.Next()
if err != nil {
return fmt.Errorf("failed to read snapshot file header: %w", err)
}
if hdr.Name != SnapshotFileName {
return fmt.Errorf("invalid archive, expect file: snapshot, got: %s", hdr.Name)
}
bz, err := io.ReadAll(tr)
if err != nil {
return fmt.Errorf("failed to read snapshot file: %w", err)
}
if err := snapshot.Unmarshal(bz); err != nil {
return fmt.Errorf("failed to unmarshal snapshot: %w", err)
}
// make sure the channel is unbuffered, because the tar reader can't do concurrency
chunks := make(chan io.ReadCloser)
quitChan := make(chan *snapshottypes.Snapshot)
go func() {
defer close(quitChan)
savedSnapshot, err := snapshotStore.Save(snapshot.Height, snapshot.Format, chunks)
if err != nil {
cmd.Println("failed to save snapshot", err)
return
}
quitChan <- savedSnapshot
}()
for i := uint32(0); i < snapshot.Chunks; i++ {
hdr, err = tr.Next()
if err != nil {
if errors.Is(err, io.EOF) {
break
}
return err
}
if hdr.Name != strconv.FormatInt(int64(i), 10) {
return fmt.Errorf("invalid archive, expect file: %d, got: %s", i, hdr.Name)
}
bz, err := io.ReadAll(tr)
if err != nil {
return fmt.Errorf("failed to read chunk file: %w", err)
}
chunks <- io.NopCloser(bytes.NewReader(bz))
}
close(chunks)
savedSnapshot := <-quitChan
if savedSnapshot == nil {
return errors.New("failed to save snapshot")
}
if !reflect.DeepEqual(&snapshot, savedSnapshot) {
_ = snapshotStore.Delete(snapshot.Height, snapshot.Format)
return errors.New("invalid archive, the saved snapshot is not equal to the original one")
}
return nil
},
}
}
client/snapshot/restore.go
-55
View File
@@ -1,55 +0,0 @@
package snapshot
import (
"path/filepath"
"strconv"
dbm "github.com/cosmos/cosmos-db"
"github.com/spf13/cobra"
corestore "cosmossdk.io/core/store"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/server"
servertypes "github.com/cosmos/cosmos-sdk/server/types"
)
// RestoreSnapshotCmd returns a command to restore a snapshot
func RestoreSnapshotCmd[T servertypes.Application](appCreator servertypes.AppCreator[T]) *cobra.Command {
cmd := &cobra.Command{
Use: "restore <height> <format>",
Short: "Restore app state from local snapshot",
Long: "Restore app state from local snapshot",
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
viper := client.GetViperFromCmd(cmd)
logger := client.GetLoggerFromCmd(cmd)
height, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
format, err := strconv.ParseUint(args[1], 10, 32)
if err != nil {
return err
}
home := viper.GetString(flags.FlagHome)
db, err := openDB(home, server.GetAppDBBackend(viper))
if err != nil {
return err
}
app := appCreator(logger, db, nil, viper)
sm := app.SnapshotManager()
return sm.RestoreLocalSnapshot(height, uint32(format))
},
}
return cmd
}
func openDB(rootDir string, backendType dbm.BackendType) (corestore.KVStoreWithBatch, error) {
dataDir := filepath.Join(rootDir, "data")
return dbm.NewDB("application", backendType, dataDir)
}