snapshot of https://github.com/livekit/livekit.git @ 08c5433449c106943231037d0b892895f6e92d3b (2026-09-15)

pkg/service/servicefakes/fake_agent_store.go

@@ -0,0 +1,414 @@
+// 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 FakeAgentStore struct {
+	DeleteAgentDispatchStub        func(context.Context, *livekit.AgentDispatch) error
+	deleteAgentDispatchMutex       sync.RWMutex
+	deleteAgentDispatchArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.AgentDispatch
+	}
+	deleteAgentDispatchReturns struct {
+		result1 error
+	}
+	deleteAgentDispatchReturnsOnCall map[int]struct {
+		result1 error
+	}
+	DeleteAgentJobStub        func(context.Context, *livekit.Job) error
+	deleteAgentJobMutex       sync.RWMutex
+	deleteAgentJobArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.Job
+	}
+	deleteAgentJobReturns struct {
+		result1 error
+	}
+	deleteAgentJobReturnsOnCall map[int]struct {
+		result1 error
+	}
+	ListAgentDispatchesStub        func(context.Context, livekit.RoomName) ([]*livekit.AgentDispatch, error)
+	listAgentDispatchesMutex       sync.RWMutex
+	listAgentDispatchesArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	listAgentDispatchesReturns struct {
+		result1 []*livekit.AgentDispatch
+		result2 error
+	}
+	listAgentDispatchesReturnsOnCall map[int]struct {
+		result1 []*livekit.AgentDispatch
+		result2 error
+	}
+	StoreAgentDispatchStub        func(context.Context, *livekit.AgentDispatch) error
+	storeAgentDispatchMutex       sync.RWMutex
+	storeAgentDispatchArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.AgentDispatch
+	}
+	storeAgentDispatchReturns struct {
+		result1 error
+	}
+	storeAgentDispatchReturnsOnCall map[int]struct {
+		result1 error
+	}
+	StoreAgentJobStub        func(context.Context, *livekit.Job) error
+	storeAgentJobMutex       sync.RWMutex
+	storeAgentJobArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.Job
+	}
+	storeAgentJobReturns struct {
+		result1 error
+	}
+	storeAgentJobReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeAgentStore) DeleteAgentDispatch(arg1 context.Context, arg2 *livekit.AgentDispatch) error {
+	fake.deleteAgentDispatchMutex.Lock()
+	ret, specificReturn := fake.deleteAgentDispatchReturnsOnCall[len(fake.deleteAgentDispatchArgsForCall)]
+	fake.deleteAgentDispatchArgsForCall = append(fake.deleteAgentDispatchArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.AgentDispatch
+	}{arg1, arg2})
+	stub := fake.DeleteAgentDispatchStub
+	fakeReturns := fake.deleteAgentDispatchReturns
+	fake.recordInvocation("DeleteAgentDispatch", []interface{}{arg1, arg2})
+	fake.deleteAgentDispatchMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeAgentStore) DeleteAgentDispatchCallCount() int {
+	fake.deleteAgentDispatchMutex.RLock()
+	defer fake.deleteAgentDispatchMutex.RUnlock()
+	return len(fake.deleteAgentDispatchArgsForCall)
+}
+
+func (fake *FakeAgentStore) DeleteAgentDispatchCalls(stub func(context.Context, *livekit.AgentDispatch) error) {
+	fake.deleteAgentDispatchMutex.Lock()
+	defer fake.deleteAgentDispatchMutex.Unlock()
+	fake.DeleteAgentDispatchStub = stub
+}
+
+func (fake *FakeAgentStore) DeleteAgentDispatchArgsForCall(i int) (context.Context, *livekit.AgentDispatch) {
+	fake.deleteAgentDispatchMutex.RLock()
+	defer fake.deleteAgentDispatchMutex.RUnlock()
+	argsForCall := fake.deleteAgentDispatchArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeAgentStore) DeleteAgentDispatchReturns(result1 error) {
+	fake.deleteAgentDispatchMutex.Lock()
+	defer fake.deleteAgentDispatchMutex.Unlock()
+	fake.DeleteAgentDispatchStub = nil
+	fake.deleteAgentDispatchReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) DeleteAgentDispatchReturnsOnCall(i int, result1 error) {
+	fake.deleteAgentDispatchMutex.Lock()
+	defer fake.deleteAgentDispatchMutex.Unlock()
+	fake.DeleteAgentDispatchStub = nil
+	if fake.deleteAgentDispatchReturnsOnCall == nil {
+		fake.deleteAgentDispatchReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.deleteAgentDispatchReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) DeleteAgentJob(arg1 context.Context, arg2 *livekit.Job) error {
+	fake.deleteAgentJobMutex.Lock()
+	ret, specificReturn := fake.deleteAgentJobReturnsOnCall[len(fake.deleteAgentJobArgsForCall)]
+	fake.deleteAgentJobArgsForCall = append(fake.deleteAgentJobArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.Job
+	}{arg1, arg2})
+	stub := fake.DeleteAgentJobStub
+	fakeReturns := fake.deleteAgentJobReturns
+	fake.recordInvocation("DeleteAgentJob", []interface{}{arg1, arg2})
+	fake.deleteAgentJobMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeAgentStore) DeleteAgentJobCallCount() int {
+	fake.deleteAgentJobMutex.RLock()
+	defer fake.deleteAgentJobMutex.RUnlock()
+	return len(fake.deleteAgentJobArgsForCall)
+}
+
+func (fake *FakeAgentStore) DeleteAgentJobCalls(stub func(context.Context, *livekit.Job) error) {
+	fake.deleteAgentJobMutex.Lock()
+	defer fake.deleteAgentJobMutex.Unlock()
+	fake.DeleteAgentJobStub = stub
+}
+
+func (fake *FakeAgentStore) DeleteAgentJobArgsForCall(i int) (context.Context, *livekit.Job) {
+	fake.deleteAgentJobMutex.RLock()
+	defer fake.deleteAgentJobMutex.RUnlock()
+	argsForCall := fake.deleteAgentJobArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeAgentStore) DeleteAgentJobReturns(result1 error) {
+	fake.deleteAgentJobMutex.Lock()
+	defer fake.deleteAgentJobMutex.Unlock()
+	fake.DeleteAgentJobStub = nil
+	fake.deleteAgentJobReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) DeleteAgentJobReturnsOnCall(i int, result1 error) {
+	fake.deleteAgentJobMutex.Lock()
+	defer fake.deleteAgentJobMutex.Unlock()
+	fake.DeleteAgentJobStub = nil
+	if fake.deleteAgentJobReturnsOnCall == nil {
+		fake.deleteAgentJobReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.deleteAgentJobReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) ListAgentDispatches(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.AgentDispatch, error) {
+	fake.listAgentDispatchesMutex.Lock()
+	ret, specificReturn := fake.listAgentDispatchesReturnsOnCall[len(fake.listAgentDispatchesArgsForCall)]
+	fake.listAgentDispatchesArgsForCall = append(fake.listAgentDispatchesArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.ListAgentDispatchesStub
+	fakeReturns := fake.listAgentDispatchesReturns
+	fake.recordInvocation("ListAgentDispatches", []interface{}{arg1, arg2})
+	fake.listAgentDispatchesMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeAgentStore) ListAgentDispatchesCallCount() int {
+	fake.listAgentDispatchesMutex.RLock()
+	defer fake.listAgentDispatchesMutex.RUnlock()
+	return len(fake.listAgentDispatchesArgsForCall)
+}
+
+func (fake *FakeAgentStore) ListAgentDispatchesCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.AgentDispatch, error)) {
+	fake.listAgentDispatchesMutex.Lock()
+	defer fake.listAgentDispatchesMutex.Unlock()
+	fake.ListAgentDispatchesStub = stub
+}
+
+func (fake *FakeAgentStore) ListAgentDispatchesArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.listAgentDispatchesMutex.RLock()
+	defer fake.listAgentDispatchesMutex.RUnlock()
+	argsForCall := fake.listAgentDispatchesArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeAgentStore) ListAgentDispatchesReturns(result1 []*livekit.AgentDispatch, result2 error) {
+	fake.listAgentDispatchesMutex.Lock()
+	defer fake.listAgentDispatchesMutex.Unlock()
+	fake.ListAgentDispatchesStub = nil
+	fake.listAgentDispatchesReturns = struct {
+		result1 []*livekit.AgentDispatch
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeAgentStore) ListAgentDispatchesReturnsOnCall(i int, result1 []*livekit.AgentDispatch, result2 error) {
+	fake.listAgentDispatchesMutex.Lock()
+	defer fake.listAgentDispatchesMutex.Unlock()
+	fake.ListAgentDispatchesStub = nil
+	if fake.listAgentDispatchesReturnsOnCall == nil {
+		fake.listAgentDispatchesReturnsOnCall = make(map[int]struct {
+			result1 []*livekit.AgentDispatch
+			result2 error
+		})
+	}
+	fake.listAgentDispatchesReturnsOnCall[i] = struct {
+		result1 []*livekit.AgentDispatch
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeAgentStore) StoreAgentDispatch(arg1 context.Context, arg2 *livekit.AgentDispatch) error {
+	fake.storeAgentDispatchMutex.Lock()
+	ret, specificReturn := fake.storeAgentDispatchReturnsOnCall[len(fake.storeAgentDispatchArgsForCall)]
+	fake.storeAgentDispatchArgsForCall = append(fake.storeAgentDispatchArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.AgentDispatch
+	}{arg1, arg2})
+	stub := fake.StoreAgentDispatchStub
+	fakeReturns := fake.storeAgentDispatchReturns
+	fake.recordInvocation("StoreAgentDispatch", []interface{}{arg1, arg2})
+	fake.storeAgentDispatchMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeAgentStore) StoreAgentDispatchCallCount() int {
+	fake.storeAgentDispatchMutex.RLock()
+	defer fake.storeAgentDispatchMutex.RUnlock()
+	return len(fake.storeAgentDispatchArgsForCall)
+}
+
+func (fake *FakeAgentStore) StoreAgentDispatchCalls(stub func(context.Context, *livekit.AgentDispatch) error) {
+	fake.storeAgentDispatchMutex.Lock()
+	defer fake.storeAgentDispatchMutex.Unlock()
+	fake.StoreAgentDispatchStub = stub
+}
+
+func (fake *FakeAgentStore) StoreAgentDispatchArgsForCall(i int) (context.Context, *livekit.AgentDispatch) {
+	fake.storeAgentDispatchMutex.RLock()
+	defer fake.storeAgentDispatchMutex.RUnlock()
+	argsForCall := fake.storeAgentDispatchArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeAgentStore) StoreAgentDispatchReturns(result1 error) {
+	fake.storeAgentDispatchMutex.Lock()
+	defer fake.storeAgentDispatchMutex.Unlock()
+	fake.StoreAgentDispatchStub = nil
+	fake.storeAgentDispatchReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) StoreAgentDispatchReturnsOnCall(i int, result1 error) {
+	fake.storeAgentDispatchMutex.Lock()
+	defer fake.storeAgentDispatchMutex.Unlock()
+	fake.StoreAgentDispatchStub = nil
+	if fake.storeAgentDispatchReturnsOnCall == nil {
+		fake.storeAgentDispatchReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.storeAgentDispatchReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) StoreAgentJob(arg1 context.Context, arg2 *livekit.Job) error {
+	fake.storeAgentJobMutex.Lock()
+	ret, specificReturn := fake.storeAgentJobReturnsOnCall[len(fake.storeAgentJobArgsForCall)]
+	fake.storeAgentJobArgsForCall = append(fake.storeAgentJobArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.Job
+	}{arg1, arg2})
+	stub := fake.StoreAgentJobStub
+	fakeReturns := fake.storeAgentJobReturns
+	fake.recordInvocation("StoreAgentJob", []interface{}{arg1, arg2})
+	fake.storeAgentJobMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeAgentStore) StoreAgentJobCallCount() int {
+	fake.storeAgentJobMutex.RLock()
+	defer fake.storeAgentJobMutex.RUnlock()
+	return len(fake.storeAgentJobArgsForCall)
+}
+
+func (fake *FakeAgentStore) StoreAgentJobCalls(stub func(context.Context, *livekit.Job) error) {
+	fake.storeAgentJobMutex.Lock()
+	defer fake.storeAgentJobMutex.Unlock()
+	fake.StoreAgentJobStub = stub
+}
+
+func (fake *FakeAgentStore) StoreAgentJobArgsForCall(i int) (context.Context, *livekit.Job) {
+	fake.storeAgentJobMutex.RLock()
+	defer fake.storeAgentJobMutex.RUnlock()
+	argsForCall := fake.storeAgentJobArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeAgentStore) StoreAgentJobReturns(result1 error) {
+	fake.storeAgentJobMutex.Lock()
+	defer fake.storeAgentJobMutex.Unlock()
+	fake.StoreAgentJobStub = nil
+	fake.storeAgentJobReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) StoreAgentJobReturnsOnCall(i int, result1 error) {
+	fake.storeAgentJobMutex.Lock()
+	defer fake.storeAgentJobMutex.Unlock()
+	fake.StoreAgentJobStub = nil
+	if fake.storeAgentJobReturnsOnCall == nil {
+		fake.storeAgentJobReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.storeAgentJobReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeAgentStore) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeAgentStore) 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.AgentStore = new(FakeAgentStore)

pkg/service/servicefakes/fake_egress_store.go

@@ -0,0 +1,347 @@
+// 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 {
+	ListEgressStub        func(context.Context, livekit.RoomName, bool) ([]*livekit.EgressInfo, error)
+	listEgressMutex       sync.RWMutex
+	listEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 bool
+	}
+	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) ListEgress(arg1 context.Context, arg2 livekit.RoomName, arg3 bool) ([]*livekit.EgressInfo, error) {
+	fake.listEgressMutex.Lock()
+	ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)]
+	fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 bool
+	}{arg1, arg2, arg3})
+	stub := fake.ListEgressStub
+	fakeReturns := fake.listEgressReturns
+	fake.recordInvocation("ListEgress", []interface{}{arg1, arg2, arg3})
+	fake.listEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	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.RoomName, bool) ([]*livekit.EgressInfo, error)) {
+	fake.listEgressMutex.Lock()
+	defer fake.listEgressMutex.Unlock()
+	fake.ListEgressStub = stub
+}
+
+func (fake *FakeEgressStore) ListEgressArgsForCall(i int) (context.Context, livekit.RoomName, bool) {
+	fake.listEgressMutex.RLock()
+	defer fake.listEgressMutex.RUnlock()
+	argsForCall := fake.listEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+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()
+	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)

