diff --git a/server/internal/webrtc/manager_test.go b/server/internal/webrtc/manager_test.go index a56cf9d48..7411235ed 100644 --- a/server/internal/webrtc/manager_test.go +++ b/server/internal/webrtc/manager_test.go @@ -141,14 +141,72 @@ func TestPeerOfAClientThatLeftStopsListening(t *testing.T) { tt.run(t, &leavingClient{capture, manager, sessions, session, websocket}) - deadline := time.Now().Add(5 * time.Second) - for capture.listeners() != 0 || session.GetWebRTCPeer() != nil { - if time.Now().After(deadline) { - t.Fatalf("%d listeners left, peer left: %t", - capture.listeners(), session.GetWebRTCPeer() != nil) - } - time.Sleep(time.Millisecond) - } + waitUntilNothingListens(t, capture, session) }) } } + +func waitUntilNothingListens(t *testing.T, capture *listenerCountingCapture, session types.Session) { + t.Helper() + + deadline := time.Now().Add(5 * time.Second) + for capture.listeners() != 0 || session.GetWebRTCPeer() != nil { + if time.Now().After(deadline) { + t.Fatalf("%d listeners left, peer left: %t", + capture.listeners(), session.GetWebRTCPeer() != nil) + } + time.Sleep(time.Millisecond) + } +} + +// The first listener of a stream starts its capture pipeline, which takes +// seconds, and its peer is busy for that long. A session is logged out under +// a lock that every login needs, so ending it must not wait for the pipeline. +func TestSessionIsDeletedWithoutWaitingForItsPeerToStartAStream(t *testing.T) { + capture := &listenerCountingCapture{ + audio: &listenerCountingStream{codec: codec.Opus()}, + video: &listenerCountingStream{ + codec: codec.VP8(), + starting: make(chan struct{}), + start: make(chan struct{}), + }, + } + manager := New(nil, capture, &config.WebRTC{ICETrickle: true}) + sessions := session.New(&config.Session{}) + + // metrics are registered once per session id + id, err := utils.NewUID(16) + if err != nil { + t.Fatalf("create session id: %v", err) + } + profile := types.MemberProfile{CanLogin: true, CanConnect: true, CanWatch: true} + session, _, err := sessions.Create(id, profile) + if err != nil { + t.Fatalf("create session: %v", err) + } + session.ConnectWebSocketPeer(&nopWebSocketPeer{}) + + requested := make(chan struct{}) + go func() { + defer close(requested) + // fails or not, depending on how far it got when the peer closed + _ = requestMedia(manager, session) + }() + <-capture.video.starting + + deleted := make(chan error, 1) + go func() { deleted <- sessions.Delete(id) }() + + select { + case err := <-deleted: + if err != nil { + t.Errorf("delete session: %v", err) + } + case <-time.After(5 * time.Second): + t.Error("deleting the session waits for the stream to start") + } + + close(capture.video.start) + <-requested + waitUntilNothingListens(t, capture, session) +} diff --git a/server/internal/webrtc/peer.go b/server/internal/webrtc/peer.go index 3310b624d..ffce16fbf 100644 --- a/server/internal/webrtc/peer.go +++ b/server/internal/webrtc/peer.go @@ -108,10 +108,26 @@ func (peer *WebRTCPeerCtx) SetCandidate(candidate webrtc.ICECandidateInit) error } // TODO: Add shutdown function? +// +// A peer that is busy is not waited for: it is closed once it is free. A peer +// is busy for seconds while its first listener starts a capture pipeline, and +// sessions are ended under a lock that every login needs. func (peer *WebRTCPeerCtx) Destroy() { - peer.mu.Lock() + if !peer.mu.TryLock() { + go func() { + peer.mu.Lock() + defer peer.mu.Unlock() + + peer.close() + }() + return + } defer peer.mu.Unlock() + peer.close() +} + +func (peer *WebRTCPeerCtx) close() { var err error // if peer connection is not closed, close it diff --git a/server/internal/webrtc/track_test.go b/server/internal/webrtc/track_test.go index fa44c487a..896b1b237 100644 --- a/server/internal/webrtc/track_test.go +++ b/server/internal/webrtc/track_test.go @@ -20,6 +20,11 @@ type listenerCountingStream struct { mu sync.Mutex added, removed int + + // When set, a listener is not added until start is closed, like one that + // has to wait for a capture pipeline. The first to wait closes starting. + starting, start chan struct{} + startingOnce sync.Once } func (s *listenerCountingStream) ID() string { return "test" } @@ -27,6 +32,11 @@ func (s *listenerCountingStream) ID() string { return "test" } func (s *listenerCountingStream) Codec() codec.RTPCodec { return s.codec } func (s *listenerCountingStream) AddListener(types.SampleListener) error { + if s.start != nil { + s.startingOnce.Do(func() { close(s.starting) }) + <-s.start + } + s.mu.Lock() defer s.mu.Unlock()