e2e

package
v0.0.0-...-d6b1dc1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 15, 2023 License: Apache-2.0 Imports: 17 Imported by: 0

Documentation

Index

Constants

View Source
const (
	ModeValidator Mode = "validator"
	ModeFull      Mode = "full"
	ModeLight     Mode = "light"
	ModeSeed      Mode = "seed"

	ProtocolBuiltin Protocol = "builtin"
	ProtocolFile    Protocol = "file"
	ProtocolGRPC    Protocol = "grpc"
	ProtocolTCP     Protocol = "tcp"
	ProtocolUNIX    Protocol = "unix"

	PerturbationDisconnect Perturbation = "disconnect"
	PerturbationKill       Perturbation = "kill"
	PerturbationPause      Perturbation = "pause"
	PerturbationRestart    Perturbation = "restart"
	PerturbationUpgrade    Perturbation = "upgrade"

	EvidenceAgeHeight int64         = 7
	EvidenceAgeTime   time.Duration = 500 * time.Millisecond
)

Variables

This section is empty.

Functions

This section is empty.

Types

type InfrastructureData

type InfrastructureData struct {

	// Provider is the name of infrastructure provider backing the testnet.
	// For example, 'docker' if it is running locally in a docker network or
	// 'digital-ocean', 'aws', 'google', etc. if it is from a cloud provider.
	Provider string `json:"provider"`

	// Instances is a map of all of the machine instances on which to run
	// processes for a testnet.
	// The key of the map is the name of the instance, which each must correspond
	// to the names of one of the testnet nodes defined in the testnet manifest.
	Instances map[string]InstanceData `json:"instances"`

	// Network is the CIDR notation range of IP addresses that all of the instances'
	// IP addresses are expected to be within.
	Network string `json:"network"`
}

InfrastructureData contains the relevant information for a set of existing infrastructure that is to be used for running a testnet.

func InfrastructureDataFromFile

func InfrastructureDataFromFile(p string) (InfrastructureData, error)

func NewDockerInfrastructureData

func NewDockerInfrastructureData(m Manifest) (InfrastructureData, error)

type InstanceData

type InstanceData struct {
	IPAddress net.IP `json:"ip_address"`
}

InstanceData contains the relevant information for a machine instance backing one of the nodes in the testnet.

type Manifest

type Manifest struct {
	// IPv6 uses IPv6 networking instead of IPv4. Defaults to IPv4.
	IPv6 bool `toml:"ipv6"`

	// InitialHeight specifies the initial block height, set in genesis. Defaults to 1.
	InitialHeight int64 `toml:"initial_height"`

	// InitialState is an initial set of key/value pairs for the application,
	// set in genesis. Defaults to nothing.
	InitialState map[string]string `toml:"initial_state"`

	// Validators is the initial validator set in genesis, given as node names
	// and power:
	//
	// validators = { validator01 = 10; validator02 = 20; validator03 = 30 }
	//
	// Defaults to all nodes that have mode=validator at power 100. Explicitly
	// specifying an empty set will start with no validators in genesis, and
	// the application must return the validator set in InitChain via the
	// setting validator_update.0 (see below).
	Validators *map[string]int64 `toml:"validators"`

	// ValidatorUpdates is a map of heights to validator names and their power,
	// and will be returned by the ABCI application. For example, the following
	// changes the power of validator01 and validator02 at height 1000:
	//
	// [validator_update.1000]
	// validator01 = 20
	// validator02 = 10
	//
	// Specifying height 0 returns the validator update during InitChain. The
	// application returns the validator updates as-is, i.e. removing a
	// validator must be done by returning it with power 0, and any validators
	// not specified are not changed.
	ValidatorUpdates map[string]map[string]int64 `toml:"validator_update"`

	// Nodes specifies the network nodes. At least one node must be given.
	Nodes map[string]*ManifestNode `toml:"node"`

	// KeyType sets the curve that will be used by validators.
	// Options are ed25519 & secp256k1
	KeyType string `toml:"key_type"`

	// Evidence indicates the amount of evidence that will be injected into the
	// testnet via the RPC endpoint of a random node. Default is 0
	Evidence int `toml:"evidence"`

	// ABCIProtocol specifies the protocol used to communicate with the ABCI
	// application: "unix", "tcp", "grpc", or "builtin". Defaults to builtin.
	// builtin will build a complete CometBFT node into the application and
	// launch it instead of launching a separate CometBFT process.
	ABCIProtocol string `toml:"abci_protocol"`

	// Add artificial delays to each of the main ABCI calls to mimic computation time
	// of the application
	PrepareProposalDelay time.Duration `toml:"prepare_proposal_delay"`
	ProcessProposalDelay time.Duration `toml:"process_proposal_delay"`
	CheckTxDelay         time.Duration `toml:"check_tx_delay"`

	// UpgradeVersion specifies to which version nodes need to upgrade.
	// Currently only uncoordinated upgrade is supported
	UpgradeVersion string `toml:"upgrade_version"`

	LoadTxSizeBytes   int `toml:"load_tx_size_bytes"`
	LoadTxBatchSize   int `toml:"load_tx_batch_size"`
	LoadTxConnections int `toml:"load_tx_connections"`

	// Enable or disable Prometheus metrics on all nodes.
	// Defaults to false (disabled).
	Prometheus bool `toml:"prometheus"`
}

