2015-11-05 15:57:57 -06:00
|
|
|
// Copyright 2015 The go-ethereum Authors
|
|
|
|
// This file is part of the go-ethereum library.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
package node
|
|
|
|
|
|
|
|
import (
|
2020-04-27 04:16:00 -05:00
|
|
|
"context"
|
2015-11-05 15:57:57 -06:00
|
|
|
"errors"
|
2017-02-22 06:10:07 -06:00
|
|
|
"fmt"
|
2016-02-02 11:06:43 -06:00
|
|
|
"net"
|
2020-04-27 04:16:00 -05:00
|
|
|
"net/http"
|
2015-11-05 15:57:57 -06:00
|
|
|
"os"
|
|
|
|
"path/filepath"
|
2015-11-17 10:33:25 -06:00
|
|
|
"reflect"
|
2016-08-18 06:28:17 -05:00
|
|
|
"strings"
|
2015-11-05 15:57:57 -06:00
|
|
|
"sync"
|
|
|
|
|
2016-08-15 11:38:32 -05:00
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
2018-09-24 07:57:49 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
2016-08-18 06:28:17 -05:00
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2015-11-05 15:57:57 -06:00
|
|
|
"github.com/ethereum/go-ethereum/event"
|
2016-01-26 07:39:21 -06:00
|
|
|
"github.com/ethereum/go-ethereum/internal/debug"
|
2017-02-22 06:10:07 -06:00
|
|
|
"github.com/ethereum/go-ethereum/log"
|
2015-11-05 15:57:57 -06:00
|
|
|
"github.com/ethereum/go-ethereum/p2p"
|
2015-12-16 03:58:01 -06:00
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
2019-04-04 08:59:18 -05:00
|
|
|
"github.com/prometheus/tsdb/fileutil"
|
2015-11-05 15:57:57 -06:00
|
|
|
)
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
// Node is a container on which services can be registered.
|
2015-11-05 15:57:57 -06:00
|
|
|
type Node struct {
|
2015-11-17 10:33:25 -06:00
|
|
|
eventmux *event.TypeMux // Event multiplexer used between the services of a stack
|
2016-08-18 06:28:17 -05:00
|
|
|
config *Config
|
|
|
|
accman *accounts.Manager
|
2015-11-05 15:57:57 -06:00
|
|
|
|
2019-04-04 08:59:18 -05:00
|
|
|
ephemeralKeystore string // if non-empty, the key directory that will be removed by Stop
|
|
|
|
instanceDirLock fileutil.Releaser // prevents concurrent use of instance directory
|
2016-08-15 11:38:32 -05:00
|
|
|
|
2016-05-18 04:31:00 -05:00
|
|
|
serverConfig p2p.Config
|
2015-11-17 10:33:25 -06:00
|
|
|
server *p2p.Server // Currently running P2P networking layer
|
2015-11-05 15:57:57 -06:00
|
|
|
|
2015-11-26 10:35:44 -06:00
|
|
|
serviceFuncs []ServiceConstructor // Service constructors (in dependency order)
|
|
|
|
services map[reflect.Type]Service // Currently running services
|
2015-11-17 10:33:25 -06:00
|
|
|
|
2016-02-09 06:10:40 -06:00
|
|
|
rpcAPIs []rpc.API // List of APIs currently provided by the node
|
|
|
|
inprocHandler *rpc.Server // In-process RPC request handler to process the API requests
|
|
|
|
|
2016-02-02 11:06:43 -06:00
|
|
|
ipcEndpoint string // IPC endpoint to listen at (empty = IPC disabled)
|
|
|
|
ipcListener net.Listener // IPC RPC listener socket to serve API requests
|
|
|
|
ipcHandler *rpc.Server // IPC RPC request handler to process the API requests
|
|
|
|
|
2020-04-27 04:16:00 -05:00
|
|
|
httpEndpoint string // HTTP endpoint (interface + port) to listen at (empty = HTTP disabled)
|
|
|
|
httpWhitelist []string // HTTP RPC modules to allow through this endpoint
|
|
|
|
httpListenerAddr net.Addr // Address of HTTP RPC listener socket serving API requests
|
|
|
|
httpServer *http.Server // HTTP RPC HTTP server
|
|
|
|
httpHandler *rpc.Server // HTTP RPC request handler to process the API requests
|
2016-02-05 05:45:36 -06:00
|
|
|
|
2020-04-27 04:16:00 -05:00
|
|
|
wsEndpoint string // WebSocket endpoint (interface + port) to listen at (empty = WebSocket disabled)
|
|
|
|
wsListenerAddr net.Addr // Address of WebSocket RPC listener socket serving API requests
|
|
|
|
wsHTTPServer *http.Server // WebSocket RPC HTTP server
|
|
|
|
wsHandler *rpc.Server // WebSocket RPC request handler to process the API requests
|
2016-02-05 07:08:48 -06:00
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
stop chan struct{} // Channel to wait for termination notifications
|
2015-11-05 15:57:57 -06:00
|
|
|
lock sync.RWMutex
|
2017-12-01 05:49:04 -06:00
|
|
|
|
|
|
|
log log.Logger
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// New creates a new P2P node, ready for protocol registration.
|
|
|
|
func New(conf *Config) (*Node, error) {
|
2016-08-18 06:28:17 -05:00
|
|
|
// Copy config and resolve the datadir so future changes to the current
|
|
|
|
// working directory don't affect the node.
|
|
|
|
confCopy := *conf
|
|
|
|
conf = &confCopy
|
2015-11-05 15:57:57 -06:00
|
|
|
if conf.DataDir != "" {
|
2016-08-18 06:28:17 -05:00
|
|
|
absdatadir, err := filepath.Abs(conf.DataDir)
|
|
|
|
if err != nil {
|
2015-11-05 15:57:57 -06:00
|
|
|
return nil, err
|
|
|
|
}
|
2016-08-18 06:28:17 -05:00
|
|
|
conf.DataDir = absdatadir
|
|
|
|
}
|
|
|
|
// Ensure that the instance name doesn't cause weird conflicts with
|
|
|
|
// other files in the data directory.
|
|
|
|
if strings.ContainsAny(conf.Name, `/\`) {
|
|
|
|
return nil, errors.New(`Config.Name must not contain '/' or '\'`)
|
|
|
|
}
|
|
|
|
if conf.Name == datadirDefaultKeyStore {
|
|
|
|
return nil, errors.New(`Config.Name cannot be "` + datadirDefaultKeyStore + `"`)
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
2016-08-18 06:28:17 -05:00
|
|
|
if strings.HasSuffix(conf.Name, ".ipc") {
|
|
|
|
return nil, errors.New(`Config.Name cannot end in ".ipc"`)
|
|
|
|
}
|
|
|
|
// Ensure that the AccountManager method works before the node has started.
|
|
|
|
// We rely on this in cmd/geth.
|
2016-08-15 11:38:32 -05:00
|
|
|
am, ephemeralKeystore, err := makeAccountManager(conf)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2017-12-01 05:49:04 -06:00
|
|
|
if conf.Logger == nil {
|
|
|
|
conf.Logger = log.New()
|
|
|
|
}
|
2016-08-18 06:28:17 -05:00
|
|
|
// Note: any interaction with Config that would create/touch files
|
|
|
|
// in the data directory or instance directory is delayed until Start.
|
2015-11-05 15:57:57 -06:00
|
|
|
return &Node{
|
2016-08-15 11:38:32 -05:00
|
|
|
accman: am,
|
|
|
|
ephemeralKeystore: ephemeralKeystore,
|
2016-08-18 06:28:17 -05:00
|
|
|
config: conf,
|
|
|
|
serviceFuncs: []ServiceConstructor{},
|
|
|
|
ipcEndpoint: conf.IPCEndpoint(),
|
|
|
|
httpEndpoint: conf.HTTPEndpoint(),
|
|
|
|
wsEndpoint: conf.WSEndpoint(),
|
|
|
|
eventmux: new(event.TypeMux),
|
2017-12-01 05:49:04 -06:00
|
|
|
log: conf.Logger,
|
2015-11-05 15:57:57 -06:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2019-02-07 04:40:36 -06:00
|
|
|
// Close stops the Node and releases resources acquired in
|
|
|
|
// Node constructor New.
|
|
|
|
func (n *Node) Close() error {
|
|
|
|
var errs []error
|
|
|
|
|
|
|
|
// Terminate all subsystems and collect any errors
|
|
|
|
if err := n.Stop(); err != nil && err != ErrNodeStopped {
|
|
|
|
errs = append(errs, err)
|
|
|
|
}
|
|
|
|
if err := n.accman.Close(); err != nil {
|
|
|
|
errs = append(errs, err)
|
|
|
|
}
|
|
|
|
// Report any errors that might have occurred
|
|
|
|
switch len(errs) {
|
|
|
|
case 0:
|
|
|
|
return nil
|
|
|
|
case 1:
|
|
|
|
return errs[0]
|
|
|
|
default:
|
|
|
|
return fmt.Errorf("%v", errs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 10:35:44 -06:00
|
|
|
// Register injects a new service into the node's stack. The service created by
|
|
|
|
// the passed constructor must be unique in its type with regard to sibling ones.
|
|
|
|
func (n *Node) Register(constructor ServiceConstructor) error {
|
2015-11-05 15:57:57 -06:00
|
|
|
n.lock.Lock()
|
|
|
|
defer n.lock.Unlock()
|
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
if n.server != nil {
|
2015-11-05 15:57:57 -06:00
|
|
|
return ErrNodeRunning
|
|
|
|
}
|
2015-11-26 10:35:44 -06:00
|
|
|
n.serviceFuncs = append(n.serviceFuncs, constructor)
|
2015-11-05 15:57:57 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-03-27 07:52:53 -05:00
|
|
|
// Start creates a live P2P node and starts running it.
|
2015-11-05 15:57:57 -06:00
|
|
|
func (n *Node) Start() error {
|
|
|
|
n.lock.Lock()
|
|
|
|
defer n.lock.Unlock()
|
|
|
|
|
|
|
|
// Short circuit if the node's already running
|
2015-11-17 10:33:25 -06:00
|
|
|
if n.server != nil {
|
2015-11-05 15:57:57 -06:00
|
|
|
return ErrNodeRunning
|
|
|
|
}
|
2016-08-18 06:28:17 -05:00
|
|
|
if err := n.openDataDir(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the p2p server. This creates the node key and
|
|
|
|
// discovery databases.
|
2017-04-12 09:27:23 -05:00
|
|
|
n.serverConfig = n.config.P2P
|
|
|
|
n.serverConfig.PrivateKey = n.config.NodeKey()
|
|
|
|
n.serverConfig.Name = n.config.NodeName()
|
2017-12-01 05:49:04 -06:00
|
|
|
n.serverConfig.Logger = n.log
|
2017-04-12 09:27:23 -05:00
|
|
|
if n.serverConfig.StaticNodes == nil {
|
|
|
|
n.serverConfig.StaticNodes = n.config.StaticNodes()
|
|
|
|
}
|
|
|
|
if n.serverConfig.TrustedNodes == nil {
|
2017-07-18 03:58:46 -05:00
|
|
|
n.serverConfig.TrustedNodes = n.config.TrustedNodes()
|
2017-04-12 09:27:23 -05:00
|
|
|
}
|
|
|
|
if n.serverConfig.NodeDatabase == "" {
|
|
|
|
n.serverConfig.NodeDatabase = n.config.NodeDB()
|
2016-08-18 06:28:17 -05:00
|
|
|
}
|
2016-05-18 04:31:00 -05:00
|
|
|
running := &p2p.Server{Config: n.serverConfig}
|
2017-12-01 05:49:04 -06:00
|
|
|
n.log.Info("Starting peer-to-peer node", "instance", n.serverConfig.Name)
|
2016-08-18 06:28:17 -05:00
|
|
|
|
|
|
|
// Otherwise copy and specialize the P2P configuration
|
2015-11-26 10:35:44 -06:00
|
|
|
services := make(map[reflect.Type]Service)
|
|
|
|
for _, constructor := range n.serviceFuncs {
|
2015-11-17 10:33:25 -06:00
|
|
|
// Create a new context for the particular service
|
|
|
|
ctx := &ServiceContext{
|
2020-02-13 07:38:30 -06:00
|
|
|
Config: *n.config,
|
2016-08-15 11:38:32 -05:00
|
|
|
services: make(map[reflect.Type]Service),
|
|
|
|
EventMux: n.eventmux,
|
|
|
|
AccountManager: n.accman,
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2015-11-26 10:35:44 -06:00
|
|
|
for kind, s := range services { // copy needed for threaded access
|
|
|
|
ctx.services[kind] = s
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
// Construct and save the service
|
2015-11-05 15:57:57 -06:00
|
|
|
service, err := constructor(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2015-11-26 10:35:44 -06:00
|
|
|
kind := reflect.TypeOf(service)
|
|
|
|
if _, exists := services[kind]; exists {
|
|
|
|
return &DuplicateServiceError{Kind: kind}
|
|
|
|
}
|
|
|
|
services[kind] = service
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
|
|
|
// Gather the protocols and start the freshly assembled P2P server
|
|
|
|
for _, service := range services {
|
|
|
|
running.Protocols = append(running.Protocols, service.Protocols()...)
|
|
|
|
}
|
|
|
|
if err := running.Start(); err != nil {
|
2017-08-18 05:14:00 -05:00
|
|
|
return convertFileLockError(err)
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
|
|
|
// Start each of the services
|
2019-02-18 05:31:22 -06:00
|
|
|
var started []reflect.Type
|
2015-11-26 10:35:44 -06:00
|
|
|
for kind, service := range services {
|
2015-11-05 15:57:57 -06:00
|
|
|
// Start the next service, stopping all previous upon failure
|
2015-11-17 10:33:25 -06:00
|
|
|
if err := service.Start(running); err != nil {
|
2015-11-26 10:35:44 -06:00
|
|
|
for _, kind := range started {
|
|
|
|
services[kind].Stop()
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
2015-11-17 10:33:25 -06:00
|
|
|
running.Stop()
|
|
|
|
|
2015-11-05 15:57:57 -06:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
// Mark the service started for potential cleanup
|
2015-11-26 10:35:44 -06:00
|
|
|
started = append(started, kind)
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
2020-03-27 07:52:53 -05:00
|
|
|
// Lastly, start the configured RPC interfaces
|
2016-02-02 11:06:43 -06:00
|
|
|
if err := n.startRPC(services); err != nil {
|
|
|
|
for _, service := range services {
|
|
|
|
service.Stop()
|
|
|
|
}
|
|
|
|
running.Stop()
|
|
|
|
return err
|
|
|
|
}
|
2015-11-05 15:57:57 -06:00
|
|
|
// Finish initializing the startup
|
|
|
|
n.services = services
|
2015-11-17 10:33:25 -06:00
|
|
|
n.server = running
|
|
|
|
n.stop = make(chan struct{})
|
2015-11-05 15:57:57 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-04-04 06:03:10 -05:00
|
|
|
// Config returns the configuration of node.
|
|
|
|
func (n *Node) Config() *Config {
|
|
|
|
return n.config
|
|
|
|
}
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
func (n *Node) openDataDir() error {
|
|
|
|
if n.config.DataDir == "" {
|
|
|
|
return nil // ephemeral
|
|
|
|
}
|
|
|
|
|
|
|
|
instdir := filepath.Join(n.config.DataDir, n.config.name())
|
|
|
|
if err := os.MkdirAll(instdir, 0700); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-08-18 05:14:00 -05:00
|
|
|
// Lock the instance directory to prevent concurrent use by another instance as well as
|
|
|
|
// accidental use of the instance directory as a database.
|
2019-04-04 08:59:18 -05:00
|
|
|
release, _, err := fileutil.Flock(filepath.Join(instdir, "LOCK"))
|
2016-08-18 06:28:17 -05:00
|
|
|
if err != nil {
|
2017-08-18 05:14:00 -05:00
|
|
|
return convertFileLockError(err)
|
2016-08-18 06:28:17 -05:00
|
|
|
}
|
2017-08-18 05:14:00 -05:00
|
|
|
n.instanceDirLock = release
|
2016-08-18 06:28:17 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-03-27 07:52:53 -05:00
|
|
|
// startRPC is a helper method to start all the various RPC endpoints during node
|
2016-02-05 05:45:36 -06:00
|
|
|
// startup. It's not meant to be called at any time afterwards as it makes certain
|
|
|
|
// assumptions about the state of the node.
|
2016-02-02 11:06:43 -06:00
|
|
|
func (n *Node) startRPC(services map[reflect.Type]Service) error {
|
2016-02-05 05:45:36 -06:00
|
|
|
// Gather all the possible APIs to surface
|
2016-02-02 11:06:43 -06:00
|
|
|
apis := n.apis()
|
|
|
|
for _, service := range services {
|
|
|
|
apis = append(apis, service.APIs()...)
|
|
|
|
}
|
2016-02-05 05:45:36 -06:00
|
|
|
// Start the various API endpoints, terminating all in case of errors
|
2016-02-09 06:10:40 -06:00
|
|
|
if err := n.startInProc(apis); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-02-05 05:45:36 -06:00
|
|
|
if err := n.startIPC(apis); err != nil {
|
2016-02-09 06:10:40 -06:00
|
|
|
n.stopInProc()
|
2016-02-05 05:45:36 -06:00
|
|
|
return err
|
|
|
|
}
|
2020-04-08 06:33:12 -05:00
|
|
|
if err := n.startHTTP(n.httpEndpoint, apis, n.config.HTTPModules, n.config.HTTPCors, n.config.HTTPVirtualHosts, n.config.HTTPTimeouts, n.config.WSOrigins); err != nil {
|
2016-02-05 05:45:36 -06:00
|
|
|
n.stopIPC()
|
2016-02-09 06:10:40 -06:00
|
|
|
n.stopInProc()
|
2016-02-05 05:45:36 -06:00
|
|
|
return err
|
|
|
|
}
|
2020-04-08 06:33:12 -05:00
|
|
|
// if endpoints are not the same, start separate servers
|
|
|
|
if n.httpEndpoint != n.wsEndpoint {
|
|
|
|
if err := n.startWS(n.wsEndpoint, apis, n.config.WSModules, n.config.WSOrigins, n.config.WSExposeAll); err != nil {
|
|
|
|
n.stopHTTP()
|
|
|
|
n.stopIPC()
|
|
|
|
n.stopInProc()
|
|
|
|
return err
|
|
|
|
}
|
2016-02-05 07:08:48 -06:00
|
|
|
}
|
2020-04-08 06:33:12 -05:00
|
|
|
|
2016-02-05 05:45:36 -06:00
|
|
|
// All API endpoints started successfully
|
|
|
|
n.rpcAPIs = apis
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-02-09 06:10:40 -06:00
|
|
|
// startInProc initializes an in-process RPC endpoint.
|
|
|
|
func (n *Node) startInProc(apis []rpc.API) error {
|
|
|
|
// Register all the APIs exposed by the services
|
|
|
|
handler := rpc.NewServer()
|
|
|
|
for _, api := range apis {
|
|
|
|
if err := handler.RegisterName(api.Namespace, api.Service); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-10-20 03:43:59 -05:00
|
|
|
n.log.Debug("InProc registered", "namespace", api.Namespace)
|
2016-02-09 06:10:40 -06:00
|
|
|
}
|
|
|
|
n.inprocHandler = handler
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// stopInProc terminates the in-process RPC endpoint.
|
|
|
|
func (n *Node) stopInProc() {
|
|
|
|
if n.inprocHandler != nil {
|
|
|
|
n.inprocHandler.Stop()
|
|
|
|
n.inprocHandler = nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-05 05:45:36 -06:00
|
|
|
// startIPC initializes and starts the IPC RPC endpoint.
|
|
|
|
func (n *Node) startIPC(apis []rpc.API) error {
|
|
|
|
if n.ipcEndpoint == "" {
|
2018-04-18 05:27:20 -05:00
|
|
|
return nil // IPC disabled.
|
cmd/clef, signer: initial poc of the standalone signer (#16154)
* signer: introduce external signer command
* cmd/signer, rpc: Implement new signer. Add info about remote user to Context
* signer: refactored request/response, made use of urfave.cli
* cmd/signer: Use common flags
* cmd/signer: methods to validate calldata against abi
* cmd/signer: work on abi parser
* signer: add mutex around UI
* cmd/signer: add json 4byte directory, remove passwords from api
* cmd/signer: minor changes
* cmd/signer: Use ErrRequestDenied, enable lightkdf
* cmd/signer: implement tests
* cmd/signer: made possible for UI to modify tx parameters
* cmd/signer: refactors, removed channels in ui comms, added UI-api via stdin/out
* cmd/signer: Made lowercase json-definitions, added UI-signer test functionality
* cmd/signer: update documentation
* cmd/signer: fix bugs, improve abi detection, abi argument display
* cmd/signer: minor change in json format
* cmd/signer: rework json communication
* cmd/signer: implement mixcase addresses in API, fix json id bug
* cmd/signer: rename fromaccount, update pythonpoc with new json encoding format
* cmd/signer: make use of new abi interface
* signer: documentation
* signer/main: remove redundant option
* signer: implement audit logging
* signer: create package 'signer', minor changes
* common: add 0x-prefix to mixcaseaddress in json marshalling + validation
* signer, rules, storage: implement rules + ephemeral storage for signer rules
* signer: implement OnApprovedTx, change signing response (API BREAKAGE)
* signer: refactoring + documentation
* signer/rules: implement dispatching to next handler
* signer: docs
* signer/rules: hide json-conversion from users, ensure context is cleaned
* signer: docs
* signer: implement validation rules, change signature of call_info
* signer: fix log flaw with string pointer
* signer: implement custom 4byte databsae that saves submitted signatures
* signer/storage: implement aes-gcm-backed credential storage
* accounts: implement json unmarshalling of url
* signer: fix listresponse, fix gas->uint64
* node: make http/ipc start methods public
* signer: add ipc capability+review concerns
* accounts: correct docstring
* signer: address review concerns
* rpc: go fmt -s
* signer: review concerns+ baptize Clef
* signer,node: move Start-functions to separate file
* signer: formatting
2018-04-16 07:04:32 -05:00
|
|
|
}
|
2018-04-18 05:27:20 -05:00
|
|
|
listener, handler, err := rpc.StartIPCEndpoint(n.ipcEndpoint, apis)
|
cmd/clef, signer: initial poc of the standalone signer (#16154)
* signer: introduce external signer command
* cmd/signer, rpc: Implement new signer. Add info about remote user to Context
* signer: refactored request/response, made use of urfave.cli
* cmd/signer: Use common flags
* cmd/signer: methods to validate calldata against abi
* cmd/signer: work on abi parser
* signer: add mutex around UI
* cmd/signer: add json 4byte directory, remove passwords from api
* cmd/signer: minor changes
* cmd/signer: Use ErrRequestDenied, enable lightkdf
* cmd/signer: implement tests
* cmd/signer: made possible for UI to modify tx parameters
* cmd/signer: refactors, removed channels in ui comms, added UI-api via stdin/out
* cmd/signer: Made lowercase json-definitions, added UI-signer test functionality
* cmd/signer: update documentation
* cmd/signer: fix bugs, improve abi detection, abi argument display
* cmd/signer: minor change in json format
* cmd/signer: rework json communication
* cmd/signer: implement mixcase addresses in API, fix json id bug
* cmd/signer: rename fromaccount, update pythonpoc with new json encoding format
* cmd/signer: make use of new abi interface
* signer: documentation
* signer/main: remove redundant option
* signer: implement audit logging
* signer: create package 'signer', minor changes
* common: add 0x-prefix to mixcaseaddress in json marshalling + validation
* signer, rules, storage: implement rules + ephemeral storage for signer rules
* signer: implement OnApprovedTx, change signing response (API BREAKAGE)
* signer: refactoring + documentation
* signer/rules: implement dispatching to next handler
* signer: docs
* signer/rules: hide json-conversion from users, ensure context is cleaned
* signer: docs
* signer: implement validation rules, change signature of call_info
* signer: fix log flaw with string pointer
* signer: implement custom 4byte databsae that saves submitted signatures
* signer/storage: implement aes-gcm-backed credential storage
* accounts: implement json unmarshalling of url
* signer: fix listresponse, fix gas->uint64
* node: make http/ipc start methods public
* signer: add ipc capability+review concerns
* accounts: correct docstring
* signer: address review concerns
* rpc: go fmt -s
* signer: review concerns+ baptize Clef
* signer,node: move Start-functions to separate file
* signer: formatting
2018-04-16 07:04:32 -05:00
|
|
|
if err != nil {
|
2016-02-05 05:45:36 -06:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
n.ipcListener = listener
|
|
|
|
n.ipcHandler = handler
|
cmd/clef, signer: initial poc of the standalone signer (#16154)
* signer: introduce external signer command
* cmd/signer, rpc: Implement new signer. Add info about remote user to Context
* signer: refactored request/response, made use of urfave.cli
* cmd/signer: Use common flags
* cmd/signer: methods to validate calldata against abi
* cmd/signer: work on abi parser
* signer: add mutex around UI
* cmd/signer: add json 4byte directory, remove passwords from api
* cmd/signer: minor changes
* cmd/signer: Use ErrRequestDenied, enable lightkdf
* cmd/signer: implement tests
* cmd/signer: made possible for UI to modify tx parameters
* cmd/signer: refactors, removed channels in ui comms, added UI-api via stdin/out
* cmd/signer: Made lowercase json-definitions, added UI-signer test functionality
* cmd/signer: update documentation
* cmd/signer: fix bugs, improve abi detection, abi argument display
* cmd/signer: minor change in json format
* cmd/signer: rework json communication
* cmd/signer: implement mixcase addresses in API, fix json id bug
* cmd/signer: rename fromaccount, update pythonpoc with new json encoding format
* cmd/signer: make use of new abi interface
* signer: documentation
* signer/main: remove redundant option
* signer: implement audit logging
* signer: create package 'signer', minor changes
* common: add 0x-prefix to mixcaseaddress in json marshalling + validation
* signer, rules, storage: implement rules + ephemeral storage for signer rules
* signer: implement OnApprovedTx, change signing response (API BREAKAGE)
* signer: refactoring + documentation
* signer/rules: implement dispatching to next handler
* signer: docs
* signer/rules: hide json-conversion from users, ensure context is cleaned
* signer: docs
* signer: implement validation rules, change signature of call_info
* signer: fix log flaw with string pointer
* signer: implement custom 4byte databsae that saves submitted signatures
* signer/storage: implement aes-gcm-backed credential storage
* accounts: implement json unmarshalling of url
* signer: fix listresponse, fix gas->uint64
* node: make http/ipc start methods public
* signer: add ipc capability+review concerns
* accounts: correct docstring
* signer: address review concerns
* rpc: go fmt -s
* signer: review concerns+ baptize Clef
* signer,node: move Start-functions to separate file
* signer: formatting
2018-04-16 07:04:32 -05:00
|
|
|
n.log.Info("IPC endpoint opened", "url", n.ipcEndpoint)
|
2016-02-05 05:45:36 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// stopIPC terminates the IPC RPC endpoint.
|
|
|
|
func (n *Node) stopIPC() {
|
|
|
|
if n.ipcListener != nil {
|
|
|
|
n.ipcListener.Close()
|
|
|
|
n.ipcListener = nil
|
|
|
|
|
2018-11-20 08:16:40 -06:00
|
|
|
n.log.Info("IPC endpoint closed", "url", n.ipcEndpoint)
|
2016-02-05 05:45:36 -06:00
|
|
|
}
|
|
|
|
if n.ipcHandler != nil {
|
|
|
|
n.ipcHandler.Stop()
|
|
|
|
n.ipcHandler = nil
|
2016-02-02 11:06:43 -06:00
|
|
|
}
|
2016-02-05 05:45:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// startHTTP initializes and starts the HTTP RPC endpoint.
|
2020-04-08 06:33:12 -05:00
|
|
|
func (n *Node) startHTTP(endpoint string, apis []rpc.API, modules []string, cors []string, vhosts []string, timeouts rpc.HTTPTimeouts, wsOrigins []string) error {
|
2016-02-05 07:08:48 -06:00
|
|
|
// Short circuit if the HTTP endpoint isn't being exposed
|
2016-02-05 05:45:36 -06:00
|
|
|
if endpoint == "" {
|
|
|
|
return nil
|
|
|
|
}
|
2020-04-08 06:33:12 -05:00
|
|
|
// register apis and create handler stack
|
|
|
|
srv := rpc.NewServer()
|
|
|
|
err := RegisterApisFromWhitelist(apis, modules, srv, false)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
handler := NewHTTPHandlerStack(srv, cors, vhosts)
|
2020-04-27 04:16:00 -05:00
|
|
|
// wrap handler in WebSocket handler only if WebSocket port is the same as http rpc
|
2020-04-08 06:33:12 -05:00
|
|
|
if n.httpEndpoint == n.wsEndpoint {
|
|
|
|
handler = NewWebsocketUpgradeHandler(handler, srv.WebsocketHandler(wsOrigins))
|
|
|
|
}
|
2020-04-27 04:16:00 -05:00
|
|
|
httpServer, addr, err := StartHTTPEndpoint(endpoint, timeouts, handler)
|
cmd/clef, signer: initial poc of the standalone signer (#16154)
* signer: introduce external signer command
* cmd/signer, rpc: Implement new signer. Add info about remote user to Context
* signer: refactored request/response, made use of urfave.cli
* cmd/signer: Use common flags
* cmd/signer: methods to validate calldata against abi
* cmd/signer: work on abi parser
* signer: add mutex around UI
* cmd/signer: add json 4byte directory, remove passwords from api
* cmd/signer: minor changes
* cmd/signer: Use ErrRequestDenied, enable lightkdf
* cmd/signer: implement tests
* cmd/signer: made possible for UI to modify tx parameters
* cmd/signer: refactors, removed channels in ui comms, added UI-api via stdin/out
* cmd/signer: Made lowercase json-definitions, added UI-signer test functionality
* cmd/signer: update documentation
* cmd/signer: fix bugs, improve abi detection, abi argument display
* cmd/signer: minor change in json format
* cmd/signer: rework json communication
* cmd/signer: implement mixcase addresses in API, fix json id bug
* cmd/signer: rename fromaccount, update pythonpoc with new json encoding format
* cmd/signer: make use of new abi interface
* signer: documentation
* signer/main: remove redundant option
* signer: implement audit logging
* signer: create package 'signer', minor changes
* common: add 0x-prefix to mixcaseaddress in json marshalling + validation
* signer, rules, storage: implement rules + ephemeral storage for signer rules
* signer: implement OnApprovedTx, change signing response (API BREAKAGE)
* signer: refactoring + documentation
* signer/rules: implement dispatching to next handler
* signer: docs
* signer/rules: hide json-conversion from users, ensure context is cleaned
* signer: docs
* signer: implement validation rules, change signature of call_info
* signer: fix log flaw with string pointer
* signer: implement custom 4byte databsae that saves submitted signatures
* signer/storage: implement aes-gcm-backed credential storage
* accounts: implement json unmarshalling of url
* signer: fix listresponse, fix gas->uint64
* node: make http/ipc start methods public
* signer: add ipc capability+review concerns
* accounts: correct docstring
* signer: address review concerns
* rpc: go fmt -s
* signer: review concerns+ baptize Clef
* signer,node: move Start-functions to separate file
* signer: formatting
2018-04-16 07:04:32 -05:00
|
|
|
if err != nil {
|
2016-02-05 05:45:36 -06:00
|
|
|
return err
|
|
|
|
}
|
2020-04-27 04:16:00 -05:00
|
|
|
n.log.Info("HTTP endpoint opened", "url", fmt.Sprintf("http://%v/", addr),
|
2020-03-23 10:26:56 -05:00
|
|
|
"cors", strings.Join(cors, ","),
|
|
|
|
"vhosts", strings.Join(vhosts, ","))
|
2020-04-08 06:33:12 -05:00
|
|
|
if n.httpEndpoint == n.wsEndpoint {
|
2020-04-27 04:16:00 -05:00
|
|
|
n.log.Info("WebSocket endpoint opened", "url", fmt.Sprintf("ws://%v", addr))
|
2020-04-08 06:33:12 -05:00
|
|
|
}
|
2016-02-02 11:06:43 -06:00
|
|
|
// All listeners booted successfully
|
2016-02-05 05:45:36 -06:00
|
|
|
n.httpEndpoint = endpoint
|
2020-04-27 04:16:00 -05:00
|
|
|
n.httpListenerAddr = addr
|
|
|
|
n.httpServer = httpServer
|
2020-04-08 06:33:12 -05:00
|
|
|
n.httpHandler = srv
|
2016-02-02 11:06:43 -06:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-02-05 05:45:36 -06:00
|
|
|
// stopHTTP terminates the HTTP RPC endpoint.
|
|
|
|
func (n *Node) stopHTTP() {
|
2020-04-27 04:16:00 -05:00
|
|
|
if n.httpServer != nil {
|
|
|
|
// Don't bother imposing a timeout here.
|
|
|
|
n.httpServer.Shutdown(context.Background())
|
|
|
|
n.log.Info("HTTP endpoint closed", "url", fmt.Sprintf("http://%v/", n.httpListenerAddr))
|
2016-02-05 05:45:36 -06:00
|
|
|
}
|
|
|
|
if n.httpHandler != nil {
|
|
|
|
n.httpHandler.Stop()
|
|
|
|
n.httpHandler = nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-27 04:16:00 -05:00
|
|
|
// startWS initializes and starts the WebSocket RPC endpoint.
|
2017-09-25 03:08:07 -05:00
|
|
|
func (n *Node) startWS(endpoint string, apis []rpc.API, modules []string, wsOrigins []string, exposeAll bool) error {
|
2016-02-05 07:08:48 -06:00
|
|
|
// Short circuit if the WS endpoint isn't being exposed
|
|
|
|
if endpoint == "" {
|
|
|
|
return nil
|
|
|
|
}
|
2020-04-08 06:33:12 -05:00
|
|
|
|
|
|
|
srv := rpc.NewServer()
|
|
|
|
handler := srv.WebsocketHandler(wsOrigins)
|
|
|
|
err := RegisterApisFromWhitelist(apis, modules, srv, exposeAll)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-04-27 04:16:00 -05:00
|
|
|
httpServer, addr, err := startWSEndpoint(endpoint, handler)
|
cmd/clef, signer: initial poc of the standalone signer (#16154)
* signer: introduce external signer command
* cmd/signer, rpc: Implement new signer. Add info about remote user to Context
* signer: refactored request/response, made use of urfave.cli
* cmd/signer: Use common flags
* cmd/signer: methods to validate calldata against abi
* cmd/signer: work on abi parser
* signer: add mutex around UI
* cmd/signer: add json 4byte directory, remove passwords from api
* cmd/signer: minor changes
* cmd/signer: Use ErrRequestDenied, enable lightkdf
* cmd/signer: implement tests
* cmd/signer: made possible for UI to modify tx parameters
* cmd/signer: refactors, removed channels in ui comms, added UI-api via stdin/out
* cmd/signer: Made lowercase json-definitions, added UI-signer test functionality
* cmd/signer: update documentation
* cmd/signer: fix bugs, improve abi detection, abi argument display
* cmd/signer: minor change in json format
* cmd/signer: rework json communication
* cmd/signer: implement mixcase addresses in API, fix json id bug
* cmd/signer: rename fromaccount, update pythonpoc with new json encoding format
* cmd/signer: make use of new abi interface
* signer: documentation
* signer/main: remove redundant option
* signer: implement audit logging
* signer: create package 'signer', minor changes
* common: add 0x-prefix to mixcaseaddress in json marshalling + validation
* signer, rules, storage: implement rules + ephemeral storage for signer rules
* signer: implement OnApprovedTx, change signing response (API BREAKAGE)
* signer: refactoring + documentation
* signer/rules: implement dispatching to next handler
* signer: docs
* signer/rules: hide json-conversion from users, ensure context is cleaned
* signer: docs
* signer: implement validation rules, change signature of call_info
* signer: fix log flaw with string pointer
* signer: implement custom 4byte databsae that saves submitted signatures
* signer/storage: implement aes-gcm-backed credential storage
* accounts: implement json unmarshalling of url
* signer: fix listresponse, fix gas->uint64
* node: make http/ipc start methods public
* signer: add ipc capability+review concerns
* accounts: correct docstring
* signer: address review concerns
* rpc: go fmt -s
* signer: review concerns+ baptize Clef
* signer,node: move Start-functions to separate file
* signer: formatting
2018-04-16 07:04:32 -05:00
|
|
|
if err != nil {
|
2016-02-05 07:08:48 -06:00
|
|
|
return err
|
|
|
|
}
|
2020-04-27 04:16:00 -05:00
|
|
|
n.log.Info("WebSocket endpoint opened", "url", fmt.Sprintf("ws://%v", addr))
|
2016-02-05 07:08:48 -06:00
|
|
|
// All listeners booted successfully
|
|
|
|
n.wsEndpoint = endpoint
|
2020-04-27 04:16:00 -05:00
|
|
|
n.wsListenerAddr = addr
|
|
|
|
n.wsHTTPServer = httpServer
|
2020-04-08 06:33:12 -05:00
|
|
|
n.wsHandler = srv
|
2016-02-05 07:08:48 -06:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-04-27 04:16:00 -05:00
|
|
|
// stopWS terminates the WebSocket RPC endpoint.
|
2016-02-05 07:08:48 -06:00
|
|
|
func (n *Node) stopWS() {
|
2020-04-27 04:16:00 -05:00
|
|
|
if n.wsHTTPServer != nil {
|
|
|
|
// Don't bother imposing a timeout here.
|
|
|
|
n.wsHTTPServer.Shutdown(context.Background())
|
|
|
|
n.log.Info("WebSocket endpoint closed", "url", fmt.Sprintf("ws://%v", n.wsListenerAddr))
|
2016-02-05 07:08:48 -06:00
|
|
|
}
|
|
|
|
if n.wsHandler != nil {
|
|
|
|
n.wsHandler.Stop()
|
|
|
|
n.wsHandler = nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-05 15:57:57 -06:00
|
|
|
// Stop terminates a running node along with all it's services. In the node was
|
|
|
|
// not started, an error is returned.
|
|
|
|
func (n *Node) Stop() error {
|
|
|
|
n.lock.Lock()
|
|
|
|
defer n.lock.Unlock()
|
|
|
|
|
|
|
|
// Short circuit if the node's not running
|
2015-11-17 10:33:25 -06:00
|
|
|
if n.server == nil {
|
2015-11-05 15:57:57 -06:00
|
|
|
return ErrNodeStopped
|
|
|
|
}
|
2016-08-18 06:28:17 -05:00
|
|
|
|
|
|
|
// Terminate the API, services and the p2p server.
|
2016-02-05 07:08:48 -06:00
|
|
|
n.stopWS()
|
2016-02-05 05:45:36 -06:00
|
|
|
n.stopHTTP()
|
2016-02-05 07:08:48 -06:00
|
|
|
n.stopIPC()
|
2016-02-05 05:45:36 -06:00
|
|
|
n.rpcAPIs = nil
|
2015-11-05 15:57:57 -06:00
|
|
|
failure := &StopError{
|
2015-11-26 10:35:44 -06:00
|
|
|
Services: make(map[reflect.Type]error),
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
2015-11-26 10:35:44 -06:00
|
|
|
for kind, service := range n.services {
|
2015-11-05 15:57:57 -06:00
|
|
|
if err := service.Stop(); err != nil {
|
2015-11-26 10:35:44 -06:00
|
|
|
failure.Services[kind] = err
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
|
|
|
}
|
2015-11-17 10:33:25 -06:00
|
|
|
n.server.Stop()
|
2015-11-05 15:57:57 -06:00
|
|
|
n.services = nil
|
2015-11-17 10:33:25 -06:00
|
|
|
n.server = nil
|
2016-08-18 06:28:17 -05:00
|
|
|
|
|
|
|
// Release instance directory lock.
|
|
|
|
if n.instanceDirLock != nil {
|
2017-08-18 05:14:00 -05:00
|
|
|
if err := n.instanceDirLock.Release(); err != nil {
|
2017-12-01 05:49:04 -06:00
|
|
|
n.log.Error("Can't release datadir lock", "err", err)
|
2017-08-18 05:14:00 -05:00
|
|
|
}
|
2016-08-18 06:28:17 -05:00
|
|
|
n.instanceDirLock = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// unblock n.Wait
|
2015-11-17 10:33:25 -06:00
|
|
|
close(n.stop)
|
2015-11-05 15:57:57 -06:00
|
|
|
|
2016-08-15 11:38:32 -05:00
|
|
|
// Remove the keystore if it was created ephemerally.
|
|
|
|
var keystoreErr error
|
|
|
|
if n.ephemeralKeystore != "" {
|
|
|
|
keystoreErr = os.RemoveAll(n.ephemeralKeystore)
|
|
|
|
}
|
|
|
|
|
2015-11-05 15:57:57 -06:00
|
|
|
if len(failure.Services) > 0 {
|
|
|
|
return failure
|
|
|
|
}
|
2016-08-15 11:38:32 -05:00
|
|
|
if keystoreErr != nil {
|
|
|
|
return keystoreErr
|
|
|
|
}
|
2015-11-05 15:57:57 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
// Wait blocks the thread until the node is stopped. If the node is not running
|
|
|
|
// at the time of invocation, the method immediately returns.
|
|
|
|
func (n *Node) Wait() {
|
|
|
|
n.lock.RLock()
|
|
|
|
if n.server == nil {
|
2017-04-25 10:04:02 -05:00
|
|
|
n.lock.RUnlock()
|
2015-11-17 10:33:25 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
stop := n.stop
|
|
|
|
n.lock.RUnlock()
|
|
|
|
|
|
|
|
<-stop
|
|
|
|
}
|
|
|
|
|
2015-11-05 15:57:57 -06:00
|
|
|
// Restart terminates a running node and boots up a new one in its place. If the
|
|
|
|
// node isn't running, an error is returned.
|
|
|
|
func (n *Node) Restart() error {
|
|
|
|
if err := n.Stop(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err := n.Start(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-02-09 06:10:40 -06:00
|
|
|
// Attach creates an RPC client attached to an in-process API handler.
|
2016-07-12 10:47:15 -05:00
|
|
|
func (n *Node) Attach() (*rpc.Client, error) {
|
2016-02-09 06:10:40 -06:00
|
|
|
n.lock.RLock()
|
|
|
|
defer n.lock.RUnlock()
|
|
|
|
|
|
|
|
if n.server == nil {
|
|
|
|
return nil, ErrNodeStopped
|
|
|
|
}
|
2016-07-12 10:47:15 -05:00
|
|
|
return rpc.DialInProc(n.inprocHandler), nil
|
2016-02-09 06:10:40 -06:00
|
|
|
}
|
|
|
|
|
2017-09-25 03:08:07 -05:00
|
|
|
// RPCHandler returns the in-process RPC request handler.
|
|
|
|
func (n *Node) RPCHandler() (*rpc.Server, error) {
|
|
|
|
n.lock.RLock()
|
|
|
|
defer n.lock.RUnlock()
|
|
|
|
|
|
|
|
if n.inprocHandler == nil {
|
|
|
|
return nil, ErrNodeStopped
|
|
|
|
}
|
|
|
|
return n.inprocHandler, nil
|
|
|
|
}
|
|
|
|
|
2015-11-05 15:57:57 -06:00
|
|
|
// Server retrieves the currently running P2P network layer. This method is meant
|
|
|
|
// only to inspect fields of the currently running server, life cycle management
|
|
|
|
// should be left to this Node entity.
|
|
|
|
func (n *Node) Server() *p2p.Server {
|
|
|
|
n.lock.RLock()
|
|
|
|
defer n.lock.RUnlock()
|
|
|
|
|
2015-11-17 10:33:25 -06:00
|
|
|
return n.server
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
|
|
|
|
2015-11-26 10:35:44 -06:00
|
|
|
// Service retrieves a currently running service registered of a specific type.
|
|
|
|
func (n *Node) Service(service interface{}) error {
|
2015-11-17 10:33:25 -06:00
|
|
|
n.lock.RLock()
|
|
|
|
defer n.lock.RUnlock()
|
|
|
|
|
|
|
|
// Short circuit if the node's not running
|
|
|
|
if n.server == nil {
|
2015-11-26 10:35:44 -06:00
|
|
|
return ErrNodeStopped
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
// Otherwise try to find the service to return
|
2015-11-26 10:35:44 -06:00
|
|
|
element := reflect.ValueOf(service).Elem()
|
|
|
|
if running, ok := n.services[element.Type()]; ok {
|
|
|
|
element.Set(reflect.ValueOf(running))
|
|
|
|
return nil
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
2015-11-26 10:35:44 -06:00
|
|
|
return ErrServiceUnknown
|
2015-11-17 10:33:25 -06:00
|
|
|
}
|
|
|
|
|
2015-11-05 15:57:57 -06:00
|
|
|
// DataDir retrieves the current datadir used by the protocol stack.
|
2016-11-10 10:03:24 -06:00
|
|
|
// Deprecated: No files should be stored in this directory, use InstanceDir instead.
|
2015-11-05 15:57:57 -06:00
|
|
|
func (n *Node) DataDir() string {
|
2016-08-18 06:28:17 -05:00
|
|
|
return n.config.DataDir
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
|
|
|
|
2016-11-10 10:03:24 -06:00
|
|
|
// InstanceDir retrieves the instance directory used by the protocol stack.
|
|
|
|
func (n *Node) InstanceDir() string {
|
|
|
|
return n.config.instanceDir()
|
|
|
|
}
|
|
|
|
|
2016-08-15 11:38:32 -05:00
|
|
|
// AccountManager retrieves the account manager used by the protocol stack.
|
|
|
|
func (n *Node) AccountManager() *accounts.Manager {
|
|
|
|
return n.accman
|
|
|
|
}
|
|
|
|
|
2016-02-09 05:24:42 -06:00
|
|
|
// IPCEndpoint retrieves the current IPC endpoint used by the protocol stack.
|
|
|
|
func (n *Node) IPCEndpoint() string {
|
2016-02-02 11:06:43 -06:00
|
|
|
return n.ipcEndpoint
|
|
|
|
}
|
|
|
|
|
2016-02-09 06:10:40 -06:00
|
|
|
// HTTPEndpoint retrieves the current HTTP endpoint used by the protocol stack.
|
|
|
|
func (n *Node) HTTPEndpoint() string {
|
2018-10-11 13:32:14 -05:00
|
|
|
n.lock.Lock()
|
|
|
|
defer n.lock.Unlock()
|
|
|
|
|
2020-04-27 04:16:00 -05:00
|
|
|
if n.httpListenerAddr != nil {
|
|
|
|
return n.httpListenerAddr.String()
|
2018-10-11 13:32:14 -05:00
|
|
|
}
|
2016-02-09 06:10:40 -06:00
|
|
|
return n.httpEndpoint
|
|
|
|
}
|
|
|
|
|
|
|
|
// WSEndpoint retrieves the current WS endpoint used by the protocol stack.
|
|
|
|
func (n *Node) WSEndpoint() string {
|
2018-10-11 13:32:14 -05:00
|
|
|
n.lock.Lock()
|
|
|
|
defer n.lock.Unlock()
|
|
|
|
|
2020-04-27 04:16:00 -05:00
|
|
|
if n.wsListenerAddr != nil {
|
|
|
|
return n.wsListenerAddr.String()
|
2018-10-11 13:32:14 -05:00
|
|
|
}
|
2016-02-09 06:10:40 -06:00
|
|
|
return n.wsEndpoint
|
|
|
|
}
|
|
|
|
|
2015-11-05 15:57:57 -06:00
|
|
|
// EventMux retrieves the event multiplexer used by all the network services in
|
|
|
|
// the current protocol stack.
|
|
|
|
func (n *Node) EventMux() *event.TypeMux {
|
2015-11-17 10:33:25 -06:00
|
|
|
return n.eventmux
|
2015-11-05 15:57:57 -06:00
|
|
|
}
|
2015-10-15 09:07:19 -05:00
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
// OpenDatabase opens an existing database with the given name (or creates one if no
|
|
|
|
// previous can be found) from within the node's instance directory. If the node is
|
|
|
|
// ephemeral, a memory database is returned.
|
2018-09-24 07:57:49 -05:00
|
|
|
func (n *Node) OpenDatabase(name string, cache, handles int, namespace string) (ethdb.Database, error) {
|
2016-08-18 06:28:17 -05:00
|
|
|
if n.config.DataDir == "" {
|
2018-09-24 07:57:49 -05:00
|
|
|
return rawdb.NewMemoryDatabase(), nil
|
2016-08-18 06:28:17 -05:00
|
|
|
}
|
2018-09-24 07:57:49 -05:00
|
|
|
return rawdb.NewLevelDBDatabase(n.config.ResolvePath(name), cache, handles, namespace)
|
2016-08-18 06:28:17 -05:00
|
|
|
}
|
|
|
|
|
2019-03-08 07:56:20 -06:00
|
|
|
// OpenDatabaseWithFreezer opens an existing database with the given name (or
|
|
|
|
// creates one if no previous can be found) from within the node's data directory,
|
|
|
|
// also attaching a chain freezer to it that moves ancient chain data from the
|
|
|
|
// database to immutable append-only files. If the node is an ephemeral one, a
|
|
|
|
// memory database is returned.
|
|
|
|
func (n *Node) OpenDatabaseWithFreezer(name string, cache, handles int, freezer, namespace string) (ethdb.Database, error) {
|
|
|
|
if n.config.DataDir == "" {
|
|
|
|
return rawdb.NewMemoryDatabase(), nil
|
|
|
|
}
|
|
|
|
root := n.config.ResolvePath(name)
|
|
|
|
|
|
|
|
switch {
|
|
|
|
case freezer == "":
|
|
|
|
freezer = filepath.Join(root, "ancient")
|
|
|
|
case !filepath.IsAbs(freezer):
|
|
|
|
freezer = n.config.ResolvePath(freezer)
|
|
|
|
}
|
|
|
|
return rawdb.NewLevelDBDatabaseWithFreezer(root, cache, handles, freezer, namespace)
|
|
|
|
}
|
|
|
|
|
2016-08-18 06:28:17 -05:00
|
|
|
// ResolvePath returns the absolute path of a resource in the instance directory.
|
|
|
|
func (n *Node) ResolvePath(x string) string {
|
cmd, dashboard, log: log collection and exploration (#17097)
* cmd, dashboard, internal, log, node: logging feature
* cmd, dashboard, internal, log: requested changes
* dashboard, vendor: gofmt, govendor, use vendored file watcher
* dashboard, log: gofmt -s -w, goimports
* dashboard, log: gosimple
2018-07-11 02:59:04 -05:00
|
|
|
return n.config.ResolvePath(x)
|
2016-08-18 06:28:17 -05:00
|
|
|
}
|
|
|
|
|
2016-02-02 11:06:43 -06:00
|
|
|
// apis returns the collection of RPC descriptors this node offers.
|
|
|
|
func (n *Node) apis() []rpc.API {
|
|
|
|
return []rpc.API{
|
2015-12-04 12:56:11 -06:00
|
|
|
{
|
|
|
|
Namespace: "admin",
|
|
|
|
Version: "1.0",
|
|
|
|
Service: NewPrivateAdminAPI(n),
|
|
|
|
}, {
|
|
|
|
Namespace: "admin",
|
|
|
|
Version: "1.0",
|
|
|
|
Service: NewPublicAdminAPI(n),
|
|
|
|
Public: true,
|
|
|
|
}, {
|
|
|
|
Namespace: "debug",
|
|
|
|
Version: "1.0",
|
2016-01-26 07:39:21 -06:00
|
|
|
Service: debug.Handler,
|
2015-12-16 03:58:01 -06:00
|
|
|
}, {
|
|
|
|
Namespace: "web3",
|
|
|
|
Version: "1.0",
|
|
|
|
Service: NewPublicWeb3API(n),
|
|
|
|
Public: true,
|
2015-12-04 12:56:11 -06:00
|
|
|
},
|
|
|
|
}
|
2016-02-02 11:06:43 -06:00
|
|
|
}
|
2020-04-08 06:33:12 -05:00
|
|
|
|
|
|
|
// RegisterApisFromWhitelist checks the given modules' availability, generates a whitelist based on the allowed modules,
|
|
|
|
// and then registers all of the APIs exposed by the services.
|
|
|
|
func RegisterApisFromWhitelist(apis []rpc.API, modules []string, srv *rpc.Server, exposeAll bool) error {
|
|
|
|
if bad, available := checkModuleAvailability(modules, apis); len(bad) > 0 {
|
|
|
|
log.Error("Unavailable modules in HTTP API list", "unavailable", bad, "available", available)
|
|
|
|
}
|
|
|
|
// Generate the whitelist based on the allowed modules
|
|
|
|
whitelist := make(map[string]bool)
|
|
|
|
for _, module := range modules {
|
|
|
|
whitelist[module] = true
|
|
|
|
}
|
|
|
|
// Register all the APIs exposed by the services
|
|
|
|
for _, api := range apis {
|
|
|
|
if exposeAll || whitelist[api.Namespace] || (len(whitelist) == 0 && api.Public) {
|
|
|
|
if err := srv.RegisterName(api.Namespace, api.Service); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|