diff --git a/server/internal/session/manager.go b/server/internal/session/manager.go index a638595bc..25de3c1b2 100644 --- a/server/internal/session/manager.go +++ b/server/internal/session/manager.go @@ -159,8 +159,9 @@ func (manager *SessionManagerCtx) Delete(id string) error { session.DestroyWebSocketPeer("session deleted") } - if session.State().IsWatching { - session.GetWebRTCPeer().Destroy() + // a closing peer is cleared from another goroutine, so it can be gone already + if webrtcPeer := session.GetWebRTCPeer(); webrtcPeer != nil { + webrtcPeer.Destroy() } manager.emmiter.Emit("deleted", session) @@ -182,8 +183,9 @@ func (manager *SessionManagerCtx) Disconnect(id string) error { session.DestroyWebSocketPeer("session disconnected") } - if session.State().IsWatching { - session.GetWebRTCPeer().Destroy() + // a closing peer is cleared from another goroutine, so it can be gone already + if webrtcPeer := session.GetWebRTCPeer(); webrtcPeer != nil { + webrtcPeer.Destroy() } return nil diff --git a/server/internal/session/session.go b/server/internal/session/session.go index 686c9611a..0f4e73b9e 100644 --- a/server/internal/session/session.go +++ b/server/internal/session/session.go @@ -30,7 +30,10 @@ type SessionCtx struct { wsDelayedTimer *time.Timer webrtcPeer types.WebRTCPeer - webrtcMu sync.Mutex + // whether webrtcPeer has connected; unlike state.IsWatching this is never + // left over from a peer that was replaced + webrtcConnected bool + webrtcMu sync.Mutex } func (session *SessionCtx) ID() string { @@ -51,7 +54,9 @@ func (session *SessionCtx) profileChanged() { // otherwise webrtc destroy would trigger websocket reconnect. In case of kick event, webrtc destroy is called // before websocket destroy that delivers the information about the kick. time.AfterFunc(time.Second, func() { - session.GetWebRTCPeer().Destroy() + if peer := session.GetWebRTCPeer(); peer != nil { + peer.Destroy() + } }) } @@ -149,6 +154,8 @@ func (session *SessionCtx) ConnectWebSocketPeer(websocketPeer types.WebSocketPee // but after a delay. If the peer is connected again before the delay, the disconnect will be // cancelled. // +// A WebRTC peer that has not connected is destroyed with the websocket peer. +// // If the peer is not the current peer or the peer is nil, it will be ignored. func (session *SessionCtx) DisconnectWebSocketPeer(websocketPeer types.WebSocketPeer, delayed bool) { session.websocketMu.Lock() @@ -212,6 +219,42 @@ func (session *SessionCtx) DisconnectWebSocketPeer(websocketPeer types.WebSocket session.websocketPeer = nil } session.websocketMu.Unlock() + + // A WebRTC peer that has not connected yet is not waited for. Until the + // client has answered, the peer needs this websocket to connect at all: + // without it the peer would stay half-open for good and keep the capture + // pipelines it subscribed to running with nobody watching. Once the client + // has answered, the peer could still connect without the websocket, but a + // client whose websocket is gone for good has left. + session.destroyPendingWebRTCPeer() +} + +// Destroy the WebRTC peer if it has not connected and no websocket peer is +// left to connect it. A connected peer is left alone: it does not need the +// websocket to keep streaming. +// +// The websocket peer must be cleared before this is called, and a WebRTC peer +// must be set before it. That order makes sure a disconnecting websocket and +// a peer being set see each other, whichever happens first. +func (session *SessionCtx) destroyPendingWebRTCPeer() { + session.webrtcMu.Lock() + webrtcPeer, connected := session.webrtcPeer, session.webrtcConnected + session.webrtcMu.Unlock() + + if webrtcPeer == nil || connected { + return + } + + // Another websocket may have connected by now, and the peer may be one it + // asked for. Looking at the websocket after the peer makes sure a peer + // that was set while a websocket is connected is left to that websocket. + session.websocketMu.Lock() + hasWebSocket := session.websocketPeer != nil + session.websocketMu.Unlock() + + if !hasWebSocket { + webrtcPeer.Destroy() + } } // Destroy WebSocket peer disconnects the peer and destroys it. It ensures that the peer is @@ -247,15 +290,24 @@ func (session *SessionCtx) Send(event string, payload any) { // webrtc // --- -// Set webrtc peer and destroy the old one, if there is old one. +// SetWebRTCPeer sets the current peer and destroys the one it replaced. func (session *SessionCtx) SetWebRTCPeer(webrtcPeer types.WebRTCPeer) { session.webrtcMu.Lock() - session.webrtcPeer, webrtcPeer = webrtcPeer, session.webrtcPeer + oldPeer := session.webrtcPeer + changed := oldPeer != webrtcPeer + if changed { + session.webrtcPeer = webrtcPeer + session.webrtcConnected = false + } session.webrtcMu.Unlock() - if webrtcPeer != nil && webrtcPeer != session.webrtcPeer { - webrtcPeer.Destroy() + if changed && oldPeer != nil { + oldPeer.Destroy() } + + // The websocket can go away while a peer is being created for it. Its + // disconnect found no peer to destroy then, so it is done here. + session.destroyPendingWebRTCPeer() } // Set if current webrtc peer is connected or not. Since there might be lefover calls from @@ -267,6 +319,9 @@ func (session *SessionCtx) SetWebRTCPeer(webrtcPeer types.WebRTCPeer) { func (session *SessionCtx) SetWebRTCConnected(webrtcPeer types.WebRTCPeer, connected bool) { session.webrtcMu.Lock() isCurrentPeer := webrtcPeer == session.webrtcPeer + if isCurrentPeer { + session.webrtcConnected = connected + } session.webrtcMu.Unlock() if !isCurrentPeer { diff --git a/server/internal/session/session_test.go b/server/internal/session/session_test.go index 2a2dddac6..f6b550301 100644 --- a/server/internal/session/session_test.go +++ b/server/internal/session/session_test.go @@ -1,7 +1,11 @@ package session import ( + "runtime" + "sync" "testing" + "testing/synctest" + "time" "github.com/m1k1o/neko/server/internal/config" "github.com/m1k1o/neko/server/pkg/types" @@ -39,3 +43,267 @@ func TestLegacyIsHost(t *testing.T) { }) } } + +// Not empty, so that two of them are never the same pointer. +type fakeWebSocketPeer struct{ _ bool } + +func (fakeWebSocketPeer) Send(event string, payload any) {} +func (fakeWebSocketPeer) Ping() error { return nil } +func (fakeWebSocketPeer) Destroy(reason string) {} + +// fakeWebRTCPeer records whether it was destroyed. Like the real peer it can +// be destroyed more than once. The embedded interface is nil: these tests +// must not reach any other method. +type fakeWebRTCPeer struct { + types.WebRTCPeer + destroyed bool +} + +func (p *fakeWebRTCPeer) Destroy() { p.destroyed = true } + +func newTestSession(t *testing.T) *SessionCtx { + t.Helper() + manager := New(&config.Session{}) + session, _, err := manager.Create("member", types.MemberProfile{CanLogin: true, CanConnect: true, CanWatch: true}) + if err != nil { + t.Fatalf("create session: %v", err) + } + return session.(*SessionCtx) +} + +func newConnectedTestSession(t *testing.T) (*SessionCtx, *fakeWebSocketPeer) { + t.Helper() + session := newTestSession(t) + websocket := &fakeWebSocketPeer{} + session.ConnectWebSocketPeer(websocket) + return session, websocket +} + +func TestSettingSameWebRTCPeerPreservesItsConnection(t *testing.T) { + session, websocket := newConnectedTestSession(t) + peer := &fakeWebRTCPeer{} + session.SetWebRTCPeer(peer) + session.SetWebRTCConnected(peer, true) + session.SetWebRTCPeer(peer) + session.DisconnectWebSocketPeer(websocket, false) + if peer.destroyed { + t.Fatal("setting the same peer made it lose its connection") + } +} + +func TestPendingWebRTCPeerWaitsForReconnectDeadline(t *testing.T) { + for _, tt := range []struct { + name string + after time.Duration + wantDestroyed bool + }{ + {"before expiry", WS_DELAYED_DURATION - time.Nanosecond, false}, + {"at expiry", WS_DELAYED_DURATION, true}, + } { + t.Run(tt.name, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + session, websocket := newConnectedTestSession(t) + peer := &fakeWebRTCPeer{} + session.SetWebRTCPeer(peer) + session.DisconnectWebSocketPeer(websocket, true) + defer session.DisconnectWebSocketPeer(websocket, false) + + time.Sleep(tt.after) + synctest.Wait() + if peer.destroyed != tt.wantDestroyed { + t.Errorf("peer destroyed = %t, want %t", peer.destroyed, tt.wantDestroyed) + } + }) + }) + } +} + +func TestPeerSetDuringReconnectGraceSurvivesReconnect(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + session, websocket := newConnectedTestSession(t) + session.DisconnectWebSocketPeer(websocket, true) + peer := &fakeWebRTCPeer{} + session.SetWebRTCPeer(peer) + session.ConnectWebSocketPeer(&fakeWebSocketPeer{}) + + time.Sleep(WS_DELAYED_DURATION) + synctest.Wait() + if peer.destroyed { + t.Fatal("old websocket's timer destroyed the peer after reconnect") + } + }) +} + +// A client that is watching can ask for media again, which replaces its peer. +// The session goes on counting as watching, because the closing of a replaced +// peer is ignored, but the new peer has not connected. +func TestWebRTCPeerThatReplacedAStreamingOneIsDestroyedUnlessItConnected(t *testing.T) { + tests := []struct { + name string + connected bool + wantDestroyed bool + }{ + {name: "websocket closes before the new peer connects", wantDestroyed: true}, + {name: "websocket closes while the new peer is streaming", connected: true, wantDestroyed: false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + session, websocket := newConnectedTestSession(t) + replaced := &fakeWebRTCPeer{} + session.SetWebRTCPeer(replaced) + session.SetWebRTCConnected(replaced, true) + + peer := &fakeWebRTCPeer{} + session.SetWebRTCPeer(peer) + if tt.connected { + session.SetWebRTCConnected(peer, true) + } + // the replaced peer reports its closing whenever it gets to it + session.SetWebRTCConnected(replaced, false) + + session.DisconnectWebSocketPeer(websocket, false) + + if !replaced.destroyed { + t.Error("replaced peer was not destroyed") + } + if peer.destroyed != tt.wantDestroyed { + t.Errorf("peer destroyed = %t, want %t", peer.destroyed, tt.wantDestroyed) + } + }) + } +} + +func TestConcurrentWebRTCPeerReplacement(t *testing.T) { + session, _ := newConnectedTestSession(t) + peers := []*fakeWebRTCPeer{{}, {}, {}} + session.SetWebRTCPeer(peers[0]) + + var wg sync.WaitGroup + for _, peer := range peers[1:] { + wg.Go(func() { session.SetWebRTCPeer(peer) }) + } + wg.Wait() + + current := session.GetWebRTCPeer() + if current != peers[1] && current != peers[2] { + t.Fatal("neither replacement is the current peer") + } + for i, peer := range peers { + if want := peer != current; peer.destroyed != want { + t.Errorf("peer %d destroyed = %t, want %t", i, peer.destroyed, want) + } + } +} + +func TestSessionEndCleansUpWebRTCPeer(t *testing.T) { + tests := []struct { + name string + end func(*SessionManagerCtx, string) error + }{ + {"delete", (*SessionManagerCtx).Delete}, + {"disconnect", (*SessionManagerCtx).Disconnect}, + } + for _, tt := range tests { + t.Run(tt.name+"/streaming without a websocket", func(t *testing.T) { + session, websocket := newConnectedTestSession(t) + peer := &fakeWebRTCPeer{} + session.SetWebRTCPeer(peer) + session.SetWebRTCConnected(peer, true) + session.DisconnectWebSocketPeer(websocket, false) + if peer.destroyed { + t.Fatal("websocket disconnect destroyed a streaming peer") + } + + if err := tt.end(session.manager, session.ID()); err != nil { + t.Fatal(err) + } + if !peer.destroyed { + t.Fatal("ending the session left its streaming peer alive") + } + }) + t.Run(tt.name+"/peer already gone", func(t *testing.T) { + session, _ := newConnectedTestSession(t) + session.state.IsWatching = true // can outlive a replaced peer + if err := tt.end(session.manager, session.ID()); err != nil { + t.Fatal(err) + } + + // A media request can finish setting its peer after the session ends. + late := &fakeWebRTCPeer{} + session.SetWebRTCPeer(late) + if !late.destroyed { + t.Fatal("peer set after the session ended was not destroyed") + } + }) + } +} + +// A session that may no longer connect has its peer destroyed a moment after +// its websocket. The websocket takes a peer that has not connected with it, +// so a session that counts as watching can have no peer left by then. +func TestSessionThatCountsAsWatchingWithoutAPeerCanLoseItsLogin(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + session := newTestSession(t) + session.state.IsWatching = true + + profile := session.Profile() + profile.CanLogin = false + if err := session.manager.Update(session.ID(), profile); err != nil { + t.Fatalf("update session: %v", err) + } + + // the peer is destroyed from a timer + time.Sleep(2 * time.Second) + }) +} + +// A client can be back on a new websocket before the old one is done leaving, +// because the session's listeners run in between. A peer the new websocket +// asked for is not the old one's to destroy. +func TestWebRTCPeerOfAWebSocketThatTookOverIsKept(t *testing.T) { + session, websocket := newConnectedTestSession(t) + + peer := &fakeWebRTCPeer{} + session.manager.OnDisconnected(func(session types.Session) { + session.ConnectWebSocketPeer(&fakeWebSocketPeer{}) + session.SetWebRTCPeer(peer) + }) + + session.DisconnectWebSocketPeer(websocket, false) + + if peer.destroyed { + t.Error("peer of the websocket that took over was destroyed") + } +} + +// The new websocket can also connect after the old one was cleared from the +// session, and ask for a peer before the old one looks for a peer to destroy. +func TestWebRTCPeerOfAWebSocketThatConnectedAfterTheOldOneWasClearedIsKept(t *testing.T) { + session, websocket := newConnectedTestSession(t) + + // holds the old websocket where it looks for a peer to destroy + session.webrtcMu.Lock() + disconnected := make(chan struct{}) + go func() { + defer close(disconnected) + session.DisconnectWebSocketPeer(websocket, false) + }() + for cleared := false; !cleared; { + session.websocketMu.Lock() + cleared = session.websocketPeer == nil + session.websocketMu.Unlock() + runtime.Gosched() + } + + // the lock is held, so the peer is set as SetWebRTCPeer would set it + session.ConnectWebSocketPeer(&fakeWebSocketPeer{}) + peer := &fakeWebRTCPeer{} + session.webrtcPeer, session.webrtcConnected = peer, false + session.webrtcMu.Unlock() + <-disconnected + + if peer.destroyed { + t.Error("peer of the websocket that connected was destroyed") + } +} diff --git a/server/internal/webrtc/manager_test.go b/server/internal/webrtc/manager_test.go new file mode 100644 index 000000000..0899ddfcb --- /dev/null +++ b/server/internal/webrtc/manager_test.go @@ -0,0 +1,170 @@ +package webrtc + +import ( + "testing" + "time" + + "github.com/m1k1o/neko/server/internal/config" + "github.com/m1k1o/neko/server/internal/session" + "github.com/m1k1o/neko/server/pkg/types" + "github.com/m1k1o/neko/server/pkg/types/codec" + "github.com/m1k1o/neko/server/pkg/utils" +) + +// listenerCountingCapture has one audio and one video stream. The embedded +// interface is nil: these tests must not reach any other method. +type listenerCountingCapture struct { + types.CaptureManager + audio, video *listenerCountingStream +} + +func (c *listenerCountingCapture) Audio() types.StreamSinkManager { return c.audio } +func (c *listenerCountingCapture) Video() types.StreamSelectorManager { return c } + +func (c *listenerCountingCapture) IDs() []string { return []string{c.video.ID()} } +func (c *listenerCountingCapture) Codec() codec.RTPCodec { return c.video.Codec() } +func (c *listenerCountingCapture) GetStream(types.StreamSelector) (types.StreamSinkManager, bool) { + return c.video, true +} + +type nopWebSocketPeer struct{ _ bool } + +func (nopWebSocketPeer) Send(event string, payload any) {} +func (nopWebSocketPeer) Ping() error { return nil } +func (nopWebSocketPeer) Destroy(reason string) {} + +type leavingClient struct { + capture *listenerCountingCapture + manager *WebRTCManagerCtx + sessions *session.SessionManagerCtx + session types.Session + websocket types.WebSocketPeer +} + +func newLeavingClient(t *testing.T) *leavingClient { + t.Helper() + capture := &listenerCountingCapture{ + audio: &listenerCountingStream{codec: codec.Opus()}, + video: &listenerCountingStream{codec: codec.VP8()}, + } + 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} + s, _, err := sessions.Create(id, profile) + if err != nil { + t.Fatalf("create session: %v", err) + } + ws := &nopWebSocketPeer{} + s.ConnectWebSocketPeer(ws) + return &leavingClient{ + capture: capture, + manager: New(nil, capture, &config.WebRTC{ICETrickle: true}), + sessions: sessions, + session: s, + websocket: ws, + } +} + +// What the signal/request handler does for a client that wants video and audio. +func (c *leavingClient) requestMedia() error { + _, peer, err := c.manager.CreatePeer(c.session) + if err != nil { + return err + } + if err := peer.SetVideo(types.PeerVideoRequest{Selector: &types.StreamSelector{ID: "test"}}); err != nil { + return err + } + disabled := false + return peer.SetAudio(types.PeerAudioRequest{Disabled: &disabled}) +} + +func (c *leavingClient) waitForCleanup(t *testing.T) { + t.Helper() + deadline := time.Now().Add(5 * time.Second) + for { + audio, video := c.capture.audio.listeners(), c.capture.video.listeners() + peer := c.session.GetWebRTCPeer() + if audio == 0 && video == 0 && peer == nil { + return + } + if time.Now().After(deadline) { + t.Fatalf("listeners left: audio=%d video=%d; peer left: %t", audio, video, peer != nil) + } + time.Sleep(time.Millisecond) + } +} + +func TestPeerOfAClientThatLeftStopsListening(t *testing.T) { + tests := []struct { + name string + requests int + }{ + {"unanswered offer", 1}, + {"replaced unanswered offer", 2}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := newLeavingClient(t) + for range tt.requests { + if err := c.requestMedia(); err != nil { + t.Fatalf("request media: %v", err) + } + if audio, video := c.capture.audio.listeners(), c.capture.video.listeners(); audio < 1 || video < 1 { + t.Fatalf("expected listeners after request: audio=%d video=%d", audio, video) + } + } + c.session.DisconnectWebSocketPeer(c.websocket, false) + c.waitForCleanup(t) + }) + } +} + +func TestMediaRequestAfterWebSocketDisconnect(t *testing.T) { + c := newLeavingClient(t) + c.session.DisconnectWebSocketPeer(c.websocket, false) + if err := c.requestMedia(); err == nil { + t.Error("request media succeeded without a websocket") + } + c.waitForCleanup(t) +} + +// 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) { + c := newLeavingClient(t) + video := c.capture.video + video.starting, video.start = make(chan struct{}), make(chan struct{}) + + requested := make(chan struct{}) + go func() { + defer close(requested) + // fails or not, depending on how far it got when the peer closed + _ = c.requestMedia() + }() + select { + case <-video.starting: + case <-requested: + t.Fatal("media request finished without starting the stream") + } + + deleted := make(chan error, 1) + go func() { deleted <- c.sessions.Delete(c.session.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(video.start) + <-requested + c.waitForCleanup(t) +} 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.go b/server/internal/webrtc/track.go index 8ddc7ea29..1fc1b557a 100644 --- a/server/internal/webrtc/track.go +++ b/server/internal/webrtc/track.go @@ -22,10 +22,13 @@ type Track struct { sample chan types.Sample paused bool + closed bool stream types.StreamSinkManager streamMu sync.Mutex } +var ErrTrackClosed = errors.New("track is closed") + type trackOption func(*Track) func WithRtcpChan(rtcp chan []rtcp.Packet) trackOption { @@ -64,6 +67,10 @@ func NewTrack(logger zerolog.Logger, codec codec.RTPCodec, connection *webrtc.Pe } func (t *Track) Shutdown() { + t.streamMu.Lock() + t.closed = true + t.streamMu.Unlock() + t.RemoveStream() close(t.sample) } @@ -119,6 +126,13 @@ func (t *Track) SetStream(stream types.StreamSinkManager) (bool, error) { t.streamMu.Lock() defer t.streamMu.Unlock() + // A peer can be destroyed while it is still being set up. A listener added + // after that would never be removed, and its samples would be written to a + // closed channel. + if t.closed { + return false, ErrTrackClosed + } + // if we already listen to the stream, do nothing if t.stream == stream { return false, nil diff --git a/server/internal/webrtc/track_test.go b/server/internal/webrtc/track_test.go new file mode 100644 index 000000000..896b1b237 --- /dev/null +++ b/server/internal/webrtc/track_test.go @@ -0,0 +1,126 @@ +package webrtc + +import ( + "errors" + "sync" + "testing" + + "github.com/pion/webrtc/v3" + "github.com/rs/zerolog" + + "github.com/m1k1o/neko/server/pkg/types" + "github.com/m1k1o/neko/server/pkg/types/codec" +) + +// listenerCountingStream counts its listeners. The embedded interface is nil: +// these tests must not reach any other method. +type listenerCountingStream struct { + types.StreamSinkManager + codec codec.RTPCodec + + 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" } + +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() + + s.added++ + return nil +} + +func (s *listenerCountingStream) RemoveListener(types.SampleListener) error { + s.mu.Lock() + defer s.mu.Unlock() + + s.removed++ + return nil +} + +func (s *listenerCountingStream) listeners() int { + s.mu.Lock() + defer s.mu.Unlock() + + return s.added - s.removed +} + +func newTestTrack(t *testing.T) *Track { + t.Helper() + connection, err := webrtc.NewPeerConnection(webrtc.Configuration{}) + if err != nil { + t.Fatalf("create peer connection: %v", err) + } + t.Cleanup(func() { connection.Close() }) + + track, err := NewTrack(zerolog.Nop(), codec.VP8(), connection) + if err != nil { + t.Fatalf("create track: %v", err) + } + return track +} + +func TestTrackStopsListeningOnShutdown(t *testing.T) { + track := newTestTrack(t) + stream := &listenerCountingStream{} + + if _, err := track.SetStream(stream); err != nil { + t.Fatalf("set stream: %v", err) + } + track.Shutdown() + + if stream.added != 1 || stream.removed != 1 { + t.Errorf("listener added %d times and removed %d times, want 1 and 1", stream.added, stream.removed) + } +} + +// A peer can be destroyed between its creation and the request that selects +// its video. The track is shut down by then; listening to a stream after that +// would keep the pipeline running for a track nobody removes. +func TestTrackDoesNotListenAfterShutdown(t *testing.T) { + track := newTestTrack(t) + stream := &listenerCountingStream{} + + track.Shutdown() + + if _, err := track.SetStream(stream); !errors.Is(err, ErrTrackClosed) { + t.Errorf("set stream after shutdown returned %v, want %v", err, ErrTrackClosed) + } + + if stream.added != 0 { + t.Errorf("listener added %d times after shutdown, want 0", stream.added) + } +} + +// The audio track gets its stream while it is paused, when the peer is +// created, and only listens once it is unpaused. That can come after the peer +// was destroyed. +func TestPausedTrackDoesNotListenAfterShutdown(t *testing.T) { + track := newTestTrack(t) + stream := &listenerCountingStream{} + + track.SetPaused(true) + if _, err := track.SetStream(stream); err != nil { + t.Fatalf("set stream: %v", err) + } + track.Shutdown() + track.SetPaused(false) + + if stream.added != 0 { + t.Errorf("listener added %d times after shutdown, want 0", stream.added) + } +}