From e57374dbdb796d896923094f2eab43dfbe2d7fcc Mon Sep 17 00:00:00 2001 From: Paul Wells Date: Wed, 18 Sep 2024 00:12:33 -0700 Subject: [PATCH] add convenience methods to participant --- pkg/rtc/participant.go | 9 ++ pkg/rtc/types/interfaces.go | 3 + .../typesfakes/fake_local_participant.go | 130 ++++++++++++++++++ pkg/rtc/types/typesfakes/fake_participant.go | 130 ++++++++++++++++++ .../types/typesfakes/fake_websocket_client.go | 74 ++++++++++ 5 files changed, 346 insertions(+) diff --git a/pkg/rtc/participant.go b/pkg/rtc/participant.go index a22f0b17f..b6ca978d3 100644 --- a/pkg/rtc/participant.go +++ b/pkg/rtc/participant.go @@ -363,6 +363,11 @@ func (p *ParticipantImpl) IsRecorder() bool { return grants.GetParticipantKind() == livekit.ParticipantInfo_EGRESS || grants.Video.Recorder } +func (p *ParticipantImpl) IsAgent() bool { + grants := p.grants.Load() + return grants.GetParticipantKind() == livekit.ParticipantInfo_AGENT || grants.Video.Agent +} + func (p *ParticipantImpl) IsDependent() bool { grants := p.grants.Load() switch grants.GetParticipantKind() { @@ -608,6 +613,10 @@ func (p *ParticipantImpl) CanSkipBroadcast() bool { return !p.requireBroadcast } +func (p *ParticipantImpl) VersionNumber() uint32 { + return p.version.Load() +} + func (p *ParticipantImpl) ToProtoWithVersion() (*livekit.ParticipantInfo, utils.TimedVersion) { if p.dirty.Load() { p.lock.Lock() diff --git a/pkg/rtc/types/interfaces.go b/pkg/rtc/types/interfaces.go index 31f7196c3..e7e495994 100644 --- a/pkg/rtc/types/interfaces.go +++ b/pkg/rtc/types/interfaces.go @@ -39,6 +39,7 @@ type WebsocketClient interface { ReadMessage() (messageType int, p []byte, err error) WriteMessage(messageType int, data []byte) error WriteControl(messageType int, data []byte, deadline time.Time) error + SetReadDeadline(deadline time.Time) error Close() error } @@ -257,8 +258,10 @@ type Participant interface { Kind() livekit.ParticipantInfo_Kind IsRecorder() bool IsDependent() bool + IsAgent() bool CanSkipBroadcast() bool + VersionNumber() uint32 ToProto() *livekit.ParticipantInfo IsPublisher() bool diff --git a/pkg/rtc/types/typesfakes/fake_local_participant.go b/pkg/rtc/types/typesfakes/fake_local_participant.go index afe375785..a18f0ae39 100644 --- a/pkg/rtc/types/typesfakes/fake_local_participant.go +++ b/pkg/rtc/types/typesfakes/fake_local_participant.go @@ -497,6 +497,16 @@ type FakeLocalParticipant struct { identityReturnsOnCall map[int]struct { result1 livekit.ParticipantIdentity } + IsAgentStub func() bool + isAgentMutex sync.RWMutex + isAgentArgsForCall []struct { + } + isAgentReturns struct { + result1 bool + } + isAgentReturnsOnCall map[int]struct { + result1 bool + } IsClosedStub func() bool isClosedMutex sync.RWMutex isClosedArgsForCall []struct { @@ -1067,6 +1077,16 @@ type FakeLocalParticipant struct { arg1 livekit.ParticipantID arg2 uint32 } + VersionNumberStub func() uint32 + versionNumberMutex sync.RWMutex + versionNumberArgsForCall []struct { + } + versionNumberReturns struct { + result1 uint32 + } + versionNumberReturnsOnCall map[int]struct { + result1 uint32 + } WaitUntilSubscribedStub func(time.Duration) error waitUntilSubscribedMutex sync.RWMutex waitUntilSubscribedArgsForCall []struct { @@ -3603,6 +3623,59 @@ func (fake *FakeLocalParticipant) IdentityReturnsOnCall(i int, result1 livekit.P }{result1} } +func (fake *FakeLocalParticipant) IsAgent() bool { + fake.isAgentMutex.Lock() + ret, specificReturn := fake.isAgentReturnsOnCall[len(fake.isAgentArgsForCall)] + fake.isAgentArgsForCall = append(fake.isAgentArgsForCall, struct { + }{}) + stub := fake.IsAgentStub + fakeReturns := fake.isAgentReturns + fake.recordInvocation("IsAgent", []interface{}{}) + fake.isAgentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) IsAgentCallCount() int { + fake.isAgentMutex.RLock() + defer fake.isAgentMutex.RUnlock() + return len(fake.isAgentArgsForCall) +} + +func (fake *FakeLocalParticipant) IsAgentCalls(stub func() bool) { + fake.isAgentMutex.Lock() + defer fake.isAgentMutex.Unlock() + fake.IsAgentStub = stub +} + +func (fake *FakeLocalParticipant) IsAgentReturns(result1 bool) { + fake.isAgentMutex.Lock() + defer fake.isAgentMutex.Unlock() + fake.IsAgentStub = nil + fake.isAgentReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeLocalParticipant) IsAgentReturnsOnCall(i int, result1 bool) { + fake.isAgentMutex.Lock() + defer fake.isAgentMutex.Unlock() + fake.IsAgentStub = nil + if fake.isAgentReturnsOnCall == nil { + fake.isAgentReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isAgentReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + func (fake *FakeLocalParticipant) IsClosed() bool { fake.isClosedMutex.Lock() ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)] @@ -6783,6 +6856,59 @@ func (fake *FakeLocalParticipant) VerifySubscribeParticipantInfoArgsForCall(i in return argsForCall.arg1, argsForCall.arg2 } +func (fake *FakeLocalParticipant) VersionNumber() uint32 { + fake.versionNumberMutex.Lock() + ret, specificReturn := fake.versionNumberReturnsOnCall[len(fake.versionNumberArgsForCall)] + fake.versionNumberArgsForCall = append(fake.versionNumberArgsForCall, struct { + }{}) + stub := fake.VersionNumberStub + fakeReturns := fake.versionNumberReturns + fake.recordInvocation("VersionNumber", []interface{}{}) + fake.versionNumberMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeLocalParticipant) VersionNumberCallCount() int { + fake.versionNumberMutex.RLock() + defer fake.versionNumberMutex.RUnlock() + return len(fake.versionNumberArgsForCall) +} + +func (fake *FakeLocalParticipant) VersionNumberCalls(stub func() uint32) { + fake.versionNumberMutex.Lock() + defer fake.versionNumberMutex.Unlock() + fake.VersionNumberStub = stub +} + +func (fake *FakeLocalParticipant) VersionNumberReturns(result1 uint32) { + fake.versionNumberMutex.Lock() + defer fake.versionNumberMutex.Unlock() + fake.VersionNumberStub = nil + fake.versionNumberReturns = struct { + result1 uint32 + }{result1} +} + +func (fake *FakeLocalParticipant) VersionNumberReturnsOnCall(i int, result1 uint32) { + fake.versionNumberMutex.Lock() + defer fake.versionNumberMutex.Unlock() + fake.VersionNumberStub = nil + if fake.versionNumberReturnsOnCall == nil { + fake.versionNumberReturnsOnCall = make(map[int]struct { + result1 uint32 + }) + } + fake.versionNumberReturnsOnCall[i] = struct { + result1 uint32 + }{result1} +} + func (fake *FakeLocalParticipant) WaitUntilSubscribed(arg1 time.Duration) error { fake.waitUntilSubscribedMutex.Lock() ret, specificReturn := fake.waitUntilSubscribedReturnsOnCall[len(fake.waitUntilSubscribedArgsForCall)] @@ -7011,6 +7137,8 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.iDMutex.RUnlock() fake.identityMutex.RLock() defer fake.identityMutex.RUnlock() + fake.isAgentMutex.RLock() + defer fake.isAgentMutex.RUnlock() fake.isClosedMutex.RLock() defer fake.isClosedMutex.RUnlock() fake.isDependentMutex.RLock() @@ -7151,6 +7279,8 @@ func (fake *FakeLocalParticipant) Invocations() map[string][][]interface{} { defer fake.updateVideoTrackMutex.RUnlock() fake.verifySubscribeParticipantInfoMutex.RLock() defer fake.verifySubscribeParticipantInfoMutex.RUnlock() + fake.versionNumberMutex.RLock() + defer fake.versionNumberMutex.RUnlock() fake.waitUntilSubscribedMutex.RLock() defer fake.waitUntilSubscribedMutex.RUnlock() fake.writeSubscriberRTCPMutex.RLock() diff --git a/pkg/rtc/types/typesfakes/fake_participant.go b/pkg/rtc/types/typesfakes/fake_participant.go index 52b1a1096..b76fb0a68 100644 --- a/pkg/rtc/types/typesfakes/fake_participant.go +++ b/pkg/rtc/types/typesfakes/fake_participant.go @@ -128,6 +128,16 @@ type FakeParticipant struct { identityReturnsOnCall map[int]struct { result1 livekit.ParticipantIdentity } + IsAgentStub func() bool + isAgentMutex sync.RWMutex + isAgentArgsForCall []struct { + } + isAgentReturns struct { + result1 bool + } + isAgentReturnsOnCall map[int]struct { + result1 bool + } IsDependentStub func() bool isDependentMutex sync.RWMutex isDependentArgsForCall []struct { @@ -220,6 +230,16 @@ type FakeParticipant struct { updateSubscriptionPermissionReturnsOnCall map[int]struct { result1 error } + VersionNumberStub func() uint32 + versionNumberMutex sync.RWMutex + versionNumberArgsForCall []struct { + } + versionNumberReturns struct { + result1 uint32 + } + versionNumberReturnsOnCall map[int]struct { + result1 uint32 + } invocations map[string][][]interface{} invocationsMutex sync.RWMutex } @@ -837,6 +857,59 @@ func (fake *FakeParticipant) IdentityReturnsOnCall(i int, result1 livekit.Partic }{result1} } +func (fake *FakeParticipant) IsAgent() bool { + fake.isAgentMutex.Lock() + ret, specificReturn := fake.isAgentReturnsOnCall[len(fake.isAgentArgsForCall)] + fake.isAgentArgsForCall = append(fake.isAgentArgsForCall, struct { + }{}) + stub := fake.IsAgentStub + fakeReturns := fake.isAgentReturns + fake.recordInvocation("IsAgent", []interface{}{}) + fake.isAgentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeParticipant) IsAgentCallCount() int { + fake.isAgentMutex.RLock() + defer fake.isAgentMutex.RUnlock() + return len(fake.isAgentArgsForCall) +} + +func (fake *FakeParticipant) IsAgentCalls(stub func() bool) { + fake.isAgentMutex.Lock() + defer fake.isAgentMutex.Unlock() + fake.IsAgentStub = stub +} + +func (fake *FakeParticipant) IsAgentReturns(result1 bool) { + fake.isAgentMutex.Lock() + defer fake.isAgentMutex.Unlock() + fake.IsAgentStub = nil + fake.isAgentReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeParticipant) IsAgentReturnsOnCall(i int, result1 bool) { + fake.isAgentMutex.Lock() + defer fake.isAgentMutex.Unlock() + fake.IsAgentStub = nil + if fake.isAgentReturnsOnCall == nil { + fake.isAgentReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isAgentReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + func (fake *FakeParticipant) IsDependent() bool { fake.isDependentMutex.Lock() ret, specificReturn := fake.isDependentReturnsOnCall[len(fake.isDependentArgsForCall)] @@ -1308,6 +1381,59 @@ func (fake *FakeParticipant) UpdateSubscriptionPermissionReturnsOnCall(i int, re }{result1} } +func (fake *FakeParticipant) VersionNumber() uint32 { + fake.versionNumberMutex.Lock() + ret, specificReturn := fake.versionNumberReturnsOnCall[len(fake.versionNumberArgsForCall)] + fake.versionNumberArgsForCall = append(fake.versionNumberArgsForCall, struct { + }{}) + stub := fake.VersionNumberStub + fakeReturns := fake.versionNumberReturns + fake.recordInvocation("VersionNumber", []interface{}{}) + fake.versionNumberMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeParticipant) VersionNumberCallCount() int { + fake.versionNumberMutex.RLock() + defer fake.versionNumberMutex.RUnlock() + return len(fake.versionNumberArgsForCall) +} + +func (fake *FakeParticipant) VersionNumberCalls(stub func() uint32) { + fake.versionNumberMutex.Lock() + defer fake.versionNumberMutex.Unlock() + fake.VersionNumberStub = stub +} + +func (fake *FakeParticipant) VersionNumberReturns(result1 uint32) { + fake.versionNumberMutex.Lock() + defer fake.versionNumberMutex.Unlock() + fake.VersionNumberStub = nil + fake.versionNumberReturns = struct { + result1 uint32 + }{result1} +} + +func (fake *FakeParticipant) VersionNumberReturnsOnCall(i int, result1 uint32) { + fake.versionNumberMutex.Lock() + defer fake.versionNumberMutex.Unlock() + fake.VersionNumberStub = nil + if fake.versionNumberReturnsOnCall == nil { + fake.versionNumberReturnsOnCall = make(map[int]struct { + result1 uint32 + }) + } + fake.versionNumberReturnsOnCall[i] = struct { + result1 uint32 + }{result1} +} + func (fake *FakeParticipant) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() @@ -1333,6 +1459,8 @@ func (fake *FakeParticipant) Invocations() map[string][][]interface{} { defer fake.iDMutex.RUnlock() fake.identityMutex.RLock() defer fake.identityMutex.RUnlock() + fake.isAgentMutex.RLock() + defer fake.isAgentMutex.RUnlock() fake.isDependentMutex.RLock() defer fake.isDependentMutex.RUnlock() fake.isPublisherMutex.RLock() @@ -1351,6 +1479,8 @@ func (fake *FakeParticipant) Invocations() map[string][][]interface{} { defer fake.toProtoMutex.RUnlock() fake.updateSubscriptionPermissionMutex.RLock() defer fake.updateSubscriptionPermissionMutex.RUnlock() + fake.versionNumberMutex.RLock() + defer fake.versionNumberMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/pkg/rtc/types/typesfakes/fake_websocket_client.go b/pkg/rtc/types/typesfakes/fake_websocket_client.go index 0a9c14b7f..93d0957ad 100644 --- a/pkg/rtc/types/typesfakes/fake_websocket_client.go +++ b/pkg/rtc/types/typesfakes/fake_websocket_client.go @@ -33,6 +33,17 @@ type FakeWebsocketClient struct { result2 []byte result3 error } + SetReadDeadlineStub func(time.Time) error + setReadDeadlineMutex sync.RWMutex + setReadDeadlineArgsForCall []struct { + arg1 time.Time + } + setReadDeadlineReturns struct { + result1 error + } + setReadDeadlineReturnsOnCall map[int]struct { + result1 error + } WriteControlStub func(int, []byte, time.Time) error writeControlMutex sync.RWMutex writeControlArgsForCall []struct { @@ -174,6 +185,67 @@ func (fake *FakeWebsocketClient) ReadMessageReturnsOnCall(i int, result1 int, re }{result1, result2, result3} } +func (fake *FakeWebsocketClient) SetReadDeadline(arg1 time.Time) error { + fake.setReadDeadlineMutex.Lock() + ret, specificReturn := fake.setReadDeadlineReturnsOnCall[len(fake.setReadDeadlineArgsForCall)] + fake.setReadDeadlineArgsForCall = append(fake.setReadDeadlineArgsForCall, struct { + arg1 time.Time + }{arg1}) + stub := fake.SetReadDeadlineStub + fakeReturns := fake.setReadDeadlineReturns + fake.recordInvocation("SetReadDeadline", []interface{}{arg1}) + fake.setReadDeadlineMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeWebsocketClient) SetReadDeadlineCallCount() int { + fake.setReadDeadlineMutex.RLock() + defer fake.setReadDeadlineMutex.RUnlock() + return len(fake.setReadDeadlineArgsForCall) +} + +func (fake *FakeWebsocketClient) SetReadDeadlineCalls(stub func(time.Time) error) { + fake.setReadDeadlineMutex.Lock() + defer fake.setReadDeadlineMutex.Unlock() + fake.SetReadDeadlineStub = stub +} + +func (fake *FakeWebsocketClient) SetReadDeadlineArgsForCall(i int) time.Time { + fake.setReadDeadlineMutex.RLock() + defer fake.setReadDeadlineMutex.RUnlock() + argsForCall := fake.setReadDeadlineArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeWebsocketClient) SetReadDeadlineReturns(result1 error) { + fake.setReadDeadlineMutex.Lock() + defer fake.setReadDeadlineMutex.Unlock() + fake.SetReadDeadlineStub = nil + fake.setReadDeadlineReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeWebsocketClient) SetReadDeadlineReturnsOnCall(i int, result1 error) { + fake.setReadDeadlineMutex.Lock() + defer fake.setReadDeadlineMutex.Unlock() + fake.SetReadDeadlineStub = nil + if fake.setReadDeadlineReturnsOnCall == nil { + fake.setReadDeadlineReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setReadDeadlineReturnsOnCall[i] = struct { + result1 error + }{result1} +} + func (fake *FakeWebsocketClient) WriteControl(arg1 int, arg2 []byte, arg3 time.Time) error { var arg2Copy []byte if arg2 != nil { @@ -316,6 +388,8 @@ func (fake *FakeWebsocketClient) Invocations() map[string][][]interface{} { defer fake.closeMutex.RUnlock() fake.readMessageMutex.RLock() defer fake.readMessageMutex.RUnlock() + fake.setReadDeadlineMutex.RLock() + defer fake.setReadDeadlineMutex.RUnlock() fake.writeControlMutex.RLock() defer fake.writeControlMutex.RUnlock() fake.writeMessageMutex.RLock()