utils

package
v1.10.30 Latest Latest
Warning

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

 Go to latest Published: Dec 14, 2021 License: GPL-3.0, GPL-3.0 Imports: 56 Imported by: 0

Documentation

Overview

Package utils contains internal helper functions for CortexFoundation commands.

Package utils contains internal helper functions for CortexFoundation commands.

Index

Constants

This section is empty.

Variables

View Source 
var (
	CommandHelpTemplate = `` /* 471-byte string literal not displayed */

	OriginCommandHelpTemplate = `` /* 357-byte string literal not displayed */

)
View Source 
var (
	// General settings
	DataDirFlag = DirectoryFlag{
		Name:  "datadir",
		Usage: "Data directory for the databases and keystore",
		Value: DirectoryString{node.DefaultDataDir()},
	}
	AncientFlag = DirectoryFlag{
		Name:  "datadir.ancient",
		Usage: "Data directory for ancient chain segments (default = inside chaindata)",
	}
	MinFreeDiskSpaceFlag = DirectoryFlag{
		Name:  "datadir.minfreedisk",
		Usage: "Minimum free disk space in MB, once reached triggers auto shut down (default = --cache.gc converted to MB, 0 = disabled)",
	}
	KeyStoreDirFlag = DirectoryFlag{
		Name:  "keystore",
		Usage: "Directory for the keystore (default = inside the datadir)",
	}
	// NoUSBFlag = cli.BoolFlag{
	// 	Name:  "nousb",
	// 	Usage: "Disables monitoring for and managing USB hardware wallets",
	// }
	NetworkIdFlag = cli.Uint64Flag{
		Name:  "networkid",
		Usage: "Network identifier (integer, 21=Mainnet, 42=Bernard, 43=Dolores)",
		Value: ctxc.DefaultConfig.NetworkId,
	}
	BernardFlag = cli.BoolFlag{
		Name:  "bernard",
		Usage: "Bernard network: pre-configured cortex test network with POA",
	}
	DoloresFlag = cli.BoolFlag{
		Name:  "dolores",
		Usage: "Dolores network: pre-configured cortex test network",
	}

	ViperFlag = cli.BoolFlag{
		Name:  "viper",
		Usage: "Sync block with 180s local sprout time",
	}
	// DeveloperFlag = cli.BoolFlag{
	// 	Name:  "dev",
	// 	Usage: "Ephemeral proof-of-authority network with a pre-funded developer account, mining enabled",
	// }
	// DeveloperPeriodFlag = cli.IntFlag{
	// 	Name:  "dev.period",
	// 	Usage: "Block period to use in developer mode (0 = mine only if transaction pending)",
	// }
	IdentityFlag = cli.StringFlag{
		Name:  "identity",
		Usage: "Custom node name",
	}
	DocRootFlag = DirectoryFlag{
		Name:  "docroot",
		Usage: "Document Root for HTTPClient file scheme",
		Value: DirectoryString{homeDir()},
	}

	SyncModeFlag = TextMarshalerFlag{
		Name:  "syncmode",
		Usage: `Blockchain sync mode ("full")`,
		Value: &defaultSyncMode,
	}
	GCModeFlag = cli.StringFlag{
		Name:  "gcmode",
		Usage: `Blockchain garbage collection mode ("full", "archive")`,
		Value: "full",
	}

	SnapshotFlag = cli.BoolFlag{
		Name:  "snapshot",
		Usage: `Enables snapshot-database mode -- experimental work in progress feature`,
	}
	TxLookupLimitFlag = cli.Int64Flag{
		Name:  "txlookuplimit",
		Usage: "Number of recent blocks to maintain transactions index by-hash for (default = index all blocks)",
		Value: 0,
	}

	WhitelistFlag = cli.StringFlag{
		Name:  "whitelist",
		Usage: "Comma separated block number-to-hash mappings to enforce (<number>=<hash>)",
	}

	// P2P storage settings
	StorageEnabledFlag = cli.BoolFlag{
		Name:  "storage",
		Usage: "Enable P2P storage",
	}
	StorageDirFlag = DirectoryFlag{
		Name:  "storage.dir",
		Usage: "P2P storage directory",
		Value: DirectoryString{node.DefaultStorageDir("")},
	}

	StorageRpcFlag = cli.StringFlag{
		Name:  "storage.rpc",
		Usage: "P2P storage status sync from blockchain rpc link",
		Value: "http://127.0.0.1:8545",
	}

	StoragePortFlag = cli.IntFlag{
		Name:  "storage.port",
		Usage: "p2p storage listening port",
		Value: torrentfs.DefaultConfig.Port,
	}

	StorageMaxSeedingFlag = cli.IntFlag{
		Name:  "storage.max_seeding",
		Usage: "The maximum number of seeding tasks in the same time",
		Value: torrentfs.DefaultConfig.MaxSeedingNum,
	}
	StorageMaxActiveFlag = cli.IntFlag{
		Name:  "storage.max_active",
		Usage: "The maximum number of active tasks in the same time",
		Value: torrentfs.DefaultConfig.MaxActiveNum,
	}
	StorageBoostNodesFlag = cli.StringFlag{
		Name:  "storage.boostnodes",
		Usage: "p2p storage boostnodes (EXPERIMENTAL)",
		Value: strings.Join(torrentfs.DefaultConfig.BoostNodes, ","),
	}
	StorageTrackerFlag = cli.StringFlag{
		Name:  "storage.tracker",
		Usage: "P2P storage tracker list",
		Value: strings.Join(torrentfs.DefaultConfig.DefaultTrackers, ","),
	}
	StorageDisableDHTFlag = cli.BoolFlag{
		Name:  "storage.disable_dht",
		Usage: "disable DHT network in FS",
	}
	StorageBoostFlag = cli.BoolFlag{
		Name:  "storage.boost",
		Usage: "Boost fs (EXPERIMENTAL)",
	}
	StorageDisableTCPFlag = cli.BoolFlag{
		Name:  "storage.disable_tcp",
		Usage: "disable TCP network in FS (EXPERIMENTAL)",
	}
	StorageFullFlag = cli.BoolFlag{
		Name:  "storage.full",
		Usage: "download full file",
	}
	StorageModeFlag = cli.StringFlag{
		Name:  "storage.mode",
		Usage: "P2P storage tracker list",
		Value: "normal",
	}
	StorageDebugFlag = cli.BoolFlag{
		Name:  "storage.debug",
		Usage: "debug mod for nas",
	}
	// Dashboard settings
	// DashboardEnabledFlag = cli.BoolFlag{
	// 	Name:  metrics.DashboardEnabledFlag,
	// 	Usage: "Enable the dashboard",
	// }
	// DashboardAddrFlag = cli.StringFlag{
	// 	Name:  "dashboard.addr",
	// 	Usage: "Dashboard listening interface",
	// 	Value: dashboard.DefaultConfig.Host,
	// }
	// DashboardPortFlag = cli.IntFlag{
	// 	Name:  "dashboard.host",
	// 	Usage: "Dashboard listening port",
	// 	Value: dashboard.DefaultConfig.Port,
	// }
	// DashboardRefreshFlag = cli.DurationFlag{
	// 	Name:  "dashboard.refresh",
	// 	Usage: "Dashboard metrics collection refresh rate",
	// 	Value: dashboard.DefaultConfig.Refresh,
	// }
	// Transaction pool settings
	TxPoolLocalsFlag = cli.StringFlag{
		Name:  "txpool.locals",
		Usage: "Comma separated accounts to treat as locals (no flush, priority inclusion)",
	}
	TxPoolNoLocalsFlag = cli.BoolFlag{
		Name:  "txpool.nolocals",
		Usage: "Disables price exemptions for locally submitted transactions",
	}
	//TxPoolNoInfersFlag = cli.BoolFlag{
	//	Name:  "txpool.noinfers",
	//	Usage: "Disables infer transactions in this node",
	//}
	TxPoolJournalFlag = cli.StringFlag{
		Name:  "txpool.journal",
		Usage: "Disk journal for local transaction to survive node restarts",
		Value: core.DefaultTxPoolConfig.Journal,
	}
	TxPoolRejournalFlag = cli.DurationFlag{
		Name:  "txpool.rejournal",
		Usage: "Time interval to regenerate the local transaction journal",
		Value: core.DefaultTxPoolConfig.Rejournal,
	}
	TxPoolPriceLimitFlag = cli.Uint64Flag{
		Name:  "txpool.pricelimit",
		Usage: "Minimum gas price limit to enforce for acceptance into the pool",
		Value: ctxc.DefaultConfig.TxPool.PriceLimit,
	}
	TxPoolPriceBumpFlag = cli.Uint64Flag{
		Name:  "txpool.pricebump",
		Usage: "Price bump percentage to replace an already existing transaction",
		Value: ctxc.DefaultConfig.TxPool.PriceBump,
	}
	TxPoolAccountSlotsFlag = cli.Uint64Flag{
		Name:  "txpool.accountslots",
		Usage: "Minimum number of executable transaction slots guaranteed per account",
		Value: ctxc.DefaultConfig.TxPool.AccountSlots,
	}
	TxPoolGlobalSlotsFlag = cli.Uint64Flag{
		Name:  "txpool.globalslots",
		Usage: "Maximum number of executable transaction slots for all accounts",
		Value: ctxc.DefaultConfig.TxPool.GlobalSlots,
	}
	TxPoolAccountQueueFlag = cli.Uint64Flag{
		Name:  "txpool.accountqueue",
		Usage: "Maximum number of non-executable transaction slots permitted per account",
		Value: ctxc.DefaultConfig.TxPool.AccountQueue,
	}
	TxPoolGlobalQueueFlag = cli.Uint64Flag{
		Name:  "txpool.globalqueue",
		Usage: "Maximum number of non-executable transaction slots for all accounts",
		Value: ctxc.DefaultConfig.TxPool.GlobalQueue,
	}
	TxPoolLifetimeFlag = cli.DurationFlag{
		Name:  "txpool.lifetime",
		Usage: "Maximum amount of time non-executable transaction are queued",
		Value: ctxc.DefaultConfig.TxPool.Lifetime,
	}
	// Performance tuning settings
	CacheFlag = cli.IntFlag{
		Name:  "cache",
		Usage: "Megabytes of memory allocated to internal caching",
		Value: 1024,
	}
	CacheDatabaseFlag = cli.IntFlag{
		Name:  "cache.database",
		Usage: "Percentage of cache memory allowance to use for database io",
		Value: 50,
	}
	CacheTrieFlag = cli.IntFlag{
		Name:  "cache.trie",
		Usage: "Percentage of cache memory allowance to use for trie caching (default = 15% full mode, 30% archive mode)",
		Value: 15,
	}
	CacheTrieJournalFlag = cli.StringFlag{
		Name:  "cache.trie.journal",
		Usage: "Disk journal directory for trie cache to survive node restarts",
		Value: ctxc.DefaultConfig.TrieCleanCacheJournal,
	}
	CacheTrieRejournalFlag = cli.DurationFlag{
		Name:  "cache.trie.rejournal",
		Usage: "Time interval to regenerate the trie cache journal",
		Value: ctxc.DefaultConfig.TrieCleanCacheRejournal,
	}
	CacheGCFlag = cli.IntFlag{
		Name:  "cache.gc",
		Usage: "Percentage of cache memory allowance to use for trie pruning 25%",
		Value: 25,
	}
	CacheSnapshotFlag = cli.IntFlag{
		Name:  "cache.snapshot",
		Usage: "Percentage of cache memory allowance to use for snapshot caching (default = 10% full mode, 20% archive mode)",
		Value: 10,
	}
	CacheNoPrefetchFlag = cli.BoolFlag{
		Name:  "cache.noprefetch",
		Usage: "Disable heuristic state prefetch during block import (less CPU and disk IO, more time waiting for data)",
	}
	CachePreimagesFlag = cli.BoolTFlag{
		Name:  "cache.preimages",
		Usage: "Enable recording the SHA3/keccak preimages of trie keys (default: true)",
	}
	TrieCacheGenFlag = cli.IntFlag{
		Name:  "trie-cache-gens",
		Usage: "Number of trie node generations to keep in memory",

		Value: 0,
	}
	// Miner settings
	MiningEnabledFlag = cli.BoolFlag{
		Name:  "mine",
		Usage: "Enable mining",
	}
	MinerThreadsFlag = cli.IntFlag{
		Name:  "miner.threads",
		Usage: "Number of CPU threads to use for mining",
		Value: 0,
	}
	//MinerLegacyThreadsFlag = cli.IntFlag{
	// 	Name:  "minerthreads",
	// 	Usage: "Number of CPU threads to use for mining (deprecated, use --miner.threads)",
	// 	Value: 0,
	// }
	MinerNotifyFlag = cli.StringFlag{
		Name:  "miner.notify",
		Usage: "Comma separated HTTP URL list to notify of new work packages",
	}
	MinerGasTargetFlag = cli.Uint64Flag{
		Name:  "miner.gastarget",
		Usage: "Target gas floor for mined blocks",
		Value: ctxc.DefaultConfig.Miner.GasFloor,
	}
	// MinerLegacyGasTargetFlag = cli.Uint64Flag{
	// 	Name:  "targetgaslimit",
	// 	Usage: "Target gas floor for mined blocks (deprecated, use --miner.gastarget)",
	// 	Value: ctxc.DefaultConfig.MinerGasFloor,
	// }
	MinerGasLimitFlag = cli.Uint64Flag{
		Name:  "miner.gaslimit",
		Usage: "Target gas ceiling for mined blocks",
		Value: ctxc.DefaultConfig.Miner.GasCeil,
	}
	MinerGasPriceFlag = BigFlag{
		Name:  "miner.gasprice",
		Usage: "Minimum gas price for mining a transaction",
		Value: ctxc.DefaultConfig.Miner.GasPrice,
	}
	MinerLegacyGasPriceFlag = BigFlag{
		Name:  "gasprice",
		Usage: "Minimum gas price for mining a transaction (deprecated, use --miner.gasprice)",
		Value: ctxc.DefaultConfig.Miner.GasPrice,
	}
	MinerCoinbaseFlag = cli.StringFlag{
		Name:  "miner.coinbase",
		Usage: "Public address for block mining rewards (default = first account)",
		Value: "0",
	}
	MinerLegacyCoinbaseFlag = cli.StringFlag{
		Name:  "coinbase",
		Usage: "Public address for block mining rewards (default = first account, deprecated, use --miner.coinbase)",
		Value: "0",
	}
	MinerExtraDataFlag = cli.StringFlag{
		Name:  "miner.extradata",
		Usage: "Block extra data set by the miner (default = client version)",
	}
	MinerLegacyExtraDataFlag = cli.StringFlag{
		Name:  "extradata",
		Usage: "Block extra data set by the miner (default = client version, deprecated, use --miner.extradata)",
	}
	MinerRecommitIntervalFlag = cli.DurationFlag{
		Name:  "miner.recommit",
		Usage: "Time interval to recreate the block being mined",
		Value: ctxc.DefaultConfig.Miner.Recommit,
	}
	MinerNoVerfiyFlag = cli.BoolFlag{
		Name:  "miner.noverify",
		Usage: "Disable remote sealing verification",
	}
	MinerCudaFlag = cli.BoolFlag{
		Name:  "miner.cuda",
		Usage: "use cuda miner plugin",
	}
	//	MinerOpenCLFlag = cli.BoolFlag{
	//		Name:  "miner.opencl",
	//		Usage: "use opencl miner plugin",
	//	}
	MinerDevicesFlag = cli.StringFlag{
		Name:  "miner.devices",
		Usage: "the devices used mining, use --miner.devices=0,1",
	}
	//	MinerAlgorithmFlag = cli.StringFlag{
	//		Name:  "miner.algorithm",
	//		Usage: "use mining algorithm, --miner.algorithm=cuckoo/cuckaroo",
	//              Value: "cuckaroo"
	//	}
	InferDeviceTypeFlag = cli.StringFlag{
		Name:  "infer.devicetype",
		Usage: "infer device type : cpu or gpu",
		Value: "cpu",
	}
	InferDeviceIdFlag = cli.IntFlag{
		Name:  "infer.device",
		Usage: "the device used infering, use --infer.device=2, not available on cpu",
		Value: 0,
	}
	InferPortFlag = cli.IntFlag{
		Name:  "infer.port",
		Usage: "local infer port",
		Value: 4321,
	}
	InferMemoryFlag = cli.IntFlag{
		Name:  "infer.memory",
		Usage: "the maximum memory usage of infer engine, use --infer.memory=4096. shoule at least be 2048 (MiB)",
		Value: int(synapse.DefaultConfig.MaxMemoryUsage >> 20),
	}

	// Account settings
	UnlockedAccountFlag = cli.StringFlag{
		Name:  "unlock",
		Usage: "Comma separated list of accounts to unlock",
		Value: "",
	}
	PasswordFileFlag = cli.StringFlag{
		Name:  "password",
		Usage: "Password file to use for non-interactive password input",
		Value: "",
	}
	ExternalSignerFlag = cli.StringFlag{
		Name:  "signer",
		Usage: "External signer (url or path to ipc file)",
		Value: "",
	}
	InsecureUnlockAllowedFlag = cli.BoolFlag{
		Name:  "allow-insecure-unlock",
		Usage: "Allow insecure account unlocking when account-related RPCs are exposed by http",
	}
	RPCGlobalGasCapFlag = cli.Uint64Flag{
		Name:  "rpc.gascap",
		Usage: "Sets a cap on gas that can be used in ctxc_call/estimateGas",
		Value: ctxc.DefaultConfig.RPCGasCap,
	}
	RPCGlobalTxFeeCapFlag = cli.Float64Flag{
		Name:  "rpc.txfeecap",
		Usage: "Sets a cap on transaction fee (in ctxc) that can be sent via the RPC APIs (0 = no cap)",
		Value: ctxc.DefaultConfig.RPCTxFeeCap,
	}

	VMEnableDebugFlag = cli.BoolFlag{
		Name:  "vmdebug",
		Usage: "Record information useful for VM and contract debugging",
	}
	// Logging and debug settings
	// CortexStatsURLFlag = cli.StringFlag{
	// 	Name:  "stats",
	// 	Usage: "Reporting URL of a ctxcstats service (nodename:secret@host:port)",
	// }
	FakePoWFlag = cli.BoolFlag{
		Name:  "fakepow",
		Usage: "Disables proof-of-work verification",
	}
	// NoCompactionFlag = cli.BoolFlag{
	// 	Name:  "nocompaction",
	// 	Usage: "Disables db compaction after import",
	// }
	// RPC settings
	RPCEnabledFlag = cli.BoolFlag{
		Name:  "rpc",
		Usage: "Enable the HTTP-RPC server",
	}
	RPCListenAddrFlag = cli.StringFlag{
		Name:  "rpcaddr",
		Usage: "HTTP-RPC server listening interface",
		Value: node.DefaultHTTPHost,
	}
	RPCPortFlag = cli.IntFlag{
		Name:  "rpcport",
		Usage: "HTTP-RPC server listening port",
		Value: node.DefaultHTTPPort,
	}
	RPCCORSDomainFlag = cli.StringFlag{
		Name:  "rpccorsdomain",
		Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
		Value: "",
	}
	RPCVirtualHostsFlag = cli.StringFlag{
		Name:  "rpcvhosts",
		Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
		Value: strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
	}
	RPCApiFlag = cli.StringFlag{
		Name:  "rpcapi",
		Usage: "API's offered over the HTTP-RPC interface",
		Value: "",
	}
	IPCDisabledFlag = cli.BoolFlag{
		Name:  "ipcdisable",
		Usage: "Disable the IPC-RPC server",
	}
	IPCPathFlag = DirectoryFlag{
		Name:  "ipcpath",
		Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
		Value: DirectoryString{"cortex.ipc"},
	}
	WSEnabledFlag = cli.BoolFlag{
		Name:  "ws",
		Usage: "Enable the WS-RPC server",
	}
	WSListenAddrFlag = cli.StringFlag{
		Name:  "wsaddr",
		Usage: "WS-RPC server listening interface",
		Value: node.DefaultWSHost,
	}
	WSPortFlag = cli.IntFlag{
		Name:  "wsport",
		Usage: "WS-RPC server listening port",
		Value: node.DefaultWSPort,
	}
	WSApiFlag = cli.StringFlag{
		Name:  "wsapi",
		Usage: "API's offered over the WS-RPC interface",
		Value: "",
	}
	WSAllowedOriginsFlag = cli.StringFlag{
		Name:  "wsorigins",
		Usage: "Origins from which to accept websockets requests",
		Value: "",
	}
	ExecFlag = cli.StringFlag{
		Name:  "exec",
		Usage: "Execute JavaScript statement",
	}
	PreloadJSFlag = cli.StringFlag{
		Name:  "preload",
		Usage: "Comma separated list of JavaScript files to preload into the console",
	}
	AllowUnprotectedTxs = cli.BoolFlag{
		Name:  "rpc.allow-unprotected-txs",
		Usage: "Allow for unprotected (non EIP155 signed) transactions to be submitted via RPC",
	}

	// Network Settings
	MaxPeersFlag = cli.IntFlag{
		Name:  "maxpeers",
		Usage: "Maximum number of network peers (network disabled if set to 0)",
		Value: 25,
	}
	MaxPendingPeersFlag = cli.IntFlag{
		Name:  "maxpendpeers",
		Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
		Value: 0,
	}
	ListenPortFlag = cli.IntFlag{
		Name:  "port",
		Usage: "Network listening port (mainnet: '40404' dolores: '40405' bernard: '40406')",
		Value: 40404,
	}
	BootnodesFlag = cli.StringFlag{
		Name:  "bootnodes",
		Usage: "Comma separated enode URLs for P2P discovery bootstrap",
		Value: "",
	}
	BootnodesV4Flag = cli.StringFlag{
		Name:  "bootnodesv4",
		Usage: "Comma separated enode URLs for P2P v4 discovery bootstrap",
		Value: "",
	}
	BootnodesV5Flag = cli.StringFlag{
		Name:  "bootnodesv5",
		Usage: "Comma separated enode URLs for P2P v5 discovery bootstrap",
		Value: "",
	}
	NodeKeyFileFlag = cli.StringFlag{
		Name:  "nodekey",
		Usage: "P2P node key file",
	}
	NodeKeyHexFlag = cli.StringFlag{
		Name:  "nodekeyhex",
		Usage: "P2P node key as hex (for testing)",
	}
	NATFlag = cli.StringFlag{
		Name:  "nat",
		Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
		Value: "any",
	}
	NoDiscoverFlag = cli.BoolFlag{
		Name:  "nodiscover",
		Usage: "Disables the peer discovery mechanism (manual peer addition)",
	}
	DiscoveryV5Flag = cli.BoolFlag{
		Name:  "v5disc",
		Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
	}
	DNSDiscoveryFlag = cli.StringFlag{
		Name:  "discovery.dns",
		Usage: "Sets DNS discovery entry points (use \"\" to disable DNS)",
	}
	NetrestrictFlag = cli.StringFlag{
		Name:  "netrestrict",
		Usage: "Restricts network communication to the given IP networks (CIDR masks)",
	}

	// ATM the url is left to the user and deployment to
	JSpathFlag = DirectoryFlag{
		Name:  "jspath",
		Usage: "JavaScript root path for `loadScript`",
		Value: DirectoryString{"."},
	}

	// Gas price oracle settings
	GpoBlocksFlag = cli.IntFlag{
		Name:  "gpoblocks",
		Usage: "Number of recent blocks to check for gas prices",
		Value: ctxc.DefaultConfig.GPO.Blocks,
	}

	GpoPercentileFlag = cli.IntFlag{
		Name:  "gpopercentile",
		Usage: "Suggested gas price is the given percentile of a set of recent transaction gas prices",
		Value: ctxc.DefaultConfig.GPO.Percentile,
	}
	GpoMaxGasPriceFlag = cli.Int64Flag{
		Name:  "gpo.maxprice",
		Usage: "Maximum gas price will be recommended by gpo",
		Value: ctxc.DefaultConfig.GPO.MaxPrice.Int64(),
	}
	WhisperEnabledFlag = cli.BoolFlag{
		Name:  "shh",
		Usage: "Enable Whisper",
	}
	WhisperMaxMessageSizeFlag = cli.IntFlag{
		Name:  "shh.maxmessagesize",
		Usage: "Max message size accepted",
		Value: int(whisper.DefaultMaxMessageSize),
	}
	WhisperMinPOWFlag = cli.Float64Flag{
		Name:  "shh.pow",
		Usage: "Minimum POW accepted",
		Value: whisper.DefaultMinimumPoW,
	}
	WhisperRestrictConnectionBetweenLightClientsFlag = cli.BoolFlag{
		Name:  "shh.restrict-light",
		Usage: "Restrict connection between two whisper light clients",
	}

	// Metrics flags
	MetricsEnabledFlag = cli.BoolFlag{
		Name:  "metrics",
		Usage: "Enable metrics collection and reporting",
	}
	MetricsEnabledExpensiveFlag = cli.BoolFlag{
		Name:  "metrics.expensive",
		Usage: "Enable expensive metrics collection and reporting",
	}
	// MetricsHTTPFlag defines the endpoint for a stand-alone metrics HTTP endpoint.
	// Since the pprof service enables sensitive/vulnerable behavior, this allows a user
	// to enable a public-OK metrics endpoint without having to worry about ALSO exposing
	// other profiling behavior or information.
	MetricsHTTPFlag = cli.StringFlag{
		Name:  "metrics.addr",
		Usage: "Enable stand-alone metrics HTTP server listening interface",
		Value: "127.0.0.1",
	}
	MetricsPortFlag = cli.IntFlag{
		Name:  "metrics.port",
		Usage: "Metrics HTTP server listening port",
		Value: 6060,
	}
	MetricsEnableInfluxDBFlag = cli.BoolFlag{
		Name:  "metrics.influxdb",
		Usage: "Enable metrics export/push to an external InfluxDB database",
	}
	MetricsInfluxDBEndpointFlag = cli.StringFlag{
		Name:  "metrics.influxdb.endpoint",
		Usage: "InfluxDB API endpoint to report metrics to",
		Value: "http://localhost:8086",
	}
	MetricsInfluxDBDatabaseFlag = cli.StringFlag{
		Name:  "metrics.influxdb.database",
		Usage: "InfluxDB database name to push reported metrics to",
		Value: "cortex",
	}
	MetricsInfluxDBUsernameFlag = cli.StringFlag{
		Name:  "metrics.influxdb.username",
		Usage: "Username to authorize access to the database",
		Value: "test",
	}
	MetricsInfluxDBPasswordFlag = cli.StringFlag{
		Name:  "metrics.influxdb.password",
		Usage: "Password to authorize access to the database",
		Value: "test",
	}
	// The `host` tag is part of every measurement sent to InfluxDB. Queries on tags are faster in InfluxDB.
	// It is used so that we can group all nodes and average a measurement across all of them, but also so
	// that we can select a specific node and inspect its measurements.
	// https://docs.influxdata.com/influxdb/v1.4/concepts/key_concepts/#tag-key
	//MetricsInfluxDBHostTagFlag = cli.StringFlag{
	//	Name:  "metrics.influxdb.host.tag",
	//	Usage: "InfluxDB `host` tag attached to all measurements",
	//	Value: "localhost",
	//}
	MetricsInfluxDBTagsFlag = cli.StringFlag{
		Name:  "metrics.influxdb.tags",
		Usage: "Comma-separated InfluxDB tags (key/values) attached to all measurements",
		Value: "host=localhost",
	}
)

