mirror of
https://github.com/livekit/livekit.git
synced 2026-10-16 00:10:26 +00:00
Martin Njalale
d2d89011e2
GenerateCLIFlags created an Int64Flag for every time.Duration config field. Setting one through its LIVEKIT_* env var or --flag with a duration string such as "30s" (the format the YAML config and the generated help text use) made the server exit at startup with a parse error. A value without a unit was accepted and read as nanoseconds. Use a DurationFlag for these fields, so they take the same values as in the YAML config.
328 lines
11 KiB
Go
328 lines
11 KiB
Go
// Copyright 2023 LiveKit, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package config
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/urfave/cli/v3"
|
|
|
|
"github.com/livekit/livekit-server/pkg/config/configtest"
|
|
"github.com/livekit/livekit-server/pkg/sfu/pacer"
|
|
)
|
|
|
|
func TestConfig_UnmarshalKeys(t *testing.T) {
|
|
conf, err := NewConfig("", true, nil, nil)
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, conf.unmarshalKeys("key1: secret1"))
|
|
require.Equal(t, "secret1", conf.Keys["key1"])
|
|
}
|
|
|
|
func TestConfig_DefaultsKept(t *testing.T) {
|
|
const content = `room:
|
|
empty_timeout: 10`
|
|
conf, err := NewConfig(content, true, nil, nil)
|
|
require.NoError(t, err)
|
|
require.Equal(t, true, conf.Room.AutoCreate)
|
|
require.Equal(t, uint32(10), conf.Room.EmptyTimeout)
|
|
}
|
|
|
|
func TestConfig_SignalMessageSizeLimitDefaults(t *testing.T) {
|
|
conf, err := NewConfig("", true, nil, nil)
|
|
require.NoError(t, err)
|
|
// both default to 2 MiB when not specified
|
|
require.Equal(t, int64(2<<20), conf.Limit.SignalMessageSizeLimit)
|
|
require.Equal(t, int64(2<<20), conf.Limit.AgentSignalMessageSizeLimit)
|
|
}
|
|
|
|
func TestConfig_SignalMessageSizeLimitOverride(t *testing.T) {
|
|
const content = `limit:
|
|
signal_message_size_limit: 1024
|
|
agent_signal_message_size_limit: 0`
|
|
conf, err := NewConfig(content, true, nil, nil)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(1024), conf.Limit.SignalMessageSizeLimit)
|
|
// 0 explicitly disables the limit
|
|
require.Equal(t, int64(0), conf.Limit.AgentSignalMessageSizeLimit)
|
|
}
|
|
|
|
func TestConfig_PSRPCCompressionDefaults(t *testing.T) {
|
|
conf, err := NewConfig("", true, nil, nil)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 0, conf.PSRPC.Compression.Quality)
|
|
require.Equal(t, 1024, conf.PSRPC.Compression.Threshold)
|
|
require.Equal(t, 0, conf.PSRPC.Compression.MaxDecompressedSize)
|
|
}
|
|
|
|
func TestConfig_PSRPCCompressionOverride(t *testing.T) {
|
|
const content = `psrpc:
|
|
compression:
|
|
quality: 6
|
|
max_decompressed_size: 4096`
|
|
conf, err := NewConfig(content, true, nil, nil)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 6, conf.PSRPC.Compression.Quality)
|
|
require.Equal(t, 4096, conf.PSRPC.Compression.MaxDecompressedSize)
|
|
require.Equal(t, 1024, conf.PSRPC.Compression.Threshold)
|
|
require.Equal(t, 3, conf.PSRPC.MaxAttempts)
|
|
}
|
|
|
|
func TestConfig_UnknownKeys(t *testing.T) {
|
|
const content = `unknown: 10
|
|
room:
|
|
empty_timeout: 10`
|
|
_, err := NewConfig(content, true, nil, nil)
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestGeneratedFlags(t *testing.T) {
|
|
generatedFlags, err := GenerateCLIFlags(nil, false)
|
|
require.NoError(t, err)
|
|
|
|
c := &cli.Command{}
|
|
c.Name = "test"
|
|
c.Flags = append(c.Flags, generatedFlags...)
|
|
|
|
c.Set("rtc.use_ice_lite", "true")
|
|
c.Set("redis.address", "localhost:6379")
|
|
c.Set("prometheus.port", "9999")
|
|
c.Set("rtc.allow_tcp_fallback", "true")
|
|
c.Set("rtc.reconnect_on_publication_error", "true")
|
|
c.Set("rtc.reconnect_on_subscription_error", "false")
|
|
|
|
conf, err := NewConfig("", true, c, nil)
|
|
require.NoError(t, err)
|
|
|
|
require.True(t, conf.RTC.UseICELite)
|
|
require.Equal(t, "localhost:6379", conf.Redis.Address)
|
|
require.Equal(t, uint32(9999), conf.Prometheus.Port)
|
|
|
|
require.NotNil(t, conf.RTC.AllowTCPFallback)
|
|
require.True(t, *conf.RTC.AllowTCPFallback)
|
|
|
|
require.NotNil(t, conf.RTC.ReconnectOnPublicationError)
|
|
require.True(t, *conf.RTC.ReconnectOnPublicationError)
|
|
|
|
require.NotNil(t, conf.RTC.ReconnectOnSubscriptionError)
|
|
require.False(t, *conf.RTC.ReconnectOnSubscriptionError)
|
|
}
|
|
|
|
func TestGeneratedDurationFlags(t *testing.T) {
|
|
// run a command with the generated flags, as cmd/server does, so that flag and env var values are parsed
|
|
run := func(t *testing.T, args ...string) (*Config, error) {
|
|
generatedFlags, err := GenerateCLIFlags(nil, true)
|
|
require.NoError(t, err)
|
|
|
|
var conf *Config
|
|
c := &cli.Command{
|
|
Name: "test",
|
|
Flags: generatedFlags,
|
|
Action: func(_ context.Context, c *cli.Command) error {
|
|
var err error
|
|
conf, err = NewConfig("", true, c, nil)
|
|
return err
|
|
},
|
|
}
|
|
err = c.Run(context.Background(), append([]string{"test"}, args...))
|
|
return conf, err
|
|
}
|
|
|
|
t.Run("flag", func(t *testing.T) {
|
|
conf, err := run(t, "--api.execution_timeout=5s")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 5*time.Second, conf.API.ExecutionTimeout)
|
|
})
|
|
|
|
t.Run("env var", func(t *testing.T) {
|
|
t.Setenv("LIVEKIT_ROOM_CREATE_ROOM_TIMEOUT", "30s")
|
|
conf, err := run(t)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 30*time.Second, conf.Room.CreateRoomTimeout)
|
|
})
|
|
|
|
t.Run("value without a unit", func(t *testing.T) {
|
|
// rejected, as in the YAML config, instead of being read as nanoseconds
|
|
t.Setenv("LIVEKIT_ROOM_CREATE_ROOM_TIMEOUT", "30")
|
|
_, err := run(t)
|
|
require.ErrorContains(t, err, "LIVEKIT_ROOM_CREATE_ROOM_TIMEOUT")
|
|
})
|
|
}
|
|
|
|
func TestYAMLTag(t *testing.T) {
|
|
require.NoError(t, configtest.CheckYAMLTags(Config{}))
|
|
}
|
|
|
|
func TestClampTURNTTLSeconds(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
in int
|
|
want int
|
|
changed bool
|
|
}{
|
|
{"negative falls back to default", -1, DefaultTURNTTLSeconds, true},
|
|
{"large negative falls back to default", -1 << 40, DefaultTURNTTLSeconds, true},
|
|
{"zero falls back to default", 0, DefaultTURNTTLSeconds, true},
|
|
{"in range preserved", 600, 600, false},
|
|
{"max preserved", TURNMaxTTLSeconds, TURNMaxTTLSeconds, false},
|
|
{"over max clamps to max", TURNMaxTTLSeconds + 1, TURNMaxTTLSeconds, true},
|
|
{"overflowing value clamps to max", 1<<62 + 1, TURNMaxTTLSeconds, true},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got, changed := ClampTURNTTLSeconds(c.in)
|
|
require.Equal(t, c.want, got)
|
|
require.Equal(t, c.changed, changed)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeTURNTTLs(t *testing.T) {
|
|
conf, err := NewConfig("", true, nil, nil)
|
|
require.NoError(t, err)
|
|
|
|
conf.TURN.TTLSeconds = -5
|
|
conf.RTC.TURNServers = []TURNServer{
|
|
{Host: "over", TTL: TURNMaxTTLSeconds + 100},
|
|
{Host: "negative", TTL: -1},
|
|
{Host: "default", TTL: 0},
|
|
{Host: "ok", TTL: 600},
|
|
}
|
|
|
|
conf.NormalizeTURNTTLs()
|
|
|
|
// embedded TTL <= 0 falls back to the 5m default
|
|
require.Equal(t, DefaultTURNTTLSeconds, conf.TURN.TTLSeconds)
|
|
// external TTLs: only the upper bound is capped at load; 0/negative keep their
|
|
// "use the default" meaning and are resolved when credentials are generated
|
|
require.Equal(t, TURNMaxTTLSeconds, conf.RTC.TURNServers[0].TTL)
|
|
require.Equal(t, -1, conf.RTC.TURNServers[1].TTL)
|
|
require.Equal(t, 0, conf.RTC.TURNServers[2].TTL)
|
|
require.Equal(t, 600, conf.RTC.TURNServers[3].TTL)
|
|
}
|
|
|
|
func TestNewConfigNormalizesTURNTTL(t *testing.T) {
|
|
const content = `turn:
|
|
ttl_seconds: -10`
|
|
conf, err := NewConfig(content, true, nil, nil)
|
|
require.NoError(t, err)
|
|
require.Equal(t, DefaultTURNTTLSeconds, conf.TURN.TTLSeconds)
|
|
}
|
|
|
|
func TestNewConfigValidatesSendSideBWEPacer(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
pacer string
|
|
wantErr bool
|
|
}{
|
|
{name: "unset keeps the default", pacer: "", wantErr: false},
|
|
{name: "pass-through", pacer: string(pacer.PacerBehaviorPassThrough), wantErr: false},
|
|
{name: "no-queue", pacer: string(pacer.PacerBehaviorNoQueue), wantErr: false},
|
|
{name: "leaky-bucket", pacer: string(pacer.PacerBehaviorLeakybucket), wantErr: false},
|
|
{name: "typo is rejected", pacer: "leakybucket", wantErr: true},
|
|
{name: "unknown value is rejected", pacer: "not-a-pacer", wantErr: true},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
content := "rtc:\n congestion_control:\n send_side_bwe_pacer: " + tc.pacer
|
|
conf, err := NewConfig(content, true, nil, nil)
|
|
if tc.wantErr {
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), tc.pacer)
|
|
return
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
if tc.pacer == "" {
|
|
require.Equal(t, string(pacer.PacerBehaviorNoQueue), conf.RTC.CongestionControl.SendSideBWEPacer)
|
|
return
|
|
}
|
|
require.Equal(t, tc.pacer, conf.RTC.CongestionControl.SendSideBWEPacer)
|
|
})
|
|
}
|
|
}
|
|
|
|
func writeSecretFile(t *testing.T, content string) string {
|
|
t.Helper()
|
|
path := filepath.Join(t.TempDir(), "secret")
|
|
require.NoError(t, os.WriteFile(path, []byte(content), 0o600))
|
|
return path
|
|
}
|
|
|
|
func TestLoadTURNSecrets(t *testing.T) {
|
|
t.Run("empty secret file is rejected", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", SecretFile: writeSecretFile(t, "")}}
|
|
require.ErrorIs(t, conf.LoadTURNSecrets(), ErrTURNSecretEmpty)
|
|
})
|
|
|
|
t.Run("whitespace-only secret file is rejected", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", SecretFile: writeSecretFile(t, " \n\t ")}}
|
|
require.ErrorIs(t, conf.LoadTURNSecrets(), ErrTURNSecretEmpty)
|
|
})
|
|
|
|
t.Run("valid secret file is loaded and trimmed", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", SecretFile: writeSecretFile(t, " topsecret\n")}}
|
|
require.NoError(t, conf.LoadTURNSecrets())
|
|
require.Equal(t, "topsecret", conf.RTC.TURNServers[0].Secret)
|
|
})
|
|
|
|
t.Run("inline whitespace secret without static creds is rejected", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", Secret: " "}}
|
|
require.ErrorIs(t, conf.LoadTURNSecrets(), ErrTURNServerNoCredentials)
|
|
})
|
|
|
|
t.Run("no credentials at all is rejected", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h"}}
|
|
require.ErrorIs(t, conf.LoadTURNSecrets(), ErrTURNServerNoCredentials)
|
|
})
|
|
|
|
t.Run("static credentials are accepted", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", Username: "u", Credential: "c"}}
|
|
require.NoError(t, conf.LoadTURNSecrets())
|
|
})
|
|
|
|
t.Run("partial static credentials are rejected", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", Username: "u"}}
|
|
require.ErrorIs(t, conf.LoadTURNSecrets(), ErrTURNServerNoCredentials)
|
|
})
|
|
|
|
t.Run("inline secret takes precedence and is trimmed", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", Secret: " inline ", SecretFile: writeSecretFile(t, "fromfile")}}
|
|
require.NoError(t, conf.LoadTURNSecrets())
|
|
require.Equal(t, "inline", conf.RTC.TURNServers[0].Secret)
|
|
})
|
|
|
|
t.Run("blank inline secret falls back to secret file", func(t *testing.T) {
|
|
conf := &Config{}
|
|
conf.RTC.TURNServers = []TURNServer{{Host: "h", Secret: " ", SecretFile: writeSecretFile(t, "fromfile")}}
|
|
require.NoError(t, conf.LoadTURNSecrets())
|
|
require.Equal(t, "fromfile", conf.RTC.TURNServers[0].Secret)
|
|
})
|
|
}
|