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

pkg/routing/routingfakes/fake_message_sink.go

@@ -0,0 +1,265 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package routingfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/routing"
+	"github.com/livekit/protocol/livekit"
+	"google.golang.org/protobuf/proto"
+)
+
+type FakeMessageSink struct {
+	CloseStub        func()
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	ConnectionIDStub        func() livekit.ConnectionID
+	connectionIDMutex       sync.RWMutex
+	connectionIDArgsForCall []struct {
+	}
+	connectionIDReturns struct {
+		result1 livekit.ConnectionID
+	}
+	connectionIDReturnsOnCall map[int]struct {
+		result1 livekit.ConnectionID
+	}
+	IsClosedStub        func() bool
+	isClosedMutex       sync.RWMutex
+	isClosedArgsForCall []struct {
+	}
+	isClosedReturns struct {
+		result1 bool
+	}
+	isClosedReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	WriteMessageStub        func(proto.Message) error
+	writeMessageMutex       sync.RWMutex
+	writeMessageArgsForCall []struct {
+		arg1 proto.Message
+	}
+	writeMessageReturns struct {
+		result1 error
+	}
+	writeMessageReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeMessageSink) Close() {
+	fake.closeMutex.Lock()
+	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
+	}{})
+	stub := fake.CloseStub
+	fake.recordInvocation("Close", []interface{}{})
+	fake.closeMutex.Unlock()
+	if stub != nil {
+		fake.CloseStub()
+	}
+}
+
+func (fake *FakeMessageSink) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeMessageSink) CloseCalls(stub func()) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeMessageSink) ConnectionID() livekit.ConnectionID {
+	fake.connectionIDMutex.Lock()
+	ret, specificReturn := fake.connectionIDReturnsOnCall[len(fake.connectionIDArgsForCall)]
+	fake.connectionIDArgsForCall = append(fake.connectionIDArgsForCall, struct {
+	}{})
+	stub := fake.ConnectionIDStub
+	fakeReturns := fake.connectionIDReturns
+	fake.recordInvocation("ConnectionID", []interface{}{})
+	fake.connectionIDMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMessageSink) ConnectionIDCallCount() int {
+	fake.connectionIDMutex.RLock()
+	defer fake.connectionIDMutex.RUnlock()
+	return len(fake.connectionIDArgsForCall)
+}
+
+func (fake *FakeMessageSink) ConnectionIDCalls(stub func() livekit.ConnectionID) {
+	fake.connectionIDMutex.Lock()
+	defer fake.connectionIDMutex.Unlock()
+	fake.ConnectionIDStub = stub
+}
+
+func (fake *FakeMessageSink) ConnectionIDReturns(result1 livekit.ConnectionID) {
+	fake.connectionIDMutex.Lock()
+	defer fake.connectionIDMutex.Unlock()
+	fake.ConnectionIDStub = nil
+	fake.connectionIDReturns = struct {
+		result1 livekit.ConnectionID
+	}{result1}
+}
+
+func (fake *FakeMessageSink) ConnectionIDReturnsOnCall(i int, result1 livekit.ConnectionID) {
+	fake.connectionIDMutex.Lock()
+	defer fake.connectionIDMutex.Unlock()
+	fake.ConnectionIDStub = nil
+	if fake.connectionIDReturnsOnCall == nil {
+		fake.connectionIDReturnsOnCall = make(map[int]struct {
+			result1 livekit.ConnectionID
+		})
+	}
+	fake.connectionIDReturnsOnCall[i] = struct {
+		result1 livekit.ConnectionID
+	}{result1}
+}
+
+func (fake *FakeMessageSink) IsClosed() bool {
+	fake.isClosedMutex.Lock()
+	ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)]
+	fake.isClosedArgsForCall = append(fake.isClosedArgsForCall, struct {
+	}{})
+	stub := fake.IsClosedStub
+	fakeReturns := fake.isClosedReturns
+	fake.recordInvocation("IsClosed", []interface{}{})
+	fake.isClosedMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMessageSink) IsClosedCallCount() int {
+	fake.isClosedMutex.RLock()
+	defer fake.isClosedMutex.RUnlock()
+	return len(fake.isClosedArgsForCall)
+}
+
+func (fake *FakeMessageSink) IsClosedCalls(stub func() bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = stub
+}
+
+func (fake *FakeMessageSink) IsClosedReturns(result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	fake.isClosedReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeMessageSink) IsClosedReturnsOnCall(i int, result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	if fake.isClosedReturnsOnCall == nil {
+		fake.isClosedReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isClosedReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeMessageSink) WriteMessage(arg1 proto.Message) error {
+	fake.writeMessageMutex.Lock()
+	ret, specificReturn := fake.writeMessageReturnsOnCall[len(fake.writeMessageArgsForCall)]
+	fake.writeMessageArgsForCall = append(fake.writeMessageArgsForCall, struct {
+		arg1 proto.Message
+	}{arg1})
+	stub := fake.WriteMessageStub
+	fakeReturns := fake.writeMessageReturns
+	fake.recordInvocation("WriteMessage", []interface{}{arg1})
+	fake.writeMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMessageSink) WriteMessageCallCount() int {
+	fake.writeMessageMutex.RLock()
+	defer fake.writeMessageMutex.RUnlock()
+	return len(fake.writeMessageArgsForCall)
+}
+
+func (fake *FakeMessageSink) WriteMessageCalls(stub func(proto.Message) error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = stub
+}
+
+func (fake *FakeMessageSink) WriteMessageArgsForCall(i int) proto.Message {
+	fake.writeMessageMutex.RLock()
+	defer fake.writeMessageMutex.RUnlock()
+	argsForCall := fake.writeMessageArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeMessageSink) WriteMessageReturns(result1 error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = nil
+	fake.writeMessageReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeMessageSink) WriteMessageReturnsOnCall(i int, result1 error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = nil
+	if fake.writeMessageReturnsOnCall == nil {
+		fake.writeMessageReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writeMessageReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeMessageSink) 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 *FakeMessageSink) 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 _ routing.MessageSink = new(FakeMessageSink)

pkg/routing/routingfakes/fake_message_source.go

@@ -0,0 +1,256 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package routingfakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/routing"
+	"github.com/livekit/protocol/livekit"
+	"google.golang.org/protobuf/proto"
+)
+
+type FakeMessageSource struct {
+	CloseStub        func()
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	ConnectionIDStub        func() livekit.ConnectionID
+	connectionIDMutex       sync.RWMutex
+	connectionIDArgsForCall []struct {
+	}
+	connectionIDReturns struct {
+		result1 livekit.ConnectionID
+	}
+	connectionIDReturnsOnCall map[int]struct {
+		result1 livekit.ConnectionID
+	}
+	IsClosedStub        func() bool
+	isClosedMutex       sync.RWMutex
+	isClosedArgsForCall []struct {
+	}
+	isClosedReturns struct {
+		result1 bool
+	}
+	isClosedReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	ReadChanStub        func() <-chan proto.Message
+	readChanMutex       sync.RWMutex
+	readChanArgsForCall []struct {
+	}
+	readChanReturns struct {
+		result1 <-chan proto.Message
+	}
+	readChanReturnsOnCall map[int]struct {
+		result1 <-chan proto.Message
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeMessageSource) Close() {
+	fake.closeMutex.Lock()
+	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
+	}{})
+	stub := fake.CloseStub
+	fake.recordInvocation("Close", []interface{}{})
+	fake.closeMutex.Unlock()
+	if stub != nil {
+		fake.CloseStub()
+	}
+}
+
+func (fake *FakeMessageSource) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeMessageSource) CloseCalls(stub func()) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeMessageSource) ConnectionID() livekit.ConnectionID {
+	fake.connectionIDMutex.Lock()
+	ret, specificReturn := fake.connectionIDReturnsOnCall[len(fake.connectionIDArgsForCall)]
+	fake.connectionIDArgsForCall = append(fake.connectionIDArgsForCall, struct {
+	}{})
+	stub := fake.ConnectionIDStub
+	fakeReturns := fake.connectionIDReturns
+	fake.recordInvocation("ConnectionID", []interface{}{})
+	fake.connectionIDMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMessageSource) ConnectionIDCallCount() int {
+	fake.connectionIDMutex.RLock()
+	defer fake.connectionIDMutex.RUnlock()
+	return len(fake.connectionIDArgsForCall)
+}
+
+func (fake *FakeMessageSource) ConnectionIDCalls(stub func() livekit.ConnectionID) {
+	fake.connectionIDMutex.Lock()
+	defer fake.connectionIDMutex.Unlock()
+	fake.ConnectionIDStub = stub
+}
+
+func (fake *FakeMessageSource) ConnectionIDReturns(result1 livekit.ConnectionID) {
+	fake.connectionIDMutex.Lock()
+	defer fake.connectionIDMutex.Unlock()
+	fake.ConnectionIDStub = nil
+	fake.connectionIDReturns = struct {
+		result1 livekit.ConnectionID
+	}{result1}
+}
+
+func (fake *FakeMessageSource) ConnectionIDReturnsOnCall(i int, result1 livekit.ConnectionID) {
+	fake.connectionIDMutex.Lock()
+	defer fake.connectionIDMutex.Unlock()
+	fake.ConnectionIDStub = nil
+	if fake.connectionIDReturnsOnCall == nil {
+		fake.connectionIDReturnsOnCall = make(map[int]struct {
+			result1 livekit.ConnectionID
+		})
+	}
+	fake.connectionIDReturnsOnCall[i] = struct {
+		result1 livekit.ConnectionID
+	}{result1}
+}
+
+func (fake *FakeMessageSource) IsClosed() bool {
+	fake.isClosedMutex.Lock()
+	ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)]
+	fake.isClosedArgsForCall = append(fake.isClosedArgsForCall, struct {
+	}{})
+	stub := fake.IsClosedStub
+	fakeReturns := fake.isClosedReturns
+	fake.recordInvocation("IsClosed", []interface{}{})
+	fake.isClosedMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMessageSource) IsClosedCallCount() int {
+	fake.isClosedMutex.RLock()
+	defer fake.isClosedMutex.RUnlock()
+	return len(fake.isClosedArgsForCall)
+}
+
+func (fake *FakeMessageSource) IsClosedCalls(stub func() bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = stub
+}
+
+func (fake *FakeMessageSource) IsClosedReturns(result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	fake.isClosedReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeMessageSource) IsClosedReturnsOnCall(i int, result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	if fake.isClosedReturnsOnCall == nil {
+		fake.isClosedReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isClosedReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeMessageSource) ReadChan() <-chan proto.Message {
+	fake.readChanMutex.Lock()
+	ret, specificReturn := fake.readChanReturnsOnCall[len(fake.readChanArgsForCall)]
+	fake.readChanArgsForCall = append(fake.readChanArgsForCall, struct {
+	}{})
+	stub := fake.ReadChanStub
+	fakeReturns := fake.readChanReturns
+	fake.recordInvocation("ReadChan", []interface{}{})
+	fake.readChanMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMessageSource) ReadChanCallCount() int {
+	fake.readChanMutex.RLock()
+	defer fake.readChanMutex.RUnlock()
+	return len(fake.readChanArgsForCall)
+}
+
+func (fake *FakeMessageSource) ReadChanCalls(stub func() <-chan proto.Message) {
+	fake.readChanMutex.Lock()
+	defer fake.readChanMutex.Unlock()
+	fake.ReadChanStub = stub
+}
+
+func (fake *FakeMessageSource) ReadChanReturns(result1 <-chan proto.Message) {
+	fake.readChanMutex.Lock()
+	defer fake.readChanMutex.Unlock()
+	fake.ReadChanStub = nil
+	fake.readChanReturns = struct {
+		result1 <-chan proto.Message
+	}{result1}
+}
+
+func (fake *FakeMessageSource) ReadChanReturnsOnCall(i int, result1 <-chan proto.Message) {
+	fake.readChanMutex.Lock()
+	defer fake.readChanMutex.Unlock()
+	fake.ReadChanStub = nil
+	if fake.readChanReturnsOnCall == nil {
+		fake.readChanReturnsOnCall = make(map[int]struct {
+			result1 <-chan proto.Message
+		})
+	}
+	fake.readChanReturnsOnCall[i] = struct {
+		result1 <-chan proto.Message
+	}{result1}
+}
+
+func (fake *FakeMessageSource) 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 *FakeMessageSource) 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 _ routing.MessageSource = new(FakeMessageSource)

