aboutsummaryrefslogtreecommitdiffstats
path: root/blockpool/status.go
blob: 02e3585104cc9b16c28805a54b32aabb58a47f11 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package blockpool

import (
    "fmt"
    "sync"

    "github.com/ethereum/go-ethereum/common"
)

type statusValues struct {
    BlockHashes       int    // number of hashes fetched this session
    BlockHashesInPool int    // number of hashes currently in  the pool
    Blocks            int    // number of blocks fetched this session
    BlocksInPool      int    // number of blocks currently in  the pool
    BlocksInChain     int    // number of blocks inserted/connected to the blockchain this session
    NewBlocks         int    // number of new blocks (received with new blocks msg) this session
    Forks             int    // number of chain forks in the blockchain (poolchain) this session
    LongestChain      int    // the longest chain inserted since the start of session (aka session blockchain height)
    BestPeer          []byte //Pubkey
    Syncing           bool   // requesting, updating etc
    Peers             int    // cumulative number of all different registered peers since the start of this session
    ActivePeers       int    // cumulative number of all different peers that contributed a hash or block since the start of this session
    LivePeers         int    // number of live peers registered with the block pool (supposed to be redundant but good sanity check
    BestPeers         int    // cumulative number of all peers that at some point were promoted as best peer (peer with highest TD status) this session
    BadPeers          int    // cumulative number of all peers that violated the protocol (invalid block or pow, unrequested hash or block, etc)
}

type status struct {
    lock        sync.Mutex
    values      statusValues
    chain       map[common.Hash]int
    peers       map[string]int
    bestPeers   map[string]int
    badPeers    map[string]int
    activePeers map[string]int
}

func newStatus() *status {
    return &status{
        chain:       make(map[common.Hash]int),
        peers:       make(map[string]int),
        bestPeers:   make(map[string]int),
        badPeers:    make(map[string]int),
        activePeers: make(map[string]int),
    }
}

type Status struct {
    statusValues
}

// blockpool status for reporting
func (self *BlockPool) Status() *Status {
    self.status.lock.Lock()
    defer self.status.lock.Unlock()
    self.status.values.ActivePeers = len(self.status.activePeers)
    self.status.values.BestPeers = len(self.status.bestPeers)
    self.status.values.BadPeers = len(self.status.badPeers)
    self.status.values.LivePeers = len(self.peers.peers)
    self.status.values.Peers = len(self.status.peers)
    self.status.values.BlockHashesInPool = len(self.pool)
    return &Status{self.status.values}
}

func (self *Status) String() string {
    return fmt.Sprintf(`
  Syncing:            %v
  BlockHashes:        %v
  BlockHashesInPool:  %v
  Blocks:             %v
  BlocksInPool:       %v
  BlocksInChain:      %v
  NewBlocks:          %v
  Forks:              %v
  LongestChain:       %v
  Peers:              %v
  LivePeers:          %v
  ActivePeers:        %v
  BestPeers:          %v
  BadPeers:           %v
`,
        self.Syncing,
        self.BlockHashes,
        self.BlockHashesInPool,
        self.Blocks,
        self.BlocksInPool,
        self.BlocksInChain,
        self.NewBlocks,
        self.Forks,
        self.LongestChain,
        self.Peers,
        self.LivePeers,
        self.ActivePeers,
        self.BestPeers,
        self.BadPeers,
    )
}

func (self *BlockPool) syncing() {
    self.status.lock.Lock()
    defer self.status.lock.Unlock()
    if !self.status.values.Syncing {
        self.status.values.Syncing = true
        go func() {
            self.wg.Wait()
            self.status.lock.Lock()
            self.status.values.Syncing = false
            self.status.lock.Unlock()
        }()
    }
}