import "github.com/cosmos/cosmos-sdk/snapshots"
func DrainChunks(chunks <-chan io.ReadCloser)
DrainChunks drains and closes all remaining chunks from a chunk channel.
type ChunkReader struct {
// contains filtered or unexported fields
}ChunkReader reads chunks from a channel of io.ReadClosers and outputs them as an io.Reader
func NewChunkReader(ch <-chan io.ReadCloser) *ChunkReader
NewChunkReader creates a new ChunkReader.
func (r *ChunkReader) Close() error
Close implements io.ReadCloser.
func (r *ChunkReader) Read(p []byte) (int, error)
Read implements io.Reader.
type ChunkWriter struct {
// contains filtered or unexported fields
}ChunkWriter reads an input stream, splits it into fixed-size chunks, and writes them to a sequence of io.ReadClosers via a channel.
func NewChunkWriter(ch chan<- io.ReadCloser, chunkSize uint64) *ChunkWriter
NewChunkWriter creates a new ChunkWriter. If chunkSize is 0, no chunking will be done.
func (w *ChunkWriter) Close() error
Close implements io.Closer.
func (w *ChunkWriter) CloseWithError(err error)
CloseWithError closes the writer and sends an error to the reader.
func (w *ChunkWriter) Write(data []byte) (int, error)
Write implements io.Writer.
type Manager struct {
// contains filtered or unexported fields
}Manager manages snapshot and restore operations for an app, making sure only a single long-running operation is in progress at any given time, and provides convenience methods mirroring the ABCI interface.
Although the ABCI interface (and this manager) passes chunks as byte slices, the internal snapshot/restore APIs use IO streams (i.e. chan io.ReadCloser), for two reasons:
1) In the future, ABCI should support streaming. Consider e.g. InitChain during chain
upgrades, which currently passes the entire chain state as an in-memory byte slice. https://github.com/tendermint/tendermint/issues/5184
2) io.ReadCloser streams automatically propagate IO errors, and can pass arbitrary
errors via io.Pipe.CloseWithError().
func NewManager(store *Store, target types.Snapshotter) *Manager
NewManager creates a new manager.
Create creates a snapshot and returns its metadata.
List lists snapshots, mirroring ABCI ListSnapshots. It can be concurrent with other operations.
LoadChunk loads a chunk into a byte slice, mirroring ABCI LoadChunk. It can be called concurrently with other operations. If the chunk does not exist, nil is returned.
Prune prunes snapshots, if no other operations are in progress.
Restore begins an async snapshot restoration, mirroring ABCI OfferSnapshot. Chunks must be fed via RestoreChunk() until the restore is complete or a chunk fails.
RestoreChunk adds a chunk to an active snapshot restoration, mirroring ABCI ApplySnapshotChunk. Chunks must be given until the restore is complete, returning true, or a chunk errors.
type Store struct {
// contains filtered or unexported fields
}Store is a snapshot store, containing snapshot metadata and binary chunks.
NewStore creates a new snapshot store.
Delete deletes a snapshot.
Get fetches snapshot info from the database.
Get fetches the latest snapshot from the database, if any.
List lists snapshots, in reverse order (newest first).
Load loads a snapshot (both metadata and binary chunks). The chunks must be consumed and closed. Returns nil if the snapshot does not exist.
LoadChunk loads a chunk from disk, or returns nil if it does not exist. The caller must call Close() on it when done.
Prune removes old snapshots. The given number of most recent heights (regardless of format) are retained.
func (s *Store) Save( height uint64, format uint32, chunks <-chan io.ReadCloser, ) (*types.Snapshot, error)
Save saves a snapshot to disk, returning it.
| Path | Synopsis |
|---|---|
| types |
Package snapshots imports 14 packages (graph) and is imported by 3 packages. Updated 2020-09-20. Refresh now. Tools for package owners.