les, les/lespay/server: refactor client pool (#21236)

* les, les/lespay/server: refactor client pool

* les: use ns.Operation and sub calls where needed

* les: fixed tests

* les: removed active/inactive logic from peerSet

* les: removed active/inactive peer logic

* les: fixed linter warnings

* les: fixed more linter errors and added missing metrics

* les: addressed comments

* cmd/geth: fixed TestPriorityClient

* les: simplified clientPool state machine

* les/lespay/server: do not use goroutine for balance callbacks

* internal/web3ext: fix addBalance required parameters

* les: removed freeCapacity, always connect at minCapacity initially

* les: only allow capacity change with priority status

Co-authored-by: rjl493456442 <garyrong0905@gmail.com>

les/utils/expiredvalue.go

@@ -18,6 +18,7 @@ package utils
 
 import (
 	"math"
+	"sync"
 
 	"github.com/ethereum/go-ethereum/common/mclock"
 )
@@ -124,6 +125,11 @@ func (e *ExpiredValue) SubExp(a ExpiredValue) {
 	}
 }
 
+// IsZero returns true if the value is zero
+func (e *ExpiredValue) IsZero() bool {
+	return e.Base == 0
+}
+
 // LinearExpiredValue is very similar with the expiredValue which the value
 // will continuously expired. But the different part is it's expired linearly.
 type LinearExpiredValue struct {
@@ -168,12 +174,20 @@ func (e *LinearExpiredValue) Add(amount int64, now mclock.AbsTime) uint64 {
 	return e.Val
 }
 
+// ValueExpirer controls value expiration rate
+type ValueExpirer interface {
+	SetRate(now mclock.AbsTime, rate float64)
+	SetLogOffset(now mclock.AbsTime, logOffset Fixed64)
+	LogOffset(now mclock.AbsTime) Fixed64
+}
+
 // Expirer changes logOffset with a linear rate which can be changed during operation.
 // It is not thread safe, if access by multiple goroutines is needed then it should be
 // encapsulated into a locked structure.
 // Note that if neither SetRate nor SetLogOffset are used during operation then LogOffset
 // is thread safe.
 type Expirer struct {
+	lock       sync.RWMutex
 	logOffset  Fixed64
 	rate       float64
 	lastUpdate mclock.AbsTime
@@ -182,6 +196,9 @@ type Expirer struct {
 // SetRate changes the expiration rate which is the inverse of the time constant in
 // nanoseconds.
 func (e *Expirer) SetRate(now mclock.AbsTime, rate float64) {
+	e.lock.Lock()
+	defer e.lock.Unlock()
+
 	dt := now - e.lastUpdate
 	if dt > 0 {
 		e.logOffset += Fixed64(logToFixedFactor * float64(dt) * e.rate)
@@ -192,12 +209,18 @@ func (e *Expirer) SetRate(now mclock.AbsTime, rate float64) {
 
 // SetLogOffset sets logOffset instantly.
 func (e *Expirer) SetLogOffset(now mclock.AbsTime, logOffset Fixed64) {
+	e.lock.Lock()
+	defer e.lock.Unlock()
+
 	e.lastUpdate = now
 	e.logOffset = logOffset
 }
 
 // LogOffset returns the current logarithmic offset.
 func (e *Expirer) LogOffset(now mclock.AbsTime) Fixed64 {
+	e.lock.RLock()
+	defer e.lock.RUnlock()
+
 	dt := now - e.lastUpdate
 	if dt <= 0 {
 		return e.logOffset

les/utils/timeutils.go

@@ -0,0 +1,69 @@
+// Copyright 2020 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 utils
+
+import (
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common/mclock"
+)
+
+type UpdateTimer struct {
+	clock     mclock.Clock
+	lock      sync.Mutex
+	last      mclock.AbsTime
+	threshold time.Duration
+}
+
+func NewUpdateTimer(clock mclock.Clock, threshold time.Duration) *UpdateTimer {
+	// We don't accept the update threshold less than 0.
+	if threshold < 0 {
+		return nil
+	}
+	// Don't panic for lazy users
+	if clock == nil {
+		clock = mclock.System{}
+	}
+	return &UpdateTimer{
+		clock:     clock,
+		last:      clock.Now(),
+		threshold: threshold,
+	}
+}
+
+func (t *UpdateTimer) Update(callback func(diff time.Duration) bool) bool {
+	return t.UpdateAt(t.clock.Now(), callback)
+}
+
+func (t *UpdateTimer) UpdateAt(at mclock.AbsTime, callback func(diff time.Duration) bool) bool {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	diff := time.Duration(at - t.last)
+	if diff < 0 {
+		diff = 0
+	}
+	if diff < t.threshold {
+		return false
+	}
+	if callback(diff) {
+		t.last = at
+		return true
+	}
+	return false
+}

les/utils/timeutils_test.go

@@ -0,0 +1,47 @@
+// Copyright 2020 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 utils
+
+import (
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common/mclock"
+)
+
+func TestUpdateTimer(t *testing.T) {
+	timer := NewUpdateTimer(mclock.System{}, -1)
+	if timer != nil {
+		t.Fatalf("Create update timer with negative threshold")
+	}
+	sim := &mclock.Simulated{}
+	timer = NewUpdateTimer(sim, time.Second)
+	if updated := timer.Update(func(diff time.Duration) bool { return true }); updated {
+		t.Fatalf("Update the clock without reaching the threshold")
+	}
+	sim.Run(time.Second)
+	if updated := timer.Update(func(diff time.Duration) bool { return true }); !updated {
+		t.Fatalf("Doesn't update the clock when reaching the threshold")
+	}
+	if updated := timer.UpdateAt(sim.Now()+mclock.AbsTime(time.Second), func(diff time.Duration) bool { return true }); !updated {
+		t.Fatalf("Doesn't update the clock when reaching the threshold")
+	}
+	timer = NewUpdateTimer(sim, 0)
+	if updated := timer.Update(func(diff time.Duration) bool { return true }); !updated {
+		t.Fatalf("Doesn't update the clock without threshold limitaion")
+	}
+}