pkg/service/servicefakes/fake_ingress_launcher.go

@@ -0,0 +1,118 @@
+// 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 FakeIngressLauncher struct {
+	LaunchPullIngressStub        func(context.Context, *livekit.IngressInfo) (*livekit.IngressInfo, error)
+	launchPullIngressMutex       sync.RWMutex
+	launchPullIngressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}
+	launchPullIngressReturns struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}
+	launchPullIngressReturnsOnCall map[int]struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeIngressLauncher) LaunchPullIngress(arg1 context.Context, arg2 *livekit.IngressInfo) (*livekit.IngressInfo, error) {
+	fake.launchPullIngressMutex.Lock()
+	ret, specificReturn := fake.launchPullIngressReturnsOnCall[len(fake.launchPullIngressArgsForCall)]
+	fake.launchPullIngressArgsForCall = append(fake.launchPullIngressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}{arg1, arg2})
+	stub := fake.LaunchPullIngressStub
+	fakeReturns := fake.launchPullIngressReturns
+	fake.recordInvocation("LaunchPullIngress", []interface{}{arg1, arg2})
+	fake.launchPullIngressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIngressLauncher) LaunchPullIngressCallCount() int {
+	fake.launchPullIngressMutex.RLock()
+	defer fake.launchPullIngressMutex.RUnlock()
+	return len(fake.launchPullIngressArgsForCall)
+}
+
+func (fake *FakeIngressLauncher) LaunchPullIngressCalls(stub func(context.Context, *livekit.IngressInfo) (*livekit.IngressInfo, error)) {
+	fake.launchPullIngressMutex.Lock()
+	defer fake.launchPullIngressMutex.Unlock()
+	fake.LaunchPullIngressStub = stub
+}
+
+func (fake *FakeIngressLauncher) LaunchPullIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
+	fake.launchPullIngressMutex.RLock()
+	defer fake.launchPullIngressMutex.RUnlock()
+	argsForCall := fake.launchPullIngressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIngressLauncher) LaunchPullIngressReturns(result1 *livekit.IngressInfo, result2 error) {
+	fake.launchPullIngressMutex.Lock()
+	defer fake.launchPullIngressMutex.Unlock()
+	fake.LaunchPullIngressStub = nil
+	fake.launchPullIngressReturns = struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressLauncher) LaunchPullIngressReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) {
+	fake.launchPullIngressMutex.Lock()
+	defer fake.launchPullIngressMutex.Unlock()
+	fake.LaunchPullIngressStub = nil
+	if fake.launchPullIngressReturnsOnCall == nil {
+		fake.launchPullIngressReturnsOnCall = make(map[int]struct {
+			result1 *livekit.IngressInfo
+			result2 error
+		})
+	}
+	fake.launchPullIngressReturnsOnCall[i] = struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressLauncher) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeIngressLauncher) 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.IngressLauncher = new(FakeIngressLauncher)

pkg/service/servicefakes/fake_ingress_store.go