pkg/routing/routingfakes/fake_room_manager_client.go

@@ -0,0 +1,151 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package routingfakes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/routing"
+	"github.com/livekit/protocol/livekit"
+	"github.com/livekit/psrpc"
+)
+
+type FakeRoomManagerClient struct {
+	CloseStub        func()
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	CreateRoomStub        func(context.Context, livekit.NodeID, *livekit.CreateRoomRequest, ...psrpc.RequestOption) (*livekit.Room, error)
+	createRoomMutex       sync.RWMutex
+	createRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.NodeID
+		arg3 *livekit.CreateRoomRequest
+		arg4 []psrpc.RequestOption
+	}
+	createRoomReturns struct {
+		result1 *livekit.Room
+		result2 error
+	}
+	createRoomReturnsOnCall map[int]struct {
+		result1 *livekit.Room
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeRoomManagerClient) Close() {
+	fake.closeMutex.Lock()
+	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
+	}{})
+	stub := fake.CloseStub
+	fake.recordInvocation("Close", []interface{}{})
+	fake.closeMutex.Unlock()
+	if stub != nil {
+		fake.CloseStub()
+	}
+}
+
+func (fake *FakeRoomManagerClient) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeRoomManagerClient) CloseCalls(stub func()) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeRoomManagerClient) CreateRoom(arg1 context.Context, arg2 livekit.NodeID, arg3 *livekit.CreateRoomRequest, arg4 ...psrpc.RequestOption) (*livekit.Room, error) {
+	fake.createRoomMutex.Lock()
+	ret, specificReturn := fake.createRoomReturnsOnCall[len(fake.createRoomArgsForCall)]
+	fake.createRoomArgsForCall = append(fake.createRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.NodeID
+		arg3 *livekit.CreateRoomRequest
+		arg4 []psrpc.RequestOption
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.CreateRoomStub
+	fakeReturns := fake.createRoomReturns
+	fake.recordInvocation("CreateRoom", []interface{}{arg1, arg2, arg3, arg4})
+	fake.createRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3, arg4...)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeRoomManagerClient) CreateRoomCallCount() int {
+	fake.createRoomMutex.RLock()
+	defer fake.createRoomMutex.RUnlock()
+	return len(fake.createRoomArgsForCall)
+}
+
+func (fake *FakeRoomManagerClient) CreateRoomCalls(stub func(context.Context, livekit.NodeID, *livekit.CreateRoomRequest, ...psrpc.RequestOption) (*livekit.Room, error)) {
+	fake.createRoomMutex.Lock()
+	defer fake.createRoomMutex.Unlock()
+	fake.CreateRoomStub = stub
+}
+
+func (fake *FakeRoomManagerClient) CreateRoomArgsForCall(i int) (context.Context, livekit.NodeID, *livekit.CreateRoomRequest, []psrpc.RequestOption) {
+	fake.createRoomMutex.RLock()
+	defer fake.createRoomMutex.RUnlock()
+	argsForCall := fake.createRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeRoomManagerClient) CreateRoomReturns(result1 *livekit.Room, result2 error) {
+	fake.createRoomMutex.Lock()
+	defer fake.createRoomMutex.Unlock()
+	fake.CreateRoomStub = nil
+	fake.createRoomReturns = struct {
+		result1 *livekit.Room
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRoomManagerClient) CreateRoomReturnsOnCall(i int, result1 *livekit.Room, result2 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 error
+		})
+	}
+	fake.createRoomReturnsOnCall[i] = struct {
+		result1 *livekit.Room
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRoomManagerClient) 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 *FakeRoomManagerClient) 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 _ routing.RoomManagerClient = new(FakeRoomManagerClient)

