mirror of
https://github.com/libp2p/go-libp2p-resource-manager.git
synced 2025-02-05 01:00:19 +08:00
reimplement parsing of JSON limit configs
This commit is contained in:
Marten Seemann
parent
83465e5846
commit
1e2500707d
83
limit.go
83
limit.go
@ -1,6 +1,9 @@
|
||||
package rcmgr
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"io"
|
||||
|
||||
"github.com/libp2p/go-libp2p-core/network"
|
||||
"github.com/libp2p/go-libp2p-core/peer"
|
||||
"github.com/libp2p/go-libp2p-core/protocol"
|
||||
@ -35,6 +38,30 @@ type Limiter interface {
|
||||
GetConnLimits() Limit
|
||||
}
|
||||
|
||||
// NewDefaultLimiterFromJSON creates a new limiter by parsing a json configuration,
|
||||
// using the default limits for fallback.
|
||||
func NewDefaultLimiterFromJSON(in io.Reader) (Limiter, error) {
|
||||
return NewLimiterFromJSON(in, DefaultLimits.AutoScale())
|
||||
}
|
||||
|
||||
// NewLimiterFromJSON creates a new limiter by parsing a json configuration.
|
||||
func NewLimiterFromJSON(in io.Reader, defaults LimitConfig) (Limiter, error) {
|
||||
cfg, err := readLimiterConfigFromJSON(in, defaults)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &fixedLimiter{cfg}, nil
|
||||
}
|
||||
|
||||
func readLimiterConfigFromJSON(in io.Reader, defaults LimitConfig) (LimitConfig, error) {
|
||||
var cfg LimitConfig
|
||||
if err := json.NewDecoder(in).Decode(&cfg); err != nil {
|
||||
return LimitConfig{}, err
|
||||
}
|
||||
cfg.apply(defaults)
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
// fixedLimiter is a limiter with fixed limits.
|
||||
type fixedLimiter struct {
|
||||
LimitConfig
|
||||
@ -70,6 +97,34 @@ type BaseLimitIncrease struct {
|
||||
FDFraction float64
|
||||
}
|
||||
|
||||
// Apply overwrites all zero-valued limits with the values of l2
|
||||
func (l *BaseLimit) Apply(l2 BaseLimit) {
|
||||
if l.Streams == 0 {
|
||||
l.Streams = l2.Streams
|
||||
}
|
||||
if l.StreamsInbound == 0 {
|
||||
l.StreamsInbound = l2.StreamsInbound
|
||||
}
|
||||
if l.StreamsOutbound == 0 {
|
||||
l.StreamsOutbound = l2.StreamsOutbound
|
||||
}
|
||||
if l.Conns == 0 {
|
||||
l.Conns = l2.Conns
|
||||
}
|
||||
if l.ConnsInbound == 0 {
|
||||
l.ConnsInbound = l2.ConnsInbound
|
||||
}
|
||||
if l.ConnsOutbound == 0 {
|
||||
l.ConnsOutbound = l2.ConnsOutbound
|
||||
}
|
||||
if l.Memory == 0 {
|
||||
l.Memory = l2.Memory
|
||||
}
|
||||
if l.FD == 0 {
|
||||
l.FD = l2.FD
|
||||
}
|
||||
}
|
||||
|
||||
func (l *BaseLimit) GetStreamLimit(dir network.Direction) int {
|
||||
if dir == network.DirInbound {
|
||||
return l.StreamsInbound
|
||||
@ -103,57 +158,57 @@ func (l *BaseLimit) GetMemoryLimit() int64 {
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetSystemLimits() Limit {
|
||||
return &l.SystemLimit
|
||||
return &l.System
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetTransientLimits() Limit {
|
||||
return &l.TransientLimit
|
||||
return &l.Transient
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetServiceLimits(svc string) Limit {
|
||||
sl, ok := l.ServiceLimits[svc]
|
||||
sl, ok := l.Service[svc]
|
||||
if !ok {
|
||||
return &l.DefaultServiceLimit
|
||||
return &l.ServiceDefault
|
||||
}
|
||||
return &sl
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetServicePeerLimits(svc string) Limit {
|
||||
pl, ok := l.ServicePeerLimits[svc]
|
||||
pl, ok := l.ServicePeer[svc]
|
||||
if !ok {
|
||||
return &l.DefaultServicePeerLimit
|
||||
return &l.ServicePeerDefault
|
||||
}
|
||||
return &pl
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetProtocolLimits(proto protocol.ID) Limit {
|
||||
pl, ok := l.ProtocolLimits[proto]
|
||||
pl, ok := l.Protocol[proto]
|
||||
if !ok {
|
||||
return &l.DefaultProtocolLimit
|
||||
return &l.ProtocolDefault
|
||||
}
|
||||
return &pl
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetProtocolPeerLimits(proto protocol.ID) Limit {
|
||||
pl, ok := l.ProtocolPeerLimits[proto]
|
||||
pl, ok := l.ProtocolPeer[proto]
|
||||
if !ok {
|
||||
return &l.DefaultProtocolPeerLimit
|
||||
return &l.ProtocolPeerDefault
|
||||
}
|
||||
return &pl
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetPeerLimits(p peer.ID) Limit {
|
||||
pl, ok := l.PeerLimits[p]
|
||||
pl, ok := l.Peer[p]
|
||||
if !ok {
|
||||
return &l.DefaultPeerLimit
|
||||
return &l.PeerDefault
|
||||
}
|
||||
return &pl
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetStreamLimits(_ peer.ID) Limit {
|
||||
return &l.StreamLimit
|
||||
return &l.Stream
|
||||
}
|
||||
|
||||
func (l *fixedLimiter) GetConnLimits() Limit {
|
||||
return &l.ConnLimit
|
||||
return &l.Conn
|
||||
}
|
||||
|
||||
53
limit_config_test.go
Normal file
53
limit_config_test.go
Normal file
@ -0,0 +1,53 @@
|
||||
package rcmgr
|
||||
|
||||
import (
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/libp2p/go-libp2p-core/peer"
|
||||
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func withMemoryLimit(l BaseLimit, m int64) BaseLimit {
|
||||
l2 := l
|
||||
l2.Memory = m
|
||||
return l2
|
||||
}
|
||||
|
||||
func TestLimitConfigParser(t *testing.T) {
|
||||
in, err := os.Open("limit_config_test.json")
|
||||
require.NoError(t, err)
|
||||
defer in.Close()
|
||||
|
||||
DefaultLimits.AddServiceLimit("C", DefaultLimits.ServiceBaseLimit, BaseLimitIncrease{})
|
||||
DefaultLimits.AddProtocolPeerLimit("C", DefaultLimits.ServiceBaseLimit, BaseLimitIncrease{})
|
||||
defaults := DefaultLimits.AutoScale()
|
||||
cfg, err := readLimiterConfigFromJSON(in, defaults)
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Equal(t, int64(65536), cfg.System.Memory)
|
||||
require.Equal(t, defaults.System.Streams, cfg.System.Streams)
|
||||
require.Equal(t, defaults.System.StreamsInbound, cfg.System.StreamsInbound)
|
||||
require.Equal(t, defaults.System.StreamsOutbound, cfg.System.StreamsOutbound)
|
||||
require.Equal(t, 16, cfg.System.Conns)
|
||||
require.Equal(t, 8, cfg.System.ConnsInbound)
|
||||
require.Equal(t, 16, cfg.System.ConnsOutbound)
|
||||
require.Equal(t, 16, cfg.System.FD)
|
||||
|
||||
require.Equal(t, defaults.Transient, cfg.Transient)
|
||||
require.Equal(t, int64(8765), cfg.ServiceDefault.Memory)
|
||||
|
||||
require.Contains(t, cfg.Service, "A")
|
||||
require.Equal(t, withMemoryLimit(cfg.ServiceDefault, 8192), cfg.Service["A"])
|
||||
require.Contains(t, cfg.Service, "B")
|
||||
require.Equal(t, cfg.ServiceDefault, cfg.Service["B"])
|
||||
require.Contains(t, cfg.Service, "C")
|
||||
require.Equal(t, defaults.Service["C"], cfg.Service["C"])
|
||||
|
||||
require.Equal(t, int64(4096), cfg.PeerDefault.Memory)
|
||||
peerID, err := peer.Decode("12D3KooWPFH2Bx2tPfw6RLxN8k2wh47GRXgkt9yrAHU37zFwHWzS")
|
||||
require.NoError(t, err)
|
||||
require.Contains(t, cfg.Peer, peerID)
|
||||
require.Equal(t, int64(4097), cfg.Peer[peerID].Memory)
|
||||
}
|
||||
@ -1,32 +1,22 @@
|
||||
{
|
||||
"System": {
|
||||
"Dynamic": true,
|
||||
"MinMemory": 16384,
|
||||
"MaxMemory": 65536,
|
||||
"MemoryFraction": 0.125,
|
||||
"Streams": 64,
|
||||
"StreamsInbound": 32,
|
||||
"StreamsOutbound": 48,
|
||||
"Memory": 65536,
|
||||
"Conns": 16,
|
||||
"ConnsInbound": 8,
|
||||
"ConnsOutbound": 16,
|
||||
"FD": 16
|
||||
},
|
||||
"Transient": {
|
||||
"MinMemory": 1024,
|
||||
"MaxMemory": 4096,
|
||||
"MemoryFraction": 0.03125
|
||||
},
|
||||
"ServiceDefault": {
|
||||
"Memory": 8192
|
||||
},
|
||||
"ServicePeerDefault": {
|
||||
"Memory": 2048
|
||||
"Memory": 8765
|
||||
},
|
||||
"Service": {
|
||||
"A": {
|
||||
"Memory": 8192
|
||||
}
|
||||
},
|
||||
"B": {}
|
||||
},
|
||||
"ServicePeerDefault": {
|
||||
"Memory": 2048
|
||||
},
|
||||
"ServicePeer": {
|
||||
"A": {
|
||||
@ -44,17 +34,12 @@
|
||||
"Memory": 8192
|
||||
}
|
||||
},
|
||||
"ProtocolPeer": {
|
||||
"/A": {
|
||||
"Memory": 4096
|
||||
}
|
||||
},
|
||||
"PeerDefault": {
|
||||
"Memory": 4096
|
||||
},
|
||||
"Peer": {
|
||||
"12D3KooWPFH2Bx2tPfw6RLxN8k2wh47GRXgkt9yrAHU37zFwHWzS": {
|
||||
"Memory": 4096
|
||||
"Memory": 4097
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -15,7 +15,7 @@ type baseLimitConfig struct {
|
||||
}
|
||||
|
||||
// ScalingLimitConfig is a struct for configuring default limits.
|
||||
// {}BaseLimit is the limits that apply for a minimal node (128 MB of memory for libp2p) and 256 file descriptors.
|
||||
// {}BaseLimit is the limits that Apply for a minimal node (128 MB of memory for libp2p) and 256 file descriptors.
|
||||
// {}LimitIncrease is the additional limit granted for every additional 1 GB of RAM.
|
||||
type ScalingLimitConfig struct {
|
||||
SystemBaseLimit BaseLimit
|
||||
@ -102,26 +102,123 @@ func (cfg *ScalingLimitConfig) AddProtocolPeerLimit(proto protocol.ID, base Base
|
||||
}
|
||||
|
||||
type LimitConfig struct {
|
||||
SystemLimit BaseLimit
|
||||
TransientLimit BaseLimit
|
||||
System BaseLimit `json:",omitempty"`
|
||||
Transient BaseLimit `json:",omitempty"`
|
||||
|
||||
DefaultServiceLimit BaseLimit
|
||||
ServiceLimits map[string]BaseLimit
|
||||
ServiceDefault BaseLimit `json:",omitempty"`
|
||||
Service map[string]BaseLimit `json:",omitempty"`
|
||||
|
||||
DefaultServicePeerLimit BaseLimit
|
||||
ServicePeerLimits map[string]BaseLimit
|
||||
ServicePeerDefault BaseLimit `json:",omitempty"`
|
||||
ServicePeer map[string]BaseLimit `json:",omitempty"`
|
||||
|
||||
DefaultProtocolLimit BaseLimit
|
||||
ProtocolLimits map[protocol.ID]BaseLimit
|
||||
ProtocolDefault BaseLimit `json:",omitempty"`
|
||||
Protocol map[protocol.ID]BaseLimit `json:",omitempty"`
|
||||
|
||||
DefaultProtocolPeerLimit BaseLimit
|
||||
ProtocolPeerLimits map[protocol.ID]BaseLimit
|
||||
ProtocolPeerDefault BaseLimit `json:",omitempty"`
|
||||
ProtocolPeer map[protocol.ID]BaseLimit `json:",omitempty"`
|
||||
|
||||
DefaultPeerLimit BaseLimit
|
||||
PeerLimits map[peer.ID]BaseLimit
|
||||
PeerDefault BaseLimit `json:",omitempty"`
|
||||
Peer map[peer.ID]BaseLimit `json:",omitempty"`
|
||||
|
||||
ConnLimit BaseLimit
|
||||
StreamLimit BaseLimit
|
||||
Conn BaseLimit `json:",omitempty"`
|
||||
Stream BaseLimit `json:",omitempty"`
|
||||
}
|
||||
|
||||
func (cfg *LimitConfig) apply(c LimitConfig) {
|
||||
cfg.System.Apply(c.System)
|
||||
cfg.Transient.Apply(c.Transient)
|
||||
cfg.ServiceDefault.Apply(c.ServiceDefault)
|
||||
cfg.ProtocolDefault.Apply(c.ProtocolDefault)
|
||||
cfg.ProtocolPeerDefault.Apply(c.ProtocolPeerDefault)
|
||||
cfg.PeerDefault.Apply(c.PeerDefault)
|
||||
cfg.Conn.Apply(c.Conn)
|
||||
cfg.Stream.Apply(c.Stream)
|
||||
|
||||
// TODO: the following could be solved a lot nicer, if only we could use generics
|
||||
for s, l := range cfg.Service {
|
||||
r := cfg.ServiceDefault
|
||||
if l2, ok := c.Service[s]; ok {
|
||||
r = l2
|
||||
}
|
||||
l.Apply(r)
|
||||
cfg.Service[s] = l
|
||||
}
|
||||
if c.Service != nil && cfg.Service == nil {
|
||||
cfg.Service = make(map[string]BaseLimit)
|
||||
}
|
||||
for s, l := range c.Service {
|
||||
if _, ok := cfg.Service[s]; !ok {
|
||||
cfg.Service[s] = l
|
||||
}
|
||||
}
|
||||
|
||||
for s, l := range cfg.ServicePeer {
|
||||
r := cfg.ServicePeerDefault
|
||||
if l2, ok := c.ServicePeer[s]; ok {
|
||||
r = l2
|
||||
}
|
||||
l.Apply(r)
|
||||
cfg.ServicePeer[s] = l
|
||||
}
|
||||
if c.ServicePeer != nil && cfg.ServicePeer == nil {
|
||||
cfg.ServicePeer = make(map[string]BaseLimit)
|
||||
}
|
||||
for s, l := range c.ServicePeer {
|
||||
if _, ok := cfg.ServicePeer[s]; !ok {
|
||||
cfg.ServicePeer[s] = l
|
||||
}
|
||||
}
|
||||
|
||||
for s, l := range cfg.Protocol {
|
||||
r := cfg.ProtocolDefault
|
||||
if l2, ok := c.Protocol[s]; ok {
|
||||
r = l2
|
||||
}
|
||||
l.Apply(r)
|
||||
cfg.Protocol[s] = l
|
||||
}
|
||||
if c.Protocol != nil && cfg.Protocol == nil {
|
||||
cfg.Protocol = make(map[protocol.ID]BaseLimit)
|
||||
}
|
||||
for s, l := range c.Protocol {
|
||||
if _, ok := cfg.Protocol[s]; !ok {
|
||||
cfg.Protocol[s] = l
|
||||
}
|
||||
}
|
||||
|
||||
for s, l := range cfg.ProtocolPeer {
|
||||
r := cfg.ProtocolPeerDefault
|
||||
if l2, ok := c.ProtocolPeer[s]; ok {
|
||||
r = l2
|
||||
}
|
||||
l.Apply(r)
|
||||
cfg.ProtocolPeer[s] = l
|
||||
}
|
||||
if c.ProtocolPeer != nil && cfg.ProtocolPeer == nil {
|
||||
cfg.ProtocolPeer = make(map[protocol.ID]BaseLimit)
|
||||
}
|
||||
for s, l := range c.ProtocolPeer {
|
||||
if _, ok := cfg.ProtocolPeer[s]; !ok {
|
||||
cfg.ProtocolPeer[s] = l
|
||||
}
|
||||
}
|
||||
|
||||
for s, l := range cfg.Peer {
|
||||
r := cfg.PeerDefault
|
||||
if l2, ok := c.Peer[s]; ok {
|
||||
r = l2
|
||||
}
|
||||
l.Apply(r)
|
||||
cfg.Peer[s] = l
|
||||
}
|
||||
if c.Peer != nil && cfg.Peer == nil {
|
||||
cfg.Peer = make(map[peer.ID]BaseLimit)
|
||||
}
|
||||
for s, l := range c.Peer {
|
||||
if _, ok := cfg.Peer[s]; !ok {
|
||||
cfg.Peer[s] = l
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Scale scales up a limit configuration.
|
||||
@ -135,44 +232,44 @@ func (cfg *ScalingLimitConfig) Scale(memory int64, numFD int) LimitConfig {
|
||||
scaleFactor = int((memory - 128<<20) >> 20)
|
||||
}
|
||||
lc := LimitConfig{
|
||||
SystemLimit: scale(cfg.SystemBaseLimit, cfg.SystemLimitIncrease, scaleFactor, numFD),
|
||||
TransientLimit: scale(cfg.TransientBaseLimit, cfg.TransientLimitIncrease, scaleFactor, numFD),
|
||||
DefaultServiceLimit: scale(cfg.ServiceBaseLimit, cfg.ServiceLimitIncrease, scaleFactor, numFD),
|
||||
DefaultServicePeerLimit: scale(cfg.ServicePeerBaseLimit, cfg.ServicePeerLimitIncrease, scaleFactor, numFD),
|
||||
DefaultProtocolLimit: scale(cfg.ProtocolBaseLimit, cfg.ProtocolLimitIncrease, scaleFactor, numFD),
|
||||
DefaultProtocolPeerLimit: scale(cfg.ProtocolPeerBaseLimit, cfg.ProtocolPeerLimitIncrease, scaleFactor, numFD),
|
||||
DefaultPeerLimit: scale(cfg.PeerBaseLimit, cfg.PeerLimitIncrease, scaleFactor, numFD),
|
||||
ConnLimit: scale(cfg.ConnBaseLimit, cfg.ConnLimitIncrease, scaleFactor, numFD),
|
||||
StreamLimit: scale(cfg.StreamBaseLimit, cfg.ConnLimitIncrease, scaleFactor, numFD),
|
||||
System: scale(cfg.SystemBaseLimit, cfg.SystemLimitIncrease, scaleFactor, numFD),
|
||||
Transient: scale(cfg.TransientBaseLimit, cfg.TransientLimitIncrease, scaleFactor, numFD),
|
||||
ServiceDefault: scale(cfg.ServiceBaseLimit, cfg.ServiceLimitIncrease, scaleFactor, numFD),
|
||||
ServicePeerDefault: scale(cfg.ServicePeerBaseLimit, cfg.ServicePeerLimitIncrease, scaleFactor, numFD),
|
||||
ProtocolDefault: scale(cfg.ProtocolBaseLimit, cfg.ProtocolLimitIncrease, scaleFactor, numFD),
|
||||
ProtocolPeerDefault: scale(cfg.ProtocolPeerBaseLimit, cfg.ProtocolPeerLimitIncrease, scaleFactor, numFD),
|
||||
PeerDefault: scale(cfg.PeerBaseLimit, cfg.PeerLimitIncrease, scaleFactor, numFD),
|
||||
Conn: scale(cfg.ConnBaseLimit, cfg.ConnLimitIncrease, scaleFactor, numFD),
|
||||
Stream: scale(cfg.StreamBaseLimit, cfg.ConnLimitIncrease, scaleFactor, numFD),
|
||||
}
|
||||
if cfg.ServiceLimits != nil {
|
||||
lc.ServiceLimits = make(map[string]BaseLimit)
|
||||
lc.Service = make(map[string]BaseLimit)
|
||||
for svc, l := range cfg.ServiceLimits {
|
||||
lc.ServiceLimits[svc] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
lc.Service[svc] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
}
|
||||
}
|
||||
if cfg.ProtocolLimits != nil {
|
||||
lc.ProtocolLimits = make(map[protocol.ID]BaseLimit)
|
||||
lc.Protocol = make(map[protocol.ID]BaseLimit)
|
||||
for proto, l := range cfg.ProtocolLimits {
|
||||
lc.ProtocolLimits[proto] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
lc.Protocol[proto] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
}
|
||||
}
|
||||
if cfg.PeerLimits != nil {
|
||||
lc.PeerLimits = make(map[peer.ID]BaseLimit)
|
||||
lc.Peer = make(map[peer.ID]BaseLimit)
|
||||
for p, l := range cfg.PeerLimits {
|
||||
lc.PeerLimits[p] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
lc.Peer[p] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
}
|
||||
}
|
||||
if cfg.ServicePeerLimits != nil {
|
||||
lc.ServicePeerLimits = make(map[string]BaseLimit)
|
||||
lc.ServicePeer = make(map[string]BaseLimit)
|
||||
for svc, l := range cfg.ServicePeerLimits {
|
||||
lc.ServicePeerLimits[svc] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
lc.ServicePeer[svc] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
}
|
||||
}
|
||||
if cfg.ProtocolPeerLimits != nil {
|
||||
lc.ProtocolPeerLimits = make(map[protocol.ID]BaseLimit)
|
||||
lc.ProtocolPeer = make(map[protocol.ID]BaseLimit)
|
||||
for p, l := range cfg.ProtocolPeerLimits {
|
||||
lc.ProtocolPeerLimits[p] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
lc.ProtocolPeer[p] = scale(l.BaseLimit, l.BaseLimitIncrease, scaleFactor, numFD)
|
||||
}
|
||||
}
|
||||
return lc
|
||||
@ -354,13 +451,13 @@ var infiniteBaseLimit = BaseLimit{
|
||||
// InfiniteLimits are a limiter configuration that uses infinite limits, thus effectively not limiting anything.
|
||||
// Keep in mind that the operating system limits the number of file descriptors that an application can use.
|
||||
var InfiniteLimits = LimitConfig{
|
||||
SystemLimit: infiniteBaseLimit,
|
||||
TransientLimit: infiniteBaseLimit,
|
||||
DefaultServiceLimit: infiniteBaseLimit,
|
||||
DefaultServicePeerLimit: infiniteBaseLimit,
|
||||
DefaultProtocolLimit: infiniteBaseLimit,
|
||||
DefaultProtocolPeerLimit: infiniteBaseLimit,
|
||||
DefaultPeerLimit: infiniteBaseLimit,
|
||||
ConnLimit: infiniteBaseLimit,
|
||||
StreamLimit: infiniteBaseLimit,
|
||||
System: infiniteBaseLimit,
|
||||
Transient: infiniteBaseLimit,
|
||||
ServiceDefault: infiniteBaseLimit,
|
||||
ServicePeerDefault: infiniteBaseLimit,
|
||||
ProtocolDefault: infiniteBaseLimit,
|
||||
ProtocolPeerDefault: infiniteBaseLimit,
|
||||
PeerDefault: infiniteBaseLimit,
|
||||
Conn: infiniteBaseLimit,
|
||||
Stream: infiniteBaseLimit,
|
||||
}
|
||||
|
||||
@ -31,7 +31,7 @@ func TestScaling(t *testing.T) {
|
||||
t.Run("no scaling if no increase is defined", func(t *testing.T) {
|
||||
cfg := ScalingLimitConfig{ServiceBaseLimit: base}
|
||||
scaled := cfg.Scale(8<<30, 100)
|
||||
require.Equal(t, base, scaled.DefaultServiceLimit)
|
||||
require.Equal(t, base, scaled.ServiceDefault)
|
||||
})
|
||||
|
||||
t.Run("scaling", func(t *testing.T) {
|
||||
@ -49,14 +49,14 @@ func TestScaling(t *testing.T) {
|
||||
},
|
||||
}
|
||||
scaled := cfg.Scale(128<<20+4<<30, 1000)
|
||||
require.Equal(t, 500, scaled.TransientLimit.FD)
|
||||
require.Equal(t, base.Streams+4, scaled.TransientLimit.Streams)
|
||||
require.Equal(t, base.StreamsInbound+4*2, scaled.TransientLimit.StreamsInbound)
|
||||
require.Equal(t, base.StreamsOutbound+4*3, scaled.TransientLimit.StreamsOutbound)
|
||||
require.Equal(t, base.Conns+4*4, scaled.TransientLimit.Conns)
|
||||
require.Equal(t, base.ConnsInbound+4*5, scaled.TransientLimit.ConnsInbound)
|
||||
require.Equal(t, base.ConnsOutbound+4*6, scaled.TransientLimit.ConnsOutbound)
|
||||
require.Equal(t, base.Memory+4*7, scaled.TransientLimit.Memory)
|
||||
require.Equal(t, 500, scaled.Transient.FD)
|
||||
require.Equal(t, base.Streams+4, scaled.Transient.Streams)
|
||||
require.Equal(t, base.StreamsInbound+4*2, scaled.Transient.StreamsInbound)
|
||||
require.Equal(t, base.StreamsOutbound+4*3, scaled.Transient.StreamsOutbound)
|
||||
require.Equal(t, base.Conns+4*4, scaled.Transient.Conns)
|
||||
require.Equal(t, base.ConnsInbound+4*5, scaled.Transient.ConnsInbound)
|
||||
require.Equal(t, base.ConnsOutbound+4*6, scaled.Transient.ConnsOutbound)
|
||||
require.Equal(t, base.Memory+4*7, scaled.Transient.Memory)
|
||||
})
|
||||
|
||||
t.Run("scaling limits in maps", func(t *testing.T) {
|
||||
@ -73,15 +73,16 @@ func TestScaling(t *testing.T) {
|
||||
}
|
||||
scaled := cfg.Scale(128<<20+4<<30, 1000)
|
||||
|
||||
require.Len(t, scaled.ServiceLimits, 2)
|
||||
require.Contains(t, scaled.ServiceLimits, "A")
|
||||
require.Equal(t, 10, scaled.ServiceLimits["A"].Streams)
|
||||
require.Equal(t, int64(100), scaled.ServiceLimits["A"].Memory)
|
||||
require.Equal(t, 9, scaled.ServiceLimits["A"].FD)
|
||||
require.Len(t, scaled.Service, 2)
|
||||
require.Contains(t, scaled.Service, "A")
|
||||
require.Equal(t, 10, scaled.Service["A"].Streams)
|
||||
require.Equal(t, int64(100), scaled.Service["A"].Memory)
|
||||
require.Equal(t, 9, scaled.Service["A"].FD)
|
||||
|
||||
require.Contains(t, scaled.Service, "B")
|
||||
require.Equal(t, 20+4*2, scaled.Service["B"].Streams)
|
||||
require.Equal(t, int64(200+4*3), scaled.Service["B"].Memory)
|
||||
require.Equal(t, 400, scaled.Service["B"].FD)
|
||||
|
||||
require.Contains(t, scaled.ServiceLimits, "B")
|
||||
require.Equal(t, 20+4*2, scaled.ServiceLimits["B"].Streams)
|
||||
require.Equal(t, int64(200+4*3), scaled.ServiceLimits["B"].Memory)
|
||||
require.Equal(t, 400, scaled.ServiceLimits["B"].FD)
|
||||
})
|
||||
}
|
||||
|
||||
@ -21,7 +21,7 @@ func TestResourceManager(t *testing.T) {
|
||||
svcB := "B.svc"
|
||||
nmgr, err := NewResourceManager(
|
||||
NewFixedLimiter(LimitConfig{
|
||||
SystemLimit: BaseLimit{
|
||||
System: BaseLimit{
|
||||
Memory: 16384,
|
||||
StreamsInbound: 3,
|
||||
StreamsOutbound: 3,
|
||||
@ -31,7 +31,7 @@ func TestResourceManager(t *testing.T) {
|
||||
Conns: 6,
|
||||
FD: 2,
|
||||
},
|
||||
TransientLimit: BaseLimit{
|
||||
Transient: BaseLimit{
|
||||
Memory: 4096,
|
||||
StreamsInbound: 1,
|
||||
StreamsOutbound: 1,
|
||||
@ -41,7 +41,7 @@ func TestResourceManager(t *testing.T) {
|
||||
Conns: 2,
|
||||
FD: 1,
|
||||
},
|
||||
DefaultServiceLimit: BaseLimit{
|
||||
ServiceDefault: BaseLimit{
|
||||
Memory: 4096,
|
||||
StreamsInbound: 1,
|
||||
StreamsOutbound: 1,
|
||||
@ -51,13 +51,13 @@ func TestResourceManager(t *testing.T) {
|
||||
Conns: 2,
|
||||
FD: 1,
|
||||
},
|
||||
DefaultServicePeerLimit: BaseLimit{
|
||||
ServicePeerDefault: BaseLimit{
|
||||
Memory: 4096,
|
||||
StreamsInbound: 5,
|
||||
StreamsOutbound: 5,
|
||||
Streams: 10,
|
||||
},
|
||||
ServiceLimits: map[string]BaseLimit{
|
||||
Service: map[string]BaseLimit{
|
||||
svcA: {
|
||||
Memory: 8192,
|
||||
StreamsInbound: 2,
|
||||
@ -79,7 +79,7 @@ func TestResourceManager(t *testing.T) {
|
||||
FD: 1,
|
||||
},
|
||||
},
|
||||
ServicePeerLimits: map[string]BaseLimit{
|
||||
ServicePeer: map[string]BaseLimit{
|
||||
svcB: {
|
||||
Memory: 8192,
|
||||
StreamsInbound: 1,
|
||||
@ -87,13 +87,13 @@ func TestResourceManager(t *testing.T) {
|
||||
Streams: 2,
|
||||
},
|
||||
},
|
||||
DefaultProtocolLimit: BaseLimit{
|
||||
ProtocolDefault: BaseLimit{
|
||||
Memory: 4096,
|
||||
StreamsInbound: 1,
|
||||
StreamsOutbound: 1,
|
||||
Streams: 2,
|
||||
},
|
||||
ProtocolLimits: map[protocol.ID]BaseLimit{
|
||||
Protocol: map[protocol.ID]BaseLimit{
|
||||
protoA: {
|
||||
Memory: 8192,
|
||||
StreamsInbound: 2,
|
||||
@ -101,7 +101,7 @@ func TestResourceManager(t *testing.T) {
|
||||
Streams: 2,
|
||||
},
|
||||
},
|
||||
ProtocolPeerLimits: map[protocol.ID]BaseLimit{
|
||||
ProtocolPeer: map[protocol.ID]BaseLimit{
|
||||
protoB: {
|
||||
Memory: 8192,
|
||||
StreamsInbound: 1,
|
||||
@ -109,7 +109,7 @@ func TestResourceManager(t *testing.T) {
|
||||
Streams: 2,
|
||||
},
|
||||
},
|
||||
DefaultPeerLimit: BaseLimit{
|
||||
PeerDefault: BaseLimit{
|
||||
Memory: 4096,
|
||||
StreamsInbound: 1,
|
||||
StreamsOutbound: 1,
|
||||
@ -119,13 +119,13 @@ func TestResourceManager(t *testing.T) {
|
||||
Conns: 2,
|
||||
FD: 1,
|
||||
},
|
||||
DefaultProtocolPeerLimit: BaseLimit{
|
||||
ProtocolPeerDefault: BaseLimit{
|
||||
Memory: 4096,
|
||||
StreamsInbound: 5,
|
||||
StreamsOutbound: 5,
|
||||
Streams: 10,
|
||||
},
|
||||
PeerLimits: map[peer.ID]BaseLimit{
|
||||
Peer: map[peer.ID]BaseLimit{
|
||||
peerA: {
|
||||
Memory: 8192,
|
||||
StreamsInbound: 2,
|
||||
@ -137,14 +137,14 @@ func TestResourceManager(t *testing.T) {
|
||||
FD: 1,
|
||||
},
|
||||
},
|
||||
ConnLimit: BaseLimit{
|
||||
Conn: BaseLimit{
|
||||
Memory: 4096,
|
||||
ConnsInbound: 1,
|
||||
ConnsOutbound: 1,
|
||||
Conns: 1,
|
||||
FD: 1,
|
||||
},
|
||||
StreamLimit: BaseLimit{
|
||||
Stream: BaseLimit{
|
||||
Memory: 4096,
|
||||
StreamsInbound: 1,
|
||||
StreamsOutbound: 1,
|
||||
@ -978,12 +978,12 @@ func TestResourceManagerWithAllowlist(t *testing.T) {
|
||||
peerA := test.RandPeerIDFatal(t)
|
||||
|
||||
limits := DefaultLimits.Scale(1<<30, 100)
|
||||
limits.SystemLimit.Conns = 0
|
||||
limits.SystemLimit.ConnsInbound = 0
|
||||
limits.SystemLimit.ConnsOutbound = 0
|
||||
limits.TransientLimit.Conns = 0
|
||||
limits.TransientLimit.ConnsInbound = 0
|
||||
limits.TransientLimit.ConnsOutbound = 0
|
||||
limits.System.Conns = 0
|
||||
limits.System.ConnsInbound = 0
|
||||
limits.System.ConnsOutbound = 0
|
||||
limits.Transient.Conns = 0
|
||||
limits.Transient.ConnsInbound = 0
|
||||
limits.Transient.ConnsOutbound = 0
|
||||
rcmgr, err := NewResourceManager(NewFixedLimiter(limits), WithAllowlistedMultiaddrs([]multiaddr.Multiaddr{
|
||||
multiaddr.StringCast("/ip4/1.2.3.4"),
|
||||
multiaddr.StringCast("/ip4/4.3.2.1/p2p/" + peerA.String()),
|
||||
@ -996,14 +996,14 @@ func TestResourceManagerWithAllowlist(t *testing.T) {
|
||||
// Setup allowlist. TODO, replace this with a config once config changes are in
|
||||
r := rcmgr.(*resourceManager)
|
||||
|
||||
sysLimit := limits.SystemLimit
|
||||
sysLimit := limits.System
|
||||
sysLimit.Conns = 2
|
||||
sysLimit.ConnsInbound = 2
|
||||
sysLimit.ConnsOutbound = 1
|
||||
r.allowlistedSystem = newSystemScope(&sysLimit, r, "allowlistedSystem")
|
||||
r.allowlistedSystem.IncRef()
|
||||
|
||||
transLimit := limits.TransientLimit
|
||||
transLimit := limits.Transient
|
||||
transLimit.Conns = 1
|
||||
transLimit.ConnsInbound = 1
|
||||
transLimit.ConnsOutbound = 1
|
||||
|
||||
Loading…
Reference in New Issue
Block a user