forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-20 10:52:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

les: renamed vip to priority

Browse source
This commit is contained in:
Zsolt Felfoldi 2019-01-16 15:44:21 +01:00
parent 8fcb060f10
commit 2b2fe5350f
2 changed files with 59 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
les/api.go
View file

@ -33,21 +33,21 @@ var (
type PrivateLesServerAPI struct {
server *LesServer
pm *ProtocolManager
vip *vipClientPool
priority *priorityClientPool
}
// NewPublicLesServerAPI creates a new les server API.
func NewPrivateLesServerAPI(server *LesServer) *PrivateLesServerAPI {
vip := &vipClientPool{
clients: make(map[enode.ID]vipClientInfo),
priority := &priorityClientPool{
clients: make(map[enode.ID]priorityClientInfo),
totalCap: server.totalCapacity,
pm: server.protocolManager,
}
server.protocolManager.vipClientPool = vip
server.protocolManager.priorityClientPool = priority
return &PrivateLesServerAPI{
server: server,
pm: server.protocolManager,
vip: vip,
priority: priority,
}
}
@ -61,18 +61,18 @@ func (api *PrivateLesServerAPI) MinimumCapacity() hexutil.Uint64 {
return hexutil.Uint64(api.server.minCapacity)
}
// vipClientPool stores information about prioritized clients
type vipClientPool struct {
// priorityClientPool stores information about prioritized clients
type priorityClientPool struct {
lock sync.Mutex
pm *ProtocolManager
clients map[enode.ID]vipClientInfo
totalCap, totalVipCap, totalConnectedCap uint64
vipCount int
clients map[enode.ID]priorityClientInfo
totalCap, totalpriorityCap, totalConnectedCap uint64
priorityCount int
}
// vipClientInfo entries exist for all prioritized clients and currently connected free clients
type vipClientInfo struct {
cap uint64 // zero for non-vip clients
// priorityClientInfo entries exist for all prioritized clients and currently connected free clients
type priorityClientInfo struct {
cap uint64 // zero for non-priority clients
connected bool
updateCap func(uint64)
}
@ -89,45 +89,45 @@ func (api *PrivateLesServerAPI) SetClientCapacity(id enode.ID, cap uint64) error
return ErrMinCap
}
api.vip.lock.Lock()
defer api.vip.lock.Unlock()
api.priority.lock.Lock()
defer api.priority.lock.Unlock()
c := api.vip.clients[id]
if api.vip.totalVipCap+cap > api.vip.totalCap+c.cap {
c := api.priority.clients[id]
if api.priority.totalpriorityCap+cap > api.priority.totalCap+c.cap {
return ErrTotalCap
}
api.vip.totalVipCap += cap - c.cap
api.priority.totalpriorityCap += cap - c.cap
if c.updateCap != nil && cap != 0 {
c.updateCap(cap)
}
if c.connected {
if c.cap != 0 {
api.vip.vipCount--
api.priority.priorityCount--
}
if cap != 0 {
api.vip.vipCount++
api.priority.priorityCount++
}
api.vip.totalConnectedCap += cap - c.cap
api.pm.clientPool.setConnLimit(api.pm.maxFreePeers(api.vip.vipCount, api.vip.totalConnectedCap))
api.priority.totalConnectedCap += cap - c.cap
api.pm.clientPool.setConnLimit(api.pm.maxFreePeers(api.priority.priorityCount, api.priority.totalConnectedCap))
}
if c.updateCap != nil && cap == 0 {
c.updateCap(cap)
}
if cap != 0 || c.connected {
c.cap = cap
api.vip.clients[id] = c
api.priority.clients[id] = c
} else {
delete(api.vip.clients, id)
delete(api.priority.clients, id)
}
return nil
}
// GetClientCapacity returns the capacity assigned to a given client
func (api *PrivateLesServerAPI) GetClientCapacity(id enode.ID) hexutil.Uint64 {
api.vip.lock.Lock()
defer api.vip.lock.Unlock()
api.priority.lock.Lock()
defer api.priority.lock.Unlock()
return hexutil.Uint64(api.vip.clients[id].cap)
return hexutil.Uint64(api.priority.clients[id].cap)
}
// connect should be called when a new client is connected. The callback function
@ -135,10 +135,10 @@ func (api *PrivateLesServerAPI) GetClientCapacity(id enode.ID) hexutil.Uint64 {
// It returns the priority capacity or zero if the client is not prioritized.
// It also returns whether the client can be accepted.
//
// Note: vipClientPool also stores a record about free clients while they are
// Note: priorityClientPool also stores a record about free clients while they are
// connected in order to be able to assign priority to them later with the callback
// function if necessary.
func (v *vipClientPool) connect(id enode.ID, updateCap func(uint64)) (uint64, bool) {
func (v *priorityClientPool) connect(id enode.ID, updateCap func(uint64)) (uint64, bool) {
v.lock.Lock()
defer v.lock.Unlock()
@ -150,16 +150,16 @@ func (v *vipClientPool) connect(id enode.ID, updateCap func(uint64)) (uint64, bo
c.updateCap = updateCap
v.clients[id] = c
if c.cap != 0 {
v.vipCount++
v.priorityCount++
}
v.totalConnectedCap += c.cap
v.pm.clientPool.setConnLimit(v.pm.maxFreePeers(v.vipCount, v.totalConnectedCap))
v.pm.clientPool.setConnLimit(v.pm.maxFreePeers(v.priorityCount, v.totalConnectedCap))
return c.cap, true
}
// disconnect should be called when a client is disconnected.
// It should be called for all clients accepted by connect even if not prioritized.
func (v *vipClientPool) disconnect(id enode.ID) {
func (v *priorityClientPool) disconnect(id enode.ID) {
v.lock.Lock()
defer v.lock.Unlock()
@ -167,10 +167,10 @@ func (v *vipClientPool) disconnect(id enode.ID) {
c.connected = false
if c.cap != 0 {
v.clients[id] = c
v.vipCount--
v.priorityCount--
} else {
delete(v.clients, id)
}
v.totalConnectedCap -= c.cap
v.pm.clientPool.setConnLimit(v.pm.maxFreePeers(v.vipCount, v.totalConnectedCap))
v.pm.clientPool.setConnLimit(v.pm.maxFreePeers(v.priorityCount, v.totalConnectedCap))
}

34
les/handler.go
View file

@ -104,7 +104,7 @@ type ProtocolManager struct {
serverPool *serverPool
clientPool *freeClientPool
freeClientCap uint64
vipClientPool *vipClientPool
priorityClientPool *priorityClientPool
lesTopic discv5.Topic
reqDist *requestDistributor
retriever *retrieveManager
@ -342,8 +342,8 @@ func (pm *ProtocolManager) handle(p *peer) error {
}
var (
free, vip bool
lock sync.Mutex // lock protects access to the free and vip flags
free, priority bool
lock sync.Mutex // lock protects access to the free and priority flags
)
defer func() {
@ -358,16 +358,16 @@ func (pm *ProtocolManager) handle(p *peer) error {
lock.Lock()
defer lock.Unlock()
if !vip && cap != 0 {
// switch to vip mode
if !priority && cap != 0 {
// switch to priority mode
if free {
pm.clientPool.disconnect(freeId)
free = false
}
vip = true
priority = true
p.updateCapacity(cap)
}
if vip {
if priority {
if cap == 0 {
// priority revoked; switch to free client mode or drop
if freeId != "" {
@ -377,33 +377,33 @@ func (pm *ProtocolManager) handle(p *peer) error {
}
free = true
}
vip = false
priority = false
p.updateCapacity(pm.freeClientCap)
} else {
// just update vip capacity
// just update priority capacity
p.updateCapacity(cap)
}
}
}
lock.Lock()
if pm.vipClientPool != nil {
// the vip client pool registers currently connected non-vip clients too
if pm.priorityClientPool != nil {
// the priority client pool registers currently connected non-priority clients too
// in order to be able to notify them if they get priority while connected
vipCap, ok := pm.vipClientPool.connect(p.ID(), updateCap)
priorityCap, ok := pm.priorityClientPool.connect(p.ID(), updateCap)
if !ok {
lock.Unlock()
return p2p.DiscAlreadyConnected
}
// always unregister
defer pm.vipClientPool.disconnect(p.ID())
if vipCap != 0 {
vip = true
p.updateCapacity(vipCap)
defer pm.priorityClientPool.disconnect(p.ID())
if priorityCap != 0 {
priority = true
p.updateCapacity(priorityCap)
}
}
if !vip && freeId != "" {
if !priority && freeId != "" {
// if freeId == "" then we are in test mode and let the client connect
// without entering the free client pool
if !pm.clientPool.connect(freeId, func() { go pm.removePeer(p.id) }) {