mirror of https://github.com/ethereum/go-ethereum
les: UDP pre-negotiation of available server capacity (#22183)
This PR implements the first one of the "lespay" UDP queries which is already useful in itself: the capacity query. The server pool is making use of this query by doing a cheap UDP query to determine whether it is worth starting the more expensive TCP connection process.pull/22399/head
Felföldi Zsolt
4 years ago
committed by
GitHub
parent
498458b410
commit
d96870428f
@ -0,0 +1,180 @@ |
|||||||
|
// 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 vflux |
||||||
|
|
||||||
|
import ( |
||||||
|
"errors" |
||||||
|
"math" |
||||||
|
"math/big" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/rlp" |
||||||
|
) |
||||||
|
|
||||||
|
var ErrNoReply = errors.New("no reply for given request") |
||||||
|
|
||||||
|
const ( |
||||||
|
MaxRequestLength = 16 // max number of individual requests in a batch
|
||||||
|
CapacityQueryName = "cq" |
||||||
|
CapacityQueryMaxLen = 16 |
||||||
|
) |
||||||
|
|
||||||
|
type ( |
||||||
|
// Request describes a single vflux request inside a batch. Service and request
|
||||||
|
// type are identified by strings, parameters are RLP encoded.
|
||||||
|
Request struct { |
||||||
|
Service, Name string |
||||||
|
Params []byte |
||||||
|
} |
||||||
|
// Requests are a batch of vflux requests
|
||||||
|
Requests []Request |
||||||
|
|
||||||
|
// Replies are the replies to a batch of requests
|
||||||
|
Replies [][]byte |
||||||
|
|
||||||
|
// CapacityQueryReq is the encoding format of the capacity query
|
||||||
|
CapacityQueryReq struct { |
||||||
|
Bias uint64 // seconds
|
||||||
|
AddTokens []IntOrInf |
||||||
|
} |
||||||
|
// CapacityQueryReq is the encoding format of the response to the capacity query
|
||||||
|
CapacityQueryReply []uint64 |
||||||
|
) |
||||||
|
|
||||||
|
// Add encodes and adds a new request to the batch
|
||||||
|
func (r *Requests) Add(service, name string, val interface{}) (int, error) { |
||||||
|
enc, err := rlp.EncodeToBytes(val) |
||||||
|
if err != nil { |
||||||
|
return -1, err |
||||||
|
} |
||||||
|
*r = append(*r, Request{ |
||||||
|
Service: service, |
||||||
|
Name: name, |
||||||
|
Params: enc, |
||||||
|
}) |
||||||
|
return len(*r) - 1, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Get decodes the reply to the i-th request in the batch
|
||||||
|
func (r Replies) Get(i int, val interface{}) error { |
||||||
|
if i < 0 || i >= len(r) { |
||||||
|
return ErrNoReply |
||||||
|
} |
||||||
|
return rlp.DecodeBytes(r[i], val) |
||||||
|
} |
||||||
|
|
||||||
|
const ( |
||||||
|
IntNonNegative = iota |
||||||
|
IntNegative |
||||||
|
IntPlusInf |
||||||
|
IntMinusInf |
||||||
|
) |
||||||
|
|
||||||
|
// IntOrInf is the encoding format for arbitrary length signed integers that can also
|
||||||
|
// hold the values of +Inf or -Inf
|
||||||
|
type IntOrInf struct { |
||||||
|
Type uint8 |
||||||
|
Value big.Int |
||||||
|
} |
||||||
|
|
||||||
|
// BigInt returns the value as a big.Int or panics if the value is infinity
|
||||||
|
func (i *IntOrInf) BigInt() *big.Int { |
||||||
|
switch i.Type { |
||||||
|
case IntNonNegative: |
||||||
|
return new(big.Int).Set(&i.Value) |
||||||
|
case IntNegative: |
||||||
|
return new(big.Int).Neg(&i.Value) |
||||||
|
case IntPlusInf: |
||||||
|
panic(nil) // caller should check Inf() before trying to convert to big.Int
|
||||||
|
case IntMinusInf: |
||||||
|
panic(nil) |
||||||
|
} |
||||||
|
return &big.Int{} // invalid type decodes to 0 value
|
||||||
|
} |
||||||
|
|
||||||
|
// Inf returns 1 if the value is +Inf, -1 if it is -Inf, 0 otherwise
|
||||||
|
func (i *IntOrInf) Inf() int { |
||||||
|
switch i.Type { |
||||||
|
case IntPlusInf: |
||||||
|
return 1 |
||||||
|
case IntMinusInf: |
||||||
|
return -1 |
||||||
|
} |
||||||
|
return 0 // invalid type decodes to 0 value
|
||||||
|
} |
||||||
|
|
||||||
|
// Int64 limits the value between MinInt64 and MaxInt64 (even if it is +-Inf) and returns an int64 type
|
||||||
|
func (i *IntOrInf) Int64() int64 { |
||||||
|
switch i.Type { |
||||||
|
case IntNonNegative: |
||||||
|
if i.Value.IsInt64() { |
||||||
|
return i.Value.Int64() |
||||||
|
} else { |
||||||
|
return math.MaxInt64 |
||||||
|
} |
||||||
|
case IntNegative: |
||||||
|
if i.Value.IsInt64() { |
||||||
|
return -i.Value.Int64() |
||||||
|
} else { |
||||||
|
return math.MinInt64 |
||||||
|
} |
||||||
|
case IntPlusInf: |
||||||
|
return math.MaxInt64 |
||||||
|
case IntMinusInf: |
||||||
|
return math.MinInt64 |
||||||
|
} |
||||||
|
return 0 // invalid type decodes to 0 value
|
||||||
|
} |
||||||
|
|
||||||
|
// SetBigInt sets the value to the given big.Int
|
||||||
|
func (i *IntOrInf) SetBigInt(v *big.Int) { |
||||||
|
if v.Sign() >= 0 { |
||||||
|
i.Type = IntNonNegative |
||||||
|
i.Value.Set(v) |
||||||
|
} else { |
||||||
|
i.Type = IntNegative |
||||||
|
i.Value.Neg(v) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// SetInt64 sets the value to the given int64. Note that MaxInt64 translates to +Inf
|
||||||
|
// while MinInt64 translates to -Inf.
|
||||||
|
func (i *IntOrInf) SetInt64(v int64) { |
||||||
|
if v >= 0 { |
||||||
|
if v == math.MaxInt64 { |
||||||
|
i.Type = IntPlusInf |
||||||
|
} else { |
||||||
|
i.Type = IntNonNegative |
||||||
|
i.Value.SetInt64(v) |
||||||
|
} |
||||||
|
} else { |
||||||
|
if v == math.MinInt64 { |
||||||
|
i.Type = IntMinusInf |
||||||
|
} else { |
||||||
|
i.Type = IntNegative |
||||||
|
i.Value.SetInt64(-v) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// SetInf sets the value to +Inf or -Inf
|
||||||
|
func (i *IntOrInf) SetInf(sign int) { |
||||||
|
if sign == 1 { |
||||||
|
i.Type = IntPlusInf |
||||||
|
} else { |
||||||
|
i.Type = IntMinusInf |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,122 @@ |
|||||||
|
// 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 server |
||||||
|
|
||||||
|
import ( |
||||||
|
"net" |
||||||
|
"strings" |
||||||
|
"sync" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/les/utils" |
||||||
|
"github.com/ethereum/go-ethereum/les/vflux" |
||||||
|
"github.com/ethereum/go-ethereum/log" |
||||||
|
"github.com/ethereum/go-ethereum/p2p/enode" |
||||||
|
"github.com/ethereum/go-ethereum/rlp" |
||||||
|
) |
||||||
|
|
||||||
|
type ( |
||||||
|
// Server serves vflux requests
|
||||||
|
Server struct { |
||||||
|
limiter *utils.Limiter |
||||||
|
lock sync.Mutex |
||||||
|
services map[string]*serviceEntry |
||||||
|
delayPerRequest time.Duration |
||||||
|
} |
||||||
|
|
||||||
|
// Service is a service registered at the Server and identified by a string id
|
||||||
|
Service interface { |
||||||
|
ServiceInfo() (id, desc string) // only called during registration
|
||||||
|
Handle(id enode.ID, address string, name string, data []byte) []byte // never called concurrently
|
||||||
|
} |
||||||
|
|
||||||
|
serviceEntry struct { |
||||||
|
id, desc string |
||||||
|
backend Service |
||||||
|
} |
||||||
|
) |
||||||
|
|
||||||
|
// NewServer creates a new Server
|
||||||
|
func NewServer(delayPerRequest time.Duration) *Server { |
||||||
|
return &Server{ |
||||||
|
limiter: utils.NewLimiter(1000), |
||||||
|
delayPerRequest: delayPerRequest, |
||||||
|
services: make(map[string]*serviceEntry), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Register registers a Service
|
||||||
|
func (s *Server) Register(b Service) { |
||||||
|
srv := &serviceEntry{backend: b} |
||||||
|
srv.id, srv.desc = b.ServiceInfo() |
||||||
|
if strings.Contains(srv.id, ":") { |
||||||
|
// srv.id + ":" will be used as a service database prefix
|
||||||
|
log.Error("Service ID contains ':'", "id", srv.id) |
||||||
|
return |
||||||
|
} |
||||||
|
s.lock.Lock() |
||||||
|
s.services[srv.id] = srv |
||||||
|
s.lock.Unlock() |
||||||
|
} |
||||||
|
|
||||||
|
// Serve serves a vflux request batch
|
||||||
|
// Note: requests are served by the Handle functions of the registered services. Serve
|
||||||
|
// may be called concurrently but the Handle functions are called sequentially and
|
||||||
|
// therefore thread safety is guaranteed.
|
||||||
|
func (s *Server) Serve(id enode.ID, address string, requests vflux.Requests) vflux.Replies { |
||||||
|
reqLen := uint(len(requests)) |
||||||
|
if reqLen == 0 || reqLen > vflux.MaxRequestLength { |
||||||
|
return nil |
||||||
|
} |
||||||
|
// Note: the value parameter will be supplied by the token sale module (total amount paid)
|
||||||
|
ch := <-s.limiter.Add(id, address, 0, reqLen) |
||||||
|
if ch == nil { |
||||||
|
return nil |
||||||
|
} |
||||||
|
// Note: the limiter ensures that the following section is not running concurrently,
|
||||||
|
// the lock only protects against contention caused by new service registration
|
||||||
|
s.lock.Lock() |
||||||
|
results := make(vflux.Replies, len(requests)) |
||||||
|
for i, req := range requests { |
||||||
|
if service := s.services[req.Service]; service != nil { |
||||||
|
results[i] = service.backend.Handle(id, address, req.Name, req.Params) |
||||||
|
} |
||||||
|
} |
||||||
|
s.lock.Unlock() |
||||||
|
time.Sleep(s.delayPerRequest * time.Duration(reqLen)) |
||||||
|
close(ch) |
||||||
|
return results |
||||||
|
} |
||||||
|
|
||||||
|
// ServeEncoded serves an encoded vflux request batch and returns the encoded replies
|
||||||
|
func (s *Server) ServeEncoded(id enode.ID, addr *net.UDPAddr, req []byte) []byte { |
||||||
|
var requests vflux.Requests |
||||||
|
if err := rlp.DecodeBytes(req, &requests); err != nil { |
||||||
|
return nil |
||||||
|
} |
||||||
|
results := s.Serve(id, addr.String(), requests) |
||||||
|
if results == nil { |
||||||
|
return nil |
||||||
|
} |
||||||
|
res, _ := rlp.EncodeToBytes(&results) |
||||||
|
return res |
||||||
|
} |
||||||
|
|
||||||
|
// Stop shuts down the server
|
||||||
|
func (s *Server) Stop() { |
||||||
|
s.limiter.Stop() |
||||||
|
} |
||||||
Loading…
Reference in new issue