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.
162 lines
4.5 KiB
162 lines
4.5 KiB
package core
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/tendermint/tendermint/internal/p2p"
|
|
"github.com/tendermint/tendermint/rpc/coretypes"
|
|
rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
|
|
)
|
|
|
|
// NetInfo returns network info.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/net_info
|
|
func (env *Environment) NetInfo(ctx *rpctypes.Context) (*coretypes.ResultNetInfo, error) {
|
|
var peers []coretypes.Peer
|
|
|
|
switch {
|
|
case env.P2PPeers != nil:
|
|
peersList := env.P2PPeers.Peers().List()
|
|
peers = make([]coretypes.Peer, 0, len(peersList))
|
|
for _, peer := range peersList {
|
|
peers = append(peers, coretypes.Peer{
|
|
ID: peer.ID(),
|
|
URL: peer.SocketAddr().String(),
|
|
})
|
|
}
|
|
case env.PeerManager != nil:
|
|
peerList := env.PeerManager.Peers()
|
|
for _, peer := range peerList {
|
|
addrs := env.PeerManager.Addresses(peer)
|
|
if len(addrs) == 0 {
|
|
continue
|
|
}
|
|
|
|
peers = append(peers, coretypes.Peer{
|
|
ID: peer,
|
|
URL: addrs[0].String(),
|
|
})
|
|
}
|
|
default:
|
|
return nil, errors.New("peer management system does not support NetInfo responses")
|
|
}
|
|
|
|
return &coretypes.ResultNetInfo{
|
|
Listening: env.P2PTransport.IsListening(),
|
|
Listeners: env.P2PTransport.Listeners(),
|
|
NPeers: len(peers),
|
|
Peers: peers,
|
|
}, nil
|
|
}
|
|
|
|
// UnsafeDialSeeds dials the given seeds (comma-separated id@IP:PORT).
|
|
func (env *Environment) UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*coretypes.ResultDialSeeds, error) {
|
|
if env.P2PPeers == nil {
|
|
return nil, errors.New("peer management system does not support this operation")
|
|
}
|
|
|
|
if len(seeds) == 0 {
|
|
return &coretypes.ResultDialSeeds{}, fmt.Errorf("%w: no seeds provided", coretypes.ErrInvalidRequest)
|
|
}
|
|
env.Logger.Info("DialSeeds", "seeds", seeds)
|
|
if err := env.P2PPeers.DialPeersAsync(seeds); err != nil {
|
|
return &coretypes.ResultDialSeeds{}, err
|
|
}
|
|
return &coretypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil
|
|
}
|
|
|
|
// UnsafeDialPeers dials the given peers (comma-separated id@IP:PORT),
|
|
// optionally making them persistent.
|
|
func (env *Environment) UnsafeDialPeers(
|
|
ctx *rpctypes.Context,
|
|
peers []string,
|
|
persistent, unconditional, private bool) (*coretypes.ResultDialPeers, error) {
|
|
|
|
if env.P2PPeers == nil {
|
|
return nil, errors.New("peer management system does not support this operation")
|
|
}
|
|
|
|
if len(peers) == 0 {
|
|
return &coretypes.ResultDialPeers{}, fmt.Errorf("%w: no peers provided", coretypes.ErrInvalidRequest)
|
|
}
|
|
|
|
ids, err := getIDs(peers)
|
|
if err != nil {
|
|
return &coretypes.ResultDialPeers{}, err
|
|
}
|
|
|
|
env.Logger.Info("DialPeers", "peers", peers, "persistent",
|
|
persistent, "unconditional", unconditional, "private", private)
|
|
|
|
if persistent {
|
|
if err := env.P2PPeers.AddPersistentPeers(peers); err != nil {
|
|
return &coretypes.ResultDialPeers{}, err
|
|
}
|
|
}
|
|
|
|
if private {
|
|
if err := env.P2PPeers.AddPrivatePeerIDs(ids); err != nil {
|
|
return &coretypes.ResultDialPeers{}, err
|
|
}
|
|
}
|
|
|
|
if unconditional {
|
|
if err := env.P2PPeers.AddUnconditionalPeerIDs(ids); err != nil {
|
|
return &coretypes.ResultDialPeers{}, err
|
|
}
|
|
}
|
|
|
|
if err := env.P2PPeers.DialPeersAsync(peers); err != nil {
|
|
return &coretypes.ResultDialPeers{}, err
|
|
}
|
|
|
|
return &coretypes.ResultDialPeers{Log: "Dialing peers in progress. See /net_info for details"}, nil
|
|
}
|
|
|
|
// Genesis returns genesis file.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/genesis
|
|
func (env *Environment) Genesis(ctx *rpctypes.Context) (*coretypes.ResultGenesis, error) {
|
|
if len(env.genChunks) > 1 {
|
|
return nil, errors.New("genesis response is large, please use the genesis_chunked API instead")
|
|
}
|
|
|
|
return &coretypes.ResultGenesis{Genesis: env.GenDoc}, nil
|
|
}
|
|
|
|
func (env *Environment) GenesisChunked(ctx *rpctypes.Context, chunk uint) (*coretypes.ResultGenesisChunk, error) {
|
|
if env.genChunks == nil {
|
|
return nil, fmt.Errorf("service configuration error, genesis chunks are not initialized")
|
|
}
|
|
|
|
if len(env.genChunks) == 0 {
|
|
return nil, fmt.Errorf("service configuration error, there are no chunks")
|
|
}
|
|
|
|
id := int(chunk)
|
|
|
|
if id > len(env.genChunks)-1 {
|
|
return nil, fmt.Errorf("there are %d chunks, %d is invalid", len(env.genChunks)-1, id)
|
|
}
|
|
|
|
return &coretypes.ResultGenesisChunk{
|
|
TotalChunks: len(env.genChunks),
|
|
ChunkNumber: id,
|
|
Data: env.genChunks[id],
|
|
}, nil
|
|
}
|
|
|
|
func getIDs(peers []string) ([]string, error) {
|
|
ids := make([]string, 0, len(peers))
|
|
|
|
for _, peer := range peers {
|
|
|
|
spl := strings.Split(peer, "@")
|
|
if len(spl) != 2 {
|
|
return nil, p2p.ErrNetAddressNoID{Addr: peer}
|
|
}
|
|
ids = append(ids, spl[0])
|
|
|
|
}
|
|
return ids, nil
|
|
}
|