|
|
|
|
@ -55,10 +55,17 @@ type Node struct { |
|
|
|
|
serviceFuncs []ServiceConstructor // Service constructors (in dependency order)
|
|
|
|
|
services map[reflect.Type]Service // Currently running services
|
|
|
|
|
|
|
|
|
|
rpcAPIs []rpc.API // List of APIs currently provided by the node
|
|
|
|
|
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
|
|
|
|
|
httpCors string // HTTP RPC Cross-Origin Resource Sharing header
|
|
|
|
|
httpListener net.Listener // HTTP RPC listener socket to server API requests
|
|
|
|
|
httpHandler *rpc.Server // HTTP RPC request handler to process the API requests
|
|
|
|
|
|
|
|
|
|
stop chan struct{} // Channel to wait for termination notifications
|
|
|
|
|
lock sync.RWMutex |
|
|
|
|
} |
|
|
|
|
@ -93,9 +100,12 @@ func New(conf *Config) (*Node, error) { |
|
|
|
|
MaxPeers: conf.MaxPeers, |
|
|
|
|
MaxPendingPeers: conf.MaxPendingPeers, |
|
|
|
|
}, |
|
|
|
|
serviceFuncs: []ServiceConstructor{}, |
|
|
|
|
ipcEndpoint: conf.IpcEndpoint(), |
|
|
|
|
eventmux: new(event.TypeMux), |
|
|
|
|
serviceFuncs: []ServiceConstructor{}, |
|
|
|
|
ipcEndpoint: conf.IpcEndpoint(), |
|
|
|
|
httpEndpoint: conf.HttpEndpoint(), |
|
|
|
|
httpWhitelist: conf.HttpModules, |
|
|
|
|
httpCors: conf.HttpCors, |
|
|
|
|
eventmux: new(event.TypeMux), |
|
|
|
|
}, nil |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -188,58 +198,146 @@ func (n *Node) Start() error { |
|
|
|
|
return nil |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// startRPC initializes and starts the IPC RPC endpoints.
|
|
|
|
|
// 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 and register all the APIs exposed by the services
|
|
|
|
|
// Gather all the possible APIs to surface
|
|
|
|
|
apis := n.apis() |
|
|
|
|
for _, service := range services { |
|
|
|
|
apis = append(apis, service.APIs()...) |
|
|
|
|
} |
|
|
|
|
ipcHandler := rpc.NewServer() |
|
|
|
|
// Start the various API endpoints, terminating all in case of errors
|
|
|
|
|
if err := n.startIPC(apis); err != nil { |
|
|
|
|
return err |
|
|
|
|
} |
|
|
|
|
if err := n.startHTTP(n.httpEndpoint, apis, n.httpWhitelist, n.httpCors); err != nil { |
|
|
|
|
n.stopIPC() |
|
|
|
|
return err |
|
|
|
|
} |
|
|
|
|
// All API endpoints started successfully
|
|
|
|
|
n.rpcAPIs = apis |
|
|
|
|
return nil |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// startIPC initializes and starts the IPC RPC endpoint.
|
|
|
|
|
func (n *Node) startIPC(apis []rpc.API) error { |
|
|
|
|
// Short circuit if the IPC endpoint isn't being exposed
|
|
|
|
|
if n.ipcEndpoint == "" { |
|
|
|
|
return nil |
|
|
|
|
} |
|
|
|
|
// Register all the APIs exposed by the services
|
|
|
|
|
handler := rpc.NewServer() |
|
|
|
|
for _, api := range apis { |
|
|
|
|
if err := ipcHandler.RegisterName(api.Namespace, api.Service); err != nil { |
|
|
|
|
if err := handler.RegisterName(api.Namespace, api.Service); err != nil { |
|
|
|
|
return err |
|
|
|
|
} |
|
|
|
|
glog.V(logger.Debug).Infof("Register %T under namespace '%s'", api.Service, api.Namespace) |
|
|
|
|
glog.V(logger.Debug).Infof("IPC registered %T under '%s'", api.Service, api.Namespace) |
|
|
|
|
} |
|
|
|
|
// All APIs registered, start the IPC and HTTP listeners
|
|
|
|
|
// All APIs registered, start the IPC listener
|
|
|
|
|
var ( |
|
|
|
|
ipcListener net.Listener |
|
|
|
|
err error |
|
|
|
|
listener net.Listener |
|
|
|
|
err error |
|
|
|
|
) |
|
|
|
|
if n.ipcEndpoint != "" { |
|
|
|
|
if ipcListener, err = rpc.CreateIPCListener(n.ipcEndpoint); err != nil { |
|
|
|
|
return err |
|
|
|
|
} |
|
|
|
|
go func() { |
|
|
|
|
glog.V(logger.Info).Infof("IPC endpoint opened: %s", n.ipcEndpoint) |
|
|
|
|
defer glog.V(logger.Info).Infof("IPC endpoint closed: %s", n.ipcEndpoint) |
|
|
|
|
|
|
|
|
|
for { |
|
|
|
|
conn, err := ipcListener.Accept() |
|
|
|
|
if err != nil { |
|
|
|
|
// Terminate if the listener was closed
|
|
|
|
|
n.lock.RLock() |
|
|
|
|
closed := n.ipcListener == nil |
|
|
|
|
n.lock.RUnlock() |
|
|
|
|
if closed { |
|
|
|
|
return |
|
|
|
|
} |
|
|
|
|
// Not closed, just some error; report and continue
|
|
|
|
|
glog.V(logger.Error).Infof("IPC accept failed: %v", err) |
|
|
|
|
continue |
|
|
|
|
if listener, err = rpc.CreateIPCListener(n.ipcEndpoint); err != nil { |
|
|
|
|
return err |
|
|
|
|
} |
|
|
|
|
go func() { |
|
|
|
|
glog.V(logger.Info).Infof("IPC endpoint opened: %s", n.ipcEndpoint) |
|
|
|
|
|
|
|
|
|
for { |
|
|
|
|
conn, err := listener.Accept() |
|
|
|
|
if err != nil { |
|
|
|
|
// Terminate if the listener was closed
|
|
|
|
|
n.lock.RLock() |
|
|
|
|
closed := n.ipcListener == nil |
|
|
|
|
n.lock.RUnlock() |
|
|
|
|
if closed { |
|
|
|
|
return |
|
|
|
|
} |
|
|
|
|
go ipcHandler.ServeCodec(rpc.NewJSONCodec(conn)) |
|
|
|
|
// Not closed, just some error; report and continue
|
|
|
|
|
glog.V(logger.Error).Infof("IPC accept failed: %v", err) |
|
|
|
|
continue |
|
|
|
|
} |
|
|
|
|
go handler.ServeCodec(rpc.NewJSONCodec(conn)) |
|
|
|
|
} |
|
|
|
|
}() |
|
|
|
|
// All listeners booted successfully
|
|
|
|
|
n.ipcListener = listener |
|
|
|
|
n.ipcHandler = handler |
|
|
|
|
|
|
|
|
|
return nil |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// stopIPC terminates the IPC RPC endpoint.
|
|
|
|
|
func (n *Node) stopIPC() { |
|
|
|
|
if n.ipcListener != nil { |
|
|
|
|
n.ipcListener.Close() |
|
|
|
|
n.ipcListener = nil |
|
|
|
|
|
|
|
|
|
glog.V(logger.Info).Infof("IPC endpoint closed: %s", 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) error { |
|
|
|
|
// Short circuit if the IPC endpoint isn't being exposed
|
|
|
|
|
if endpoint == "" { |
|
|
|
|
return nil |
|
|
|
|
} |
|
|
|
|
// 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
|
|
|
|
|
handler := rpc.NewServer() |
|
|
|
|
for _, api := range apis { |
|
|
|
|
if whitelist[api.Namespace] || (len(whitelist) == 0 && api.Public) { |
|
|
|
|
if err := handler.RegisterName(api.Namespace, api.Service); err != nil { |
|
|
|
|
return err |
|
|
|
|
} |
|
|
|
|
}() |
|
|
|
|
glog.V(logger.Debug).Infof("HTTP registered %T under '%s'", api.Service, api.Namespace) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
// All APIs registered, start the HTTP listener
|
|
|
|
|
var ( |
|
|
|
|
listener net.Listener |
|
|
|
|
err error |
|
|
|
|
) |
|
|
|
|
if listener, err = net.Listen("tcp", endpoint); err != nil { |
|
|
|
|
return err |
|
|
|
|
} |
|
|
|
|
go rpc.NewHTTPServer(cors, handler).Serve(listener) |
|
|
|
|
glog.V(logger.Info).Infof("HTTP endpoint opened: http://%s", endpoint) |
|
|
|
|
|
|
|
|
|
// All listeners booted successfully
|
|
|
|
|
n.ipcListener = ipcListener |
|
|
|
|
n.ipcHandler = ipcHandler |
|
|
|
|
n.httpEndpoint = endpoint |
|
|
|
|
n.httpListener = listener |
|
|
|
|
n.httpHandler = handler |
|
|
|
|
n.httpCors = cors |
|
|
|
|
|
|
|
|
|
return nil |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// stopHTTP terminates the HTTP RPC endpoint.
|
|
|
|
|
func (n *Node) stopHTTP() { |
|
|
|
|
if n.httpListener != nil { |
|
|
|
|
n.httpListener.Close() |
|
|
|
|
n.httpListener = nil |
|
|
|
|
|
|
|
|
|
glog.V(logger.Info).Infof("HTTP endpoint closed: http://%s", n.httpEndpoint) |
|
|
|
|
} |
|
|
|
|
if n.httpHandler != nil { |
|
|
|
|
n.httpHandler.Stop() |
|
|
|
|
n.httpHandler = 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 { |
|
|
|
|
@ -251,14 +349,10 @@ func (n *Node) Stop() error { |
|
|
|
|
return ErrNodeStopped |
|
|
|
|
} |
|
|
|
|
// Otherwise terminate the API, all services and the P2P server too
|
|
|
|
|
if n.ipcListener != nil { |
|
|
|
|
n.ipcListener.Close() |
|
|
|
|
n.ipcListener = nil |
|
|
|
|
} |
|
|
|
|
if n.ipcHandler != nil { |
|
|
|
|
n.ipcHandler.Stop() |
|
|
|
|
n.ipcHandler = nil |
|
|
|
|
} |
|
|
|
|
n.stopIPC() |
|
|
|
|
n.stopHTTP() |
|
|
|
|
n.rpcAPIs = nil |
|
|
|
|
|
|
|
|
|
failure := &StopError{ |
|
|
|
|
Services: make(map[reflect.Type]error), |
|
|
|
|
} |
|
|
|
|
|
Péter Szilágyi
9 years ago