Use config directly in room manager and centralize config loading.

src/app/spreed-webrtc-server/channelling_api.go

@@ -38,7 +38,6 @@ type ChannellingAPI interface {
 }
 
 type channellingAPI struct {
-	version string
 	*Config
 	RoomStatusManager
 	SessionEncoder
@@ -51,9 +50,8 @@ type channellingAPI struct {
 	buddyImages ImageCache
 }
 
-func NewChannellingAPI(version string, config *Config, roomStatus RoomStatusManager, sessionEncoder SessionEncoder, sessionManager SessionManager, statsCounter StatsCounter, contactManager ContactManager, turnDataCreator TurnDataCreator, unicaster Unicaster, broadcaster Broadcaster, buddyImages ImageCache) ChannellingAPI {
+func NewChannellingAPI(config *Config, roomStatus RoomStatusManager, sessionEncoder SessionEncoder, sessionManager SessionManager, statsCounter StatsCounter, contactManager ContactManager, turnDataCreator TurnDataCreator, unicaster Unicaster, broadcaster Broadcaster, buddyImages ImageCache) ChannellingAPI {
 	return &channellingAPI{
-		version,
 		config,
 		roomStatus,
 		sessionEncoder,
@@ -255,7 +253,7 @@ func (api *channellingAPI) SendSelf(c Responder, session *Session) {
 		Userid:  session.Userid(),
 		Suserid: api.EncodeSessionUserID(session),
 		Token:   token,
-		Version: api.version,
+		Version: api.Version,
 		Turn:    api.CreateTurnData(session),
 		Stun:    api.StunURIs,
 	}

src/app/spreed-webrtc-server/channelling_api_test.go

@@ -26,10 +26,6 @@ import (
 	"testing"
 )
 
-const (
-	testAppVersion string = "0.0.0+unittests"
-)
-
 type fakeClient struct {
 	replies map[string]interface{}
 }
@@ -103,7 +99,7 @@ func assertErrorReply(t *testing.T, client *fakeClient, iid, code string) {
 
 func NewTestChannellingAPI() (ChannellingAPI, *fakeClient, *Session, *fakeRoomManager) {
 	client, roomManager, session := &fakeClient{}, &fakeRoomManager{}, &Session{}
-	return NewChannellingAPI(testAppVersion, nil, roomManager, nil, nil, nil, nil, nil, nil, roomManager, nil), client, session, roomManager
+	return NewChannellingAPI(nil, roomManager, nil, nil, nil, nil, nil, nil, roomManager, nil), client, session, roomManager
 }
 
 func Test_ChannellingAPI_OnIncoming_HelloMessage_JoinsTheSelectedRoom(t *testing.T) {

src/app/spreed-webrtc-server/config.go

@@ -24,6 +24,10 @@ package main
 import (
 	"fmt"
 	"net/http"
+	"strings"
+	"time"
+
+	"github.com/strukturag/phoenix"
 )
 
 type Config struct {
@@ -41,30 +45,77 @@ type Config struct {
 	UsersMode              string   // Users mode string
 	DefaultRoomEnabled     bool     // Flag if default room ("") is enabled
 	Plugin                 string   // Plugin to load
-	globalRoomid           string   // Id of the global room (not exported to Javascript)
+	globalRoomID           string   // Id of the global room (not exported to Javascript)
 }
 
-func NewConfig(title, ver, runtimeVersion, basePath, serverToken string, stunURIs, turnURIs []string, tokens bool, globalRoomid string, defaultRoomEnabled, usersEnabled, usersAllowRegistration bool, usersMode, plugin string) *Config {
-	sv := fmt.Sprintf("static/ver=%s", ver)
+func NewConfig(container phoenix.Container, tokens bool) *Config {
+	ver := container.GetStringDefault("app", "ver", "")
+
+	version := container.Version()
+	if version != "unreleased" {
+		ver = fmt.Sprintf("%s%s", ver, strings.Replace(version, ".", "", -1))
+	} else {
+		ts := fmt.Sprintf("%d", time.Now().Unix())
+		if ver == "" {
+			ver = ts
+		}
+		version = fmt.Sprintf("unreleased.%s", ts)
+	}
+
+	// Read base path from config and make sure it ends with a slash.
+	basePath := container.GetStringDefault("http", "basePath", "/")
+	if !strings.HasSuffix(basePath, "/") {
+		basePath = fmt.Sprintf("%s/", basePath)
+	}
+	if basePath != "/" {
+		container.Printf("Using '%s' base base path.", basePath)
+	}
+
+	//TODO(longsleep): When we have a database, generate this once from random source and store it.
+	serverToken := container.GetStringDefault("app", "serverToken", "i-did-not-change-the-public-token-boo")
+
+	stunURIsString := container.GetStringDefault("app", "stunURIs", "")
+	stunURIs := strings.Split(stunURIsString, " ")
+	trimAndRemoveDuplicates(&stunURIs)
+
+	turnURIsString := container.GetStringDefault("app", "turnURIs", "")
+	turnURIs := strings.Split(turnURIsString, " ")
+	trimAndRemoveDuplicates(&turnURIs)
+
 	return &Config{
-		Title:                  title,
+		Title:                  container.GetStringDefault("app", "title", "Spreed WebRTC"),
 		ver:                    ver,
-		S:                      sv,
+		S:                      fmt.Sprintf("static/ver=%s", ver),
 		B:                      basePath,
 		Token:                  serverToken,
 		StunURIs:               stunURIs,
 		TurnURIs:               turnURIs,
 		Tokens:                 tokens,
-		Version:                runtimeVersion,
-		UsersEnabled:           usersEnabled,
-		UsersAllowRegistration: usersAllowRegistration,
-		UsersMode:              usersMode,
-		DefaultRoomEnabled:     defaultRoomEnabled,
-		Plugin:                 plugin,
-		globalRoomid:           globalRoomid,
+		Version:                version,
+		UsersEnabled:           container.GetBoolDefault("users", "enabled", false),
+		UsersAllowRegistration: container.GetBoolDefault("users", "allowRegistration", false),
+		UsersMode:              container.GetStringDefault("users", "mode", ""),
+		DefaultRoomEnabled:     container.GetBoolDefault("app", "defaultRoomEnabled", true),
+		Plugin:                 container.GetStringDefault("app", "plugin", ""),
+		globalRoomID:           container.GetStringDefault("app", "globalRoom", ""),
 	}
 }
 
 func (config *Config) Get(request *http.Request) (int, interface{}, http.Header) {
 	return 200, config, http.Header{"Content-Type": {"application/json; charset=utf-8"}}
 }
+
+// Helper function to clean up string arrays.
+func trimAndRemoveDuplicates(data *[]string) {
+	found := make(map[string]bool)
+	j := 0
+	for i, x := range *data {
+		x = strings.TrimSpace(x)
+		if len(x) > 0 && !found[x] {
+			found[x] = true
+			(*data)[j] = (*data)[i]
+			j++
+		}
+	}
+	*data = (*data)[:j]
+}

src/app/spreed-webrtc-server/main.go

@@ -40,7 +40,6 @@ import (
 	"path"
 	goruntime "runtime"
 	"strconv"
-	"strings"
 	"syscall"
 	"time"
 )
@@ -63,21 +62,6 @@ func getRequestLanguages(r *http.Request, supportedLanguages []string) []string
 
 }
 
-// Helper function to clean up string arrays.
-func trimAndRemoveDuplicates(data *[]string) {
-	found := make(map[string]bool)
-	j := 0
-	for i, x := range *data {
-		x = strings.TrimSpace(x)
-		if len(x) > 0 && !found[x] {
-			found[x] = true
-			(*data)[j] = (*data)[i]
-			j++
-		}
-	}
-	*data = (*data)[:j]
-}
-
 func mainHandler(w http.ResponseWriter, r *http.Request) {
 
 	handleRoomView("", w, r)
@@ -184,17 +168,6 @@ func runner(runtime phoenix.Runtime) error {
 		return fmt.Errorf("Unable to find client. Path correct and compiled css?")
 	}
 
-	// Read base path from config and make sure it ends with a slash.
-	basePath, err := runtime.GetString("http", "basePath")
-	if err != nil {
-		basePath = "/"
-	} else {
-		if !strings.HasSuffix(basePath, "/") {
-			basePath = fmt.Sprintf("%s/", basePath)
-		}
-		log.Printf("Using '%s' base base path.", basePath)
-	}
-
 	statsEnabled, err := runtime.GetBool("http", "stats")
 	if err != nil {
 		statsEnabled = false
@@ -246,109 +219,33 @@ func runner(runtime phoenix.Runtime) error {
 		}
 	}
 
-	tokenFile, err := runtime.GetString("app", "tokenFile")
-	if err == nil {
-		if !httputils.HasFilePath(path.Clean(tokenFile)) {
-			return fmt.Errorf("Unable to find token file at %s", tokenFile)
-		}
-	}
-
-	title, err := runtime.GetString("app", "title")
-	if err != nil {
-		title = "Spreed WebRTC"
-	}
-
-	ver, err := runtime.GetString("app", "ver")
-	if err != nil {
-		ver = ""
-	}
-
-	runtimeVersion := version
-	if version != "unreleased" {
-		ver1 := ver
-		if err != nil {
-			ver1 = ""
-		}
-		ver = fmt.Sprintf("%s%s", ver1, strings.Replace(version, ".", "", -1))
-	} else {
-		ts := fmt.Sprintf("%d", time.Now().Unix())
-		if err != nil {
-			ver = ts
-		}
-		runtimeVersion = fmt.Sprintf("unreleased.%s", ts)
-	}
-
-	turnURIsString, err := runtime.GetString("app", "turnURIs")
-	if err != nil {
-		turnURIsString = ""
-	}
-	turnURIs := strings.Split(turnURIsString, " ")
-	trimAndRemoveDuplicates(&turnURIs)
-
 	var turnSecret []byte
 	turnSecretString, err := runtime.GetString("app", "turnSecret")
 	if err == nil {
 		turnSecret = []byte(turnSecretString)
 	}
 
-	stunURIsString, err := runtime.GetString("app", "stunURIs")
-	if err != nil {
-		stunURIsString = ""
-	}
-	stunURIs := strings.Split(stunURIsString, " ")
-	trimAndRemoveDuplicates(&stunURIs)
-
-	globalRoomid, err := runtime.GetString("app", "globalRoom")
-	if err != nil {
-		// Global room is disabled.
-		globalRoomid = ""
-	}
-
-	plugin, err := runtime.GetString("app", "plugin")
-	if err != nil {
-		plugin = ""
-	}
-
-	defaultRoomEnabled := true
-	defaultRoomEnabledString, err := runtime.GetString("app", "defaultRoomEnabled")
-	if err == nil {
-		defaultRoomEnabled = defaultRoomEnabledString == "true"
-	}
-
-	usersEnabled := false
-	usersEnabledString, err := runtime.GetString("users", "enabled")
-	if err == nil {
-		usersEnabled = usersEnabledString == "true"
-	}
-
-	usersAllowRegistration := false
-	usersAllowRegistrationString, err := runtime.GetString("users", "allowRegistration")
-	if err == nil {
-		usersAllowRegistration = usersAllowRegistrationString == "true"
-	}
-
-	serverToken, err := runtime.GetString("app", "serverToken")
-	if err != nil {
-		//TODO(longsleep): When we have a database, generate this once from random source and store it.
-		serverToken = "i-did-not-change-the-public-token-boo"
-	}
-
 	serverRealm, err := runtime.GetString("app", "serverRealm")
 	if err != nil {
 		serverRealm = "local"
 	}
 
-	usersMode, _ := runtime.GetString("users", "mode")
-
 	// Create token provider.
+	tokenFile, err := runtime.GetString("app", "tokenFile")
+	if err == nil {
+		if !httputils.HasFilePath(path.Clean(tokenFile)) {
+			return fmt.Errorf("Unable to find token file at %s", tokenFile)
+		}
+	}
+
 	var tokenProvider TokenProvider
 	if tokenFile != "" {
 		log.Printf("Using token authorization from %s\n", tokenFile)
 		tokenProvider = TokenFileProvider(tokenFile)
 	}
 
-	// Create configuration data structure.
-	config = NewConfig(title, ver, runtimeVersion, basePath, serverToken, stunURIs, turnURIs, tokenProvider != nil, globalRoomid, defaultRoomEnabled, usersEnabled, usersAllowRegistration, usersMode, plugin)
+	// Load remaining configuration items.
+	config = NewConfig(runtime, tokenProvider != nil)
 
 	// Load templates.
 	tt := template.New("")
@@ -373,7 +270,7 @@ func runner(runtime phoenix.Runtime) error {
 	}
 
 	// Create realm string from config.
-	computedRealm := fmt.Sprintf("%s.%s", serverRealm, serverToken)
+	computedRealm := fmt.Sprintf("%s.%s", serverRealm, config.Token)
 
 	// Set number of go routines if it is 1
 	if goruntime.GOMAXPROCS(0) == 1 {
@@ -406,7 +303,7 @@ func runner(runtime phoenix.Runtime) error {
 
 	// Create router.
 	router := mux.NewRouter()
-	r := router.PathPrefix(basePath).Subrouter().StrictSlash(true)
+	r := router.PathPrefix(config.B).Subrouter().StrictSlash(true)
 
 	// HTTP listener support.
 	if _, err = runtime.GetString("http", "listen"); err == nil {
@@ -434,12 +331,12 @@ func runner(runtime phoenix.Runtime) error {
 	tickets := NewTickets(sessionSecret, encryptionSecret, computedRealm)
 	sessionManager := NewSessionManager(config, tickets, sessionSecret)
 	statsManager := NewStatsManager(hub, roomManager, sessionManager)
-	channellingAPI := NewChannellingAPI(runtimeVersion, config, roomManager, tickets, sessionManager, statsManager, hub, hub, hub, roomManager, buddyImages)
+	channellingAPI := NewChannellingAPI(config, roomManager, tickets, sessionManager, statsManager, hub, hub, hub, roomManager, buddyImages)
 	r.HandleFunc("/", httputils.MakeGzipHandler(mainHandler))
-	r.Handle("/static/img/buddy/{flags}/{imageid}/{idx:.*}", http.StripPrefix(basePath, makeImageHandler(buddyImages, time.Duration(24)*time.Hour)))
-	r.Handle("/static/{path:.*}", http.StripPrefix(basePath, httputils.FileStaticServer(http.Dir(rootFolder))))
-	r.Handle("/robots.txt", http.StripPrefix(basePath, http.FileServer(http.Dir(path.Join(rootFolder, "static")))))
-	r.Handle("/favicon.ico", http.StripPrefix(basePath, http.FileServer(http.Dir(path.Join(rootFolder, "static", "img")))))
+	r.Handle("/static/img/buddy/{flags}/{imageid}/{idx:.*}", http.StripPrefix(config.B, makeImageHandler(buddyImages, time.Duration(24)*time.Hour)))
+	r.Handle("/static/{path:.*}", http.StripPrefix(config.B, httputils.FileStaticServer(http.Dir(rootFolder))))
+	r.Handle("/robots.txt", http.StripPrefix(config.B, http.FileServer(http.Dir(path.Join(rootFolder, "static")))))
+	r.Handle("/favicon.ico", http.StripPrefix(config.B, http.FileServer(http.Dir(path.Join(rootFolder, "static", "img")))))
 	r.Handle("/ws", makeWSHandler(statsManager, sessionManager, codec, channellingAPI))
 	r.HandleFunc("/{room}", httputils.MakeGzipHandler(roomHandler))
 
@@ -449,11 +346,11 @@ func runner(runtime phoenix.Runtime) error {
 	api.AddResource(&Rooms{}, "/rooms")
 	api.AddResource(config, "/config")
 	api.AddResourceWithWrapper(&Tokens{tokenProvider}, httputils.MakeGzipHandler, "/tokens")
-	if usersEnabled {
+	if config.UsersEnabled {
 		// Create Users handler.
-		users := NewUsers(hub, tickets, sessionManager, usersMode, serverRealm, runtime)
+		users := NewUsers(hub, tickets, sessionManager, config.UsersMode, serverRealm, runtime)
 		api.AddResource(&Sessions{tickets, hub, users}, "/sessions/{id}/")
-		if usersAllowRegistration {
+		if config.UsersAllowRegistration {
 			api.AddResource(users, "/users")
 		}
 	}
@@ -466,7 +363,7 @@ func runner(runtime phoenix.Runtime) error {
 	if extraFolder != "" {
 		extraFolderStatic := path.Join(extraFolder, "static")
 		if _, err = os.Stat(extraFolderStatic); err == nil {
-			r.Handle("/extra/static/{path:.*}", http.StripPrefix(fmt.Sprintf("%sextra", basePath), httputils.FileStaticServer(http.Dir(extraFolder))))
+			r.Handle("/extra/static/{path:.*}", http.StripPrefix(fmt.Sprintf("%sextra", config.B), httputils.FileStaticServer(http.Dir(extraFolder))))
 			log.Printf("Added URL handler /extra/static/... for static files in %s/...\n", extraFolderStatic)
 		}
 	}
@@ -491,7 +388,7 @@ func boot() error {
 		return nil
 	}
 
-	return phoenix.NewServer("server", "").
+	return phoenix.NewServer("server", version).
 		Config(configPath).
 		Log(logPath).
 		CpuProfile(cpuprofile).

src/app/spreed-webrtc-server/room_manager.go

@@ -49,18 +49,16 @@ type RoomManager interface {
 
 type roomManager struct {
 	sync.RWMutex
+	*Config
 	OutgoingEncoder
-	defaultRoomEnabled bool
-	globalRoomID       string
-	roomTable          map[string]RoomWorker
+	roomTable map[string]RoomWorker
 }
 
 func NewRoomManager(config *Config, encoder OutgoingEncoder) RoomManager {
 	return &roomManager{
 		sync.RWMutex{},
+		config,
 		encoder,
-		config.DefaultRoomEnabled,
-		config.globalRoomid,
 		make(map[string]RoomWorker),
 	}
 }
@@ -74,7 +72,7 @@ func (rooms *roomManager) RoomUsers(session *Session) []*DataSession {
 }
 
 func (rooms *roomManager) JoinRoom(id string, credentials *DataRoomCredentials, session *Session, sender Sender) (*DataRoom, error) {
-	if id == "" && !rooms.defaultRoomEnabled {
+	if id == "" && !rooms.DefaultRoomEnabled {
 		return nil, &DataError{Type: "Error", Code: "default_room_disabled", Message: "The default room is not enabled"}
 	}
 

src/app/spreed-webrtc-server/roomworker_test.go

@@ -30,14 +30,14 @@ const (
 )
 
 func NewTestRoomWorker() RoomWorker {
-	worker := NewRoomWorker(&roomManager{}, testRoomName, nil)
+	worker := NewRoomWorker(&roomManager{Config: &Config{}}, testRoomName, nil)
 	go worker.Start()
 	return worker
 }
 
 func NewTestRoomWorkerWithPIN(t *testing.T) (RoomWorker, string) {
 	pin := "asdf"
-	worker := NewRoomWorker(&roomManager{}, testRoomName, &DataRoomCredentials{PIN: pin})
+	worker := NewRoomWorker(&roomManager{Config: &Config{}}, testRoomName, &DataRoomCredentials{PIN: pin})
 	go worker.Start()
 	return worker, pin
 }