140 lines
3.4 KiB
Go
140 lines
3.4 KiB
Go
package room
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"errors"
|
|
"math/big"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
|
|
|
|
type Store interface {
|
|
CreateRoom(ctx context.Context, r Room) error
|
|
GetRoom(ctx context.Context, code string) (Room, error)
|
|
SaveRoom(ctx context.Context, r Room) error
|
|
}
|
|
|
|
type Service struct {
|
|
store Store
|
|
codeLength int
|
|
emptyTTL time.Duration
|
|
ownerReconnectHold time.Duration
|
|
}
|
|
|
|
func NewService(st Store, codeLength int, emptyTTL, ownerReconnectHold time.Duration) *Service {
|
|
return &Service{
|
|
store: st,
|
|
codeLength: codeLength,
|
|
emptyTTL: emptyTTL,
|
|
ownerReconnectHold: ownerReconnectHold,
|
|
}
|
|
}
|
|
|
|
func (s *Service) Create(ctx context.Context) (Room, error) {
|
|
for i := 0; i < 10; i++ {
|
|
code, err := randomCode(s.codeLength)
|
|
if err != nil {
|
|
return Room{}, err
|
|
}
|
|
r := New(code, s.emptyTTL)
|
|
if err := s.store.CreateRoom(ctx, r); err == nil {
|
|
return r, nil
|
|
}
|
|
}
|
|
return Room{}, errors.New("failed to allocate room code")
|
|
}
|
|
|
|
func (s *Service) Join(ctx context.Context, code, deviceID string, onlineCount int) (Room, bool, error) {
|
|
code = strings.ToUpper(strings.TrimSpace(code))
|
|
if code == "" || deviceID == "" {
|
|
return Room{}, false, errors.New("room code and device id are required")
|
|
}
|
|
|
|
r, err := s.store.GetRoom(ctx, code)
|
|
if err != nil {
|
|
return Room{}, false, err
|
|
}
|
|
now := NowMS()
|
|
if r.OwnerDeviceID == "" {
|
|
r.OwnerDeviceID = deviceID
|
|
}
|
|
if r.OwnerDeviceID == deviceID {
|
|
r.OwnerLastSeenAt = now
|
|
}
|
|
r.OnlineCount = onlineCount
|
|
if err := s.store.SaveRoom(ctx, r); err != nil {
|
|
return Room{}, false, err
|
|
}
|
|
return r, r.OwnerDeviceID == deviceID, nil
|
|
}
|
|
|
|
func (s *Service) Get(ctx context.Context, code string) (Room, error) {
|
|
return s.store.GetRoom(ctx, strings.ToUpper(strings.TrimSpace(code)))
|
|
}
|
|
|
|
func (s *Service) SetOnlineCount(ctx context.Context, code string, count int) error {
|
|
r, err := s.Get(ctx, code)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.OnlineCount = count
|
|
return s.store.SaveRoom(ctx, r)
|
|
}
|
|
|
|
func (s *Service) SetSource(ctx context.Context, code, deviceID string, src Source) (Room, error) {
|
|
r, err := s.Get(ctx, code)
|
|
if err != nil {
|
|
return Room{}, err
|
|
}
|
|
if r.OwnerDeviceID != deviceID {
|
|
return Room{}, errors.New("only room owner can configure source")
|
|
}
|
|
if src.Mode == "" {
|
|
src.Mode = SourceModeDirect
|
|
}
|
|
if src.Mode != SourceModeDirect && src.Mode != SourceModeProxy {
|
|
return Room{}, errors.New("source mode must be direct or proxy")
|
|
}
|
|
if strings.TrimSpace(src.URL) == "" {
|
|
return Room{}, errors.New("source url is required")
|
|
}
|
|
if src.Mode == SourceModeProxy {
|
|
src.ProxyPath = "/api/rooms/" + r.Code + "/stream"
|
|
}
|
|
r.Source = &src
|
|
r.Playback = Playback{State: PlaybackIdle, ServerUpdatedAt: NowMS()}
|
|
if err := s.store.SaveRoom(ctx, r); err != nil {
|
|
return Room{}, err
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func (s *Service) UpdatePlayback(ctx context.Context, code string, p Playback) (Room, error) {
|
|
r, err := s.Get(ctx, code)
|
|
if err != nil {
|
|
return Room{}, err
|
|
}
|
|
p.ServerUpdatedAt = NowMS()
|
|
r.Playback = p
|
|
if err := s.store.SaveRoom(ctx, r); err != nil {
|
|
return Room{}, err
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func randomCode(n int) (string, error) {
|
|
var b strings.Builder
|
|
b.Grow(n)
|
|
for i := 0; i < n; i++ {
|
|
x, err := rand.Int(rand.Reader, big.NewInt(int64(len(alphabet))))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
b.WriteByte(alphabet[x.Int64()])
|
|
}
|
|
return b.String(), nil
|
|
}
|