Support multiple urls per backend

api_backend.go

@@ -32,6 +32,7 @@ import (
 	"net/http"
 	"net/url"
 	"regexp"
+	"slices"
 	"strings"
 	"time"
 )
@@ -432,10 +433,12 @@ type TurnCredentials struct {
 // Information on a backend in the etcd cluster.
 
 type BackendInformationEtcd struct {
-	parsedUrl *url.URL
+	// Compat setting.
+	Url string `json:"url,omitempty"`
 
-	Url    string `json:"url"`
-	Secret string `json:"secret"`
+	Urls       []string `json:"urls,omitempty"`
+	parsedUrls []*url.URL
+	Secret     string `json:"secret"`
 
 	MaxStreamBitrate int `json:"maxstreambitrate,omitempty"`
 	MaxScreenBitrate int `json:"maxscreenbitrate,omitempty"`
@@ -444,23 +447,40 @@ type BackendInformationEtcd struct {
 }
 
 func (p *BackendInformationEtcd) CheckValid() error {
-	if p.Url == "" {
-		return fmt.Errorf("url missing")
-	}
 	if p.Secret == "" {
 		return fmt.Errorf("secret missing")
 	}
 
-	parsedUrl, err := url.Parse(p.Url)
-	if err != nil {
-		return fmt.Errorf("invalid url: %w", err)
-	}
+	if len(p.Urls) > 0 {
+		slices.Sort(p.Urls)
+		p.Urls = slices.Compact(p.Urls)
+		for idx, u := range p.Urls {
+			parsedUrl, err := url.Parse(u)
+			if err != nil {
+				return fmt.Errorf("invalid url %s: %w", u, err)
+			}
+			if strings.Contains(parsedUrl.Host, ":") && hasStandardPort(parsedUrl) {
+				parsedUrl.Host = parsedUrl.Hostname()
+				p.Urls[idx] = parsedUrl.String()
+			}
+
+			p.parsedUrls = append(p.parsedUrls, parsedUrl)
+		}
+	} else if p.Url != "" {
+		parsedUrl, err := url.Parse(p.Url)
+		if err != nil {
+			return fmt.Errorf("invalid url: %w", err)
+		}
+		if strings.Contains(parsedUrl.Host, ":") && hasStandardPort(parsedUrl) {
+			parsedUrl.Host = parsedUrl.Hostname()
+			p.Url = parsedUrl.String()
+		}
 
-	if strings.Contains(parsedUrl.Host, ":") && hasStandardPort(parsedUrl) {
-		parsedUrl.Host = parsedUrl.Hostname()
-		p.Url = parsedUrl.String()
+		p.Urls = append(p.Urls, p.Url)
+		p.parsedUrls = append(p.parsedUrls, parsedUrl)
+	} else {
+		return fmt.Errorf("urls missing")
 	}
 
-	p.parsedUrl = parsedUrl
 	return nil
 }

api_signaling.go

@@ -370,11 +370,17 @@ type ClientTypeInternalAuthParams struct {
 func (p *ClientTypeInternalAuthParams) CheckValid() error {
 	if p.Backend == "" {
 		return fmt.Errorf("backend missing")
-	} else if u, err := url.Parse(p.Backend); err != nil {
+	}
+
+	if p.Backend[len(p.Backend)-1] != '/' {
+		p.Backend += "/"
+	}
+	if u, err := url.Parse(p.Backend); err != nil {
 		return err
 	} else {
 		if strings.Contains(u.Host, ":") && hasStandardPort(u) {
 			u.Host = u.Hostname()
+			p.Backend = u.String()
 		}
 
 		p.parsedBackend = u
@@ -475,11 +481,21 @@ func (m *HelloClientMessage) CheckValid() error {
 		case HelloClientTypeFederation:
 			if m.Auth.Url == "" {
 				return fmt.Errorf("url missing")
-			} else if u, err := url.ParseRequestURI(m.Auth.Url); err != nil {
+			}
+
+			if m.Auth.Url[len(m.Auth.Url)-1] != '/' {
+				m.Auth.Url += "/"
+			}
+			if pos := strings.Index(m.Auth.Url, "ocs/v2.php/apps/spreed/"); pos != -1 {
+				m.Auth.Url = m.Auth.Url[:pos]
+			}
+
+			if u, err := url.ParseRequestURI(m.Auth.Url); err != nil {
 				return err
 			} else {
 				if strings.Contains(u.Host, ":") && hasStandardPort(u) {
 					u.Host = u.Hostname()
+					m.Auth.Url = u.String()
 				}
 
 				m.Auth.parsedUrl = u

backend_client.go

@@ -171,13 +171,13 @@ func (b *BackendClient) PerformJSONRequest(ctx context.Context, u *url.URL, requ
 
 	ct := resp.Header.Get("Content-Type")
 	if !strings.HasPrefix(ct, "application/json") {
-		log.Printf("Received unsupported content-type from %s: %s (%s)", req.URL, ct, resp.Status)
+		log.Printf("Received unsupported content-type from %s for %s: %s (%s)", req.URL, string(data), ct, resp.Status)
 		return ErrUnsupportedContentType
 	}
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		log.Printf("Could not read response body from %s: %s", req.URL, err)
+		log.Printf("Could not read response body from %s for %s: %s", req.URL, string(data), err)
 		return err
 	}
 

backend_configuration.go

@@ -22,8 +22,10 @@
 package signaling
 
 import (
+	"bytes"
 	"fmt"
 	"net/url"
+	"slices"
 	"strings"
 	"sync"
 
@@ -42,11 +44,9 @@ var (
 )
 
 type Backend struct {
-	id        string
-	url       string
-	parsedUrl *url.URL
-	secret    []byte
-	compat    bool
+	id     string
+	urls   []string
+	secret []byte
 
 	allowHttp bool
 
@@ -67,7 +67,23 @@ func (b *Backend) Secret() []byte {
 }
 
 func (b *Backend) IsCompat() bool {
-	return b.compat
+	return len(b.urls) == 0
+}
+
+func (b *Backend) Equal(other *Backend) bool {
+	if b == other {
+		return true
+	} else if b == nil || other == nil {
+		return false
+	}
+
+	return b.id == other.id &&
+		b.allowHttp == other.allowHttp &&
+		b.maxStreamBitrate == other.maxStreamBitrate &&
+		b.maxScreenBitrate == other.maxScreenBitrate &&
+		b.sessionLimit == other.sessionLimit &&
+		bytes.Equal(b.secret, other.secret) &&
+		slices.Equal(b.urls, other.urls)
 }
 
 func (b *Backend) IsUrlAllowed(u *url.URL) bool {
@@ -81,12 +97,23 @@ func (b *Backend) IsUrlAllowed(u *url.URL) bool {
 	}
 }
 
-func (b *Backend) Url() string {
-	return b.url
+func (b *Backend) HasUrl(url string) bool {
+	if b.IsCompat() {
+		// Old-style configuration, only hosts are configured.
+		return true
+	}
+
+	for _, u := range b.urls {
+		if strings.HasPrefix(url, u) {
+			return true
+		}
+	}
+
+	return false
 }
 
-func (b *Backend) ParsedUrl() *url.URL {
-	return b.parsedUrl
+func (b *Backend) Urls() []string {
+	return b.urls
 }
 
 func (b *Backend) Limit() int {
@@ -173,10 +200,7 @@ func (s *backendStorageCommon) getBackendLocked(u *url.URL) *Backend {
 			continue
 		}
 
-		if entry.url == "" {
-			// Old-style configuration, only hosts are configured.
-			return entry
-		} else if strings.HasPrefix(url, entry.url) {
+		if entry.HasUrl(url) {
 			return entry
 		}
 	}