iotex-core: github.com/iotexproject/iotex-core/config Index | Files

package config

import "github.com/iotexproject/iotex-core/config"

Index

Package Files

config.go heightupgrade.go

Constants

const (
    // RollDPoSScheme means randomized delegated proof of stake
    RollDPoSScheme = "ROLLDPOS"
    // StandaloneScheme means that the node creates a block periodically regardless of others (if there is any)
    StandaloneScheme = "STANDALONE"
    // NOOPScheme means that the node does not create only block
    NOOPScheme = "NOOP"
)
const (
    DardanellesUnmatchedEventTTL            = 2 * time.Second
    DardanellesUnmatchedEventInterval       = 100 * time.Millisecond
    DardanellesAcceptBlockTTL               = 2 * time.Second
    DardanellesAcceptProposalEndorsementTTL = time.Second
    DardanellesAcceptLockEndorsementTTL     = time.Second
    DardanellesCommitTTL                    = time.Second
    DardanellesBlockInterval                = 5 * time.Second
    DardanellesDelay                        = 2 * time.Second
)

Dardanelles consensus config

const (
    Pacific = iota
    Aleutian
    Bering
    Cook
    Dardanelles
)

Codename for height upgrades

const (
    // GatewayPlugin is the plugin of accepting user API requests and serving blockchain data to users
    GatewayPlugin = iota
)

Variables

var (
    // Default is the default config
    Default = Config{
        Plugins: make(map[int]interface{}),
        SubLogs: make(map[string]log.GlobalConfig),
        Network: Network{
            Host:              "0.0.0.0",
            Port:              4689,
            ExternalHost:      "",
            ExternalPort:      4689,
            BootstrapNodes:    []string{},
            MasterKey:         "",
            RateLimit:         p2p.DefaultRatelimitConfig,
            EnableRateLimit:   true,
            PrivateNetworkPSK: "",
        },
        Chain: Chain{
            ChainDBPath:     "./chain.db",
            TrieDBPath:      "./trie.db",
            IndexDBPath:     "./index.db",
            ID:              1,
            Address:         "",
            ProducerPrivKey: PrivateKey.HexString(),
            EmptyGenesis:    false,
            GravityChainDB:  DB{DbPath: "./poll.db", NumRetries: 10},
            Committee: committee.Config{
                GravityChainAPIs: []string{},
            },
            EnableTrielessStateDB:         true,
            EnableAsyncIndexWrite:         true,
            CompressBlock:                 false,
            AllowedBlockGasResidue:        10000,
            MaxCacheSize:                  0,
            PollInitialCandidatesInterval: 10 * time.Second,
            EnableHistoryStateDB:          false,
        },
        ActPool: ActPool{
            MaxNumActsPerPool:  32000,
            MaxGasLimitPerPool: 320000000,
            MaxNumActsPerAcct:  2000,
            ActionExpiry:       10 * time.Minute,
            MinGasPriceStr:     big.NewInt(unit.Qev).String(),
            BlackList:          []string{},
        },
        Consensus: Consensus{
            Scheme: StandaloneScheme,
            RollDPoS: RollDPoS{
                FSM: ConsensusTiming{
                    UnmatchedEventTTL:            3 * time.Second,
                    UnmatchedEventInterval:       100 * time.Millisecond,
                    AcceptBlockTTL:               4 * time.Second,
                    AcceptProposalEndorsementTTL: 2 * time.Second,
                    AcceptLockEndorsementTTL:     2 * time.Second,
                    CommitTTL:                    2 * time.Second,
                    EventChanSize:                10000,
                },
                ToleratedOvertime: 2 * time.Second,
                Delay:             5 * time.Second,
                ConsensusDBPath:   "./consensus.db",
            },
        },
        BlockSync: BlockSync{
            Interval:        10 * time.Second,
            BufferSize:      200,
            IntervalSize:    20,
            MaxRepeat:       3,
            RepeatDecayStep: 1,
        },
        Dispatcher: Dispatcher{
            EventChanSize: 10000,
        },
        API: API{
            UseRDS:    false,
            Port:      14014,
            TpsWindow: 10,
            GasStation: GasStation{
                SuggestBlockWindow: 20,
                DefaultGas:         uint64(unit.Qev),
                Percentile:         60,
            },
            RangeQueryLimit: 1000,
        },
        System: System{
            Active:                true,
            HeartbeatInterval:     10 * time.Second,
            HTTPStatsPort:         8080,
            HTTPAdminPort:         9009,
            StartSubChainInterval: 10 * time.Second,
        },
        DB: DB{
            NumRetries:   3,
            MaxCacheSize: 64,
            SQLITE3: SQLITE3{
                SQLite3File: "./explorer.db",
            },
            SplitDBSizeMB:         0,
            SplitDBHeight:         900000,
            HistoryStateRetention: 2000,
        },
        Genesis: genesis.Default,
    }

    // ErrInvalidCfg indicates the invalid config value
    ErrInvalidCfg = errors.New("invalid config value")

    // Validates is the collection config validation functions
    Validates = []Validate{
        ValidateRollDPoS,
        ValidateDispatcher,
        ValidateAPI,
        ValidateActPool,
    }

    // PrivateKey is a randomly generated producer's key for testing purpose
    PrivateKey, _ = crypto.GenerateKey()
)

