dandri/livekit
1
0
Fork 0
mirror of https://github.com/livekit/livekit.git synced 2026-03-30 17:45:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

small refactor (#104)

Browse Source
This commit is contained in:
David Colburn
2021-08-30 18:22:11 -05:00
committed by GitHub
parent 0bfd05c3b8
commit 2fd61531d2
8 changed files with 74 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
cmd/server/main.go
View File

@@ -11,8 +11,6 @@ import (
"syscall"
"time"
"github.com/livekit/protocol/auth"
"github.com/pkg/errors"
"github.com/urfave/cli/v2"
"github.com/livekit/livekit-server/pkg/config"
@@ -187,19 +185,12 @@ func startServer(c *cli.Context) error {
}
}
// require a key provider
keyProvider, err := createKeyProvider(conf)
if err != nil {
return err
}
logger.Infow("configured key provider", "numKeys", keyProvider.NumKeys())
currentNode, err := routing.NewLocalNode(conf)
if err != nil {
return err
}
server, err := service.InitializeServer(conf, keyProvider, currentNode)
server, err := service.InitializeServer(conf, currentNode)
if err != nil {
return err
}
@@ -216,31 +207,6 @@ func startServer(c *cli.Context) error {
return server.Start()
}
func createKeyProvider(conf *config.Config) (auth.KeyProvider, error) {
// prefer keyfile if set
if conf.KeyFile != "" {
if st, err := os.Stat(conf.KeyFile); err != nil {
return nil, err
} else if st.Mode().Perm() != 0600 {
return nil, fmt.Errorf("key file must have permission set to 600")
}
f, err := os.Open(conf.KeyFile)
if err != nil {
return nil, err
}
defer func() {
_ = f.Close()
}()
return auth.NewFileBasedKeyProviderFromReader(f)
}
if len(conf.Keys) == 0 {
return nil, errors.New("one of key-file or keys must be provided in order to support a secure installation")
}
return auth.NewFileBasedKeyProviderFromMap(conf.Keys), nil
}
func getConfigString(c *cli.Context) (string, error) {
configFile := c.String("config")
configBody := c.String("config-body")

4
pkg/config/config.go
View File

@@ -143,8 +143,8 @@ func NewConfig(confString string, c *cli.Context) (*Config, error) {
EnabledCodecs: []CodecSpec{
{Mime: webrtc.MimeTypeOpus},
{Mime: webrtc.MimeTypeVP8},
//{Mime: webrtc.MimeTypeH264},
//{Mime: webrtc.MimeTypeVP9},
// {Mime: webrtc.MimeTypeH264},
// {Mime: webrtc.MimeTypeVP9},
},
EmptyTimeout: 5 * 60,
},

80
pkg/service/utils.go
View File

@@ -2,7 +2,9 @@ package service
import (
"context"
"fmt"
"net/http"
"os"
"regexp"
"github.com/go-redis/redis/v8"
@@ -21,8 +23,9 @@ var ServiceSet = wire.NewSet(
createRedisClient,
createRouter,
createStore,
createWebhookNotifier,
nodeSelectorFromConfig,
CreateKeyProvider,
CreateWebhookNotifier,
CreateNodeSelector,
NewRecordingService,
NewRoomService,
NewRTCService,
@@ -35,6 +38,55 @@ var ServiceSet = wire.NewSet(
wire.Bind(new(livekit.RoomService), new(*RoomService)),
)
func CreateKeyProvider(conf *config.Config) (auth.KeyProvider, error) {
// prefer keyfile if set
if conf.KeyFile != "" {
if st, err := os.Stat(conf.KeyFile); err != nil {
return nil, err
} else if st.Mode().Perm() != 0600 {
return nil, fmt.Errorf("key file must have permission set to 600")
}
f, err := os.Open(conf.KeyFile)
if err != nil {
return nil, err
}
defer func() {
_ = f.Close()
}()
return auth.NewFileBasedKeyProviderFromReader(f)
}
if len(conf.Keys) == 0 {
return nil, errors.New("one of key-file or keys must be provided in order to support a secure installation")
}
return auth.NewFileBasedKeyProviderFromMap(conf.Keys), nil
}
func CreateWebhookNotifier(conf *config.Config, provider auth.KeyProvider) (*webhook.Notifier, error) {
wc := conf.WebHook
if len(wc.URLs) == 0 {
return nil, nil
}
secret := provider.GetSecret(wc.APIKey)
if secret == "" {
return nil, ErrWebHookMissingAPIKey
}
return webhook.NewNotifier(wc.APIKey, secret, wc.URLs), nil
}
func CreateNodeSelector(conf *config.Config) routing.NodeSelector {
switch conf.NodeSelector.Kind {
case "sysload":
return &routing.SystemLoadSelector{
SysloadLimit: conf.NodeSelector.SysloadLimit,
}
default:
return &routing.RandomSelector{}
}
}
func createRedisClient(conf *config.Config) (*redis.Client, error) {
if !conf.HasRedis() {
return nil, nil
@@ -72,30 +124,6 @@ func createStore(rc *redis.Client) RoomStore {
return NewLocalRoomStore()
}
func createWebhookNotifier(conf *config.Config, provider auth.KeyProvider) (*webhook.Notifier, error) {
wc := conf.WebHook
if len(wc.URLs) == 0 {
return nil, nil
}
secret := provider.GetSecret(wc.APIKey)
if secret == "" {
return nil, ErrWebHookMissingAPIKey
}
return webhook.NewNotifier(wc.APIKey, secret, wc.URLs), nil
}
func nodeSelectorFromConfig(conf *config.Config) routing.NodeSelector {
switch conf.NodeSelector.Kind {
case "sysload":
return &routing.SystemLoadSelector{
SysloadLimit: conf.NodeSelector.SysloadLimit,
}
default:
return &routing.RandomSelector{}
}
}
func handleError(w http.ResponseWriter, status int, msg string) {
// GetLogger already with extra depth 1
logger.GetLogger().V(1).Info("error handling request", "error", msg, "status", status)

4
pkg/service/wire.go
View File

@@ -5,13 +5,11 @@ package service
import (
"github.com/google/wire"
"github.com/livekit/protocol/auth"
"github.com/livekit/livekit-server/pkg/config"
"github.com/livekit/livekit-server/pkg/routing"
)
func InitializeServer(conf *config.Config, keyProvider auth.KeyProvider, currentNode routing.LocalNode) (*LivekitServer, error) {
func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*LivekitServer, error) {
wire.Build(
ServiceSet,
)

11
pkg/service/wire_gen.go
View File

@@ -8,20 +8,23 @@ package service
import (
"github.com/livekit/livekit-server/pkg/config"
"github.com/livekit/livekit-server/pkg/routing"
"github.com/livekit/protocol/auth"
)
// Injectors from wire.go:
func InitializeServer(conf *config.Config, keyProvider auth.KeyProvider, currentNode routing.LocalNode) (*LivekitServer, error) {
func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*LivekitServer, error) {
client, err := createRedisClient(conf)
if err != nil {
return nil, err
}
roomStore := createStore(client)
router := createRouter(client, currentNode)
nodeSelector := nodeSelectorFromConfig(conf)
notifier, err := createWebhookNotifier(conf, keyProvider)
nodeSelector := CreateNodeSelector(conf)
keyProvider, err := CreateKeyProvider(conf)
if err != nil {
return nil, err
}
notifier, err := CreateWebhookNotifier(conf, keyProvider)
if err != nil {
return nil, err
}

20
test/integration_helpers.go
View File

@@ -138,6 +138,7 @@ func createSingleNodeServer() *service.LivekitServer {
panic(fmt.Sprintf("could not create config: %v", err))
}
conf.Development = true
conf.Keys = map[string]string{testApiKey: testApiSecret}
currentNode, err := routing.NewLocalNode(conf)
if err != nil {
@@ -145,7 +146,7 @@ func createSingleNodeServer() *service.LivekitServer {
}
currentNode.Id = utils.NewGuid(nodeId1)
s, err := service.InitializeServer(conf, &StaticKeyProvider{}, currentNode)
s, err := service.InitializeServer(conf, currentNode)
if err != nil {
panic(fmt.Sprintf("could not create server: %v", err))
}
@@ -165,6 +166,7 @@ func createMultiNodeServer(nodeId string, port uint32) *service.LivekitServer {
conf.RTC.TCPPort = port + 2
conf.Redis.Address = "localhost:6379"
conf.Development = true
conf.Keys = map[string]string{testApiKey: testApiSecret}
currentNode, err := routing.NewLocalNode(conf)
if err != nil {
@@ -173,7 +175,7 @@ func createMultiNodeServer(nodeId string, port uint32) *service.LivekitServer {
currentNode.Id = nodeId
// redis routing and store
s, err := service.InitializeServer(conf, &StaticKeyProvider{}, currentNode)
s, err := service.InitializeServer(conf, currentNode)
if err != nil {
panic(fmt.Sprintf("could not create server: %v", err))
}
@@ -239,17 +241,3 @@ func stopClients(clients ...*testclient.RTCClient) {
c.Stop()
}
}
type StaticKeyProvider struct {
}
func (p *StaticKeyProvider) NumKeys() int {
return 1
}
func (p *StaticKeyProvider) GetSecret(key string) string {
if key == testApiKey {
return testApiSecret
}
return ""
}

3
test/turn_test.go
View File

@@ -21,13 +21,14 @@ func testTurnServer(t *testing.T) {
require.NoError(t, err)
conf.TURN.Enabled = true
conf.Keys = map[string]string{testApiKey: testApiSecret}
currentNode, err := routing.NewLocalNode(conf)
require.NoError(t, err)
currentNode.Id = utils.NewGuid(nodeId1)
// local routing and store
s, err := service.InitializeServer(conf, &StaticKeyProvider{}, currentNode)
s, err := service.InitializeServer(conf, currentNode)
require.NoError(t, err)
go s.Start()
waitForServerToStart(s)

5
test/webhook_test.go
View File

@@ -92,6 +92,7 @@ func setupServerWithWebhook() (server *service.LivekitServer, testServer *webook
conf.WebHook.URLs = []string{"http://localhost:7890"}
conf.WebHook.APIKey = testApiKey
conf.Development = true
conf.Keys = map[string]string{testApiKey: testApiSecret}
testServer = newTestServer(":7890")
if err = testServer.Start(); err != nil {
@@ -104,7 +105,7 @@ func setupServerWithWebhook() (server *service.LivekitServer, testServer *webook
}
currentNode.Id = utils.NewGuid(nodeId1)
server, err = service.InitializeServer(conf, &StaticKeyProvider{}, currentNode)
server, err = service.InitializeServer(conf, currentNode)
if err != nil {
return
}
@@ -134,7 +135,7 @@ type webookTestServer struct {
func newTestServer(addr string) *webookTestServer {
s := &webookTestServer{
events: make(map[string]*livekit.WebhookEvent),
provider: &StaticKeyProvider{},
provider: auth.NewFileBasedKeyProviderFromMap(map[string]string{testApiKey: testApiSecret}),
}
s.server = &http.Server{
Addr: addr,