Functions

func CheckExclusive added in v1.9.52 

func CheckExclusive(ctx *cli.Context, args ...interface{})

func ExportAppendChain 

func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, last uint64) error

ExportAppendChain exports a blockchain into the specified file, appending to the file if data already exists in it.

func ExportChain 

func ExportChain(blockchain *core.BlockChain, fn string) error

ExportChain exports a blockchain into the specified file, truncating any data already present in the file.

func ExportPreimages 

func ExportPreimages(db ctxcdb.Database, fn string) error

ExportPreimages exports all known hash preimages into the specified file, truncating any data already present in the file.

func Fatalf 

func Fatalf(format string, args ...interface{})

Fatalf formats a message to standard error and exits the program. The message is also printed to standard output if standard error is redirected to a different file.

func GlobalBig 

func GlobalBig(ctx *cli.Context, name string) *big.Int

GlobalBig returns the value of a BigFlag from the global flag set.

func ImportChain 

func ImportChain(chain *core.BlockChain, fn string) error

func ImportPreimages 

func ImportPreimages(db ctxcdb.Database, fn string) error

ImportPreimages imports a batch of exported hash preimages into the database.

func MakeAddress 

func MakeAddress(ks *keystore.KeyStore, account string) (accounts.Account, error)

MakeAddress converts an account specified directly as a hex encoded string or a key index in the key store to an internal account representation.