pkg/routing/routingfakes/fake_router.go

@@ -0,0 +1,867 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package routingfakes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/routing"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeRouter struct {
+	ClearRoomStateStub        func(context.Context, livekit.RoomName) error
+	clearRoomStateMutex       sync.RWMutex
+	clearRoomStateArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	clearRoomStateReturns struct {
+		result1 error
+	}
+	clearRoomStateReturnsOnCall map[int]struct {
+		result1 error
+	}
+	CreateRoomStub        func(context.Context, *livekit.CreateRoomRequest) (*livekit.Room, error)
+	createRoomMutex       sync.RWMutex
+	createRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.CreateRoomRequest
+	}
+	createRoomReturns struct {
+		result1 *livekit.Room
+		result2 error
+	}
+	createRoomReturnsOnCall map[int]struct {
+		result1 *livekit.Room
+		result2 error
+	}
+	DrainStub        func()
+	drainMutex       sync.RWMutex
+	drainArgsForCall []struct {
+	}
+	GetNodeForRoomStub        func(context.Context, livekit.RoomName) (*livekit.Node, error)
+	getNodeForRoomMutex       sync.RWMutex
+	getNodeForRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	getNodeForRoomReturns struct {
+		result1 *livekit.Node
+		result2 error
+	}
+	getNodeForRoomReturnsOnCall map[int]struct {
+		result1 *livekit.Node
+		result2 error
+	}
+	GetRegionStub        func() string
+	getRegionMutex       sync.RWMutex
+	getRegionArgsForCall []struct {
+	}
+	getRegionReturns struct {
+		result1 string
+	}
+	getRegionReturnsOnCall map[int]struct {
+		result1 string
+	}
+	ListNodesStub        func() ([]*livekit.Node, error)
+	listNodesMutex       sync.RWMutex
+	listNodesArgsForCall []struct {
+	}
+	listNodesReturns struct {
+		result1 []*livekit.Node
+		result2 error
+	}
+	listNodesReturnsOnCall map[int]struct {
+		result1 []*livekit.Node
+		result2 error
+	}
+	RegisterNodeStub        func() error
+	registerNodeMutex       sync.RWMutex
+	registerNodeArgsForCall []struct {
+	}
+	registerNodeReturns struct {
+		result1 error
+	}
+	registerNodeReturnsOnCall map[int]struct {
+		result1 error
+	}
+	RemoveDeadNodesStub        func() error
+	removeDeadNodesMutex       sync.RWMutex
+	removeDeadNodesArgsForCall []struct {
+	}
+	removeDeadNodesReturns struct {
+		result1 error
+	}
+	removeDeadNodesReturnsOnCall map[int]struct {
+		result1 error
+	}
+	SetNodeForRoomStub        func(context.Context, livekit.RoomName, livekit.NodeID) error
+	setNodeForRoomMutex       sync.RWMutex
+	setNodeForRoomArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.NodeID
+	}
+	setNodeForRoomReturns struct {
+		result1 error
+	}
+	setNodeForRoomReturnsOnCall map[int]struct {
+		result1 error
+	}
+	StartStub        func() error
+	startMutex       sync.RWMutex
+	startArgsForCall []struct {
+	}
+	startReturns struct {
+		result1 error
+	}
+	startReturnsOnCall map[int]struct {
+		result1 error
+	}
+	StartParticipantSignalStub        func(context.Context, livekit.RoomName, routing.ParticipantInit) (routing.StartParticipantSignalResults, error)
+	startParticipantSignalMutex       sync.RWMutex
+	startParticipantSignalArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 routing.ParticipantInit
+	}
+	startParticipantSignalReturns struct {
+		result1 routing.StartParticipantSignalResults
+		result2 error
+	}
+	startParticipantSignalReturnsOnCall map[int]struct {
+		result1 routing.StartParticipantSignalResults
+		result2 error
+	}
+	StopStub        func()
+	stopMutex       sync.RWMutex
+	stopArgsForCall []struct {
+	}
+	UnregisterNodeStub        func() error
+	unregisterNodeMutex       sync.RWMutex
+	unregisterNodeArgsForCall []struct {
+	}
+	unregisterNodeReturns struct {
+		result1 error
+	}
+	unregisterNodeReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeRouter) ClearRoomState(arg1 context.Context, arg2 livekit.RoomName) error {
+	fake.clearRoomStateMutex.Lock()
+	ret, specificReturn := fake.clearRoomStateReturnsOnCall[len(fake.clearRoomStateArgsForCall)]
+	fake.clearRoomStateArgsForCall = append(fake.clearRoomStateArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.ClearRoomStateStub
+	fakeReturns := fake.clearRoomStateReturns
+	fake.recordInvocation("ClearRoomState", []interface{}{arg1, arg2})
+	fake.clearRoomStateMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRouter) ClearRoomStateCallCount() int {
+	fake.clearRoomStateMutex.RLock()
+	defer fake.clearRoomStateMutex.RUnlock()
+	return len(fake.clearRoomStateArgsForCall)
+}
+
+func (fake *FakeRouter) ClearRoomStateCalls(stub func(context.Context, livekit.RoomName) error) {
+	fake.clearRoomStateMutex.Lock()
+	defer fake.clearRoomStateMutex.Unlock()
+	fake.ClearRoomStateStub = stub
+}
+
+func (fake *FakeRouter) ClearRoomStateArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.clearRoomStateMutex.RLock()
+	defer fake.clearRoomStateMutex.RUnlock()
+	argsForCall := fake.clearRoomStateArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeRouter) ClearRoomStateReturns(result1 error) {
+	fake.clearRoomStateMutex.Lock()
+	defer fake.clearRoomStateMutex.Unlock()
+	fake.ClearRoomStateStub = nil
+	fake.clearRoomStateReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) ClearRoomStateReturnsOnCall(i int, result1 error) {
+	fake.clearRoomStateMutex.Lock()
+	defer fake.clearRoomStateMutex.Unlock()
+	fake.ClearRoomStateStub = nil
+	if fake.clearRoomStateReturnsOnCall == nil {
+		fake.clearRoomStateReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.clearRoomStateReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) CreateRoom(arg1 context.Context, arg2 *livekit.CreateRoomRequest) (*livekit.Room, error) {
+	fake.createRoomMutex.Lock()
+	ret, specificReturn := fake.createRoomReturnsOnCall[len(fake.createRoomArgsForCall)]
+	fake.createRoomArgsForCall = append(fake.createRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.CreateRoomRequest
+	}{arg1, arg2})
+	stub := fake.CreateRoomStub
+	fakeReturns := fake.createRoomReturns
+	fake.recordInvocation("CreateRoom", []interface{}{arg1, arg2})
+	fake.createRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeRouter) CreateRoomCallCount() int {
+	fake.createRoomMutex.RLock()
+	defer fake.createRoomMutex.RUnlock()
+	return len(fake.createRoomArgsForCall)
+}
+
+func (fake *FakeRouter) CreateRoomCalls(stub func(context.Context, *livekit.CreateRoomRequest) (*livekit.Room, error)) {
+	fake.createRoomMutex.Lock()
+	defer fake.createRoomMutex.Unlock()
+	fake.CreateRoomStub = stub
+}
+
+func (fake *FakeRouter) CreateRoomArgsForCall(i int) (context.Context, *livekit.CreateRoomRequest) {
+	fake.createRoomMutex.RLock()
+	defer fake.createRoomMutex.RUnlock()
+	argsForCall := fake.createRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeRouter) CreateRoomReturns(result1 *livekit.Room, result2 error) {
+	fake.createRoomMutex.Lock()
+	defer fake.createRoomMutex.Unlock()
+	fake.CreateRoomStub = nil
+	fake.createRoomReturns = struct {
+		result1 *livekit.Room
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) CreateRoomReturnsOnCall(i int, result1 *livekit.Room, result2 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 error
+		})
+	}
+	fake.createRoomReturnsOnCall[i] = struct {
+		result1 *livekit.Room
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) Drain() {
+	fake.drainMutex.Lock()
+	fake.drainArgsForCall = append(fake.drainArgsForCall, struct {
+	}{})
+	stub := fake.DrainStub
+	fake.recordInvocation("Drain", []interface{}{})
+	fake.drainMutex.Unlock()
+	if stub != nil {
+		fake.DrainStub()
+	}
+}
+
+func (fake *FakeRouter) DrainCallCount() int {
+	fake.drainMutex.RLock()
+	defer fake.drainMutex.RUnlock()
+	return len(fake.drainArgsForCall)
+}
+
+func (fake *FakeRouter) DrainCalls(stub func()) {
+	fake.drainMutex.Lock()
+	defer fake.drainMutex.Unlock()
+	fake.DrainStub = stub
+}
+
+func (fake *FakeRouter) GetNodeForRoom(arg1 context.Context, arg2 livekit.RoomName) (*livekit.Node, error) {
+	fake.getNodeForRoomMutex.Lock()
+	ret, specificReturn := fake.getNodeForRoomReturnsOnCall[len(fake.getNodeForRoomArgsForCall)]
+	fake.getNodeForRoomArgsForCall = append(fake.getNodeForRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.GetNodeForRoomStub
+	fakeReturns := fake.getNodeForRoomReturns
+	fake.recordInvocation("GetNodeForRoom", []interface{}{arg1, arg2})
+	fake.getNodeForRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeRouter) GetNodeForRoomCallCount() int {
+	fake.getNodeForRoomMutex.RLock()
+	defer fake.getNodeForRoomMutex.RUnlock()
+	return len(fake.getNodeForRoomArgsForCall)
+}
+
+func (fake *FakeRouter) GetNodeForRoomCalls(stub func(context.Context, livekit.RoomName) (*livekit.Node, error)) {
+	fake.getNodeForRoomMutex.Lock()
+	defer fake.getNodeForRoomMutex.Unlock()
+	fake.GetNodeForRoomStub = stub
+}
+
+func (fake *FakeRouter) GetNodeForRoomArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.getNodeForRoomMutex.RLock()
+	defer fake.getNodeForRoomMutex.RUnlock()
+	argsForCall := fake.getNodeForRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeRouter) GetNodeForRoomReturns(result1 *livekit.Node, result2 error) {
+	fake.getNodeForRoomMutex.Lock()
+	defer fake.getNodeForRoomMutex.Unlock()
+	fake.GetNodeForRoomStub = nil
+	fake.getNodeForRoomReturns = struct {
+		result1 *livekit.Node
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) GetNodeForRoomReturnsOnCall(i int, result1 *livekit.Node, result2 error) {
+	fake.getNodeForRoomMutex.Lock()
+	defer fake.getNodeForRoomMutex.Unlock()
+	fake.GetNodeForRoomStub = nil
+	if fake.getNodeForRoomReturnsOnCall == nil {
+		fake.getNodeForRoomReturnsOnCall = make(map[int]struct {
+			result1 *livekit.Node
+			result2 error
+		})
+	}
+	fake.getNodeForRoomReturnsOnCall[i] = struct {
+		result1 *livekit.Node
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) GetRegion() string {
+	fake.getRegionMutex.Lock()
+	ret, specificReturn := fake.getRegionReturnsOnCall[len(fake.getRegionArgsForCall)]
+	fake.getRegionArgsForCall = append(fake.getRegionArgsForCall, struct {
+	}{})
+	stub := fake.GetRegionStub
+	fakeReturns := fake.getRegionReturns
+	fake.recordInvocation("GetRegion", []interface{}{})
+	fake.getRegionMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRouter) GetRegionCallCount() int {
+	fake.getRegionMutex.RLock()
+	defer fake.getRegionMutex.RUnlock()
+	return len(fake.getRegionArgsForCall)
+}
+
+func (fake *FakeRouter) GetRegionCalls(stub func() string) {
+	fake.getRegionMutex.Lock()
+	defer fake.getRegionMutex.Unlock()
+	fake.GetRegionStub = stub
+}
+
+func (fake *FakeRouter) GetRegionReturns(result1 string) {
+	fake.getRegionMutex.Lock()
+	defer fake.getRegionMutex.Unlock()
+	fake.GetRegionStub = nil
+	fake.getRegionReturns = struct {
+		result1 string
+	}{result1}
+}
+
+func (fake *FakeRouter) GetRegionReturnsOnCall(i int, result1 string) {
+	fake.getRegionMutex.Lock()
+	defer fake.getRegionMutex.Unlock()
+	fake.GetRegionStub = nil
+	if fake.getRegionReturnsOnCall == nil {
+		fake.getRegionReturnsOnCall = make(map[int]struct {
+			result1 string
+		})
+	}
+	fake.getRegionReturnsOnCall[i] = struct {
+		result1 string
+	}{result1}
+}
+
+func (fake *FakeRouter) ListNodes() ([]*livekit.Node, error) {
+	fake.listNodesMutex.Lock()
+	ret, specificReturn := fake.listNodesReturnsOnCall[len(fake.listNodesArgsForCall)]
+	fake.listNodesArgsForCall = append(fake.listNodesArgsForCall, struct {
+	}{})
+	stub := fake.ListNodesStub
+	fakeReturns := fake.listNodesReturns
+	fake.recordInvocation("ListNodes", []interface{}{})
+	fake.listNodesMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeRouter) ListNodesCallCount() int {
+	fake.listNodesMutex.RLock()
+	defer fake.listNodesMutex.RUnlock()
+	return len(fake.listNodesArgsForCall)
+}
+
+func (fake *FakeRouter) ListNodesCalls(stub func() ([]*livekit.Node, error)) {
+	fake.listNodesMutex.Lock()
+	defer fake.listNodesMutex.Unlock()
+	fake.ListNodesStub = stub
+}
+
+func (fake *FakeRouter) ListNodesReturns(result1 []*livekit.Node, result2 error) {
+	fake.listNodesMutex.Lock()
+	defer fake.listNodesMutex.Unlock()
+	fake.ListNodesStub = nil
+	fake.listNodesReturns = struct {
+		result1 []*livekit.Node
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) ListNodesReturnsOnCall(i int, result1 []*livekit.Node, result2 error) {
+	fake.listNodesMutex.Lock()
+	defer fake.listNodesMutex.Unlock()
+	fake.ListNodesStub = nil
+	if fake.listNodesReturnsOnCall == nil {
+		fake.listNodesReturnsOnCall = make(map[int]struct {
+			result1 []*livekit.Node
+			result2 error
+		})
+	}
+	fake.listNodesReturnsOnCall[i] = struct {
+		result1 []*livekit.Node
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) RegisterNode() error {
+	fake.registerNodeMutex.Lock()
+	ret, specificReturn := fake.registerNodeReturnsOnCall[len(fake.registerNodeArgsForCall)]
+	fake.registerNodeArgsForCall = append(fake.registerNodeArgsForCall, struct {
+	}{})
+	stub := fake.RegisterNodeStub
+	fakeReturns := fake.registerNodeReturns
+	fake.recordInvocation("RegisterNode", []interface{}{})
+	fake.registerNodeMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRouter) RegisterNodeCallCount() int {
+	fake.registerNodeMutex.RLock()
+	defer fake.registerNodeMutex.RUnlock()
+	return len(fake.registerNodeArgsForCall)
+}
+
+func (fake *FakeRouter) RegisterNodeCalls(stub func() error) {
+	fake.registerNodeMutex.Lock()
+	defer fake.registerNodeMutex.Unlock()
+	fake.RegisterNodeStub = stub
+}
+
+func (fake *FakeRouter) RegisterNodeReturns(result1 error) {
+	fake.registerNodeMutex.Lock()
+	defer fake.registerNodeMutex.Unlock()
+	fake.RegisterNodeStub = nil
+	fake.registerNodeReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) RegisterNodeReturnsOnCall(i int, result1 error) {
+	fake.registerNodeMutex.Lock()
+	defer fake.registerNodeMutex.Unlock()
+	fake.RegisterNodeStub = nil
+	if fake.registerNodeReturnsOnCall == nil {
+		fake.registerNodeReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.registerNodeReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) RemoveDeadNodes() error {
+	fake.removeDeadNodesMutex.Lock()
+	ret, specificReturn := fake.removeDeadNodesReturnsOnCall[len(fake.removeDeadNodesArgsForCall)]
+	fake.removeDeadNodesArgsForCall = append(fake.removeDeadNodesArgsForCall, struct {
+	}{})
+	stub := fake.RemoveDeadNodesStub
+	fakeReturns := fake.removeDeadNodesReturns
+	fake.recordInvocation("RemoveDeadNodes", []interface{}{})
+	fake.removeDeadNodesMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRouter) RemoveDeadNodesCallCount() int {
+	fake.removeDeadNodesMutex.RLock()
+	defer fake.removeDeadNodesMutex.RUnlock()
+	return len(fake.removeDeadNodesArgsForCall)
+}
+
+func (fake *FakeRouter) RemoveDeadNodesCalls(stub func() error) {
+	fake.removeDeadNodesMutex.Lock()
+	defer fake.removeDeadNodesMutex.Unlock()
+	fake.RemoveDeadNodesStub = stub
+}
+
+func (fake *FakeRouter) RemoveDeadNodesReturns(result1 error) {
+	fake.removeDeadNodesMutex.Lock()
+	defer fake.removeDeadNodesMutex.Unlock()
+	fake.RemoveDeadNodesStub = nil
+	fake.removeDeadNodesReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) RemoveDeadNodesReturnsOnCall(i int, result1 error) {
+	fake.removeDeadNodesMutex.Lock()
+	defer fake.removeDeadNodesMutex.Unlock()
+	fake.RemoveDeadNodesStub = nil
+	if fake.removeDeadNodesReturnsOnCall == nil {
+		fake.removeDeadNodesReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.removeDeadNodesReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) SetNodeForRoom(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.NodeID) error {
+	fake.setNodeForRoomMutex.Lock()
+	ret, specificReturn := fake.setNodeForRoomReturnsOnCall[len(fake.setNodeForRoomArgsForCall)]
+	fake.setNodeForRoomArgsForCall = append(fake.setNodeForRoomArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 livekit.NodeID
+	}{arg1, arg2, arg3})
+	stub := fake.SetNodeForRoomStub
+	fakeReturns := fake.setNodeForRoomReturns
+	fake.recordInvocation("SetNodeForRoom", []interface{}{arg1, arg2, arg3})
+	fake.setNodeForRoomMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRouter) SetNodeForRoomCallCount() int {
+	fake.setNodeForRoomMutex.RLock()
+	defer fake.setNodeForRoomMutex.RUnlock()
+	return len(fake.setNodeForRoomArgsForCall)
+}
+
+func (fake *FakeRouter) SetNodeForRoomCalls(stub func(context.Context, livekit.RoomName, livekit.NodeID) error) {
+	fake.setNodeForRoomMutex.Lock()
+	defer fake.setNodeForRoomMutex.Unlock()
+	fake.SetNodeForRoomStub = stub
+}
+
+func (fake *FakeRouter) SetNodeForRoomArgsForCall(i int) (context.Context, livekit.RoomName, livekit.NodeID) {
+	fake.setNodeForRoomMutex.RLock()
+	defer fake.setNodeForRoomMutex.RUnlock()
+	argsForCall := fake.setNodeForRoomArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeRouter) SetNodeForRoomReturns(result1 error) {
+	fake.setNodeForRoomMutex.Lock()
+	defer fake.setNodeForRoomMutex.Unlock()
+	fake.SetNodeForRoomStub = nil
+	fake.setNodeForRoomReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) SetNodeForRoomReturnsOnCall(i int, result1 error) {
+	fake.setNodeForRoomMutex.Lock()
+	defer fake.setNodeForRoomMutex.Unlock()
+	fake.SetNodeForRoomStub = nil
+	if fake.setNodeForRoomReturnsOnCall == nil {
+		fake.setNodeForRoomReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.setNodeForRoomReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) Start() error {
+	fake.startMutex.Lock()
+	ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)]
+	fake.startArgsForCall = append(fake.startArgsForCall, struct {
+	}{})
+	stub := fake.StartStub
+	fakeReturns := fake.startReturns
+	fake.recordInvocation("Start", []interface{}{})
+	fake.startMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRouter) StartCallCount() int {
+	fake.startMutex.RLock()
+	defer fake.startMutex.RUnlock()
+	return len(fake.startArgsForCall)
+}
+
+func (fake *FakeRouter) StartCalls(stub func() error) {
+	fake.startMutex.Lock()
+	defer fake.startMutex.Unlock()
+	fake.StartStub = stub
+}
+
+func (fake *FakeRouter) StartReturns(result1 error) {
+	fake.startMutex.Lock()
+	defer fake.startMutex.Unlock()
+	fake.StartStub = nil
+	fake.startReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) StartReturnsOnCall(i int, result1 error) {
+	fake.startMutex.Lock()
+	defer fake.startMutex.Unlock()
+	fake.StartStub = nil
+	if fake.startReturnsOnCall == nil {
+		fake.startReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.startReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) StartParticipantSignal(arg1 context.Context, arg2 livekit.RoomName, arg3 routing.ParticipantInit) (routing.StartParticipantSignalResults, error) {
+	fake.startParticipantSignalMutex.Lock()
+	ret, specificReturn := fake.startParticipantSignalReturnsOnCall[len(fake.startParticipantSignalArgsForCall)]
+	fake.startParticipantSignalArgsForCall = append(fake.startParticipantSignalArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 routing.ParticipantInit
+	}{arg1, arg2, arg3})
+	stub := fake.StartParticipantSignalStub
+	fakeReturns := fake.startParticipantSignalReturns
+	fake.recordInvocation("StartParticipantSignal", []interface{}{arg1, arg2, arg3})
+	fake.startParticipantSignalMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeRouter) StartParticipantSignalCallCount() int {
+	fake.startParticipantSignalMutex.RLock()
+	defer fake.startParticipantSignalMutex.RUnlock()
+	return len(fake.startParticipantSignalArgsForCall)
+}
+
+func (fake *FakeRouter) StartParticipantSignalCalls(stub func(context.Context, livekit.RoomName, routing.ParticipantInit) (routing.StartParticipantSignalResults, error)) {
+	fake.startParticipantSignalMutex.Lock()
+	defer fake.startParticipantSignalMutex.Unlock()
+	fake.StartParticipantSignalStub = stub
+}
+
+func (fake *FakeRouter) StartParticipantSignalArgsForCall(i int) (context.Context, livekit.RoomName, routing.ParticipantInit) {
+	fake.startParticipantSignalMutex.RLock()
+	defer fake.startParticipantSignalMutex.RUnlock()
+	argsForCall := fake.startParticipantSignalArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeRouter) StartParticipantSignalReturns(result1 routing.StartParticipantSignalResults, result2 error) {
+	fake.startParticipantSignalMutex.Lock()
+	defer fake.startParticipantSignalMutex.Unlock()
+	fake.StartParticipantSignalStub = nil
+	fake.startParticipantSignalReturns = struct {
+		result1 routing.StartParticipantSignalResults
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) StartParticipantSignalReturnsOnCall(i int, result1 routing.StartParticipantSignalResults, result2 error) {
+	fake.startParticipantSignalMutex.Lock()
+	defer fake.startParticipantSignalMutex.Unlock()
+	fake.StartParticipantSignalStub = nil
+	if fake.startParticipantSignalReturnsOnCall == nil {
+		fake.startParticipantSignalReturnsOnCall = make(map[int]struct {
+			result1 routing.StartParticipantSignalResults
+			result2 error
+		})
+	}
+	fake.startParticipantSignalReturnsOnCall[i] = struct {
+		result1 routing.StartParticipantSignalResults
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeRouter) Stop() {
+	fake.stopMutex.Lock()
+	fake.stopArgsForCall = append(fake.stopArgsForCall, struct {
+	}{})
+	stub := fake.StopStub
+	fake.recordInvocation("Stop", []interface{}{})
+	fake.stopMutex.Unlock()
+	if stub != nil {
+		fake.StopStub()
+	}
+}
+
+func (fake *FakeRouter) StopCallCount() int {
+	fake.stopMutex.RLock()
+	defer fake.stopMutex.RUnlock()
+	return len(fake.stopArgsForCall)
+}
+
+func (fake *FakeRouter) StopCalls(stub func()) {
+	fake.stopMutex.Lock()
+	defer fake.stopMutex.Unlock()
+	fake.StopStub = stub
+}
+
+func (fake *FakeRouter) UnregisterNode() error {
+	fake.unregisterNodeMutex.Lock()
+	ret, specificReturn := fake.unregisterNodeReturnsOnCall[len(fake.unregisterNodeArgsForCall)]
+	fake.unregisterNodeArgsForCall = append(fake.unregisterNodeArgsForCall, struct {
+	}{})
+	stub := fake.UnregisterNodeStub
+	fakeReturns := fake.unregisterNodeReturns
+	fake.recordInvocation("UnregisterNode", []interface{}{})
+	fake.unregisterNodeMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeRouter) UnregisterNodeCallCount() int {
+	fake.unregisterNodeMutex.RLock()
+	defer fake.unregisterNodeMutex.RUnlock()
+	return len(fake.unregisterNodeArgsForCall)
+}
+
+func (fake *FakeRouter) UnregisterNodeCalls(stub func() error) {
+	fake.unregisterNodeMutex.Lock()
+	defer fake.unregisterNodeMutex.Unlock()
+	fake.UnregisterNodeStub = stub
+}
+
+func (fake *FakeRouter) UnregisterNodeReturns(result1 error) {
+	fake.unregisterNodeMutex.Lock()
+	defer fake.unregisterNodeMutex.Unlock()
+	fake.UnregisterNodeStub = nil
+	fake.unregisterNodeReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) UnregisterNodeReturnsOnCall(i int, result1 error) {
+	fake.unregisterNodeMutex.Lock()
+	defer fake.unregisterNodeMutex.Unlock()
+	fake.UnregisterNodeStub = nil
+	if fake.unregisterNodeReturnsOnCall == nil {
+		fake.unregisterNodeReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.unregisterNodeReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeRouter) 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 *FakeRouter) 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 _ routing.Router = new(FakeRouter)

pkg/routing/routingfakes/fake_signal_client.go

@@ -0,0 +1,195 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package routingfakes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/routing"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeSignalClient struct {
+	ActiveCountStub        func() int
+	activeCountMutex       sync.RWMutex
+	activeCountArgsForCall []struct {
+	}
+	activeCountReturns struct {
+		result1 int
+	}
+	activeCountReturnsOnCall map[int]struct {
+		result1 int
+	}
+	StartParticipantSignalStub        func(context.Context, livekit.RoomName, routing.ParticipantInit, livekit.NodeID) (livekit.ConnectionID, routing.MessageSink, routing.MessageSource, error)
+	startParticipantSignalMutex       sync.RWMutex
+	startParticipantSignalArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 routing.ParticipantInit
+		arg4 livekit.NodeID
+	}
+	startParticipantSignalReturns struct {
+		result1 livekit.ConnectionID
+		result2 routing.MessageSink
+		result3 routing.MessageSource
+		result4 error
+	}
+	startParticipantSignalReturnsOnCall map[int]struct {
+		result1 livekit.ConnectionID
+		result2 routing.MessageSink
+		result3 routing.MessageSource
+		result4 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeSignalClient) ActiveCount() int {
+	fake.activeCountMutex.Lock()
+	ret, specificReturn := fake.activeCountReturnsOnCall[len(fake.activeCountArgsForCall)]
+	fake.activeCountArgsForCall = append(fake.activeCountArgsForCall, struct {
+	}{})
+	stub := fake.ActiveCountStub
+	fakeReturns := fake.activeCountReturns
+	fake.recordInvocation("ActiveCount", []interface{}{})
+	fake.activeCountMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeSignalClient) ActiveCountCallCount() int {
+	fake.activeCountMutex.RLock()
+	defer fake.activeCountMutex.RUnlock()
+	return len(fake.activeCountArgsForCall)
+}
+
+func (fake *FakeSignalClient) ActiveCountCalls(stub func() int) {
+	fake.activeCountMutex.Lock()
+	defer fake.activeCountMutex.Unlock()
+	fake.ActiveCountStub = stub
+}
+
+func (fake *FakeSignalClient) ActiveCountReturns(result1 int) {
+	fake.activeCountMutex.Lock()
+	defer fake.activeCountMutex.Unlock()
+	fake.ActiveCountStub = nil
+	fake.activeCountReturns = struct {
+		result1 int
+	}{result1}
+}
+
+func (fake *FakeSignalClient) ActiveCountReturnsOnCall(i int, result1 int) {
+	fake.activeCountMutex.Lock()
+	defer fake.activeCountMutex.Unlock()
+	fake.ActiveCountStub = nil
+	if fake.activeCountReturnsOnCall == nil {
+		fake.activeCountReturnsOnCall = make(map[int]struct {
+			result1 int
+		})
+	}
+	fake.activeCountReturnsOnCall[i] = struct {
+		result1 int
+	}{result1}
+}
+
+func (fake *FakeSignalClient) StartParticipantSignal(arg1 context.Context, arg2 livekit.RoomName, arg3 routing.ParticipantInit, arg4 livekit.NodeID) (livekit.ConnectionID, routing.MessageSink, routing.MessageSource, error) {
+	fake.startParticipantSignalMutex.Lock()
+	ret, specificReturn := fake.startParticipantSignalReturnsOnCall[len(fake.startParticipantSignalArgsForCall)]
+	fake.startParticipantSignalArgsForCall = append(fake.startParticipantSignalArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+		arg3 routing.ParticipantInit
+		arg4 livekit.NodeID
+	}{arg1, arg2, arg3, arg4})
+	stub := fake.StartParticipantSignalStub
+	fakeReturns := fake.startParticipantSignalReturns
+	fake.recordInvocation("StartParticipantSignal", []interface{}{arg1, arg2, arg3, arg4})
+	fake.startParticipantSignalMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3, arg4)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2, ret.result3, ret.result4
+	}
+	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
+}
+
+func (fake *FakeSignalClient) StartParticipantSignalCallCount() int {
+	fake.startParticipantSignalMutex.RLock()
+	defer fake.startParticipantSignalMutex.RUnlock()
+	return len(fake.startParticipantSignalArgsForCall)
+}
+
+func (fake *FakeSignalClient) StartParticipantSignalCalls(stub func(context.Context, livekit.RoomName, routing.ParticipantInit, livekit.NodeID) (livekit.ConnectionID, routing.MessageSink, routing.MessageSource, error)) {
+	fake.startParticipantSignalMutex.Lock()
+	defer fake.startParticipantSignalMutex.Unlock()
+	fake.StartParticipantSignalStub = stub
+}
+
+func (fake *FakeSignalClient) StartParticipantSignalArgsForCall(i int) (context.Context, livekit.RoomName, routing.ParticipantInit, livekit.NodeID) {
+	fake.startParticipantSignalMutex.RLock()
+	defer fake.startParticipantSignalMutex.RUnlock()
+	argsForCall := fake.startParticipantSignalArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+}
+
+func (fake *FakeSignalClient) StartParticipantSignalReturns(result1 livekit.ConnectionID, result2 routing.MessageSink, result3 routing.MessageSource, result4 error) {
+	fake.startParticipantSignalMutex.Lock()
+	defer fake.startParticipantSignalMutex.Unlock()
+	fake.StartParticipantSignalStub = nil
+	fake.startParticipantSignalReturns = struct {
+		result1 livekit.ConnectionID
+		result2 routing.MessageSink
+		result3 routing.MessageSource
+		result4 error
+	}{result1, result2, result3, result4}
+}
+
+func (fake *FakeSignalClient) StartParticipantSignalReturnsOnCall(i int, result1 livekit.ConnectionID, result2 routing.MessageSink, result3 routing.MessageSource, result4 error) {
+	fake.startParticipantSignalMutex.Lock()
+	defer fake.startParticipantSignalMutex.Unlock()
+	fake.StartParticipantSignalStub = nil
+	if fake.startParticipantSignalReturnsOnCall == nil {
+		fake.startParticipantSignalReturnsOnCall = make(map[int]struct {
+			result1 livekit.ConnectionID
+			result2 routing.MessageSink
+			result3 routing.MessageSource
+			result4 error
+		})
+	}
+	fake.startParticipantSignalReturnsOnCall[i] = struct {
+		result1 livekit.ConnectionID
+		result2 routing.MessageSink
+		result3 routing.MessageSource
+		result4 error
+	}{result1, result2, result3, result4}
+}
+
+func (fake *FakeSignalClient) 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 *FakeSignalClient) 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 _ routing.SignalClient = new(FakeSignalClient)