modify field name (#1202)

[bytom/bytom-spv.git] / api / nodeinfo.go

diff --git a/api/nodeinfo.go b/api/nodeinfo.go
index 62f1d51..ccf4c8f 100644 (file)
--- a/api/nodeinfo.go
+++ b/api/nodeinfo.go
@@ -1,6 +1,12 @@
 package api
 
 import (
+       "context"
+       "net"
+
+       "github.com/bytom/errors"
+       "github.com/bytom/netsync"
+       "github.com/bytom/p2p"
        "github.com/bytom/version"
 )
 
@@ -20,21 +26,59 @@ type NetInfo struct {
 func (a *API) GetNodeInfo() *NetInfo {
        info := &NetInfo{
                Listening:    a.sync.Switch().IsListening(),
-               Syncing:      a.sync.BlockKeeper().IsCaughtUp(),
+               Syncing:      !a.sync.IsCaughtUp(),
                Mining:       a.cpuMiner.IsMining(),
                PeerCount:    len(a.sync.Switch().Peers().List()),
                CurrentBlock: a.chain.BestBlockHeight(),
                NetWorkID:    a.sync.NodeInfo().Network,
                Version:      version.Version,
        }
-       _, info.HighestBlock = a.sync.Peers().BestPeer()
+       if bestPeer := a.sync.BestPeer(); bestPeer != nil {
+               info.HighestBlock = bestPeer.Height
+       }
        if info.CurrentBlock > info.HighestBlock {
                info.HighestBlock = info.CurrentBlock
        }
        return info
 }
 
-// getNetInfo return network infomation
+// return the currently connected peers with net address
+func (a *API) getPeerInfoByAddr(addr string) *netsync.PeerInfo {
+       peerInfos := a.sync.GetPeerInfos()
+       for _, peerInfo := range peerInfos {
+               if peerInfo.RemoteAddr == addr {
+                       return peerInfo
+               }
+       }
+       return nil
+}
+
+// disconnect peer by the peer id
+func (a *API) disconnectPeerById(peerID string) error {
+       return a.sync.StopPeer(peerID)
+}
+
+// connect peer b y net address
+func (a *API) connectPeerByIpAndPort(ip string, port uint16) (*netsync.PeerInfo, error) {
+       netIp := net.ParseIP(ip)
+       if netIp == nil {
+               return nil, errors.New("invalid ip address")
+       }
+
+       addr := p2p.NewNetAddressIPPort(netIp, port)
+       sw := a.sync.Switch()
+
+       if err := sw.DialPeerWithAddress(addr); err != nil {
+               return nil, errors.Wrap(err, "can not connect to the address")
+       }
+       peer := a.getPeerInfoByAddr(addr.String())
+       if peer == nil {
+               return nil, errors.New("the peer is disconnected again")
+       }
+       return peer, nil
+}
+
+// getNetInfo return network information
 func (a *API) getNetInfo() Response {
        return NewSuccessResponse(a.GetNodeInfo())
 }
@@ -49,3 +93,30 @@ func (a *API) isMining() Response {
 func (a *API) IsMining() bool {
        return a.cpuMiner.IsMining()
 }
+
+// return the peers of current node
+func (a *API) listPeers() Response {
+       return NewSuccessResponse(a.sync.GetPeerInfos())
+}
+
+// disconnect peer
+func (a *API) disconnectPeer(ctx context.Context, ins struct {
+       PeerID string `json:"peer_id"`
+}) Response {
+       if err := a.disconnectPeerById(ins.PeerID); err != nil {
+               return NewErrorResponse(err)
+       }
+       return NewSuccessResponse(nil)
+}
+
+// connect peer by ip and port
+func (a *API) connectPeer(ctx context.Context, ins struct {
+       Ip   string `json:"ip"`
+       Port uint16 `json:"port"`
+}) Response {
+       if peer, err := a.connectPeerByIpAndPort(ins.Ip, ins.Port); err != nil {
+               return NewErrorResponse(err)
+       } else {
+               return NewSuccessResponse(peer)
+       }
+}