func MakeChain 

func MakeChain(ctx *cli.Context, stack *node.Node, readOnly bool) (chain *core.BlockChain, chainDb ctxcdb.Database)

MakeChain creates a chain manager from set command line flags.

func MakeChainDatabase 

func MakeChainDatabase(ctx *cli.Context, stack *node.Node, readonly bool) ctxcdb.Database

MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.

func MakeConsolePreloads 

func MakeConsolePreloads(ctx *cli.Context) []string

MakeConsolePreloads retrieves the absolute paths for the console JavaScript scripts to preload before starting.

func MakeDataDir 

func MakeDataDir(ctx *cli.Context) string

MakeDataDir retrieves the currently requested data directory, terminating if none (or the empty string) is specified. If the node is starting a testnet, the a subdirectory of the specified datadir will be used.

func MakeGenesis 

func MakeGenesis(ctx *cli.Context) *core.Genesis

func MakePasswordList 

func MakePasswordList(ctx *cli.Context) []string

MakePasswordList reads password lines from the file specified by the global --password flag.

func MakeStorageDir 

func MakeStorageDir(ctx *cli.Context) string

MakeStorageDir retrieves the currently requested data directory, terminating if none (or the empty string) is specified.

func MigrateFlags 

func MigrateFlags(action func(ctx *cli.Context) error) func(*cli.Context) error

