[MM-62410] Implement API handler to fetch session config

service/client.go

@@ -11,9 +11,11 @@ import (
 	"log"
 	"net"
 	"net/http"
+	"net/url"
 	"sync"
 	"time"
 
+	"github.com/mattermost/rtcd/service/rtc"
 	"github.com/mattermost/rtcd/service/ws"
 )
 
@@ -38,6 +40,52 @@ type Client struct {
 	wg  sync.WaitGroup
 }
 
+type ClientConfig struct {
+	httpURL string
+	wsURL   string
+
+	ClientID          string
+	AuthKey           string
+	URL               string
+	ReconnectInterval time.Duration
+}
+
+func (c *ClientConfig) Parse() error {
+	if c.URL == "" {
+		return fmt.Errorf("invalid URL value: should not be empty")
+	}
+
+	u, err := url.Parse(c.URL)
+	if err != nil {
+		return fmt.Errorf("failed to parse url: %w", err)
+	}
+
+	if u.Host == "" {
+		return fmt.Errorf("invalid url host: should not be empty")
+	}
+
+	switch u.Scheme {
+	case "http":
+		c.httpURL = c.URL
+		u.Scheme = "ws"
+		u.Path = "/ws"
+		c.wsURL = u.String()
+	case "https":
+		c.httpURL = c.URL
+		u.Scheme = "wss"
+		u.Path = "/ws"
+		c.wsURL = u.String()
+	default:
+		return fmt.Errorf("invalid url scheme: %q is not valid", u.Scheme)
+	}
+
+	if c.ReconnectInterval <= 0 {
+		c.ReconnectInterval = defaultReconnectInterval
+	}
+
+	return nil
+}
+
 func NewClient(cfg ClientConfig, opts ...ClientOption) (*Client, error) {
 	var c Client
 
@@ -408,3 +456,59 @@ func (c *Client) GetSystemInfo() (SystemInfo, error) {
 
 	return info, nil
 }
+
+func (c *Client) GetSession(callID, sessionID string) (rtc.SessionConfig, int, error) {
+	reqURL := fmt.Sprintf("%s/calls/%s/sessions/%s", c.cfg.httpURL, callID, sessionID)
+
+	req, err := http.NewRequest("GET", reqURL, nil)
+	if err != nil {
+		return rtc.SessionConfig{}, 0, fmt.Errorf("failed to build request: %w", err)
+	}
+	req.SetBasicAuth(c.cfg.ClientID, c.cfg.AuthKey)
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return rtc.SessionConfig{}, 0, fmt.Errorf("http request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var cfg rtc.SessionConfig
+
+	if resp.StatusCode != http.StatusOK {
+		return rtc.SessionConfig{}, resp.StatusCode, fmt.Errorf("request failed with status %s", resp.Status)
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&cfg); err != nil {
+		return rtc.SessionConfig{}, resp.StatusCode, fmt.Errorf("decoding http response failed: %w", err)
+	}
+
+	return cfg, resp.StatusCode, nil
+}
+
+func (c *Client) GetSessions(callID string) ([]rtc.SessionConfig, int, error) {
+	reqURL := fmt.Sprintf("%s/calls/%s/sessions", c.cfg.httpURL, callID)
+
+	req, err := http.NewRequest("GET", reqURL, nil)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to build request: %w", err)
+	}
+	req.SetBasicAuth(c.cfg.ClientID, c.cfg.AuthKey)
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, 0, fmt.Errorf("http request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var cfgs []rtc.SessionConfig
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, resp.StatusCode, fmt.Errorf("request failed with status %s", resp.Status)
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&cfgs); err != nil {
+		return nil, resp.StatusCode, fmt.Errorf("decoding http response failed: %w", err)
+	}
+
+	return cfgs, resp.StatusCode, nil
+}

service/client_test.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"net/http"
 	"runtime"
 	"sync"
 	"sync/atomic"
@@ -16,6 +17,7 @@ import (
 
 	"github.com/mattermost/rtcd/service/auth"
 	"github.com/mattermost/rtcd/service/random"
+	"github.com/mattermost/rtcd/service/rtc"
 	"github.com/mattermost/rtcd/service/ws"
 
 	"github.com/stretchr/testify/require"
@@ -780,3 +782,183 @@ func TestClientGetSystemInfo(t *testing.T) {
 		require.NotZero(t, info.CPULoad)
 	})
 }
