mirror of https://github.com/ethereum/go-ethereum
les: code refactoring (#14416)
This commit does various code refactorings: - generalizes and moves the request retrieval/timeout/resend logic out of LesOdr (will be used by a subsequent PR) - reworks the peer management logic so that all services can register with peerSet to get notified about added/dropped peers (also gets rid of the ugly getAllPeers callback in requestDistributor) - moves peerSet, LesOdr, requestDistributor and retrieveManager initialization out of ProtocolManager because I believe they do not really belong there and the whole init process was ugly and ad-hocpull/14677/head
Felföldi Zsolt
7 years ago
committed by
Felix Lange
parent
60e27b51bc
commit
a5d08c893d
@ -0,0 +1,395 @@ |
|||||||
|
// Copyright 2016 The go-ethereum Authors
|
||||||
|
// This file is part of the go-ethereum library.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||||
|
// it under the terms of the GNU Lesser General Public License as published by
|
||||||
|
// the Free Software Foundation, either version 3 of the License, or
|
||||||
|
// (at your option) any later version.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||||
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
// GNU Lesser General Public License for more details.
|
||||||
|
//
|
||||||
|
// You should have received a copy of the GNU Lesser General Public License
|
||||||
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
// Package light implements on-demand retrieval capable state and chain objects
|
||||||
|
// for the Ethereum Light Client.
|
||||||
|
package les |
||||||
|
|
||||||
|
import ( |
||||||
|
"context" |
||||||
|
"crypto/rand" |
||||||
|
"encoding/binary" |
||||||
|
"sync" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/common/mclock" |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
retryQueue = time.Millisecond * 100 |
||||||
|
softRequestTimeout = time.Millisecond * 500 |
||||||
|
hardRequestTimeout = time.Second * 10 |
||||||
|
) |
||||||
|
|
||||||
|
// retrieveManager is a layer on top of requestDistributor which takes care of
|
||||||
|
// matching replies by request ID and handles timeouts and resends if necessary.
|
||||||
|
type retrieveManager struct { |
||||||
|
dist *requestDistributor |
||||||
|
peers *peerSet |
||||||
|
serverPool peerSelector |
||||||
|
|
||||||
|
lock sync.RWMutex |
||||||
|
sentReqs map[uint64]*sentReq |
||||||
|
} |
||||||
|
|
||||||
|
// validatorFunc is a function that processes a reply message
|
||||||
|
type validatorFunc func(distPeer, *Msg) error |
||||||
|
|
||||||
|
// peerSelector receives feedback info about response times and timeouts
|
||||||
|
type peerSelector interface { |
||||||
|
adjustResponseTime(*poolEntry, time.Duration, bool) |
||||||
|
} |
||||||
|
|
||||||
|
// sentReq represents a request sent and tracked by retrieveManager
|
||||||
|
type sentReq struct { |
||||||
|
rm *retrieveManager |
||||||
|
req *distReq |
||||||
|
id uint64 |
||||||
|
validate validatorFunc |
||||||
|
|
||||||
|
eventsCh chan reqPeerEvent |
||||||
|
stopCh chan struct{} |
||||||
|
stopped bool |
||||||
|
err error |
||||||
|
|
||||||
|
lock sync.RWMutex // protect access to sentTo map
|
||||||
|
sentTo map[distPeer]sentReqToPeer |
||||||
|
|
||||||
|
reqQueued bool // a request has been queued but not sent
|
||||||
|
reqSent bool // a request has been sent but not timed out
|
||||||
|
reqSrtoCount int // number of requests that reached soft (but not hard) timeout
|
||||||
|
} |
||||||
|
|
||||||
|
// sentReqToPeer notifies the request-from-peer goroutine (tryRequest) about a response
|
||||||
|
// delivered by the given peer. Only one delivery is allowed per request per peer,
|
||||||
|
// after which delivered is set to true, the validity of the response is sent on the
|
||||||
|
// valid channel and no more responses are accepted.
|
||||||
|
type sentReqToPeer struct { |
||||||
|
delivered bool |
||||||
|
valid chan bool |
||||||
|
} |
||||||
|
|
||||||
|
// reqPeerEvent is sent by the request-from-peer goroutine (tryRequest) to the
|
||||||
|
// request state machine (retrieveLoop) through the eventsCh channel.
|
||||||
|
type reqPeerEvent struct { |
||||||
|
event int |
||||||
|
peer distPeer |
||||||
|
} |
||||||
|
|
||||||
|
const ( |
||||||
|
rpSent = iota // if peer == nil, not sent (no suitable peers)
|
||||||
|
rpSoftTimeout |
||||||
|
rpHardTimeout |
||||||
|
rpDeliveredValid |
||||||
|
rpDeliveredInvalid |
||||||
|
) |
||||||
|
|
||||||
|
// newRetrieveManager creates the retrieve manager
|
||||||
|
func newRetrieveManager(peers *peerSet, dist *requestDistributor, serverPool peerSelector) *retrieveManager { |
||||||
|
return &retrieveManager{ |
||||||
|
peers: peers, |
||||||
|
dist: dist, |
||||||
|
serverPool: serverPool, |
||||||
|
sentReqs: make(map[uint64]*sentReq), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// retrieve sends a request (to multiple peers if necessary) and waits for an answer
|
||||||
|
// that is delivered through the deliver function and successfully validated by the
|
||||||
|
// validator callback. It returns when a valid answer is delivered or the context is
|
||||||
|
// cancelled.
|
||||||
|
func (rm *retrieveManager) retrieve(ctx context.Context, reqID uint64, req *distReq, val validatorFunc) error { |
||||||
|
sentReq := rm.sendReq(reqID, req, val) |
||||||
|
select { |
||||||
|
case <-sentReq.stopCh: |
||||||
|
case <-ctx.Done(): |
||||||
|
sentReq.stop(ctx.Err()) |
||||||
|
} |
||||||
|
return sentReq.getError() |
||||||
|
} |
||||||
|
|
||||||
|
// sendReq starts a process that keeps trying to retrieve a valid answer for a
|
||||||
|
// request from any suitable peers until stopped or succeeded.
|
||||||
|
func (rm *retrieveManager) sendReq(reqID uint64, req *distReq, val validatorFunc) *sentReq { |
||||||
|
r := &sentReq{ |
||||||
|
rm: rm, |
||||||
|
req: req, |
||||||
|
id: reqID, |
||||||
|
sentTo: make(map[distPeer]sentReqToPeer), |
||||||
|
stopCh: make(chan struct{}), |
||||||
|
eventsCh: make(chan reqPeerEvent, 10), |
||||||
|
validate: val, |
||||||
|
} |
||||||
|
|
||||||
|
canSend := req.canSend |
||||||
|
req.canSend = func(p distPeer) bool { |
||||||
|
// add an extra check to canSend: the request has not been sent to the same peer before
|
||||||
|
r.lock.RLock() |
||||||
|
_, sent := r.sentTo[p] |
||||||
|
r.lock.RUnlock() |
||||||
|
return !sent && canSend(p) |
||||||
|
} |
||||||
|
|
||||||
|
request := req.request |
||||||
|
req.request = func(p distPeer) func() { |
||||||
|
// before actually sending the request, put an entry into the sentTo map
|
||||||
|
r.lock.Lock() |
||||||
|
r.sentTo[p] = sentReqToPeer{false, make(chan bool, 1)} |
||||||
|
r.lock.Unlock() |
||||||
|
return request(p) |
||||||
|
} |
||||||
|
rm.lock.Lock() |
||||||
|
rm.sentReqs[reqID] = r |
||||||
|
rm.lock.Unlock() |
||||||
|
|
||||||
|
go r.retrieveLoop() |
||||||
|
return r |
||||||
|
} |
||||||
|
|
||||||
|
// deliver is called by the LES protocol manager to deliver reply messages to waiting requests
|
||||||
|
func (rm *retrieveManager) deliver(peer distPeer, msg *Msg) error { |
||||||
|
rm.lock.RLock() |
||||||
|
req, ok := rm.sentReqs[msg.ReqID] |
||||||
|
rm.lock.RUnlock() |
||||||
|
|
||||||
|
if ok { |
||||||
|
return req.deliver(peer, msg) |
||||||
|
} |
||||||
|
return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID) |
||||||
|
} |
||||||
|
|
||||||
|
// reqStateFn represents a state of the retrieve loop state machine
|
||||||
|
type reqStateFn func() reqStateFn |
||||||
|
|
||||||
|
// retrieveLoop is the retrieval state machine event loop
|
||||||
|
func (r *sentReq) retrieveLoop() { |
||||||
|
go r.tryRequest() |
||||||
|
r.reqQueued = true |
||||||
|
state := r.stateRequesting |
||||||
|
|
||||||
|
for state != nil { |
||||||
|
state = state() |
||||||
|
} |
||||||
|
|
||||||
|
r.rm.lock.Lock() |
||||||
|
delete(r.rm.sentReqs, r.id) |
||||||
|
r.rm.lock.Unlock() |
||||||
|
} |
||||||
|
|
||||||
|
// stateRequesting: a request has been queued or sent recently; when it reaches soft timeout,
|
||||||
|
// a new request is sent to a new peer
|
||||||
|
func (r *sentReq) stateRequesting() reqStateFn { |
||||||
|
select { |
||||||
|
case ev := <-r.eventsCh: |
||||||
|
r.update(ev) |
||||||
|
switch ev.event { |
||||||
|
case rpSent: |
||||||
|
if ev.peer == nil { |
||||||
|
// request send failed, no more suitable peers
|
||||||
|
if r.waiting() { |
||||||
|
// we are already waiting for sent requests which may succeed so keep waiting
|
||||||
|
return r.stateNoMorePeers |
||||||
|
} |
||||||
|
// nothing to wait for, no more peers to ask, return with error
|
||||||
|
r.stop(ErrNoPeers) |
||||||
|
// no need to go to stopped state because waiting() already returned false
|
||||||
|
return nil |
||||||
|
} |
||||||
|
case rpSoftTimeout: |
||||||
|
// last request timed out, try asking a new peer
|
||||||
|
go r.tryRequest() |
||||||
|
r.reqQueued = true |
||||||
|
return r.stateRequesting |
||||||
|
case rpDeliveredValid: |
||||||
|
r.stop(nil) |
||||||
|
return r.stateStopped |
||||||
|
} |
||||||
|
return r.stateRequesting |
||||||
|
case <-r.stopCh: |
||||||
|
return r.stateStopped |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// stateNoMorePeers: could not send more requests because no suitable peers are available.
|
||||||
|
// Peers may become suitable for a certain request later or new peers may appear so we
|
||||||
|
// keep trying.
|
||||||
|
func (r *sentReq) stateNoMorePeers() reqStateFn { |
||||||
|
select { |
||||||
|
case <-time.After(retryQueue): |
||||||
|
go r.tryRequest() |
||||||
|
r.reqQueued = true |
||||||
|
return r.stateRequesting |
||||||
|
case ev := <-r.eventsCh: |
||||||
|
r.update(ev) |
||||||
|
if ev.event == rpDeliveredValid { |
||||||
|
r.stop(nil) |
||||||
|
return r.stateStopped |
||||||
|
} |
||||||
|
return r.stateNoMorePeers |
||||||
|
case <-r.stopCh: |
||||||
|
return r.stateStopped |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// stateStopped: request succeeded or cancelled, just waiting for some peers
|
||||||
|
// to either answer or time out hard
|
||||||
|
func (r *sentReq) stateStopped() reqStateFn { |
||||||
|
for r.waiting() { |
||||||
|
r.update(<-r.eventsCh) |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// update updates the queued/sent flags and timed out peers counter according to the event
|
||||||
|
func (r *sentReq) update(ev reqPeerEvent) { |
||||||
|
switch ev.event { |
||||||
|
case rpSent: |
||||||
|
r.reqQueued = false |
||||||
|
if ev.peer != nil { |
||||||
|
r.reqSent = true |
||||||
|
} |
||||||
|
case rpSoftTimeout: |
||||||
|
r.reqSent = false |
||||||
|
r.reqSrtoCount++ |
||||||
|
case rpHardTimeout, rpDeliveredValid, rpDeliveredInvalid: |
||||||
|
r.reqSrtoCount-- |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// waiting returns true if the retrieval mechanism is waiting for an answer from
|
||||||
|
// any peer
|
||||||
|
func (r *sentReq) waiting() bool { |
||||||
|
return r.reqQueued || r.reqSent || r.reqSrtoCount > 0 |
||||||
|
} |
||||||
|
|
||||||
|
// tryRequest tries to send the request to a new peer and waits for it to either
|
||||||
|
// succeed or time out if it has been sent. It also sends the appropriate reqPeerEvent
|
||||||
|
// messages to the request's event channel.
|
||||||
|
func (r *sentReq) tryRequest() { |
||||||
|
sent := r.rm.dist.queue(r.req) |
||||||
|
var p distPeer |
||||||
|
select { |
||||||
|
case p = <-sent: |
||||||
|
case <-r.stopCh: |
||||||
|
if r.rm.dist.cancel(r.req) { |
||||||
|
p = nil |
||||||
|
} else { |
||||||
|
p = <-sent |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
r.eventsCh <- reqPeerEvent{rpSent, p} |
||||||
|
if p == nil { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
reqSent := mclock.Now() |
||||||
|
srto, hrto := false, false |
||||||
|
|
||||||
|
r.lock.RLock() |
||||||
|
s, ok := r.sentTo[p] |
||||||
|
r.lock.RUnlock() |
||||||
|
if !ok { |
||||||
|
panic(nil) |
||||||
|
} |
||||||
|
|
||||||
|
defer func() { |
||||||
|
// send feedback to server pool and remove peer if hard timeout happened
|
||||||
|
pp, ok := p.(*peer) |
||||||
|
if ok && r.rm.serverPool != nil { |
||||||
|
respTime := time.Duration(mclock.Now() - reqSent) |
||||||
|
r.rm.serverPool.adjustResponseTime(pp.poolEntry, respTime, srto) |
||||||
|
} |
||||||
|
if hrto { |
||||||
|
pp.Log().Debug("Request timed out hard") |
||||||
|
if r.rm.peers != nil { |
||||||
|
r.rm.peers.Unregister(pp.id) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
r.lock.Lock() |
||||||
|
delete(r.sentTo, p) |
||||||
|
r.lock.Unlock() |
||||||
|
}() |
||||||
|
|
||||||
|
select { |
||||||
|
case ok := <-s.valid: |
||||||
|
if ok { |
||||||
|
r.eventsCh <- reqPeerEvent{rpDeliveredValid, p} |
||||||
|
} else { |
||||||
|
r.eventsCh <- reqPeerEvent{rpDeliveredInvalid, p} |
||||||
|
} |
||||||
|
return |
||||||
|
case <-time.After(softRequestTimeout): |
||||||
|
srto = true |
||||||
|
r.eventsCh <- reqPeerEvent{rpSoftTimeout, p} |
||||||
|
} |
||||||
|
|
||||||
|
select { |
||||||
|
case ok := <-s.valid: |
||||||
|
if ok { |
||||||
|
r.eventsCh <- reqPeerEvent{rpDeliveredValid, p} |
||||||
|
} else { |
||||||
|
r.eventsCh <- reqPeerEvent{rpDeliveredInvalid, p} |
||||||
|
} |
||||||
|
case <-time.After(hardRequestTimeout): |
||||||
|
hrto = true |
||||||
|
r.eventsCh <- reqPeerEvent{rpHardTimeout, p} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// deliver a reply belonging to this request
|
||||||
|
func (r *sentReq) deliver(peer distPeer, msg *Msg) error { |
||||||
|
r.lock.Lock() |
||||||
|
defer r.lock.Unlock() |
||||||
|
|
||||||
|
s, ok := r.sentTo[peer] |
||||||
|
if !ok || s.delivered { |
||||||
|
return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID) |
||||||
|
} |
||||||
|
valid := r.validate(peer, msg) == nil |
||||||
|
r.sentTo[peer] = sentReqToPeer{true, s.valid} |
||||||
|
s.valid <- valid |
||||||
|
if !valid { |
||||||
|
return errResp(ErrInvalidResponse, "reqID = %v", msg.ReqID) |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// stop stops the retrieval process and sets an error code that will be returned
|
||||||
|
// by getError
|
||||||
|
func (r *sentReq) stop(err error) { |
||||||
|
r.lock.Lock() |
||||||
|
if !r.stopped { |
||||||
|
r.stopped = true |
||||||
|
r.err = err |
||||||
|
close(r.stopCh) |
||||||
|
} |
||||||
|
r.lock.Unlock() |
||||||
|
} |
||||||
|
|
||||||
|
// getError returns any retrieval error (either internally generated or set by the
|
||||||
|
// stop function) after stopCh has been closed
|
||||||
|
func (r *sentReq) getError() error { |
||||||
|
return r.err |
||||||
|
} |
||||||
|
|
||||||
|
// genReqID generates a new random request ID
|
||||||
|
func genReqID() uint64 { |
||||||
|
var rnd [8]byte |
||||||
|
rand.Read(rnd[:]) |
||||||
|
return binary.BigEndian.Uint64(rnd[:]) |
||||||
|
} |
||||||
Loading…
Reference in new issue