ceremonyclient/go-libp2p/p2p/host/resource-manager/limit_test.go

package rcmgr

import (
	"encoding/json"
	"math"
	"runtime"
	"testing"

	"github.com/stretchr/testify/require"
)

func TestFileDescriptorCounting(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("can't read file descriptors on Windows")
	}
	n := getNumFDs()
	require.NotZero(t, n)
	require.Less(t, n, int(1e7))
}

func TestScaling(t *testing.T) {
	base := BaseLimit{
		Streams:         100,
		StreamsInbound:  200,
		StreamsOutbound: 400,
		Conns:           10,
		ConnsInbound:    20,
		ConnsOutbound:   40,
		FD:              1,
		Memory:          1 << 20,
	}

	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.serviceDefault)
	})

	t.Run("scaling", func(t *testing.T) {
		cfg := ScalingLimitConfig{
			TransientBaseLimit: base,
			TransientLimitIncrease: BaseLimitIncrease{
				Streams:         1,
				StreamsInbound:  2,
				StreamsOutbound: 3,
				Conns:           4,
				ConnsInbound:    5,
				ConnsOutbound:   6,
				Memory:          7,
				FDFraction:      0.5,
			},
		}
		scaled := cfg.Scale(128<<20+4<<30, 1000)
		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 and using the base amounts", func(t *testing.T) {
		cfg := ScalingLimitConfig{
			TransientBaseLimit: base,
			TransientLimitIncrease: BaseLimitIncrease{
				Streams:         1,
				StreamsInbound:  2,
				StreamsOutbound: 3,
				Conns:           4,
				ConnsInbound:    5,
				ConnsOutbound:   6,
				Memory:          7,
				FDFraction:      0.01,
			},
		}
		scaled := cfg.Scale(1, 10)
		require.Equal(t, 1, scaled.transient.FD)
		require.Equal(t, base.Streams, scaled.transient.Streams)
		require.Equal(t, base.StreamsInbound, scaled.transient.StreamsInbound)
		require.Equal(t, base.StreamsOutbound, scaled.transient.StreamsOutbound)
		require.Equal(t, base.Conns, scaled.transient.Conns)
		require.Equal(t, base.ConnsInbound, scaled.transient.ConnsInbound)
		require.Equal(t, base.ConnsOutbound, scaled.transient.ConnsOutbound)
		require.Equal(t, base.Memory, scaled.transient.Memory)
	})

	t.Run("scaling limits in maps", func(t *testing.T) {
		cfg := ScalingLimitConfig{
			ServiceLimits: map[string]baseLimitConfig{
				"A": {
					BaseLimit: BaseLimit{Streams: 10, Memory: 100, FD: 9},
				},
				"B": {
					BaseLimit:         BaseLimit{Streams: 20, Memory: 200, FD: 10},
					BaseLimitIncrease: BaseLimitIncrease{Streams: 2, Memory: 3, FDFraction: 0.4},
				},
			},
		}
		scaled := cfg.Scale(128<<20+4<<30, 1000)

		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)
	})
}

func TestReadmeExample(t *testing.T) {
	scalingLimits := ScalingLimitConfig{
		SystemBaseLimit: BaseLimit{
			ConnsInbound:    64,
			ConnsOutbound:   128,
			Conns:           128,
			StreamsInbound:  512,
			StreamsOutbound: 1024,
			Streams:         1024,
			Memory:          128 << 20,
			FD:              256,
		},
		SystemLimitIncrease: BaseLimitIncrease{
			ConnsInbound:    32,
			ConnsOutbound:   64,
			Conns:           64,
			StreamsInbound:  256,
			StreamsOutbound: 512,
			Streams:         512,
			Memory:          256 << 20,
			FDFraction:      1,
		},
	}

	limitConf := scalingLimits.Scale(4<<30, 1000)

	require.Equal(t, 384, limitConf.system.Conns)
	require.Equal(t, 1000, limitConf.system.FD)
}

func TestJSONMarshalling(t *testing.T) {
	bl := ResourceLimits{
		Streams:         DefaultLimit,
		StreamsInbound:  10,
		StreamsOutbound: BlockAllLimit,
		Conns:           10,
		// ConnsInbound:    DefaultLimit,
		ConnsOutbound: Unlimited,
		Memory:        Unlimited64,
	}

	jsonEncoded, err := json.Marshal(bl)
	require.NoError(t, err)
	require.Equal(t, `{"StreamsInbound":10,"StreamsOutbound":"blockAll","Conns":10,"ConnsOutbound":"unlimited","Memory":"unlimited"}`, string(jsonEncoded))

	// Roundtrip
	var blDecoded ResourceLimits
	err = json.Unmarshal(jsonEncoded, &blDecoded)
	require.NoError(t, err)

	require.Equal(t, bl, blDecoded)
}

func TestJSONRoundTripInt64(t *testing.T) {
	bl := ResourceLimits{
		Memory: math.MaxInt64,
	}

	jsonEncoded, err := json.Marshal(bl)
	require.NoError(t, err)

	require.Equal(t, `{"Memory":"9223372036854775807"}`, string(jsonEncoded))

	// Roundtrip
	var blDecoded ResourceLimits
	err = json.Unmarshal(jsonEncoded, &blDecoded)
	require.NoError(t, err)

	require.Equal(t, bl, blDecoded)
}

func TestRoundTripFromConcreteAndBack(t *testing.T) {
	l := PartialLimitConfig{
		System: ResourceLimits{
			Conns:  1234,
			Memory: 54321,
		},

		ServiceDefault: ResourceLimits{
			Conns: 2,
		},

		Service: map[string]ResourceLimits{
			"foo": {
				Conns: 3,
			},
		},
	}

	concrete := l.Build(InfiniteLimits)

	// Roundtrip
	fromConcrete := concrete.ToPartialLimitConfig().Build(InfiniteLimits)
	require.Equal(t, concrete, fromConcrete)
}

func TestSerializeJSON(t *testing.T) {
	bl := BaseLimit{
		Streams: 10,
	}

	out, err := json.Marshal(bl)
	require.NoError(t, err)
	require.Equal(t, "{\"Streams\":10}", string(out))

	bli := BaseLimitIncrease{
		Streams: 10,
	}

	out, err = json.Marshal(bli)
	require.NoError(t, err)
	require.Equal(t, "{\"Streams\":10}", string(out))
}

func TestWhatIsZeroInResourceLimits(t *testing.T) {
	l := ResourceLimits{
		Streams: BlockAllLimit,
		Memory:  BlockAllLimit64,
	}

	out, err := json.Marshal(l)
	require.NoError(t, err)
	require.Equal(t, `{"Streams":"blockAll","Memory":"blockAll"}`, string(out))

	l2 := ResourceLimits{}
	err = json.Unmarshal([]byte(`{"Streams":0,"Memory":0}`), &l2)
	require.NoError(t, err)
	require.Equal(t, l, l2)

	l3 := ResourceLimits{}
	err = json.Unmarshal([]byte(`{"Streams":0,"Memory":"0"}`), &l3)
	require.NoError(t, err)
	require.Equal(t, l, l3)
}