diff --git a/go.sum b/go.sum index 6e3355005..94987a22a 100644 --- a/go.sum +++ b/go.sum @@ -235,8 +235,6 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/lithammer/shortuuid/v3 v3.0.7 h1:trX0KTHy4Pbwo/6ia8fscyHoGA+mf1jWbPJVuvyJQQ8= github.com/lithammer/shortuuid/v3 v3.0.7/go.mod h1:vMk8ke37EmiewwolSO1NLW8vP4ZaKlRuDIi8tWWmAts= -github.com/livekit/protocol v0.13.5-0.20220726184153-ad9c55ddef52 h1:E0trQ3RLu2b9hjSiJG1+1hyK/8v57NPJznA7/lKj0qY= -github.com/livekit/protocol v0.13.5-0.20220726184153-ad9c55ddef52/go.mod h1:Qd/Dn4BkJfZQy/IjtEeUOGXARrR7l09WDkg5SY8thkw= github.com/livekit/protocol v0.13.5-0.20220727215941-ac26418a52e9 h1:e12j1EyiiTG56Ag44fwpVtnYQ6MVgLv4bYYI0nTgxZY= github.com/livekit/protocol v0.13.5-0.20220727215941-ac26418a52e9/go.mod h1:Qd/Dn4BkJfZQy/IjtEeUOGXARrR7l09WDkg5SY8thkw= github.com/livekit/rtcscore-go v0.0.0-20220524203225-dfd1ba40744a h1:cENjhGfslLSDV07gt8ASy47Wd12Q0kBS7hsdunyQ62I= diff --git a/pkg/service/egress.go b/pkg/service/egress.go index 35b030864..8be5bd220 100644 --- a/pkg/service/egress.go +++ b/pkg/service/egress.go @@ -17,6 +17,7 @@ import ( type EgressService struct { rpcClient egress.RPCClient store ServiceStore + es EgressStore roomService livekit.RoomService telemetry telemetry.TelemetryService shutdown chan struct{} @@ -25,6 +26,7 @@ type EgressService struct { func NewEgressService( rpcClient egress.RPCClient, store ServiceStore, + es EgressStore, rs livekit.RoomService, ts telemetry.TelemetryService, ) *EgressService { @@ -32,6 +34,7 @@ func NewEgressService( return &EgressService{ rpcClient: rpcClient, store: store, + es: es, roomService: rs, telemetry: ts, shutdown: make(chan struct{}), @@ -93,7 +96,7 @@ func (s *EgressService) StartEgress(ctx context.Context, roomName livekit.RoomNa s.telemetry.EgressStarted(ctx, info) go func() { - if err := s.store.StoreEgress(ctx, info); err != nil { + if err := s.es.StoreEgress(ctx, info); err != nil { logger.Errorw("could not write egress info", err) } }() @@ -113,7 +116,7 @@ func (s *EgressService) UpdateLayout(ctx context.Context, req *livekit.UpdateLay return nil, ErrEgressNotConnected } - info, err := s.store.LoadEgress(ctx, req.EgressId) + info, err := s.es.LoadEgress(ctx, req.EgressId) if err != nil { return nil, err } @@ -170,7 +173,7 @@ func (s *EgressService) UpdateStream(ctx context.Context, req *livekit.UpdateStr } go func() { - if err := s.store.UpdateEgress(ctx, info); err != nil { + if err := s.es.UpdateEgress(ctx, info); err != nil { logger.Errorw("could not write egress info", err) } }() @@ -198,7 +201,7 @@ func (s *EgressService) ListEgress(ctx context.Context, req *livekit.ListEgressR roomID = livekit.RoomID(room.Sid) } - infos, err := s.store.ListEgress(ctx, roomID) + infos, err := s.es.ListEgress(ctx, roomID) if err != nil { return nil, err } @@ -225,7 +228,7 @@ func (s *EgressService) StopEgress(ctx context.Context, req *livekit.StopEgressR } go func() { - if err := s.store.UpdateEgress(ctx, info); err != nil { + if err := s.es.UpdateEgress(ctx, info); err != nil { logger.Errorw("could not write egress info", err) } }() @@ -257,7 +260,7 @@ func (s *EgressService) updateWorker() { livekit.EgressStatus_EGRESS_ENDING: // save updated info to store - err = s.store.UpdateEgress(context.Background(), res) + err = s.es.UpdateEgress(context.Background(), res) if err != nil { logger.Errorw("could not update egress", err) } @@ -267,7 +270,7 @@ func (s *EgressService) updateWorker() { livekit.EgressStatus_EGRESS_ABORTED: // delete from store - err = s.store.DeleteEgress(context.Background(), res) + err = s.es.DeleteEgress(context.Background(), res) if err != nil { logger.Errorw("could not delete egress from store", err) } diff --git a/pkg/service/ingress.go b/pkg/service/ingress.go index fc3db4244..7e0c007e6 100644 --- a/pkg/service/ingress.go +++ b/pkg/service/ingress.go @@ -14,7 +14,7 @@ import ( type IngressService struct { rpc ingress.RPC - store ServiceStore + store IngressStore roomService livekit.RoomService telemetry telemetry.TelemetryService shutdown chan struct{} @@ -22,7 +22,7 @@ type IngressService struct { func NewIngressService( rpc ingress.RPC, - store ServiceStore, + store IngressStore, rs livekit.RoomService, ts telemetry.TelemetryService, ) *IngressService { diff --git a/pkg/service/interfaces.go b/pkg/service/interfaces.go index 9beedf7fc..efbf3c804 100644 --- a/pkg/service/interfaces.go +++ b/pkg/service/interfaces.go @@ -35,13 +35,19 @@ type ServiceStore interface { LoadParticipant(ctx context.Context, roomName livekit.RoomName, identity livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error) ListParticipants(ctx context.Context, roomName livekit.RoomName) ([]*livekit.ParticipantInfo, error) +} +//counterfeiter:generate . EgressStore +type EgressStore interface { StoreEgress(ctx context.Context, info *livekit.EgressInfo) error LoadEgress(ctx context.Context, egressID string) (*livekit.EgressInfo, error) ListEgress(ctx context.Context, roomID livekit.RoomID) ([]*livekit.EgressInfo, error) UpdateEgress(ctx context.Context, info *livekit.EgressInfo) error DeleteEgress(ctx context.Context, info *livekit.EgressInfo) error +} +//counterfeiter:generate . IngressStore +type IngressStore interface { StoreIngress(ctx context.Context, info *livekit.IngressInfo) error LoadIngress(ctx context.Context, ingressID string) (*livekit.IngressInfo, error) LoadIngressFromStreamKey(ctx context.Context, streamKey string) (*livekit.IngressInfo, error) diff --git a/pkg/service/servicefakes/fake_egress_store.go b/pkg/service/servicefakes/fake_egress_store.go new file mode 100644 index 000000000..ee05a5649 --- /dev/null +++ b/pkg/service/servicefakes/fake_egress_store.go @@ -0,0 +1,429 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package servicefakes + +import ( + "context" + "sync" + + "github.com/livekit/livekit-server/pkg/service" + "github.com/livekit/protocol/livekit" +) + +type FakeEgressStore struct { + DeleteEgressStub func(context.Context, *livekit.EgressInfo) error + deleteEgressMutex sync.RWMutex + deleteEgressArgsForCall []struct { + arg1 context.Context + arg2 *livekit.EgressInfo + } + deleteEgressReturns struct { + result1 error + } + deleteEgressReturnsOnCall map[int]struct { + result1 error + } + ListEgressStub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error) + listEgressMutex sync.RWMutex + listEgressArgsForCall []struct { + arg1 context.Context + arg2 livekit.RoomID + } + listEgressReturns struct { + result1 []*livekit.EgressInfo + result2 error + } + listEgressReturnsOnCall map[int]struct { + result1 []*livekit.EgressInfo + result2 error + } + LoadEgressStub func(context.Context, string) (*livekit.EgressInfo, error) + loadEgressMutex sync.RWMutex + loadEgressArgsForCall []struct { + arg1 context.Context + arg2 string + } + loadEgressReturns struct { + result1 *livekit.EgressInfo + result2 error + } + loadEgressReturnsOnCall map[int]struct { + result1 *livekit.EgressInfo + result2 error + } + StoreEgressStub func(context.Context, *livekit.EgressInfo) error + storeEgressMutex sync.RWMutex + storeEgressArgsForCall []struct { + arg1 context.Context + arg2 *livekit.EgressInfo + } + storeEgressReturns struct { + result1 error + } + storeEgressReturnsOnCall map[int]struct { + result1 error + } + UpdateEgressStub func(context.Context, *livekit.EgressInfo) error + updateEgressMutex sync.RWMutex + updateEgressArgsForCall []struct { + arg1 context.Context + arg2 *livekit.EgressInfo + } + updateEgressReturns struct { + result1 error + } + updateEgressReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeEgressStore) DeleteEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { + fake.deleteEgressMutex.Lock() + ret, specificReturn := fake.deleteEgressReturnsOnCall[len(fake.deleteEgressArgsForCall)] + fake.deleteEgressArgsForCall = append(fake.deleteEgressArgsForCall, struct { + arg1 context.Context + arg2 *livekit.EgressInfo + }{arg1, arg2}) + stub := fake.DeleteEgressStub + fakeReturns := fake.deleteEgressReturns + fake.recordInvocation("DeleteEgress", []interface{}{arg1, arg2}) + fake.deleteEgressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEgressStore) DeleteEgressCallCount() int { + fake.deleteEgressMutex.RLock() + defer fake.deleteEgressMutex.RUnlock() + return len(fake.deleteEgressArgsForCall) +} + +func (fake *FakeEgressStore) DeleteEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { + fake.deleteEgressMutex.Lock() + defer fake.deleteEgressMutex.Unlock() + fake.DeleteEgressStub = stub +} + +func (fake *FakeEgressStore) DeleteEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { + fake.deleteEgressMutex.RLock() + defer fake.deleteEgressMutex.RUnlock() + argsForCall := fake.deleteEgressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeEgressStore) DeleteEgressReturns(result1 error) { + fake.deleteEgressMutex.Lock() + defer fake.deleteEgressMutex.Unlock() + fake.DeleteEgressStub = nil + fake.deleteEgressReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeEgressStore) DeleteEgressReturnsOnCall(i int, result1 error) { + fake.deleteEgressMutex.Lock() + defer fake.deleteEgressMutex.Unlock() + fake.DeleteEgressStub = nil + if fake.deleteEgressReturnsOnCall == nil { + fake.deleteEgressReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteEgressReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeEgressStore) ListEgress(arg1 context.Context, arg2 livekit.RoomID) ([]*livekit.EgressInfo, error) { + fake.listEgressMutex.Lock() + ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)] + fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct { + arg1 context.Context + arg2 livekit.RoomID + }{arg1, arg2}) + stub := fake.ListEgressStub + fakeReturns := fake.listEgressReturns + fake.recordInvocation("ListEgress", []interface{}{arg1, arg2}) + fake.listEgressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeEgressStore) ListEgressCallCount() int { + fake.listEgressMutex.RLock() + defer fake.listEgressMutex.RUnlock() + return len(fake.listEgressArgsForCall) +} + +func (fake *FakeEgressStore) ListEgressCalls(stub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)) { + fake.listEgressMutex.Lock() + defer fake.listEgressMutex.Unlock() + fake.ListEgressStub = stub +} + +func (fake *FakeEgressStore) ListEgressArgsForCall(i int) (context.Context, livekit.RoomID) { + fake.listEgressMutex.RLock() + defer fake.listEgressMutex.RUnlock() + argsForCall := fake.listEgressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeEgressStore) ListEgressReturns(result1 []*livekit.EgressInfo, result2 error) { + fake.listEgressMutex.Lock() + defer fake.listEgressMutex.Unlock() + fake.ListEgressStub = nil + fake.listEgressReturns = struct { + result1 []*livekit.EgressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeEgressStore) ListEgressReturnsOnCall(i int, result1 []*livekit.EgressInfo, result2 error) { + fake.listEgressMutex.Lock() + defer fake.listEgressMutex.Unlock() + fake.ListEgressStub = nil + if fake.listEgressReturnsOnCall == nil { + fake.listEgressReturnsOnCall = make(map[int]struct { + result1 []*livekit.EgressInfo + result2 error + }) + } + fake.listEgressReturnsOnCall[i] = struct { + result1 []*livekit.EgressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeEgressStore) LoadEgress(arg1 context.Context, arg2 string) (*livekit.EgressInfo, error) { + fake.loadEgressMutex.Lock() + ret, specificReturn := fake.loadEgressReturnsOnCall[len(fake.loadEgressArgsForCall)] + fake.loadEgressArgsForCall = append(fake.loadEgressArgsForCall, struct { + arg1 context.Context + arg2 string + }{arg1, arg2}) + stub := fake.LoadEgressStub + fakeReturns := fake.loadEgressReturns + fake.recordInvocation("LoadEgress", []interface{}{arg1, arg2}) + fake.loadEgressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeEgressStore) LoadEgressCallCount() int { + fake.loadEgressMutex.RLock() + defer fake.loadEgressMutex.RUnlock() + return len(fake.loadEgressArgsForCall) +} + +func (fake *FakeEgressStore) LoadEgressCalls(stub func(context.Context, string) (*livekit.EgressInfo, error)) { + fake.loadEgressMutex.Lock() + defer fake.loadEgressMutex.Unlock() + fake.LoadEgressStub = stub +} + +func (fake *FakeEgressStore) LoadEgressArgsForCall(i int) (context.Context, string) { + fake.loadEgressMutex.RLock() + defer fake.loadEgressMutex.RUnlock() + argsForCall := fake.loadEgressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeEgressStore) LoadEgressReturns(result1 *livekit.EgressInfo, result2 error) { + fake.loadEgressMutex.Lock() + defer fake.loadEgressMutex.Unlock() + fake.LoadEgressStub = nil + fake.loadEgressReturns = struct { + result1 *livekit.EgressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeEgressStore) LoadEgressReturnsOnCall(i int, result1 *livekit.EgressInfo, result2 error) { + fake.loadEgressMutex.Lock() + defer fake.loadEgressMutex.Unlock() + fake.LoadEgressStub = nil + if fake.loadEgressReturnsOnCall == nil { + fake.loadEgressReturnsOnCall = make(map[int]struct { + result1 *livekit.EgressInfo + result2 error + }) + } + fake.loadEgressReturnsOnCall[i] = struct { + result1 *livekit.EgressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeEgressStore) StoreEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { + fake.storeEgressMutex.Lock() + ret, specificReturn := fake.storeEgressReturnsOnCall[len(fake.storeEgressArgsForCall)] + fake.storeEgressArgsForCall = append(fake.storeEgressArgsForCall, struct { + arg1 context.Context + arg2 *livekit.EgressInfo + }{arg1, arg2}) + stub := fake.StoreEgressStub + fakeReturns := fake.storeEgressReturns + fake.recordInvocation("StoreEgress", []interface{}{arg1, arg2}) + fake.storeEgressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEgressStore) StoreEgressCallCount() int { + fake.storeEgressMutex.RLock() + defer fake.storeEgressMutex.RUnlock() + return len(fake.storeEgressArgsForCall) +} + +func (fake *FakeEgressStore) StoreEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { + fake.storeEgressMutex.Lock() + defer fake.storeEgressMutex.Unlock() + fake.StoreEgressStub = stub +} + +func (fake *FakeEgressStore) StoreEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { + fake.storeEgressMutex.RLock() + defer fake.storeEgressMutex.RUnlock() + argsForCall := fake.storeEgressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeEgressStore) StoreEgressReturns(result1 error) { + fake.storeEgressMutex.Lock() + defer fake.storeEgressMutex.Unlock() + fake.StoreEgressStub = nil + fake.storeEgressReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeEgressStore) StoreEgressReturnsOnCall(i int, result1 error) { + fake.storeEgressMutex.Lock() + defer fake.storeEgressMutex.Unlock() + fake.StoreEgressStub = nil + if fake.storeEgressReturnsOnCall == nil { + fake.storeEgressReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.storeEgressReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeEgressStore) UpdateEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { + fake.updateEgressMutex.Lock() + ret, specificReturn := fake.updateEgressReturnsOnCall[len(fake.updateEgressArgsForCall)] + fake.updateEgressArgsForCall = append(fake.updateEgressArgsForCall, struct { + arg1 context.Context + arg2 *livekit.EgressInfo + }{arg1, arg2}) + stub := fake.UpdateEgressStub + fakeReturns := fake.updateEgressReturns + fake.recordInvocation("UpdateEgress", []interface{}{arg1, arg2}) + fake.updateEgressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEgressStore) UpdateEgressCallCount() int { + fake.updateEgressMutex.RLock() + defer fake.updateEgressMutex.RUnlock() + return len(fake.updateEgressArgsForCall) +} + +func (fake *FakeEgressStore) UpdateEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { + fake.updateEgressMutex.Lock() + defer fake.updateEgressMutex.Unlock() + fake.UpdateEgressStub = stub +} + +func (fake *FakeEgressStore) UpdateEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { + fake.updateEgressMutex.RLock() + defer fake.updateEgressMutex.RUnlock() + argsForCall := fake.updateEgressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeEgressStore) UpdateEgressReturns(result1 error) { + fake.updateEgressMutex.Lock() + defer fake.updateEgressMutex.Unlock() + fake.UpdateEgressStub = nil + fake.updateEgressReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeEgressStore) UpdateEgressReturnsOnCall(i int, result1 error) { + fake.updateEgressMutex.Lock() + defer fake.updateEgressMutex.Unlock() + fake.UpdateEgressStub = nil + if fake.updateEgressReturnsOnCall == nil { + fake.updateEgressReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateEgressReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeEgressStore) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.deleteEgressMutex.RLock() + defer fake.deleteEgressMutex.RUnlock() + fake.listEgressMutex.RLock() + defer fake.listEgressMutex.RUnlock() + fake.loadEgressMutex.RLock() + defer fake.loadEgressMutex.RUnlock() + fake.storeEgressMutex.RLock() + defer fake.storeEgressMutex.RUnlock() + fake.updateEgressMutex.RLock() + defer fake.updateEgressMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeEgressStore) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ service.EgressStore = new(FakeEgressStore) diff --git a/pkg/service/servicefakes/fake_ingress_store.go b/pkg/service/servicefakes/fake_ingress_store.go new file mode 100644 index 000000000..542d92e90 --- /dev/null +++ b/pkg/service/servicefakes/fake_ingress_store.go @@ -0,0 +1,510 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package servicefakes + +import ( + "context" + "sync" + + "github.com/livekit/livekit-server/pkg/service" + "github.com/livekit/protocol/livekit" +) + +type FakeIngressStore struct { + DeleteIngressStub func(context.Context, *livekit.IngressInfo) error + deleteIngressMutex sync.RWMutex + deleteIngressArgsForCall []struct { + arg1 context.Context + arg2 *livekit.IngressInfo + } + deleteIngressReturns struct { + result1 error + } + deleteIngressReturnsOnCall map[int]struct { + result1 error + } + ListIngressStub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error) + listIngressMutex sync.RWMutex + listIngressArgsForCall []struct { + arg1 context.Context + arg2 livekit.RoomName + } + listIngressReturns struct { + result1 []*livekit.IngressInfo + result2 error + } + listIngressReturnsOnCall map[int]struct { + result1 []*livekit.IngressInfo + result2 error + } + LoadIngressStub func(context.Context, string) (*livekit.IngressInfo, error) + loadIngressMutex sync.RWMutex + loadIngressArgsForCall []struct { + arg1 context.Context + arg2 string + } + loadIngressReturns struct { + result1 *livekit.IngressInfo + result2 error + } + loadIngressReturnsOnCall map[int]struct { + result1 *livekit.IngressInfo + result2 error + } + LoadIngressFromStreamKeyStub func(context.Context, string) (*livekit.IngressInfo, error) + loadIngressFromStreamKeyMutex sync.RWMutex + loadIngressFromStreamKeyArgsForCall []struct { + arg1 context.Context + arg2 string + } + loadIngressFromStreamKeyReturns struct { + result1 *livekit.IngressInfo + result2 error + } + loadIngressFromStreamKeyReturnsOnCall map[int]struct { + result1 *livekit.IngressInfo + result2 error + } + StoreIngressStub func(context.Context, *livekit.IngressInfo) error + storeIngressMutex sync.RWMutex + storeIngressArgsForCall []struct { + arg1 context.Context + arg2 *livekit.IngressInfo + } + storeIngressReturns struct { + result1 error + } + storeIngressReturnsOnCall map[int]struct { + result1 error + } + UpdateIngressStub func(context.Context, *livekit.IngressInfo) error + updateIngressMutex sync.RWMutex + updateIngressArgsForCall []struct { + arg1 context.Context + arg2 *livekit.IngressInfo + } + updateIngressReturns struct { + result1 error + } + updateIngressReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeIngressStore) DeleteIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { + fake.deleteIngressMutex.Lock() + ret, specificReturn := fake.deleteIngressReturnsOnCall[len(fake.deleteIngressArgsForCall)] + fake.deleteIngressArgsForCall = append(fake.deleteIngressArgsForCall, struct { + arg1 context.Context + arg2 *livekit.IngressInfo + }{arg1, arg2}) + stub := fake.DeleteIngressStub + fakeReturns := fake.deleteIngressReturns + fake.recordInvocation("DeleteIngress", []interface{}{arg1, arg2}) + fake.deleteIngressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeIngressStore) DeleteIngressCallCount() int { + fake.deleteIngressMutex.RLock() + defer fake.deleteIngressMutex.RUnlock() + return len(fake.deleteIngressArgsForCall) +} + +func (fake *FakeIngressStore) DeleteIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { + fake.deleteIngressMutex.Lock() + defer fake.deleteIngressMutex.Unlock() + fake.DeleteIngressStub = stub +} + +func (fake *FakeIngressStore) DeleteIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { + fake.deleteIngressMutex.RLock() + defer fake.deleteIngressMutex.RUnlock() + argsForCall := fake.deleteIngressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeIngressStore) DeleteIngressReturns(result1 error) { + fake.deleteIngressMutex.Lock() + defer fake.deleteIngressMutex.Unlock() + fake.DeleteIngressStub = nil + fake.deleteIngressReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeIngressStore) DeleteIngressReturnsOnCall(i int, result1 error) { + fake.deleteIngressMutex.Lock() + defer fake.deleteIngressMutex.Unlock() + fake.DeleteIngressStub = nil + if fake.deleteIngressReturnsOnCall == nil { + fake.deleteIngressReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteIngressReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeIngressStore) ListIngress(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.IngressInfo, error) { + fake.listIngressMutex.Lock() + ret, specificReturn := fake.listIngressReturnsOnCall[len(fake.listIngressArgsForCall)] + fake.listIngressArgsForCall = append(fake.listIngressArgsForCall, struct { + arg1 context.Context + arg2 livekit.RoomName + }{arg1, arg2}) + stub := fake.ListIngressStub + fakeReturns := fake.listIngressReturns + fake.recordInvocation("ListIngress", []interface{}{arg1, arg2}) + fake.listIngressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeIngressStore) ListIngressCallCount() int { + fake.listIngressMutex.RLock() + defer fake.listIngressMutex.RUnlock() + return len(fake.listIngressArgsForCall) +} + +func (fake *FakeIngressStore) ListIngressCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)) { + fake.listIngressMutex.Lock() + defer fake.listIngressMutex.Unlock() + fake.ListIngressStub = stub +} + +func (fake *FakeIngressStore) ListIngressArgsForCall(i int) (context.Context, livekit.RoomName) { + fake.listIngressMutex.RLock() + defer fake.listIngressMutex.RUnlock() + argsForCall := fake.listIngressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeIngressStore) ListIngressReturns(result1 []*livekit.IngressInfo, result2 error) { + fake.listIngressMutex.Lock() + defer fake.listIngressMutex.Unlock() + fake.ListIngressStub = nil + fake.listIngressReturns = struct { + result1 []*livekit.IngressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeIngressStore) ListIngressReturnsOnCall(i int, result1 []*livekit.IngressInfo, result2 error) { + fake.listIngressMutex.Lock() + defer fake.listIngressMutex.Unlock() + fake.ListIngressStub = nil + if fake.listIngressReturnsOnCall == nil { + fake.listIngressReturnsOnCall = make(map[int]struct { + result1 []*livekit.IngressInfo + result2 error + }) + } + fake.listIngressReturnsOnCall[i] = struct { + result1 []*livekit.IngressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeIngressStore) LoadIngress(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) { + fake.loadIngressMutex.Lock() + ret, specificReturn := fake.loadIngressReturnsOnCall[len(fake.loadIngressArgsForCall)] + fake.loadIngressArgsForCall = append(fake.loadIngressArgsForCall, struct { + arg1 context.Context + arg2 string + }{arg1, arg2}) + stub := fake.LoadIngressStub + fakeReturns := fake.loadIngressReturns + fake.recordInvocation("LoadIngress", []interface{}{arg1, arg2}) + fake.loadIngressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeIngressStore) LoadIngressCallCount() int { + fake.loadIngressMutex.RLock() + defer fake.loadIngressMutex.RUnlock() + return len(fake.loadIngressArgsForCall) +} + +func (fake *FakeIngressStore) LoadIngressCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) { + fake.loadIngressMutex.Lock() + defer fake.loadIngressMutex.Unlock() + fake.LoadIngressStub = stub +} + +func (fake *FakeIngressStore) LoadIngressArgsForCall(i int) (context.Context, string) { + fake.loadIngressMutex.RLock() + defer fake.loadIngressMutex.RUnlock() + argsForCall := fake.loadIngressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeIngressStore) LoadIngressReturns(result1 *livekit.IngressInfo, result2 error) { + fake.loadIngressMutex.Lock() + defer fake.loadIngressMutex.Unlock() + fake.LoadIngressStub = nil + fake.loadIngressReturns = struct { + result1 *livekit.IngressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeIngressStore) LoadIngressReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) { + fake.loadIngressMutex.Lock() + defer fake.loadIngressMutex.Unlock() + fake.LoadIngressStub = nil + if fake.loadIngressReturnsOnCall == nil { + fake.loadIngressReturnsOnCall = make(map[int]struct { + result1 *livekit.IngressInfo + result2 error + }) + } + fake.loadIngressReturnsOnCall[i] = struct { + result1 *livekit.IngressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeIngressStore) LoadIngressFromStreamKey(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) { + fake.loadIngressFromStreamKeyMutex.Lock() + ret, specificReturn := fake.loadIngressFromStreamKeyReturnsOnCall[len(fake.loadIngressFromStreamKeyArgsForCall)] + fake.loadIngressFromStreamKeyArgsForCall = append(fake.loadIngressFromStreamKeyArgsForCall, struct { + arg1 context.Context + arg2 string + }{arg1, arg2}) + stub := fake.LoadIngressFromStreamKeyStub + fakeReturns := fake.loadIngressFromStreamKeyReturns + fake.recordInvocation("LoadIngressFromStreamKey", []interface{}{arg1, arg2}) + fake.loadIngressFromStreamKeyMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeIngressStore) LoadIngressFromStreamKeyCallCount() int { + fake.loadIngressFromStreamKeyMutex.RLock() + defer fake.loadIngressFromStreamKeyMutex.RUnlock() + return len(fake.loadIngressFromStreamKeyArgsForCall) +} + +func (fake *FakeIngressStore) LoadIngressFromStreamKeyCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) { + fake.loadIngressFromStreamKeyMutex.Lock() + defer fake.loadIngressFromStreamKeyMutex.Unlock() + fake.LoadIngressFromStreamKeyStub = stub +} + +func (fake *FakeIngressStore) LoadIngressFromStreamKeyArgsForCall(i int) (context.Context, string) { + fake.loadIngressFromStreamKeyMutex.RLock() + defer fake.loadIngressFromStreamKeyMutex.RUnlock() + argsForCall := fake.loadIngressFromStreamKeyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeIngressStore) LoadIngressFromStreamKeyReturns(result1 *livekit.IngressInfo, result2 error) { + fake.loadIngressFromStreamKeyMutex.Lock() + defer fake.loadIngressFromStreamKeyMutex.Unlock() + fake.LoadIngressFromStreamKeyStub = nil + fake.loadIngressFromStreamKeyReturns = struct { + result1 *livekit.IngressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeIngressStore) LoadIngressFromStreamKeyReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) { + fake.loadIngressFromStreamKeyMutex.Lock() + defer fake.loadIngressFromStreamKeyMutex.Unlock() + fake.LoadIngressFromStreamKeyStub = nil + if fake.loadIngressFromStreamKeyReturnsOnCall == nil { + fake.loadIngressFromStreamKeyReturnsOnCall = make(map[int]struct { + result1 *livekit.IngressInfo + result2 error + }) + } + fake.loadIngressFromStreamKeyReturnsOnCall[i] = struct { + result1 *livekit.IngressInfo + result2 error + }{result1, result2} +} + +func (fake *FakeIngressStore) StoreIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { + fake.storeIngressMutex.Lock() + ret, specificReturn := fake.storeIngressReturnsOnCall[len(fake.storeIngressArgsForCall)] + fake.storeIngressArgsForCall = append(fake.storeIngressArgsForCall, struct { + arg1 context.Context + arg2 *livekit.IngressInfo + }{arg1, arg2}) + stub := fake.StoreIngressStub + fakeReturns := fake.storeIngressReturns + fake.recordInvocation("StoreIngress", []interface{}{arg1, arg2}) + fake.storeIngressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeIngressStore) StoreIngressCallCount() int { + fake.storeIngressMutex.RLock() + defer fake.storeIngressMutex.RUnlock() + return len(fake.storeIngressArgsForCall) +} + +func (fake *FakeIngressStore) StoreIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { + fake.storeIngressMutex.Lock() + defer fake.storeIngressMutex.Unlock() + fake.StoreIngressStub = stub +} + +func (fake *FakeIngressStore) StoreIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { + fake.storeIngressMutex.RLock() + defer fake.storeIngressMutex.RUnlock() + argsForCall := fake.storeIngressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeIngressStore) StoreIngressReturns(result1 error) { + fake.storeIngressMutex.Lock() + defer fake.storeIngressMutex.Unlock() + fake.StoreIngressStub = nil + fake.storeIngressReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeIngressStore) StoreIngressReturnsOnCall(i int, result1 error) { + fake.storeIngressMutex.Lock() + defer fake.storeIngressMutex.Unlock() + fake.StoreIngressStub = nil + if fake.storeIngressReturnsOnCall == nil { + fake.storeIngressReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.storeIngressReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeIngressStore) UpdateIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { + fake.updateIngressMutex.Lock() + ret, specificReturn := fake.updateIngressReturnsOnCall[len(fake.updateIngressArgsForCall)] + fake.updateIngressArgsForCall = append(fake.updateIngressArgsForCall, struct { + arg1 context.Context + arg2 *livekit.IngressInfo + }{arg1, arg2}) + stub := fake.UpdateIngressStub + fakeReturns := fake.updateIngressReturns + fake.recordInvocation("UpdateIngress", []interface{}{arg1, arg2}) + fake.updateIngressMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeIngressStore) UpdateIngressCallCount() int { + fake.updateIngressMutex.RLock() + defer fake.updateIngressMutex.RUnlock() + return len(fake.updateIngressArgsForCall) +} + +func (fake *FakeIngressStore) UpdateIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { + fake.updateIngressMutex.Lock() + defer fake.updateIngressMutex.Unlock() + fake.UpdateIngressStub = stub +} + +func (fake *FakeIngressStore) UpdateIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { + fake.updateIngressMutex.RLock() + defer fake.updateIngressMutex.RUnlock() + argsForCall := fake.updateIngressArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeIngressStore) UpdateIngressReturns(result1 error) { + fake.updateIngressMutex.Lock() + defer fake.updateIngressMutex.Unlock() + fake.UpdateIngressStub = nil + fake.updateIngressReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeIngressStore) UpdateIngressReturnsOnCall(i int, result1 error) { + fake.updateIngressMutex.Lock() + defer fake.updateIngressMutex.Unlock() + fake.UpdateIngressStub = nil + if fake.updateIngressReturnsOnCall == nil { + fake.updateIngressReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateIngressReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeIngressStore) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.deleteIngressMutex.RLock() + defer fake.deleteIngressMutex.RUnlock() + fake.listIngressMutex.RLock() + defer fake.listIngressMutex.RUnlock() + fake.loadIngressMutex.RLock() + defer fake.loadIngressMutex.RUnlock() + fake.loadIngressFromStreamKeyMutex.RLock() + defer fake.loadIngressFromStreamKeyMutex.RUnlock() + fake.storeIngressMutex.RLock() + defer fake.storeIngressMutex.RUnlock() + fake.updateIngressMutex.RLock() + defer fake.updateIngressMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeIngressStore) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ service.IngressStore = new(FakeIngressStore) diff --git a/pkg/service/servicefakes/fake_object_store.go b/pkg/service/servicefakes/fake_object_store.go index 5ef01673b..a027f8961 100644 --- a/pkg/service/servicefakes/fake_object_store.go +++ b/pkg/service/servicefakes/fake_object_store.go @@ -11,30 +11,6 @@ import ( ) type FakeObjectStore struct { - DeleteEgressStub func(context.Context, *livekit.EgressInfo) error - deleteEgressMutex sync.RWMutex - deleteEgressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.EgressInfo - } - deleteEgressReturns struct { - result1 error - } - deleteEgressReturnsOnCall map[int]struct { - result1 error - } - DeleteIngressStub func(context.Context, *livekit.IngressInfo) error - deleteIngressMutex sync.RWMutex - deleteIngressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.IngressInfo - } - deleteIngressReturns struct { - result1 error - } - deleteIngressReturnsOnCall map[int]struct { - result1 error - } DeleteParticipantStub func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) error deleteParticipantMutex sync.RWMutex deleteParticipantArgsForCall []struct { @@ -60,34 +36,6 @@ type FakeObjectStore struct { deleteRoomReturnsOnCall map[int]struct { result1 error } - ListEgressStub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error) - listEgressMutex sync.RWMutex - listEgressArgsForCall []struct { - arg1 context.Context - arg2 livekit.RoomID - } - listEgressReturns struct { - result1 []*livekit.EgressInfo - result2 error - } - listEgressReturnsOnCall map[int]struct { - result1 []*livekit.EgressInfo - result2 error - } - ListIngressStub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error) - listIngressMutex sync.RWMutex - listIngressArgsForCall []struct { - arg1 context.Context - arg2 livekit.RoomName - } - listIngressReturns struct { - result1 []*livekit.IngressInfo - result2 error - } - listIngressReturnsOnCall map[int]struct { - result1 []*livekit.IngressInfo - result2 error - } ListParticipantsStub func(context.Context, livekit.RoomName) ([]*livekit.ParticipantInfo, error) listParticipantsMutex sync.RWMutex listParticipantsArgsForCall []struct { @@ -116,48 +64,6 @@ type FakeObjectStore struct { result1 []*livekit.Room result2 error } - LoadEgressStub func(context.Context, string) (*livekit.EgressInfo, error) - loadEgressMutex sync.RWMutex - loadEgressArgsForCall []struct { - arg1 context.Context - arg2 string - } - loadEgressReturns struct { - result1 *livekit.EgressInfo - result2 error - } - loadEgressReturnsOnCall map[int]struct { - result1 *livekit.EgressInfo - result2 error - } - LoadIngressStub func(context.Context, string) (*livekit.IngressInfo, error) - loadIngressMutex sync.RWMutex - loadIngressArgsForCall []struct { - arg1 context.Context - arg2 string - } - loadIngressReturns struct { - result1 *livekit.IngressInfo - result2 error - } - loadIngressReturnsOnCall map[int]struct { - result1 *livekit.IngressInfo - result2 error - } - LoadIngressFromStreamKeyStub func(context.Context, string) (*livekit.IngressInfo, error) - loadIngressFromStreamKeyMutex sync.RWMutex - loadIngressFromStreamKeyArgsForCall []struct { - arg1 context.Context - arg2 string - } - loadIngressFromStreamKeyReturns struct { - result1 *livekit.IngressInfo - result2 error - } - loadIngressFromStreamKeyReturnsOnCall map[int]struct { - result1 *livekit.IngressInfo - result2 error - } LoadParticipantStub func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error) loadParticipantMutex sync.RWMutex loadParticipantArgsForCall []struct { @@ -202,30 +108,6 @@ type FakeObjectStore struct { result1 string result2 error } - StoreEgressStub func(context.Context, *livekit.EgressInfo) error - storeEgressMutex sync.RWMutex - storeEgressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.EgressInfo - } - storeEgressReturns struct { - result1 error - } - storeEgressReturnsOnCall map[int]struct { - result1 error - } - StoreIngressStub func(context.Context, *livekit.IngressInfo) error - storeIngressMutex sync.RWMutex - storeIngressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.IngressInfo - } - storeIngressReturns struct { - result1 error - } - storeIngressReturnsOnCall map[int]struct { - result1 error - } StoreParticipantStub func(context.Context, livekit.RoomName, *livekit.ParticipantInfo) error storeParticipantMutex sync.RWMutex storeParticipantArgsForCall []struct { @@ -264,158 +146,10 @@ type FakeObjectStore struct { unlockRoomReturnsOnCall map[int]struct { result1 error } - UpdateEgressStub func(context.Context, *livekit.EgressInfo) error - updateEgressMutex sync.RWMutex - updateEgressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.EgressInfo - } - updateEgressReturns struct { - result1 error - } - updateEgressReturnsOnCall map[int]struct { - result1 error - } - UpdateIngressStub func(context.Context, *livekit.IngressInfo) error - updateIngressMutex sync.RWMutex - updateIngressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.IngressInfo - } - updateIngressReturns struct { - result1 error - } - updateIngressReturnsOnCall map[int]struct { - result1 error - } invocations map[string][][]interface{} invocationsMutex sync.RWMutex } -func (fake *FakeObjectStore) DeleteEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { - fake.deleteEgressMutex.Lock() - ret, specificReturn := fake.deleteEgressReturnsOnCall[len(fake.deleteEgressArgsForCall)] - fake.deleteEgressArgsForCall = append(fake.deleteEgressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.EgressInfo - }{arg1, arg2}) - stub := fake.DeleteEgressStub - fakeReturns := fake.deleteEgressReturns - fake.recordInvocation("DeleteEgress", []interface{}{arg1, arg2}) - fake.deleteEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeObjectStore) DeleteEgressCallCount() int { - fake.deleteEgressMutex.RLock() - defer fake.deleteEgressMutex.RUnlock() - return len(fake.deleteEgressArgsForCall) -} - -func (fake *FakeObjectStore) DeleteEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { - fake.deleteEgressMutex.Lock() - defer fake.deleteEgressMutex.Unlock() - fake.DeleteEgressStub = stub -} - -func (fake *FakeObjectStore) DeleteEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { - fake.deleteEgressMutex.RLock() - defer fake.deleteEgressMutex.RUnlock() - argsForCall := fake.deleteEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) DeleteEgressReturns(result1 error) { - fake.deleteEgressMutex.Lock() - defer fake.deleteEgressMutex.Unlock() - fake.DeleteEgressStub = nil - fake.deleteEgressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) DeleteEgressReturnsOnCall(i int, result1 error) { - fake.deleteEgressMutex.Lock() - defer fake.deleteEgressMutex.Unlock() - fake.DeleteEgressStub = nil - if fake.deleteEgressReturnsOnCall == nil { - fake.deleteEgressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteEgressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) DeleteIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { - fake.deleteIngressMutex.Lock() - ret, specificReturn := fake.deleteIngressReturnsOnCall[len(fake.deleteIngressArgsForCall)] - fake.deleteIngressArgsForCall = append(fake.deleteIngressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.IngressInfo - }{arg1, arg2}) - stub := fake.DeleteIngressStub - fakeReturns := fake.deleteIngressReturns - fake.recordInvocation("DeleteIngress", []interface{}{arg1, arg2}) - fake.deleteIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeObjectStore) DeleteIngressCallCount() int { - fake.deleteIngressMutex.RLock() - defer fake.deleteIngressMutex.RUnlock() - return len(fake.deleteIngressArgsForCall) -} - -func (fake *FakeObjectStore) DeleteIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { - fake.deleteIngressMutex.Lock() - defer fake.deleteIngressMutex.Unlock() - fake.DeleteIngressStub = stub -} - -func (fake *FakeObjectStore) DeleteIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { - fake.deleteIngressMutex.RLock() - defer fake.deleteIngressMutex.RUnlock() - argsForCall := fake.deleteIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) DeleteIngressReturns(result1 error) { - fake.deleteIngressMutex.Lock() - defer fake.deleteIngressMutex.Unlock() - fake.DeleteIngressStub = nil - fake.deleteIngressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) DeleteIngressReturnsOnCall(i int, result1 error) { - fake.deleteIngressMutex.Lock() - defer fake.deleteIngressMutex.Unlock() - fake.DeleteIngressStub = nil - if fake.deleteIngressReturnsOnCall == nil { - fake.deleteIngressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteIngressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - func (fake *FakeObjectStore) DeleteParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) error { fake.deleteParticipantMutex.Lock() ret, specificReturn := fake.deleteParticipantReturnsOnCall[len(fake.deleteParticipantArgsForCall)] @@ -541,136 +275,6 @@ func (fake *FakeObjectStore) DeleteRoomReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeObjectStore) ListEgress(arg1 context.Context, arg2 livekit.RoomID) ([]*livekit.EgressInfo, error) { - fake.listEgressMutex.Lock() - ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)] - fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct { - arg1 context.Context - arg2 livekit.RoomID - }{arg1, arg2}) - stub := fake.ListEgressStub - fakeReturns := fake.listEgressReturns - fake.recordInvocation("ListEgress", []interface{}{arg1, arg2}) - fake.listEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeObjectStore) ListEgressCallCount() int { - fake.listEgressMutex.RLock() - defer fake.listEgressMutex.RUnlock() - return len(fake.listEgressArgsForCall) -} - -func (fake *FakeObjectStore) ListEgressCalls(stub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)) { - fake.listEgressMutex.Lock() - defer fake.listEgressMutex.Unlock() - fake.ListEgressStub = stub -} - -func (fake *FakeObjectStore) ListEgressArgsForCall(i int) (context.Context, livekit.RoomID) { - fake.listEgressMutex.RLock() - defer fake.listEgressMutex.RUnlock() - argsForCall := fake.listEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) ListEgressReturns(result1 []*livekit.EgressInfo, result2 error) { - fake.listEgressMutex.Lock() - defer fake.listEgressMutex.Unlock() - fake.ListEgressStub = nil - fake.listEgressReturns = struct { - result1 []*livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) ListEgressReturnsOnCall(i int, result1 []*livekit.EgressInfo, result2 error) { - fake.listEgressMutex.Lock() - defer fake.listEgressMutex.Unlock() - fake.ListEgressStub = nil - if fake.listEgressReturnsOnCall == nil { - fake.listEgressReturnsOnCall = make(map[int]struct { - result1 []*livekit.EgressInfo - result2 error - }) - } - fake.listEgressReturnsOnCall[i] = struct { - result1 []*livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) ListIngress(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.IngressInfo, error) { - fake.listIngressMutex.Lock() - ret, specificReturn := fake.listIngressReturnsOnCall[len(fake.listIngressArgsForCall)] - fake.listIngressArgsForCall = append(fake.listIngressArgsForCall, struct { - arg1 context.Context - arg2 livekit.RoomName - }{arg1, arg2}) - stub := fake.ListIngressStub - fakeReturns := fake.listIngressReturns - fake.recordInvocation("ListIngress", []interface{}{arg1, arg2}) - fake.listIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeObjectStore) ListIngressCallCount() int { - fake.listIngressMutex.RLock() - defer fake.listIngressMutex.RUnlock() - return len(fake.listIngressArgsForCall) -} - -func (fake *FakeObjectStore) ListIngressCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)) { - fake.listIngressMutex.Lock() - defer fake.listIngressMutex.Unlock() - fake.ListIngressStub = stub -} - -func (fake *FakeObjectStore) ListIngressArgsForCall(i int) (context.Context, livekit.RoomName) { - fake.listIngressMutex.RLock() - defer fake.listIngressMutex.RUnlock() - argsForCall := fake.listIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) ListIngressReturns(result1 []*livekit.IngressInfo, result2 error) { - fake.listIngressMutex.Lock() - defer fake.listIngressMutex.Unlock() - fake.ListIngressStub = nil - fake.listIngressReturns = struct { - result1 []*livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) ListIngressReturnsOnCall(i int, result1 []*livekit.IngressInfo, result2 error) { - fake.listIngressMutex.Lock() - defer fake.listIngressMutex.Unlock() - fake.ListIngressStub = nil - if fake.listIngressReturnsOnCall == nil { - fake.listIngressReturnsOnCall = make(map[int]struct { - result1 []*livekit.IngressInfo - result2 error - }) - } - fake.listIngressReturnsOnCall[i] = struct { - result1 []*livekit.IngressInfo - result2 error - }{result1, result2} -} - func (fake *FakeObjectStore) ListParticipants(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.ParticipantInfo, error) { fake.listParticipantsMutex.Lock() ret, specificReturn := fake.listParticipantsReturnsOnCall[len(fake.listParticipantsArgsForCall)] @@ -806,201 +410,6 @@ func (fake *FakeObjectStore) ListRoomsReturnsOnCall(i int, result1 []*livekit.Ro }{result1, result2} } -func (fake *FakeObjectStore) LoadEgress(arg1 context.Context, arg2 string) (*livekit.EgressInfo, error) { - fake.loadEgressMutex.Lock() - ret, specificReturn := fake.loadEgressReturnsOnCall[len(fake.loadEgressArgsForCall)] - fake.loadEgressArgsForCall = append(fake.loadEgressArgsForCall, struct { - arg1 context.Context - arg2 string - }{arg1, arg2}) - stub := fake.LoadEgressStub - fakeReturns := fake.loadEgressReturns - fake.recordInvocation("LoadEgress", []interface{}{arg1, arg2}) - fake.loadEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeObjectStore) LoadEgressCallCount() int { - fake.loadEgressMutex.RLock() - defer fake.loadEgressMutex.RUnlock() - return len(fake.loadEgressArgsForCall) -} - -func (fake *FakeObjectStore) LoadEgressCalls(stub func(context.Context, string) (*livekit.EgressInfo, error)) { - fake.loadEgressMutex.Lock() - defer fake.loadEgressMutex.Unlock() - fake.LoadEgressStub = stub -} - -func (fake *FakeObjectStore) LoadEgressArgsForCall(i int) (context.Context, string) { - fake.loadEgressMutex.RLock() - defer fake.loadEgressMutex.RUnlock() - argsForCall := fake.loadEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) LoadEgressReturns(result1 *livekit.EgressInfo, result2 error) { - fake.loadEgressMutex.Lock() - defer fake.loadEgressMutex.Unlock() - fake.LoadEgressStub = nil - fake.loadEgressReturns = struct { - result1 *livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) LoadEgressReturnsOnCall(i int, result1 *livekit.EgressInfo, result2 error) { - fake.loadEgressMutex.Lock() - defer fake.loadEgressMutex.Unlock() - fake.LoadEgressStub = nil - if fake.loadEgressReturnsOnCall == nil { - fake.loadEgressReturnsOnCall = make(map[int]struct { - result1 *livekit.EgressInfo - result2 error - }) - } - fake.loadEgressReturnsOnCall[i] = struct { - result1 *livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) LoadIngress(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) { - fake.loadIngressMutex.Lock() - ret, specificReturn := fake.loadIngressReturnsOnCall[len(fake.loadIngressArgsForCall)] - fake.loadIngressArgsForCall = append(fake.loadIngressArgsForCall, struct { - arg1 context.Context - arg2 string - }{arg1, arg2}) - stub := fake.LoadIngressStub - fakeReturns := fake.loadIngressReturns - fake.recordInvocation("LoadIngress", []interface{}{arg1, arg2}) - fake.loadIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeObjectStore) LoadIngressCallCount() int { - fake.loadIngressMutex.RLock() - defer fake.loadIngressMutex.RUnlock() - return len(fake.loadIngressArgsForCall) -} - -func (fake *FakeObjectStore) LoadIngressCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) { - fake.loadIngressMutex.Lock() - defer fake.loadIngressMutex.Unlock() - fake.LoadIngressStub = stub -} - -func (fake *FakeObjectStore) LoadIngressArgsForCall(i int) (context.Context, string) { - fake.loadIngressMutex.RLock() - defer fake.loadIngressMutex.RUnlock() - argsForCall := fake.loadIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) LoadIngressReturns(result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressMutex.Lock() - defer fake.loadIngressMutex.Unlock() - fake.LoadIngressStub = nil - fake.loadIngressReturns = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) LoadIngressReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressMutex.Lock() - defer fake.loadIngressMutex.Unlock() - fake.LoadIngressStub = nil - if fake.loadIngressReturnsOnCall == nil { - fake.loadIngressReturnsOnCall = make(map[int]struct { - result1 *livekit.IngressInfo - result2 error - }) - } - fake.loadIngressReturnsOnCall[i] = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) LoadIngressFromStreamKey(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) { - fake.loadIngressFromStreamKeyMutex.Lock() - ret, specificReturn := fake.loadIngressFromStreamKeyReturnsOnCall[len(fake.loadIngressFromStreamKeyArgsForCall)] - fake.loadIngressFromStreamKeyArgsForCall = append(fake.loadIngressFromStreamKeyArgsForCall, struct { - arg1 context.Context - arg2 string - }{arg1, arg2}) - stub := fake.LoadIngressFromStreamKeyStub - fakeReturns := fake.loadIngressFromStreamKeyReturns - fake.recordInvocation("LoadIngressFromStreamKey", []interface{}{arg1, arg2}) - fake.loadIngressFromStreamKeyMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeObjectStore) LoadIngressFromStreamKeyCallCount() int { - fake.loadIngressFromStreamKeyMutex.RLock() - defer fake.loadIngressFromStreamKeyMutex.RUnlock() - return len(fake.loadIngressFromStreamKeyArgsForCall) -} - -func (fake *FakeObjectStore) LoadIngressFromStreamKeyCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) { - fake.loadIngressFromStreamKeyMutex.Lock() - defer fake.loadIngressFromStreamKeyMutex.Unlock() - fake.LoadIngressFromStreamKeyStub = stub -} - -func (fake *FakeObjectStore) LoadIngressFromStreamKeyArgsForCall(i int) (context.Context, string) { - fake.loadIngressFromStreamKeyMutex.RLock() - defer fake.loadIngressFromStreamKeyMutex.RUnlock() - argsForCall := fake.loadIngressFromStreamKeyArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) LoadIngressFromStreamKeyReturns(result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressFromStreamKeyMutex.Lock() - defer fake.loadIngressFromStreamKeyMutex.Unlock() - fake.LoadIngressFromStreamKeyStub = nil - fake.loadIngressFromStreamKeyReturns = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeObjectStore) LoadIngressFromStreamKeyReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressFromStreamKeyMutex.Lock() - defer fake.loadIngressFromStreamKeyMutex.Unlock() - fake.LoadIngressFromStreamKeyStub = nil - if fake.loadIngressFromStreamKeyReturnsOnCall == nil { - fake.loadIngressFromStreamKeyReturnsOnCall = make(map[int]struct { - result1 *livekit.IngressInfo - result2 error - }) - } - fake.loadIngressFromStreamKeyReturnsOnCall[i] = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - func (fake *FakeObjectStore) LoadParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error) { fake.loadParticipantMutex.Lock() ret, specificReturn := fake.loadParticipantReturnsOnCall[len(fake.loadParticipantArgsForCall)] @@ -1198,130 +607,6 @@ func (fake *FakeObjectStore) LockRoomReturnsOnCall(i int, result1 string, result }{result1, result2} } -func (fake *FakeObjectStore) StoreEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { - fake.storeEgressMutex.Lock() - ret, specificReturn := fake.storeEgressReturnsOnCall[len(fake.storeEgressArgsForCall)] - fake.storeEgressArgsForCall = append(fake.storeEgressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.EgressInfo - }{arg1, arg2}) - stub := fake.StoreEgressStub - fakeReturns := fake.storeEgressReturns - fake.recordInvocation("StoreEgress", []interface{}{arg1, arg2}) - fake.storeEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeObjectStore) StoreEgressCallCount() int { - fake.storeEgressMutex.RLock() - defer fake.storeEgressMutex.RUnlock() - return len(fake.storeEgressArgsForCall) -} - -func (fake *FakeObjectStore) StoreEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { - fake.storeEgressMutex.Lock() - defer fake.storeEgressMutex.Unlock() - fake.StoreEgressStub = stub -} - -func (fake *FakeObjectStore) StoreEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { - fake.storeEgressMutex.RLock() - defer fake.storeEgressMutex.RUnlock() - argsForCall := fake.storeEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) StoreEgressReturns(result1 error) { - fake.storeEgressMutex.Lock() - defer fake.storeEgressMutex.Unlock() - fake.StoreEgressStub = nil - fake.storeEgressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) StoreEgressReturnsOnCall(i int, result1 error) { - fake.storeEgressMutex.Lock() - defer fake.storeEgressMutex.Unlock() - fake.StoreEgressStub = nil - if fake.storeEgressReturnsOnCall == nil { - fake.storeEgressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.storeEgressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) StoreIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { - fake.storeIngressMutex.Lock() - ret, specificReturn := fake.storeIngressReturnsOnCall[len(fake.storeIngressArgsForCall)] - fake.storeIngressArgsForCall = append(fake.storeIngressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.IngressInfo - }{arg1, arg2}) - stub := fake.StoreIngressStub - fakeReturns := fake.storeIngressReturns - fake.recordInvocation("StoreIngress", []interface{}{arg1, arg2}) - fake.storeIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeObjectStore) StoreIngressCallCount() int { - fake.storeIngressMutex.RLock() - defer fake.storeIngressMutex.RUnlock() - return len(fake.storeIngressArgsForCall) -} - -func (fake *FakeObjectStore) StoreIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { - fake.storeIngressMutex.Lock() - defer fake.storeIngressMutex.Unlock() - fake.StoreIngressStub = stub -} - -func (fake *FakeObjectStore) StoreIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { - fake.storeIngressMutex.RLock() - defer fake.storeIngressMutex.RUnlock() - argsForCall := fake.storeIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) StoreIngressReturns(result1 error) { - fake.storeIngressMutex.Lock() - defer fake.storeIngressMutex.Unlock() - fake.StoreIngressStub = nil - fake.storeIngressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) StoreIngressReturnsOnCall(i int, result1 error) { - fake.storeIngressMutex.Lock() - defer fake.storeIngressMutex.Unlock() - fake.StoreIngressStub = nil - if fake.storeIngressReturnsOnCall == nil { - fake.storeIngressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.storeIngressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - func (fake *FakeObjectStore) StoreParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 *livekit.ParticipantInfo) error { fake.storeParticipantMutex.Lock() ret, specificReturn := fake.storeParticipantReturnsOnCall[len(fake.storeParticipantArgsForCall)] @@ -1510,175 +795,29 @@ func (fake *FakeObjectStore) UnlockRoomReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeObjectStore) UpdateEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { - fake.updateEgressMutex.Lock() - ret, specificReturn := fake.updateEgressReturnsOnCall[len(fake.updateEgressArgsForCall)] - fake.updateEgressArgsForCall = append(fake.updateEgressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.EgressInfo - }{arg1, arg2}) - stub := fake.UpdateEgressStub - fakeReturns := fake.updateEgressReturns - fake.recordInvocation("UpdateEgress", []interface{}{arg1, arg2}) - fake.updateEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeObjectStore) UpdateEgressCallCount() int { - fake.updateEgressMutex.RLock() - defer fake.updateEgressMutex.RUnlock() - return len(fake.updateEgressArgsForCall) -} - -func (fake *FakeObjectStore) UpdateEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { - fake.updateEgressMutex.Lock() - defer fake.updateEgressMutex.Unlock() - fake.UpdateEgressStub = stub -} - -func (fake *FakeObjectStore) UpdateEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { - fake.updateEgressMutex.RLock() - defer fake.updateEgressMutex.RUnlock() - argsForCall := fake.updateEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) UpdateEgressReturns(result1 error) { - fake.updateEgressMutex.Lock() - defer fake.updateEgressMutex.Unlock() - fake.UpdateEgressStub = nil - fake.updateEgressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) UpdateEgressReturnsOnCall(i int, result1 error) { - fake.updateEgressMutex.Lock() - defer fake.updateEgressMutex.Unlock() - fake.UpdateEgressStub = nil - if fake.updateEgressReturnsOnCall == nil { - fake.updateEgressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.updateEgressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) UpdateIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { - fake.updateIngressMutex.Lock() - ret, specificReturn := fake.updateIngressReturnsOnCall[len(fake.updateIngressArgsForCall)] - fake.updateIngressArgsForCall = append(fake.updateIngressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.IngressInfo - }{arg1, arg2}) - stub := fake.UpdateIngressStub - fakeReturns := fake.updateIngressReturns - fake.recordInvocation("UpdateIngress", []interface{}{arg1, arg2}) - fake.updateIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeObjectStore) UpdateIngressCallCount() int { - fake.updateIngressMutex.RLock() - defer fake.updateIngressMutex.RUnlock() - return len(fake.updateIngressArgsForCall) -} - -func (fake *FakeObjectStore) UpdateIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { - fake.updateIngressMutex.Lock() - defer fake.updateIngressMutex.Unlock() - fake.UpdateIngressStub = stub -} - -func (fake *FakeObjectStore) UpdateIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { - fake.updateIngressMutex.RLock() - defer fake.updateIngressMutex.RUnlock() - argsForCall := fake.updateIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeObjectStore) UpdateIngressReturns(result1 error) { - fake.updateIngressMutex.Lock() - defer fake.updateIngressMutex.Unlock() - fake.UpdateIngressStub = nil - fake.updateIngressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeObjectStore) UpdateIngressReturnsOnCall(i int, result1 error) { - fake.updateIngressMutex.Lock() - defer fake.updateIngressMutex.Unlock() - fake.UpdateIngressStub = nil - if fake.updateIngressReturnsOnCall == nil { - fake.updateIngressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.updateIngressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - func (fake *FakeObjectStore) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.deleteEgressMutex.RLock() - defer fake.deleteEgressMutex.RUnlock() - fake.deleteIngressMutex.RLock() - defer fake.deleteIngressMutex.RUnlock() fake.deleteParticipantMutex.RLock() defer fake.deleteParticipantMutex.RUnlock() fake.deleteRoomMutex.RLock() defer fake.deleteRoomMutex.RUnlock() - fake.listEgressMutex.RLock() - defer fake.listEgressMutex.RUnlock() - fake.listIngressMutex.RLock() - defer fake.listIngressMutex.RUnlock() fake.listParticipantsMutex.RLock() defer fake.listParticipantsMutex.RUnlock() fake.listRoomsMutex.RLock() defer fake.listRoomsMutex.RUnlock() - fake.loadEgressMutex.RLock() - defer fake.loadEgressMutex.RUnlock() - fake.loadIngressMutex.RLock() - defer fake.loadIngressMutex.RUnlock() - fake.loadIngressFromStreamKeyMutex.RLock() - defer fake.loadIngressFromStreamKeyMutex.RUnlock() fake.loadParticipantMutex.RLock() defer fake.loadParticipantMutex.RUnlock() fake.loadRoomMutex.RLock() defer fake.loadRoomMutex.RUnlock() fake.lockRoomMutex.RLock() defer fake.lockRoomMutex.RUnlock() - fake.storeEgressMutex.RLock() - defer fake.storeEgressMutex.RUnlock() - fake.storeIngressMutex.RLock() - defer fake.storeIngressMutex.RUnlock() fake.storeParticipantMutex.RLock() defer fake.storeParticipantMutex.RUnlock() fake.storeRoomMutex.RLock() defer fake.storeRoomMutex.RUnlock() fake.unlockRoomMutex.RLock() defer fake.unlockRoomMutex.RUnlock() - fake.updateEgressMutex.RLock() - defer fake.updateEgressMutex.RUnlock() - fake.updateIngressMutex.RLock() - defer fake.updateIngressMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/pkg/service/servicefakes/fake_service_store.go b/pkg/service/servicefakes/fake_service_store.go index 0b5c743ab..2f8c4759f 100644 --- a/pkg/service/servicefakes/fake_service_store.go +++ b/pkg/service/servicefakes/fake_service_store.go @@ -10,58 +10,6 @@ import ( ) type FakeServiceStore struct { - DeleteEgressStub func(context.Context, *livekit.EgressInfo) error - deleteEgressMutex sync.RWMutex - deleteEgressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.EgressInfo - } - deleteEgressReturns struct { - result1 error - } - deleteEgressReturnsOnCall map[int]struct { - result1 error - } - DeleteIngressStub func(context.Context, *livekit.IngressInfo) error - deleteIngressMutex sync.RWMutex - deleteIngressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.IngressInfo - } - deleteIngressReturns struct { - result1 error - } - deleteIngressReturnsOnCall map[int]struct { - result1 error - } - ListEgressStub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error) - listEgressMutex sync.RWMutex - listEgressArgsForCall []struct { - arg1 context.Context - arg2 livekit.RoomID - } - listEgressReturns struct { - result1 []*livekit.EgressInfo - result2 error - } - listEgressReturnsOnCall map[int]struct { - result1 []*livekit.EgressInfo - result2 error - } - ListIngressStub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error) - listIngressMutex sync.RWMutex - listIngressArgsForCall []struct { - arg1 context.Context - arg2 livekit.RoomName - } - listIngressReturns struct { - result1 []*livekit.IngressInfo - result2 error - } - listIngressReturnsOnCall map[int]struct { - result1 []*livekit.IngressInfo - result2 error - } ListParticipantsStub func(context.Context, livekit.RoomName) ([]*livekit.ParticipantInfo, error) listParticipantsMutex sync.RWMutex listParticipantsArgsForCall []struct { @@ -90,48 +38,6 @@ type FakeServiceStore struct { result1 []*livekit.Room result2 error } - LoadEgressStub func(context.Context, string) (*livekit.EgressInfo, error) - loadEgressMutex sync.RWMutex - loadEgressArgsForCall []struct { - arg1 context.Context - arg2 string - } - loadEgressReturns struct { - result1 *livekit.EgressInfo - result2 error - } - loadEgressReturnsOnCall map[int]struct { - result1 *livekit.EgressInfo - result2 error - } - LoadIngressStub func(context.Context, string) (*livekit.IngressInfo, error) - loadIngressMutex sync.RWMutex - loadIngressArgsForCall []struct { - arg1 context.Context - arg2 string - } - loadIngressReturns struct { - result1 *livekit.IngressInfo - result2 error - } - loadIngressReturnsOnCall map[int]struct { - result1 *livekit.IngressInfo - result2 error - } - LoadIngressFromStreamKeyStub func(context.Context, string) (*livekit.IngressInfo, error) - loadIngressFromStreamKeyMutex sync.RWMutex - loadIngressFromStreamKeyArgsForCall []struct { - arg1 context.Context - arg2 string - } - loadIngressFromStreamKeyReturns struct { - result1 *livekit.IngressInfo - result2 error - } - loadIngressFromStreamKeyReturnsOnCall map[int]struct { - result1 *livekit.IngressInfo - result2 error - } LoadParticipantStub func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error) loadParticipantMutex sync.RWMutex loadParticipantArgsForCall []struct { @@ -161,312 +67,10 @@ type FakeServiceStore struct { result1 *livekit.Room result2 error } - StoreEgressStub func(context.Context, *livekit.EgressInfo) error - storeEgressMutex sync.RWMutex - storeEgressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.EgressInfo - } - storeEgressReturns struct { - result1 error - } - storeEgressReturnsOnCall map[int]struct { - result1 error - } - StoreIngressStub func(context.Context, *livekit.IngressInfo) error - storeIngressMutex sync.RWMutex - storeIngressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.IngressInfo - } - storeIngressReturns struct { - result1 error - } - storeIngressReturnsOnCall map[int]struct { - result1 error - } - UpdateEgressStub func(context.Context, *livekit.EgressInfo) error - updateEgressMutex sync.RWMutex - updateEgressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.EgressInfo - } - updateEgressReturns struct { - result1 error - } - updateEgressReturnsOnCall map[int]struct { - result1 error - } - UpdateIngressStub func(context.Context, *livekit.IngressInfo) error - updateIngressMutex sync.RWMutex - updateIngressArgsForCall []struct { - arg1 context.Context - arg2 *livekit.IngressInfo - } - updateIngressReturns struct { - result1 error - } - updateIngressReturnsOnCall map[int]struct { - result1 error - } invocations map[string][][]interface{} invocationsMutex sync.RWMutex } -func (fake *FakeServiceStore) DeleteEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { - fake.deleteEgressMutex.Lock() - ret, specificReturn := fake.deleteEgressReturnsOnCall[len(fake.deleteEgressArgsForCall)] - fake.deleteEgressArgsForCall = append(fake.deleteEgressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.EgressInfo - }{arg1, arg2}) - stub := fake.DeleteEgressStub - fakeReturns := fake.deleteEgressReturns - fake.recordInvocation("DeleteEgress", []interface{}{arg1, arg2}) - fake.deleteEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeServiceStore) DeleteEgressCallCount() int { - fake.deleteEgressMutex.RLock() - defer fake.deleteEgressMutex.RUnlock() - return len(fake.deleteEgressArgsForCall) -} - -func (fake *FakeServiceStore) DeleteEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { - fake.deleteEgressMutex.Lock() - defer fake.deleteEgressMutex.Unlock() - fake.DeleteEgressStub = stub -} - -func (fake *FakeServiceStore) DeleteEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { - fake.deleteEgressMutex.RLock() - defer fake.deleteEgressMutex.RUnlock() - argsForCall := fake.deleteEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) DeleteEgressReturns(result1 error) { - fake.deleteEgressMutex.Lock() - defer fake.deleteEgressMutex.Unlock() - fake.DeleteEgressStub = nil - fake.deleteEgressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) DeleteEgressReturnsOnCall(i int, result1 error) { - fake.deleteEgressMutex.Lock() - defer fake.deleteEgressMutex.Unlock() - fake.DeleteEgressStub = nil - if fake.deleteEgressReturnsOnCall == nil { - fake.deleteEgressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteEgressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) DeleteIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { - fake.deleteIngressMutex.Lock() - ret, specificReturn := fake.deleteIngressReturnsOnCall[len(fake.deleteIngressArgsForCall)] - fake.deleteIngressArgsForCall = append(fake.deleteIngressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.IngressInfo - }{arg1, arg2}) - stub := fake.DeleteIngressStub - fakeReturns := fake.deleteIngressReturns - fake.recordInvocation("DeleteIngress", []interface{}{arg1, arg2}) - fake.deleteIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeServiceStore) DeleteIngressCallCount() int { - fake.deleteIngressMutex.RLock() - defer fake.deleteIngressMutex.RUnlock() - return len(fake.deleteIngressArgsForCall) -} - -func (fake *FakeServiceStore) DeleteIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { - fake.deleteIngressMutex.Lock() - defer fake.deleteIngressMutex.Unlock() - fake.DeleteIngressStub = stub -} - -func (fake *FakeServiceStore) DeleteIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { - fake.deleteIngressMutex.RLock() - defer fake.deleteIngressMutex.RUnlock() - argsForCall := fake.deleteIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) DeleteIngressReturns(result1 error) { - fake.deleteIngressMutex.Lock() - defer fake.deleteIngressMutex.Unlock() - fake.DeleteIngressStub = nil - fake.deleteIngressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) DeleteIngressReturnsOnCall(i int, result1 error) { - fake.deleteIngressMutex.Lock() - defer fake.deleteIngressMutex.Unlock() - fake.DeleteIngressStub = nil - if fake.deleteIngressReturnsOnCall == nil { - fake.deleteIngressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteIngressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) ListEgress(arg1 context.Context, arg2 livekit.RoomID) ([]*livekit.EgressInfo, error) { - fake.listEgressMutex.Lock() - ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)] - fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct { - arg1 context.Context - arg2 livekit.RoomID - }{arg1, arg2}) - stub := fake.ListEgressStub - fakeReturns := fake.listEgressReturns - fake.recordInvocation("ListEgress", []interface{}{arg1, arg2}) - fake.listEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeServiceStore) ListEgressCallCount() int { - fake.listEgressMutex.RLock() - defer fake.listEgressMutex.RUnlock() - return len(fake.listEgressArgsForCall) -} - -func (fake *FakeServiceStore) ListEgressCalls(stub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)) { - fake.listEgressMutex.Lock() - defer fake.listEgressMutex.Unlock() - fake.ListEgressStub = stub -} - -func (fake *FakeServiceStore) ListEgressArgsForCall(i int) (context.Context, livekit.RoomID) { - fake.listEgressMutex.RLock() - defer fake.listEgressMutex.RUnlock() - argsForCall := fake.listEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) ListEgressReturns(result1 []*livekit.EgressInfo, result2 error) { - fake.listEgressMutex.Lock() - defer fake.listEgressMutex.Unlock() - fake.ListEgressStub = nil - fake.listEgressReturns = struct { - result1 []*livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) ListEgressReturnsOnCall(i int, result1 []*livekit.EgressInfo, result2 error) { - fake.listEgressMutex.Lock() - defer fake.listEgressMutex.Unlock() - fake.ListEgressStub = nil - if fake.listEgressReturnsOnCall == nil { - fake.listEgressReturnsOnCall = make(map[int]struct { - result1 []*livekit.EgressInfo - result2 error - }) - } - fake.listEgressReturnsOnCall[i] = struct { - result1 []*livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) ListIngress(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.IngressInfo, error) { - fake.listIngressMutex.Lock() - ret, specificReturn := fake.listIngressReturnsOnCall[len(fake.listIngressArgsForCall)] - fake.listIngressArgsForCall = append(fake.listIngressArgsForCall, struct { - arg1 context.Context - arg2 livekit.RoomName - }{arg1, arg2}) - stub := fake.ListIngressStub - fakeReturns := fake.listIngressReturns - fake.recordInvocation("ListIngress", []interface{}{arg1, arg2}) - fake.listIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeServiceStore) ListIngressCallCount() int { - fake.listIngressMutex.RLock() - defer fake.listIngressMutex.RUnlock() - return len(fake.listIngressArgsForCall) -} - -func (fake *FakeServiceStore) ListIngressCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)) { - fake.listIngressMutex.Lock() - defer fake.listIngressMutex.Unlock() - fake.ListIngressStub = stub -} - -func (fake *FakeServiceStore) ListIngressArgsForCall(i int) (context.Context, livekit.RoomName) { - fake.listIngressMutex.RLock() - defer fake.listIngressMutex.RUnlock() - argsForCall := fake.listIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) ListIngressReturns(result1 []*livekit.IngressInfo, result2 error) { - fake.listIngressMutex.Lock() - defer fake.listIngressMutex.Unlock() - fake.ListIngressStub = nil - fake.listIngressReturns = struct { - result1 []*livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) ListIngressReturnsOnCall(i int, result1 []*livekit.IngressInfo, result2 error) { - fake.listIngressMutex.Lock() - defer fake.listIngressMutex.Unlock() - fake.ListIngressStub = nil - if fake.listIngressReturnsOnCall == nil { - fake.listIngressReturnsOnCall = make(map[int]struct { - result1 []*livekit.IngressInfo - result2 error - }) - } - fake.listIngressReturnsOnCall[i] = struct { - result1 []*livekit.IngressInfo - result2 error - }{result1, result2} -} - func (fake *FakeServiceStore) ListParticipants(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.ParticipantInfo, error) { fake.listParticipantsMutex.Lock() ret, specificReturn := fake.listParticipantsReturnsOnCall[len(fake.listParticipantsArgsForCall)] @@ -602,201 +206,6 @@ func (fake *FakeServiceStore) ListRoomsReturnsOnCall(i int, result1 []*livekit.R }{result1, result2} } -func (fake *FakeServiceStore) LoadEgress(arg1 context.Context, arg2 string) (*livekit.EgressInfo, error) { - fake.loadEgressMutex.Lock() - ret, specificReturn := fake.loadEgressReturnsOnCall[len(fake.loadEgressArgsForCall)] - fake.loadEgressArgsForCall = append(fake.loadEgressArgsForCall, struct { - arg1 context.Context - arg2 string - }{arg1, arg2}) - stub := fake.LoadEgressStub - fakeReturns := fake.loadEgressReturns - fake.recordInvocation("LoadEgress", []interface{}{arg1, arg2}) - fake.loadEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeServiceStore) LoadEgressCallCount() int { - fake.loadEgressMutex.RLock() - defer fake.loadEgressMutex.RUnlock() - return len(fake.loadEgressArgsForCall) -} - -func (fake *FakeServiceStore) LoadEgressCalls(stub func(context.Context, string) (*livekit.EgressInfo, error)) { - fake.loadEgressMutex.Lock() - defer fake.loadEgressMutex.Unlock() - fake.LoadEgressStub = stub -} - -func (fake *FakeServiceStore) LoadEgressArgsForCall(i int) (context.Context, string) { - fake.loadEgressMutex.RLock() - defer fake.loadEgressMutex.RUnlock() - argsForCall := fake.loadEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) LoadEgressReturns(result1 *livekit.EgressInfo, result2 error) { - fake.loadEgressMutex.Lock() - defer fake.loadEgressMutex.Unlock() - fake.LoadEgressStub = nil - fake.loadEgressReturns = struct { - result1 *livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) LoadEgressReturnsOnCall(i int, result1 *livekit.EgressInfo, result2 error) { - fake.loadEgressMutex.Lock() - defer fake.loadEgressMutex.Unlock() - fake.LoadEgressStub = nil - if fake.loadEgressReturnsOnCall == nil { - fake.loadEgressReturnsOnCall = make(map[int]struct { - result1 *livekit.EgressInfo - result2 error - }) - } - fake.loadEgressReturnsOnCall[i] = struct { - result1 *livekit.EgressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) LoadIngress(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) { - fake.loadIngressMutex.Lock() - ret, specificReturn := fake.loadIngressReturnsOnCall[len(fake.loadIngressArgsForCall)] - fake.loadIngressArgsForCall = append(fake.loadIngressArgsForCall, struct { - arg1 context.Context - arg2 string - }{arg1, arg2}) - stub := fake.LoadIngressStub - fakeReturns := fake.loadIngressReturns - fake.recordInvocation("LoadIngress", []interface{}{arg1, arg2}) - fake.loadIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeServiceStore) LoadIngressCallCount() int { - fake.loadIngressMutex.RLock() - defer fake.loadIngressMutex.RUnlock() - return len(fake.loadIngressArgsForCall) -} - -func (fake *FakeServiceStore) LoadIngressCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) { - fake.loadIngressMutex.Lock() - defer fake.loadIngressMutex.Unlock() - fake.LoadIngressStub = stub -} - -func (fake *FakeServiceStore) LoadIngressArgsForCall(i int) (context.Context, string) { - fake.loadIngressMutex.RLock() - defer fake.loadIngressMutex.RUnlock() - argsForCall := fake.loadIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) LoadIngressReturns(result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressMutex.Lock() - defer fake.loadIngressMutex.Unlock() - fake.LoadIngressStub = nil - fake.loadIngressReturns = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) LoadIngressReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressMutex.Lock() - defer fake.loadIngressMutex.Unlock() - fake.LoadIngressStub = nil - if fake.loadIngressReturnsOnCall == nil { - fake.loadIngressReturnsOnCall = make(map[int]struct { - result1 *livekit.IngressInfo - result2 error - }) - } - fake.loadIngressReturnsOnCall[i] = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) LoadIngressFromStreamKey(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) { - fake.loadIngressFromStreamKeyMutex.Lock() - ret, specificReturn := fake.loadIngressFromStreamKeyReturnsOnCall[len(fake.loadIngressFromStreamKeyArgsForCall)] - fake.loadIngressFromStreamKeyArgsForCall = append(fake.loadIngressFromStreamKeyArgsForCall, struct { - arg1 context.Context - arg2 string - }{arg1, arg2}) - stub := fake.LoadIngressFromStreamKeyStub - fakeReturns := fake.loadIngressFromStreamKeyReturns - fake.recordInvocation("LoadIngressFromStreamKey", []interface{}{arg1, arg2}) - fake.loadIngressFromStreamKeyMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeServiceStore) LoadIngressFromStreamKeyCallCount() int { - fake.loadIngressFromStreamKeyMutex.RLock() - defer fake.loadIngressFromStreamKeyMutex.RUnlock() - return len(fake.loadIngressFromStreamKeyArgsForCall) -} - -func (fake *FakeServiceStore) LoadIngressFromStreamKeyCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) { - fake.loadIngressFromStreamKeyMutex.Lock() - defer fake.loadIngressFromStreamKeyMutex.Unlock() - fake.LoadIngressFromStreamKeyStub = stub -} - -func (fake *FakeServiceStore) LoadIngressFromStreamKeyArgsForCall(i int) (context.Context, string) { - fake.loadIngressFromStreamKeyMutex.RLock() - defer fake.loadIngressFromStreamKeyMutex.RUnlock() - argsForCall := fake.loadIngressFromStreamKeyArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) LoadIngressFromStreamKeyReturns(result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressFromStreamKeyMutex.Lock() - defer fake.loadIngressFromStreamKeyMutex.Unlock() - fake.LoadIngressFromStreamKeyStub = nil - fake.loadIngressFromStreamKeyReturns = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - -func (fake *FakeServiceStore) LoadIngressFromStreamKeyReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) { - fake.loadIngressFromStreamKeyMutex.Lock() - defer fake.loadIngressFromStreamKeyMutex.Unlock() - fake.LoadIngressFromStreamKeyStub = nil - if fake.loadIngressFromStreamKeyReturnsOnCall == nil { - fake.loadIngressFromStreamKeyReturnsOnCall = make(map[int]struct { - result1 *livekit.IngressInfo - result2 error - }) - } - fake.loadIngressFromStreamKeyReturnsOnCall[i] = struct { - result1 *livekit.IngressInfo - result2 error - }{result1, result2} -} - func (fake *FakeServiceStore) LoadParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error) { fake.loadParticipantMutex.Lock() ret, specificReturn := fake.loadParticipantReturnsOnCall[len(fake.loadParticipantArgsForCall)] @@ -928,287 +337,17 @@ func (fake *FakeServiceStore) LoadRoomReturnsOnCall(i int, result1 *livekit.Room }{result1, result2} } -func (fake *FakeServiceStore) StoreEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { - fake.storeEgressMutex.Lock() - ret, specificReturn := fake.storeEgressReturnsOnCall[len(fake.storeEgressArgsForCall)] - fake.storeEgressArgsForCall = append(fake.storeEgressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.EgressInfo - }{arg1, arg2}) - stub := fake.StoreEgressStub - fakeReturns := fake.storeEgressReturns - fake.recordInvocation("StoreEgress", []interface{}{arg1, arg2}) - fake.storeEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeServiceStore) StoreEgressCallCount() int { - fake.storeEgressMutex.RLock() - defer fake.storeEgressMutex.RUnlock() - return len(fake.storeEgressArgsForCall) -} - -func (fake *FakeServiceStore) StoreEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { - fake.storeEgressMutex.Lock() - defer fake.storeEgressMutex.Unlock() - fake.StoreEgressStub = stub -} - -func (fake *FakeServiceStore) StoreEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { - fake.storeEgressMutex.RLock() - defer fake.storeEgressMutex.RUnlock() - argsForCall := fake.storeEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) StoreEgressReturns(result1 error) { - fake.storeEgressMutex.Lock() - defer fake.storeEgressMutex.Unlock() - fake.StoreEgressStub = nil - fake.storeEgressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) StoreEgressReturnsOnCall(i int, result1 error) { - fake.storeEgressMutex.Lock() - defer fake.storeEgressMutex.Unlock() - fake.StoreEgressStub = nil - if fake.storeEgressReturnsOnCall == nil { - fake.storeEgressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.storeEgressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) StoreIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { - fake.storeIngressMutex.Lock() - ret, specificReturn := fake.storeIngressReturnsOnCall[len(fake.storeIngressArgsForCall)] - fake.storeIngressArgsForCall = append(fake.storeIngressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.IngressInfo - }{arg1, arg2}) - stub := fake.StoreIngressStub - fakeReturns := fake.storeIngressReturns - fake.recordInvocation("StoreIngress", []interface{}{arg1, arg2}) - fake.storeIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeServiceStore) StoreIngressCallCount() int { - fake.storeIngressMutex.RLock() - defer fake.storeIngressMutex.RUnlock() - return len(fake.storeIngressArgsForCall) -} - -func (fake *FakeServiceStore) StoreIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { - fake.storeIngressMutex.Lock() - defer fake.storeIngressMutex.Unlock() - fake.StoreIngressStub = stub -} - -func (fake *FakeServiceStore) StoreIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { - fake.storeIngressMutex.RLock() - defer fake.storeIngressMutex.RUnlock() - argsForCall := fake.storeIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) StoreIngressReturns(result1 error) { - fake.storeIngressMutex.Lock() - defer fake.storeIngressMutex.Unlock() - fake.StoreIngressStub = nil - fake.storeIngressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) StoreIngressReturnsOnCall(i int, result1 error) { - fake.storeIngressMutex.Lock() - defer fake.storeIngressMutex.Unlock() - fake.StoreIngressStub = nil - if fake.storeIngressReturnsOnCall == nil { - fake.storeIngressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.storeIngressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) UpdateEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error { - fake.updateEgressMutex.Lock() - ret, specificReturn := fake.updateEgressReturnsOnCall[len(fake.updateEgressArgsForCall)] - fake.updateEgressArgsForCall = append(fake.updateEgressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.EgressInfo - }{arg1, arg2}) - stub := fake.UpdateEgressStub - fakeReturns := fake.updateEgressReturns - fake.recordInvocation("UpdateEgress", []interface{}{arg1, arg2}) - fake.updateEgressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeServiceStore) UpdateEgressCallCount() int { - fake.updateEgressMutex.RLock() - defer fake.updateEgressMutex.RUnlock() - return len(fake.updateEgressArgsForCall) -} - -func (fake *FakeServiceStore) UpdateEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) { - fake.updateEgressMutex.Lock() - defer fake.updateEgressMutex.Unlock() - fake.UpdateEgressStub = stub -} - -func (fake *FakeServiceStore) UpdateEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) { - fake.updateEgressMutex.RLock() - defer fake.updateEgressMutex.RUnlock() - argsForCall := fake.updateEgressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) UpdateEgressReturns(result1 error) { - fake.updateEgressMutex.Lock() - defer fake.updateEgressMutex.Unlock() - fake.UpdateEgressStub = nil - fake.updateEgressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) UpdateEgressReturnsOnCall(i int, result1 error) { - fake.updateEgressMutex.Lock() - defer fake.updateEgressMutex.Unlock() - fake.UpdateEgressStub = nil - if fake.updateEgressReturnsOnCall == nil { - fake.updateEgressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.updateEgressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) UpdateIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error { - fake.updateIngressMutex.Lock() - ret, specificReturn := fake.updateIngressReturnsOnCall[len(fake.updateIngressArgsForCall)] - fake.updateIngressArgsForCall = append(fake.updateIngressArgsForCall, struct { - arg1 context.Context - arg2 *livekit.IngressInfo - }{arg1, arg2}) - stub := fake.UpdateIngressStub - fakeReturns := fake.updateIngressReturns - fake.recordInvocation("UpdateIngress", []interface{}{arg1, arg2}) - fake.updateIngressMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeServiceStore) UpdateIngressCallCount() int { - fake.updateIngressMutex.RLock() - defer fake.updateIngressMutex.RUnlock() - return len(fake.updateIngressArgsForCall) -} - -func (fake *FakeServiceStore) UpdateIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) { - fake.updateIngressMutex.Lock() - defer fake.updateIngressMutex.Unlock() - fake.UpdateIngressStub = stub -} - -func (fake *FakeServiceStore) UpdateIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) { - fake.updateIngressMutex.RLock() - defer fake.updateIngressMutex.RUnlock() - argsForCall := fake.updateIngressArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeServiceStore) UpdateIngressReturns(result1 error) { - fake.updateIngressMutex.Lock() - defer fake.updateIngressMutex.Unlock() - fake.UpdateIngressStub = nil - fake.updateIngressReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceStore) UpdateIngressReturnsOnCall(i int, result1 error) { - fake.updateIngressMutex.Lock() - defer fake.updateIngressMutex.Unlock() - fake.UpdateIngressStub = nil - if fake.updateIngressReturnsOnCall == nil { - fake.updateIngressReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.updateIngressReturnsOnCall[i] = struct { - result1 error - }{result1} -} - func (fake *FakeServiceStore) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.deleteEgressMutex.RLock() - defer fake.deleteEgressMutex.RUnlock() - fake.deleteIngressMutex.RLock() - defer fake.deleteIngressMutex.RUnlock() - fake.listEgressMutex.RLock() - defer fake.listEgressMutex.RUnlock() - fake.listIngressMutex.RLock() - defer fake.listIngressMutex.RUnlock() fake.listParticipantsMutex.RLock() defer fake.listParticipantsMutex.RUnlock() fake.listRoomsMutex.RLock() defer fake.listRoomsMutex.RUnlock() - fake.loadEgressMutex.RLock() - defer fake.loadEgressMutex.RUnlock() - fake.loadIngressMutex.RLock() - defer fake.loadIngressMutex.RUnlock() - fake.loadIngressFromStreamKeyMutex.RLock() - defer fake.loadIngressFromStreamKeyMutex.RUnlock() fake.loadParticipantMutex.RLock() defer fake.loadParticipantMutex.RUnlock() fake.loadRoomMutex.RLock() defer fake.loadRoomMutex.RUnlock() - fake.storeEgressMutex.RLock() - defer fake.storeEgressMutex.RUnlock() - fake.storeIngressMutex.RLock() - defer fake.storeIngressMutex.RUnlock() - fake.updateEgressMutex.RLock() - defer fake.updateEgressMutex.RUnlock() - fake.updateIngressMutex.RLock() - defer fake.updateIngressMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/pkg/service/wire.go b/pkg/service/wire.go index 4669cc971..1d1c79b7e 100644 --- a/pkg/service/wire.go +++ b/pkg/service/wire.go @@ -42,6 +42,7 @@ func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*Live telemetry.NewAnalyticsService, telemetry.NewTelemetryService, egress.NewRedisRPCClient, + getEgressStore, NewEgressService, NewRoomAllocator, NewRoomService, @@ -165,6 +166,17 @@ func createStore(rc *redis.Client) ObjectStore { return NewLocalStore() } +func getEgressStore(s ObjectStore) EgressStore { + switch store := s.(type) { + case *RedisStore: + return store + case *LocalStore: + return store + default: + return nil + } +} + func createClientConfiguration() clientconfiguration.ClientConfigurationManager { return clientconfiguration.NewStaticClientConfigurationManager(clientconfiguration.StaticConfigurations) } diff --git a/pkg/service/wire_gen.go b/pkg/service/wire_gen.go index e23d40155..88a1525dc 100644 --- a/pkg/service/wire_gen.go +++ b/pkg/service/wire_gen.go @@ -49,6 +49,7 @@ func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*Live } nodeID := getNodeID(currentNode) rpcClient := egress.NewRedisRPCClient(nodeID, client) + egressStore := getEgressStore(objectStore) keyProvider, err := createKeyProvider(conf) if err != nil { return nil, err @@ -59,7 +60,7 @@ func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*Live } analyticsService := telemetry.NewAnalyticsService(conf, currentNode) telemetryService := telemetry.NewTelemetryService(notifier, analyticsService) - egressService := NewEgressService(rpcClient, objectStore, roomService, telemetryService) + egressService := NewEgressService(rpcClient, objectStore, egressStore, roomService, telemetryService) rtcService := NewRTCService(conf, roomAllocator, objectStore, router, currentNode) clientConfigurationManager := createClientConfiguration() roomManager, err := NewLocalRoomManager(conf, objectStore, currentNode, router, telemetryService, clientConfigurationManager) @@ -191,6 +192,17 @@ func createStore(rc *redis.Client) ObjectStore { return NewLocalStore() } +func getEgressStore(s ObjectStore) EgressStore { + switch store := s.(type) { + case *RedisStore: + return store + case *LocalStore: + return store + default: + return nil + } +} + func createClientConfiguration() clientconfiguration.ClientConfigurationManager { return clientconfiguration.NewStaticClientConfigurationManager(clientconfiguration.StaticConfigurations) }