@@ -0,0 +1,574 @@
+// 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
+	}
+	UpdateIngressStateStub        func(context.Context, string, *livekit.IngressState) error
+	updateIngressStateMutex       sync.RWMutex
+	updateIngressStateArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+		arg3 *livekit.IngressState
+	}
+	updateIngressStateReturns struct {
+		result1 error
+	}
+	updateIngressStateReturnsOnCall 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) UpdateIngressState(arg1 context.Context, arg2 string, arg3 *livekit.IngressState) error {
+	fake.updateIngressStateMutex.Lock()
+	ret, specificReturn := fake.updateIngressStateReturnsOnCall[len(fake.updateIngressStateArgsForCall)]
+	fake.updateIngressStateArgsForCall = append(fake.updateIngressStateArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+		arg3 *livekit.IngressState
+	}{arg1, arg2, arg3})
+	stub := fake.UpdateIngressStateStub
+	fakeReturns := fake.updateIngressStateReturns
+	fake.recordInvocation("UpdateIngressState", []interface{}{arg1, arg2, arg3})
+	fake.updateIngressStateMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeIngressStore) UpdateIngressStateCallCount() int {
+	fake.updateIngressStateMutex.RLock()
+	defer fake.updateIngressStateMutex.RUnlock()
+	return len(fake.updateIngressStateArgsForCall)
+}
+
+func (fake *FakeIngressStore) UpdateIngressStateCalls(stub func(context.Context, string, *livekit.IngressState) error) {
+	fake.updateIngressStateMutex.Lock()
+	defer fake.updateIngressStateMutex.Unlock()
+	fake.UpdateIngressStateStub = stub
+}
+
+func (fake *FakeIngressStore) UpdateIngressStateArgsForCall(i int) (context.Context, string, *livekit.IngressState) {
+	fake.updateIngressStateMutex.RLock()
+	defer fake.updateIngressStateMutex.RUnlock()
+	argsForCall := fake.updateIngressStateArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeIngressStore) UpdateIngressStateReturns(result1 error) {
+	fake.updateIngressStateMutex.Lock()
+	defer fake.updateIngressStateMutex.Unlock()
+	fake.UpdateIngressStateStub = nil
+	fake.updateIngressStateReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) UpdateIngressStateReturnsOnCall(i int, result1 error) {
+	fake.updateIngressStateMutex.Lock()
+	defer fake.updateIngressStateMutex.Unlock()
+	fake.UpdateIngressStateStub = nil
+	if fake.updateIngressStateReturnsOnCall == nil {
+		fake.updateIngressStateReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.updateIngressStateReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.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)

pkg/service/servicefakes/fake_ioclient.go

@@ -0,0 +1,436 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package servicefakes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/service"
+	"github.com/livekit/protocol/livekit"
+	"github.com/livekit/protocol/rpc"
+	"google.golang.org/protobuf/types/known/emptypb"
+)
+
+type FakeIOClient struct {
+	CreateEgressStub        func(context.Context, *livekit.EgressInfo) (*emptypb.Empty, error)
+	createEgressMutex       sync.RWMutex
+	createEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}
+	createEgressReturns struct {
+		result1 *emptypb.Empty
+		result2 error
+	}
+	createEgressReturnsOnCall map[int]struct {
+		result1 *emptypb.Empty
+		result2 error
+	}
+	CreateIngressStub        func(context.Context, *livekit.IngressInfo) (*rpc.CreateIngressResponse, error)
+	createIngressMutex       sync.RWMutex
+	createIngressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}
+	createIngressReturns struct {
+		result1 *rpc.CreateIngressResponse
+		result2 error
+	}
+	createIngressReturnsOnCall map[int]struct {
+		result1 *rpc.CreateIngressResponse
+		result2 error
+	}
+	GetEgressStub        func(context.Context, *rpc.GetEgressRequest) (*livekit.EgressInfo, error)
+	getEgressMutex       sync.RWMutex
+	getEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *rpc.GetEgressRequest
+	}
+	getEgressReturns struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}
+	getEgressReturnsOnCall map[int]struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}
+	ListEgressStub        func(context.Context, *livekit.ListEgressRequest) (*livekit.ListEgressResponse, error)
+	listEgressMutex       sync.RWMutex
+	listEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.ListEgressRequest
+	}
+	listEgressReturns struct {
+		result1 *livekit.ListEgressResponse
+		result2 error
+	}
+	listEgressReturnsOnCall map[int]struct {
+		result1 *livekit.ListEgressResponse
+		result2 error
+	}
+	UpdateIngressStateStub        func(context.Context, *rpc.UpdateIngressStateRequest) (*emptypb.Empty, error)
+	updateIngressStateMutex       sync.RWMutex
+	updateIngressStateArgsForCall []struct {
+		arg1 context.Context
+		arg2 *rpc.UpdateIngressStateRequest
+	}
+	updateIngressStateReturns struct {
+		result1 *emptypb.Empty
+		result2 error
+	}
+	updateIngressStateReturnsOnCall map[int]struct {
+		result1 *emptypb.Empty
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeIOClient) CreateEgress(arg1 context.Context, arg2 *livekit.EgressInfo) (*emptypb.Empty, error) {
+	fake.createEgressMutex.Lock()
+	ret, specificReturn := fake.createEgressReturnsOnCall[len(fake.createEgressArgsForCall)]
+	fake.createEgressArgsForCall = append(fake.createEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}{arg1, arg2})
+	stub := fake.CreateEgressStub
+	fakeReturns := fake.createEgressReturns
+	fake.recordInvocation("CreateEgress", []interface{}{arg1, arg2})
+	fake.createEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIOClient) CreateEgressCallCount() int {
+	fake.createEgressMutex.RLock()
+	defer fake.createEgressMutex.RUnlock()
+	return len(fake.createEgressArgsForCall)
+}
+
+func (fake *FakeIOClient) CreateEgressCalls(stub func(context.Context, *livekit.EgressInfo) (*emptypb.Empty, error)) {
+	fake.createEgressMutex.Lock()
+	defer fake.createEgressMutex.Unlock()
+	fake.CreateEgressStub = stub
+}
+
+func (fake *FakeIOClient) CreateEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
+	fake.createEgressMutex.RLock()
+	defer fake.createEgressMutex.RUnlock()
+	argsForCall := fake.createEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIOClient) CreateEgressReturns(result1 *emptypb.Empty, result2 error) {
+	fake.createEgressMutex.Lock()
+	defer fake.createEgressMutex.Unlock()
+	fake.CreateEgressStub = nil
+	fake.createEgressReturns = struct {
+		result1 *emptypb.Empty
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) CreateEgressReturnsOnCall(i int, result1 *emptypb.Empty, result2 error) {
+	fake.createEgressMutex.Lock()
+	defer fake.createEgressMutex.Unlock()
+	fake.CreateEgressStub = nil
+	if fake.createEgressReturnsOnCall == nil {
+		fake.createEgressReturnsOnCall = make(map[int]struct {
+			result1 *emptypb.Empty
+			result2 error
+		})
+	}
+	fake.createEgressReturnsOnCall[i] = struct {
+		result1 *emptypb.Empty
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) CreateIngress(arg1 context.Context, arg2 *livekit.IngressInfo) (*rpc.CreateIngressResponse, error) {
+	fake.createIngressMutex.Lock()
+	ret, specificReturn := fake.createIngressReturnsOnCall[len(fake.createIngressArgsForCall)]
+	fake.createIngressArgsForCall = append(fake.createIngressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}{arg1, arg2})
+	stub := fake.CreateIngressStub
+	fakeReturns := fake.createIngressReturns
+	fake.recordInvocation("CreateIngress", []interface{}{arg1, arg2})
+	fake.createIngressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIOClient) CreateIngressCallCount() int {
+	fake.createIngressMutex.RLock()
+	defer fake.createIngressMutex.RUnlock()
+	return len(fake.createIngressArgsForCall)
+}
+
+func (fake *FakeIOClient) CreateIngressCalls(stub func(context.Context, *livekit.IngressInfo) (*rpc.CreateIngressResponse, error)) {
+	fake.createIngressMutex.Lock()
+	defer fake.createIngressMutex.Unlock()
+	fake.CreateIngressStub = stub
+}
+
+func (fake *FakeIOClient) CreateIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
+	fake.createIngressMutex.RLock()
+	defer fake.createIngressMutex.RUnlock()
+	argsForCall := fake.createIngressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIOClient) CreateIngressReturns(result1 *rpc.CreateIngressResponse, result2 error) {
+	fake.createIngressMutex.Lock()
+	defer fake.createIngressMutex.Unlock()
+	fake.CreateIngressStub = nil
+	fake.createIngressReturns = struct {
+		result1 *rpc.CreateIngressResponse
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) CreateIngressReturnsOnCall(i int, result1 *rpc.CreateIngressResponse, result2 error) {
+	fake.createIngressMutex.Lock()
+	defer fake.createIngressMutex.Unlock()
+	fake.CreateIngressStub = nil
+	if fake.createIngressReturnsOnCall == nil {
+		fake.createIngressReturnsOnCall = make(map[int]struct {
+			result1 *rpc.CreateIngressResponse
+			result2 error
+		})
+	}
+	fake.createIngressReturnsOnCall[i] = struct {
+		result1 *rpc.CreateIngressResponse
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) GetEgress(arg1 context.Context, arg2 *rpc.GetEgressRequest) (*livekit.EgressInfo, error) {
+	fake.getEgressMutex.Lock()
+	ret, specificReturn := fake.getEgressReturnsOnCall[len(fake.getEgressArgsForCall)]
+	fake.getEgressArgsForCall = append(fake.getEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *rpc.GetEgressRequest
+	}{arg1, arg2})
+	stub := fake.GetEgressStub
+	fakeReturns := fake.getEgressReturns
+	fake.recordInvocation("GetEgress", []interface{}{arg1, arg2})
+	fake.getEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIOClient) GetEgressCallCount() int {
+	fake.getEgressMutex.RLock()
+	defer fake.getEgressMutex.RUnlock()
+	return len(fake.getEgressArgsForCall)
+}
+
+func (fake *FakeIOClient) GetEgressCalls(stub func(context.Context, *rpc.GetEgressRequest) (*livekit.EgressInfo, error)) {
+	fake.getEgressMutex.Lock()
+	defer fake.getEgressMutex.Unlock()
+	fake.GetEgressStub = stub
+}
+
+func (fake *FakeIOClient) GetEgressArgsForCall(i int) (context.Context, *rpc.GetEgressRequest) {
+	fake.getEgressMutex.RLock()
+	defer fake.getEgressMutex.RUnlock()
+	argsForCall := fake.getEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIOClient) GetEgressReturns(result1 *livekit.EgressInfo, result2 error) {
+	fake.getEgressMutex.Lock()
+	defer fake.getEgressMutex.Unlock()
+	fake.GetEgressStub = nil
+	fake.getEgressReturns = struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) GetEgressReturnsOnCall(i int, result1 *livekit.EgressInfo, result2 error) {
+	fake.getEgressMutex.Lock()
+	defer fake.getEgressMutex.Unlock()
+	fake.GetEgressStub = nil
+	if fake.getEgressReturnsOnCall == nil {
+		fake.getEgressReturnsOnCall = make(map[int]struct {
+			result1 *livekit.EgressInfo
+			result2 error
+		})
+	}
+	fake.getEgressReturnsOnCall[i] = struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) ListEgress(arg1 context.Context, arg2 *livekit.ListEgressRequest) (*livekit.ListEgressResponse, error) {
+	fake.listEgressMutex.Lock()
+	ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)]
+	fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.ListEgressRequest
+	}{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 *FakeIOClient) ListEgressCallCount() int {
+	fake.listEgressMutex.RLock()
+	defer fake.listEgressMutex.RUnlock()
+	return len(fake.listEgressArgsForCall)
+}
+
+func (fake *FakeIOClient) ListEgressCalls(stub func(context.Context, *livekit.ListEgressRequest) (*livekit.ListEgressResponse, error)) {
+	fake.listEgressMutex.Lock()
+	defer fake.listEgressMutex.Unlock()
+	fake.ListEgressStub = stub
+}
+
+func (fake *FakeIOClient) ListEgressArgsForCall(i int) (context.Context, *livekit.ListEgressRequest) {
+	fake.listEgressMutex.RLock()
+	defer fake.listEgressMutex.RUnlock()
+	argsForCall := fake.listEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIOClient) ListEgressReturns(result1 *livekit.ListEgressResponse, result2 error) {
+	fake.listEgressMutex.Lock()
+	defer fake.listEgressMutex.Unlock()
+	fake.ListEgressStub = nil
+	fake.listEgressReturns = struct {
+		result1 *livekit.ListEgressResponse
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) ListEgressReturnsOnCall(i int, result1 *livekit.ListEgressResponse, result2 error) {
+	fake.listEgressMutex.Lock()
+	defer fake.listEgressMutex.Unlock()
+	fake.ListEgressStub = nil
+	if fake.listEgressReturnsOnCall == nil {
+		fake.listEgressReturnsOnCall = make(map[int]struct {
+			result1 *livekit.ListEgressResponse
+			result2 error
+		})
+	}
+	fake.listEgressReturnsOnCall[i] = struct {
+		result1 *livekit.ListEgressResponse
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) UpdateIngressState(arg1 context.Context, arg2 *rpc.UpdateIngressStateRequest) (*emptypb.Empty, error) {
+	fake.updateIngressStateMutex.Lock()
+	ret, specificReturn := fake.updateIngressStateReturnsOnCall[len(fake.updateIngressStateArgsForCall)]
+	fake.updateIngressStateArgsForCall = append(fake.updateIngressStateArgsForCall, struct {
+		arg1 context.Context
+		arg2 *rpc.UpdateIngressStateRequest
+	}{arg1, arg2})
+	stub := fake.UpdateIngressStateStub
+	fakeReturns := fake.updateIngressStateReturns
+	fake.recordInvocation("UpdateIngressState", []interface{}{arg1, arg2})
+	fake.updateIngressStateMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIOClient) UpdateIngressStateCallCount() int {
+	fake.updateIngressStateMutex.RLock()
+	defer fake.updateIngressStateMutex.RUnlock()
+	return len(fake.updateIngressStateArgsForCall)
+}
+
+func (fake *FakeIOClient) UpdateIngressStateCalls(stub func(context.Context, *rpc.UpdateIngressStateRequest) (*emptypb.Empty, error)) {
+	fake.updateIngressStateMutex.Lock()
+	defer fake.updateIngressStateMutex.Unlock()
+	fake.UpdateIngressStateStub = stub
+}
+
+func (fake *FakeIOClient) UpdateIngressStateArgsForCall(i int) (context.Context, *rpc.UpdateIngressStateRequest) {
+	fake.updateIngressStateMutex.RLock()
+	defer fake.updateIngressStateMutex.RUnlock()
+	argsForCall := fake.updateIngressStateArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIOClient) UpdateIngressStateReturns(result1 *emptypb.Empty, result2 error) {
+	fake.updateIngressStateMutex.Lock()
+	defer fake.updateIngressStateMutex.Unlock()
+	fake.UpdateIngressStateStub = nil
+	fake.updateIngressStateReturns = struct {
+		result1 *emptypb.Empty
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) UpdateIngressStateReturnsOnCall(i int, result1 *emptypb.Empty, result2 error) {
+	fake.updateIngressStateMutex.Lock()
+	defer fake.updateIngressStateMutex.Unlock()
+	fake.UpdateIngressStateStub = nil
+	if fake.updateIngressStateReturnsOnCall == nil {
+		fake.updateIngressStateReturnsOnCall = make(map[int]struct {
+			result1 *emptypb.Empty
+			result2 error
+		})
+	}
+	fake.updateIngressStateReturnsOnCall[i] = struct {
+		result1 *emptypb.Empty
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIOClient) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeIOClient) 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.IOClient = new(FakeIOClient)

pkg/service/servicefakes/fake_object_store.go

@@ -0,0 +1,989 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package servicefakes
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/livekit/livekit-server/pkg/service"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeObjectStore struct {
+	DeleteParticipantStub        func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) error
+	deleteParticipantMutex       sync.RWMutex
+	deleteParticipantArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.ParticipantIdentity
+	}
+	deleteParticipantReturns struct {
+		result1 error
+	}
+	deleteParticipantReturnsOnCall map[int]struct {
+		result1 error
+	}
+	DeleteRoomStub        func(context.Context, livekit.RoomName) error
+	deleteRoomMutex       sync.RWMutex
+	deleteRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	deleteRoomReturns struct {
+		result1 error
+	}
+	deleteRoomReturnsOnCall map[int]struct {
+		result1 error
+	}
+	HasParticipantStub        func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (bool, error)
+	hasParticipantMutex       sync.RWMutex
+	hasParticipantArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.ParticipantIdentity
+	}
+	hasParticipantReturns struct {
+		result1 bool
+		result2 error
+	}
+	hasParticipantReturnsOnCall map[int]struct {
+		result1 bool
+		result2 error
+	}
+	ListParticipantsStub        func(context.Context, livekit.RoomName) ([]*livekit.ParticipantInfo, error)
+	listParticipantsMutex       sync.RWMutex
+	listParticipantsArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	listParticipantsReturns struct {
+		result1 []*livekit.ParticipantInfo
+		result2 error
+	}
+	listParticipantsReturnsOnCall map[int]struct {
+		result1 []*livekit.ParticipantInfo
+		result2 error
+	}
+	ListRoomsStub        func(context.Context, []livekit.RoomName) ([]*livekit.Room, error)
+	listRoomsMutex       sync.RWMutex
+	listRoomsArgsForCall []struct {
+		arg1 context.Context
+		arg2 []livekit.RoomName
+	}
+	listRoomsReturns struct {
+		result1 []*livekit.Room
+		result2 error
+	}
+	listRoomsReturnsOnCall map[int]struct {
+		result1 []*livekit.Room
+		result2 error
+	}
+	LoadParticipantStub        func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error)
+	loadParticipantMutex       sync.RWMutex
+	loadParticipantArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.ParticipantIdentity
+	}
+	loadParticipantReturns struct {
+		result1 *livekit.ParticipantInfo
+		result2 error
+	}
+	loadParticipantReturnsOnCall map[int]struct {
+		result1 *livekit.ParticipantInfo
+		result2 error
+	}
+	LoadRoomStub        func(context.Context, livekit.RoomName, bool) (*livekit.Room, *livekit.RoomInternal, error)
+	loadRoomMutex       sync.RWMutex
+	loadRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 bool
+	}
+	loadRoomReturns struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}
+	loadRoomReturnsOnCall map[int]struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}
+	LockRoomStub        func(context.Context, livekit.RoomName, time.Duration) (string, error)
+	lockRoomMutex       sync.RWMutex
+	lockRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 time.Duration
+	}
+	lockRoomReturns struct {
+		result1 string
+		result2 error
+	}
+	lockRoomReturnsOnCall map[int]struct {
+		result1 string
+		result2 error
+	}
+	RoomExistsStub        func(context.Context, livekit.RoomName) (bool, error)
+	roomExistsMutex       sync.RWMutex
+	roomExistsArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	roomExistsReturns struct {
+		result1 bool
+		result2 error
+	}
+	roomExistsReturnsOnCall map[int]struct {
+		result1 bool
+		result2 error
+	}
+	StoreParticipantStub        func(context.Context, livekit.RoomName, *livekit.ParticipantInfo) error
+	storeParticipantMutex       sync.RWMutex
+	storeParticipantArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 *livekit.ParticipantInfo
+	}
+	storeParticipantReturns struct {
+		result1 error
+	}
+	storeParticipantReturnsOnCall map[int]struct {
+		result1 error
+	}
+	StoreRoomStub        func(context.Context, *livekit.Room, *livekit.RoomInternal) error
+	storeRoomMutex       sync.RWMutex
+	storeRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.Room
+		arg3 *livekit.RoomInternal
+	}
+	storeRoomReturns struct {
+		result1 error
+	}
+	storeRoomReturnsOnCall map[int]struct {
+		result1 error
+	}
+	UnlockRoomStub        func(context.Context, livekit.RoomName, string) error
+	unlockRoomMutex       sync.RWMutex
+	unlockRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 string
+	}
+	unlockRoomReturns struct {
+		result1 error
+	}
+	unlockRoomReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeObjectStore) DeleteParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) error {
+	fake.deleteParticipantMutex.Lock()
+	ret, specificReturn := fake.deleteParticipantReturnsOnCall[len(fake.deleteParticipantArgsForCall)]
+	fake.deleteParticipantArgsForCall = append(fake.deleteParticipantArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.ParticipantIdentity
+	}{arg1, arg2, arg3})
+	stub := fake.DeleteParticipantStub
+	fakeReturns := fake.deleteParticipantReturns
+	fake.recordInvocation("DeleteParticipant", []interface{}{arg1, arg2, arg3})
+	fake.deleteParticipantMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeObjectStore) DeleteParticipantCallCount() int {
+	fake.deleteParticipantMutex.RLock()
+	defer fake.deleteParticipantMutex.RUnlock()
+	return len(fake.deleteParticipantArgsForCall)
+}
+
+func (fake *FakeObjectStore) DeleteParticipantCalls(stub func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) error) {
+	fake.deleteParticipantMutex.Lock()
+	defer fake.deleteParticipantMutex.Unlock()
+	fake.DeleteParticipantStub = stub
+}
+
+func (fake *FakeObjectStore) DeleteParticipantArgsForCall(i int) (context.Context, livekit.RoomName, livekit.ParticipantIdentity) {
+	fake.deleteParticipantMutex.RLock()
+	defer fake.deleteParticipantMutex.RUnlock()
+	argsForCall := fake.deleteParticipantArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) DeleteParticipantReturns(result1 error) {
+	fake.deleteParticipantMutex.Lock()
+	defer fake.deleteParticipantMutex.Unlock()
+	fake.DeleteParticipantStub = nil
+	fake.deleteParticipantReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) DeleteParticipantReturnsOnCall(i int, result1 error) {
+	fake.deleteParticipantMutex.Lock()
+	defer fake.deleteParticipantMutex.Unlock()
+	fake.DeleteParticipantStub = nil
+	if fake.deleteParticipantReturnsOnCall == nil {
+		fake.deleteParticipantReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.deleteParticipantReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) DeleteRoom(arg1 context.Context, arg2 livekit.RoomName) error {
+	fake.deleteRoomMutex.Lock()
+	ret, specificReturn := fake.deleteRoomReturnsOnCall[len(fake.deleteRoomArgsForCall)]
+	fake.deleteRoomArgsForCall = append(fake.deleteRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.DeleteRoomStub
+	fakeReturns := fake.deleteRoomReturns
+	fake.recordInvocation("DeleteRoom", []interface{}{arg1, arg2})
+	fake.deleteRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeObjectStore) DeleteRoomCallCount() int {
+	fake.deleteRoomMutex.RLock()
+	defer fake.deleteRoomMutex.RUnlock()
+	return len(fake.deleteRoomArgsForCall)
+}
+
+func (fake *FakeObjectStore) DeleteRoomCalls(stub func(context.Context, livekit.RoomName) error) {
+	fake.deleteRoomMutex.Lock()
+	defer fake.deleteRoomMutex.Unlock()
+	fake.DeleteRoomStub = stub
+}
+
+func (fake *FakeObjectStore) DeleteRoomArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.deleteRoomMutex.RLock()
+	defer fake.deleteRoomMutex.RUnlock()
+	argsForCall := fake.deleteRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeObjectStore) DeleteRoomReturns(result1 error) {
+	fake.deleteRoomMutex.Lock()
+	defer fake.deleteRoomMutex.Unlock()
+	fake.DeleteRoomStub = nil
+	fake.deleteRoomReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) DeleteRoomReturnsOnCall(i int, result1 error) {
+	fake.deleteRoomMutex.Lock()
+	defer fake.deleteRoomMutex.Unlock()
+	fake.DeleteRoomStub = nil
+	if fake.deleteRoomReturnsOnCall == nil {
+		fake.deleteRoomReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.deleteRoomReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) HasParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) (bool, error) {
+	fake.hasParticipantMutex.Lock()
+	ret, specificReturn := fake.hasParticipantReturnsOnCall[len(fake.hasParticipantArgsForCall)]
+	fake.hasParticipantArgsForCall = append(fake.hasParticipantArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.ParticipantIdentity
+	}{arg1, arg2, arg3})
+	stub := fake.HasParticipantStub
+	fakeReturns := fake.hasParticipantReturns
+	fake.recordInvocation("HasParticipant", []interface{}{arg1, arg2, arg3})
+	fake.hasParticipantMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeObjectStore) HasParticipantCallCount() int {
+	fake.hasParticipantMutex.RLock()
+	defer fake.hasParticipantMutex.RUnlock()
+	return len(fake.hasParticipantArgsForCall)
+}
+
+func (fake *FakeObjectStore) HasParticipantCalls(stub func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (bool, error)) {
+	fake.hasParticipantMutex.Lock()
+	defer fake.hasParticipantMutex.Unlock()
+	fake.HasParticipantStub = stub
+}
+
+func (fake *FakeObjectStore) HasParticipantArgsForCall(i int) (context.Context, livekit.RoomName, livekit.ParticipantIdentity) {
+	fake.hasParticipantMutex.RLock()
+	defer fake.hasParticipantMutex.RUnlock()
+	argsForCall := fake.hasParticipantArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) HasParticipantReturns(result1 bool, result2 error) {
+	fake.hasParticipantMutex.Lock()
+	defer fake.hasParticipantMutex.Unlock()
+	fake.HasParticipantStub = nil
+	fake.hasParticipantReturns = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) HasParticipantReturnsOnCall(i int, result1 bool, result2 error) {
+	fake.hasParticipantMutex.Lock()
+	defer fake.hasParticipantMutex.Unlock()
+	fake.HasParticipantStub = nil
+	if fake.hasParticipantReturnsOnCall == nil {
+		fake.hasParticipantReturnsOnCall = make(map[int]struct {
+			result1 bool
+			result2 error
+		})
+	}
+	fake.hasParticipantReturnsOnCall[i] = struct {
+		result1 bool
+		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)]
+	fake.listParticipantsArgsForCall = append(fake.listParticipantsArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.ListParticipantsStub
+	fakeReturns := fake.listParticipantsReturns
+	fake.recordInvocation("ListParticipants", []interface{}{arg1, arg2})
+	fake.listParticipantsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeObjectStore) ListParticipantsCallCount() int {
+	fake.listParticipantsMutex.RLock()
+	defer fake.listParticipantsMutex.RUnlock()
+	return len(fake.listParticipantsArgsForCall)
+}
+
+func (fake *FakeObjectStore) ListParticipantsCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.ParticipantInfo, error)) {
+	fake.listParticipantsMutex.Lock()
+	defer fake.listParticipantsMutex.Unlock()
+	fake.ListParticipantsStub = stub
+}
+
+func (fake *FakeObjectStore) ListParticipantsArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.listParticipantsMutex.RLock()
+	defer fake.listParticipantsMutex.RUnlock()
+	argsForCall := fake.listParticipantsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeObjectStore) ListParticipantsReturns(result1 []*livekit.ParticipantInfo, result2 error) {
+	fake.listParticipantsMutex.Lock()
+	defer fake.listParticipantsMutex.Unlock()
+	fake.ListParticipantsStub = nil
+	fake.listParticipantsReturns = struct {
+		result1 []*livekit.ParticipantInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) ListParticipantsReturnsOnCall(i int, result1 []*livekit.ParticipantInfo, result2 error) {
+	fake.listParticipantsMutex.Lock()
+	defer fake.listParticipantsMutex.Unlock()
+	fake.ListParticipantsStub = nil
+	if fake.listParticipantsReturnsOnCall == nil {
+		fake.listParticipantsReturnsOnCall = make(map[int]struct {
+			result1 []*livekit.ParticipantInfo
+			result2 error
+		})
+	}
+	fake.listParticipantsReturnsOnCall[i] = struct {
+		result1 []*livekit.ParticipantInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) ListRooms(arg1 context.Context, arg2 []livekit.RoomName) ([]*livekit.Room, error) {
+	var arg2Copy []livekit.RoomName
+	if arg2 != nil {
+		arg2Copy = make([]livekit.RoomName, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	fake.listRoomsMutex.Lock()
+	ret, specificReturn := fake.listRoomsReturnsOnCall[len(fake.listRoomsArgsForCall)]
+	fake.listRoomsArgsForCall = append(fake.listRoomsArgsForCall, struct {
+		arg1 context.Context
+		arg2 []livekit.RoomName
+	}{arg1, arg2Copy})
+	stub := fake.ListRoomsStub
+	fakeReturns := fake.listRoomsReturns
+	fake.recordInvocation("ListRooms", []interface{}{arg1, arg2Copy})
+	fake.listRoomsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeObjectStore) ListRoomsCallCount() int {
+	fake.listRoomsMutex.RLock()
+	defer fake.listRoomsMutex.RUnlock()
+	return len(fake.listRoomsArgsForCall)
+}
+
+func (fake *FakeObjectStore) ListRoomsCalls(stub func(context.Context, []livekit.RoomName) ([]*livekit.Room, error)) {
+	fake.listRoomsMutex.Lock()
+	defer fake.listRoomsMutex.Unlock()
+	fake.ListRoomsStub = stub
+}
+
+func (fake *FakeObjectStore) ListRoomsArgsForCall(i int) (context.Context, []livekit.RoomName) {
+	fake.listRoomsMutex.RLock()
+	defer fake.listRoomsMutex.RUnlock()
+	argsForCall := fake.listRoomsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeObjectStore) ListRoomsReturns(result1 []*livekit.Room, result2 error) {
+	fake.listRoomsMutex.Lock()
+	defer fake.listRoomsMutex.Unlock()
+	fake.ListRoomsStub = nil
+	fake.listRoomsReturns = struct {
+		result1 []*livekit.Room
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) ListRoomsReturnsOnCall(i int, result1 []*livekit.Room, result2 error) {
+	fake.listRoomsMutex.Lock()
+	defer fake.listRoomsMutex.Unlock()
+	fake.ListRoomsStub = nil
+	if fake.listRoomsReturnsOnCall == nil {
+		fake.listRoomsReturnsOnCall = make(map[int]struct {
+			result1 []*livekit.Room
+			result2 error
+		})
+	}
+	fake.listRoomsReturnsOnCall[i] = struct {
+		result1 []*livekit.Room
+		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)]
+	fake.loadParticipantArgsForCall = append(fake.loadParticipantArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.ParticipantIdentity
+	}{arg1, arg2, arg3})
+	stub := fake.LoadParticipantStub
+	fakeReturns := fake.loadParticipantReturns
+	fake.recordInvocation("LoadParticipant", []interface{}{arg1, arg2, arg3})
+	fake.loadParticipantMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeObjectStore) LoadParticipantCallCount() int {
+	fake.loadParticipantMutex.RLock()
+	defer fake.loadParticipantMutex.RUnlock()
+	return len(fake.loadParticipantArgsForCall)
+}
+
+func (fake *FakeObjectStore) LoadParticipantCalls(stub func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error)) {
+	fake.loadParticipantMutex.Lock()
+	defer fake.loadParticipantMutex.Unlock()
+	fake.LoadParticipantStub = stub
+}
+
+func (fake *FakeObjectStore) LoadParticipantArgsForCall(i int) (context.Context, livekit.RoomName, livekit.ParticipantIdentity) {
+	fake.loadParticipantMutex.RLock()
+	defer fake.loadParticipantMutex.RUnlock()
+	argsForCall := fake.loadParticipantArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) LoadParticipantReturns(result1 *livekit.ParticipantInfo, result2 error) {
+	fake.loadParticipantMutex.Lock()
+	defer fake.loadParticipantMutex.Unlock()
+	fake.LoadParticipantStub = nil
+	fake.loadParticipantReturns = struct {
+		result1 *livekit.ParticipantInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) LoadParticipantReturnsOnCall(i int, result1 *livekit.ParticipantInfo, result2 error) {
+	fake.loadParticipantMutex.Lock()
+	defer fake.loadParticipantMutex.Unlock()
+	fake.LoadParticipantStub = nil
+	if fake.loadParticipantReturnsOnCall == nil {
+		fake.loadParticipantReturnsOnCall = make(map[int]struct {
+			result1 *livekit.ParticipantInfo
+			result2 error
+		})
+	}
+	fake.loadParticipantReturnsOnCall[i] = struct {
+		result1 *livekit.ParticipantInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) LoadRoom(arg1 context.Context, arg2 livekit.RoomName, arg3 bool) (*livekit.Room, *livekit.RoomInternal, error) {
+	fake.loadRoomMutex.Lock()
+	ret, specificReturn := fake.loadRoomReturnsOnCall[len(fake.loadRoomArgsForCall)]
+	fake.loadRoomArgsForCall = append(fake.loadRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 bool
+	}{arg1, arg2, arg3})
+	stub := fake.LoadRoomStub
+	fakeReturns := fake.loadRoomReturns
+	fake.recordInvocation("LoadRoom", []interface{}{arg1, arg2, arg3})
+	fake.loadRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2, ret.result3
+	}
+	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
+}
+
+func (fake *FakeObjectStore) LoadRoomCallCount() int {
+	fake.loadRoomMutex.RLock()
+	defer fake.loadRoomMutex.RUnlock()
+	return len(fake.loadRoomArgsForCall)
+}
+
+func (fake *FakeObjectStore) LoadRoomCalls(stub func(context.Context, livekit.RoomName, bool) (*livekit.Room, *livekit.RoomInternal, error)) {
+	fake.loadRoomMutex.Lock()
+	defer fake.loadRoomMutex.Unlock()
+	fake.LoadRoomStub = stub
+}
+
+func (fake *FakeObjectStore) LoadRoomArgsForCall(i int) (context.Context, livekit.RoomName, bool) {
+	fake.loadRoomMutex.RLock()
+	defer fake.loadRoomMutex.RUnlock()
+	argsForCall := fake.loadRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) LoadRoomReturns(result1 *livekit.Room, result2 *livekit.RoomInternal, result3 error) {
+	fake.loadRoomMutex.Lock()
+	defer fake.loadRoomMutex.Unlock()
+	fake.LoadRoomStub = nil
+	fake.loadRoomReturns = struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeObjectStore) LoadRoomReturnsOnCall(i int, result1 *livekit.Room, result2 *livekit.RoomInternal, result3 error) {
+	fake.loadRoomMutex.Lock()
+	defer fake.loadRoomMutex.Unlock()
+	fake.LoadRoomStub = nil
+	if fake.loadRoomReturnsOnCall == nil {
+		fake.loadRoomReturnsOnCall = make(map[int]struct {
+			result1 *livekit.Room
+			result2 *livekit.RoomInternal
+			result3 error
+		})
+	}
+	fake.loadRoomReturnsOnCall[i] = struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeObjectStore) LockRoom(arg1 context.Context, arg2 livekit.RoomName, arg3 time.Duration) (string, error) {
+	fake.lockRoomMutex.Lock()
+	ret, specificReturn := fake.lockRoomReturnsOnCall[len(fake.lockRoomArgsForCall)]
+	fake.lockRoomArgsForCall = append(fake.lockRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 time.Duration
+	}{arg1, arg2, arg3})
+	stub := fake.LockRoomStub
+	fakeReturns := fake.lockRoomReturns
+	fake.recordInvocation("LockRoom", []interface{}{arg1, arg2, arg3})
+	fake.lockRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeObjectStore) LockRoomCallCount() int {
+	fake.lockRoomMutex.RLock()
+	defer fake.lockRoomMutex.RUnlock()
+	return len(fake.lockRoomArgsForCall)
+}
+
+func (fake *FakeObjectStore) LockRoomCalls(stub func(context.Context, livekit.RoomName, time.Duration) (string, error)) {
+	fake.lockRoomMutex.Lock()
+	defer fake.lockRoomMutex.Unlock()
+	fake.LockRoomStub = stub
+}
+
+func (fake *FakeObjectStore) LockRoomArgsForCall(i int) (context.Context, livekit.RoomName, time.Duration) {
+	fake.lockRoomMutex.RLock()
+	defer fake.lockRoomMutex.RUnlock()
+	argsForCall := fake.lockRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) LockRoomReturns(result1 string, result2 error) {
+	fake.lockRoomMutex.Lock()
+	defer fake.lockRoomMutex.Unlock()
+	fake.LockRoomStub = nil
+	fake.lockRoomReturns = struct {
+		result1 string
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) LockRoomReturnsOnCall(i int, result1 string, result2 error) {
+	fake.lockRoomMutex.Lock()
+	defer fake.lockRoomMutex.Unlock()
+	fake.LockRoomStub = nil
+	if fake.lockRoomReturnsOnCall == nil {
+		fake.lockRoomReturnsOnCall = make(map[int]struct {
+			result1 string
+			result2 error
+		})
+	}
+	fake.lockRoomReturnsOnCall[i] = struct {
+		result1 string
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) RoomExists(arg1 context.Context, arg2 livekit.RoomName) (bool, error) {
+	fake.roomExistsMutex.Lock()
+	ret, specificReturn := fake.roomExistsReturnsOnCall[len(fake.roomExistsArgsForCall)]
+	fake.roomExistsArgsForCall = append(fake.roomExistsArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.RoomExistsStub
+	fakeReturns := fake.roomExistsReturns
+	fake.recordInvocation("RoomExists", []interface{}{arg1, arg2})
+	fake.roomExistsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeObjectStore) RoomExistsCallCount() int {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	return len(fake.roomExistsArgsForCall)
+}
+
+func (fake *FakeObjectStore) RoomExistsCalls(stub func(context.Context, livekit.RoomName) (bool, error)) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = stub
+}
+
+func (fake *FakeObjectStore) RoomExistsArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	argsForCall := fake.roomExistsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeObjectStore) RoomExistsReturns(result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	fake.roomExistsReturns = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) RoomExistsReturnsOnCall(i int, result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	if fake.roomExistsReturnsOnCall == nil {
+		fake.roomExistsReturnsOnCall = make(map[int]struct {
+			result1 bool
+			result2 error
+		})
+	}
+	fake.roomExistsReturnsOnCall[i] = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) StoreParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 *livekit.ParticipantInfo) error {
+	fake.storeParticipantMutex.Lock()
+	ret, specificReturn := fake.storeParticipantReturnsOnCall[len(fake.storeParticipantArgsForCall)]
+	fake.storeParticipantArgsForCall = append(fake.storeParticipantArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 *livekit.ParticipantInfo
+	}{arg1, arg2, arg3})
+	stub := fake.StoreParticipantStub
+	fakeReturns := fake.storeParticipantReturns
+	fake.recordInvocation("StoreParticipant", []interface{}{arg1, arg2, arg3})
+	fake.storeParticipantMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeObjectStore) StoreParticipantCallCount() int {
+	fake.storeParticipantMutex.RLock()
+	defer fake.storeParticipantMutex.RUnlock()
+	return len(fake.storeParticipantArgsForCall)
+}
+
+func (fake *FakeObjectStore) StoreParticipantCalls(stub func(context.Context, livekit.RoomName, *livekit.ParticipantInfo) error) {
+	fake.storeParticipantMutex.Lock()
+	defer fake.storeParticipantMutex.Unlock()
+	fake.StoreParticipantStub = stub
+}
+
+func (fake *FakeObjectStore) StoreParticipantArgsForCall(i int) (context.Context, livekit.RoomName, *livekit.ParticipantInfo) {
+	fake.storeParticipantMutex.RLock()
+	defer fake.storeParticipantMutex.RUnlock()
+	argsForCall := fake.storeParticipantArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) StoreParticipantReturns(result1 error) {
+	fake.storeParticipantMutex.Lock()
+	defer fake.storeParticipantMutex.Unlock()
+	fake.StoreParticipantStub = nil
+	fake.storeParticipantReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) StoreParticipantReturnsOnCall(i int, result1 error) {
+	fake.storeParticipantMutex.Lock()
+	defer fake.storeParticipantMutex.Unlock()
+	fake.StoreParticipantStub = nil
+	if fake.storeParticipantReturnsOnCall == nil {
+		fake.storeParticipantReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.storeParticipantReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) StoreRoom(arg1 context.Context, arg2 *livekit.Room, arg3 *livekit.RoomInternal) error {
+	fake.storeRoomMutex.Lock()
+	ret, specificReturn := fake.storeRoomReturnsOnCall[len(fake.storeRoomArgsForCall)]
+	fake.storeRoomArgsForCall = append(fake.storeRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.Room
+		arg3 *livekit.RoomInternal
+	}{arg1, arg2, arg3})
+	stub := fake.StoreRoomStub
+	fakeReturns := fake.storeRoomReturns
+	fake.recordInvocation("StoreRoom", []interface{}{arg1, arg2, arg3})
+	fake.storeRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeObjectStore) StoreRoomCallCount() int {
+	fake.storeRoomMutex.RLock()
+	defer fake.storeRoomMutex.RUnlock()
+	return len(fake.storeRoomArgsForCall)
+}
+
+func (fake *FakeObjectStore) StoreRoomCalls(stub func(context.Context, *livekit.Room, *livekit.RoomInternal) error) {
+	fake.storeRoomMutex.Lock()
+	defer fake.storeRoomMutex.Unlock()
+	fake.StoreRoomStub = stub
+}
+
+func (fake *FakeObjectStore) StoreRoomArgsForCall(i int) (context.Context, *livekit.Room, *livekit.RoomInternal) {
+	fake.storeRoomMutex.RLock()
+	defer fake.storeRoomMutex.RUnlock()
+	argsForCall := fake.storeRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) StoreRoomReturns(result1 error) {
+	fake.storeRoomMutex.Lock()
+	defer fake.storeRoomMutex.Unlock()
+	fake.StoreRoomStub = nil
+	fake.storeRoomReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) StoreRoomReturnsOnCall(i int, result1 error) {
+	fake.storeRoomMutex.Lock()
+	defer fake.storeRoomMutex.Unlock()
+	fake.StoreRoomStub = nil
+	if fake.storeRoomReturnsOnCall == nil {
+		fake.storeRoomReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.storeRoomReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) UnlockRoom(arg1 context.Context, arg2 livekit.RoomName, arg3 string) error {
+	fake.unlockRoomMutex.Lock()
+	ret, specificReturn := fake.unlockRoomReturnsOnCall[len(fake.unlockRoomArgsForCall)]
+	fake.unlockRoomArgsForCall = append(fake.unlockRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 string
+	}{arg1, arg2, arg3})
+	stub := fake.UnlockRoomStub
+	fakeReturns := fake.unlockRoomReturns
+	fake.recordInvocation("UnlockRoom", []interface{}{arg1, arg2, arg3})
+	fake.unlockRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeObjectStore) UnlockRoomCallCount() int {
+	fake.unlockRoomMutex.RLock()
+	defer fake.unlockRoomMutex.RUnlock()
+	return len(fake.unlockRoomArgsForCall)
+}
+
+func (fake *FakeObjectStore) UnlockRoomCalls(stub func(context.Context, livekit.RoomName, string) error) {
+	fake.unlockRoomMutex.Lock()
+	defer fake.unlockRoomMutex.Unlock()
+	fake.UnlockRoomStub = stub
+}
+
+func (fake *FakeObjectStore) UnlockRoomArgsForCall(i int) (context.Context, livekit.RoomName, string) {
+	fake.unlockRoomMutex.RLock()
+	defer fake.unlockRoomMutex.RUnlock()
+	argsForCall := fake.unlockRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeObjectStore) UnlockRoomReturns(result1 error) {
+	fake.unlockRoomMutex.Lock()
+	defer fake.unlockRoomMutex.Unlock()
+	fake.UnlockRoomStub = nil
+	fake.unlockRoomReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) UnlockRoomReturnsOnCall(i int, result1 error) {
+	fake.unlockRoomMutex.Lock()
+	defer fake.unlockRoomMutex.Unlock()
+	fake.UnlockRoomStub = nil
+	if fake.unlockRoomReturnsOnCall == nil {
+		fake.unlockRoomReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.unlockRoomReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeObjectStore) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeObjectStore) 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.ObjectStore = new(FakeObjectStore)