+
+func TestClientGetSession(t *testing.T) {
+	th := SetupTestHelper(t, nil)
+	defer th.Teardown()
+
+	// register client
+	authKey := "Nl9OZthX5cMJz5a_HmU3kQJ4pHIIlohr"
+	err := th.srvc.auth.Register("clientA", authKey)
+	require.NoError(t, err)
+
+	t.Run("unauthorized", func(t *testing.T) {
+		c, err := NewClient(ClientConfig{
+			URL: th.apiURL,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, c)
+		defer c.Close()
+
+		cfg, code, err := c.GetSession("callID", "sessionID")
+		require.EqualError(t, err, "request failed with status 401 Unauthorized")
+		require.Empty(t, cfg)
+		require.Equal(t, http.StatusUnauthorized, code)
+	})
+
+	t.Run("no call ongoing", func(t *testing.T) {
+		c, err := NewClient(ClientConfig{
+			URL:      th.apiURL,
+			ClientID: "clientA",
+			AuthKey:  authKey,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, c)
+		defer c.Close()
+
+		cfg, code, err := c.GetSession("callID", "sessionID")
+		require.EqualError(t, err, "request failed with status 404 Not Found")
+		require.Empty(t, cfg)
+		require.Equal(t, http.StatusNotFound, code)
+	})
+
+	t.Run("no session found", func(t *testing.T) {
+		c, err := NewClient(ClientConfig{
+			URL:      th.apiURL,
+			ClientID: "clientA",
+			AuthKey:  authKey,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, c)
+		defer c.Close()
+
+		cfg := rtc.SessionConfig{
+			GroupID:   "clientA",
+			CallID:    "callIDA",
+			UserID:    "userID",
+			SessionID: "sessionID",
+		}
+		err = th.srvc.rtcServer.InitSession(cfg, nil)
+		require.NoError(t, err)
+		defer func() {
+			err := th.srvc.rtcServer.CloseSession("sessionID")
+			require.NoError(t, err)
+		}()
+
+		cfg, code, err := c.GetSession("callID", "sessionID")
+		require.EqualError(t, err, "request failed with status 404 Not Found")
+		require.Empty(t, cfg)
+		require.Equal(t, http.StatusNotFound, code)
+	})
+
+	t.Run("session found", func(t *testing.T) {
+		c, err := NewClient(ClientConfig{
+			URL:      th.apiURL,
+			ClientID: "clientA",
+			AuthKey:  authKey,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, c)
+		defer c.Close()
+
+		cfg := rtc.SessionConfig{
+			GroupID:   "clientA",
+			CallID:    "callIDA",
+			UserID:    "userID",
+			SessionID: "sessionID",
+		}
+		err = th.srvc.rtcServer.InitSession(cfg, nil)
+		require.NoError(t, err)
+		defer func() {
+			err := th.srvc.rtcServer.CloseSession("sessionID")
+			require.NoError(t, err)
+		}()
+
+		sessionCfg, code, err := c.GetSession("callIDA", "sessionID")
+		require.NoError(t, err)
+		require.Equal(t, cfg, sessionCfg)
+		require.Equal(t, http.StatusOK, code)
+	})
+}
+
+func TestClientGetSessions(t *testing.T) {
+	th := SetupTestHelper(t, nil)
+	defer th.Teardown()
+
+	// register client
+	authKey := "Nl9OZthX5cMJz5a_HmU3kQJ4pHIIlohr"
+	err := th.srvc.auth.Register("clientA", authKey)
+	require.NoError(t, err)
+
+	t.Run("unauthorized", func(t *testing.T) {
+		c, err := NewClient(ClientConfig{
+			URL: th.apiURL,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, c)
+		defer c.Close()
+
+		cfgs, code, err := c.GetSessions("callID")
+		require.EqualError(t, err, "request failed with status 401 Unauthorized")
+		require.Empty(t, cfgs)
+		require.Equal(t, http.StatusUnauthorized, code)
+	})
+
+	t.Run("no call ongoing", func(t *testing.T) {
+		c, err := NewClient(ClientConfig{
+			URL:      th.apiURL,
+			ClientID: "clientA",
+			AuthKey:  authKey,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, c)
+		defer c.Close()
+
+		cfgs, code, err := c.GetSessions("callID")
+		require.EqualError(t, err, "request failed with status 404 Not Found")
+		require.Empty(t, cfgs)
+		require.Equal(t, http.StatusNotFound, code)
+	})
+
+	t.Run("call ongoing", func(t *testing.T) {
+		c, err := NewClient(ClientConfig{
+			URL:      th.apiURL,
+			ClientID: "clientA",
+			AuthKey:  authKey,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, c)
+		defer c.Close()
+
+		cfgA := rtc.SessionConfig{
+			GroupID:   "clientA",
+			CallID:    "callIDA",
+			UserID:    "userA",
+			SessionID: "sessionA",
+		}
+		err = th.srvc.rtcServer.InitSession(cfgA, nil)
+		require.NoError(t, err)
+		defer func() {
+			err := th.srvc.rtcServer.CloseSession("sessionA")
+			require.NoError(t, err)
+		}()
+
+		cfgB := rtc.SessionConfig{
+			GroupID:   "clientA",
+			CallID:    "callIDA",
+			UserID:    "userB",
+			SessionID: "sessionB",
+		}
+		err = th.srvc.rtcServer.InitSession(cfgB, nil)
+		require.NoError(t, err)
+		defer func() {
+			err := th.srvc.rtcServer.CloseSession("sessionB")
+			require.NoError(t, err)
+		}()
+
+		sessionCfgs, code, err := c.GetSessions("callIDA")
+		require.NoError(t, err)
+		require.ElementsMatch(t, []rtc.SessionConfig{cfgA, cfgB}, sessionCfgs)
+		require.Equal(t, http.StatusOK, code)
+	})
+}

service/config.go

@@ -5,8 +5,6 @@ package service
 
 import (
 	"fmt"
-	"net/url"
-	"time"
 
 	"github.com/mattermost/rtcd/service/auth"
 
@@ -105,49 +103,3 @@ func (c StoreConfig) IsValid() error {
 	}
 	return nil
 }
-
-type ClientConfig struct {
-	httpURL string
-	wsURL   string
-
-	ClientID          string
-	AuthKey           string
-	URL               string
-	ReconnectInterval time.Duration
-}
-
-func (c *ClientConfig) Parse() error {
-	if c.URL == "" {
-		return fmt.Errorf("invalid URL value: should not be empty")
-	}
-
-	u, err := url.Parse(c.URL)
-	if err != nil {
-		return fmt.Errorf("failed to parse url: %w", err)
-	}
-
-	if u.Host == "" {
-		return fmt.Errorf("invalid url host: should not be empty")
-	}
-
-	switch u.Scheme {
-	case "http":
-		c.httpURL = c.URL
-		u.Scheme = "ws"
-		u.Path = "/ws"
-		c.wsURL = u.String()
-	case "https":
-		c.httpURL = c.URL
-		u.Scheme = "wss"
-		u.Path = "/ws"
-		c.wsURL = u.String()
-	default:
-		return fmt.Errorf("invalid url scheme: %q is not valid", u.Scheme)
-	}
-
-	if c.ReconnectInterval <= 0 {
-		c.ReconnectInterval = defaultReconnectInterval
-	}
-
-	return nil
-}