diff --git a/limit.go b/limit.go index 812309b..786611b 100644 --- a/limit.go +++ b/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 } diff --git a/limit_config_test.go b/limit_config_test.go new file mode 100644 index 0000000..bdbf435 --- /dev/null +++ b/limit_config_test.go @@ -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) +} diff --git a/limit_config_test.json b/limit_config_test.json index a766a7f..b7758ba 100644 --- a/limit_config_test.json +++ b/limit_config_test.json @@ -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 - } + "12D3KooWPFH2Bx2tPfw6RLxN8k2wh47GRXgkt9yrAHU37zFwHWzS": { + "Memory": 4097 + } } } diff --git a/limit_defaults.go b/limit_defaults.go index 406dabd..04a3ca5 100644 --- a/limit_defaults.go +++ b/limit_defaults.go @@ -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, } diff --git a/limit_test.go b/limit_test.go index 3c5a8e9..2268187 100644 --- a/limit_test.go +++ b/limit_test.go @@ -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) }) } diff --git a/rcmgr_test.go b/rcmgr_test.go index 0d49206..f853ae0 100644 --- a/rcmgr_test.go +++ b/rcmgr_test.go @@ -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