pkg/service/servicefakes/fake_room_allocator.go

@@ -0,0 +1,352 @@
+// 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 FakeRoomAllocator struct {
+	AutoCreateEnabledStub        func(context.Context) bool
+	autoCreateEnabledMutex       sync.RWMutex
+	autoCreateEnabledArgsForCall []struct {
+		arg1 context.Context
+	}
+	autoCreateEnabledReturns struct {
+		result1 bool
+	}
+	autoCreateEnabledReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	CreateRoomStub        func(context.Context, *livekit.CreateRoomRequest, bool) (*livekit.Room, *livekit.RoomInternal, bool, error)
+	createRoomMutex       sync.RWMutex
+	createRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.CreateRoomRequest
+		arg3 bool
+	}
+	createRoomReturns struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 bool
+		result4 error
+	}
+	createRoomReturnsOnCall map[int]struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 bool
+		result4 error
+	}
+	SelectRoomNodeStub        func(context.Context, livekit.RoomName, livekit.NodeID) error
+	selectRoomNodeMutex       sync.RWMutex
+	selectRoomNodeArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.NodeID
+	}
+	selectRoomNodeReturns struct {
+		result1 error
+	}
+	selectRoomNodeReturnsOnCall map[int]struct {
+		result1 error
+	}
+	ValidateCreateRoomStub        func(context.Context, livekit.RoomName) error
+	validateCreateRoomMutex       sync.RWMutex
+	validateCreateRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	validateCreateRoomReturns struct {
+		result1 error
+	}
+	validateCreateRoomReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeRoomAllocator) AutoCreateEnabled(arg1 context.Context) bool {
+	fake.autoCreateEnabledMutex.Lock()
+	ret, specificReturn := fake.autoCreateEnabledReturnsOnCall[len(fake.autoCreateEnabledArgsForCall)]
+	fake.autoCreateEnabledArgsForCall = append(fake.autoCreateEnabledArgsForCall, struct {
+		arg1 context.Context
+	}{arg1})
+	stub := fake.AutoCreateEnabledStub
+	fakeReturns := fake.autoCreateEnabledReturns
+	fake.recordInvocation("AutoCreateEnabled", []interface{}{arg1})
+	fake.autoCreateEnabledMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRoomAllocator) AutoCreateEnabledCallCount() int {
+	fake.autoCreateEnabledMutex.RLock()
+	defer fake.autoCreateEnabledMutex.RUnlock()
+	return len(fake.autoCreateEnabledArgsForCall)
+}
+
+func (fake *FakeRoomAllocator) AutoCreateEnabledCalls(stub func(context.Context) bool) {
+	fake.autoCreateEnabledMutex.Lock()
+	defer fake.autoCreateEnabledMutex.Unlock()
+	fake.AutoCreateEnabledStub = stub
+}
+
+func (fake *FakeRoomAllocator) AutoCreateEnabledArgsForCall(i int) context.Context {
+	fake.autoCreateEnabledMutex.RLock()
+	defer fake.autoCreateEnabledMutex.RUnlock()
+	argsForCall := fake.autoCreateEnabledArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeRoomAllocator) AutoCreateEnabledReturns(result1 bool) {
+	fake.autoCreateEnabledMutex.Lock()
+	defer fake.autoCreateEnabledMutex.Unlock()
+	fake.AutoCreateEnabledStub = nil
+	fake.autoCreateEnabledReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeRoomAllocator) AutoCreateEnabledReturnsOnCall(i int, result1 bool) {
+	fake.autoCreateEnabledMutex.Lock()
+	defer fake.autoCreateEnabledMutex.Unlock()
+	fake.AutoCreateEnabledStub = nil
+	if fake.autoCreateEnabledReturnsOnCall == nil {
+		fake.autoCreateEnabledReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.autoCreateEnabledReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeRoomAllocator) CreateRoom(arg1 context.Context, arg2 *livekit.CreateRoomRequest, arg3 bool) (*livekit.Room, *livekit.RoomInternal, bool, error) {
+	fake.createRoomMutex.Lock()
+	ret, specificReturn := fake.createRoomReturnsOnCall[len(fake.createRoomArgsForCall)]
+	fake.createRoomArgsForCall = append(fake.createRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.CreateRoomRequest
+		arg3 bool
+	}{arg1, arg2, arg3})
+	stub := fake.CreateRoomStub
+	fakeReturns := fake.createRoomReturns
+	fake.recordInvocation("CreateRoom", []interface{}{arg1, arg2, arg3})
+	fake.createRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2, ret.result3, ret.result4
+	}
+	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
+}
+
+func (fake *FakeRoomAllocator) CreateRoomCallCount() int {
+	fake.createRoomMutex.RLock()
+	defer fake.createRoomMutex.RUnlock()
+	return len(fake.createRoomArgsForCall)
+}
+
+func (fake *FakeRoomAllocator) CreateRoomCalls(stub func(context.Context, *livekit.CreateRoomRequest, bool) (*livekit.Room, *livekit.RoomInternal, bool, error)) {
+	fake.createRoomMutex.Lock()
+	defer fake.createRoomMutex.Unlock()
+	fake.CreateRoomStub = stub
+}
+
+func (fake *FakeRoomAllocator) CreateRoomArgsForCall(i int) (context.Context, *livekit.CreateRoomRequest, bool) {
+	fake.createRoomMutex.RLock()
+	defer fake.createRoomMutex.RUnlock()
+	argsForCall := fake.createRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeRoomAllocator) CreateRoomReturns(result1 *livekit.Room, result2 *livekit.RoomInternal, result3 bool, result4 error) {
+	fake.createRoomMutex.Lock()
+	defer fake.createRoomMutex.Unlock()
+	fake.CreateRoomStub = nil
+	fake.createRoomReturns = struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 bool
+		result4 error
+	}{result1, result2, result3, result4}
+}
+
+func (fake *FakeRoomAllocator) CreateRoomReturnsOnCall(i int, result1 *livekit.Room, result2 *livekit.RoomInternal, result3 bool, result4 error) {
+	fake.createRoomMutex.Lock()
+	defer fake.createRoomMutex.Unlock()
+	fake.CreateRoomStub = nil
+	if fake.createRoomReturnsOnCall == nil {
+		fake.createRoomReturnsOnCall = make(map[int]struct {
+			result1 *livekit.Room
+			result2 *livekit.RoomInternal
+			result3 bool
+			result4 error
+		})
+	}
+	fake.createRoomReturnsOnCall[i] = struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 bool
+		result4 error
+	}{result1, result2, result3, result4}
+}
+
+func (fake *FakeRoomAllocator) SelectRoomNode(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.NodeID) error {
+	fake.selectRoomNodeMutex.Lock()
+	ret, specificReturn := fake.selectRoomNodeReturnsOnCall[len(fake.selectRoomNodeArgsForCall)]
+	fake.selectRoomNodeArgsForCall = append(fake.selectRoomNodeArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.NodeID
+	}{arg1, arg2, arg3})
+	stub := fake.SelectRoomNodeStub
+	fakeReturns := fake.selectRoomNodeReturns
+	fake.recordInvocation("SelectRoomNode", []interface{}{arg1, arg2, arg3})
+	fake.selectRoomNodeMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRoomAllocator) SelectRoomNodeCallCount() int {
+	fake.selectRoomNodeMutex.RLock()
+	defer fake.selectRoomNodeMutex.RUnlock()
+	return len(fake.selectRoomNodeArgsForCall)
+}
+
+func (fake *FakeRoomAllocator) SelectRoomNodeCalls(stub func(context.Context, livekit.RoomName, livekit.NodeID) error) {
+	fake.selectRoomNodeMutex.Lock()
+	defer fake.selectRoomNodeMutex.Unlock()
+	fake.SelectRoomNodeStub = stub
+}
+
+func (fake *FakeRoomAllocator) SelectRoomNodeArgsForCall(i int) (context.Context, livekit.RoomName, livekit.NodeID) {
+	fake.selectRoomNodeMutex.RLock()
+	defer fake.selectRoomNodeMutex.RUnlock()
+	argsForCall := fake.selectRoomNodeArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeRoomAllocator) SelectRoomNodeReturns(result1 error) {
+	fake.selectRoomNodeMutex.Lock()
+	defer fake.selectRoomNodeMutex.Unlock()
+	fake.SelectRoomNodeStub = nil
+	fake.selectRoomNodeReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRoomAllocator) SelectRoomNodeReturnsOnCall(i int, result1 error) {
+	fake.selectRoomNodeMutex.Lock()
+	defer fake.selectRoomNodeMutex.Unlock()
+	fake.SelectRoomNodeStub = nil
+	if fake.selectRoomNodeReturnsOnCall == nil {
+		fake.selectRoomNodeReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.selectRoomNodeReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRoomAllocator) ValidateCreateRoom(arg1 context.Context, arg2 livekit.RoomName) error {
+	fake.validateCreateRoomMutex.Lock()
+	ret, specificReturn := fake.validateCreateRoomReturnsOnCall[len(fake.validateCreateRoomArgsForCall)]
+	fake.validateCreateRoomArgsForCall = append(fake.validateCreateRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.ValidateCreateRoomStub
+	fakeReturns := fake.validateCreateRoomReturns
+	fake.recordInvocation("ValidateCreateRoom", []interface{}{arg1, arg2})
+	fake.validateCreateRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRoomAllocator) ValidateCreateRoomCallCount() int {
+	fake.validateCreateRoomMutex.RLock()
+	defer fake.validateCreateRoomMutex.RUnlock()
+	return len(fake.validateCreateRoomArgsForCall)
+}
+
+func (fake *FakeRoomAllocator) ValidateCreateRoomCalls(stub func(context.Context, livekit.RoomName) error) {
+	fake.validateCreateRoomMutex.Lock()
+	defer fake.validateCreateRoomMutex.Unlock()
+	fake.ValidateCreateRoomStub = stub
+}
+
+func (fake *FakeRoomAllocator) ValidateCreateRoomArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.validateCreateRoomMutex.RLock()
+	defer fake.validateCreateRoomMutex.RUnlock()
+	argsForCall := fake.validateCreateRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeRoomAllocator) ValidateCreateRoomReturns(result1 error) {
+	fake.validateCreateRoomMutex.Lock()
+	defer fake.validateCreateRoomMutex.Unlock()
+	fake.ValidateCreateRoomStub = nil
+	fake.validateCreateRoomReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRoomAllocator) ValidateCreateRoomReturnsOnCall(i int, result1 error) {
+	fake.validateCreateRoomMutex.Lock()
+	defer fake.validateCreateRoomMutex.Unlock()
+	fake.ValidateCreateRoomStub = nil
+	if fake.validateCreateRoomReturnsOnCall == nil {
+		fake.validateCreateRoomReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.validateCreateRoomReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRoomAllocator) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeRoomAllocator) 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.RoomAllocator = new(FakeRoomAllocator)

pkg/service/servicefakes/fake_service_store.go

@@ -0,0 +1,288 @@
+// 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 FakeServiceStore struct {
+	ListRoomsStub        func(context.Context, []livekit.RoomName) ([]*livekit.Room, error)
+	listRoomsMutex       sync.RWMutex
+	listRoomsArgsForCall []struct {
+		arg1 context.Context
+		arg2 []livekit.RoomName
+	}
+	listRoomsReturns struct {
+		result1 []*livekit.Room
+		result2 error
+	}
+	listRoomsReturnsOnCall map[int]struct {
+		result1 []*livekit.Room
+		result2 error
+	}
+	LoadRoomStub        func(context.Context, livekit.RoomName, bool) (*livekit.Room, *livekit.RoomInternal, error)
+	loadRoomMutex       sync.RWMutex
+	loadRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 bool
+	}
+	loadRoomReturns struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}
+	loadRoomReturnsOnCall map[int]struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}
+	RoomExistsStub        func(context.Context, livekit.RoomName) (bool, error)
+	roomExistsMutex       sync.RWMutex
+	roomExistsArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	roomExistsReturns struct {
+		result1 bool
+		result2 error
+	}
+	roomExistsReturnsOnCall map[int]struct {
+		result1 bool
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeServiceStore) ListRooms(arg1 context.Context, arg2 []livekit.RoomName) ([]*livekit.Room, error) {
+	var arg2Copy []livekit.RoomName
+	if arg2 != nil {
+		arg2Copy = make([]livekit.RoomName, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	fake.listRoomsMutex.Lock()
+	ret, specificReturn := fake.listRoomsReturnsOnCall[len(fake.listRoomsArgsForCall)]
+	fake.listRoomsArgsForCall = append(fake.listRoomsArgsForCall, struct {
+		arg1 context.Context
+		arg2 []livekit.RoomName
+	}{arg1, arg2Copy})
+	stub := fake.ListRoomsStub
+	fakeReturns := fake.listRoomsReturns
+	fake.recordInvocation("ListRooms", []interface{}{arg1, arg2Copy})
+	fake.listRoomsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeServiceStore) ListRoomsCallCount() int {
+	fake.listRoomsMutex.RLock()
+	defer fake.listRoomsMutex.RUnlock()
+	return len(fake.listRoomsArgsForCall)
+}
+
+func (fake *FakeServiceStore) ListRoomsCalls(stub func(context.Context, []livekit.RoomName) ([]*livekit.Room, error)) {
+	fake.listRoomsMutex.Lock()
+	defer fake.listRoomsMutex.Unlock()
+	fake.ListRoomsStub = stub
+}
+
+func (fake *FakeServiceStore) ListRoomsArgsForCall(i int) (context.Context, []livekit.RoomName) {
+	fake.listRoomsMutex.RLock()
+	defer fake.listRoomsMutex.RUnlock()
+	argsForCall := fake.listRoomsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeServiceStore) ListRoomsReturns(result1 []*livekit.Room, result2 error) {
+	fake.listRoomsMutex.Lock()
+	defer fake.listRoomsMutex.Unlock()
+	fake.ListRoomsStub = nil
+	fake.listRoomsReturns = struct {
+		result1 []*livekit.Room
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeServiceStore) ListRoomsReturnsOnCall(i int, result1 []*livekit.Room, result2 error) {
+	fake.listRoomsMutex.Lock()
+	defer fake.listRoomsMutex.Unlock()
+	fake.ListRoomsStub = nil
+	if fake.listRoomsReturnsOnCall == nil {
+		fake.listRoomsReturnsOnCall = make(map[int]struct {
+			result1 []*livekit.Room
+			result2 error
+		})
+	}
+	fake.listRoomsReturnsOnCall[i] = struct {
+		result1 []*livekit.Room
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeServiceStore) LoadRoom(arg1 context.Context, arg2 livekit.RoomName, arg3 bool) (*livekit.Room, *livekit.RoomInternal, error) {
+	fake.loadRoomMutex.Lock()
+	ret, specificReturn := fake.loadRoomReturnsOnCall[len(fake.loadRoomArgsForCall)]
+	fake.loadRoomArgsForCall = append(fake.loadRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 bool
+	}{arg1, arg2, arg3})
+	stub := fake.LoadRoomStub
+	fakeReturns := fake.loadRoomReturns
+	fake.recordInvocation("LoadRoom", []interface{}{arg1, arg2, arg3})
+	fake.loadRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2, ret.result3
+	}
+	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
+}
+
+func (fake *FakeServiceStore) LoadRoomCallCount() int {
+	fake.loadRoomMutex.RLock()
+	defer fake.loadRoomMutex.RUnlock()
+	return len(fake.loadRoomArgsForCall)
+}
+
+func (fake *FakeServiceStore) LoadRoomCalls(stub func(context.Context, livekit.RoomName, bool) (*livekit.Room, *livekit.RoomInternal, error)) {
+	fake.loadRoomMutex.Lock()
+	defer fake.loadRoomMutex.Unlock()
+	fake.LoadRoomStub = stub
+}
+
+func (fake *FakeServiceStore) LoadRoomArgsForCall(i int) (context.Context, livekit.RoomName, bool) {
+	fake.loadRoomMutex.RLock()
+	defer fake.loadRoomMutex.RUnlock()
+	argsForCall := fake.loadRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeServiceStore) LoadRoomReturns(result1 *livekit.Room, result2 *livekit.RoomInternal, result3 error) {
+	fake.loadRoomMutex.Lock()
+	defer fake.loadRoomMutex.Unlock()
+	fake.LoadRoomStub = nil
+	fake.loadRoomReturns = struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeServiceStore) LoadRoomReturnsOnCall(i int, result1 *livekit.Room, result2 *livekit.RoomInternal, result3 error) {
+	fake.loadRoomMutex.Lock()
+	defer fake.loadRoomMutex.Unlock()
+	fake.LoadRoomStub = nil
+	if fake.loadRoomReturnsOnCall == nil {
+		fake.loadRoomReturnsOnCall = make(map[int]struct {
+			result1 *livekit.Room
+			result2 *livekit.RoomInternal
+			result3 error
+		})
+	}
+	fake.loadRoomReturnsOnCall[i] = struct {
+		result1 *livekit.Room
+		result2 *livekit.RoomInternal
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *FakeServiceStore) RoomExists(arg1 context.Context, arg2 livekit.RoomName) (bool, error) {
+	fake.roomExistsMutex.Lock()
+	ret, specificReturn := fake.roomExistsReturnsOnCall[len(fake.roomExistsArgsForCall)]
+	fake.roomExistsArgsForCall = append(fake.roomExistsArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.RoomExistsStub
+	fakeReturns := fake.roomExistsReturns
+	fake.recordInvocation("RoomExists", []interface{}{arg1, arg2})
+	fake.roomExistsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeServiceStore) RoomExistsCallCount() int {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	return len(fake.roomExistsArgsForCall)
+}
+
+func (fake *FakeServiceStore) RoomExistsCalls(stub func(context.Context, livekit.RoomName) (bool, error)) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = stub
+}
+
+func (fake *FakeServiceStore) RoomExistsArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	argsForCall := fake.roomExistsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeServiceStore) RoomExistsReturns(result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	fake.roomExistsReturns = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeServiceStore) RoomExistsReturnsOnCall(i int, result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	if fake.roomExistsReturnsOnCall == nil {
+		fake.roomExistsReturnsOnCall = make(map[int]struct {
+			result1 bool
+			result2 error
+		})
+	}
+	fake.roomExistsReturnsOnCall[i] = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeServiceStore) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeServiceStore) 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.ServiceStore = new(FakeServiceStore)

pkg/service/servicefakes/fake_session_handler.go

@@ -0,0 +1,193 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package servicefakes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/routing"
+	"github.com/livekit/livekit-server/pkg/service"
+	"github.com/livekit/protocol/livekit"
+	"github.com/livekit/protocol/logger"
+)
+
+type FakeSessionHandler struct {
+	HandleSessionStub        func(context.Context, routing.ParticipantInit, livekit.ConnectionID, routing.MessageSource, routing.MessageSink) error
+	handleSessionMutex       sync.RWMutex
+	handleSessionArgsForCall []struct {
+		arg1 context.Context
+		arg2 routing.ParticipantInit
+		arg3 livekit.ConnectionID
+		arg4 routing.MessageSource
+		arg5 routing.MessageSink
+	}
+	handleSessionReturns struct {
+		result1 error
+	}
+	handleSessionReturnsOnCall map[int]struct {
+		result1 error
+	}
+	LoggerStub        func(context.Context) logger.Logger
+	loggerMutex       sync.RWMutex
+	loggerArgsForCall []struct {
+		arg1 context.Context
+	}
+	loggerReturns struct {
+		result1 logger.Logger
+	}
+	loggerReturnsOnCall map[int]struct {
+		result1 logger.Logger
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeSessionHandler) HandleSession(arg1 context.Context, arg2 routing.ParticipantInit, arg3 livekit.ConnectionID, arg4 routing.MessageSource, arg5 routing.MessageSink) error {
+	fake.handleSessionMutex.Lock()
+	ret, specificReturn := fake.handleSessionReturnsOnCall[len(fake.handleSessionArgsForCall)]
+	fake.handleSessionArgsForCall = append(fake.handleSessionArgsForCall, struct {
+		arg1 context.Context
+		arg2 routing.ParticipantInit
+		arg3 livekit.ConnectionID
+		arg4 routing.MessageSource
+		arg5 routing.MessageSink
+	}{arg1, arg2, arg3, arg4, arg5})
+	stub := fake.HandleSessionStub
+	fakeReturns := fake.handleSessionReturns
+	fake.recordInvocation("HandleSession", []interface{}{arg1, arg2, arg3, arg4, arg5})
+	fake.handleSessionMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3, arg4, arg5)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeSessionHandler) HandleSessionCallCount() int {
+	fake.handleSessionMutex.RLock()
+	defer fake.handleSessionMutex.RUnlock()
+	return len(fake.handleSessionArgsForCall)
+}
+
+func (fake *FakeSessionHandler) HandleSessionCalls(stub func(context.Context, routing.ParticipantInit, livekit.ConnectionID, routing.MessageSource, routing.MessageSink) error) {
+	fake.handleSessionMutex.Lock()
+	defer fake.handleSessionMutex.Unlock()
+	fake.HandleSessionStub = stub
+}
+
+func (fake *FakeSessionHandler) HandleSessionArgsForCall(i int) (context.Context, routing.ParticipantInit, livekit.ConnectionID, routing.MessageSource, routing.MessageSink) {
+	fake.handleSessionMutex.RLock()
+	defer fake.handleSessionMutex.RUnlock()
+	argsForCall := fake.handleSessionArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
+}
+
+func (fake *FakeSessionHandler) HandleSessionReturns(result1 error) {
+	fake.handleSessionMutex.Lock()
+	defer fake.handleSessionMutex.Unlock()
+	fake.HandleSessionStub = nil
+	fake.handleSessionReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeSessionHandler) HandleSessionReturnsOnCall(i int, result1 error) {
+	fake.handleSessionMutex.Lock()
+	defer fake.handleSessionMutex.Unlock()
+	fake.HandleSessionStub = nil
+	if fake.handleSessionReturnsOnCall == nil {
+		fake.handleSessionReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.handleSessionReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeSessionHandler) Logger(arg1 context.Context) logger.Logger {
+	fake.loggerMutex.Lock()
+	ret, specificReturn := fake.loggerReturnsOnCall[len(fake.loggerArgsForCall)]
+	fake.loggerArgsForCall = append(fake.loggerArgsForCall, struct {
+		arg1 context.Context
+	}{arg1})
+	stub := fake.LoggerStub
+	fakeReturns := fake.loggerReturns
+	fake.recordInvocation("Logger", []interface{}{arg1})
+	fake.loggerMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeSessionHandler) LoggerCallCount() int {
+	fake.loggerMutex.RLock()
+	defer fake.loggerMutex.RUnlock()
+	return len(fake.loggerArgsForCall)
+}
+
+func (fake *FakeSessionHandler) LoggerCalls(stub func(context.Context) logger.Logger) {
+	fake.loggerMutex.Lock()
+	defer fake.loggerMutex.Unlock()
+	fake.LoggerStub = stub
+}
+
+func (fake *FakeSessionHandler) LoggerArgsForCall(i int) context.Context {
+	fake.loggerMutex.RLock()
+	defer fake.loggerMutex.RUnlock()
+	argsForCall := fake.loggerArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeSessionHandler) LoggerReturns(result1 logger.Logger) {
+	fake.loggerMutex.Lock()
+	defer fake.loggerMutex.Unlock()
+	fake.LoggerStub = nil
+	fake.loggerReturns = struct {
+		result1 logger.Logger
+	}{result1}
+}
+
+func (fake *FakeSessionHandler) LoggerReturnsOnCall(i int, result1 logger.Logger) {
+	fake.loggerMutex.Lock()
+	defer fake.loggerMutex.Unlock()
+	fake.LoggerStub = nil
+	if fake.loggerReturnsOnCall == nil {
+		fake.loggerReturnsOnCall = make(map[int]struct {
+			result1 logger.Logger
+		})
+	}
+	fake.loggerReturnsOnCall[i] = struct {
+		result1 logger.Logger
+	}{result1}
+}
+
+func (fake *FakeSessionHandler) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeSessionHandler) 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.SessionHandler = new(FakeSessionHandler)