p2p: fix some golint warnings (ethereum#16577)

p2p/discover/table_test.go

@@ -582,26 +582,26 @@ func (*preminedTestnet) ping(toid NodeID, toaddr *net.UDPAddr) error { return ni
 
 // mine generates a testnet struct literal with nodes at
 // various distances to the given target.
-func (n *preminedTestnet) mine(target NodeID) {
- n.target = target
- n.targetSha = crypto.Keccak256Hash(n.target[:])
+func (tn *preminedTestnet) mine(target NodeID) {
+ tn.target = target
+ tn.targetSha = crypto.Keccak256Hash(tn.target[:])
  found := 0
  for found < bucketSize*10 {
  k := newkey()
  id := PubkeyID(&k.PublicKey)
  sha := crypto.Keccak256Hash(id[:])
- ld := logdist(n.targetSha, sha)
- if len(n.dists[ld]) < bucketSize {
- n.dists[ld] = append(n.dists[ld], id)
+ ld := logdist(tn.targetSha, sha)
+ if len(tn.dists[ld]) < bucketSize {
+ tn.dists[ld] = append(tn.dists[ld], id)
  fmt.Println("found ID with ld", ld)
  found++
  }
  }
  fmt.Println("&preminedTestnet{")
- fmt.Printf(" target: %#v,\n", n.target)
- fmt.Printf(" targetSha: %#v,\n", n.targetSha)
- fmt.Printf(" dists: [%d][]NodeID{\n", len(n.dists))
- for ld, ns := range n.dists {
+ fmt.Printf(" target: %#v,\n", tn.target)
+ fmt.Printf(" targetSha: %#v,\n", tn.targetSha)
+ fmt.Printf(" dists: [%d][]NodeID{\n", len(tn.dists))
+ for ld, ns := range tn.dists {
  if len(ns) == 0 {
  continue
  }

p2p/discv5/net_test.go

@@ -336,26 +336,26 @@ func (*preminedTestnet) localAddr() *net.UDPAddr {
 
 // mine generates a testnet struct literal with nodes at
 // various distances to the given target.
-func (n *preminedTestnet) mine(target NodeID) {
- n.target = target
- n.targetSha = crypto.Keccak256Hash(n.target[:])
+func (tn *preminedTestnet) mine(target NodeID) {
+ tn.target = target
+ tn.targetSha = crypto.Keccak256Hash(tn.target[:])
  found := 0
  for found < bucketSize*10 {
  k := newkey()
  id := PubkeyID(&k.PublicKey)
  sha := crypto.Keccak256Hash(id[:])
- ld := logdist(n.targetSha, sha)
- if len(n.dists[ld]) < bucketSize {
- n.dists[ld] = append(n.dists[ld], id)
+ ld := logdist(tn.targetSha, sha)
+ if len(tn.dists[ld]) < bucketSize {
+ tn.dists[ld] = append(tn.dists[ld], id)
  fmt.Println("found ID with ld", ld)
  found++
  }
  }
  fmt.Println("&preminedTestnet{")
- fmt.Printf(" target: %#v,\n", n.target)
- fmt.Printf(" targetSha: %#v,\n", n.targetSha)
- fmt.Printf(" dists: [%d][]NodeID{\n", len(n.dists))
- for ld, ns := range n.dists {
+ fmt.Printf(" target: %#v,\n", tn.target)
+ fmt.Printf(" targetSha: %#v,\n", tn.targetSha)
+ fmt.Printf(" dists: [%d][]NodeID{\n", len(tn.dists))
+ for ld, ns := range tn.dists {
  if len(ns) == 0 {
  continue
  }

p2p/discv5/node.go

@@ -315,11 +315,11 @@ func PubkeyID(pub *ecdsa.PublicKey) NodeID {
 
 // Pubkey returns the public key represented by the node ID.
 // It returns an error if the ID is not a point on the curve.
-func (id NodeID) Pubkey() (*ecdsa.PublicKey, error) {
+func (n NodeID) Pubkey() (*ecdsa.PublicKey, error) {
  p := &ecdsa.PublicKey{Curve: crypto.S256(), X: new(big.Int), Y: new(big.Int)}
- half := len(id) / 2
- p.X.SetBytes(id[:half])
- p.Y.SetBytes(id[half:])
+ half := len(n) / 2
+ p.X.SetBytes(n[:half])
+ p.Y.SetBytes(n[half:])
  if !p.Curve.IsOnCurve(p.X, p.Y) {
  return nil, errors.New("id is invalid secp256k1 curve point")
  }

p2p/discv5/ticket.go

@@ -304,8 +304,8 @@ func (s ticketRefByWaitTime) Len() int {
  return len(s)
 }
 
-func (r ticketRef) waitTime() mclock.AbsTime {
- return r.t.regTime[r.idx] - r.t.issueTime
+func (ref ticketRef) waitTime() mclock.AbsTime {
+ return ref.t.regTime[ref.idx] - ref.t.issueTime
 }
 
 // Less reports whether the element with

p2p/discv5/topic.go

@@ -271,31 +271,31 @@ func (t *topicTable) useTicket(node *Node, serialNo uint32, topics []Topic, idx
  return false
 }
 
-func (topictab *topicTable) getTicket(node *Node, topics []Topic) *ticket {
- topictab.collectGarbage()
+func (t *topicTable) getTicket(node *Node, topics []Topic) *ticket {
+ t.collectGarbage()
 
  now := mclock.Now()
- n := topictab.getOrNewNode(node)
+ n := t.getOrNewNode(node)
  n.lastIssuedTicket++
- topictab.storeTicketCounters(node)
+ t.storeTicketCounters(node)
 
- t := &ticket{
+ tic := &ticket{
  issueTime: now,
  topics: topics,
  serial: n.lastIssuedTicket,
  regTime: make([]mclock.AbsTime, len(topics)),
  }
  for i, topic := range topics {
  var waitPeriod time.Duration
- if topic := topictab.topics[topic]; topic != nil {
+ if topic := t.topics[topic]; topic != nil {
  waitPeriod = topic.wcl.waitPeriod
  } else {
  waitPeriod = minWaitPeriod
  }
 
- t.regTime[i] = now + mclock.AbsTime(waitPeriod)
+ tic.regTime[i] = now + mclock.AbsTime(waitPeriod)
  }
- return t
+ return tic
 }
 
 const gcInterval = time.Minute

p2p/message.go

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

p2p/peer_error.go

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