/geth-docker/src/main/docker/api.go
Go | 331 lines | 253 code | 40 blank | 38 comment | 57 complexity | 8a6292ffaf8a73f29e3ce2ef71879db9 MD5 | raw file
- package node
- import (
- "fmt"
- "strings"
- "time"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/p2p/discover"
- "github.com/ethereum/go-ethereum/rpc"
- "github.com/rcrowley/go-metrics"
- )
- // PrivateAdminAPI is the collection of administrative API methods exposed only
- // over a secure RPC channel.
- type PrivateAdminAPI struct {
- node *Node // Node interfaced by this API
- }
- // NewPrivateAdminAPI creates a new API definition for the private admin methods
- // of the node itself.
- func NewPrivateAdminAPI(node *Node) *PrivateAdminAPI {
- return &PrivateAdminAPI{node: node}
- }
- // AddPeer requests connecting to a remote node, and also maintaining the new
- // connection at all times, even reconnecting if it is lost.
- func (api *PrivateAdminAPI) AddPeer(url string) (bool, error) {
- // Make sure the server is running, fail otherwise
- server := api.node.Server()
- if server == nil {
- return false, ErrNodeStopped
- }
- // Try to add the url as a static peer and return
- node, err := discover.ParseNode(url)
- if err != nil {
- return false, fmt.Errorf("invalid enode: %v", err)
- }
- server.AddPeer(node)
- return true, nil
- }
- // RemovePeer disconnects from a a remote node if the connection exists
- func (api *PrivateAdminAPI) RemovePeer(url string) (bool, error) {
- // Make sure the server is running, fail otherwise
- server := api.node.Server()
- if server == nil {
- return false, ErrNodeStopped
- }
- // Try to remove the url as a static peer and return
- node, err := discover.ParseNode(url)
- if err != nil {
- return false, fmt.Errorf("invalid enode: %v", err)
- }
- server.RemovePeer(node)
- return true, nil
- }
- // StartRPC starts the HTTP RPC API server.
- func (api *PrivateAdminAPI) StartRPC(host *string, port *rpc.HexNumber, cors *string, apis *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 = rpc.NewHexNumber(api.node.config.HTTPPort)
- }
- if cors == nil {
- cors = &api.node.config.HTTPCors
- }
- 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.Int()), api.node.rpcAPIs, modules, *cors); 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 *rpc.HexNumber, 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 = rpc.NewHexNumber(api.node.config.WSPort)
- }
- if allowedOrigins == nil {
- allowedOrigins = &api.node.config.WSOrigins
- }
- 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.Int()), api.node.rpcAPIs, modules, *allowedOrigins); err != nil {
- return false, err
- }
- return true, nil
- }
- // StopRPC 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 {
- node *Node // Node interfaced by this API
- }
- // NewPublicAdminAPI creates a new API definition for the public admin methods
- // of the node itself.
- func NewPublicAdminAPI(node *Node) *PublicAdminAPI {
- return &PublicAdminAPI{node: node}
- }
- // Peers retrieves all the information we know about each individual peer at the
- // protocol granularity.
- func (api *PublicAdminAPI) Peers() ([]*p2p.PeerInfo, error) {
- server := api.node.Server()
- if server == nil {
- return nil, ErrNodeStopped
- }
- return server.PeersInfo(), nil
- }
- // NodeInfo retrieves all the information we know about the host node at the
- // protocol granularity.
- func (api *PublicAdminAPI) NodeInfo() (*p2p.NodeInfo, error) {
- server := api.node.Server()
- if server == nil {
- return nil, ErrNodeStopped
- }
- return server.NodeInfo(), nil
- }
- // Datadir retrieves the current data directory the node is using.
- func (api *PublicAdminAPI) Datadir() string {
- return api.node.DataDir()
- }
- // PublicDebugAPI is the collection of debugging related API methods exposed over
- // both secure and unsecure RPC channels.
- type PublicDebugAPI struct {
- node *Node // Node interfaced by this API
- }
- // NewPublicDebugAPI creates a new API definition for the public debug methods
- // of the node itself.
- func NewPublicDebugAPI(node *Node) *PublicDebugAPI {
- return &PublicDebugAPI{node: node}
- }
- // Metrics retrieves all the known system metric collected by the node.
- func (api *PublicDebugAPI) Metrics(raw bool) (map[string]interface{}, error) {
- // Create a rate formatter
- units := []string{"", "K", "M", "G", "T", "E", "P"}
- round := func(value float64, prec int) string {
- unit := 0
- for value >= 1000 {
- unit, value, prec = unit+1, value/1000, 2
- }
- return fmt.Sprintf(fmt.Sprintf("%%.%df%s", prec, units[unit]), value)
- }
- format := func(total float64, rate float64) string {
- return fmt.Sprintf("%s (%s/s)", round(total, 0), round(rate, 2))
- }
- // Iterate over all the metrics, and just dump for now
- counters := make(map[string]interface{})
- metrics.DefaultRegistry.Each(func(name string, metric interface{}) {
- // Create or retrieve the counter hierarchy for this metric
- root, parts := counters, strings.Split(name, "/")
- for _, part := range parts[:len(parts)-1] {
- if _, ok := root[part]; !ok {
- root[part] = make(map[string]interface{})
- }
- root = root[part].(map[string]interface{})
- }
- name = parts[len(parts)-1]
- // Fill the counter with the metric details, formatting if requested
- if raw {
- switch metric := metric.(type) {
- case metrics.Meter:
- root[name] = map[string]interface{}{
- "AvgRate01Min": metric.Rate1(),
- "AvgRate05Min": metric.Rate5(),
- "AvgRate15Min": metric.Rate15(),
- "MeanRate": metric.RateMean(),
- "Overall": float64(metric.Count()),
- }
- case metrics.Counter:
- root[name] = map[string]interface{}{
- "Count": float64(metric.Count()),
- }
- case metrics.Timer:
- root[name] = map[string]interface{}{
- "AvgRate01Min": metric.Rate1(),
- "AvgRate05Min": metric.Rate5(),
- "AvgRate15Min": metric.Rate15(),
- "MeanRate": metric.RateMean(),
- "Overall": float64(metric.Count()),
- "Percentiles": map[string]interface{}{
- "5": metric.Percentile(0.05),
- "20": metric.Percentile(0.2),
- "50": metric.Percentile(0.5),
- "80": metric.Percentile(0.8),
- "95": metric.Percentile(0.95),
- },
- }
- default:
- root[name] = "Unknown metric type"
- }
- } else {
- switch metric := metric.(type) {
- case metrics.Meter:
- root[name] = map[string]interface{}{
- "Avg01Min": format(metric.Rate1()*60, metric.Rate1()),
- "Avg05Min": format(metric.Rate5()*300, metric.Rate5()),
- "Avg15Min": format(metric.Rate15()*900, metric.Rate15()),
- "Overall": format(float64(metric.Count()), metric.RateMean()),
- }
- case metrics.Counter:
- root[name] = map[string]interface{}{
- "Count": metric.Count(),
- }
- case metrics.Timer:
- root[name] = map[string]interface{}{
- "Avg01Min": format(metric.Rate1()*60, metric.Rate1()),
- "Avg05Min": format(metric.Rate5()*300, metric.Rate5()),
- "Avg15Min": format(metric.Rate15()*900, metric.Rate15()),
- "Overall": format(float64(metric.Count()), metric.RateMean()),
- "Maximum": time.Duration(metric.Max()).String(),
- "Minimum": time.Duration(metric.Min()).String(),
- "Percentiles": map[string]interface{}{
- "5": time.Duration(metric.Percentile(0.05)).String(),
- "20": time.Duration(metric.Percentile(0.2)).String(),
- "50": time.Duration(metric.Percentile(0.5)).String(),
- "80": time.Duration(metric.Percentile(0.8)).String(),
- "95": time.Duration(metric.Percentile(0.95)).String(),
- },
- }
- default:
- root[name] = "Unknown metric type"
- }
- }
- })
- return counters, nil
- }
- // PublicWeb3API offers helper utils
- type PublicWeb3API struct {
- stack *Node
- }
- // NewPublicWeb3API creates a new Web3Service instance
- func NewPublicWeb3API(stack *Node) *PublicWeb3API {
- return &PublicWeb3API{stack}
- }
- // ClientVersion returns the node name
- func (s *PublicWeb3API) ClientVersion() string {
- return s.stack.Server().Name
- }
- // Sha3 applies the ethereum sha3 implementation on the input.
- // It assumes the input is hex encoded.
- func (s *PublicWeb3API) Sha3(input hexutil.Bytes) hexutil.Bytes {
- return crypto.Keccak256(input)
- }