From 67ae6a33a4bfd74dad0a043f07f91647d34cff8d Mon Sep 17 00:00:00 2001 From: Determinant Date: Fri, 3 Jul 2020 10:54:47 -0400 Subject: more clean up --- core/state_processor.go | 2 - go.mod | 31 ++++ node/api.go | 116 ------------- node/node.go | 445 ------------------------------------------------ 4 files changed, 31 insertions(+), 563 deletions(-) create mode 100644 go.mod diff --git a/core/state_processor.go b/core/state_processor.go index d80997e..6cc646a 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -25,7 +25,6 @@ import ( "github.com/ava-labs/coreth/params" "github.com/ava-labs/go-ethereum/common" "github.com/ava-labs/go-ethereum/crypto" - "github.com/ava-labs/go-ethereum/log" ) // StateProcessor is a basic Processor, which takes care of transitioning @@ -55,7 +54,6 @@ func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consen // returns the amount of gas that was used in the process. If any of the // transactions failed to execute due to insufficient gas it will return an error. func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) { - log.Debug("here4") var ( receipts types.Receipts usedGas = new(uint64) diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..86b7bfd --- /dev/null +++ b/go.mod @@ -0,0 +1,31 @@ +module github.com/ava-labs/coreth + +go 1.14 + +require ( + github.com/ava-labs/gecko v0.5.7 + github.com/ava-labs/go-ethereum v1.9.3 + github.com/davecgh/go-spew v1.1.1 + github.com/deckarep/golang-set v1.7.1 + github.com/edsrzf/mmap-go v1.0.0 + github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 + github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 + github.com/golang/snappy v0.0.1 + github.com/gorilla/websocket v1.4.2 + github.com/hashicorp/go-plugin v1.3.0 + github.com/hashicorp/golang-lru v0.5.4 + github.com/mattn/go-colorable v0.1.7 + github.com/mattn/go-isatty v0.0.12 + github.com/olekukonko/tablewriter v0.0.4 + github.com/pborman/uuid v1.2.0 + github.com/prometheus/tsdb v0.10.0 + github.com/rjeczalik/notify v0.9.2 + github.com/rs/cors v1.7.0 + github.com/status-im/keycard-go v0.0.0-20200402102358-957c09536969 + github.com/tyler-smith/go-bip39 v1.0.2 + github.com/wsddn/go-ecdh v0.0.0-20161211032359-48726bab9208 + golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 + golang.org/x/text v0.3.3 + gopkg.in/olebedev/go-duktape.v3 v3.0.0-20200619000410-60c24ae608a6 + gopkg.in/urfave/cli.v1 v1.20.0 +) diff --git a/node/api.go b/node/api.go index 8352020..5e93580 100644 --- a/node/api.go +++ b/node/api.go @@ -142,122 +142,6 @@ func (api *PrivateAdminAPI) PeerEvents(ctx context.Context) (*rpc.Subscription, return rpcSub, nil } -//// StartRPC starts the HTTP RPC API server. -//func (api *PrivateAdminAPI) StartRPC(host *string, port *int, cors *string, apis *string, vhosts *string) (bool, error) { -// api.node.lock.Lock() -// defer api.node.lock.Unlock() -// -// if api.node.httpHandler != nil { -// return false, fmt.Errorf("HTTP RPC already running on %s", api.node.httpEndpoint) -// } -// -// if host == nil { -// h := DefaultHTTPHost -// if api.node.config.HTTPHost != "" { -// h = api.node.config.HTTPHost -// } -// host = &h -// } -// if port == nil { -// port = &api.node.config.HTTPPort -// } -// -// allowedOrigins := api.node.config.HTTPCors -// if cors != nil { -// allowedOrigins = nil -// for _, origin := range strings.Split(*cors, ",") { -// allowedOrigins = append(allowedOrigins, strings.TrimSpace(origin)) -// } -// } -// -// allowedVHosts := api.node.config.HTTPVirtualHosts -// if vhosts != nil { -// allowedVHosts = nil -// for _, vhost := range strings.Split(*host, ",") { -// allowedVHosts = append(allowedVHosts, strings.TrimSpace(vhost)) -// } -// } -// -// modules := api.node.httpWhitelist -// if apis != nil { -// modules = nil -// for _, m := range strings.Split(*apis, ",") { -// modules = append(modules, strings.TrimSpace(m)) -// } -// } -// -// if err := api.node.startHTTP(fmt.Sprintf("%s:%d", *host, *port), api.node.rpcAPIs, modules, allowedOrigins, allowedVHosts, api.node.config.HTTPTimeouts); err != nil { -// return false, err -// } -// return true, nil -//} - -// StopRPC terminates an already running HTTP RPC API endpoint. -func (api *PrivateAdminAPI) StopRPC() (bool, error) { - api.node.lock.Lock() - defer api.node.lock.Unlock() - - if api.node.httpHandler == nil { - return false, fmt.Errorf("HTTP RPC not running") - } - api.node.stopHTTP() - return true, nil -} - -//// StartWS starts the websocket RPC API server. -//func (api *PrivateAdminAPI) StartWS(host *string, port *int, allowedOrigins *string, apis *string) (bool, error) { -// api.node.lock.Lock() -// defer api.node.lock.Unlock() -// -// if api.node.wsHandler != nil { -// return false, fmt.Errorf("WebSocket RPC already running on %s", api.node.wsEndpoint) -// } -// -// if host == nil { -// h := DefaultWSHost -// if api.node.config.WSHost != "" { -// h = api.node.config.WSHost -// } -// host = &h -// } -// if port == nil { -// port = &api.node.config.WSPort -// } -// -// origins := api.node.config.WSOrigins -// if allowedOrigins != nil { -// origins = nil -// for _, origin := range strings.Split(*allowedOrigins, ",") { -// origins = append(origins, strings.TrimSpace(origin)) -// } -// } -// -// modules := api.node.config.WSModules -// if apis != nil { -// modules = nil -// for _, m := range strings.Split(*apis, ",") { -// modules = append(modules, strings.TrimSpace(m)) -// } -// } -// -// if err := api.node.startWS(fmt.Sprintf("%s:%d", *host, *port), api.node.rpcAPIs, modules, origins, api.node.config.WSExposeAll); err != nil { -// return false, err -// } -// return true, nil -//} - -// StopWS terminates an already running websocket RPC API endpoint. -func (api *PrivateAdminAPI) StopWS() (bool, error) { - api.node.lock.Lock() - defer api.node.lock.Unlock() - - if api.node.wsHandler == nil { - return false, fmt.Errorf("WebSocket RPC not running") - } - api.node.stopWS() - return true, nil -} - // PublicAdminAPI is the collection of administrative API methods exposed over // both secure and unsecure RPC channels. type PublicAdminAPI struct { diff --git a/node/node.go b/node/node.go index 6e91b60..d2a212b 100644 --- a/node/node.go +++ b/node/node.go @@ -18,9 +18,6 @@ package node import ( "errors" - "fmt" - "net" - "os" "path/filepath" "reflect" "strings" @@ -55,19 +52,6 @@ type Node struct { rpcAPIs []rpc.API // List of APIs currently provided by the node inprocHandler *rpc.Server // In-process RPC request handler to process the API requests - 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 - - httpEndpoint string // HTTP endpoint (interface + port) to listen at (empty = HTTP disabled) - httpWhitelist []string // HTTP RPC modules to allow through this endpoint - httpListener net.Listener // HTTP RPC listener socket to server API requests - httpHandler *rpc.Server // HTTP RPC request handler to process the API requests - - wsEndpoint string // Websocket endpoint (interface + port) to listen at (empty = websocket disabled) - wsListener net.Listener // Websocket RPC listener socket to server API requests - wsHandler *rpc.Server // Websocket RPC request handler to process the API requests - stop chan struct{} // Channel to wait for termination notifications lock sync.RWMutex @@ -114,418 +98,16 @@ func New(conf *Config) (*Node, error) { ephemeralKeystore: ephemeralKeystore, config: conf, serviceFuncs: []ServiceConstructor{}, - ipcEndpoint: conf.IPCEndpoint(), - httpEndpoint: conf.HTTPEndpoint(), - wsEndpoint: conf.WSEndpoint(), eventmux: new(event.TypeMux), log: conf.Logger, }, nil } -// 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) - } -} - -// 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 { - n.lock.Lock() - defer n.lock.Unlock() - - if n.server != nil { - return ErrNodeRunning - } - n.serviceFuncs = append(n.serviceFuncs, constructor) - return nil -} - -// Start create a live P2P node and starts running it. -func (n *Node) Start() error { - n.lock.Lock() - defer n.lock.Unlock() - - // Short circuit if the node's already running - if n.server != nil { - return ErrNodeRunning - } - if err := n.openDataDir(); err != nil { - return err - } - - // Initialize the p2p server. This creates the node key and - // discovery databases. - n.serverConfig = n.config.P2P - n.serverConfig.PrivateKey = n.config.NodeKey() - n.serverConfig.Name = n.config.NodeName() - n.serverConfig.Logger = n.log - if n.serverConfig.StaticNodes == nil { - n.serverConfig.StaticNodes = n.config.StaticNodes() - } - if n.serverConfig.TrustedNodes == nil { - n.serverConfig.TrustedNodes = n.config.TrustedNodes() - } - if n.serverConfig.NodeDatabase == "" { - n.serverConfig.NodeDatabase = n.config.NodeDB() - } - running := &p2p.Server{Config: n.serverConfig} - n.log.Info("Starting peer-to-peer node", "instance", n.serverConfig.Name) - - // Otherwise copy and specialize the P2P configuration - services := make(map[reflect.Type]Service) - for _, constructor := range n.serviceFuncs { - // Create a new context for the particular service - ctx := &ServiceContext{ - config: n.config, - services: make(map[reflect.Type]Service), - EventMux: n.eventmux, - AccountManager: n.accman, - } - for kind, s := range services { // copy needed for threaded access - ctx.services[kind] = s - } - // Construct and save the service - service, err := constructor(ctx) - if err != nil { - return err - } - kind := reflect.TypeOf(service) - if _, exists := services[kind]; exists { - return &DuplicateServiceError{Kind: kind} - } - services[kind] = service - } - // 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 { - return convertFileLockError(err) - } - // Start each of the services - var started []reflect.Type - for kind, service := range services { - // Start the next service, stopping all previous upon failure - if err := service.Start(running); err != nil { - for _, kind := range started { - services[kind].Stop() - } - running.Stop() - - return err - } - // Mark the service started for potential cleanup - started = append(started, kind) - } - // Lastly start the configured RPC interfaces - //if err := n.startRPC(services); err != nil { - // for _, service := range services { - // service.Stop() - // } - // running.Stop() - // return err - //} - // Finish initializing the startup - n.services = services - n.server = running - n.stop = make(chan struct{}) - return nil -} - // Config returns the configuration of node. func (n *Node) Config() *Config { return n.config } -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 - } - // Lock the instance directory to prevent concurrent use by another instance as well as - // accidental use of the instance directory as a database. - release, _, err := fileutil.Flock(filepath.Join(instdir, "LOCK")) - if err != nil { - return convertFileLockError(err) - } - n.instanceDirLock = release - return nil -} - -// startRPC is a helper method to start all the various RPC endpoint during node -// startup. It's not meant to be called at any time afterwards as it makes certain -// assumptions about the state of the node. -//func (n *Node) startRPC(services map[reflect.Type]Service) error { -// // Gather all the possible APIs to surface -// apis := n.apis() -// for _, service := range services { -// apis = append(apis, service.APIs()...) -// } -// // Start the various API endpoints, terminating all in case of errors -// if err := n.startInProc(apis); err != nil { -// return err -// } -// if err := n.startIPC(apis); err != nil { -// n.stopInProc() -// return err -// } -// if err := n.startHTTP(n.httpEndpoint, apis, n.config.HTTPModules, n.config.HTTPCors, n.config.HTTPVirtualHosts, n.config.HTTPTimeouts); err != nil { -// n.stopIPC() -// n.stopInProc() -// return err -// } -// 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 -// } -// // All API endpoints started successfully -// n.rpcAPIs = apis -// return nil -//} - -// 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 - } - n.log.Debug("InProc registered", "namespace", api.Namespace) - } - 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 - } -} - -//// startIPC initializes and starts the IPC RPC endpoint. -//func (n *Node) startIPC(apis []rpc.API) error { -// if n.ipcEndpoint == "" { -// return nil // IPC disabled. -// } -// listener, handler, err := rpc.StartIPCEndpoint(n.ipcEndpoint, apis) -// if err != nil { -// return err -// } -// n.ipcListener = listener -// n.ipcHandler = handler -// n.log.Info("IPC endpoint opened", "url", n.ipcEndpoint) -// return nil -//} - -// stopIPC terminates the IPC RPC endpoint. -func (n *Node) stopIPC() { - if n.ipcListener != nil { - n.ipcListener.Close() - n.ipcListener = nil - - n.log.Info("IPC endpoint closed", "url", n.ipcEndpoint) - } - if n.ipcHandler != nil { - n.ipcHandler.Stop() - n.ipcHandler = nil - } -} - -// startHTTP initializes and starts the HTTP RPC endpoint. -//func (n *Node) startHTTP(endpoint string, apis []rpc.API, modules []string, cors []string, vhosts []string, timeouts rpc.HTTPTimeouts) error { -// // Short circuit if the HTTP endpoint isn't being exposed -// if endpoint == "" { -// return nil -// } -// listener, handler, err := rpc.StartHTTPEndpoint(endpoint, apis, modules, cors, vhosts, timeouts) -// if err != nil { -// return err -// } -// n.log.Info("HTTP endpoint opened", "url", fmt.Sprintf("http://%s", endpoint), "cors", strings.Join(cors, ","), "vhosts", strings.Join(vhosts, ",")) -// // All listeners booted successfully -// n.httpEndpoint = endpoint -// n.httpListener = listener -// n.httpHandler = handler -// -// return nil -//} - -// stopHTTP terminates the HTTP RPC endpoint. -func (n *Node) stopHTTP() { - if n.httpListener != nil { - n.httpListener.Close() - n.httpListener = nil - - n.log.Info("HTTP endpoint closed", "url", fmt.Sprintf("http://%s", n.httpEndpoint)) - } - if n.httpHandler != nil { - n.httpHandler.Stop() - n.httpHandler = nil - } -} - -//// startWS initializes and starts the websocket RPC endpoint. -//func (n *Node) startWS(endpoint string, apis []rpc.API, modules []string, wsOrigins []string, exposeAll bool) error { -// // Short circuit if the WS endpoint isn't being exposed -// if endpoint == "" { -// return nil -// } -// listener, handler, err := rpc.StartWSEndpoint(endpoint, apis, modules, wsOrigins, exposeAll) -// if err != nil { -// return err -// } -// n.log.Info("WebSocket endpoint opened", "url", fmt.Sprintf("ws://%s", listener.Addr())) -// // All listeners booted successfully -// n.wsEndpoint = endpoint -// n.wsListener = listener -// n.wsHandler = handler -// -// return nil -//} - -// stopWS terminates the websocket RPC endpoint. -func (n *Node) stopWS() { - if n.wsListener != nil { - n.wsListener.Close() - n.wsListener = nil - - n.log.Info("WebSocket endpoint closed", "url", fmt.Sprintf("ws://%s", n.wsEndpoint)) - } - if n.wsHandler != nil { - n.wsHandler.Stop() - n.wsHandler = nil - } -} - -// 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 - if n.server == nil { - return ErrNodeStopped - } - - // Terminate the API, services and the p2p server. - n.stopWS() - n.stopHTTP() - n.stopIPC() - n.rpcAPIs = nil - failure := &StopError{ - Services: make(map[reflect.Type]error), - } - for kind, service := range n.services { - if err := service.Stop(); err != nil { - failure.Services[kind] = err - } - } - n.server.Stop() - n.services = nil - n.server = nil - - // Release instance directory lock. - if n.instanceDirLock != nil { - if err := n.instanceDirLock.Release(); err != nil { - n.log.Error("Can't release datadir lock", "err", err) - } - n.instanceDirLock = nil - } - - // unblock n.Wait - close(n.stop) - - // Remove the keystore if it was created ephemerally. - var keystoreErr error - if n.ephemeralKeystore != "" { - keystoreErr = os.RemoveAll(n.ephemeralKeystore) - } - - if len(failure.Services) > 0 { - return failure - } - if keystoreErr != nil { - return keystoreErr - } - return nil -} - -// 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 { - n.lock.RUnlock() - return - } - stop := n.stop - n.lock.RUnlock() - - <-stop -} - -// 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 -} - -//// Attach creates an RPC client attached to an in-process API handler. -//func (n *Node) Attach() (*rpc.Client, error) { -// n.lock.RLock() -// defer n.lock.RUnlock() -// -// if n.server == nil { -// return nil, ErrNodeStopped -// } -// return rpc.DialInProc(n.inprocHandler), nil -//} - -// 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 -} - // 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. @@ -570,33 +152,6 @@ func (n *Node) AccountManager() *accounts.Manager { return n.accman } -// IPCEndpoint retrieves the current IPC endpoint used by the protocol stack. -func (n *Node) IPCEndpoint() string { - return n.ipcEndpoint -} - -// HTTPEndpoint retrieves the current HTTP endpoint used by the protocol stack. -func (n *Node) HTTPEndpoint() string { - n.lock.Lock() - defer n.lock.Unlock() - - if n.httpListener != nil { - return n.httpListener.Addr().String() - } - return n.httpEndpoint -} - -// WSEndpoint retrieves the current WS endpoint used by the protocol stack. -func (n *Node) WSEndpoint() string { - n.lock.Lock() - defer n.lock.Unlock() - - if n.wsListener != nil { - return n.wsListener.Addr().String() - } - return n.wsEndpoint -} - // EventMux retrieves the event multiplexer used by all the network services in // the current protocol stack. func (n *Node) EventMux() *event.TypeMux { -- cgit v1.2.3