MigrateFlags sets the global flag from a local flag when it's set. This is a temporary function used for migrating old command/flags to the new format.

is equivalent after calling this method with:

cortex --keystore /tmp/mykeystore --lightkdf account new

This allows the use of the existing configuration functionality. When all flags are migrated this function can be removed and the existing configuration functionality must be changed that is uses local flags

func NewApp 

func NewApp(gitCommit, usage string) *cli.App

NewApp creates an app with sane defaults.

func RegisterCortexService added in v1.0.0 

func RegisterCortexService(stack *node.Node, cfg *ctxc.Config)

RegisterCortexService adds an Cortex client to the stack.

func RegisterShhService 

func RegisterShhService(stack *node.Node, cfg *whisper.Config)

RegisterShhService configures Whisper and adds it to the given node.

func RegisterStorageService 

func RegisterStorageService(stack *node.Node, cfg *torrentfs.Config)

RegisterStorageService adds a torrent file system to the stack. func RegisterStorageService(stack *node.Node, cfg *torrentfs.Config, mode downloader.SyncMode) {

func SetCortexConfig added in v1.0.0 

func SetCortexConfig(ctx *cli.Context, stack *node.Node, cfg *ctxc.Config)

SetCortexConfig applies ctxc-related command line flags to the config.

func SetNodeConfig 

func SetNodeConfig(ctx *cli.Context, cfg *node.Config)

SetNodeConfig applies node-related command line flags to the config.

func SetP2PConfig 

func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config)

