You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
269 lines
6.3 KiB
269 lines
6.3 KiB
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"math"
|
|
"time"
|
|
|
|
em "github.com/tendermint/go-event-meter"
|
|
events "github.com/tendermint/go-events"
|
|
rpc_client "github.com/tendermint/go-rpc/client"
|
|
tmtypes "github.com/tendermint/tendermint/types"
|
|
|
|
crypto "github.com/tendermint/go-crypto"
|
|
wire "github.com/tendermint/go-wire"
|
|
ctypes "github.com/tendermint/tendermint/rpc/core/types"
|
|
)
|
|
|
|
// remove when https://github.com/tendermint/go-rpc/issues/8 will be fixed
|
|
type rpcClientI interface {
|
|
Call(method string, params map[string]interface{}, result interface{}) (interface{}, error)
|
|
}
|
|
|
|
const maxRestarts = 25
|
|
|
|
type Node struct {
|
|
rpcAddr string
|
|
|
|
IsValidator bool `json:"is_validator"` // validator or non-validator?
|
|
pubKey crypto.PubKey `json:"pub_key"`
|
|
|
|
Name string `json:"name"`
|
|
Online bool `json:"online"`
|
|
Height uint64 `json:"height"`
|
|
BlockLatency float64 `json:"block_latency" wire:"unsafe"` // ms, interval between block commits
|
|
|
|
// em holds the ws connection. Each eventMeter callback is called in a separate go-routine.
|
|
em eventMeter
|
|
|
|
// rpcClient is an client for making RPC calls to TM
|
|
rpcClient rpcClientI
|
|
|
|
blockCh chan<- tmtypes.Header
|
|
blockLatencyCh chan<- float64
|
|
disconnectCh chan<- bool
|
|
|
|
checkIsValidatorInterval time.Duration
|
|
|
|
quit chan struct{}
|
|
}
|
|
|
|
func NewNode(rpcAddr string, options ...func(*Node)) *Node {
|
|
em := em.NewEventMeter(rpcAddr, UnmarshalEvent)
|
|
rpcClient := rpc_client.NewClientURI(rpcAddr) // HTTP client by default
|
|
return NewNodeWithEventMeterAndRpcClient(rpcAddr, em, rpcClient, options...)
|
|
}
|
|
|
|
func NewNodeWithEventMeterAndRpcClient(rpcAddr string, em eventMeter, rpcClient rpcClientI, options ...func(*Node)) *Node {
|
|
n := &Node{
|
|
rpcAddr: rpcAddr,
|
|
em: em,
|
|
rpcClient: rpcClient,
|
|
Name: rpcAddr,
|
|
quit: make(chan struct{}),
|
|
checkIsValidatorInterval: 5 * time.Second,
|
|
}
|
|
|
|
for _, option := range options {
|
|
option(n)
|
|
}
|
|
|
|
return n
|
|
}
|
|
|
|
// SetCheckIsValidatorInterval lets you change interval for checking whenever
|
|
// node is still a validator or not.
|
|
func SetCheckIsValidatorInterval(d time.Duration) func(n *Node) {
|
|
return func(n *Node) {
|
|
n.checkIsValidatorInterval = d
|
|
}
|
|
}
|
|
|
|
func (n *Node) SendBlocksTo(ch chan<- tmtypes.Header) {
|
|
n.blockCh = ch
|
|
}
|
|
|
|
func (n *Node) SendBlockLatenciesTo(ch chan<- float64) {
|
|
n.blockLatencyCh = ch
|
|
}
|
|
|
|
func (n *Node) NotifyAboutDisconnects(ch chan<- bool) {
|
|
n.disconnectCh = ch
|
|
}
|
|
|
|
func (n *Node) Start() error {
|
|
if _, err := n.em.Start(); err != nil {
|
|
return err
|
|
}
|
|
|
|
n.em.RegisterLatencyCallback(latencyCallback(n))
|
|
n.em.Subscribe(tmtypes.EventStringNewBlockHeader(), newBlockCallback(n))
|
|
n.em.RegisterDisconnectCallback(disconnectCallback(n))
|
|
|
|
n.Online = true
|
|
|
|
n.checkIsValidator()
|
|
go n.checkIsValidatorLoop()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (n *Node) Stop() {
|
|
n.Online = false
|
|
|
|
n.em.RegisterLatencyCallback(nil)
|
|
n.em.Unsubscribe(tmtypes.EventStringNewBlockHeader())
|
|
n.em.RegisterDisconnectCallback(nil)
|
|
|
|
// FIXME stop blocks at event_meter.go:140
|
|
// n.em.Stop()
|
|
|
|
close(n.quit)
|
|
}
|
|
|
|
// implements eventmeter.EventCallbackFunc
|
|
func newBlockCallback(n *Node) em.EventCallbackFunc {
|
|
return func(metric *em.EventMetric, data events.EventData) {
|
|
block := data.(tmtypes.EventDataNewBlockHeader).Header
|
|
|
|
n.Height = uint64(block.Height)
|
|
|
|
if n.blockCh != nil {
|
|
n.blockCh <- *block
|
|
}
|
|
}
|
|
}
|
|
|
|
// implements eventmeter.EventLatencyFunc
|
|
func latencyCallback(n *Node) em.LatencyCallbackFunc {
|
|
return func(latency float64) {
|
|
n.BlockLatency = latency / 1000000.0 // ns to ms
|
|
if n.blockLatencyCh != nil {
|
|
n.blockLatencyCh <- latency
|
|
}
|
|
}
|
|
}
|
|
|
|
// implements eventmeter.DisconnectCallbackFunc
|
|
func disconnectCallback(n *Node) em.DisconnectCallbackFunc {
|
|
return func() {
|
|
n.Online = false
|
|
if n.disconnectCh != nil {
|
|
n.disconnectCh <- true
|
|
}
|
|
|
|
if err := n.RestartBackOff(); err != nil {
|
|
log.Error(err.Error())
|
|
} else {
|
|
n.Online = true
|
|
if n.disconnectCh != nil {
|
|
n.disconnectCh <- false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (n *Node) RestartBackOff() error {
|
|
attempt := 0
|
|
|
|
for {
|
|
d := time.Duration(math.Exp2(float64(attempt)))
|
|
time.Sleep(d * time.Second)
|
|
|
|
if err := n.Start(); err != nil {
|
|
log.Debug("Can't connect to node %v due to %v", n, err)
|
|
} else {
|
|
// TODO: authenticate pubkey
|
|
return nil
|
|
}
|
|
|
|
attempt++
|
|
|
|
if attempt > maxRestarts {
|
|
return fmt.Errorf("Reached max restarts for node %v", n)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (n *Node) NumValidators() (height uint64, num int, err error) {
|
|
height, vals, err := n.validators()
|
|
if err != nil {
|
|
return 0, 0, err
|
|
}
|
|
return height, len(vals), nil
|
|
}
|
|
|
|
func (n *Node) validators() (height uint64, validators []*tmtypes.Validator, err error) {
|
|
var result ctypes.TMResult
|
|
if _, err = n.rpcClient.Call("validators", nil, &result); err != nil {
|
|
return 0, make([]*tmtypes.Validator, 0), err
|
|
}
|
|
vals := result.(*ctypes.ResultValidators)
|
|
return uint64(vals.BlockHeight), vals.Validators, nil
|
|
}
|
|
|
|
func (n *Node) checkIsValidatorLoop() {
|
|
for {
|
|
select {
|
|
case <-n.quit:
|
|
return
|
|
case <-time.After(n.checkIsValidatorInterval):
|
|
n.checkIsValidator()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (n *Node) checkIsValidator() {
|
|
_, validators, err := n.validators()
|
|
if err == nil {
|
|
for _, v := range validators {
|
|
key, err := n.getPubKey()
|
|
if err == nil && v.PubKey == key {
|
|
n.IsValidator = true
|
|
}
|
|
}
|
|
} else {
|
|
log.Debug(err.Error())
|
|
}
|
|
}
|
|
|
|
func (n *Node) getPubKey() (crypto.PubKey, error) {
|
|
if n.pubKey != nil {
|
|
return n.pubKey, nil
|
|
}
|
|
|
|
var result ctypes.TMResult
|
|
_, err := n.rpcClient.Call("status", nil, &result)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
status := result.(*ctypes.ResultStatus)
|
|
n.pubKey = status.PubKey
|
|
return n.pubKey, nil
|
|
}
|
|
|
|
type eventMeter interface {
|
|
Start() (bool, error)
|
|
Stop() bool
|
|
RegisterLatencyCallback(em.LatencyCallbackFunc)
|
|
RegisterDisconnectCallback(em.DisconnectCallbackFunc)
|
|
Subscribe(string, em.EventCallbackFunc) error
|
|
Unsubscribe(string) error
|
|
}
|
|
|
|
// UnmarshalEvent unmarshals a json event
|
|
func UnmarshalEvent(b json.RawMessage) (string, events.EventData, error) {
|
|
var err error
|
|
result := new(ctypes.TMResult)
|
|
wire.ReadJSONPtr(result, b, &err)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
event, ok := (*result).(*ctypes.ResultEvent)
|
|
if !ok {
|
|
return "", nil, nil // TODO: handle non-event messages (ie. return from subscribe/unsubscribe)
|
|
// fmt.Errorf("Result is not type *ctypes.ResultEvent. Got %v", reflect.TypeOf(*result))
|
|
}
|
|
return event.Name, event.Data, nil
|
|
}
|