func DoNotValidate Uses

func DoNotValidate(cfg Config) error

DoNotValidate validates the given config

func ValidateAPI Uses

func ValidateAPI(cfg Config) error

ValidateAPI validates the api configs

func ValidateActPool Uses

func ValidateActPool(cfg Config) error

ValidateActPool validates the given config

func ValidateDispatcher Uses

func ValidateDispatcher(cfg Config) error

ValidateDispatcher validates the dispatcher configs

func ValidateRollDPoS Uses

func ValidateRollDPoS(cfg Config) error

ValidateRollDPoS validates the roll-DPoS configs

type API Uses

type API struct {
    UseRDS          bool       `yaml:"useRDS"`
    Port            int        `yaml:"port"`
    TpsWindow       int        `yaml:"tpsWindow"`
    GasStation      GasStation `yaml:"gasStation"`
    RangeQueryLimit uint64     `yaml:"rangeQueryLimit"`
}

API is the api service config

type ActPool Uses

type ActPool struct {
    // MaxNumActsPerPool indicates maximum number of actions the whole actpool can hold
    MaxNumActsPerPool uint64 `yaml:"maxNumActsPerPool"`
    // MaxGasLimitPerPool indicates maximum gas limit the whole actpool can hold
    MaxGasLimitPerPool uint64
    // MaxNumActsPerAcct indicates maximum number of actions an account queue can hold
    MaxNumActsPerAcct uint64 `yaml:"maxNumActsPerAcct"`
    // ActionExpiry defines how long an action will be kept in action pool.
    ActionExpiry time.Duration `yaml:"actionExpiry"`
    // MinGasPriceStr defines the minimal gas price the delegate will accept for an action
    MinGasPriceStr string `yaml:"minGasPrice"`
    // BlackList lists the account address that are banned from initiating actions
    BlackList []string `yaml:"blackList"`
}

ActPool is the actpool config

func (ActPool) MinGasPrice Uses

func (ap ActPool) MinGasPrice() *big.Int

MinGasPrice returns the minimal gas price threshold

type BlockSync Uses

type BlockSync struct {
    Interval     time.Duration `yaml:"interval"` // update duration
    BufferSize   uint64        `yaml:"bufferSize"`
    IntervalSize uint64        `yaml:"intervalSize"`
    // MaxRepeat is the maximal number of repeat of a block sync request
    MaxRepeat int `yaml:"maxRepeat"`
    // RepeatDecayStep is the step for repeat number decreasing by 1
    RepeatDecayStep int `yaml:"repeatDecayStep"`
}

BlockSync is the config struct for the BlockSync

type Chain Uses

type Chain struct {
    ChainDBPath     string           `yaml:"chainDBPath"`
    TrieDBPath      string           `yaml:"trieDBPath"`
    IndexDBPath     string           `yaml:"indexDBPath"`
    ID              uint32           `yaml:"id"`
    Address         string           `yaml:"address"`
    ProducerPrivKey string           `yaml:"producerPrivKey"`
    EmptyGenesis    bool             `yaml:"emptyGenesis"`
    GravityChainDB  DB               `yaml:"gravityChainDB"`
    Committee       committee.Config `yaml:"committee"`

    EnableTrielessStateDB bool `yaml:"enableTrielessStateDB"`
    EnableHistoryStateDB  bool `yaml:"enableHistoryStateDB"`
    // EnableAsyncIndexWrite enables writing the block actions' and receipts' index asynchronously
    EnableAsyncIndexWrite bool `yaml:"enableAsyncIndexWrite"`
    // CompressBlock enables gzip compression on block data
    CompressBlock bool `yaml:"compressBlock"`
    // AllowedBlockGasResidue is the amount of gas remained when block producer could stop processing more actions
    AllowedBlockGasResidue uint64 `yaml:"allowedBlockGasResidue"`
    // MaxCacheSize is the max number of blocks that will be put into an LRU cache. 0 means disabled
    MaxCacheSize int `yaml:"maxCacheSize"`
    // PollInitialCandidatesInterval is the config for committee init db
    PollInitialCandidatesInterval time.Duration `yaml:"pollInitialCandidatesInterval"`
}

