forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-17 18:30:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

styel(p2p): golint updates for this or self warning #16577 (#2007)

Browse source
This commit is contained in:
Daniel Liu 2026-02-06 15:55:53 +08:00 committed by GitHub
parent 6fc437394c
commit 59e9c72d94
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 87 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

138
p2p/discv5/topic.go
View file

@ -90,70 +90,70 @@ func newTopicTable(db *nodeDB, self *Node) *topicTable {
} }
} }
func (topictab *topicTable) getOrNewTopic(topic Topic) *topicInfo { func (t *topicTable) getOrNewTopic(topic Topic) *topicInfo {
ti := topictab.topics[topic] ti := t.topics[topic]
if ti == nil { if ti == nil {
rqItem := &topicRequestQueueItem{ rqItem := &topicRequestQueueItem{
topic: topic, topic: topic,
priority: topictab.requestCnt, priority: t.requestCnt,
} }
ti = &topicInfo{ ti = &topicInfo{
entries: make(map[uint64]*topicEntry), entries: make(map[uint64]*topicEntry),
rqItem: rqItem, rqItem: rqItem,
} }
topictab.topics[topic] = ti t.topics[topic] = ti
heap.Push(&topictab.requested, rqItem) heap.Push(&t.requested, rqItem)
} }
return ti return ti
} }
func (topictab *topicTable) checkDeleteTopic(topic Topic) { func (t *topicTable) checkDeleteTopic(topic Topic) {
ti := topictab.topics[topic] ti := t.topics[topic]
if ti == nil { if ti == nil {
return return
} }
if len(ti.entries) == 0 && ti.wcl.hasMinimumWaitPeriod() { if len(ti.entries) == 0 && ti.wcl.hasMinimumWaitPeriod() {
delete(topictab.topics, topic) delete(t.topics, topic)
heap.Remove(&topictab.requested, ti.rqItem.index) heap.Remove(&t.requested, ti.rqItem.index)
} }
} }
func (topictab *topicTable) getOrNewNode(node *Node) *nodeInfo { func (t *topicTable) getOrNewNode(node *Node) *nodeInfo {
n := topictab.nodes[node] n := t.nodes[node]
if n == nil { if n == nil {
//fmt.Printf("newNode %016x %016x\n", t.self.sha[:8], node.sha[:8]) //fmt.Printf("newNode %016x %016x\n", t.self.sha[:8], node.sha[:8])
var issued, used uint32 var issued, used uint32
if topictab.db != nil { if t.db != nil {
issued, used = topictab.db.fetchTopicRegTickets(node.ID) issued, used = t.db.fetchTopicRegTickets(node.ID)
} }
n = &nodeInfo{ n = &nodeInfo{
entries: make(map[Topic]*topicEntry), entries: make(map[Topic]*topicEntry),
lastIssuedTicket: issued, lastIssuedTicket: issued,
lastUsedTicket: used, lastUsedTicket: used,
} }
topictab.nodes[node] = n t.nodes[node] = n
} }
return n return n
} }
func (topictab *topicTable) checkDeleteNode(node *Node) { func (t *topicTable) checkDeleteNode(node *Node) {
if n, ok := topictab.nodes[node]; ok && len(n.entries) == 0 && n.noRegUntil < mclock.Now() { if n, ok := t.nodes[node]; ok && len(n.entries) == 0 && n.noRegUntil < mclock.Now() {
//fmt.Printf("deleteNode %016x %016x\n", t.self.sha[:8], node.sha[:8]) //fmt.Printf("deleteNode %016x %016x\n", t.self.sha[:8], node.sha[:8])
delete(topictab.nodes, node) delete(t.nodes, node)
} }
} }
func (topictab *topicTable) storeTicketCounters(node *Node) { func (t *topicTable) storeTicketCounters(node *Node) {
n := topictab.getOrNewNode(node) n := t.getOrNewNode(node)
if topictab.db != nil { if t.db != nil {
topictab.db.updateTopicRegTickets(node.ID, n.lastIssuedTicket, n.lastUsedTicket) t.db.updateTopicRegTickets(node.ID, n.lastIssuedTicket, n.lastUsedTicket)
} }
} }
func (topictab *topicTable) getEntries(topic Topic) []*Node { func (t *topicTable) getEntries(topic Topic) []*Node {
topictab.collectGarbage() t.collectGarbage()
te := topictab.topics[topic] te := t.topics[topic]
if te == nil { if te == nil {
return nil return nil
} }
@ -163,29 +163,29 @@ func (topictab *topicTable) getEntries(topic Topic) []*Node {
nodes[i] = e.node nodes[i] = e.node
i++ i++
} }
topictab.requestCnt++ t.requestCnt++
topictab.requested.update(te.rqItem, topictab.requestCnt) t.requested.update(te.rqItem, t.requestCnt)
return nodes return nodes
} }
func (topictab *topicTable) addEntry(node *Node, topic Topic) { func (t *topicTable) addEntry(node *Node, topic Topic) {
n := topictab.getOrNewNode(node) n := t.getOrNewNode(node)
// clear previous entries by the same node // clear previous entries by the same node
for _, e := range n.entries { for _, e := range n.entries {
topictab.deleteEntry(e) t.deleteEntry(e)
} }
// *** // ***
n = topictab.getOrNewNode(node) n = t.getOrNewNode(node)
tm := mclock.Now() tm := mclock.Now()
te := topictab.getOrNewTopic(topic) te := t.getOrNewTopic(topic)
if len(te.entries) == maxEntriesPerTopic { if len(te.entries) == maxEntriesPerTopic {
topictab.deleteEntry(te.getFifoTail()) t.deleteEntry(te.getFifoTail())
} }
if topictab.globalEntries == maxEntries { if t.globalEntries == maxEntries {
topictab.deleteEntry(topictab.leastRequested()) // not empty, no need to check for nil t.deleteEntry(t.leastRequested()) // not empty, no need to check for nil
} }
fifoIdx := te.fifoHead fifoIdx := te.fifoHead
@ -197,50 +197,50 @@ func (topictab *topicTable) addEntry(node *Node, topic Topic) {
expire: tm.Add(fallbackRegistrationExpiry), expire: tm.Add(fallbackRegistrationExpiry),
} }
if printTestImgLogs { if printTestImgLogs {
fmt.Printf("*+ %d %v %016x %016x\n", tm/1000000, topic, topictab.self.sha[:8], node.sha[:8]) fmt.Printf("*+ %d %v %016x %016x\n", tm/1000000, topic, t.self.sha[:8], node.sha[:8])
} }
te.entries[fifoIdx] = entry te.entries[fifoIdx] = entry
n.entries[topic] = entry n.entries[topic] = entry
topictab.globalEntries++ t.globalEntries++
te.wcl.registered(tm) te.wcl.registered(tm)
} }
// removes least requested element from the fifo // removes least requested element from the fifo
func (topictab *topicTable) leastRequested() *topicEntry { func (t *topicTable) leastRequested() *topicEntry {
for topictab.requested.Len() > 0 && topictab.topics[topictab.requested[0].topic] == nil { for t.requested.Len() > 0 && t.topics[t.requested[0].topic] == nil {
heap.Pop(&topictab.requested) heap.Pop(&t.requested)
} }
if topictab.requested.Len() == 0 { if t.requested.Len() == 0 {
return nil return nil
} }
return topictab.topics[topictab.requested[0].topic].getFifoTail() return t.topics[t.requested[0].topic].getFifoTail()
} }
// entry should exist // entry should exist
func (topictab *topicTable) deleteEntry(e *topicEntry) { func (t *topicTable) deleteEntry(e *topicEntry) {
if printTestImgLogs { if printTestImgLogs {
fmt.Printf("*- %d %v %016x %016x\n", mclock.Now()/1000000, e.topic, topictab.self.sha[:8], e.node.sha[:8]) fmt.Printf("*- %d %v %016x %016x\n", mclock.Now()/1000000, e.topic, t.self.sha[:8], e.node.sha[:8])
} }
ne := topictab.nodes[e.node].entries ne := t.nodes[e.node].entries
delete(ne, e.topic) delete(ne, e.topic)
if len(ne) == 0 { if len(ne) == 0 {
topictab.checkDeleteNode(e.node) t.checkDeleteNode(e.node)
} }
te := topictab.topics[e.topic] te := t.topics[e.topic]
delete(te.entries, e.fifoIdx) delete(te.entries, e.fifoIdx)
if len(te.entries) == 0 { if len(te.entries) == 0 {
topictab.checkDeleteTopic(e.topic) t.checkDeleteTopic(e.topic)
} }
topictab.globalEntries-- t.globalEntries--
} }
// It is assumed that topics and waitPeriods have the same length. // It is assumed that topics and waitPeriods have the same length.
func (topictab *topicTable) useTicket(node *Node, serialNo uint32, topics []Topic, idx int, issueTime uint64, waitPeriods []uint32) (registered bool) { func (t *topicTable) useTicket(node *Node, serialNo uint32, topics []Topic, idx int, issueTime uint64, waitPeriods []uint32) (registered bool) {
log.Trace("Using discovery ticket", "serial", serialNo, "topics", topics, "waits", waitPeriods) log.Trace("Using discovery ticket", "serial", serialNo, "topics", topics, "waits", waitPeriods)
//fmt.Println("useTicket", serialNo, topics, waitPeriods) //fmt.Println("useTicket", serialNo, topics, waitPeriods)
topictab.collectGarbage() t.collectGarbage()
n := topictab.getOrNewNode(node) n := t.getOrNewNode(node)
if serialNo < n.lastUsedTicket { if serialNo < n.lastUsedTicket {
return false return false
} }
@ -252,7 +252,7 @@ func (topictab *topicTable) useTicket(node *Node, serialNo uint32, topics []Topi
if serialNo != n.lastUsedTicket { if serialNo != n.lastUsedTicket {
n.lastUsedTicket = serialNo n.lastUsedTicket = serialNo
n.noRegUntil = tm.Add(noRegTimeout()) n.noRegUntil = tm.Add(noRegTimeout())
topictab.storeTicketCounters(node) t.storeTicketCounters(node)
} }
currTime := uint64(tm / mclock.AbsTime(time.Second)) currTime := uint64(tm / mclock.AbsTime(time.Second))
@ -260,7 +260,7 @@ func (topictab *topicTable) useTicket(node *Node, serialNo uint32, topics []Topi
relTime := int64(currTime - regTime) relTime := int64(currTime - regTime)
if relTime >= -1 && relTime <= regTimeWindow+1 { // give clients a little security margin on both ends if relTime >= -1 && relTime <= regTimeWindow+1 { // give clients a little security margin on both ends
if e := n.entries[topics[idx]]; e == nil { if e := n.entries[topics[idx]]; e == nil {
topictab.addEntry(node, topics[idx]) t.addEntry(node, topics[idx])
} else { } else {
// if there is an active entry, don't move to the front of the FIFO but prolong expire time // if there is an active entry, don't move to the front of the FIFO but prolong expire time
e.expire = tm.Add(fallbackRegistrationExpiry) e.expire = tm.Add(fallbackRegistrationExpiry)
@ -271,15 +271,15 @@ func (topictab *topicTable) useTicket(node *Node, serialNo uint32, topics []Topi
return false return false
} }
func (topictab *topicTable) getTicket(node *Node, topics []Topic) *ticket { func (t *topicTable) getTicket(node *Node, topics []Topic) *ticket {
topictab.collectGarbage() t.collectGarbage()
now := mclock.Now() now := mclock.Now()
n := topictab.getOrNewNode(node) n := t.getOrNewNode(node)
n.lastIssuedTicket++ n.lastIssuedTicket++
topictab.storeTicketCounters(node) t.storeTicketCounters(node)
t := &ticket{ tic := &ticket{
issueTime: now, issueTime: now,
topics: topics, topics: topics,
serial: n.lastIssuedTicket, serial: n.lastIssuedTicket,
@ -287,38 +287,38 @@ func (topictab *topicTable) getTicket(node *Node, topics []Topic) *ticket {
} }
for i, topic := range topics { for i, topic := range topics {
var waitPeriod time.Duration var waitPeriod time.Duration
if topic := topictab.topics[topic]; topic != nil { if topic := t.topics[topic]; topic != nil {
waitPeriod = topic.wcl.waitPeriod waitPeriod = topic.wcl.waitPeriod
} else { } else {
waitPeriod = minWaitPeriod waitPeriod = minWaitPeriod
} }
t.regTime[i] = now.Add(waitPeriod) tic.regTime[i] = now.Add(waitPeriod)
} }
return t return tic
} }
const gcInterval = time.Minute const gcInterval = time.Minute
func (topictab *topicTable) collectGarbage() { func (t *topicTable) collectGarbage() {
tm := mclock.Now() tm := mclock.Now()
if time.Duration(tm-topictab.lastGarbageCollection) < gcInterval { if time.Duration(tm-t.lastGarbageCollection) < gcInterval {
return return
} }
topictab.lastGarbageCollection = tm t.lastGarbageCollection = tm
for node, n := range topictab.nodes { for node, n := range t.nodes {
for _, e := range n.entries { for _, e := range n.entries {
if e.expire <= tm { if e.expire <= tm {
topictab.deleteEntry(e) t.deleteEntry(e)
} }
} }
topictab.checkDeleteNode(node) t.checkDeleteNode(node)
} }
for topic := range topictab.topics { for topic := range t.topics {
topictab.checkDeleteTopic(topic) t.checkDeleteTopic(topic)
} }
} }

24
p2p/message.go
View file

@ -272,15 +272,15 @@ func newMsgEventer(rw MsgReadWriter, feed *event.Feed, peerID discover.NodeID, p
// ReadMsg reads a message from the underlying MsgReadWriter and emits a // ReadMsg reads a message from the underlying MsgReadWriter and emits a
// "message received" event // "message received" event
func (e *msgEventer) ReadMsg() (Msg, error) { func (ev *msgEventer) ReadMsg() (Msg, error) {
msg, err := e.MsgReadWriter.ReadMsg() msg, err := ev.MsgReadWriter.ReadMsg()
if err != nil { if err != nil {
return msg, err return msg, err
} }
e.feed.Send(&PeerEvent{ ev.feed.Send(&PeerEvent{
Type: PeerEventTypeMsgRecv, Type: PeerEventTypeMsgRecv,
Peer: e.peerID, Peer: ev.peerID,
Protocol: e.Protocol, Protocol: ev.Protocol,
MsgCode: &msg.Code, MsgCode: &msg.Code,
MsgSize: &msg.Size, MsgSize: &msg.Size,
}) })
@ -289,15 +289,15 @@ func (e *msgEventer) ReadMsg() (Msg, error) {
// WriteMsg writes a message to the underlying MsgReadWriter and emits a // WriteMsg writes a message to the underlying MsgReadWriter and emits a
// "message sent" event // "message sent" event
func (e *msgEventer) WriteMsg(msg Msg) error { func (ev *msgEventer) WriteMsg(msg Msg) error {
err := e.MsgReadWriter.WriteMsg(msg) err := ev.MsgReadWriter.WriteMsg(msg)
if err != nil { if err != nil {
return err return err
} }
e.feed.Send(&PeerEvent{ ev.feed.Send(&PeerEvent{
Type: PeerEventTypeMsgSend, Type: PeerEventTypeMsgSend,
Peer: e.peerID, Peer: ev.peerID,
Protocol: e.Protocol, Protocol: ev.Protocol,
MsgCode: &msg.Code, MsgCode: &msg.Code,
MsgSize: &msg.Size, MsgSize: &msg.Size,
}) })
@ -306,8 +306,8 @@ func (e *msgEventer) WriteMsg(msg Msg) error {
// Close closes the underlying MsgReadWriter if it implements the io.Closer // Close closes the underlying MsgReadWriter if it implements the io.Closer
// interface // interface
func (e *msgEventer) Close() error { func (ev *msgEventer) Close() error {
if v, ok := e.MsgReadWriter.(io.Closer); ok { if v, ok := ev.MsgReadWriter.(io.Closer); ok {
return v.Close() return v.Close()
} }
return nil return nil

4
p2p/peer_error.go
View file

@ -48,8 +48,8 @@ func newPeerError(code int, format string, v ...interface{}) *peerError {
return err return err
} }
func (e *peerError) Error() string { func (pe *peerError) Error() string {
return e.message return pe.message
} }
var errProtocolReturned = errors.New("protocol returned") var errProtocolReturned = errors.New("protocol returned")

8
p2p/simulations/adapters/state.go
View file

@ -20,12 +20,12 @@ type SimStateStore struct {
m map[string][]byte m map[string][]byte
} }
func (sss *SimStateStore) Load(s string) ([]byte, error) { func (st *SimStateStore) Load(s string) ([]byte, error) {
return sss.m[s], nil return st.m[s], nil
} }
func (sss *SimStateStore) Save(s string, data []byte) error { func (st *SimStateStore) Save(s string, data []byte) error {
sss.m[s] = data st.m[s] = data
return nil return nil
} }