From 98764f2782709c7abeadb7480cbc067e4e7c7331 Mon Sep 17 00:00:00 2001 From: Joachim Bauch Date: Thu, 11 Dec 2025 19:53:03 +0100 Subject: [PATCH] Move confiuration helpers to config module. --- .codecov.yml | 4 +++ backend_server.go | 13 +++---- backend_storage_static.go | 47 +++++++++++++------------ client/main.go | 7 ++-- config.go => config/config.go | 2 +- config_test.go => config/config_test.go | 2 +- geoip.go | 5 +-- grpc_server.go | 7 ++-- hub.go | 35 +++++++++--------- mcu_proxy.go | 5 +-- proxy/main.go | 14 ++++---- proxy/proxy_server.go | 9 ++--- proxy/proxy_tokens_static.go | 6 ++-- proxy_config_static.go | 7 ++-- server/main.go | 45 +++++++++++------------ 15 files changed, 111 insertions(+), 97 deletions(-) rename config.go => config/config.go (99%) rename config_test.go => config/config_test.go (99%) diff --git a/.codecov.yml b/.codecov.yml index 48adc51..832fbf1 100644 --- a/.codecov.yml +++ b/.codecov.yml @@ -30,6 +30,10 @@ component_management: name: client paths: - client/** + - component_id: module_config + name: config + paths: + - config/** - component_id: module_container name: container paths: diff --git a/backend_server.go b/backend_server.go index 94530ff..f94bef6 100644 --- a/backend_server.go +++ b/backend_server.go @@ -50,6 +50,7 @@ import ( "github.com/strukturag/nextcloud-spreed-signaling/api" "github.com/strukturag/nextcloud-spreed-signaling/async" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/container" "github.com/strukturag/nextcloud-spreed-signaling/internal" "github.com/strukturag/nextcloud-spreed-signaling/log" @@ -87,11 +88,11 @@ type BackendServer struct { buffers pool.BufferPool } -func NewBackendServer(ctx context.Context, config *goconf.ConfigFile, hub *Hub, version string) (*BackendServer, error) { +func NewBackendServer(ctx context.Context, cfg *goconf.ConfigFile, hub *Hub, version string) (*BackendServer, error) { logger := log.LoggerFromContext(ctx) - turnapikey, _ := GetStringOptionWithEnv(config, "turn", "apikey") - turnsecret, _ := GetStringOptionWithEnv(config, "turn", "secret") - turnservers, _ := config.GetString("turn", "servers") + turnapikey, _ := config.GetStringOptionWithEnv(cfg, "turn", "apikey") + turnsecret, _ := config.GetStringOptionWithEnv(cfg, "turn", "secret") + turnservers, _ := cfg.GetString("turn", "servers") // TODO(jojo): Make the validity for TURN credentials configurable. turnvalid := 24 * time.Hour @@ -111,7 +112,7 @@ func NewBackendServer(ctx context.Context, config *goconf.ConfigFile, hub *Hub, } } - statsAllowed, _ := config.GetString("stats", "allowed_ips") + statsAllowed, _ := cfg.GetString("stats", "allowed_ips") statsAllowedIps, err := container.ParseIPList(statsAllowed) if err != nil { return nil, err @@ -129,7 +130,7 @@ func NewBackendServer(ctx context.Context, config *goconf.ConfigFile, hub *Hub, return nil, err } - debug, _ := config.GetBool("app", "debug") + debug, _ := cfg.GetBool("app", "debug") result := &BackendServer{ logger: logger, diff --git a/backend_storage_static.go b/backend_storage_static.go index 2624a56..f0ebebc 100644 --- a/backend_storage_static.go +++ b/backend_storage_static.go @@ -29,6 +29,7 @@ import ( "github.com/dlintw/goconf" "github.com/strukturag/nextcloud-spreed-signaling/api" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/internal" "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -45,11 +46,11 @@ type backendStorageStatic struct { compatBackend *Backend } -func NewBackendStorageStatic(logger log.Logger, config *goconf.ConfigFile, stats BackendStorageStats) (BackendStorage, error) { - allowAll, _ := config.GetBool("backend", "allowall") - allowHttp, _ := config.GetBool("backend", "allowhttp") - commonSecret, _ := GetStringOptionWithEnv(config, "backend", "secret") - sessionLimit, err := config.GetInt("backend", "sessionlimit") +func NewBackendStorageStatic(logger log.Logger, cfg *goconf.ConfigFile, stats BackendStorageStats) (BackendStorage, error) { + allowAll, _ := cfg.GetBool("backend", "allowall") + allowHttp, _ := cfg.GetBool("backend", "allowhttp") + commonSecret, _ := config.GetStringOptionWithEnv(cfg, "backend", "secret") + sessionLimit, err := cfg.GetInt("backend", "sessionlimit") if err != nil || sessionLimit < 0 { sessionLimit = 0 } @@ -59,11 +60,11 @@ func NewBackendStorageStatic(logger log.Logger, config *goconf.ConfigFile, stats numBackends := 0 if allowAll { logger.Println("WARNING: All backend hostnames are allowed, only use for development!") - maxStreamBitrate, err := config.GetInt("backend", "maxstreambitrate") + maxStreamBitrate, err := cfg.GetInt("backend", "maxstreambitrate") if err != nil || maxStreamBitrate < 0 { maxStreamBitrate = 0 } - maxScreenBitrate, err := config.GetInt("backend", "maxscreenbitrate") + maxScreenBitrate, err := cfg.GetInt("backend", "maxscreenbitrate") if err != nil || maxScreenBitrate < 0 { maxScreenBitrate = 0 } @@ -85,9 +86,9 @@ func NewBackendStorageStatic(logger log.Logger, config *goconf.ConfigFile, stats updateBackendStats(compatBackend) backendsById[compatBackend.id] = compatBackend numBackends++ - } else if backendIds, _ := config.GetString("backend", "backends"); backendIds != "" { + } else if backendIds, _ := cfg.GetString("backend", "backends"); backendIds != "" { added := make(map[string]*Backend) - for host, configuredBackends := range getConfiguredHosts(logger, backendIds, config, commonSecret) { + for host, configuredBackends := range getConfiguredHosts(logger, backendIds, cfg, commonSecret) { backends[host] = append(backends[host], configuredBackends...) for _, be := range configuredBackends { added[be.id] = be @@ -100,7 +101,7 @@ func NewBackendStorageStatic(logger log.Logger, config *goconf.ConfigFile, stats be.counted = true } numBackends += len(added) - } else if allowedUrls, _ := config.GetString("backend", "allowed"); allowedUrls != "" { + } else if allowedUrls, _ := cfg.GetString("backend", "allowed"); allowedUrls != "" { // Old-style configuration, only hosts are configured and are using a common secret. allowMap := make(map[string]bool) for u := range internal.SplitEntries(allowedUrls, ",") { @@ -117,11 +118,11 @@ func NewBackendStorageStatic(logger log.Logger, config *goconf.ConfigFile, stats if len(allowMap) == 0 { logger.Println("WARNING: No backend hostnames are allowed, check your configuration!") } else { - maxStreamBitrate, err := config.GetInt("backend", "maxstreambitrate") + maxStreamBitrate, err := cfg.GetInt("backend", "maxstreambitrate") if err != nil || maxStreamBitrate < 0 { maxStreamBitrate = 0 } - maxScreenBitrate, err := config.GetInt("backend", "maxscreenbitrate") + maxScreenBitrate, err := cfg.GetInt("backend", "maxscreenbitrate") if err != nil || maxScreenBitrate < 0 { maxScreenBitrate = 0 } @@ -297,11 +298,11 @@ func getConfiguredBackendIDs(backendIds string) (ids []string) { return ids } -func getConfiguredHosts(logger log.Logger, backendIds string, config *goconf.ConfigFile, commonSecret string) (hosts map[string][]*Backend) { +func getConfiguredHosts(logger log.Logger, backendIds string, cfg *goconf.ConfigFile, commonSecret string) (hosts map[string][]*Backend) { hosts = make(map[string][]*Backend) seenUrls := make(map[string]string) for _, id := range getConfiguredBackendIDs(backendIds) { - secret, _ := GetStringOptionWithEnv(config, id, "secret") + secret, _ := config.GetStringOptionWithEnv(cfg, id, "secret") if secret == "" && commonSecret != "" { logger.Printf("Backend %s has no own shared secret set, using common shared secret", id) secret = commonSecret @@ -311,7 +312,7 @@ func getConfiguredHosts(logger log.Logger, backendIds string, config *goconf.Con continue } - sessionLimit, err := config.GetInt(id, "sessionlimit") + sessionLimit, err := cfg.GetInt(id, "sessionlimit") if err != nil || sessionLimit < 0 { sessionLimit = 0 } @@ -319,20 +320,20 @@ func getConfiguredHosts(logger log.Logger, backendIds string, config *goconf.Con logger.Printf("Backend %s allows a maximum of %d sessions", id, sessionLimit) } - maxStreamBitrate, err := config.GetInt(id, "maxstreambitrate") + maxStreamBitrate, err := cfg.GetInt(id, "maxstreambitrate") if err != nil || maxStreamBitrate < 0 { maxStreamBitrate = 0 } - maxScreenBitrate, err := config.GetInt(id, "maxscreenbitrate") + maxScreenBitrate, err := cfg.GetInt(id, "maxscreenbitrate") if err != nil || maxScreenBitrate < 0 { maxScreenBitrate = 0 } var urls []string - if u, _ := GetStringOptionWithEnv(config, id, "urls"); u != "" { + if u, _ := config.GetStringOptionWithEnv(cfg, id, "urls"); u != "" { urls = slices.Sorted(internal.SplitEntries(u, ",")) urls = slices.Compact(urls) - } else if u, _ := GetStringOptionWithEnv(config, id, "url"); u != "" { + } else if u, _ := config.GetStringOptionWithEnv(cfg, id, "url"); u != "" { if u = strings.TrimSpace(u); u != "" { urls = []string{u} } @@ -391,7 +392,7 @@ func getConfiguredHosts(logger log.Logger, backendIds string, config *goconf.Con return hosts } -func (s *backendStorageStatic) Reload(config *goconf.ConfigFile) { +func (s *backendStorageStatic) Reload(cfg *goconf.ConfigFile) { s.mu.Lock() defer s.mu.Unlock() @@ -400,10 +401,10 @@ func (s *backendStorageStatic) Reload(config *goconf.ConfigFile) { return } - commonSecret, _ := GetStringOptionWithEnv(config, "backend", "secret") + commonSecret, _ := config.GetStringOptionWithEnv(cfg, "backend", "secret") - if backendIds, _ := config.GetString("backend", "backends"); backendIds != "" { - configuredHosts := getConfiguredHosts(s.logger, backendIds, config, commonSecret) + if backendIds, _ := cfg.GetString("backend", "backends"); backendIds != "" { + configuredHosts := getConfiguredHosts(s.logger, backendIds, cfg, commonSecret) // remove backends that are no longer configured seen := make(map[string]seenState) diff --git a/client/main.go b/client/main.go index 9156623..dd38d7f 100644 --- a/client/main.go +++ b/client/main.go @@ -49,6 +49,7 @@ import ( signaling "github.com/strukturag/nextcloud-spreed-signaling" "github.com/strukturag/nextcloud-spreed-signaling/api" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/internal" "github.com/strukturag/nextcloud-spreed-signaling/talk" ) @@ -60,7 +61,7 @@ var ( addr = flag.String("addr", "localhost:28080", "http service address") - config = flag.String("config", "server.conf", "config file to use") + configFlag = flag.String("config", "server.conf", "config file to use") cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file") @@ -508,12 +509,12 @@ func main() { os.Exit(0) } - config, err := goconf.ReadConfigFile(*config) + cfg, err := goconf.ReadConfigFile(*configFlag) if err != nil { log.Fatal("Could not read configuration: ", err) } - secret, _ := signaling.GetStringOptionWithEnv(config, "backend", "secret") + secret, _ := config.GetStringOptionWithEnv(cfg, "backend", "secret") backendSecret = []byte(secret) log.Printf("Using a maximum of %d CPUs", runtime.GOMAXPROCS(0)) diff --git a/config.go b/config/config.go similarity index 99% rename from config.go rename to config/config.go index c3a006e..25e8833 100644 --- a/config.go +++ b/config/config.go @@ -19,7 +19,7 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ -package signaling +package config import ( "errors" diff --git a/config_test.go b/config/config_test.go similarity index 99% rename from config_test.go rename to config/config_test.go index f0cc619..7727138 100644 --- a/config_test.go +++ b/config/config_test.go @@ -19,7 +19,7 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ -package signaling +package config import ( "testing" diff --git a/geoip.go b/geoip.go index 326e23f..4da1aa4 100644 --- a/geoip.go +++ b/geoip.go @@ -39,6 +39,7 @@ import ( "github.com/dlintw/goconf" "github.com/oschwald/maxminddb-golang" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -274,9 +275,9 @@ func IsValidContinent(continent string) bool { } } -func LoadGeoIPOverrides(ctx context.Context, config *goconf.ConfigFile, ignoreErrors bool) (map[*net.IPNet]string, error) { +func LoadGeoIPOverrides(ctx context.Context, cfg *goconf.ConfigFile, ignoreErrors bool) (map[*net.IPNet]string, error) { logger := log.LoggerFromContext(ctx) - options, _ := GetStringOptions(config, "geoip-overrides", true) + options, _ := config.GetStringOptions(cfg, "geoip-overrides", true) if len(options) == 0 { return nil, nil } diff --git a/grpc_server.go b/grpc_server.go index 307c091..e66fcd9 100644 --- a/grpc_server.go +++ b/grpc_server.go @@ -39,6 +39,7 @@ import ( status "google.golang.org/grpc/status" "github.com/strukturag/nextcloud-spreed-signaling/api" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -86,9 +87,9 @@ type GrpcServer struct { hub GrpcServerHub } -func NewGrpcServer(ctx context.Context, config *goconf.ConfigFile, version string) (*GrpcServer, error) { +func NewGrpcServer(ctx context.Context, cfg *goconf.ConfigFile, version string) (*GrpcServer, error) { var listener net.Listener - if addr, _ := GetStringOptionWithEnv(config, "grpc", "listen"); addr != "" { + if addr, _ := config.GetStringOptionWithEnv(cfg, "grpc", "listen"); addr != "" { var err error listener, err = net.Listen("tcp", addr) if err != nil { @@ -97,7 +98,7 @@ func NewGrpcServer(ctx context.Context, config *goconf.ConfigFile, version strin } logger := log.LoggerFromContext(ctx) - creds, err := NewReloadableCredentials(logger, config, true) + creds, err := NewReloadableCredentials(logger, cfg, true) if err != nil { return nil, err } diff --git a/hub.go b/hub.go index 8f41a36..5c97b7d 100644 --- a/hub.go +++ b/hub.go @@ -53,6 +53,7 @@ import ( "github.com/strukturag/nextcloud-spreed-signaling/api" "github.com/strukturag/nextcloud-spreed-signaling/async" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/container" "github.com/strukturag/nextcloud-spreed-signaling/internal" "github.com/strukturag/nextcloud-spreed-signaling/log" @@ -222,9 +223,9 @@ type Hub struct { blockedCandidates atomic.Pointer[container.IPList] } -func NewHub(ctx context.Context, config *goconf.ConfigFile, events AsyncEvents, rpcServer *GrpcServer, rpcClients *GrpcClients, etcdClient *EtcdClient, r *mux.Router, version string) (*Hub, error) { +func NewHub(ctx context.Context, cfg *goconf.ConfigFile, events AsyncEvents, rpcServer *GrpcServer, rpcClients *GrpcClients, etcdClient *EtcdClient, r *mux.Router, version string) (*Hub, error) { logger := log.LoggerFromContext(ctx) - hashKey, _ := GetStringOptionWithEnv(config, "sessions", "hashkey") + hashKey, _ := config.GetStringOptionWithEnv(cfg, "sessions", "hashkey") switch len(hashKey) { case 32: case 64: @@ -232,7 +233,7 @@ func NewHub(ctx context.Context, config *goconf.ConfigFile, events AsyncEvents, logger.Printf("WARNING: The sessions hash key should be 32 or 64 bytes but is %d bytes", len(hashKey)) } - blockKey, _ := GetStringOptionWithEnv(config, "sessions", "blockkey") + blockKey, _ := config.GetStringOptionWithEnv(cfg, "sessions", "blockkey") blockBytes := []byte(blockKey) switch len(blockKey) { case 0: @@ -249,51 +250,51 @@ func NewHub(ctx context.Context, config *goconf.ConfigFile, events AsyncEvents, return nil, fmt.Errorf("error creating session id codec: %w", err) } - internalClientsSecret, _ := GetStringOptionWithEnv(config, "clients", "internalsecret") + internalClientsSecret, _ := config.GetStringOptionWithEnv(cfg, "clients", "internalsecret") if internalClientsSecret == "" { logger.Println("WARNING: No shared secret has been set for internal clients.") } - maxConcurrentRequestsPerHost, _ := config.GetInt("backend", "connectionsperhost") + maxConcurrentRequestsPerHost, _ := cfg.GetInt("backend", "connectionsperhost") if maxConcurrentRequestsPerHost <= 0 { maxConcurrentRequestsPerHost = defaultMaxConcurrentRequestsPerHost } - backend, err := NewBackendClient(ctx, config, maxConcurrentRequestsPerHost, version, etcdClient) + backend, err := NewBackendClient(ctx, cfg, maxConcurrentRequestsPerHost, version, etcdClient) if err != nil { return nil, err } logger.Printf("Using a maximum of %d concurrent backend connections per host", maxConcurrentRequestsPerHost) - backendTimeoutSeconds, _ := config.GetInt("backend", "timeout") + backendTimeoutSeconds, _ := cfg.GetInt("backend", "timeout") if backendTimeoutSeconds <= 0 { backendTimeoutSeconds = defaultBackendTimeoutSeconds } backendTimeout := time.Duration(backendTimeoutSeconds) * time.Second logger.Printf("Using a timeout of %s for backend connections", backendTimeout) - mcuTimeoutSeconds, _ := config.GetInt("mcu", "timeout") + mcuTimeoutSeconds, _ := cfg.GetInt("mcu", "timeout") if mcuTimeoutSeconds <= 0 { mcuTimeoutSeconds = defaultMcuTimeoutSeconds } mcuTimeout := time.Duration(mcuTimeoutSeconds) * time.Second - allowSubscribeAnyStream, _ := config.GetBool("app", "allowsubscribeany") + allowSubscribeAnyStream, _ := cfg.GetBool("app", "allowsubscribeany") if allowSubscribeAnyStream { logger.Printf("WARNING: Allow subscribing any streams, this is insecure and should only be enabled for testing") } - trustedProxies, _ := config.GetString("app", "trustedproxies") + trustedProxies, _ := cfg.GetString("app", "trustedproxies") trustedProxiesIps, err := container.ParseIPList(trustedProxies) if err != nil { return nil, err } - skipFederationVerify, _ := config.GetBool("federation", "skipverify") + skipFederationVerify, _ := cfg.GetBool("federation", "skipverify") if skipFederationVerify { logger.Println("WARNING: Federation target verification is disabled!") } - federationTimeoutSeconds, _ := config.GetInt("federation", "timeout") + federationTimeoutSeconds, _ := cfg.GetInt("federation", "timeout") if federationTimeoutSeconds <= 0 { federationTimeoutSeconds = defaultFederationTimeoutSeconds } @@ -321,12 +322,12 @@ func NewHub(ctx context.Context, config *goconf.ConfigFile, events AsyncEvents, return nil, err } - geoipUrl, _ := config.GetString("geoip", "url") + geoipUrl, _ := cfg.GetString("geoip", "url") if geoipUrl == "default" || geoipUrl == "none" { geoipUrl = "" } if geoipUrl == "" { - if geoipLicense, _ := config.GetString("geoip", "license"); geoipLicense != "" { + if geoipLicense, _ := cfg.GetString("geoip", "license"); geoipLicense != "" { geoipUrl = GetGeoIpDownloadUrl(geoipLicense) } } @@ -347,7 +348,7 @@ func NewHub(ctx context.Context, config *goconf.ConfigFile, events AsyncEvents, logger.Printf("Not using GeoIP database") } - geoipOverrides, err := LoadGeoIPOverrides(ctx, config, false) + geoipOverrides, err := LoadGeoIPOverrides(ctx, cfg, false) if err != nil { return nil, err } @@ -418,7 +419,7 @@ func NewHub(ctx context.Context, config *goconf.ConfigFile, events AsyncEvents, skipFederationVerify: skipFederationVerify, federationTimeout: federationTimeout, } - if value, _ := config.GetString("mcu", "allowedcandidates"); value != "" { + if value, _ := cfg.GetString("mcu", "allowedcandidates"); value != "" { allowed, err := container.ParseIPList(value) if err != nil { return nil, fmt.Errorf("invalid allowedcandidates: %w", err) @@ -429,7 +430,7 @@ func NewHub(ctx context.Context, config *goconf.ConfigFile, events AsyncEvents, } else { logger.Printf("No candidates allowlist") } - if value, _ := config.GetString("mcu", "blockedcandidates"); value != "" { + if value, _ := cfg.GetString("mcu", "blockedcandidates"); value != "" { blocked, err := container.ParseIPList(value) if err != nil { return nil, fmt.Errorf("invalid blockedcandidates: %w", err) diff --git a/mcu_proxy.go b/mcu_proxy.go index 3e471bc..0383a91 100644 --- a/mcu_proxy.go +++ b/mcu_proxy.go @@ -47,6 +47,7 @@ import ( "github.com/strukturag/nextcloud-spreed-signaling/api" "github.com/strukturag/nextcloud-spreed-signaling/async" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/internal" "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -1589,8 +1590,8 @@ func (m *mcuProxy) GetBandwidthLimits() (api.Bandwidth, api.Bandwidth) { return m.settings.MaxStreamBitrate(), m.settings.MaxScreenBitrate() } -func (m *mcuProxy) loadContinentsMap(config *goconf.ConfigFile) error { - options, err := GetStringOptions(config, "continent-overrides", false) +func (m *mcuProxy) loadContinentsMap(cfg *goconf.ConfigFile) error { + options, err := config.GetStringOptions(cfg, "continent-overrides", false) if err != nil { return err } diff --git a/proxy/main.go b/proxy/main.go index 76755ad..2f406e6 100644 --- a/proxy/main.go +++ b/proxy/main.go @@ -37,7 +37,7 @@ import ( "github.com/dlintw/goconf" "github.com/gorilla/mux" - signaling "github.com/strukturag/nextcloud-spreed-signaling" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/internal" signalinglog "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -78,7 +78,7 @@ func main() { logger.Printf("Starting up version %s/%s as pid %d", version, runtime.Version(), os.Getpid()) - config, err := goconf.ReadConfigFile(*configFlag) + cfg, err := goconf.ReadConfigFile(*configFlag) if err != nil { logger.Fatal("Could not read configuration: ", err) } @@ -87,22 +87,22 @@ func main() { r := mux.NewRouter() - proxy, err := NewProxyServer(stopCtx, r, version, config) + proxy, err := NewProxyServer(stopCtx, r, version, cfg) if err != nil { logger.Fatal(err) } - if err := proxy.Start(config); err != nil { + if err := proxy.Start(cfg); err != nil { logger.Fatal(err) } defer proxy.Stop() - if addr, _ := signaling.GetStringOptionWithEnv(config, "http", "listen"); addr != "" { - readTimeout, _ := config.GetInt("http", "readtimeout") + if addr, _ := config.GetStringOptionWithEnv(cfg, "http", "listen"); addr != "" { + readTimeout, _ := cfg.GetInt("http", "readtimeout") if readTimeout <= 0 { readTimeout = defaultReadTimeout } - writeTimeout, _ := config.GetInt("http", "writetimeout") + writeTimeout, _ := cfg.GetInt("http", "writetimeout") if writeTimeout <= 0 { writeTimeout = defaultWriteTimeout } diff --git a/proxy/proxy_server.go b/proxy/proxy_server.go index 7c12372..a0e7d4b 100644 --- a/proxy/proxy_server.go +++ b/proxy/proxy_server.go @@ -52,6 +52,7 @@ import ( signaling "github.com/strukturag/nextcloud-spreed-signaling" "github.com/strukturag/nextcloud-spreed-signaling/api" "github.com/strukturag/nextcloud-spreed-signaling/async" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/container" "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -424,13 +425,13 @@ func (s *ProxyServer) checkOrigin(r *http.Request) bool { return true } -func (s *ProxyServer) Start(config *goconf.ConfigFile) error { - s.url, _ = signaling.GetStringOptionWithEnv(config, "mcu", "url") +func (s *ProxyServer) Start(cfg *goconf.ConfigFile) error { + s.url, _ = config.GetStringOptionWithEnv(cfg, "mcu", "url") if s.url == "" { return errors.New("no MCU server url configured") } - mcuType, _ := config.GetString("mcu", "type") + mcuType, _ := cfg.GetString("mcu", "type") if mcuType == "" { mcuType = signaling.McuTypeDefault } @@ -447,7 +448,7 @@ func (s *ProxyServer) Start(config *goconf.ConfigFile) error { for { switch mcuType { case signaling.McuTypeJanus: - mcu, err = signaling.NewMcuJanus(ctx, s.url, config) + mcu, err = signaling.NewMcuJanus(ctx, s.url, cfg) if err == nil { signaling.RegisterJanusMcuStats() } diff --git a/proxy/proxy_tokens_static.go b/proxy/proxy_tokens_static.go index ab28f04..2abb43c 100644 --- a/proxy/proxy_tokens_static.go +++ b/proxy/proxy_tokens_static.go @@ -30,7 +30,7 @@ import ( "github.com/dlintw/goconf" "github.com/golang-jwt/jwt/v5" - signaling "github.com/strukturag/nextcloud-spreed-signaling" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -64,8 +64,8 @@ func (t *tokensStatic) Get(id string) (*ProxyToken, error) { return token, nil } -func (t *tokensStatic) load(config *goconf.ConfigFile, ignoreErrors bool) error { - options, err := signaling.GetStringOptions(config, "tokens", ignoreErrors) +func (t *tokensStatic) load(cfg *goconf.ConfigFile, ignoreErrors bool) error { + options, err := config.GetStringOptions(cfg, "tokens", ignoreErrors) if err != nil { return err } diff --git a/proxy_config_static.go b/proxy_config_static.go index 2c81fa5..36424bb 100644 --- a/proxy_config_static.go +++ b/proxy_config_static.go @@ -30,6 +30,7 @@ import ( "github.com/dlintw/goconf" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/internal" "github.com/strukturag/nextcloud-spreed-signaling/log" ) @@ -70,11 +71,11 @@ func NewProxyConfigStatic(logger log.Logger, config *goconf.ConfigFile, proxy Mc return result, nil } -func (p *proxyConfigStatic) configure(config *goconf.ConfigFile, fromReload bool) error { +func (p *proxyConfigStatic) configure(cfg *goconf.ConfigFile, fromReload bool) error { p.mu.Lock() defer p.mu.Unlock() - dnsDiscovery, _ := config.GetBool("mcu", "dnsdiscovery") + dnsDiscovery, _ := cfg.GetBool("mcu", "dnsdiscovery") if dnsDiscovery != p.dnsDiscovery { if !dnsDiscovery { for _, ips := range p.connectionsMap { @@ -89,7 +90,7 @@ func (p *proxyConfigStatic) configure(config *goconf.ConfigFile, fromReload bool remove := maps.Clone(p.connectionsMap) - mcuUrl, _ := GetStringOptionWithEnv(config, "mcu", "url") + mcuUrl, _ := config.GetStringOptionWithEnv(cfg, "mcu", "url") for u := range internal.SplitEntries(mcuUrl, " ") { if existing, found := remove[u]; found { // Proxy connection still exists in new configuration diff --git a/server/main.go b/server/main.go index 4f2b7a4..022ef7c 100644 --- a/server/main.go +++ b/server/main.go @@ -42,6 +42,7 @@ import ( "github.com/gorilla/mux" signaling "github.com/strukturag/nextcloud-spreed-signaling" + "github.com/strukturag/nextcloud-spreed-signaling/config" "github.com/strukturag/nextcloud-spreed-signaling/internal" signalinglog "github.com/strukturag/nextcloud-spreed-signaling/log" "github.com/strukturag/nextcloud-spreed-signaling/nats" @@ -168,7 +169,7 @@ func main() { logger.Printf("Starting up version %s/%s as pid %d", version, runtime.Version(), os.Getpid()) - config, err := goconf.ReadConfigFile(*configFlag) + cfg, err := goconf.ReadConfigFile(*configFlag) if err != nil { logger.Fatal("Could not read configuration: ", err) } @@ -177,7 +178,7 @@ func main() { signaling.RegisterStats() - natsUrl, _ := signaling.GetStringOptionWithEnv(config, "nats", "url") + natsUrl, _ := config.GetStringOptionWithEnv(cfg, "nats", "url") if natsUrl == "" { natsUrl = nats.DefaultURL } @@ -203,7 +204,7 @@ func main() { } defer dnsMonitor.Stop() - etcdClient, err := signaling.NewEtcdClient(logger, config, "mcu") + etcdClient, err := signaling.NewEtcdClient(logger, cfg, "mcu") if err != nil { logger.Fatalf("Could not create etcd client: %s", err) } @@ -213,7 +214,7 @@ func main() { } }() - rpcServer, err := signaling.NewGrpcServer(stopCtx, config, version) + rpcServer, err := signaling.NewGrpcServer(stopCtx, cfg, version) if err != nil { logger.Fatalf("Could not create RPC server: %s", err) } @@ -224,20 +225,20 @@ func main() { }() defer rpcServer.Close() - rpcClients, err := signaling.NewGrpcClients(stopCtx, config, etcdClient, dnsMonitor, version) + rpcClients, err := signaling.NewGrpcClients(stopCtx, cfg, etcdClient, dnsMonitor, version) if err != nil { logger.Fatalf("Could not create RPC clients: %s", err) } defer rpcClients.Close() r := mux.NewRouter() - hub, err := signaling.NewHub(stopCtx, config, events, rpcServer, rpcClients, etcdClient, r, version) + hub, err := signaling.NewHub(stopCtx, cfg, events, rpcServer, rpcClients, etcdClient, r, version) if err != nil { logger.Fatal("Could not create hub: ", err) } - mcuUrl, _ := signaling.GetStringOptionWithEnv(config, "mcu", "url") - mcuType, _ := config.GetString("mcu", "type") + mcuUrl, _ := config.GetStringOptionWithEnv(cfg, "mcu", "url") + mcuType, _ := cfg.GetString("mcu", "type") if mcuType == "" && mcuUrl != "" { logger.Printf("WARNING: Old-style MCU configuration detected with url but no type, defaulting to type %s", signaling.McuTypeJanus) mcuType = signaling.McuTypeJanus @@ -256,11 +257,11 @@ func main() { ctx := context.TODO() switch mcuType { case signaling.McuTypeJanus: - mcu, err = signaling.NewMcuJanus(ctx, mcuUrl, config) + mcu, err = signaling.NewMcuJanus(ctx, mcuUrl, cfg) signaling.UnregisterProxyMcuStats() signaling.RegisterJanusMcuStats() case signaling.McuTypeProxy: - mcu, err = signaling.NewMcuProxy(ctx, config, etcdClient, rpcClients, dnsMonitor) + mcu, err = signaling.NewMcuProxy(ctx, cfg, etcdClient, rpcClients, dnsMonitor) signaling.UnregisterJanusMcuStats() signaling.RegisterProxyMcuStats() default: @@ -285,11 +286,11 @@ func main() { switch sig { case syscall.SIGHUP: logger.Printf("Received SIGHUP, reloading %s", *configFlag) - if config, err = goconf.ReadConfigFile(*configFlag); err != nil { + if cfg, err = goconf.ReadConfigFile(*configFlag); err != nil { logger.Printf("Could not read configuration from %s: %s", *configFlag, err) } else { - mcuUrl, _ = signaling.GetStringOptionWithEnv(config, "mcu", "url") - mcuType, _ = config.GetString("mcu", "type") + mcuUrl, _ = config.GetStringOptionWithEnv(cfg, "mcu", "url") + mcuType, _ = cfg.GetString("mcu", "type") if mcuType == "" && mcuUrl != "" { logger.Printf("WARNING: Old-style MCU configuration detected with url but no type, defaulting to type %s", signaling.McuTypeJanus) mcuType = signaling.McuTypeJanus @@ -316,7 +317,7 @@ func main() { go hub.Run() defer hub.Stop() - server, err := signaling.NewBackendServer(stopCtx, config, hub, version) + server, err := signaling.NewBackendServer(stopCtx, cfg, hub, version) if err != nil { logger.Fatal("Could not create backend server: ", err) } @@ -328,18 +329,18 @@ func main() { logger: logger, } - if saddr, _ := signaling.GetStringOptionWithEnv(config, "https", "listen"); saddr != "" { - cert, _ := config.GetString("https", "certificate") - key, _ := config.GetString("https", "key") + if saddr, _ := config.GetStringOptionWithEnv(cfg, "https", "listen"); saddr != "" { + cert, _ := cfg.GetString("https", "certificate") + key, _ := cfg.GetString("https", "key") if cert == "" || key == "" { logger.Fatal("Need a certificate and key for the HTTPS listener") } - readTimeout, _ := config.GetInt("https", "readtimeout") + readTimeout, _ := cfg.GetInt("https", "readtimeout") if readTimeout <= 0 { readTimeout = defaultReadTimeout } - writeTimeout, _ := config.GetInt("https", "writetimeout") + writeTimeout, _ := cfg.GetInt("https", "writetimeout") if writeTimeout <= 0 { writeTimeout = defaultWriteTimeout } @@ -366,12 +367,12 @@ func main() { } } - if addr, _ := signaling.GetStringOptionWithEnv(config, "http", "listen"); addr != "" { - readTimeout, _ := config.GetInt("http", "readtimeout") + if addr, _ := config.GetStringOptionWithEnv(cfg, "http", "listen"); addr != "" { + readTimeout, _ := cfg.GetInt("http", "readtimeout") if readTimeout <= 0 { readTimeout = defaultReadTimeout } - writeTimeout, _ := config.GetInt("http", "writetimeout") + writeTimeout, _ := cfg.GetInt("http", "writetimeout") if writeTimeout <= 0 { writeTimeout = defaultWriteTimeout }