2017-03-15 21:03:01 +00:00
|
|
|
package params
|
|
|
|
|
|
|
|
import (
|
2017-04-12 18:26:54 +00:00
|
|
|
"bytes"
|
|
|
|
"crypto/ecdsa"
|
2017-03-15 21:03:01 +00:00
|
|
|
"encoding/json"
|
2017-03-18 18:23:58 +00:00
|
|
|
"errors"
|
2017-05-02 14:30:11 +00:00
|
|
|
"fmt"
|
2017-03-15 21:03:01 +00:00
|
|
|
"io/ioutil"
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2017-04-12 18:26:54 +00:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
2017-08-10 13:35:58 +00:00
|
|
|
"github.com/status-im/status-go/geth/log"
|
2017-08-25 09:56:54 +00:00
|
|
|
"github.com/status-im/status-go/static"
|
2017-03-15 21:03:01 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// default node configuration options
|
|
|
|
var (
|
|
|
|
UseMainnetFlag = "false" // to be overridden via -ldflags '-X geth/params.UseMainnetFlag'
|
|
|
|
UseMainnet = false
|
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
if UseMainnetFlag == "true" { // set at compile time, here we make sure to set corresponding boolean flag
|
|
|
|
UseMainnet = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-03 14:24:48 +00:00
|
|
|
// errors
|
2017-03-15 21:03:01 +00:00
|
|
|
var (
|
2017-07-13 06:54:10 +00:00
|
|
|
ErrMissingDataDir = errors.New("missing required 'DataDir' parameter")
|
|
|
|
ErrMissingNetworkID = errors.New("missing required 'NetworkID' parameter")
|
|
|
|
ErrEmptyPasswordFile = errors.New("password file cannot be empty")
|
|
|
|
ErrNoPasswordFileValueSet = errors.New("password file path not set")
|
|
|
|
ErrNoIdentityFileValueSet = errors.New("identity file path not set")
|
|
|
|
ErrEmptyIdentityFile = errors.New("identity file cannot be empty")
|
|
|
|
ErrEmptyAuthorizationKeyFile = errors.New("authorization key file cannot be empty")
|
|
|
|
ErrAuthorizationKeyFileNotSet = errors.New("authorization key file is not set")
|
2017-03-15 21:03:01 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// LightEthConfig holds LES-related configuration
|
|
|
|
// Status nodes are always lightweight clients (due to mobile platform constraints)
|
|
|
|
type LightEthConfig struct {
|
2017-05-11 13:20:27 +00:00
|
|
|
// Enabled flag specifies whether protocol is enabled
|
2017-03-28 09:04:52 +00:00
|
|
|
Enabled bool
|
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// Genesis is JSON to seed the chain database with
|
|
|
|
Genesis string
|
|
|
|
|
|
|
|
// DatabaseCache is memory (in MBs) allocated to internal caching (min 16MB / database forced)
|
|
|
|
DatabaseCache int
|
|
|
|
}
|
|
|
|
|
2017-05-03 14:24:48 +00:00
|
|
|
// FirebaseConfig holds FCM-related configuration
|
2017-04-12 18:26:54 +00:00
|
|
|
type FirebaseConfig struct {
|
|
|
|
// AuthorizationKeyFile file path that contains FCM authorization key
|
|
|
|
AuthorizationKeyFile string
|
|
|
|
|
|
|
|
// NotificationTriggerURL URL used to send push notification requests to
|
|
|
|
NotificationTriggerURL string
|
|
|
|
}
|
|
|
|
|
2017-07-13 06:54:10 +00:00
|
|
|
// ReadAuthorizationKeyFile reads and loads FCM authorization key
|
|
|
|
func (c *FirebaseConfig) ReadAuthorizationKeyFile() ([]byte, error) {
|
|
|
|
if len(c.AuthorizationKeyFile) == 0 {
|
|
|
|
return nil, ErrAuthorizationKeyFileNotSet
|
|
|
|
}
|
|
|
|
|
|
|
|
key, err := ioutil.ReadFile(c.AuthorizationKeyFile)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
key = bytes.TrimRight(key, "\n")
|
|
|
|
|
|
|
|
if len(key) == 0 {
|
|
|
|
return nil, ErrEmptyAuthorizationKeyFile
|
|
|
|
}
|
|
|
|
|
|
|
|
return key, nil
|
|
|
|
}
|
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// WhisperConfig holds SHH-related configuration
|
2017-03-28 09:04:52 +00:00
|
|
|
type WhisperConfig struct {
|
2017-05-11 13:20:27 +00:00
|
|
|
// Enabled flag specifies whether protocol is enabled
|
2017-03-28 09:04:52 +00:00
|
|
|
Enabled bool
|
2017-04-09 22:16:05 +00:00
|
|
|
|
2017-12-04 16:11:14 +00:00
|
|
|
// IdentityFile path to private key, that will be loaded as identity into Whisper.
|
|
|
|
// Currently, it's used by Push Notification service.
|
2017-04-12 18:26:54 +00:00
|
|
|
IdentityFile string
|
|
|
|
|
2017-12-07 16:58:11 +00:00
|
|
|
// PasswordFile contains a password for symmetric encryption with MailServer.
|
2017-04-12 18:26:54 +00:00
|
|
|
PasswordFile string
|
|
|
|
|
2017-12-07 16:58:11 +00:00
|
|
|
// Password for symmetric encryption with MailServer.
|
|
|
|
// (if no account file selected, then this password is used for symmetric encryption).
|
|
|
|
Password string
|
|
|
|
|
2017-12-04 16:11:14 +00:00
|
|
|
// EnableMailServer is mode when node is capable of delivering expired messages on demand
|
|
|
|
EnableMailServer bool
|
2017-04-09 22:16:05 +00:00
|
|
|
|
2017-12-04 16:11:14 +00:00
|
|
|
// EnablePushNotification is mode when node is capable of sending Push (and probably other kinds) Notifications
|
|
|
|
EnablePushNotification bool
|
2017-04-09 22:16:05 +00:00
|
|
|
|
|
|
|
// DataDir is the file system folder Whisper should use for any data storage needs.
|
2017-12-04 16:11:14 +00:00
|
|
|
// For instance, MailServer will use this directory to store its data.
|
2017-04-09 22:16:05 +00:00
|
|
|
DataDir string
|
|
|
|
|
|
|
|
// MinimumPoW minimum PoW for Whisper messages
|
|
|
|
MinimumPoW float64
|
|
|
|
|
|
|
|
// TTL time to live for messages, in seconds
|
|
|
|
TTL int
|
2017-04-12 18:26:54 +00:00
|
|
|
|
|
|
|
// FirebaseConfig extra configuration for Firebase Cloud Messaging
|
|
|
|
FirebaseConfig *FirebaseConfig `json:"FirebaseConfig,"`
|
2017-03-28 09:04:52 +00:00
|
|
|
}
|
2017-03-15 21:03:01 +00:00
|
|
|
|
2017-07-13 06:54:10 +00:00
|
|
|
// ReadPasswordFile reads and returns content of the password file
|
2017-12-07 16:58:11 +00:00
|
|
|
func (c *WhisperConfig) ReadPasswordFile() error {
|
2017-07-13 06:54:10 +00:00
|
|
|
if len(c.PasswordFile) == 0 {
|
2017-12-07 16:58:11 +00:00
|
|
|
return ErrNoPasswordFileValueSet
|
2017-07-13 06:54:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
password, err := ioutil.ReadFile(c.PasswordFile)
|
|
|
|
if err != nil {
|
2017-12-07 16:58:11 +00:00
|
|
|
return err
|
2017-07-13 06:54:10 +00:00
|
|
|
}
|
|
|
|
password = bytes.TrimRight(password, "\n")
|
|
|
|
|
|
|
|
if len(password) == 0 {
|
2017-12-07 16:58:11 +00:00
|
|
|
return ErrEmptyPasswordFile
|
2017-07-13 06:54:10 +00:00
|
|
|
}
|
|
|
|
|
2017-12-07 16:58:11 +00:00
|
|
|
c.Password = string(password)
|
|
|
|
|
|
|
|
return nil
|
2017-07-13 06:54:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ReadIdentityFile reads and loads identity private key
|
|
|
|
func (c *WhisperConfig) ReadIdentityFile() (*ecdsa.PrivateKey, error) {
|
|
|
|
if len(c.IdentityFile) == 0 {
|
|
|
|
return nil, ErrNoIdentityFileValueSet
|
|
|
|
}
|
|
|
|
|
|
|
|
identity, err := crypto.LoadECDSA(c.IdentityFile)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if identity == nil {
|
|
|
|
return nil, ErrEmptyIdentityFile
|
|
|
|
}
|
|
|
|
|
|
|
|
return identity, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// String dumps config object as nicely indented JSON
|
|
|
|
func (c *WhisperConfig) String() string {
|
|
|
|
data, _ := json.MarshalIndent(c, "", " ")
|
|
|
|
return string(data)
|
|
|
|
}
|
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// SwarmConfig holds Swarm-related configuration
|
2017-03-28 09:04:52 +00:00
|
|
|
type SwarmConfig struct {
|
2017-05-11 13:20:27 +00:00
|
|
|
// Enabled flag specifies whether protocol is enabled
|
2017-03-28 09:04:52 +00:00
|
|
|
Enabled bool
|
|
|
|
}
|
2017-03-15 21:03:01 +00:00
|
|
|
|
2017-07-13 06:54:10 +00:00
|
|
|
// String dumps config object as nicely indented JSON
|
|
|
|
func (c *SwarmConfig) String() string {
|
|
|
|
data, _ := json.MarshalIndent(c, "", " ")
|
|
|
|
return string(data)
|
|
|
|
}
|
|
|
|
|
2017-05-16 12:09:52 +00:00
|
|
|
// BootClusterConfig holds configuration for supporting boot cluster, which is a temporary
|
2017-05-11 13:20:27 +00:00
|
|
|
// means for mobile devices to get connected to Ethereum network (UDP-based discovery
|
|
|
|
// may not be available, so we need means to discover the network manually).
|
|
|
|
type BootClusterConfig struct {
|
|
|
|
// Enabled flag specifies whether feature is enabled
|
|
|
|
Enabled bool
|
|
|
|
|
2017-08-04 16:14:17 +00:00
|
|
|
// RootNumber CHT root number
|
|
|
|
RootNumber int
|
|
|
|
|
|
|
|
// RootHash is hash of CHT root for a given root number
|
|
|
|
RootHash string
|
|
|
|
|
|
|
|
// BootNodes list of bootstrap nodes for a given network (Ropsten, Rinkeby, Homestead),
|
|
|
|
// for a given mode (production vs development)
|
|
|
|
BootNodes []string
|
2017-05-11 13:20:27 +00:00
|
|
|
}
|
|
|
|
|
2017-07-13 06:54:10 +00:00
|
|
|
// String dumps config object as nicely indented JSON
|
|
|
|
func (c *BootClusterConfig) String() string {
|
|
|
|
data, _ := json.MarshalIndent(c, "", " ")
|
|
|
|
return string(data)
|
|
|
|
}
|
|
|
|
|
2017-08-15 10:27:12 +00:00
|
|
|
//=====================================================================================
|
|
|
|
|
|
|
|
// UpstreamRPCConfig stores configuration for upstream rpc connection.
|
|
|
|
type UpstreamRPCConfig struct {
|
|
|
|
// Enabled flag specifies whether feature is enabled
|
|
|
|
Enabled bool
|
|
|
|
|
|
|
|
// URL sets the rpc upstream host address for communication with
|
|
|
|
// a non-local infura endpoint.
|
|
|
|
URL string
|
|
|
|
}
|
|
|
|
|
|
|
|
//=====================================================================================
|
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// NodeConfig stores configuration options for a node
|
|
|
|
type NodeConfig struct {
|
2017-05-16 03:24:56 +00:00
|
|
|
// DevMode is true when given configuration is to be used during development.
|
|
|
|
// For production, this flag should be turned off, so that more strict requirements
|
|
|
|
// are applied to node's configuration
|
|
|
|
DevMode bool
|
2017-03-15 21:03:01 +00:00
|
|
|
|
2017-05-03 14:24:48 +00:00
|
|
|
// NetworkID sets network to use for selecting peers to connect to
|
2017-08-10 15:31:29 +00:00
|
|
|
NetworkID uint64 `json:"NetworkId" validate:"required"`
|
2017-03-15 21:03:01 +00:00
|
|
|
|
|
|
|
// DataDir is the file system folder the node should use for any data storage needs.
|
2017-08-10 15:31:29 +00:00
|
|
|
DataDir string `validate:"required"`
|
2017-03-15 21:03:01 +00:00
|
|
|
|
2017-04-28 08:49:15 +00:00
|
|
|
// KeyStoreDir is the file system folder that contains private keys.
|
|
|
|
// If KeyStoreDir is empty, the default location is the "keystore" subdirectory of DataDir.
|
|
|
|
KeyStoreDir string
|
|
|
|
|
2017-04-09 22:16:05 +00:00
|
|
|
// PrivateKeyFile is a filename with node ID (private key)
|
|
|
|
// This file should contain a valid secp256k1 private key that will be used for both
|
|
|
|
// remote peer identification as well as network traffic encryption.
|
|
|
|
NodeKeyFile string
|
|
|
|
|
2017-12-04 16:11:14 +00:00
|
|
|
// ListenAddr is an IP address and port of this node (e.g. 127.0.0.1:30303).
|
|
|
|
ListenAddr string
|
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// Name sets the instance name of the node. It must not contain the / character.
|
2017-08-10 15:31:29 +00:00
|
|
|
Name string `validate:"excludes=/"`
|
2017-03-15 21:03:01 +00:00
|
|
|
|
|
|
|
// Version exposes program's version. It is used in the devp2p node identifier.
|
|
|
|
Version string
|
|
|
|
|
|
|
|
// APIModules is a comma-separated list of API modules exposed via *any* (HTTP/WS/IPC) RPC interface.
|
|
|
|
APIModules string
|
|
|
|
|
|
|
|
// HTTPHost is the host interface on which to start the HTTP RPC server.
|
|
|
|
// Pass empty string if no HTTP RPC interface needs to be started.
|
|
|
|
HTTPHost string
|
|
|
|
|
2017-07-13 06:54:10 +00:00
|
|
|
// RPCEnabled specifies whether the http RPC server is to be enabled by default.
|
|
|
|
RPCEnabled bool
|
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// HTTPPort is the TCP port number on which to start the Geth's HTTP RPC server.
|
|
|
|
HTTPPort int
|
|
|
|
|
|
|
|
// WSHost is a host interface for the WebSocket RPC server
|
|
|
|
WSHost string
|
|
|
|
|
|
|
|
// WSPort is the TCP port number on which to start the Geth's WebSocket RPC server.
|
|
|
|
WSPort int
|
|
|
|
|
|
|
|
// WSEnabled specifies whether WS-RPC Server is enabled or not
|
|
|
|
WSEnabled bool
|
|
|
|
|
|
|
|
// IPCFile is filename of exposed IPC RPC Server
|
|
|
|
IPCFile string
|
|
|
|
|
|
|
|
// IPCEnabled specifies whether IPC-RPC Server is enabled or not
|
|
|
|
IPCEnabled bool
|
|
|
|
|
|
|
|
// TLSEnabled specifies whether TLS support should be enabled on node or not
|
|
|
|
// TLS support is only planned in go-ethereum, so we are using our own patch.
|
|
|
|
TLSEnabled bool
|
|
|
|
|
|
|
|
// MaxPeers is the maximum number of (global) peers that can be connected.
|
|
|
|
// Set to zero, if only static or trusted peers are allowed to connect.
|
|
|
|
MaxPeers int
|
|
|
|
|
|
|
|
// MaxPendingPeers is the maximum number of peers that can be pending in the
|
|
|
|
// handshake phase, counted separately for inbound and outbound connections.
|
|
|
|
MaxPendingPeers int
|
|
|
|
|
2017-03-18 19:00:40 +00:00
|
|
|
// LogFile is filename where exposed logs get written to
|
|
|
|
LogFile string
|
|
|
|
|
2017-05-02 14:30:11 +00:00
|
|
|
// LogLevel defines minimum log level. Valid names are "ERROR", "WARNING", "INFO", "DEBUG", and "TRACE".
|
2017-08-10 15:31:29 +00:00
|
|
|
LogLevel string `validate:"eq=ERROR|eq=WARNING|eq=INFO|eq=DEBUG|eq=TRACE"`
|
2017-03-18 19:00:40 +00:00
|
|
|
|
2017-05-02 14:30:11 +00:00
|
|
|
// LogToStderr defines whether logged info should also be output to os.Stderr
|
|
|
|
LogToStderr bool
|
2017-03-15 21:03:01 +00:00
|
|
|
|
2017-08-15 10:27:12 +00:00
|
|
|
// UpstreamConfig extra config for providing upstream infura server.
|
|
|
|
UpstreamConfig UpstreamRPCConfig `json:"UpstreamConfig"`
|
|
|
|
|
2017-05-11 13:20:27 +00:00
|
|
|
// BootClusterConfig extra configuration for supporting cluster
|
2017-08-10 15:31:29 +00:00
|
|
|
BootClusterConfig *BootClusterConfig `json:"BootClusterConfig," validate:"structonly"`
|
2017-05-11 13:20:27 +00:00
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// LightEthConfig extra configuration for LES
|
2017-08-10 15:31:29 +00:00
|
|
|
LightEthConfig *LightEthConfig `json:"LightEthConfig," validate:"structonly"`
|
2017-03-15 21:03:01 +00:00
|
|
|
|
|
|
|
// WhisperConfig extra configuration for SHH
|
2017-08-10 15:31:29 +00:00
|
|
|
WhisperConfig *WhisperConfig `json:"WhisperConfig," validate:"structonly"`
|
2017-03-15 21:03:01 +00:00
|
|
|
|
|
|
|
// SwarmConfig extra configuration for Swarm and ENS
|
2017-08-10 15:31:29 +00:00
|
|
|
SwarmConfig *SwarmConfig `json:"SwarmConfig," validate:"structonly"`
|
2017-03-15 21:03:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewNodeConfig creates new node configuration object
|
2017-05-16 03:24:56 +00:00
|
|
|
func NewNodeConfig(dataDir string, networkID uint64, devMode bool) (*NodeConfig, error) {
|
2017-03-15 21:03:01 +00:00
|
|
|
nodeConfig := &NodeConfig{
|
2017-05-16 03:24:56 +00:00
|
|
|
DevMode: devMode,
|
2017-05-03 14:24:48 +00:00
|
|
|
NetworkID: networkID,
|
2017-03-15 21:03:01 +00:00
|
|
|
DataDir: dataDir,
|
2017-04-09 22:16:05 +00:00
|
|
|
Name: ClientIdentifier,
|
2017-03-15 21:03:01 +00:00
|
|
|
Version: Version,
|
2017-07-13 06:54:10 +00:00
|
|
|
RPCEnabled: RPCEnabledDefault,
|
2017-04-09 22:16:05 +00:00
|
|
|
HTTPHost: HTTPHost,
|
|
|
|
HTTPPort: HTTPPort,
|
2017-12-04 16:11:14 +00:00
|
|
|
ListenAddr: ListenAddr,
|
2017-08-04 16:14:17 +00:00
|
|
|
APIModules: APIModules,
|
2017-04-09 22:16:05 +00:00
|
|
|
WSHost: WSHost,
|
|
|
|
WSPort: WSPort,
|
|
|
|
MaxPeers: MaxPeers,
|
|
|
|
MaxPendingPeers: MaxPendingPeers,
|
|
|
|
IPCFile: IPCFile,
|
|
|
|
LogFile: LogFile,
|
|
|
|
LogLevel: LogLevel,
|
2017-05-02 14:30:11 +00:00
|
|
|
LogToStderr: LogToStderr,
|
2017-05-11 13:20:27 +00:00
|
|
|
BootClusterConfig: &BootClusterConfig{
|
2017-08-04 16:14:17 +00:00
|
|
|
Enabled: true,
|
|
|
|
BootNodes: []string{},
|
|
|
|
},
|
|
|
|
LightEthConfig: &LightEthConfig{
|
|
|
|
Enabled: true,
|
|
|
|
DatabaseCache: DatabaseCache,
|
2017-05-11 13:20:27 +00:00
|
|
|
},
|
2017-03-28 09:04:52 +00:00
|
|
|
WhisperConfig: &WhisperConfig{
|
2017-04-09 22:16:05 +00:00
|
|
|
Enabled: true,
|
|
|
|
MinimumPoW: WhisperMinimumPoW,
|
|
|
|
TTL: WhisperTTL,
|
2017-04-12 18:26:54 +00:00
|
|
|
FirebaseConfig: &FirebaseConfig{
|
|
|
|
NotificationTriggerURL: FirebaseNotificationTriggerURL,
|
|
|
|
},
|
2017-03-28 09:04:52 +00:00
|
|
|
},
|
|
|
|
SwarmConfig: &SwarmConfig{},
|
2017-03-15 21:03:01 +00:00
|
|
|
}
|
|
|
|
|
2017-05-16 03:24:56 +00:00
|
|
|
// adjust dependent values
|
|
|
|
if err := nodeConfig.updateConfig(); err != nil {
|
2017-05-02 14:30:11 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2017-03-15 21:03:01 +00:00
|
|
|
|
|
|
|
return nodeConfig, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// LoadNodeConfig parses incoming JSON and returned it as Config
|
|
|
|
func LoadNodeConfig(configJSON string) (*NodeConfig, error) {
|
2017-08-10 15:31:29 +00:00
|
|
|
nodeConfig, err := loadNodeConfig(configJSON)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := nodeConfig.Validate(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nodeConfig, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func loadNodeConfig(configJSON string) (*NodeConfig, error) {
|
2017-05-16 03:24:56 +00:00
|
|
|
nodeConfig, err := NewNodeConfig("", 0, true)
|
2017-03-15 21:03:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
decoder := json.NewDecoder(strings.NewReader(configJSON))
|
|
|
|
|
|
|
|
// override default configuration with values by JSON input
|
|
|
|
if err := decoder.Decode(&nodeConfig); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// repopulate
|
2017-05-16 03:24:56 +00:00
|
|
|
if err := nodeConfig.updateConfig(); err != nil {
|
2017-05-02 14:30:11 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2017-03-15 21:03:01 +00:00
|
|
|
|
2017-08-10 15:31:29 +00:00
|
|
|
return nodeConfig, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Validate checks if NodeConfig fields have valid values.
|
|
|
|
//
|
|
|
|
// It returns nil if there are no errors, otherwise one or more errors
|
|
|
|
// can be returned. Multiple errors are joined with a new line.
|
|
|
|
//
|
|
|
|
// A single error for a struct:
|
|
|
|
//
|
|
|
|
// type TestStruct struct {
|
|
|
|
// TestField string `validate:"required"`
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// has the following format:
|
|
|
|
//
|
|
|
|
// Key: 'TestStruct.TestField' Error:Field validation for 'TestField' failed on the 'required' tag
|
|
|
|
//
|
|
|
|
func (c *NodeConfig) Validate() error {
|
|
|
|
validate := NewValidator()
|
|
|
|
|
|
|
|
if err := validate.Struct(c); err != nil {
|
|
|
|
return err
|
2017-03-15 21:03:01 +00:00
|
|
|
}
|
|
|
|
|
2017-08-10 15:31:29 +00:00
|
|
|
if c.BootClusterConfig.Enabled {
|
|
|
|
if err := validate.Struct(c.BootClusterConfig); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-03-15 21:03:01 +00:00
|
|
|
}
|
|
|
|
|
2017-08-10 15:31:29 +00:00
|
|
|
if c.LightEthConfig.Enabled {
|
|
|
|
if err := validate.Struct(c.LightEthConfig); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if c.WhisperConfig.Enabled {
|
|
|
|
if err := validate.Struct(c.WhisperConfig); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if c.SwarmConfig.Enabled {
|
|
|
|
if err := validate.Struct(c.SwarmConfig); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2017-03-15 21:03:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Save dumps configuration to the disk
|
|
|
|
func (c *NodeConfig) Save() error {
|
|
|
|
data, err := json.MarshalIndent(c, "", " ")
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := os.MkdirAll(c.DataDir, os.ModePerm); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
configFilePath := filepath.Join(c.DataDir, "config.json")
|
|
|
|
if err := ioutil.WriteFile(configFilePath, data, os.ModePerm); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-05-02 14:30:11 +00:00
|
|
|
log.Info(fmt.Sprintf("config file saved: %v", configFilePath))
|
2017-03-15 21:03:01 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-05-16 03:24:56 +00:00
|
|
|
// updateConfig traverses configuration and adjusts dependent fields
|
|
|
|
// (we have a development/production and mobile/full node dependent configurations)
|
|
|
|
func (c *NodeConfig) updateConfig() error {
|
|
|
|
if err := c.updateGenesisConfig(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-08-15 10:27:12 +00:00
|
|
|
|
|
|
|
if err := c.updateUpstreamConfig(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-05-16 03:24:56 +00:00
|
|
|
if err := c.updateBootClusterConfig(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-08-15 10:27:12 +00:00
|
|
|
|
2017-05-16 03:24:56 +00:00
|
|
|
if err := c.updateRelativeDirsConfig(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// updateGenesisConfig does necessary adjustments to config object (depending on network node will be running on)
|
|
|
|
func (c *NodeConfig) updateGenesisConfig() error {
|
|
|
|
var genesis *core.Genesis
|
|
|
|
|
|
|
|
switch c.NetworkID {
|
|
|
|
case MainNetworkID:
|
|
|
|
genesis = core.DefaultGenesisBlock()
|
|
|
|
case RopstenNetworkID:
|
|
|
|
genesis = core.DefaultTestnetGenesisBlock()
|
|
|
|
case RinkebyNetworkID:
|
|
|
|
genesis = core.DefaultRinkebyGenesisBlock()
|
2017-10-16 21:54:56 +00:00
|
|
|
case StatusChainNetworkID:
|
|
|
|
var err error
|
|
|
|
genesis, err = c.DefaultStatusChainGenesisBlock()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-05-16 03:24:56 +00:00
|
|
|
default:
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// encode the genesis into JSON
|
|
|
|
enc, err := json.Marshal(genesis)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
c.LightEthConfig.Genesis = string(enc)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-10-16 21:54:56 +00:00
|
|
|
// DefaultStatusChainGenesisBlock returns the StatusChain network genesis block.
|
|
|
|
func (c *NodeConfig) DefaultStatusChainGenesisBlock() (*core.Genesis, error) {
|
|
|
|
genesisJSON, err := static.Asset("config/status-chain-genesis.json")
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("status-chain-genesis.json could not be loaded: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
var genesis *core.Genesis
|
2017-10-20 09:06:22 +00:00
|
|
|
err = json.Unmarshal(genesisJSON, &genesis)
|
|
|
|
if err != nil {
|
2017-10-16 21:54:56 +00:00
|
|
|
return nil, fmt.Errorf("cannot unmarshal status-chain-genesis.json: %s", err)
|
|
|
|
}
|
|
|
|
return genesis, nil
|
|
|
|
}
|
|
|
|
|
2017-08-15 10:27:12 +00:00
|
|
|
// updateUpstreamConfig sets the proper UpstreamConfig.URL for the network id being used.
|
|
|
|
func (c *NodeConfig) updateUpstreamConfig() error {
|
|
|
|
|
|
|
|
// If we have a URL already set then keep URL incase
|
|
|
|
// of custom server.
|
|
|
|
if c.UpstreamConfig.URL != "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
switch c.NetworkID {
|
|
|
|
case MainNetworkID:
|
2017-10-25 12:08:33 +00:00
|
|
|
c.UpstreamConfig.URL = MainnetEthereumNetworkURL
|
2017-08-15 10:27:12 +00:00
|
|
|
case RopstenNetworkID:
|
2017-10-25 12:08:33 +00:00
|
|
|
c.UpstreamConfig.URL = RopstenEthereumNetworkURL
|
2017-08-15 10:27:12 +00:00
|
|
|
case RinkebyNetworkID:
|
2017-10-25 12:08:33 +00:00
|
|
|
c.UpstreamConfig.URL = RinkebyEthereumNetworkURL
|
2017-08-15 10:27:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-08-04 16:14:17 +00:00
|
|
|
// updateBootClusterConfig loads boot nodes and CHT for a given network and mode.
|
|
|
|
// This is necessary until we have LES protocol support CHT sync, and better node
|
|
|
|
// discovery on mobile devices)
|
2017-05-16 03:24:56 +00:00
|
|
|
func (c *NodeConfig) updateBootClusterConfig() error {
|
2017-08-04 16:14:17 +00:00
|
|
|
if !c.BootClusterConfig.Enabled {
|
|
|
|
return nil
|
2017-05-16 03:24:56 +00:00
|
|
|
}
|
2017-07-13 06:54:10 +00:00
|
|
|
|
2017-08-04 16:14:17 +00:00
|
|
|
// TODO: Remove this thing as this is an ugly hack.
|
|
|
|
// Once CHT sync sub-protocol is working in LES, we will rely on it, as it provides
|
|
|
|
// decentralized solution. For now, in order to avoid forcing users to long sync times
|
|
|
|
// we use central static resource
|
|
|
|
type subClusterConfig struct {
|
|
|
|
Number int `json:"number"`
|
|
|
|
Hash string `json:"hash"`
|
|
|
|
BootNodes []string `json:"bootnodes"`
|
2017-05-16 03:24:56 +00:00
|
|
|
}
|
2017-08-04 16:14:17 +00:00
|
|
|
type clusterConfig struct {
|
|
|
|
NetworkID int `json:"networkID"`
|
|
|
|
GenesisHash string `json:"genesisHash"`
|
|
|
|
Prod subClusterConfig `json:"prod"`
|
|
|
|
Dev subClusterConfig `json:"dev"`
|
2017-05-16 03:24:56 +00:00
|
|
|
}
|
|
|
|
|
2017-08-25 09:56:54 +00:00
|
|
|
chtFile, err := static.Asset("config/cht.json")
|
2017-08-04 16:14:17 +00:00
|
|
|
if err != nil {
|
2017-08-25 09:56:54 +00:00
|
|
|
return fmt.Errorf("cht.json could not be loaded: %s", err)
|
2017-08-04 16:14:17 +00:00
|
|
|
}
|
2017-05-16 03:24:56 +00:00
|
|
|
|
2017-08-04 16:14:17 +00:00
|
|
|
var clusters []clusterConfig
|
2017-08-25 09:56:54 +00:00
|
|
|
err = json.Unmarshal(chtFile, &clusters)
|
2017-08-04 16:14:17 +00:00
|
|
|
if err != nil {
|
2017-08-25 09:56:54 +00:00
|
|
|
return fmt.Errorf("failed to unmarshal cht.json: %s", err)
|
2017-08-04 16:14:17 +00:00
|
|
|
}
|
2017-07-13 06:54:10 +00:00
|
|
|
|
2017-08-04 16:14:17 +00:00
|
|
|
for _, cluster := range clusters {
|
|
|
|
if cluster.NetworkID == int(c.NetworkID) {
|
|
|
|
c.BootClusterConfig.RootNumber = cluster.Prod.Number
|
|
|
|
c.BootClusterConfig.RootHash = cluster.Prod.Hash
|
|
|
|
c.BootClusterConfig.BootNodes = cluster.Prod.BootNodes
|
|
|
|
if c.DevMode {
|
|
|
|
c.BootClusterConfig.RootNumber = cluster.Dev.Number
|
|
|
|
c.BootClusterConfig.RootHash = cluster.Dev.Hash
|
|
|
|
c.BootClusterConfig.BootNodes = cluster.Dev.BootNodes
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
2017-05-16 03:24:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// updateRelativeDirsConfig updates directories that should be wrt to DataDir
|
|
|
|
func (c *NodeConfig) updateRelativeDirsConfig() error {
|
|
|
|
makeSubDirPath := func(baseDir, subDir string) string {
|
|
|
|
if len(baseDir) == 0 {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
return filepath.Join(baseDir, subDir)
|
|
|
|
}
|
|
|
|
if len(c.KeyStoreDir) == 0 {
|
|
|
|
c.KeyStoreDir = makeSubDirPath(c.DataDir, KeyStoreDir)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(c.WhisperConfig.DataDir) == 0 {
|
|
|
|
c.WhisperConfig.DataDir = makeSubDirPath(c.DataDir, WhisperDataDir)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-03-15 21:03:01 +00:00
|
|
|
// String dumps config object as nicely indented JSON
|
|
|
|
func (c *NodeConfig) String() string {
|
|
|
|
data, _ := json.MarshalIndent(c, "", " ")
|
|
|
|
return string(data)
|
|
|
|
}
|