fix log

[bytom/vapor.git] / toolbar / precog / monitor / monitor.go

diff --git a/toolbar/precog/monitor/monitor.go b/toolbar/precog/monitor/monitor.go
index 8b8c74e..e934990 100644 (file)
--- a/toolbar/precog/monitor/monitor.go
+++ b/toolbar/precog/monitor/monitor.go
@@ -2,7 +2,6 @@ package monitor
 
 import (
        "fmt"
-       "io/ioutil"
        "os"
        "os/user"
        "strings"
@@ -35,20 +34,17 @@ type monitor struct {
        privKey chainkd.XPrv
        chain   *mock.Chain
        txPool  *mock.Mempool
-       // nodeMap maps a node's public key to the node itself
-       nodeMap       map[string]*dht.Node
-       dialCh        chan struct{}
-       checkStatusCh chan struct{}
+       // discvMap maps a node's public key to the node itself
+       discvMap       map[string]*dht.Node
+       dialCh         chan struct{}
+       checkStatusCh  chan struct{}
+       bestHeightSeen uint64
 }
 
-// TODO: set myself as SPV?
 func NewMonitor(cfg *config.Config, db *gorm.DB) *monitor {
-       //TODO: for test
-       cfg.CheckFreqSeconds = 15
-
        dbPath, err := makePath()
        if err != nil {
-               log.Fatal(err)
+               log.WithFields(log.Fields{"err": err}).Fatal("makePath")
        }
 
        nodeCfg := &vaporCfg.Config{
@@ -60,25 +56,26 @@ func NewMonitor(cfg *config.Config, db *gorm.DB) *monitor {
        nodeCfg.ChainID = "mainnet"
        privKey, err := signlib.NewPrivKey()
        if err != nil {
-               log.Fatal(err)
+               log.WithFields(log.Fields{"err": err}).Fatal("NewPrivKey")
        }
 
        chain, txPool, err := mockChainAndPool()
        if err != nil {
-               log.Fatal(err)
+               log.WithFields(log.Fields{"err": err}).Fatal("mockChainAndPool")
        }
 
        return &monitor{
-               RWMutex:       &sync.RWMutex{},
-               cfg:           cfg,
-               db:            db,
-               nodeCfg:       nodeCfg,
-               privKey:       privKey.(chainkd.XPrv),
-               chain:         chain,
-               txPool:        txPool,
-               nodeMap:       make(map[string]*dht.Node),
-               dialCh:        make(chan struct{}, 1),
-               checkStatusCh: make(chan struct{}, 1),
+               RWMutex:        &sync.RWMutex{},
+               cfg:            cfg,
+               db:             db,
+               nodeCfg:        nodeCfg,
+               privKey:        privKey.(chainkd.XPrv),
+               chain:          chain,
+               txPool:         txPool,
+               discvMap:       make(map[string]*dht.Node),
+               dialCh:         make(chan struct{}, 1),
+               checkStatusCh:  make(chan struct{}, 1),
+               bestHeightSeen: uint64(0),
        }
 }
 
@@ -88,38 +85,32 @@ func makePath() (string, error) {
                return "", err
        }
 
-       dataPath := usr.HomeDir + "/.precog"
+       dataPath := usr.HomeDir + "/.vapor/precog"
        if err := os.MkdirAll(dataPath, os.ModePerm); err != nil {
                return "", err
        }
 
-       tmpDir, err := ioutil.TempDir(dataPath, "")
-       if err != nil {
-               return "", err
-       }
-
-       return tmpDir, nil
+       return dataPath, nil
 }
 
 func (m *monitor) Run() {
-       defer os.RemoveAll(m.nodeCfg.DBPath)
-
        var seeds []string
        for _, node := range m.cfg.Nodes {
-               seeds = append(seeds, fmt.Sprintf("%s:%d", node.Host, node.Port))
+               seeds = append(seeds, fmt.Sprintf("%s:%d", node.IP, node.Port))
                if err := m.upSertNode(&node); err != nil {
-                       log.Error(err)
+                       log.WithFields(log.Fields{
+                               "node": node,
+                               "err":  err,
+                       }).Error("upSertNode")
                }
        }
        m.nodeCfg.P2P.Seeds = strings.Join(seeds, ",")
        if err := m.makeSwitch(); err != nil {
-               log.Fatal(err)
+               log.WithFields(log.Fields{"err": err}).Fatal("makeSwitch")
        }
 
        m.dialCh <- struct{}{}
-       // var discvWg sync.WaitGroup
-       go m.discoveryRoutine( /*&discvWg*/ )
-       // go m.collectDiscoveredNodes(&discvWg)
+       go m.discoveryRoutine()
        go m.connectNodesRoutine()
        go m.checkStatusRoutine()
 }
@@ -133,12 +124,11 @@ func (m *monitor) makeSwitch() error {
 
        // no need for lanDiscv, but passing &mdns.LANDiscover{} will cause NilPointer
        lanDiscv := mdns.NewLANDiscover(mdns.NewProtocol(), int(l.ExternalAddress().Port))
-       sw, err := p2p.NewSwitch(m.nodeCfg, discv, lanDiscv, l, m.privKey, listenAddr, m.cfg.NetworkID)
+       m.sw, err = p2p.NewSwitch(m.nodeCfg, discv, lanDiscv, l, m.privKey, listenAddr, m.cfg.NetworkID)
        if err != nil {
                return err
        }
 
-       m.sw = sw
        return nil
 }
 
@@ -148,13 +138,15 @@ func (m *monitor) prepareReactors(peers *peers.PeerSet) error {
        _ = consensusmgr.NewManager(m.sw, m.chain, peers, dispatcher)
        fastSyncDB := dbm.NewDB("fastsync", m.nodeCfg.DBBackend, m.nodeCfg.DBDir())
        // add ProtocolReactor to handle msgs
-       _, err := chainmgr.NewManager(m.nodeCfg, m.sw, m.chain, m.txPool, dispatcher, peers, fastSyncDB)
-       if err != nil {
+       if _, err := chainmgr.NewManager(m.nodeCfg, m.sw, m.chain, m.txPool, dispatcher, peers, fastSyncDB); err != nil {
                return err
        }
 
        for label, reactor := range m.sw.GetReactors() {
-               log.Debugf("start reactor: (%s:%v)", label, reactor)
+               log.WithFields(log.Fields{
+                       "label":   label,
+                       "reactor": reactor,
+               }).Debug("start reactor")
                if _, err := reactor.Start(); err != nil {
                        return nil
                }
@@ -168,16 +160,18 @@ func (m *monitor) prepareReactors(peers *peers.PeerSet) error {
 func (m *monitor) checkStatusRoutine() {
        peers := peers.NewPeerSet(m.sw)
        if err := m.prepareReactors(peers); err != nil {
-               log.Fatal(err)
+               log.WithFields(log.Fields{"err": err}).Fatal("prepareReactors")
        }
 
-       bestHeight := uint64(0)
        for range m.checkStatusCh {
                for _, peer := range m.sw.GetPeers().List() {
                        peer.Start()
                        peers.AddPeer(peer)
                }
-               log.Infof("%d connected peers: %v", len(m.sw.GetPeers().List()), m.sw.GetPeers().List())
+               log.WithFields(log.Fields{
+                       "num":   len(m.sw.GetPeers().List()),
+                       "peers": m.sw.GetPeers().List(),
+               }).Info("connected peers")
 
                for _, peer := range m.sw.GetPeers().List() {
                        p := peers.GetPeer(peer.ID())
@@ -185,18 +179,21 @@ func (m *monitor) checkStatusRoutine() {
                                continue
                        }
 
-                       if err := p.SendStatus(m.chain.BestBlockHeader(), m.chain.LastIrreversibleHeader()); err != nil {
-                               log.Error(err)
+                       if err := p.(m.chain.BestBlockHeader(), m.chain.LastIrreversibleHeader()); err != nil {
+                               log.WithFields(log.Fields{
+                                       "peer": p,
+                                       "err": err,
+                                       }).Error("SendStatus")
                                peers.RemovePeer(p.ID())
                        }
                }
 
                for _, peerInfo := range peers.GetPeerInfos() {
-                       if peerInfo.Height > bestHeight {
-                               bestHeight = peerInfo.Height
+                       if peerInfo.Height > m.bestHeightSeen {
+                               m.bestHeightSeen = peerInfo.Height
                        }
                }
-               log.Info("bestHeight: ", bestHeight)
+               log.Info("bestHeight: ", m.bestHeightSeen)
                m.processPeerInfos(peers.GetPeerInfos())
 
                for _, peer := range m.sw.GetPeers().List() {
@@ -208,6 +205,7 @@ func (m *monitor) checkStatusRoutine() {
                        peers.RemovePeer(p.ID())
                }
                log.Info("Disonnect all peers.")
+
                m.Unlock()
                m.dialCh <- struct{}{}
        }