Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
74 changes: 66 additions & 8 deletions server/internal/webrtc/manager_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}
18 changes: 17 additions & 1 deletion server/internal/webrtc/peer.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
10 changes: 10 additions & 0 deletions server/internal/webrtc/track_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -20,13 +20,23 @@ 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" }

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()

Expand Down