# snapshot

import "command-line-arguments"

# Index

  • Constants
  • func ChunkRawStateSnapshot(rawStateSnapshot *pb.ECSStateSnapshot, chunkPercentage int) []*pb.ECSStateSnapshot
  • func IsSnaphotAvailableLatest(worldAddress string) bool
  • func IsWorldAddressSnapshotAvailable() bool
  • func PruneSnapshotOwnedByComponent(snapshot *pb.ECSStateSnapshot, pruneForAddress string) *pb.ECSStateSnapshot
  • func RawReadStateSnapshotLatest(worldAddress string) *pb.ECSStateSnapshot
  • func RawReadWorldAddressesSnapshot() *pb.Worlds
  • func Start(state ChainECSState, client *ethclient.Client, startBlock *big.Int, worldAddresses []common.Address, config *SnapshotServerConfig, logger *zap.Logger)
  • type ChainECSState
    • func Sync(client *ethclient.Client, fromBlock *big.Int, toBlock *big.Int, worldAddresses []common.Address, config *SnapshotServerConfig) ChainECSState
  • type ECSState
  • type SnapshotServerConfig
  • type SnapshotType

# Constants

SerializedStateFilename is the name for the snapshot binary of ECS State.

const SerializedStateFilename string = "./snapshots/SerializedECSState"

SerializedWorldsFilename is the name for the snapshot binary of Worlds.

const SerializedWorldsFilename string = "./snapshots/SerializedWorlds"

SnapshotDir is the directory name for where the ECS snapshots are stored.

const SnapshotDir string = "snapshots"

# func ChunkRawStateSnapshot

func ChunkRawStateSnapshot(rawStateSnapshot *pb.ECSStateSnapshot, chunkPercentage int) []*pb.ECSStateSnapshot

ChunkRawStateSnapshot splits a rawStateSnapshot ECSStateSnapshot in protobuf format into a list of ECSStateSnapshot's also in protobuf format. Each ECSStateSnapshot after chunking is chunkPercentage fraction size of the original snapshot.

# func IsSnaphotAvailableLatest

func IsSnaphotAvailableLatest(worldAddress string) bool

# func IsWorldAddressSnapshotAvailable

func IsWorldAddressSnapshotAvailable() bool

IsWorldAddressSnapshotAvailable returns if a snapshot of all indexed World addresses is available.

# func PruneSnapshotOwnedByComponent

func PruneSnapshotOwnedByComponent(snapshot *pb.ECSStateSnapshot, pruneForAddress string) *pb.ECSStateSnapshot

PruneSnapshotOwnedByComponent prunes a given ECSStateSnapshot, given an address. This helps get rid of unnecessary state that a given address does not depend on in order to perform actions.

# func RawReadStateSnapshotLatest

func RawReadStateSnapshotLatest(worldAddress string) *pb.ECSStateSnapshot

RawReadStateSnapshotLatest returns the latest ECS state snapshot in protobuf format.

# func RawReadWorldAddressesSnapshot

func RawReadWorldAddressesSnapshot() *pb.Worlds

RawReadWorldAddressesSnapshot returns a snapshot of all indexed World addresses in protobuf format.

# func Start

func Start(state ChainECSState, client *ethclient.Client, startBlock *big.Int, worldAddresses []common.Address, config *SnapshotServerConfig, logger *zap.Logger)

Start starts the process of processing data from an Ethereum client, reducing the ECS state, and taking intermittent snapshots.

# type ChainECSState

ChainECSState is the full state of a chain, which is a mapping from all worlds to their ECSState.

type ChainECSState = map[string]ECSState

# func Sync

func Sync(client *ethclient.Client, fromBlock *big.Int, toBlock *big.Int, worldAddresses []common.Address, config *SnapshotServerConfig) ChainECSState

Sync performs an initial sync to the state of the chain from block number fromBlock to block number toBlock with an optional worldAddresses filter to filter the state.

If there is a snapshot available to load, uses that snapshot as the initial state and starts the sync up to the specified toBlock, otherwise starts with an empty ECS state and syncs everything while reducing the state.

Returns the entire ECS state once the sync is complete.

# type ECSState

ECSState mimics a simple state machine, hence every transformation must return the updated state and there are no objects. This type represents an ECS state on the world.

type ECSState = map[string]*sync.Map

# type SnapshotServerConfig

type SnapshotServerConfig struct {
    // The block number interval for how often to take regular snapshots.
    SnapshotBlockInterval int64
    // The number of blocks to fetch data for when performing an initial
    // sync. This is limited by the bandwidth limit of Geth for fetching logs, which is a hardcoded
    // constant.
    InitialSyncBlockBatchSize int64
    // The time to wait between calls to fetch batched log data when performing an initial sync.
    InitialSyncBlockBatchSyncTimeout time.Duration
    // The block number interval for how often to take intermediary
    // snapshots when performing an initial sync. This is useful in case the snapshot service
    // disconnects or fails while perfoming a lengthy initial sync.
    InitialSyncSnapshotInterval int64

    // Default to use when chunking snapshot to send snapshot in chunks over the wire.
    DefaultSnapshotChunkPercentage int
}

# type SnapshotType

A SnapshotType distinguishes between snapshot types if those are required.

type SnapshotType int
const (
    Latest        SnapshotType = iota // latest available snapshot
    BlockSpecific                     // snapshot at a specific block
    InitialSync                       // snapshot taken right after the service has performed a sync
)

Generated by gomarkdoc