func SetShhConfig 

func SetShhConfig(ctx *cli.Context, stack *node.Node, cfg *whisper.Config)

SetShhConfig applies shh-related command line flags to the config.

func SetTorrentFsConfig 

func SetTorrentFsConfig(ctx *cli.Context, cfg *torrentfs.Config)

SetTorrentFsConfig applies torrentFs related command line flags to the config.

func SetupMetrics 

func SetupMetrics(ctx *cli.Context)

func SplitTagsFlag added in v1.10.2 

func SplitTagsFlag(tagsFlag string) map[string]string

func StartNode 

func StartNode(ctx *cli.Context, stack *node.Node)

Types

type BigFlag 

type BigFlag struct {
	Name  string
	Value *big.Int
	Usage string
}

BigFlag is a command line flag that accepts 256 bit big integers in decimal or hexadecimal syntax.

func (BigFlag) Apply 

func (f BigFlag) Apply(set *flag.FlagSet)

func (BigFlag) GetName 

func (f BigFlag) GetName() string

func (BigFlag) String 

func (f BigFlag) String() string

type DirectoryFlag 

type DirectoryFlag struct {
	Name  string
	Value DirectoryString
	Usage string
}

Custom cli.Flag type which expand the received string to an absolute path. e.g. ~/.cortex -> /home/username/.cortex