Chain is the config struct for blockchain package

type Config Uses

type Config struct {
    Plugins    map[int]interface{}         `ymal:"plugins"`
    Network    Network                     `yaml:"network"`
    Chain      Chain                       `yaml:"chain"`
    ActPool    ActPool                     `yaml:"actPool"`
    Consensus  Consensus                   `yaml:"consensus"`
    BlockSync  BlockSync                   `yaml:"blockSync"`
    Dispatcher Dispatcher                  `yaml:"dispatcher"`
    API        API                         `yaml:"api"`
    System     System                      `yaml:"system"`
    DB         DB                          `yaml:"db"`
    Log        log.GlobalConfig            `yaml:"log"`
    SubLogs    map[string]log.GlobalConfig `yaml:"subLogs"`
    Genesis    genesis.Genesis             `yaml:"genesis"`
}

Config is the root config struct, each package's config should be put as its sub struct

func New Uses

func New(validates ...Validate) (Config, error)

New creates a config instance. It first loads the default configs. If the config path is not empty, it will read from the file and override the default configs. By default, it will apply all validation functions. To bypass validation, use DoNotValidate instead.

func NewSub Uses

func NewSub(validates ...Validate) (Config, error)

NewSub create config for sub chain.

func (Config) ProducerAddress Uses

func (cfg Config) ProducerAddress() address.Address

ProducerAddress returns the configured producer address derived from key

func (Config) ProducerPrivateKey Uses

func (cfg Config) ProducerPrivateKey() crypto.PrivateKey

ProducerPrivateKey returns the configured private key

type Consensus Uses

type Consensus struct {
    // There are three schemes that are supported
    Scheme   string   `yaml:"scheme"`
    RollDPoS RollDPoS `yaml:"rollDPoS"`
}

Consensus is the config struct for consensus package

type ConsensusTiming Uses

type ConsensusTiming struct {
    EventChanSize                uint          `yaml:"eventChanSize"`
    UnmatchedEventTTL            time.Duration `yaml:"unmatchedEventTTL"`
    UnmatchedEventInterval       time.Duration `yaml:"unmatchedEventInterval"`
    AcceptBlockTTL               time.Duration `yaml:"acceptBlockTTL"`
    AcceptProposalEndorsementTTL time.Duration `yaml:"acceptProposalEndorsementTTL"`
    AcceptLockEndorsementTTL     time.Duration `yaml:"acceptLockEndorsementTTL"`
    CommitTTL                    time.Duration `yaml:"commitTTL"`
}

ConsensusTiming defines a set of time durations used in fsm and event queue size

type DB Uses

type DB struct {
    DbPath string `yaml:"dbPath"`
    // NumRetries is the number of retries
    NumRetries uint8 `yaml:"numRetries"`
    // MaxCacheSize is the max number of blocks that will be put into an LRU cache. 0 means disabled
    MaxCacheSize int `yaml:"maxCacheSize"`
    // RDS is the config for rds
    RDS RDS `yaml:"RDS"`
    // SQLite3 is the config for SQLITE3
    SQLITE3 SQLITE3 `yaml:"SQLITE3"`
    // SplitDBSize is the config for DB's split file size
    SplitDBSizeMB uint64 `yaml:"splitDBSizeMB"`
    // SplitDBHeight is the config for DB's split start height
    SplitDBHeight uint64 `yaml:"splitDBHeight"`
    // HistoryStateRetention is the number of blocks account/contract state will be retained
    HistoryStateRetention uint64 `yaml:"historyStateRetention"`
}

DB is the config for database

func (DB) SplitDBSize Uses

func (db DB) SplitDBSize() uint64

SplitDBSize returns the configured SplitDBSizeMB

type Dispatcher Uses

type Dispatcher struct {
    EventChanSize uint `yaml:"eventChanSize"`
}

Dispatcher is the dispatcher config

type GasStation Uses

type GasStation struct {
    SuggestBlockWindow int    `yaml:"suggestBlockWindow"`
    DefaultGas         uint64 `yaml:"defaultGas"`
    Percentile         int    `yaml:"Percentile"`
}

GasStation is the gas station config

type HeightName Uses

type HeightName int