Manifest represents a TOML testnet manifest.

func LoadManifest

func LoadManifest(file string) (Manifest, error)

LoadManifest loads a testnet manifest from a file.

func (Manifest) Save

func (m Manifest) Save(file string) error

Save saves the testnet manifest to a file.

type ManifestNode

type ManifestNode struct {
	// Mode specifies the type of node: "validator", "full", "light" or "seed".
	// Defaults to "validator". Full nodes do not get a signing key (a dummy key
	// is generated), and seed nodes run in seed mode with the PEX reactor enabled.
	Mode string `toml:"mode"`

	// Version specifies which version of CometBFT this node is. Specifying different
	// versions for different nodes allows for testing the interaction of different
	// node's compatibility. Note that in order to use a node at a particular version,
	// there must be a docker image of the test app tagged with this version present
	// on the machine where the test is being run.
	Version string `toml:"version"`

	// Seeds is the list of node names to use as P2P seed nodes. Defaults to none.
	Seeds []string `toml:"seeds"`

	// PersistentPeers is a list of node names to maintain persistent P2P
	// connections to. If neither seeds nor persistent peers are specified,
	// this defaults to all other nodes in the network. For light clients,
	// this relates to the providers the light client is connected to.
	PersistentPeers []string `toml:"persistent_peers"`

	// Database specifies the database backend: "goleveldb", "cleveldb",
	// "rocksdb", "boltdb", or "badgerdb". Defaults to goleveldb.
	Database string `toml:"database"`

	// PrivvalProtocol specifies the protocol used to sign consensus messages:
	// "file", "unix", or "tcp". Defaults to "file". For unix and tcp, the ABCI
	// application will launch a remote signer client in a separate goroutine.
	// Only nodes with mode=validator will actually make use of this.
	PrivvalProtocol string `toml:"privval_protocol"`

	// StartAt specifies the block height at which the node will be started. The
	// runner will wait for the network to reach at least this block height.
	StartAt int64 `toml:"start_at"`

	// BlockSync specifies the block sync mode: "" (disable), "v0" or "v2".
	// Defaults to disabled.
	//
	// Note that BlockSync will always be enabled in the next major release and the
	// `block_sync` key will be removed from the config file.
	BlockSync string `toml:"block_sync"`

	// Mempool specifies which version of mempool to use. Either "v0" or "v1"
	// This defaults to v0.
	Mempool string `toml:"mempool_version"`

	// StateSync enables state sync. The runner automatically configures trusted
	// block hashes and RPC servers. At least one node in the network must have
	// SnapshotInterval set to non-zero, and the state syncing node must have
	// StartAt set to an appropriate height where a snapshot is available.
	StateSync bool `toml:"state_sync"`

	// PersistInterval specifies the height interval at which the application
	// will persist state to disk. Defaults to 1 (every height), setting this to
	// 0 disables state persistence.
	PersistInterval *uint64 `toml:"persist_interval"`

	// SnapshotInterval specifies the height interval at which the application
	// will take state sync snapshots. Defaults to 0 (disabled).
	SnapshotInterval uint64 `toml:"snapshot_interval"`

	// RetainBlocks specifies the number of recent blocks to retain. Defaults to
	// 0, which retains all blocks. Must be greater that PersistInterval and
	// SnapshotInterval.
	RetainBlocks uint64 `toml:"retain_blocks"`

	// Perturb lists perturbations to apply to the node after it has been
	// started and synced with the network:
	//
	// disconnect: temporarily disconnects the node from the network
	// kill:       kills the node with SIGKILL then restarts it
	// pause:      temporarily pauses (freezes) the node
	// restart:    restarts the node, shutting it down with SIGTERM
	Perturb []string `toml:"perturb"`

	// SendNoLoad determines if the e2e test should send load to this node.
	// It defaults to false so unless the configured, the node will
	// receive load.
	SendNoLoad bool `toml:"send_no_load"`
}