func (DirectoryFlag) Apply 

func (self DirectoryFlag) Apply(set *flag.FlagSet)

called by cli library, grabs variable from environment (if in env) and adds variable to flag set for parsing.

func (DirectoryFlag) GetName 

func (self DirectoryFlag) GetName() string

func (*DirectoryFlag) Set 

func (self *DirectoryFlag) Set(value string)

func (DirectoryFlag) String 

func (self DirectoryFlag) String() string

type DirectoryString 

type DirectoryString struct {
	Value string
}

Custom type which is registered in the flags library which cli uses for argument parsing. This allows us to expand Value to an absolute path when the argument is parsed

func (*DirectoryString) Set 

func (self *DirectoryString) Set(value string) error

func (*DirectoryString) String 

func (self *DirectoryString) String() string

type TextMarshaler 

type TextMarshaler interface {
	encoding.TextMarshaler
	encoding.TextUnmarshaler
}

func GlobalTextMarshaler 

func GlobalTextMarshaler(ctx *cli.Context, name string) TextMarshaler

GlobalTextMarshaler returns the value of a TextMarshalerFlag from the global flag set.

type TextMarshalerFlag 

type TextMarshalerFlag struct {
	Name  string
	Value TextMarshaler
	Usage string
}

TextMarshalerFlag wraps a TextMarshaler value.

func (TextMarshalerFlag) Apply 

func (f TextMarshalerFlag) Apply(set *flag.FlagSet)

func (TextMarshalerFlag) GetName 

func (f TextMarshalerFlag) GetName() string

func (TextMarshalerFlag) String 

func (f TextMarshalerFlag) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.