HeightName is codename for height upgrades

type HeightUpgrade Uses

type HeightUpgrade struct {
    // contains filtered or unexported fields
}

HeightUpgrade lists heights at which certain fixes take effect

func NewHeightUpgrade Uses

func NewHeightUpgrade(cfg *genesis.Genesis) HeightUpgrade

NewHeightUpgrade creates a height upgrade config

func (*HeightUpgrade) AleutianBlockHeight Uses

func (hu *HeightUpgrade) AleutianBlockHeight() uint64

AleutianBlockHeight returns the aleutian height

func (*HeightUpgrade) BeringBlockHeight Uses

func (hu *HeightUpgrade) BeringBlockHeight() uint64

BeringBlockHeight returns the bering height

func (*HeightUpgrade) CookBlockHeight Uses

func (hu *HeightUpgrade) CookBlockHeight() uint64

CookBlockHeight returns the cook height

func (*HeightUpgrade) DardanellesBlockHeight Uses

func (hu *HeightUpgrade) DardanellesBlockHeight() uint64

DardanellesBlockHeight returns the dardanelles height

func (*HeightUpgrade) IsPost Uses

func (hu *HeightUpgrade) IsPost(name HeightName, height uint64) bool

IsPost return true if height is after the height upgrade

func (*HeightUpgrade) IsPre Uses

func (hu *HeightUpgrade) IsPre(name HeightName, height uint64) bool

IsPre return true if height is before the height upgrade

func (*HeightUpgrade) PacificBlockHeight Uses

func (hu *HeightUpgrade) PacificBlockHeight() uint64

PacificBlockHeight returns the pacific height

type Network Uses

type Network struct {
    Host           string   `yaml:"host"`
    Port           int      `yaml:"port"`
    ExternalHost   string   `yaml:"externalHost"`
    ExternalPort   int      `yaml:"externalPort"`
    BootstrapNodes []string `yaml:"bootstrapNodes"`
    MasterKey      string   `yaml:"masterKey"` // master key will be PrivateKey if not set.
    // RelayType is the type of P2P network relay. By default, the value is empty, meaning disabled. Two relay types
    // are supported: active, nat.
    RelayType         string              `yaml:"relayType"`
    RateLimit         p2p.RateLimitConfig `yaml:"rateLimit"`
    EnableRateLimit   bool                `yaml:"enableRateLimit"`
    PrivateNetworkPSK string              `yaml:"privateNetworkPSK"`
}

Network is the config struct for network package

type RDS Uses

type RDS struct {
    // AwsRDSEndpoint is the endpoint of aws rds
    AwsRDSEndpoint string `yaml:"awsRDSEndpoint"`
    // AwsRDSPort is the port of aws rds
    AwsRDSPort uint64 `yaml:"awsRDSPort"`
    // AwsRDSUser is the user to access aws rds
    AwsRDSUser string `yaml:"awsRDSUser"`
    // AwsPass is the pass to access aws rds
    AwsPass string `yaml:"awsPass"`
    // AwsDBName is the db name of aws rds
    AwsDBName string `yaml:"awsDBName"`
}

RDS is the cloud rds config

type RollDPoS Uses

type RollDPoS struct {
    FSM               ConsensusTiming `yaml:"fsm"`
    ToleratedOvertime time.Duration   `yaml:"toleratedOvertime"`
    Delay             time.Duration   `yaml:"delay"`
    ConsensusDBPath   string          `yaml:"consensusDBPath"`
}

RollDPoS is the config struct for RollDPoS consensus package

type SQLITE3 Uses

type SQLITE3 struct {
    // SQLite3File is the sqlite3 db file
    SQLite3File string `yaml:"sqlite3File"`
}

SQLITE3 is the local sqlite3 config

type System Uses

type System struct {
    // Active is the status of the node. True means active and false means stand-by
    Active            bool          `yaml:"active"`
    HeartbeatInterval time.Duration `yaml:"heartbeatInterval"`
    // HTTPProfilingPort is the port number to access golang performance profiling data of a blockchain node. It is
    // 0 by default, meaning performance profiling has been disabled
    HTTPAdminPort         int           `yaml:"httpAdminPort"`
    HTTPStatsPort         int           `yaml:"httpStatsPort"`
    StartSubChainInterval time.Duration `yaml:"startSubChainInterval"`
}

System is the system config

type Validate Uses

type Validate func(Config) error

Validate is the interface of validating the config

Package config imports 16 packages (graph) and is imported by 20 packages. Updated 2019-12-08. Refresh now. Tools for package owners.