ManifestNode represents a node in a testnet manifest.

type Mode

type Mode string

type Node

type Node struct {
	Name                string
	Version             string
	Testnet             *Testnet
	Mode                Mode
	PrivvalKey          crypto.PrivKey
	NodeKey             crypto.PrivKey
	IP                  net.IP
	ProxyPort           uint32
	StartAt             int64
	BlockSync           string
	StateSync           bool
	Mempool             string
	Database            string
	ABCIProtocol        Protocol
	PrivvalProtocol     Protocol
	PersistInterval     uint64
	SnapshotInterval    uint64
	RetainBlocks        uint64
	Seeds               []*Node
	PersistentPeers     []*Node
	Perturbations       []Perturbation
	SendNoLoad          bool
	Prometheus          bool
	PrometheusProxyPort uint32
}

Node represents a CometBFT node in a testnet.

func (Node) AddressP2P

func (n Node) AddressP2P(withID bool) string

Address returns a P2P endpoint address for the node.

func (Node) AddressRPC

func (n Node) AddressRPC() string

Address returns an RPC endpoint address for the node.

func (Node) Client

func (n Node) Client() (*rpchttp.HTTP, error)

Client returns an RPC client for a node.

func (Node) Stateless

func (n Node) Stateless() bool

Stateless returns true if the node is either a seed node or a light node

func (Node) Validate

func (n Node) Validate(testnet Testnet) error

Validate validates a node.

type Perturbation

type Perturbation string

type Protocol

type Protocol string

type Testnet

type Testnet struct {
	Name                 string
	File                 string
	Dir                  string
	IP                   *net.IPNet
	InitialHeight        int64
	InitialState         map[string]string
	Validators           map[*Node]int64
	ValidatorUpdates     map[int64]map[*Node]int64
	Nodes                []*Node
	KeyType              string
	Evidence             int
	LoadTxSizeBytes      int
	LoadTxBatchSize      int
	LoadTxConnections    int
	ABCIProtocol         string
	PrepareProposalDelay time.Duration
	ProcessProposalDelay time.Duration
	CheckTxDelay         time.Duration
	UpgradeVersion       string
	Prometheus           bool
}

Testnet represents a single testnet.

func LoadTestnet

func LoadTestnet(manifest Manifest, fname string, ifd InfrastructureData) (*Testnet, error)

LoadTestnet loads a testnet from a manifest file, using the filename to determine the testnet name and directory (from the basename of the file). The testnet generation must be deterministic, since it is generated separately by the runner and the test cases. For this reason, testnets use a random seed to generate e.g. keys.

func (Testnet) ArchiveNodes

func (t Testnet) ArchiveNodes() []*Node

ArchiveNodes returns a list of archive nodes that start at the initial height and contain the entire blockchain history. They are used e.g. as light client RPC servers.

func (Testnet) HasPerturbations

func (t Testnet) HasPerturbations() bool

HasPerturbations returns whether the network has any perturbations.

func (Testnet) IPv6

func (t Testnet) IPv6() bool

IPv6 returns true if the testnet is an IPv6 network.

func (Testnet) LookupNode

func (t Testnet) LookupNode(name string) *Node

LookupNode looks up a node by name. For now, simply do a linear search.

func (Testnet) RandomNode

func (t Testnet) RandomNode() *Node

RandomNode returns a random non-seed node.

func (Testnet) Validate

func (t Testnet) Validate() error

Validate validates a testnet.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL