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.
254 lines
6.3 KiB
254 lines
6.3 KiB
package handlers
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/tendermint/go-event-meter"
|
|
"github.com/tendermint/go-wire"
|
|
|
|
"github.com/tendermint/netmon/types"
|
|
)
|
|
|
|
type NetMonResult interface {
|
|
}
|
|
|
|
// for wire.readReflect
|
|
var _ = wire.RegisterInterface(
|
|
struct{ NetMonResult }{},
|
|
wire.ConcreteType{&types.ChainAndValidatorSetIDs{}, 0x01},
|
|
wire.ConcreteType{&types.ChainState{}, 0x02},
|
|
wire.ConcreteType{&types.ValidatorSet{}, 0x10},
|
|
wire.ConcreteType{&types.Validator{}, 0x11},
|
|
wire.ConcreteType{&types.ValidatorConfig{}, 0x12},
|
|
wire.ConcreteType{&eventmeter.EventMetric{}, 0x20},
|
|
)
|
|
|
|
//---------------------------------------------
|
|
// global state and backend functions
|
|
|
|
// TODO: relax the locking (use RWMutex, reduce scope)
|
|
type TendermintNetwork struct {
|
|
mtx sync.Mutex
|
|
Chains map[string]*types.ChainState `json:"blockchains"`
|
|
ValSets map[string]*types.ValidatorSet `json:"validator_sets"`
|
|
}
|
|
|
|
func NewTendermintNetwork() *TendermintNetwork {
|
|
network := &TendermintNetwork{
|
|
Chains: make(map[string]*types.ChainState),
|
|
ValSets: make(map[string]*types.ValidatorSet),
|
|
}
|
|
return network
|
|
}
|
|
|
|
//------------
|
|
// Public Methods
|
|
|
|
func (tn *TendermintNetwork) Stop() {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
wg := new(sync.WaitGroup)
|
|
for _, c := range tn.Chains {
|
|
for _, v := range c.Config.Validators {
|
|
wg.Add(1)
|
|
go func(val *types.ValidatorState) {
|
|
val.Stop()
|
|
wg.Done()
|
|
}(v)
|
|
}
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
//-----------------------------------------------------------
|
|
// RPC funcs
|
|
//-----------------------------------------------------------
|
|
|
|
//------------------
|
|
// Status
|
|
|
|
// Returns sorted lists of all chains and validator sets
|
|
func (tn *TendermintNetwork) Status() (*types.ChainAndValidatorSetIDs, error) {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
chains := make([]string, len(tn.Chains))
|
|
valSets := make([]string, len(tn.ValSets))
|
|
i := 0
|
|
for chain, _ := range tn.Chains {
|
|
chains[i] = chain
|
|
i += 1
|
|
}
|
|
i = 0
|
|
for valset, _ := range tn.ValSets {
|
|
valSets[i] = valset
|
|
i += 1
|
|
}
|
|
sort.StringSlice(chains).Sort()
|
|
sort.StringSlice(valSets).Sort()
|
|
return &types.ChainAndValidatorSetIDs{
|
|
ChainIDs: chains,
|
|
ValidatorSetIDs: valSets,
|
|
}, nil
|
|
|
|
}
|
|
|
|
// NOTE: returned values should not be manipulated by callers as they are pointers to the state!
|
|
//------------------
|
|
// Blockchains
|
|
|
|
// Get the current state of a chain
|
|
func (tn *TendermintNetwork) GetChain(chainID string) (*types.ChainState, error) {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
chain, ok := tn.Chains[chainID]
|
|
if !ok {
|
|
return nil, fmt.Errorf("Unknown chain %s", chainID)
|
|
}
|
|
chain.Status.RealTimeUpdates()
|
|
return chain, nil
|
|
}
|
|
|
|
// Register a new chain on the network.
|
|
// For each validator, start a websocket connection to listen for new block events and record latency
|
|
func (tn *TendermintNetwork) RegisterChain(chainConfig *types.BlockchainConfig) (*types.ChainState, error) {
|
|
// Don't bother locking until we touch the TendermintNetwork object
|
|
|
|
chainState := &types.ChainState{
|
|
Config: chainConfig,
|
|
Status: types.NewBlockchainStatus(),
|
|
}
|
|
chainState.Status.NumValidators = len(chainConfig.Validators)
|
|
|
|
// so we can easily lookup validators by id rather than index
|
|
chainState.Config.PopulateValIDMap()
|
|
|
|
// start the event meter and listen for new blocks on each validator
|
|
for _, v := range chainConfig.Validators {
|
|
v.Status = &types.ValidatorStatus{}
|
|
|
|
var err error
|
|
RETRYLOOP:
|
|
for i := 0; i < 10; i++ {
|
|
if err = v.Start(); err == nil {
|
|
break RETRYLOOP
|
|
}
|
|
time.Sleep(time.Second)
|
|
}
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Error starting validator %s: %v", v.Config.Validator.ID, err)
|
|
}
|
|
|
|
// register callbacks for the validator
|
|
tn.registerCallbacks(chainState, v)
|
|
|
|
// the DisconnectCallback will set us offline and start a reconnect routine
|
|
chainState.Status.SetOnline(v, true)
|
|
|
|
// get/set the validator's pub key
|
|
// TODO: make this authenticate...
|
|
v.PubKey()
|
|
}
|
|
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
tn.Chains[chainState.Config.ID] = chainState
|
|
return chainState, nil
|
|
}
|
|
|
|
//------------------
|
|
// Validators
|
|
|
|
func (tn *TendermintNetwork) GetValidatorSet(valSetID string) (*types.ValidatorSet, error) {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
valSet, ok := tn.ValSets[valSetID]
|
|
if !ok {
|
|
return nil, fmt.Errorf("Unknown validator set %s", valSetID)
|
|
}
|
|
return valSet, nil
|
|
}
|
|
|
|
func (tn *TendermintNetwork) RegisterValidatorSet(valSet *types.ValidatorSet) (*types.ValidatorSet, error) {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
tn.ValSets[valSet.ID] = valSet
|
|
return valSet, nil
|
|
}
|
|
|
|
func (tn *TendermintNetwork) GetValidator(valSetID, valID string) (*types.Validator, error) {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
valSet, ok := tn.ValSets[valSetID]
|
|
if !ok {
|
|
return nil, fmt.Errorf("Unknown validator set %s", valSetID)
|
|
}
|
|
val, err := valSet.Validator(valID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return val, nil
|
|
}
|
|
|
|
// Update the validator's rpc address (for now its the only thing that can be updated!)
|
|
func (tn *TendermintNetwork) UpdateValidator(chainID, valID, rpcAddr string) (*types.ValidatorConfig, error) {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
val, err := tn.getChainVal(chainID, valID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
val.Config.UpdateRPCAddress(rpcAddr)
|
|
log.Debug("Update validator rpc address", "chain", chainID, "val", valID, "rpcAddr", rpcAddr)
|
|
return val.Config, nil
|
|
}
|
|
|
|
//------------------
|
|
// Event metering
|
|
|
|
func (tn *TendermintNetwork) StartMeter(chainID, valID, eventID string) error {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
val, err := tn.getChainVal(chainID, valID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return val.EventMeter().Subscribe(eventID, nil)
|
|
}
|
|
|
|
func (tn *TendermintNetwork) StopMeter(chainID, valID, eventID string) error {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
val, err := tn.getChainVal(chainID, valID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return val.EventMeter().Unsubscribe(eventID)
|
|
}
|
|
|
|
func (tn *TendermintNetwork) GetMeter(chainID, valID, eventID string) (*eventmeter.EventMetric, error) {
|
|
tn.mtx.Lock()
|
|
defer tn.mtx.Unlock()
|
|
val, err := tn.getChainVal(chainID, valID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return val.EventMeter().GetMetric(eventID)
|
|
}
|
|
|
|
// assumes lock is held
|
|
func (tn *TendermintNetwork) getChainVal(chainID, valID string) (*types.ValidatorState, error) {
|
|
chain, ok := tn.Chains[chainID]
|
|
if !ok {
|
|
return nil, fmt.Errorf("Unknown chain %s", chainID)
|
|
}
|
|
val, err := chain.Config.GetValidatorByID(valID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return val, nil
|
|
}
|