github.com/evdatsion/aphelion-dpos-bft@v0.32.1/tools/tm-monitor/rpc.go (about)

     1  package main
     2  
     3  import (
     4  	"errors"
     5  	"net"
     6  	"net/http"
     7  
     8  	rpctypes "github.com/evdatsion/aphelion-dpos-bft/rpc/lib/types"
     9  
    10  	"github.com/evdatsion/aphelion-dpos-bft/libs/log"
    11  	rpc "github.com/evdatsion/aphelion-dpos-bft/rpc/lib/server"
    12  	"github.com/evdatsion/aphelion-dpos-bft/tools/tm-monitor/monitor"
    13  )
    14  
    15  func startRPC(listenAddr string, m *monitor.Monitor, logger log.Logger) net.Listener {
    16  	routes := routes(m)
    17  
    18  	mux := http.NewServeMux()
    19  	wm := rpc.NewWebsocketManager(routes, nil)
    20  	mux.HandleFunc("/websocket", wm.WebsocketHandler)
    21  	rpc.RegisterRPCFuncs(mux, routes, cdc, logger)
    22  	config := rpc.DefaultConfig()
    23  	listener, err := rpc.Listen(listenAddr, config)
    24  	if err != nil {
    25  		panic(err)
    26  	}
    27  	go rpc.StartHTTPServer(listener, mux, logger, config)
    28  	return listener
    29  }
    30  
    31  func routes(m *monitor.Monitor) map[string]*rpc.RPCFunc {
    32  	return map[string]*rpc.RPCFunc{
    33  		"status":         rpc.NewRPCFunc(RPCStatus(m), ""),
    34  		"status/network": rpc.NewRPCFunc(RPCNetworkStatus(m), ""),
    35  		"status/node":    rpc.NewRPCFunc(RPCNodeStatus(m), "name"),
    36  		"monitor":        rpc.NewRPCFunc(RPCMonitor(m), "endpoint"),
    37  		"unmonitor":      rpc.NewRPCFunc(RPCUnmonitor(m), "endpoint"),
    38  
    39  		// "start_meter": rpc.NewRPCFunc(network.StartMeter, "chainID,valID,event"),
    40  		// "stop_meter":  rpc.NewRPCFunc(network.StopMeter, "chainID,valID,event"),
    41  		// "meter":       rpc.NewRPCFunc(GetMeterResult(network), "chainID,valID,event"),
    42  	}
    43  }
    44  
    45  // RPCStatus returns common statistics for the network and statistics per node.
    46  func RPCStatus(m *monitor.Monitor) func(*rpctypes.Context) (networkAndNodes, error) {
    47  	return func(_ *rpctypes.Context) (networkAndNodes, error) {
    48  		return networkAndNodes{m.Network, m.Nodes}, nil
    49  	}
    50  }
    51  
    52  // RPCNetworkStatus returns common statistics for the network.
    53  func RPCNetworkStatus(m *monitor.Monitor) func(*rpctypes.Context) (*monitor.Network, error) {
    54  	return func(_ *rpctypes.Context) (*monitor.Network, error) {
    55  		return m.Network, nil
    56  	}
    57  }
    58  
    59  // RPCNodeStatus returns statistics for the given node.
    60  func RPCNodeStatus(m *monitor.Monitor) func(*rpctypes.Context, string) (*monitor.Node, error) {
    61  	return func(_ *rpctypes.Context, name string) (*monitor.Node, error) {
    62  		if i, n := m.NodeByName(name); i != -1 {
    63  			return n, nil
    64  		}
    65  		return nil, errors.New("cannot find node with that name")
    66  	}
    67  }
    68  
    69  // RPCMonitor allows to dynamically add a endpoint to under the monitor. Safe
    70  // to call multiple times.
    71  func RPCMonitor(m *monitor.Monitor) func(*rpctypes.Context, string) (*monitor.Node, error) {
    72  	return func(_ *rpctypes.Context, endpoint string) (*monitor.Node, error) {
    73  		i, n := m.NodeByName(endpoint)
    74  		if i == -1 {
    75  			n = monitor.NewNode(endpoint)
    76  			if err := m.Monitor(n); err != nil {
    77  				return nil, err
    78  			}
    79  		}
    80  		return n, nil
    81  	}
    82  }
    83  
    84  // RPCUnmonitor removes the given endpoint from under the monitor.
    85  func RPCUnmonitor(m *monitor.Monitor) func(*rpctypes.Context, string) (bool, error) {
    86  	return func(_ *rpctypes.Context, endpoint string) (bool, error) {
    87  		if i, n := m.NodeByName(endpoint); i != -1 {
    88  			m.Unmonitor(n)
    89  			return true, nil
    90  		}
    91  		return false, errors.New("cannot find node with that name")
    92  	}
    93  }
    94  
    95  // func (tn *TendermintNetwork) StartMeter(chainID, valID, eventID string) error {
    96  // 	tn.mtx.Lock()
    97  // 	defer tn.mtx.Unlock()
    98  // 	val, err := tn.getChainVal(chainID, valID)
    99  // 	if err != nil {
   100  // 		return err
   101  // 	}
   102  // 	return val.EventMeter().Subscribe(eventID, nil)
   103  // }
   104  
   105  // func (tn *TendermintNetwork) StopMeter(chainID, valID, eventID string) error {
   106  // 	tn.mtx.Lock()
   107  // 	defer tn.mtx.Unlock()
   108  // 	val, err := tn.getChainVal(chainID, valID)
   109  // 	if err != nil {
   110  // 		return err
   111  // 	}
   112  // 	return val.EventMeter().Unsubscribe(eventID)
   113  // }
   114  
   115  // func (tn *TendermintNetwork) GetMeter(chainID, valID, eventID string) (*eventmeter.EventMetric, error) {
   116  // 	tn.mtx.Lock()
   117  // 	defer tn.mtx.Unlock()
   118  // 	val, err := tn.getChainVal(chainID, valID)
   119  // 	if err != nil {
   120  // 		return nil, err
   121  // 	}
   122  
   123  // 	return val.EventMeter().GetMetric(eventID)
   124  // }
   125  
   126  //--> types
   127  
   128  type networkAndNodes struct {
   129  	Network *monitor.Network `json:"network"`
   130  	Nodes   []*monitor.Node  `json:"nodes"`
   131  }